def test_command_message_existing_body(self):
# Given
node_uri = 'foo_command_node'
lane_uri = 'bar_command_lane'
body = Text.create_from('Command_Body')
# When
actual = CommandMessage(node_uri, lane_uri, body)
# Then
self.assertEqual('foo_command_node', actual.node_uri)
self.assertEqual('bar_command_lane', actual.lane_uri)
self.assertEqual('command', actual.tag)
self.assertEqual('foo_command_node/bar_command_lane', actual.route)
self.assertEqual(body, actual.body)
self.assertIsInstance(actual.form, CommandMessageForm)
def test_synced_response_existing_body(self):
# Given
node_uri = 'foo_synced_node'
lane_uri = 'bar_synced_lane'
body = Text.create_from('Synced_Body')
# When
actual = SyncedResponse(node_uri, lane_uri, body=body)
# Then
self.assertEqual('foo_synced_node', actual.node_uri)
self.assertEqual('bar_synced_lane', actual.lane_uri)
self.assertEqual('synced', actual.tag)
self.assertEqual('foo_synced_node/bar_synced_lane', actual.route)
self.assertEqual(body, actual.body)
self.assertIsInstance(actual.form, SyncedResponseForm)
def test_record_parser_parse_existing_key_multiple(self):
# Given
message = _InputMessage._create(':dog, test:bar')
parser = _ReconParser()
key = Text.create_from('animal')
# When
actual = parser._parse_record(message, key_output=key)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('animal', actual.get_item(0).key.value)
self.assertEqual('dog', actual.get_item(0).value.value)
self.assertEqual('test', actual.get_item(1).key.value)
self.assertEqual('bar', actual.get_item(1).value.value)
def test_record_parser_parse_existing_value_multiple(self):
# Given
message = _InputMessage._create('animal, test:foo')
parser = _ReconParser()
value = Text.create_from('cat')
# When
actual = parser._parse_record(message, value_output=value)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('animal', actual.get_item(0).key.value)
self.assertEqual('cat', actual.get_item(0).value.value)
self.assertEqual('test', actual.get_item(1).key.value)
self.assertEqual('foo', actual.get_item(1).value.value)
def test_write_sync_prio_rate(self):
# Given
envelope = _SyncRequest('bar/baz/',
'foo/bar',
prio=33.2,
rate=0.3,
body=Text.create_from('Hello, World!'))
expected = '@sync(node:"bar/baz/",lane:"foo/bar",prio:33.2,rate:0.3)"Hello, World!"'
# When
actual = envelope._to_recon()
# Then
self.assertEqual(expected, actual)
def test_event_message_existing_body(self):
# Given
node_uri = 'foo_event_node'
lane_uri = 'bar_event_lane'
body = Text.create_from('Event_Body')
# When
actual = EventMessage(node_uri, lane_uri, body)
# Then
self.assertEqual('foo_event_node', actual.node_uri)
self.assertEqual('bar_event_lane', actual.lane_uri)
self.assertEqual('foo_event_node/bar_event_lane', actual.route)
self.assertEqual('event', actual.tag)
self.assertEqual(body, actual.body)
self.assertIsInstance(actual.form, EventMessageForm)
def test_write_link_prio_rate(self):
# Given
envelope = _LinkRequest('/unit/5',
'/unit/3',
prio=22.11,
rate=0.2,
body=Text.create_from('spam and \\ham/'))
expected = '@link(node:"/unit/5",lane:"/unit/3",prio:22.11,rate:0.2)"spam and \\ham/"'
# When
actual = envelope._to_recon()
# Then
self.assertEqual(expected, actual)
async def test_write_unlinked_prio_rate(self):
# Given
envelope = UnlinkedResponse('/unit/5',
'/unit/3',
prio=22.11,
rate=0.2,
body=Text.create_from('spam and \\ham/'))
expected = '@unlinked(node:"/unit/5",lane:"/unit/3",prio:22.11,rate:0.2)"spam and \\ham/"'
# When
actual = await envelope.to_recon()
# Then
self.assertEqual(expected, actual)
def test_sync_form_mold(self):
# Given
form = SyncRequestForm()
envelope = SyncRequest('sync_node', 'sync_lane', prio=99.1, rate=41.42, body=Text.create_from('Moo'))
# When
actual = form.mold(envelope)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('sync', actual.tag)
self.assertEqual('sync_node', actual.get_item(0).value.get_item(0).value.value)
self.assertEqual('sync_lane', actual.get_item(0).value.get_item(1).value.value)
self.assertEqual(99.1, actual.get_item(0).value.get_item(2).value.value)
self.assertEqual(41.42, actual.get_item(0).value.get_item(3).value.value)
self.assertEqual('Moo', actual.get_item(1).value)
def test_parse_literal_ident_existing_builder(self):
# Given
message = _InputMessage._create('foo')
builder = _ReconParser._create_value_builder()
builder.add(Text.create_from('bar'))
parser = _ReconParser()
# When
actual = parser._parse_literal(message, builder)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertIsInstance(actual.get_item(0), Text)
self.assertIsInstance(actual.get_item(1), Text)
self.assertEqual('bar', actual.get_item(0).value)
self.assertEqual('foo', actual.get_item(1).value)
def test_link_form_mold(self):
# Given
form = LinkRequestForm()
envelope = LinkRequest('link_node', 'link_lane', prio=1, rate=2, body=Text.create_from('Moo'))
# When
actual = form.mold(envelope)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('link', actual.tag)
self.assertEqual('link_node', actual.get_item(0).value.get_item(0).value.value)
self.assertEqual('link_lane', actual.get_item(0).value.get_item(1).value.value)
self.assertEqual(1, actual.get_item(0).value.get_item(2).value.value)
self.assertEqual(2, actual.get_item(0).value.get_item(3).value.value)
self.assertEqual('Moo', actual.get_item(1).value)
def test_unlinked_form_cast(self):
# Given
form = UnlinkedResponseForm()
items = RecordMap.create()
items.add(Slot.create_slot(Text.create_from('node'), Text.create_from('unlinked_node')))
items.add(Slot.create_slot(Text.create_from('lane'), Text.create_from('unlinked_lane')))
items.add(Slot.create_slot(Text.create_from('prio'), Num.create_from(20)))
items.add(Slot.create_slot(Text.create_from('rate'), Num.create_from(25)))
body = Attr.create_attr(Text.create_from('body'), Text.create_from('unlinked_body'))
record_map = RecordMap.create()
record_map.add(Attr.create_attr(Text.create_from('unlinked'), items))
record_map.add(body)
# When
actual = form.cast(record_map)
# Then
self.assertIsInstance(actual, UnlinkedResponse)
self.assertEqual('unlinked_node', actual.node_uri)
self.assertEqual('unlinked_lane', actual.lane_uri)
self.assertEqual(20, actual.prio)
self.assertEqual(25, actual.rate)
self.assertEqual(body, actual.body.get_item(0))
def test_link_form_cast(self):
# Given
form = LinkRequestForm()
items = RecordMap.create()
items.add(Slot.create_slot(Text.create_from('node'), Text.create_from('link_node')))
items.add(Slot.create_slot(Text.create_from('lane'), Text.create_from('link_lane')))
items.add(Slot.create_slot(Text.create_from('prio'), Num.create_from(1)))
items.add(Slot.create_slot(Text.create_from('rate'), Num.create_from(3)))
body = Attr.create_attr(Text.create_from('body'), Text.create_from('link_body'))
record_map = RecordMap.create()
record_map.add(Attr.create_attr(Text.create_from('link'), items))
record_map.add(body)
# When
actual = form.cast(record_map)
# Then
self.assertIsInstance(actual, LinkRequest)
self.assertEqual('link_node', actual.node_uri)
self.assertEqual('link_lane', actual.lane_uri)
self.assertEqual(1, actual.prio)
self.assertEqual(3, actual.rate)
self.assertEqual(body, actual.body.get_item(0))
def test_linked_response_existing_body(self):
# Given
node_uri = 'foo_linked_node'
lane_uri = 'bar_linked_lane'
body = Text.create_from('Linked_Body')
priority = 1.13
rate = 3.11
# When
actual = _LinkedResponse(node_uri, lane_uri, priority, rate, body)
# Then
self.assertEqual('foo_linked_node', actual._node_uri)
self.assertEqual('bar_linked_lane', actual._lane_uri)
self.assertEqual('linked', actual._tag)
self.assertEqual('foo_linked_node/bar_linked_lane', actual._route)
self.assertEqual(body, actual._body)
self.assertIsInstance(actual._form, _LinkedResponseForm)
def test_unlinked_response_existing_body(self):
# Given
node_uri = 'foo_unlinked_node'
lane_uri = 'bar_unlinked_lane'
body = Text.create_from('Unlinked_Body')
priority = 5.11
rate = 6.13
# When
actual = UnlinkedResponse(node_uri, lane_uri, priority, rate, body)
# Then
self.assertEqual('foo_unlinked_node', actual.node_uri)
self.assertEqual('bar_unlinked_lane', actual.lane_uri)
self.assertEqual('unlinked', actual.tag)
self.assertEqual('foo_unlinked_node/bar_unlinked_lane', actual.route)
self.assertEqual(body, actual.body)
self.assertIsInstance(actual.form, UnlinkedResponseForm)
def test_link_request_existing_body(self):
# Given
node_uri = 'foo_link_node'
lane_uri = 'bar_link_lane'
body = Text.create_from('Link_Body')
priority = 13.1
rate = 11.3
# When
actual = LinkRequest(node_uri, lane_uri, priority, rate, body)
# Then
self.assertEqual('foo_link_node', actual.node_uri)
self.assertEqual('bar_link_lane', actual.lane_uri)
self.assertEqual('link', actual.tag)
self.assertEqual('foo_link_node/bar_link_lane', actual.route)
self.assertEqual(body, actual.body)
self.assertIsInstance(actual.form, LinkRequestForm)
def test_swim_client_command(self, mock_websocket_connect):
# Given
host_uri = 'ws://*****:*****@command(node:moo,lane:cow)"Hello, World!"'
with SwimClient() as swim_client:
# When
actual = swim_client.command(host_uri, node_uri, lane_uri, Text.create_from('Hello, World!'))
while not actual.done():
pass
# Then
self.assertIsInstance(actual, futures.Future)
mock_websocket_connect.assert_called_once_with(host_uri)
self.assertEqual(expected, MockWebsocket.get_mock_websocket().sent_messages[0])
def test_unlinked_form_create_envelope(self):
# Given
form = _UnlinkedResponseForm()
body = Text.create_from('unlinked_body')
# When
actual = form._create_envelope_from('oof',
'bar',
prio=2,
rate=6,
body=body)
# Then
self.assertIsInstance(actual, _UnlinkedResponse)
self.assertEqual('oof', actual._node_uri)
self.assertEqual('bar', actual._lane_uri)
self.assertEqual(2, actual._prio)
self.assertEqual(6, actual._rate)
self.assertEqual(body, actual._body)
def test_event_form_mold(self):
# Given
form = _EventMessageForm()
envelope = _EventMessage('event_node',
'event_lane',
body=Text.create_from('Event_body'))
# When
actual = form._mold(envelope)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('event', actual._tag)
self.assertEqual('event_node',
actual.get_item(0).value.get_item(0).value.value)
self.assertEqual('event_lane',
actual.get_item(0).value.get_item(1).value.value)
self.assertEqual('Event_body', actual.get_item(1).value)
def test_link_form_create_envelope(self):
# Given
form = _LinkRequestForm()
body = Text.create_from('link_body')
# When
actual = form._create_envelope_from('moo',
'cow',
prio=0.13,
rate=0.26,
body=body)
# Then
self.assertIsInstance(actual, _LinkRequest)
self.assertEqual('moo', actual._node_uri)
self.assertEqual('cow', actual._lane_uri)
self.assertEqual(0.13, actual._prio)
self.assertEqual(0.26, actual._rate)
self.assertEqual(body, actual._body)
def test_linked_form_create_envelope(self):
# Given
form = _LinkedResponseForm()
body = Text.create_from('linked_body')
# When
actual = form._create_envelope_from('boo',
'far',
prio=1.13,
rate=2.26,
body=body)
# Then
self.assertIsInstance(actual, _LinkedResponse)
self.assertEqual('boo', actual._node_uri)
self.assertEqual('far', actual._lane_uri)
self.assertEqual(1.13, actual._prio)
self.assertEqual(2.26, actual._rate)
self.assertEqual(body, actual._body)
def test_synced_form_mold(self):
# Given
form = _SyncedResponseForm()
envelope = _SyncedResponse('foo_node',
'bar_lane',
body=Text.create_from('Boo'))
# When
actual = form._mold(envelope)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('synced', actual._tag)
self.assertEqual('foo_node',
actual.get_item(0).value.get_item(0).value.value)
self.assertEqual('bar_lane',
actual.get_item(0).value.get_item(1).value.value)
self.assertEqual('Boo', actual.get_item(1).value)
def test_sync_form_create_envelope(self):
# Given
form = _SyncRequestForm()
body = Text.create_from('sync_body')
# When
actual = form._create_envelope_from('foo',
'bar',
prio=3.2,
rate=2.1,
body=body)
# Then
self.assertIsInstance(actual, _SyncRequest)
self.assertEqual('foo', actual._node_uri)
self.assertEqual('bar', actual._lane_uri)
self.assertEqual(3.2, actual._prio)
self.assertEqual(2.1, actual._rate)
self.assertEqual(body, actual._body)
def test_sync_request_existing_body(self):
# Given
node_uri = 'foo_sync_node'
lane_uri = 'bar_sync_lane'
body = Text.create_from('Sync_Body')
priority = 3.5
rate = 2.0
# When
actual = SyncRequest(node_uri, lane_uri, priority, rate, body=body)
# Then
self.assertEqual('foo_sync_node', actual.node_uri)
self.assertEqual('bar_sync_lane', actual.lane_uri)
self.assertEqual(3.5, actual.prio)
self.assertEqual(2.0, actual.rate)
self.assertEqual('sync', actual.tag)
self.assertEqual('foo_sync_node/bar_sync_lane', actual.route)
self.assertEqual(body, actual.body)
self.assertIsInstance(actual.form, SyncRequestForm)
def test_event_form_cast(self):
# Given
form = EventMessageForm()
items = RecordMap.create()
items.add(Slot.create_slot(Text.create_from('node'), Text.create_from('event_node')))
items.add(Slot.create_slot(Text.create_from('lane'), Text.create_from('event_lane')))
body = Attr.create_attr(Text.create_from('body'), Text.create_from('event_body'))
record_map = RecordMap.create()
record_map.add(Attr.create_attr(Text.create_from('event'), items))
record_map.add(body)
# When
actual = form.cast(record_map)
# Then
self.assertIsInstance(actual, EventMessage)
self.assertEqual('event_node', actual.node_uri)
self.assertEqual('event_lane', actual.lane_uri)
self.assertEqual(body, actual.body.get_item(0))
def test_unlinked_form_mold(self):
# Given
form = _UnlinkedResponseForm()
envelope = _LinkedResponse('unlinked_node',
'unlinked_lane',
prio=9,
rate=10,
body=Text.create_from('Baz'))
# When
actual = form._mold(envelope)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('unlinked', actual._tag)
self.assertEqual('unlinked_node',
actual.get_item(0).value.get_item(0).value.value)
self.assertEqual('unlinked_lane',
actual.get_item(0).value.get_item(1).value.value)
self.assertEqual(9, actual.get_item(0).value.get_item(2).value.value)
self.assertEqual(10, actual.get_item(0).value.get_item(3).value.value)
self.assertEqual('Baz', actual.get_item(1).value)
async def test_downlink_model_receive_message_event(self):
# Given
with SwimClient() as client:
downlink = ValueDownlinkModel(client)
downlink.connection = MockConnection.get_mock_connection()
downlink.connection.owner = downlink
downlink_manager = DownlinkManager(downlink.connection)
downlink.downlink_manager = downlink_manager
event_message = EventMessage(
'event_node', 'event_lane',
Record.create_from(Text.create_from('event_body')))
downlink.connection.messages_to_receive.append(event_message)
# When
actual = downlink.open()
while not actual.value:
pass
# Then
self.assertEqual(downlink, actual)
self.assertEqual('event_body', actual.value.value)
def test_block_writer_nested_attributes(self):
# Given
items = list()
name_record = _Record.create()
name_record.add(Slot.create_slot(Text.create_from('Name'), Text.create_from('Collie')))
breed_record = _Record.create()
breed_record.add(Attr.create_attr(Text.create_from('Breed'), name_record))
dog_record = _Record.create()
dog_record.add(Slot.create_slot(Text.create_from('Dog'), breed_record))
species_record = _Record.create()
species_record.add(Attr.create_attr(Text.create_from('Species'), dog_record))
animals_record = _Record.create()
animals_record.add(Slot.create_slot(Text.create_from('Animals'), species_record))
items.append(Attr.create_attr(Text.create_from('Zoo'), animals_record))
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer, first=True)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('@Zoo(Animals:@Species(Dog:@Breed(Name:Collie)))', actual._message)
def test_command_form_cast(self):
# Given
form = _CommandMessageForm()
items = RecordMap.create()
items.add(
Slot.create_slot(Text.create_from('node'),
Text.create_from('command_node')))
items.add(
Slot.create_slot(Text.create_from('lane'),
Text.create_from('command_lane')))
body = Attr.create_attr(Text.create_from('body'),
Text.create_from('command_body'))
record_map = RecordMap.create()
record_map.add(Attr.create_attr(Text.create_from('command'), items))
record_map.add(body)
# When
actual = form._cast(record_map)
# Then
self.assertIsInstance(actual, _CommandMessage)
self.assertEqual('command_node', actual._node_uri)
self.assertEqual('command_lane', actual._lane_uri)
self.assertEqual(body, actual._body.get_item(0))
def test_write_event_body_nested(self):
# Given
friend = RecordMap.create()
friend.add(
Attr.create_attr(Text.create_from('Person'),
_Extant._get_extant()))
friend.add(
Slot.create_slot(Text.create_from('name'),
Text.create_from('Sam/Spam')))
friend.add(
Slot.create_slot(Text.create_from('age'), Num.create_from(1)))
friend.add(
Slot.create_slot(Text.create_from('salary'), Num.create_from(22)))
body = RecordMap.create()
body.add(
Attr.create_attr(Text.create_from('Person'),
_Extant._get_extant()))
body.add(
Slot.create_slot(Text.create_from('name'),
Text.create_from('Par')))
body.add(Slot.create_slot(Text.create_from('age'),
Num.create_from(11)))
body.add(
Slot.create_slot(Text.create_from('salary'),
Num.create_from(-5.9)))
body.add(Slot.create_slot(Text.create_from('friend'), friend))
envelope = _EventMessage('/this/is/spam', 'hello', body=body)
person = '@Person{name:Par,age:11,salary:-5.9,friend:@Person{name:"Sam/Spam",age:1,salary:22}}'
expected = '@event(node:"/this/is/spam",lane:hello)' + person
# When
actual = envelope._to_recon()
# Then
self.assertEqual(expected, actual)