async def test_non_existent(self):
c1, c2 = pipe_bidi()
srv = MockReqRespServer(c1)
cli = MockReqRespClient(c2)
async with srv, cli:
with self.assertRaises(CallFailed):
await wait_for(cli.non_existent(), 5)
async def test_echo(self):
c1, c2 = pipe_bidi()
srv = MockReqRespServer(c1)
cli = MockReqRespClient(c2)
async with srv, cli:
result: Message = await wait_for(cli.echo(), 5)
self.assertEqual(Message({}, []), result)
async def test_remote_clip_map(self):
c_client, c_server = pipe_bidi()
rs = MockScript({})
rss = RemoteScriptServer(rs, c_server)
rsc = RemoteScript(c_client)
async with timeout_context(rss, 10), timeout_context(rsc, 10):
clips = await wait_for(rsc.retrieve_clips(), 10)
self.assertEqual(len(clips), 1)
self.assertEqual(list(clips), ["test"])
async def test_clip_metadata_transmit(self):
c_client, c_server = pipe_bidi()
mock_clip = MockClip()
async with mock_clip:
server = ClipServer(mock_clip, c_server)
client = RemoteClip(c_client)
# Make sure the server is acquired first, as otherwise
# there will be a deadlock.
async with server, client:
self.assertEqual(await wait_for(client.get_metadata(), 5), {"id": id(mock_clip)})
async def test_clip_length(self):
c_client, c_server = pipe_bidi()
mock_clip = MockClip()
async with mock_clip:
server = ClipServer(mock_clip, c_server)
client = RemoteClip(c_client)
# Make sure the server is acquired first, as otherwise
# there will be a deadlock.
async with server, client:
self.assertEqual(len(client), len(mock_clip))
async def test_invalid_packet__unset_method(self):
c1, c2 = pipe_bidi()
srv = MockReqRespServer(c1)
async with srv, c2:
await c2.write(Message({'id': 0, 'type': 'request', 'params': {}}))
msg: Message = await wait_for(c2.read(), 5)
self.assertIsInstance(msg.values, dict)
self.assertIn('type', msg.values)
self.assertEqual('error', msg.values['type'])
self.assertIn('id', msg.values)
self.assertEqual(0, msg.values['id'])
self.assertIn('error', msg.values)
async def test_get_script(self):
c_client, c_server = pipe_bidi()
ms = MockScript({"id": id(self)})
sp = SingleScriptProvider(ms)
rsps = RemoteScriptProviderServer(sp, c_server)
rspc = RemoteScriptProvider(c_client)
async with timeout_context(rsps, 10), timeout_context(rspc, 10):
rsc = await rspc.get()
async with timeout_context(rsc, 10):
self.assertEqual(await wait_for(rsc.get_config("id"), 10),
id(self))
async def test_clip_frame_size(self):
c_client, c_server = pipe_bidi()
mock_frame = MockFrame()
mock_clip = SingleFrameMockClip(mock_frame)
async with mock_clip, mock_frame:
server = ClipServer(mock_clip, c_server)
client = RemoteClip(c_client)
# Make sure the server is acquired first, as otherwise
# there will be a deadlock.
async with timeout_context(server, 10), timeout_context(client, 10):
remote_frame = client[0]
async with remote_frame:
self.assertEqual(remote_frame.size, mock_frame.size)
async def test_clip_frame_render(self):
c_client, c_server = pipe_bidi()
mock_clip = MockClip()
async with mock_clip:
server = ClipServer(mock_clip, c_server)
client = RemoteClip(c_client)
# Make sure the server is acquired first, as otherwise
# there will be a deadlock.
async with timeout_context(server, 10), timeout_context(client, 10):
remote_frame = client[0]
async with remote_frame:
data = bytearray(remote_frame.native_format.get_plane_size(0, remote_frame.size))
self.assertEqual(await remote_frame.render_into(data, 0, remote_frame.native_format, 0), 0)
async def test_multiplexer_reject(self):
c_faked_networking, c_multiplexed = pipe_bidi()
muliplexer = Multiplexer(c_multiplexed)
async with c_faked_networking, muliplexer:
await c_faked_networking.write(
Message({
'target': 'non-existent',
'payload': {}
}))
msg: Message = await wait_for(c_faked_networking.read(), 5)
self.assertIsInstance(msg.values, dict)
self.assertIn('type', msg.values)
self.assertEqual('close', msg.values['type'])
async def test_clip_frame_can_render(self):
c_client, c_server = pipe_bidi()
mock_clip = MockClip()
async with mock_clip:
server = ClipServer(mock_clip, c_server)
client = RemoteClip(c_client)
# Make sure the server is acquired first, as otherwise
# there will be a deadlock.
async with timeout_context(server, 10), timeout_context(client, 10):
remote_frame = client[0]
async with remote_frame:
self.assertFalse(await remote_frame.can_render(GRAY8))
self.assertTrue(await remote_frame.can_render(RGB24))
async def test_clip_frame_metadata(self):
c_client, c_server = pipe_bidi()
mock_frame = MockFrame()
mock_clip = SingleFrameMockClip(mock_frame)
async with mock_clip, mock_frame:
server = ClipServer(mock_clip, c_server)
client = RemoteClip(c_client)
# Make sure the server is acquired first, as otherwise
# there will be a deadlock.
async with timeout_context(server, 10), timeout_context(client, 10):
remote_frame = client[0]
async with remote_frame:
metadata = await wait_for(remote_frame.get_metadata(), 5)
self.assertEqual(metadata, {"id": id(mock_frame)})
async def test_multiplexer_illegal(self):
c_faked_networking, c_multiplexed = pipe_bidi()
muliplexer = Multiplexer(c_multiplexed)
async with c_faked_networking, muliplexer:
async with muliplexer.connect('existing') as f:
await c_faked_networking.write(
Message({
'target': 'existing',
'type': 'message'
}))
msg: Message = await wait_for(c_faked_networking.read(), 5)
self.assertIsInstance(msg.values, dict)
self.assertIn('type', msg.values)
self.assertEqual('illegal', msg.values['type'])
async def test_multiplexer_forward_close(self):
c_m1, c_m2 = pipe_bidi()
m1 = Multiplexer(c_m1)
m2 = Multiplexer(c_m2)
async with m1, m2:
m1_ch = m1.connect('channel')
m2_ch = m2.connect('channel')
async with m1_ch, m2_ch:
await m1_ch.close()
self.assertTrue(m1_ch.closed)
await wait_for(m2_ch.read(), 5)
self.assertTrue(m2_ch.closed)
async def test_multiplexer_delivered(self):
value = {'v': 'test'}
c_faked_networking, c_multiplexed = pipe_bidi()
muliplexer = Multiplexer(c_multiplexed)
async with c_faked_networking, muliplexer:
async with muliplexer.connect('existing') as f:
await c_faked_networking.write(
Message({
'target': 'existing',
'type': 'message',
'payload': value
}))
msg: Message = await wait_for(f.read(), 5)
self.assertIs(value, msg.values)
async def test_remote_script_run(self):
c_client, c_server = pipe_bidi()
rs = MockScript({})
rss = RemoteScriptServer(rs, c_server)
rsc = RemoteScript(c_client)
async with timeout_context(rss, 10), timeout_context(rsc, 10):
await wait_for(rsc.run("test-code-string"), 10)
self.assertEqual(
await wait_for(rsc.get_config("last-command"), 10),
"test-code-string")
await wait_for(rsc.run(b"test-code-binary"), 10)
self.assertEqual(
await wait_for(rsc.get_config("last-command"), 10),
b"test-code-binary")
async def test_multiplexer_send(self):
values = {}
c_faked_networking, c_multiplexed = pipe_bidi()
muliplexer = Multiplexer(c_multiplexed)
async with c_faked_networking, muliplexer:
async with muliplexer.connect('existing') as f:
await f.write(Message(values, []))
msg: Message = await wait_for(c_faked_networking.read(), 5)
self.assertIsInstance(msg.values, dict)
self.assertIn('target', msg.values)
self.assertEqual('existing', msg.values['target'])
self.assertIn('type', msg.values)
self.assertEqual('message', msg.values['type'])
self.assertIn('payload', msg.values)
self.assertIs(values, msg.values['payload'])
async def test_bidi_multiplexer_comm(self):
c_m1, c_m2 = pipe_bidi()
m1 = Multiplexer(c_m1)
m2 = Multiplexer(c_m2)
async with m1, m2:
m1_ch = m1.connect('channel')
m2_ch = m2.connect('channel')
async with m1_ch, m2_ch:
await m1_ch.write(Message({'someval': 123456}))
msg: Message = await m2_ch.read()
self.assertIsInstance(msg.values, dict)
self.assertIn('someval', msg.values)
self.assertEqual(123456, msg.values['someval'])
self.assertTrue(m1_ch.closed)
self.assertTrue(m2_ch.closed)
async def test_remote_script_config(self):
c_client, c_server = pipe_bidi()
rs = MockScript({
"test-int": 1,
"test-bytes": b"abc",
"test-null": None,
"test-string": "foo",
"test-float": 3.1415926
})
unset = object()
rss = RemoteScriptServer(rs, c_server)
rsc = RemoteScript(c_client)
async with timeout_context(rss, 10), timeout_context(rsc, 10):
self.assertEqual(await wait_for(rsc.list_config(), 10), [
"test-int", "test-bytes", "test-null", "test-string",
"test-float"
])
self.assertEqual(await wait_for(rsc.get_config("test-int"), 10), 1)
self.assertEqual(await wait_for(rsc.get_config("test-bytes"), 10),
b"abc")
self.assertIsNone(await wait_for(rsc.get_config("test-null"), 10))
self.assertEqual(await wait_for(rsc.get_config("test-float"), 10),
3.1415926)
self.assertEqual(await wait_for(rsc.get_config("test-string"), 10),
"foo")
with self.assertRaises(KeyError):
await wait_for(rsc.get_config("test-unset"), 10)
self.assertIs(
await wait_for(rsc.get_config("test-unset", unset), 10), unset)
for val in [2, b"def", None, 6.2831852, "bar"]:
await wait_for(rsc.set_config("test-set", val), 10)
self.assertEqual(await wait_for(rsc.list_config(), 10), [
"test-int", "test-bytes", "test-null", "test-string",
"test-float", "test-set"
])
self.assertEqual(
await wait_for(rsc.get_config("test-set"), 10), val)
async def test_multiplexer_channel_death(self):
c_faked_networking, c_multiplexed = pipe_bidi()
muliplexer = Multiplexer(c_multiplexed)
async with c_faked_networking, muliplexer:
async with muliplexer.connect('temporary'):
pass
msg: Message = await wait_for(c_faked_networking.read(), 5)
self.assertIsInstance(msg.values, dict)
self.assertIn('type', msg.values)
self.assertEqual('close', msg.values['type'])
await c_faked_networking.write(
Message({
'target': 'temporary',
'payload': {}
}))
msg: Message = await wait_for(c_faked_networking.read(), 5)
self.assertIsInstance(msg.values, dict)
self.assertIn('type', msg.values)
self.assertEqual('close', msg.values['type'])
