def test_counter_subscribe(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) b = Counter(process, dict(mri="counting"))[0] process.start() # wait until block is Ready task = Task("counter_ready_task", process) task.when_matches(b["state"], "Ready", timeout=1) q = sync_factory.create_queue() sub = Subscribe(response_queue=q, context="ClientConnection", endpoint=["counting", "counter"], delta=False) process.q.put(sub) resp = q.get(timeout=1) self.assertIsInstance(resp, Update) attr = NTScalar.from_dict(resp.value) self.assertEqual(0, attr.value) post = Post(response_queue=q, context="ClientConnection", endpoint=["counting", "increment"]) process.q.put(post) resp = q.get(timeout=1) self.assertIsInstance(resp, Update) self.assertEqual(resp.value["value"], 1) resp = q.get(timeout=1) self.assertIsInstance(resp, Return) process.stop()
def test_put_async(self): t = Task("testTask", self.proc) t.put_async(self.attr, "testValue") req = self.proc.q.get(timeout=0) self.assertIsInstance(req, Request) self.assertEqual(req.endpoint, ['testBlock', 'testAttr', 'value']) self.assertEqual(req.value, "testValue") self.assertEqual(len(t._futures), 1)
def test_when_matches(self): t = Task("testTask", self.proc) f = t.when_matches_async(self.attr, "matchTest") resp = Update(1, None, None) resp.set_value('matchTest') t.q.put(resp) self.assertEqual(f[0].result(0), 'matchTest') t.stop()
def test_when_matches(self): t = Task("testTask", self.proc) f = t.when_matches(self.attr, "matchTest") # match (response goes to the subscription at id 1, # not the future at id 0) resp = Update(1, None, None) resp.set_value('matchTest') t.q.put(resp) t.stop() self.assertEqual(f[0].result(0),'matchTest')
def test_put(self): # single attribute t = Task("testTask", self.proc) resp = Return(0, None, None) resp.set_value('testVal') # cheat and add the response before the blocking call to put t.q.put(resp) t.stop() t.put(self.attr, "testValue") self.assertEqual(len(t._futures), 0) self.assertEqual(self.proc.q.qsize(), 1)
def test_when_matches(self): t = Task("testTask", self.proc) f = t.when_matches(self.attr, "matchTest") # match (response goes to the subscription at id 1, # not the future at id 0) resp = Update(1, None, None) resp.set_value('matchTest') t.q.put(resp) t.stop() self.assertEqual(f[0].result(0), 'matchTest')
def test_put_many_async(self): t = Task("testTask", self.proc) t.put_many_async(self.block, dict(testAttr="testValue", testAttr2="testValue2")) reqs = [self.proc.q.get(timeout=0), self.proc.q.get(timeout=0)] self.assertEqual(self.proc.q.qsize(), 0) self.assertEqual(len(t._futures), 2) values = list(sorted((req.endpoint, req.value) for req in reqs)) self.assertEqual(values[0][0], ['testBlock', 'testAttr', 'value']) self.assertEqual(values[0][1], 'testValue') self.assertEqual(values[1][0], ['testBlock', 'testAttr2', 'value']) self.assertEqual(values[1][1], 'testValue2')
def test_put_many_async(self): t = Task("testTask", self.proc) t.put_many_async(self.block, dict( testAttr="testValue", testAttr2="testValue2")) reqs = [self.proc.q.get(timeout=0), self.proc.q.get(timeout=0)] self.assertEqual(self.proc.q.qsize(), 0) self.assertEqual(len(t._futures), 2) values = list(sorted((req.endpoint, req.value) for req in reqs)) self.assertEqual(values[0][0], ['testBlock', 'testAttr', 'value']) self.assertEqual(values[0][1], 'testValue') self.assertEqual(values[1][0], ['testBlock', 'testAttr2', 'value']) self.assertEqual(values[1][1], 'testValue2')
def test_not_when_matches(self): t = Task("testTask", self.proc) f = t.when_matches(self.attr, "matchTest") # match (response goes to the subscription at id 1, # not the future at id 0) resp = Update(1, None, None) resp.set_value('NOTmatchTest') t.q.put(resp) t.stop() # this will abort the task because f[0] never gets filled self.assertRaises(StopIteration, f[0].result)
def test_not_when_matches(self): t = Task("testTask", self.proc) f = t.when_matches(self.attr, "matchTest") # match (response goes to the subscription at id 1, # not the future at id 0) resp = Update(1, None, None) resp.set_value('NOTmatchTest') t.q.put(resp) t.stop() # this will abort the task because f[0] never gets filled self.assertRaises(RuntimeWarning, f[0].result)
def test_post(self): t = Task("testTask", self.proc) resp1 = Return(1, None, None) resp1.set_value(dict(ret='testVal')) resp2 = Error(2, None, "") # cheat and add the responses before the blocking call to put t.q.put(resp1) t.q.put(resp2) t.stop() t.post(self.method, {"a": "testParm"}) self.assertRaises(ResponseError, t.post, self.method, {"a": "testParm2"}) self.assertEqual(len(t._futures), 0) self.assertEqual(self.proc.q.qsize(), 2)
def test_put_many(self): # many attributes t = Task("testTask", self.proc) resp1 = Return(1, None, None) resp1.set_value('testVal1') resp2 = Return(2, None, None) resp2.set_value('testVal2') # cheat and add the response before the blocking call to put t.q.put(resp1) t.q.put(resp2) t.stop() t.put_many(self.block, dict( testAttr="testValue", testAttr2="testValue2")) self.assertEqual(len(t._futures), 0) self.assertEqual(self.proc.q.qsize(), 2)
def test_put_async(self): t = Task("testTask", self.proc) t.put_async(self.attr, "testValue") req = self.proc.q.get(timeout=0) self.assertIsInstance(req, Request) self.assertEqual(req.endpoint, [self.block.name, 'testAttr', 'value']) self.assertEqual(len(t._futures), 1) d = {self.attr: "testValue", self.attr2: "testValue2"} t.put_async(d) self.proc.q.get(timeout=0) req2 = self.proc.q.get(timeout=0) self.assertEqual(self.proc.q.qsize(), 0) self.assertIsInstance(req2, Request) self.assertEqual(len(t._futures), 3)
def test_clear_raises_if_running(self): proc = Process("proc", SyncFactory("sync")) t = Task("testTask", proc) import time def f(): time.sleep(0.05) t.define_spawn_function(f) start = time.time() t.start() self.assertRaises(AssertionError, t.define_spawn_function, None) t.wait() end = time.time() self.assertAlmostEqual(end - start, 0.05, delta=0.005) t.define_spawn_function(None)
def test_wait_all_missing_futures(self): # unsolicited response t = Task("testTask", self.proc) f1 = Future(t) resp10 = Return(10, None, None) t.q.put(resp10) t.q.put(Spawnable.STOP) self.assertRaises(AbortedError, t.wait_all, f1, 0) # same future twice f2 = Future(t) t._futures = {1: f2} resp1 = Return(1, None, None) t.q.put(resp1) t.q.put(Spawnable.STOP) t.wait_all(f2,0) t.wait_all(f2,0)
def test_wait_all_missing_futures(self): # unsolicited response t = Task("testTask", self.proc) f1 = Future(t) resp10 = Return(10, None, None) t.q.put(resp10) t.q.put(Spawnable.STOP) self.assertRaises(StopIteration, t.wait_all, f1, 0) # same future twice f2 = Future(t) t._futures = {1: f2} resp1 = Return(1, None, None) t.q.put(resp1) t.q.put(Spawnable.STOP) t.wait_all(f2, 0) t.wait_all(f2, 0)
def run(self, controller): """ Run all relevant functions for this Hook Args: controller(Controller): Controller who's parts' functions will be run """ names = [n for n in dir(controller) if getattr(controller, n) is self] assert len(names) > 0, \ "Hook is not in controller" assert len(names) == 1, \ "Hook appears in controller multiple times as %s" % names self.set_logger_name("%s.%s" % (controller.block.name, names[0])) task_queue = controller.process.create_queue() spawned_list = [] active_tasks = [] for part in controller.parts: members = [ value[1] for value in inspect.getmembers(part, predicate=inspect.ismethod) ] for function in members: if hasattr(function, "Hook") and function.Hook == self: task = Task(controller.process) spawned_list.append( controller.process.spawn(self._run_func, task_queue, function, task)) active_tasks.append(task) while active_tasks: task, response = controller.process.q.get() active_tasks.remove(task) if isinstance(response, Exception): for task in active_tasks: task.stop() for spawned in spawned_list: spawned.wait() raise response
def test_wait_all_missing_futures(self): # unsolicited response t = Task("testTask", self.proc) f1 = Future(t) resp10 = Return(10, None, None) t.q.put(resp10) t.q.put(Task.TASK_STOP) self.assertRaises(RuntimeWarning, t.wait_all, f1, 0) # same future twice f2 = Future(t) t._futures = {1: f2} resp1 = Return(1, None, None) t.q.put(resp1) t.q.put(Task.TASK_STOP) t.wait_all(f2, 0) t.wait_all(f2, 0)
def test_wait_all_missing_futures(self): # unsolicited response t = Task("testTask", self.proc) f1 = Future(t) resp10 = Return(10, None, None) t.q.put(resp10) t.q.put(Task.TASK_STOP) self.assertRaises(RuntimeWarning, t.wait_all, f1, 0) # same future twice f2 = Future(t) t._futures = {1: f2} resp1 = Return(1, None, None) t.q.put(resp1) t.q.put(Task.TASK_STOP) t.wait_all(f2,0) t.wait_all(f2,0)
def test_clear_raises_if_running(self): proc = Process("proc", SyncFactory("sync")) t = Task("testTask", proc) import time def f(): time.sleep(0.05) t.define_spawn_function(f) start = time.time() t.start() self.assertRaises(UnexpectedError, t.define_spawn_function, None) t.wait() end = time.time() self.assertAlmostEqual(end-start, 0.05, delta=0.005) t.define_spawn_function(None) del proc.sync_factory
def run(self, controller): """ Run all relevant functions for this Hook Args: controller(Controller): Controller who's parts' functions will be run """ names = [n for n in dir(controller) if getattr(controller, n) is self] assert len(names) > 0, \ "Hook is not in controller" assert len(names) == 1, \ "Hook appears in controller multiple times as %s" % names self.set_logger_name("%s.%s" % (controller.block.name, names[0])) task_queue = controller.process.create_queue() spawned_list = [] active_tasks = [] for part in controller.parts: members = [value[1] for value in inspect.getmembers(part, predicate=inspect.ismethod)] for function in members: if hasattr(function, "Hook") and function.Hook == self: task = Task(controller.process) spawned_list.append(controller.process.spawn( self._run_func, task_queue, function, task)) active_tasks.append(task) while active_tasks: task, response = controller.process.q.get() active_tasks.remove(task) if isinstance(response, Exception): for task in active_tasks: task.stop() for spawned in spawned_list: spawned.wait() raise response
def test_callback_unexpected(self): t = Task("testTask", self.proc) resp = Delta(0, None, None) t.q.put(resp) t.stop() t.subscribe(self.attr, self._callback, 3, 5) f1 = Future(t) t._futures = {1: f1} self.assertRaises(ValueError, t.wait_all, f1, 0)
def test_post(self): t = Task("testTask", self.proc) resp1 = Return(0, None, None) resp1.set_value('testVal') resp2 = Error(1, None, None) # cheat and add the responses before the blocking call to put t.q.put(resp1) t.q.put(resp2) t.stop() t.post(self.method, "testParm") t.post(self.method, "testParm2") self.assertEqual(len(t._futures), 0) self.assertEqual(self.proc.q.qsize(), 2)
def test_hello_with_process(self): sync_factory = SyncFactory("sched") process = Process("proc", sync_factory) b = Hello(process, dict(mri="hello"))[0] process.start() # wait until block is Ready task = Task("hello_ready_task", process) task.when_matches(b["state"], "Ready", timeout=1) q = sync_factory.create_queue() req = Post(response_queue=q, context="ClientConnection", endpoint=["hello", "greet"], parameters=dict(name="thing")) req.set_id(44) process.q.put(req) resp = q.get(timeout=1) self.assertEqual(resp.id, 44) self.assertEqual(resp.context, "ClientConnection") self.assertEqual(resp.typeid, "malcolm:core/Return:1.0") self.assertEqual(resp.value["greeting"], "Hello thing") process.stop()
def test_wait_all(self): t = Task("testTask", self.proc) f1 = Future(t) f2 = Future(t) f3 = Future(t) f0 = Future(t) t._futures = {0: f0, 1: f1, 2: f2, 3: f3} f_wait1 = [f2, f0] self.assertRaises(queue.Empty, t.wait_all, f_wait1, 0) resp0 = Return(0, None, None) resp0.set_value('testVal') resp2 = Error(2, None, "") t.q.put(resp0) t.q.put(resp2) self.assertRaises(ResponseError, t.wait_all, f_wait1, 0) self.assertEqual(t._futures, {1: f1, 3: f3}) self.assertEqual(f0.done(), True) self.assertEqual(f1.done(), False) self.assertEqual(f2.done(), True) self.assertEqual(f3.done(), False) self.assertEqual(self.proc.q.qsize(), 0) resp3 = Delta(3, None, None) t.q.put(resp3) f_wait1 = [f3] self.assertRaises(UnexpectedError, t.wait_all, f_wait1, 0.01) t.stop() self.assertRaises(AbortedError, t.wait_all, f_wait1, 0.01) resp1 = Return(1, None, None) resp1.set_value('testVal') t.q.put(resp1) self.assertRaises(queue.Empty, t.wait_all, f_wait1, 0.01) self.assertEqual(t._futures, {}) t._futures = {0: f0, 1: f1, 2: f2} t.q.put(resp1) t.q.put(Spawnable.STOP) self.assertEqual(f1.result(), 'testVal')
def test_callback_error(self): t = Task("testTask", self.proc) resp = Error(0, None, None) resp.set_message('error') t.q.put(resp) t.stop() t.subscribe(self.attr, self._callback, 3, 5) f1 = Future(t) t._futures = {1: f1} self.assertRaises(RuntimeError, t.wait_all, f1, 0)
def test_subscribe(self): t = Task("testTask", self.proc) resp = Update(0, None, None) resp.set_value('changedVal') t.q.put(resp) t.stop() new_id = t.subscribe(self.attr, self._callback, 3, 5) f1 = Future(t) t._futures = {1: f1} self.assertRaises(StopIteration, t.wait_all, f1, 0) self.assertEqual(self.callback_value, 'changedVal') self.assertEqual(self.callback_result, 8) t.unsubscribe(new_id)
def test_callback_crash(self): t = Task("testTask", self.proc) resp = Update(0, None, None) resp.set_value('changedVal') t.q.put(resp) t.stop() t.subscribe(self.attr, self._bad_callback) f1 = Future(t) t._futures = {1: f1} self.assertRaises(StopIteration, t.wait_all, f1, 0) self.assertEquals(self.bad_called_back, True)
def test_subscribe(self): t = Task("testTask", self.proc) resp = Update(0, None, None) resp.set_value('changedVal') t.q.put(resp) t.stop() new_id = t.subscribe(self.attr, self._callback, 3, 5) f1 = Future(t) t._futures = {1: f1} self.assertRaises(RuntimeWarning, t.wait_all, f1, 0) self.assertEqual(self.callback_value, 'changedVal') self.assertEqual(self.callback_result, 8) t.unsubscribe(new_id)
def test_callback_crash(self): t = Task("testTask", self.proc) resp = Update(0, None, None) resp.set_value('changedVal') t.q.put(resp) t.stop() t.subscribe(self.attr, self._bad_callback) f1 = Future(t) t._futures = {1: f1} self.assertRaises(RuntimeWarning, t.wait_all, f1, 0) self.assertEquals(self.bad_called_back, True)
def test_wait_all(self): t = Task("testTask", self.proc) f1 = Future(t) f2 = Future(t) f3 = Future(t) f0 = Future(t) t._futures = {0: f0, 1: f1, 2: f2, 3: f3} f_wait1 = [f2, f0] self.assertRaises(queue.Empty, t.wait_all, f_wait1, 0) resp0 = Return(0, None, None) resp0.set_value('testVal') resp2 = Error(2, None, None) t.q.put(resp0) t.q.put(resp2) t.wait_all(f_wait1, 0) self.assertEqual(t._futures, {1: f1, 3: f3}) self.assertEqual(f0.done(), True) self.assertEqual(f1.done(), False) self.assertEqual(f2.done(), True) self.assertEqual(f3.done(), False) self.assertEqual(self.proc.q.qsize(), 0) resp3 = Delta(3, None, None) t.q.put(resp3) f_wait1 = [f3] self.assertRaises(ValueError, t.wait_all, f_wait1, 0.01) t.stop() self.assertRaises(RuntimeWarning, t.wait_all, f_wait1, 0.01) resp1 = Return(1, None, None) resp1.set_value('testVal') t.q.put(resp1) self.assertRaises(queue.Empty, t.wait_all, f_wait1, 0.01) self.assertEqual(t._futures, {}) t._futures = {0: f0, 1: f1, 2: f2} t.q.put(resp1) t.q.put(Task.TASK_STOP) self.assertEqual(f1.result(), 'testVal')
def test_put_many(self): # many attributes t = Task("testTask", self.proc) resp1 = Return(1, None, None) resp1.set_value('testVal1') resp2 = Return(2, None, None) resp2.set_value('testVal2') # cheat and add the response before the blocking call to put t.q.put(resp1) t.q.put(resp2) t.stop() t.put_many(self.block, dict(testAttr="testValue", testAttr2="testValue2")) self.assertEqual(len(t._futures), 0) self.assertEqual(self.proc.q.qsize(), 2)
def test_put_async(self): t = Task("testTask", self.proc) t.put_async(self.attr, "testValue") req = self.proc.q.get(timeout=0) self.assertIsInstance(req, Request) self.assertEqual(req.endpoint, ['testBlock', 'testAttr', 'value']) self.assertEqual(len(t._futures), 1) d = {self.attr: "testValue", self.attr2: "testValue2"} t.put_async(d) self.proc.q.get(timeout=0) req2 = self.proc.q.get(timeout=0) self.assertEqual(self.proc.q.qsize(), 0) self.assertIsInstance(req2, Request) self.assertEqual(len(t._futures), 3)
def test_init(self): t = Task("testTask", self.proc) self.assertIsInstance(t._logger, logging.Logger) self.assertIsInstance(t.q, queue.Queue) self.assertEqual(t.process, self.proc)
def setUp(self): self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(return_value=queue.Queue()) self.task = Task("testTask", self.proc)
def test_sleep(self): t = Task("testTask", self.proc) start = time.time() t.sleep(0.05) end = time.time() self.assertAlmostEqual(end - start, 0.05, delta=0.005)
def test_start_default_raises(self): t = Task("t", self.proc) self.assertRaises(AssertionError, t.start)
def test_clear_spawn_functions(self): t = Task("testTask", self.proc) f = MagicMock() t.define_spawn_function(None) self.assertEquals([(None, (), ANY)], t._spawn_functions)
def create_part_tasks(self): part_tasks = {} for part_name, part in self.parts.items(): part_tasks[part] = Task("Task(%s)" % part_name, self.process) return part_tasks
def test_sleep(self): t = Task("testTask", self.proc) start = time.time() t.sleep(0.05) end = time.time() self.assertAlmostEqual(end-start, 0.05, delta=0.005)