def setUp(self): self.callback_result = 0 self.callback_value = '' meta = VMeta("meta for unit tests") self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.block = Block() self.block.set_parent(self.proc, "testBlock") self.attr = meta.make_attribute() self.attr.set_parent(self.block, "testAttr") self.attr2 = meta.make_attribute() self.attr2.set_parent(self.block, "testAttr2") self.method = MethodMeta("method for unit tests") self.method.set_parent(self.block, "testFunc") self.method2 = MethodMeta("method for unit tests") self.method2.set_parent(self.block, "testFunc") self.bad_called_back = False
def setUp(self): self.callback_result = 0 self.callback_value = '' meta = StringMeta("meta for unit tests") self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.block = Block() self.block.set_process_path(self.proc, ("testBlock", )) self.attr = meta.make_attribute() self.attr2 = meta.make_attribute() self.method = MethodMeta("method for unit tests") self.method.returns.set_elements(ElementMap(dict(ret=StringMeta()))) self.method2 = MethodMeta("method for unit tests") self.block.replace_endpoints( dict(testFunc=self.method, testFunc2=self.method2, testAttr=self.attr, testAttr2=self.attr2)) self.bad_called_back = False
def test_getattr(self): b = Block() a = NumberMeta("int32").make_attribute() b.replace_endpoints(dict(a=a)) def f(meta, value): a.set_value(value) b.set_writeable_functions(dict(a=f)) b.a = 32 self.assertEqual(b.a, 32)
def test_handle_request_fails(self): parent = MagicMock() child = MagicMock(spec=Attribute) func = MagicMock() child.handle_request.side_effect = Exception("Test exception") b = Block() b.replace_endpoints({"child": child}) b.set_writeable_functions({"child": func}) b.set_parent(parent, "name") request = MagicMock(spec=Put, id=12345, response_queue=MagicMock(), context=MagicMock(), endpoint=["name", "child", "irrelevant"]) b.handle_request(request) calls = parent.block_respond.call_args_list self.assertEquals(1, len(calls)) response = calls[0][0][0] self.assertIsInstance(response, Error) self.assertEquals(request.id, response.id) self.assertEquals(request.context, response.context) self.assertEquals("Test exception", response.message) self.assertEquals(request.response_queue, calls[0][0][1])
def test_handle_post_request(self): parent = MagicMock() child = MagicMock(spec=Attribute) func = MagicMock() b = Block() b.replace_endpoints({"child": child}) b.set_writeable_functions({"child": func}) b.set_parent(parent, "name") request = MagicMock(spec=Post, id=12345, response_queue=MagicMock(), context=MagicMock(), endpoint=["name", "child", "irrelevant"]) b.handle_request(request) calls = parent.block_respond.call_args_list self.assertEquals(1, len(calls)) response = calls[0][0][0] self.assertIsInstance(response, Return) self.assertEquals(request.id, response.id) self.assertEquals(request.context, response.context) self.assertEquals(child.handle_request.return_value.to_dict(), response.value) self.assertEquals(request.response_queue, calls[0][0][1])
def setUp(self): self.callback_result = 0 self.callback_value = '' meta = StringMeta("meta for unit tests") self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.block = Block() self.block.set_process_path(self.proc, ("testBlock",)) self.attr = meta.make_attribute() self.attr2 = meta.make_attribute() self.method = MethodMeta("method for unit tests") self.method.returns.set_elements(ElementMap(dict(ret=StringMeta()))) self.method2 = MethodMeta("method for unit tests") self.block.replace_endpoints( dict(testFunc=self.method, testFunc2=self.method2, testAttr=self.attr, testAttr2=self.attr2)) self.bad_called_back = False
def set_dimensions(child: Block, generator: CompoundGenerator) -> List[Future]: num_dims = len(generator.dimensions) assert num_dims <= 10, "Can only do 10 dims, you gave me %s" % num_dims attr_dict: Dict = dict(numExtraDims=num_dims - 1) # Fill in dim name and size # NOTE: HDF writer has these filled with fastest moving first # while dimensions is slowest moving first for i in range(10): suffix = SUFFIXES[i] if i < num_dims: forward_i = num_dims - i - 1 index_name = "d%d" % forward_i index_size = generator.dimensions[forward_i].size else: index_name = "" index_size = 1 attr_dict["posNameDim%s" % suffix] = index_name attr_dict["extraDimSize%s" % suffix] = index_size futures = child.put_attribute_values_async(attr_dict) return futures
class TestTask(unittest.TestCase): def setUp(self): self.callback_result = 0 self.callback_value = '' meta = StringMeta("meta for unit tests") self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.block = Block() self.block.set_process_path(self.proc, ("testBlock",)) self.attr = meta.make_attribute() self.attr2 = meta.make_attribute() self.method = MethodMeta("method for unit tests") self.method.returns.set_elements(ElementMap(dict(ret=StringMeta()))) self.method2 = MethodMeta("method for unit tests") self.block.replace_endpoints( dict(testFunc=self.method, testFunc2=self.method2, testAttr=self.attr, testAttr2=self.attr2)) self.bad_called_back = False 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 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_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(self): # single attribute t = Task("testTask", self.proc) resp = Return(1, 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_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_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_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_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 _callback(self, value, a, b): self.callback_result = a+b self.callback_value = value def test_subscribe(self): t = Task("testTask", self.proc) resp = Update(1, 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(AbortedError, t.wait_all, f1, 0) self.assertEqual(self.callback_value, 'changedVal') self.assertEqual(self.callback_result, 8) t.unsubscribe(new_id) def test_callback_error(self): t = Task("testTask", self.proc) resp = Error(1, 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(ResponseError, t.wait_all, f1, 0) def test_callback_unexpected(self): t = Task("testTask", self.proc) resp = Delta(1, 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(UnexpectedError, t.wait_all, f1, 0) def _bad_callback(self, value): self.bad_called_back = True raise TestWarning() def test_callback_crash(self): t = Task("testTask", self.proc) resp = Update(1, 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(TestWarning, t.wait_all, f1, 0) self.assertEquals(self.bad_called_back, True) 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_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_not_when_matches(self): t = Task("testTask", self.proc) f = t.when_matches_async(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(AbortedError, f[0].result) 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 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
class TestTask(unittest.TestCase): def setUp(self): self.callback_result = 0 self.callback_value = '' meta = VMeta("meta for unit tests") self.proc = MagicMock(q=queue.Queue()) self.proc.create_queue = MagicMock(side_effect=queue.Queue) self.block = Block() self.block.set_parent(self.proc, "testBlock") self.attr = meta.make_attribute() self.attr.set_parent(self.block, "testAttr") self.attr2 = meta.make_attribute() self.attr2.set_parent(self.block, "testAttr2") self.method = MethodMeta("method for unit tests") self.method.set_parent(self.block, "testFunc") self.method2 = MethodMeta("method for unit tests") self.method2.set_parent(self.block, "testFunc") self.bad_called_back = False 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 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_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_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, {"a": "testParm"}) self.assertRaises(ValueError, t.post, self.method, {"a": "testParm2"}) self.assertEqual(len(t._futures), 0) self.assertEqual(self.proc.q.qsize(), 2) 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) self.assertRaises(ValueError, 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(StopIteration, 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_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 _callback(self, value, a, b): self.callback_result = a + b self.callback_value = value 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_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_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 _bad_callback(self, value): self.bad_called_back = True raise TestWarning() 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_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_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_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_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 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_getattr_raises(self): b = Block() self.assertRaises(AttributeError, getattr, b, "_does_not_exist")
def test_init(self): b = Block() self.assertEqual(list(b), []) self.assertEqual("malcolm:core/Block:1.0", b.typeid)