def test_add_block(self):
p = Process("proc", MagicMock())
b = MagicMock()
p.add_block("myblock", b)
b.set_parent.assert_called_once_with(p, "myblock")
req = p.q.put.call_args[0][0]
self.assertEqual(req.block, b)
def test_add_block(self):
p = Process("proc", MagicMock())
b = Block()
b.set_process_path(p, ("name",))
c = MagicMock()
p.add_block(b, c)
self.assertEqual(p._blocks["name"], b)
self.assertEqual(p._controllers["name"], c)
def test_add_block(self):
p = Process("proc", MagicMock())
b = Block()
b.set_process_path(p, ("name", ))
c = MagicMock()
p.add_block(b, c)
self.assertEqual(p._blocks["name"], b)
self.assertEqual(p._controllers["name"], c)
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_add_block_calls_handle(self):
s = SyncFactory("sched")
p = Process("proc", s)
b = Block()
c = MagicMock()
b.set_process_path(p, ("myblock",))
p.add_block(b, c)
p.start()
p.stop()
self.assertEqual(len(p._blocks), 2)
self.assertEqual(p._blocks, dict(myblock=b, proc=p.process_block))
def test_get_block(self):
p = Process("proc", MagicMock())
p.process_block["remoteBlocks"].set_value(['name1'])
b1 = p.get_block("name1")
self.assertEqual(b1.status, "Waiting for connection...")
self.assertEqual(p.get_block("name1"), b1)
b2 = Block()
b2.set_process_path(p, ("name2",))
c = MagicMock()
p.add_block(b2, c)
self.assertEqual(p.get_block("name2"), b2)
self.assertEqual(p.get_controller("name2"), c)
class TestSystemWSComms(unittest.TestCase):
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 tearDown(self):
self.sc.stop()
self.process.stop()
@gen.coroutine
def send_message(self):
conn = yield websocket_connect("ws://localhost:8888/ws")
req = dict(
type="Post",
id=0,
endpoint=["hello", "say_hello"],
parameters=dict(
name="me"
)
)
conn.write_message(json.dumps(req))
resp = yield conn.read_message()
resp = json.loads(resp)
self.assertEqual(resp, dict(
id=0,
type="Return",
value=dict(
greeting="Hello me"
)
))
conn.close()
def test_server_and_simple_client(self):
self.send_message()
def test_server_with_malcolm_client(self):
self.cc = WSClientComms("cc", self.process, "ws://localhost:8888/ws")
self.cc.start()
# Wait for comms to be connected
while not self.cc.conn.done():
time.sleep(0.001)
# Don't add to process as we already have a block of that name
block2 = Block("hello")
ClientController(self.process, block2, self.cc)
ret = block2.say_hello("me2")
self.assertEqual(ret, dict(greeting="Hello me2"))
self.cc.stop()
def test_get_block(self):
p = Process("proc", MagicMock())
p.process_block["remoteBlocks"].set_value(['name1'])
b1 = p.get_block("name1")
self.assertEqual(b1.status, "Waiting for connection...")
self.assertEqual(p.get_block("name1"), b1)
b2 = Block()
b2.set_process_path(p, ("name2", ))
c = MagicMock()
p.add_block(b2, c)
self.assertEqual(p.get_block("name2"), b2)
self.assertEqual(p.get_controller("name2"), c)
def test_starting_process(self):
s = SyncFactory("sched")
p = Process("proc", s)
b = MagicMock()
b.name = "myblock"
p.add_block(b)
self.assertEqual(p._blocks, dict(myblock=b))
p.start()
request = MagicMock()
request.endpoint = ["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_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"))
class TestSystemWSComms(unittest.TestCase):
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 tearDown(self):
self.sc.stop()
self.process.stop()
@gen.coroutine
def send_message(self):
conn = yield websocket_connect("ws://localhost:8888/ws")
req = dict(type="Post",
id=0,
endpoint=["hello", "say_hello"],
parameters=dict(name="me"))
conn.write_message(json.dumps(req))
resp = yield conn.read_message()
resp = json.loads(resp)
self.assertEqual(
resp, dict(id=0, type="Return", value=dict(greeting="Hello me")))
conn.close()
def test_server_and_simple_client(self):
self.send_message()
def test_server_with_malcolm_client(self):
self.cc = WSClientComms("cc", self.process, "ws://localhost:8888/ws")
self.cc.start()
# Wait for comms to be connected
while not self.cc.conn.done():
time.sleep(0.001)
# Don't add to process as we already have a block of that name
block2 = Block("hello")
ClientController(self.process, block2, self.cc)
ret = block2.say_hello("me2")
self.assertEqual(ret, dict(greeting="Hello me2"))
self.cc.stop()
def test_add_block(self):
p = Process("proc", MagicMock())
b = Block()
b.set_parent(p, "name")
p.add_block(b)
self.assertEqual(p._blocks["name"], b)
