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)
