class TestProcess(unittest.TestCase):
def setUp(self):
self.o = Process("proc")
self.o.start()
def tearDown(self):
self.o.stop(timeout=1)
def test_init(self):
assert self.o.name == "proc"
def test_add_controller(self):
controller = MagicMock()
self.o.add_controller("mri", controller)
assert self.o.get_controller("mri") == controller
def test_init_controller(self):
class InitController(Controller):
init = False
@Process.Init
def do_init(self):
self.init = True
c = InitController(self.o, "mri", [])
self.o.add_controller("mri", c)
assert c.init == True
def test_publish_controller(self):
class PublishController(Controller):
published = []
@Process.Publish
def do_publish(self, published):
self.published = published
c = PublishController(self.o, "mri", [])
self.o.add_controller("mri", c)
assert c.published == ["mri"]
self.o.add_controller("mri2", MagicMock())
assert c.published == ["mri", "mri2"]
self.o.add_controller("mri3", MagicMock(), False)
assert c.published == ["mri", "mri2"]
self.o.remove_controller("mri2")
assert c.published == ["mri"]
class TestMethod(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.part = MyPart("test_part")
self.controller = MyController(self.process, "mri", [self.part])
self.process.add_controller("mri", self.controller)
self.context = Context(self.process)
self.block = self.controller.make_view(self.context)
self.process.start()
self.process.my_method_executed = False
def tearDown(self):
self.process.stop(timeout=1)
def test_post(self):
method_view = self.block.my_method
result = method_view.post(param1='testPost', param2='y')
assert result.ret == 'testPosty'
def test_post_async(self):
method_view = self.block.my_method
f = method_view.post_async('testAsync', 'y')
assert f.result().ret == 'testAsyncy'
class TestContext(unittest.TestCase):
def setUp(self):
self.process = Process("proc")
self.controller = MagicMock()
self.process.add_controller("block", self.controller)
self.o = Context(self.process)
self.cothread = maybe_import_cothread()
def test_aborts_timeout_zero(self):
self.o.ignore_stops_before_now()
self.o.sleep(0)
self.o.ignore_stops_before_now()
self.o.ignore_stops_before_now()
self.o.stop()
with self.assertRaises(AbortedError):
self.o.sleep(0)
def test_block_view(self):
self.o.block_view("block")
self.controller.make_view.assert_called_once_with(ANY)
def test_put(self):
self.o._q.put(Return(1, None))
self.o.put(["block", "attr", "value"], 32)
self.controller.handle_request.assert_called_once_with(
Put(1, ["block", "attr", "value"], 32))
def test_put_failure(self):
self.o._q.put(Error(1, "Test Exception"))
with self.assertRaises(ResponseError) as cm:
self.o.put(["block", "attr", "value"], 32)
assert str(cm.exception) == "Test Exception"
def test_post(self):
self.controller.validate_result.return_value = 22
self.o._q.put(Return(1, dict(a=2)))
result = self.o.post(["block", "method"], dict(b=32))
self.controller.handle_request.assert_called_once_with(
Post(1, ["block", "method"], dict(b=32)))
self.controller.validate_result.assert_called_once_with(
"method", dict(a=2))
assert result == 22
def test_post_failure(self):
self.o._q.put(Error(1, "Test Exception"))
with self.assertRaises(ResponseError) as cm:
self.o.post(["block", "method"], dict(b=32))
assert str(cm.exception) == "Test Exception"
def test_subscribe(self):
cb = MagicMock()
f = self.o.subscribe(["block", "attr", "value"], cb, self.o, 'arg2')
self.controller.handle_request.assert_called_once_with(
Subscribe(1, ["block", "attr", "value"]))
self.o._q.put(Update(1, "value1"))
with self.assertRaises(TimeoutError):
self.o.wait_all_futures(f, 0.01)
cb.assert_called_once_with("value1", ANY, 'arg2')
# since args = self.o it should be a weak proxy in second argument
param1 = cb.call_args[0][1]
# TODO: giles cant work out how to check weakproxy equivalence??
# self.assertEquals(param1, self.o)
cb.reset_mock()
self.o._q.put(Update(1, "value2"))
self.o._q.put(Return(1))
self.o.wait_all_futures(f, 0.01)
cb.assert_called_once_with("value2", ANY, 'arg2')
assert f.result(0.01) == None
def test_subscribe_cb_failure(self):
def cb(value):
raise MyWarning()
f = self.o.subscribe(["block", "attr", "value"], cb)
self.o._q.put(Update(1, "value1"))
with self.assertRaises(MyWarning):
self.o.wait_all_futures(f, 0.01)
assert not f.done()
self.o._q.put(Update(1, "value1"))
with self.assertRaises(MyWarning):
self.o.wait_all_futures(f, 0.01)
assert not f.done()
self.o._q.put(Return(1))
self.o.wait_all_futures(f, 0.01)
assert f.done()
def test_many_puts(self):
fs = [
self.o.put_async(["block", "attr", "value"], 32),
self.o.put_async(["block", "attr2", "value"], 32)
]
with self.assertRaises(TimeoutError):
self.o.wait_all_futures(fs, 0.01)
assert [f.done() for f in fs] == [False, False]
self.o._q.put(Return(2, None))
assert [f.done() for f in fs] == [False, False]
with self.assertRaises(TimeoutError):
self.o.wait_all_futures(fs, 0.01)
assert [f.done() for f in fs] == [False, True]
self.o._q.put(Return(1, None))
self.o.wait_all_futures(fs, 0.01)
assert [f.done() for f in fs] == [True, True]
self.o.wait_all_futures(fs, 0.01)
assert [f.done() for f in fs] == [True, True]
def test_sleep(self):
start = time.time()
self.o.sleep(0.05)
end = time.time()
self.assertAlmostEqual(end - start, 0.05, delta=0.01)
def test_when_matches(self):
self.o._q.put(Update(1, "value1"))
self.o._q.put(Return(1))
self.o.when_matches(["block", "attr", "value"], "value1", timeout=0.01)
assert self.controller.handle_request.call_args_list == [
call(Subscribe(1, ["block", "attr", "value"])),
call(Unsubscribe(1))
]
def test_when_matches_func(self):
self.o._q.put(Update(1, "value1"))
self.o._q.put(Return(1))
def f(value):
return value.startswith("v")
self.o.when_matches(["block", "attr", "value"], f, timeout=0.01)
assert self.controller.handle_request.call_args_list == [
call(Subscribe(1, ["block", "attr", "value"])),
call(Unsubscribe(1))
]
def test_when_not_matches(self):
self.o._q.put(Update(1, "value2"))
with self.assertRaises(BadValueError):
self.o.when_matches(["block", "attr", "value"],
"value1", ["value2"],
timeout=0.01)
assert self.controller.handle_request.call_args_list == [
call(Subscribe(1, ["block", "attr", "value"])),
call(Unsubscribe(1))
]
def test_ignore_stops_before_now(self):
fs = [self.o.put_async(["block", "attr", "value"], 32)]
self.o.stop()
self.o.ignore_stops_before_now()
with self.assertRaises(TimeoutError):
self.o.wait_all_futures(fs, 0)
if self.cothread:
assert 0 == len(self.o._q._event_queue)
else:
assert 0 == self.o._q._queue.qsize()
def test_futures_exception(self):
fs = [self.o.put_async(["block", "attr", "value"], 32)]
fs[0]._exception = BadValueError
fs[0]._state = Future.FINISHED
with self.assertRaises(BadValueError):
self.o.wait_all_futures(fs, 0)
def test_futures_remaining_paths(self):
fs = [self.o.put_async(["block", "attr", "value"], 32)]
self.o.stop()
with self.assertRaises(AbortedError):
self.o.wait_all_futures(fs, 0)
