def test_write_item_attr(self):
# Given
item = Attr.create_attr(Text.create_from('Cat'), Text.create_from('Meow'))
writer = _ReconWriter()
# When
actual = writer._write_item(item)
# Then
self.assertIsInstance(actual, str)
self.assertEqual('@Cat(Meow)', actual)
def test_block_writer_slot_single_not_first(self):
# Given
items = list()
items.append(Slot.create_slot(Text.create_from('cat'), Text.create_from('meow')))
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer, first=False)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual(',cat:meow', actual._message)
def test_block_writer_attr(self):
# Given
items = list()
items.append(Attr.create_attr(Text.create_from('dog'), Text.create_from('bark')))
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('@dog(bark)', actual._message)
def test_attr_writer_existing_key_and_value_text(self):
# Given
key = Text.create_from('bird')
value = Text.create_from('chirp')
writer = _ReconWriter()
# When
actual = _AttrWriter._write(key=key, writer=writer, value=value)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('@bird(chirp)', actual._message)
def test_slot_writer_existing_key_and_value(self):
# Given
key = Text.create_from('animal')
value = Text.create_from('dog')
writer = _ReconWriter()
# When
actual = _SlotWriter._write(key=key, writer=writer, value=value)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('animal:dog', actual._value)
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_block_writer_multiple_attributes(self):
# Given
items = list()
record_map = _Record.create()
dog_map = _Record.create()
dog_map.add(Slot.create_slot(Text.create_from('dog'), Text.create_from('bark')))
record_map.add(Attr.create_attr(Text.create_from('Animal'), dog_map))
cat_map = _Record.create()
cat_map.add(Slot.create_slot(Text.create_from('cat'), Text.create_from('meow')))
record_map.add(Attr.create_attr(Text.create_from('Animal'), cat_map))
bird_map = _Record.create()
bird_map.add(Slot.create_slot(Text.create_from('bird'), Text.create_from('chirp')))
record_map.add(Attr.create_attr(Text.create_from('Animal'), bird_map))
items.append(record_map)
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer, first=True)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('@Animal(dog:bark)@Animal(cat:meow)@Animal(bird:chirp)', actual._message)
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_block_writer_slot_multiple(self):
# Given
items = list()
items.append(Slot.create_slot(Text.create_from('dog'), Text.create_from('bark')))
items.append(Slot.create_slot(Text.create_from('cat'), Text.create_from('meow')))
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer, first=True)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('dog:bark,cat:meow', actual._message)
def test_block_writer_text_multiple(self):
# Given
items = list()
items.append(Text.create_from('foo_'))
items.append(Text.create_from('bar'))
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('foo_bar', actual._message)
def test_attr_writer_existing_key_and_value_slot(self):
# Given
key = Text.create_from('animal')
value = _Record.create()
value.add(Slot.create_slot(Text.create_from('dog'), Text.create_from('bark')))
writer = _ReconWriter()
# When
actual = _AttrWriter._write(key=key, writer=writer, value=value)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('@animal(dog:bark)', actual._message)
def test_lane_addressed_form_cast_missing_lane(self):
# Given
form = SyncedResponseForm()
items = RecordMap.create()
items.add(Attr.create_attr(Text.create_from('node'), Text.create_from('foo_node')))
record_map = RecordMap.create()
record_map.add(Attr.create_attr(Text.create_from('synced'), items))
# When
actual = form.cast(record_map)
# Then
self.assertEqual(None, actual)
def test_write_value_record(self):
# Given
record = _Record.create()
record.add(Slot.create_slot(Text.create_from('Cow'), Text.create_from('Moo')))
writer = _ReconWriter()
# When
actual = writer._write_value(record)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual(7, actual._size)
self.assertEqual('Cow:Moo', actual._value)
self.assertEqual('o', actual._last_char)
def test_write_attr(self):
# Given
key = Text.create_from('Hello')
value = Text.create_from('Friend')
writer = _ReconWriter()
# When
actual = writer._write_attr(key, value)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual(14, actual._size)
self.assertEqual('@Hello(Friend)', actual._value)
self.assertEqual(')', actual._last_char)
def test_block_writer_slot_in_attr(self):
# Given
items = list()
record_map = _Record.create()
record_map.add(Slot.create_slot(Text.create_from('cat'), Text.create_from('meow')))
items.append(Attr.create_attr(Text.create_from('animal'), record_map))
writer = _ReconWriter()
# When
actual = _BlockWriter._write(items, writer=writer, first=True)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual('@animal(cat:meow)', actual._message)
def test_to_string(self):
# Given
value = RecordMap.create()
value.add(
Attr.create_attr(
Text.create_from('remove'),
RecordMap.create_record_map(
Slot.create_slot(Text.create_from('key'),
Text.create_from('foo')))))
# When
actual = Recon.to_string(value)
# Then
self.assertEqual('@remove(key:foo)', actual)
async def test_record_parser_parse_existing_builder_empty(self):
# Given
message = await InputMessage.create('')
parser = ReconParser()
builder = await parser.create_record_builder()
builder.add(await parser.create_slot(Text.create_from('cow'), Text.create_from('moo')))
# When
actual = await parser.parse_record(message, builder=builder)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(1, actual.size)
self.assertEqual('cow', actual.get_item(0).key.value)
self.assertEqual('moo', actual.get_item(0).value.value)
def test_link_addressed_form_cast_missing_node(self):
# Given
form = _SyncRequestForm()
items = RecordMap.create()
items.add(
Attr.create_attr(Text.create_from('lane'),
Text.create_from('sync_foo_lane')))
record_map = RecordMap.create()
record_map.add(Attr.create_attr(Text.create_from('sync'), items))
# When
actual = form._cast(record_map)
# Then
self.assertEqual(None, actual)
def test_write_record_multiple(self):
# Given
record = _Record.create()
record.add(Text.create_from('Dog'))
record.add(Text.create_from('Cat'))
writer = _ReconWriter()
# When
actual = writer._write_record(record)
# Then
self.assertIsInstance(actual, _OutputMessage)
self.assertEqual(6, actual._size)
self.assertEqual('DogCat', actual._value)
self.assertEqual('t', actual._last_char)
def test_parse_attr_existing_key_and_value(self):
# Given
message = _InputMessage._create('')
parser = _ReconParser()
key_output = Text.create_from('Baz')
value_output = Text.create_from('Qux')
# When
actual = parser._parse_attr(message, key_output, value_output)
# Then
self.assertIsInstance(actual, Attr)
self.assertIsInstance(actual.key, Text)
self.assertIsInstance(actual.value, Text)
self.assertEqual('Baz', actual.key.value)
self.assertEqual('Qux', actual.value.value)
async def test_attr_expression_parser_parse_literal_existing_value(self):
# Given
message = await InputMessage.create('literal')
parser = ReconParser()
builder = RecordMap.create()
builder.add(Text.create_from('Moo'))
value = Text.create_from('Dog')
# When
actual = await parser.parse_attr_expression(message, builder=builder, value_output=value)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(3, actual.size)
self.assertEqual('Moo', actual.get_item(0).value)
self.assertEqual('Dog', actual.get_item(1).value)
self.assertEqual('literal', actual.get_item(2).value)
async def test_attr_expression_parser_parse_attribute_existing_field(self):
# Given
message = await InputMessage.create('@test')
parser = ReconParser()
builder = RecordMap.create()
builder.add(Text.create_from('Moo'))
field = Text.create_from('Boo')
# When
actual = await parser.parse_attr_expression(message, builder=builder, field_output=field)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(3, actual.size)
self.assertEqual('Moo', actual.get_item(0).value)
self.assertEqual('Boo', actual.get_item(1).value)
self.assertEqual('test', actual.get_item(2).key.value)
def _create_ident(value: str) -> 'Value':
if value == 'true':
return Bool.create_from(True)
elif value == 'false':
return Bool.create_from(False)
return Text.create_from(value)
def _parse(message: '_InputMessage' = None,
parser: '_ReconParser' = None,
output: '_OutputMessage' = None) -> 'Text':
message._skip_spaces(message)
char = message._head
if char == '"':
if output is None:
output = _OutputMessage._create()
char = message._step()
while char != '"' and message._is_cont:
output._append(char)
char = message._step()
message._step()
if output is None:
output = _OutputMessage()
return Text.create_from(output._value)
async def parse(message: 'InputMessage' = None,
parser: 'ReconParser' = None,
output: 'OutputMessage' = None) -> 'Text':
await message.skip_spaces(message)
char = message.head
if char == '"':
if output is None:
output = await OutputMessage.create()
char = message.step()
while char != '"' and message.is_cont:
await output.append(char)
char = message.step()
message.step()
if output is None:
output = OutputMessage()
return Text.create_from(output.value)
def test_record_parser_parse_existing_builder_single(self):
# Given
message = _InputMessage._create(' cat: meow')
parser = _ReconParser()
builder = parser._create_record_builder()
builder.add(
parser._create_slot(Text.create_from('dog'),
Text.create_from('bark')))
# When
actual = parser._parse_record(message, builder=builder)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(2, actual.size)
self.assertEqual('dog', actual.get_item(0).key.value)
self.assertEqual('bark', actual.get_item(0).value.value)
self.assertEqual('cat', actual.get_item(1).key.value)
self.assertEqual('meow', actual.get_item(1).value.value)
def to_record(self) -> '_Record':
key_slot = self.get_key_item()
value_slot = self.get_value_item()
update_record = RecordMap.create_record_map(
Attr.create_attr(Text.create_from('update'), key_slot))
update_record.add(value_slot)
return update_record
def get_key_item(self) -> 'Record':
key_slot = RecordMap.create()
key_slot.add(
Slot.create_slot(
Text.create_from('key'),
RecordConverter.get_converter().object_to_record(self.key)))
return key_slot
def test_parse_literal_quote_existing_builder(self):
# Given
message = _InputMessage._create('"Hello_World"')
builder = _ReconParser._create_value_builder()
parser = _ReconParser()
builder.add(Text.create_from('Hi'))
builder.add(Text.create_from('Bye'))
# When
actual = parser._parse_literal(message, builder)
# Then
self.assertIsInstance(actual, RecordMap)
self.assertEqual(3, actual.size)
self.assertIsInstance(actual.get_item(0), Text)
self.assertIsInstance(actual.get_item(1), Text)
self.assertIsInstance(actual.get_item(2), Text)
self.assertEqual('Hi', actual.get_item(0).value)
self.assertEqual('Bye', actual.get_item(1).value)
self.assertEqual('Hello_World', actual.get_item(2).value)
def test_parse_literal_minus_existing_builder(self):
# Given
message = _InputMessage._create(' 37')
parser = _ReconParser()
builder = _ReconParser._create_value_builder()
builder.add(Text.create_from('Hello'))
builder.add(Text.create_from('Friend'))
# When
actual = parser._parse_literal(message, builder)
# Then
self.assertEqual(3, actual.size)
self.assertIsInstance(actual, RecordMap)
self.assertIsInstance(actual.get_item(0), Text)
self.assertIsInstance(actual.get_item(1), Text)
self.assertIsInstance(actual.get_item(2), Num)
self.assertEqual('Hello', actual.get_item(0).value)
self.assertEqual('Friend', actual.get_item(1).value)
self.assertEqual(37, actual.get_item(2).value)
