Rework graph flow unit tests
This commit adds unit tests that check graph flow methods without executing or flattening it. Now-redundant tests from other test suites are deleted. Change-Id: I8dafe0f9b295428831eddb3f9fd48f042d2f1ffc
This commit is contained in:
Ivan A. Melnikov
@@ -41,16 +41,6 @@ class Flow(flow.Flow):
|
||||
super(Flow, self).__init__(name, retry)
|
||||
self._graph = nx.freeze(nx.DiGraph())
|
||||
|
||||
def _validate(self, graph=None):
|
||||
if graph is None:
|
||||
graph = self._graph
|
||||
# Ensure that there is a valid topological ordering.
|
||||
if not nx.is_directed_acyclic_graph(graph):
|
||||
raise exc.DependencyFailure("No path through the items in the"
|
||||
" graph produces an ordering that"
|
||||
" will allow for correct dependency"
|
||||
" resolution")
|
||||
|
||||
def link(self, u, v):
|
||||
"""Link existing node u as a runtime dependency of existing node v."""
|
||||
if not self._graph.has_node(u):
|
||||
@@ -86,7 +76,11 @@ class Flow(flow.Flow):
|
||||
with a frozen version of the replacement graph (this maintains the
|
||||
invariant that the underlying graph is immutable).
|
||||
"""
|
||||
self._validate(replacement_graph)
|
||||
if not nx.is_directed_acyclic_graph(replacement_graph):
|
||||
raise exc.DependencyFailure("No path through the items in the"
|
||||
" graph produces an ordering that"
|
||||
" will allow for correct dependency"
|
||||
" resolution")
|
||||
self._graph = nx.freeze(replacement_graph)
|
||||
|
||||
def add(self, *items):
|
||||
|
||||
259
taskflow/tests/unit/patterns/test_graph_flow.py
Normal file
259
taskflow/tests/unit/patterns/test_graph_flow.py
Normal file
@@ -0,0 +1,259 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2014 Yahoo! Inc. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
from taskflow import exceptions as exc
|
||||
from taskflow.patterns import graph_flow as gf
|
||||
from taskflow import retry
|
||||
|
||||
from taskflow import test
|
||||
from taskflow.tests import utils
|
||||
|
||||
|
||||
def _task(name, provides=None, requires=None):
|
||||
return utils.ProvidesRequiresTask(name, provides, requires)
|
||||
|
||||
|
||||
class GraphFlowTest(test.TestCase):
|
||||
|
||||
def test_graph_flow_starts_as_empty(self):
|
||||
f = gf.Flow('test')
|
||||
|
||||
self.assertEqual(len(f), 0)
|
||||
self.assertEqual(list(f), [])
|
||||
self.assertEqual(list(f.iter_links()), [])
|
||||
|
||||
self.assertEqual(f.requires, set())
|
||||
self.assertEqual(f.provides, set())
|
||||
|
||||
expected = 'taskflow.patterns.graph_flow.Flow: test; 0'
|
||||
self.assertEqual(str(f), expected)
|
||||
|
||||
def test_graph_flow_add_nothing(self):
|
||||
f = gf.Flow('test')
|
||||
result = f.add()
|
||||
self.assertIs(f, result)
|
||||
self.assertEqual(len(f), 0)
|
||||
|
||||
def test_graph_flow_one_task(self):
|
||||
f = gf.Flow('test')
|
||||
task = _task(name='task1', requires=['a', 'b'], provides=['c', 'd'])
|
||||
result = f.add(task)
|
||||
|
||||
self.assertIs(f, result)
|
||||
|
||||
self.assertEqual(len(f), 1)
|
||||
self.assertEqual(list(f), [task])
|
||||
self.assertEqual(list(f.iter_links()), [])
|
||||
self.assertEqual(f.requires, set(['a', 'b']))
|
||||
self.assertEqual(f.provides, set(['c', 'd']))
|
||||
|
||||
def test_graph_flow_two_independent_tasks(self):
|
||||
task1 = _task(name='task1')
|
||||
task2 = _task(name='task2')
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
|
||||
self.assertEqual(len(f), 2)
|
||||
self.assertItemsEqual(f, [task1, task2])
|
||||
self.assertEqual(list(f.iter_links()), [])
|
||||
|
||||
def test_graph_flow_two_dependent_tasks(self):
|
||||
task1 = _task(name='task1', provides=['a'])
|
||||
task2 = _task(name='task2', requires=['a'])
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
|
||||
self.assertEqual(len(f), 2)
|
||||
self.assertItemsEqual(f, [task1, task2])
|
||||
self.assertEqual(list(f.iter_links()), [
|
||||
(task1, task2, {'reasons': set(['a'])})
|
||||
])
|
||||
|
||||
self.assertEqual(f.requires, set())
|
||||
self.assertEqual(f.provides, set(['a']))
|
||||
|
||||
def test_graph_flow_two_dependent_tasks_two_different_calls(self):
|
||||
task1 = _task(name='task1', provides=['a'])
|
||||
task2 = _task(name='task2', requires=['a'])
|
||||
f = gf.Flow('test').add(task1).add(task2)
|
||||
|
||||
self.assertEqual(len(f), 2)
|
||||
self.assertItemsEqual(f, [task1, task2])
|
||||
self.assertEqual(list(f.iter_links()), [
|
||||
(task1, task2, {'reasons': set(['a'])})
|
||||
])
|
||||
|
||||
def test_graph_flow_two_task_same_provide(self):
|
||||
task1 = _task(name='task1', provides=['a', 'b'])
|
||||
task2 = _task(name='task2', provides=['a', 'c'])
|
||||
f = gf.Flow('test')
|
||||
self.assertRaises(exc.DependencyFailure, f.add, task2, task1)
|
||||
|
||||
def test_graph_flow_with_retry(self):
|
||||
ret = retry.AlwaysRevert(requires=['a'], provides=['b'])
|
||||
f = gf.Flow('test', ret)
|
||||
self.assertIs(f.retry, ret)
|
||||
self.assertEqual(ret.name, 'test_retry')
|
||||
|
||||
self.assertEqual(f.requires, set(['a']))
|
||||
self.assertEqual(f.provides, set(['b']))
|
||||
|
||||
def test_graph_flow_ordering(self):
|
||||
task1 = _task('task1', provides=set(['a', 'b']))
|
||||
task2 = _task('task2', provides=['c'], requires=['a', 'b'])
|
||||
task3 = _task('task3', provides=[], requires=['c'])
|
||||
f = gf.Flow('test').add(task1, task2, task3)
|
||||
|
||||
self.assertEqual(3, len(f))
|
||||
|
||||
self.assertItemsEqual(list(f.iter_links()), [
|
||||
(task1, task2, {'reasons': set(['a', 'b'])}),
|
||||
(task2, task3, {'reasons': set(['c'])})
|
||||
])
|
||||
|
||||
def test_graph_flow_links(self):
|
||||
task1 = _task('task1')
|
||||
task2 = _task('task2')
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
linked = f.link(task1, task2)
|
||||
self.assertIs(linked, f)
|
||||
self.assertItemsEqual(list(f.iter_links()), [
|
||||
(task1, task2, {'manual': True})
|
||||
])
|
||||
|
||||
def test_graph_flow_links_and_dependencies(self):
|
||||
task1 = _task('task1', provides=['a'])
|
||||
task2 = _task('task2', requires=['a'])
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
linked = f.link(task1, task2)
|
||||
self.assertIs(linked, f)
|
||||
expected_meta = {
|
||||
'manual': True,
|
||||
'reasons': set(['a'])
|
||||
}
|
||||
self.assertItemsEqual(list(f.iter_links()), [
|
||||
(task1, task2, expected_meta)
|
||||
])
|
||||
|
||||
def test_graph_flow_link_from_unknown_node(self):
|
||||
task1 = _task('task1')
|
||||
task2 = _task('task2')
|
||||
f = gf.Flow('test').add(task2)
|
||||
self.assertRaisesRegexp(ValueError, 'Item .* not found to link from',
|
||||
f.link, task1, task2)
|
||||
|
||||
def test_graph_flow_link_to_unknown_node(self):
|
||||
task1 = _task('task1')
|
||||
task2 = _task('task2')
|
||||
f = gf.Flow('test').add(task1)
|
||||
self.assertRaisesRegexp(ValueError, 'Item .* not found to link to',
|
||||
f.link, task1, task2)
|
||||
|
||||
def test_graph_flow_link_raises_on_cycle(self):
|
||||
task1 = _task('task1', provides=['a'])
|
||||
task2 = _task('task2', requires=['a'])
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
self.assertRaises(exc.DependencyFailure, f.link, task2, task1)
|
||||
|
||||
def test_graph_flow_link_raises_on_link_cycle(self):
|
||||
task1 = _task('task1')
|
||||
task2 = _task('task2')
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
f.link(task1, task2)
|
||||
self.assertRaises(exc.DependencyFailure, f.link, task2, task1)
|
||||
|
||||
def test_graph_flow_dependency_cycle(self):
|
||||
task1 = _task('task1', provides=['a'], requires=['c'])
|
||||
task2 = _task('task2', provides=['b'], requires=['a'])
|
||||
task3 = _task('task3', provides=['c'], requires=['b'])
|
||||
f = gf.Flow('test').add(task1, task2)
|
||||
self.assertRaises(exc.DependencyFailure, f.add, task3)
|
||||
|
||||
|
||||
class TargetedGraphFlowTest(test.TestCase):
|
||||
|
||||
def test_targeted_flow_restricts(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=['a'], requires=[])
|
||||
task2 = _task('task2', provides=['b'], requires=['a'])
|
||||
task3 = _task('task3', provides=[], requires=['b'])
|
||||
task4 = _task('task4', provides=[], requires=['b'])
|
||||
f.add(task1, task2, task3, task4)
|
||||
f.set_target(task3)
|
||||
self.assertEqual(len(f), 3)
|
||||
self.assertItemsEqual(f, [task1, task2, task3])
|
||||
self.assertNotIn('c', f.provides)
|
||||
|
||||
def test_targeted_flow_reset(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=['a'], requires=[])
|
||||
task2 = _task('task2', provides=['b'], requires=['a'])
|
||||
task3 = _task('task3', provides=[], requires=['b'])
|
||||
task4 = _task('task4', provides=['c'], requires=['b'])
|
||||
f.add(task1, task2, task3, task4)
|
||||
f.set_target(task3)
|
||||
f.reset_target()
|
||||
self.assertEqual(len(f), 4)
|
||||
self.assertItemsEqual(f, [task1, task2, task3, task4])
|
||||
self.assertIn('c', f.provides)
|
||||
|
||||
def test_targeted_flow_bad_target(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=['a'], requires=[])
|
||||
task2 = _task('task2', provides=['b'], requires=['a'])
|
||||
f.add(task1)
|
||||
self.assertRaisesRegexp(ValueError, '^Item .* not found',
|
||||
f.set_target, task2)
|
||||
|
||||
def test_targeted_flow_one_node(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=['a'], requires=[])
|
||||
f.add(task1)
|
||||
f.set_target(task1)
|
||||
self.assertEqual(len(f), 1)
|
||||
self.assertItemsEqual(f, [task1])
|
||||
|
||||
def test_recache_on_add(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=[], requires=['a'])
|
||||
f.add(task1)
|
||||
f.set_target(task1)
|
||||
self.assertEqual(1, len(f))
|
||||
task2 = _task('task2', provides=['a'], requires=[])
|
||||
f.add(task2)
|
||||
self.assertEqual(2, len(f))
|
||||
|
||||
def test_recache_on_add_no_deps(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=[], requires=[])
|
||||
f.add(task1)
|
||||
f.set_target(task1)
|
||||
self.assertEqual(1, len(f))
|
||||
task2 = _task('task2', provides=[], requires=[])
|
||||
f.add(task2)
|
||||
self.assertEqual(1, len(f))
|
||||
|
||||
def test_recache_on_link(self):
|
||||
f = gf.TargetedFlow("test")
|
||||
task1 = _task('task1', provides=[], requires=[])
|
||||
task2 = _task('task2', provides=[], requires=[])
|
||||
f.add(task1, task2)
|
||||
f.set_target(task1)
|
||||
self.assertEqual(1, len(f))
|
||||
|
||||
f.link(task2, task1)
|
||||
self.assertEqual(2, len(f))
|
||||
self.assertEqual(list(f.iter_links()), [
|
||||
(task2, task1, {'manual': True})
|
||||
])
|
||||
@@ -194,13 +194,6 @@ class FlowDependenciesTest(test.TestCase):
|
||||
flow.add,
|
||||
gf.Flow('gf').add(utils.TaskOneReturn(provides='x')))
|
||||
|
||||
def test_graph_flow_without_dependencies(self):
|
||||
flow = gf.Flow('gf').add(
|
||||
utils.TaskNoRequiresNoReturns('task1'),
|
||||
utils.TaskNoRequiresNoReturns('task2'))
|
||||
self.assertEqual(flow.requires, set())
|
||||
self.assertEqual(flow.provides, set())
|
||||
|
||||
def test_graph_flow_requires_values(self):
|
||||
flow = gf.Flow('gf').add(
|
||||
utils.TaskOneArg('task1'),
|
||||
|
||||
@@ -1,215 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2012 Yahoo! Inc. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import collections
|
||||
|
||||
import taskflow.engines
|
||||
|
||||
from taskflow.patterns import graph_flow as gw
|
||||
from taskflow.utils import flow_utils as fu
|
||||
from taskflow.utils import graph_utils as gu
|
||||
|
||||
from taskflow import test
|
||||
from taskflow.tests import utils
|
||||
|
||||
|
||||
class GraphFlowTest(test.TestCase):
|
||||
def _make_engine(self, flow):
|
||||
return taskflow.engines.load(flow, store={})
|
||||
|
||||
def _capture_states(self):
|
||||
# TODO(harlowja): move function to shared helper.
|
||||
capture_where = collections.defaultdict(list)
|
||||
|
||||
def do_capture(state, details):
|
||||
task_uuid = details.get('task_uuid')
|
||||
if not task_uuid:
|
||||
return
|
||||
capture_where[task_uuid].append(state)
|
||||
|
||||
return (do_capture, capture_where)
|
||||
|
||||
def test_ordering(self):
|
||||
wf = gw.Flow("the-test-action")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
requires=[],
|
||||
provides=set(['a', 'b']))
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=['c'],
|
||||
requires=['a', 'b'])
|
||||
test_3 = utils.ProvidesRequiresTask('test-3',
|
||||
provides=[],
|
||||
requires=['c'])
|
||||
wf.add(test_1, test_2, test_3)
|
||||
self.assertEqual(3, len(wf))
|
||||
|
||||
edges = [(src, dst) for src, dst, _meta in wf.iter_links()]
|
||||
self.assertIn((test_1, test_2), edges)
|
||||
self.assertIn((test_2, test_3), edges)
|
||||
self.assertEqual(2, len(edges))
|
||||
|
||||
def test_basic_edge_reasons(self):
|
||||
wf = gw.Flow("the-test-action")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
requires=[],
|
||||
provides=set(['a', 'b']))
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=['c'],
|
||||
requires=['a', 'b'])
|
||||
wf.add(test_1, test_2)
|
||||
edges = list(wf.iter_links())
|
||||
self.assertEqual(len(edges), 1)
|
||||
|
||||
from_task, to_task, edge_attrs = edges[0]
|
||||
self.assertIs(from_task, test_1)
|
||||
self.assertIs(to_task, test_2)
|
||||
|
||||
self.assertTrue(len(edge_attrs) > 0)
|
||||
self.assertIn('reasons', edge_attrs)
|
||||
self.assertEqual(set(['a', 'b']), edge_attrs['reasons'])
|
||||
|
||||
def test_linked_edge_reasons(self):
|
||||
wf = gw.Flow("the-test-action")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
requires=[],
|
||||
provides=[])
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=[],
|
||||
requires=[])
|
||||
wf.add(test_1, test_2)
|
||||
self.assertEqual(len(list(wf.iter_links())), 0)
|
||||
|
||||
wf.link(test_1, test_2)
|
||||
edges = list(wf.iter_links())
|
||||
self.assertEqual(len(edges), 1)
|
||||
|
||||
from_task, to_task, edge_attrs = edges[0]
|
||||
self.assertIs(from_task, test_1)
|
||||
self.assertIs(to_task, test_2)
|
||||
|
||||
self.assertTrue(len(edge_attrs) > 0)
|
||||
self.assertTrue(edge_attrs.get('manual'))
|
||||
|
||||
def test_flatten_attribute(self):
|
||||
wf = gw.Flow("the-test-action")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
requires=[],
|
||||
provides=[])
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=[],
|
||||
requires=[])
|
||||
wf.add(test_1, test_2)
|
||||
wf.link(test_1, test_2)
|
||||
g = fu.flatten(wf)
|
||||
self.assertEqual(2, len(g))
|
||||
edge_attrs = gu.get_edge_attrs(g, test_1, test_2)
|
||||
self.assertTrue(edge_attrs.get('manual'))
|
||||
self.assertTrue(edge_attrs.get('flatten'))
|
||||
|
||||
|
||||
class TargetedGraphFlowTest(test.TestCase):
|
||||
|
||||
def test_targeted_flow(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=['a'], requires=[])
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=['b'], requires=['a'])
|
||||
test_3 = utils.ProvidesRequiresTask('test-3',
|
||||
provides=[], requires=['b'])
|
||||
test_4 = utils.ProvidesRequiresTask('test-4',
|
||||
provides=[], requires=['b'])
|
||||
wf.add(test_1, test_2, test_3, test_4)
|
||||
wf.set_target(test_3)
|
||||
g = fu.flatten(wf)
|
||||
self.assertEqual(3, len(g))
|
||||
self.assertFalse(g.has_node(test_4))
|
||||
self.assertFalse('c' in wf.provides)
|
||||
|
||||
def test_targeted_flow_reset(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=['a'], requires=[])
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=['b'], requires=['a'])
|
||||
test_3 = utils.ProvidesRequiresTask('test-3',
|
||||
provides=[], requires=['b'])
|
||||
test_4 = utils.ProvidesRequiresTask('test-4',
|
||||
provides=['c'], requires=['b'])
|
||||
wf.add(test_1, test_2, test_3, test_4)
|
||||
wf.set_target(test_3)
|
||||
wf.reset_target()
|
||||
g = fu.flatten(wf)
|
||||
self.assertEqual(4, len(g))
|
||||
self.assertTrue(g.has_node(test_4))
|
||||
|
||||
def test_targeted_flow_bad_target(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=['a'], requires=[])
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=['b'], requires=['a'])
|
||||
wf.add(test_1)
|
||||
self.assertRaisesRegexp(ValueError, '^Item .* not found',
|
||||
wf.set_target, test_2)
|
||||
|
||||
def test_targeted_flow_one_node(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=['a'], requires=[])
|
||||
wf.add(test_1)
|
||||
wf.set_target(test_1)
|
||||
g = fu.flatten(wf)
|
||||
self.assertEqual(1, len(g))
|
||||
self.assertTrue(g.has_node(test_1))
|
||||
|
||||
def test_recache_on_add(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=[], requires=['a'])
|
||||
wf.add(test_1)
|
||||
wf.set_target(test_1)
|
||||
self.assertEqual(1, len(wf))
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=['a'], requires=[])
|
||||
wf.add(test_2)
|
||||
self.assertEqual(2, len(wf))
|
||||
|
||||
def test_recache_on_add_no_deps(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=[], requires=[])
|
||||
wf.add(test_1)
|
||||
wf.set_target(test_1)
|
||||
self.assertEqual(1, len(wf))
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=[], requires=[])
|
||||
wf.add(test_2)
|
||||
self.assertEqual(1, len(wf))
|
||||
|
||||
def test_recache_on_link(self):
|
||||
wf = gw.TargetedFlow("test")
|
||||
test_1 = utils.ProvidesRequiresTask('test-1',
|
||||
provides=[], requires=[])
|
||||
test_2 = utils.ProvidesRequiresTask('test-2',
|
||||
provides=[], requires=[])
|
||||
wf.add(test_1, test_2)
|
||||
wf.set_target(test_1)
|
||||
self.assertEqual(1, len(wf))
|
||||
wf.link(test_2, test_1)
|
||||
self.assertEqual(2, len(wf))
|
||||
edges = [(src, dst) for src, dst, _meta in wf.iter_links()]
|
||||
self.assertEqual([(test_2, test_1)], edges)
|
||||
Reference in New Issue
Block a user