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()
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 setUp(self): self.sync = SyncFactory("threads") self.process = Process("proc", self.sync) self.block = Block("block") self.host = socket.gethostname().split('.')[0] self.prefix = "%s-AD-SIM-01" % self.host pass
def setUp(self): s = SyncFactory("sync") self.p = Process("process", s) self.b = Block("blockname") self.comms = MagicMock() serialized = dict(say_hello=dict( description="Says hello", takes=dict( elements=dict(name=dict( description="A name", metaOf="malcolm:core/String:1.0", ), ), required=["name"], ), defaults={}, returns=dict( elements=dict(greeting=dict( description="A greeting", metaOf="malcolm:core/String:1.0", ), ), required=["response"], ), ), ) def f(request): request.respond_with_return(serialized) self.comms.q.put.side_effect = f self.cc = ClientController(self.p, self.b, self.comms)
def setUp(self): self.p = Process('process1', SyncFactory('threading')) # create a child ManagerController block params = ManagerController.MethodMeta. \ prepare_input_map(mri='childBlock', configDir="/tmp") self.c_child = ManagerController(self.p, [], params) self.b_child = self.c_child.block self.sm = self.c_child.stateMachine params = Part.MethodMeta.prepare_input_map(name='part1') part1 = Part(self.p, params) params = {'name': 'part2', 'mri': 'childBlock'} params = ChildPart.MethodMeta.prepare_input_map(**params) part2 = ChildPart(self.p, params) # create a root block for the ManagerController block to reside in parts = [part1, part2] params = ManagerController.MethodMeta.prepare_input_map( mri='mainBlock', configDir="/tmp") self.c = ManagerController(self.p, parts, params) self.b = self.c.block # check that do_initial_reset works asynchronously self.p.start() # wait until block is Ready task = Task("block_ready_task", self.p) task.when_matches(self.b["state"], self.sm.READY, timeout=1) self.checkState(self.sm.READY)
def setUp(self): self.maxDiff = 5000 self.p = Process('process1', SyncFactory('threading')) # Make a ticker block to act as our child params = Ticker.MethodMeta.prepare_input_map(mri="childBlock", configDir="/tmp") self.b_child = Ticker(self.p, params)[-1] # Make an empty part for our parent params = Part.MethodMeta.prepare_input_map(name='part1') part1 = Part(self.p, params) # Make a RunnableChildPart to control the ticker params = RunnableChildPart.MethodMeta.prepare_input_map( mri='childBlock', name='part2') part2 = RunnableChildPart(self.p, params) # create a root block for the RunnableController block to reside in params = RunnableController.MethodMeta.prepare_input_map( mri='mainBlock', configDir="/tmp") self.c = RunnableController(self.p, [part1, part2], params) self.b = self.c.block self.sm = self.c.stateMachine # start the process off self.p.start() # wait until block is Ready task = Task("block_ready_task", self.p) task.when_matches(self.b["state"], self.sm.IDLE, timeout=1) self.checkState(self.sm.IDLE)
def setUp(self): self.p = Process('process1', SyncFactory('threading')) self.p1, self.c1 = self.makeChildBlock('child1') self.p2, self.c2 = self.makeChildBlock('child2') self.p3, self.c3 = self.makeChildBlock('child3') # create a root block for the child blocks to reside in parts = [self.p1, self.p2, self.p3] params = RunnableController.MethodMeta.prepare_input_map( mri='mainBlock', configDir="/tmp") self.c = RunnableController(self.p, parts, params) self.b = self.c.block params = ChildPart.MethodMeta.prepare_input_map(mri='mainBlock', name='mainPart') self.part = ChildPart(self.p, params) # Get the parent block into idle state self.p.start() # wait until block is Ready task = Task("block_ready_task", self.p) task.when_matches(self.c.block["state"], sm.IDLE, timeout=1) self.checkState(sm.IDLE)
def setUp(self): self.sf = SyncFactory("sync") self.process = Process("proc", self.sf) block = Block() HelloController(self.process, block, 'hello') self.sc = WSServerComms("sc", self.process, self.socket) self.process.start() self.sc.start()
def setUp(self): sync_factory = SyncFactory("sync") self.process = Process("proc", sync_factory) block = Block("hello") self.process.add_block(block) HelloController(block) self.sc = WSServerComms("sc", self.process, 8888) self.process.start() self.sc.start()
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_add_block_calls_handle(self): s = SyncFactory("sched") p = Process("proc", s) b = Block() b.set_parent(p, "myblock") p.add_block(b) p.start() p.stop() self.assertEqual(len(p._blocks), 2) self.assertEqual(p._blocks, dict(myblock=b, proc=p.process_block))
def test_add_block_calls_handle(self): s = SyncFactory("sched") p = Process("proc", s) b = MagicMock() b.name = "myblock" p.add_block("myblock", b) p.start() p.stop() b.set_parent.assert_called_once_with(p, "myblock") self.assertEqual(len(p._blocks), 2) self.assertEqual(p._blocks, dict(myblock=b, proc=p.process_block))
def test_error(self): s = SyncFactory("sched") p = Process("proc", s) p.log_exception = MagicMock() p.start() request = MagicMock() request.endpoint = ["anything"] p.q.put(request) p.stop() p.log_exception.assert_called_once_with("Exception while handling %s", request)
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_starting_process(self): s = SyncFactory("sched") p = Process("proc", s) b = MagicMock() p._handle_block_add(BlockAdd(b, "myblock", None)) self.assertEqual(p._blocks, dict(myblock=b, proc=ANY)) p.start() request = Post(MagicMock(), MagicMock(), ["myblock", "foo"]) p.q.put(request) # wait for spawns to have done their job p.stop() b.handle_request.assert_called_once_with(request)
def test_spawned_adds_to_other_spawned(self): s = SyncFactory("sched") p = Process("proc", s) def sleep(n, a=None): time.sleep(a) f = MagicMock(side_effect=sleep) spawned = p.spawn(f, "fred", a=0.05) p.start() p.stop() self.assertEqual(p._other_spawned, [(spawned, f)]) f.assert_called_once_with("fred", a=0.05)
def test_start_stop(self): self.process.sync_factory = SyncFactory("s") self.process.spawn = self.process.sync_factory.spawn self.process.create_queue = self.process.sync_factory.create_queue server = ServerComms("server", self.process) server.send_loop = Mock(side_effect = server.send_loop) server.start_recv_loop = Mock() server.stop_recv_loop = Mock() server.start() self.assertFalse(server._send_spawned.ready()) server.start_recv_loop.assert_called_once_with() server.stop(0.1) self.assertTrue(server._send_spawned.ready()) server.send_loop.assert_called_once_with() server.stop_recv_loop.assert_called_once_with()
def test_start_stop(self): sync_factory = SyncFactory("s") process = Mock() process.spawn = sync_factory.spawn process.create_queue = sync_factory.create_queue client = ClientComms("c", process) client.send_loop = Mock(side_effect = client.send_loop) client.start_recv_loop = Mock() client.stop_recv_loop = Mock() client.log_exception = Mock() client.start() self.assertFalse(client._send_spawned.ready()) client.start_recv_loop.assert_called_once_with() client.stop(0.1) self.assertTrue(client._send_spawned.ready()) client.send_loop.assert_called_once_with() client.stop_recv_loop.assert_called_once_with() client.log_exception.assert_not_called()
def setUp(self, mock_pool): self.s = SyncFactory("sched") mock_pool.assert_called_once_with() self.assertEqual(self.s.pool, mock_pool.return_value)