class TestBlock(unittest.TestCase):
@patch("malcolm.core.syncfactory.ThreadPool")
def setUp(self, mock_pool):
self.s = SyncFactory("sched")
mock_pool.assert_called_once_with()
self.assertEqual(self.s.pool, mock_pool.return_value)
@patch("malcolm.core.syncfactory.Queue")
def test_queue_creation(self, mock_queue):
q = self.s.create_queue()
mock_queue.assert_called_once_with()
self.assertEqual(q, mock_queue.return_value)
@patch("malcolm.core.syncfactory.Lock")
def test_lock_creation(self, mock_lock):
l = self.s.create_lock()
mock_lock.assert_called_once_with()
self.assertEqual(l, mock_lock.return_value)
def test_spawned_calls_pool_apply(self):
r = self.s.spawn(callable, "fred", b=43)
self.s.pool.apply_async.assert_called_once_with(
callable, ("fred",), dict(b=43))
self.assertEqual(r, self.s.pool.apply_async.return_value)
class TestBlock(unittest.TestCase):
@patch("malcolm.core.syncfactory.ThreadPool")
def setUp(self, mock_pool):
self.s = SyncFactory("sched")
mock_pool.assert_called_once_with(128)
self.assertEqual(self.s.pool, mock_pool.return_value)
def tearDown(self):
del self.s
@patch("malcolm.core.syncfactory.InterruptableQueue")
def test_queue_creation(self, mock_queue):
q = self.s.create_queue()
mock_queue.assert_called_once_with()
self.assertEqual(q, mock_queue.return_value)
@patch("malcolm.core.syncfactory.Lock")
def test_lock_creation(self, mock_lock):
l = self.s.create_lock()
mock_lock.assert_called_once_with()
self.assertEqual(l, mock_lock.return_value)
def test_spawned_calls_pool_apply(self):
r = self.s.spawn(callable, "fred", b=43)
self.s.pool.apply_async.assert_called_once_with(
callable, ("fred", ), dict(b=43))
self.assertEqual(r, self.s.pool.apply_async.return_value)
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_hello_controller_with_process(self):
sync_factory = SyncFactory("sched")
process = Process("proc", sync_factory)
block = Block("hello")
HelloController(block)
process.add_block(block)
process.start()
q = sync_factory.create_queue()
req = Request.Post(response_queue=q, context="ClientConnection",
endpoint=["hello", "say_hello"],
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.type_, "Return")
self.assertEqual(resp.value, dict(greeting="Hello thing"))
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()
