def test_3(self):
'''test that sequence_node_from_tokens works with more than one item'''
self.assertEqual(
sequence_node_from_tokens(tokens=[
SequenceStart(),
ScalarValue(data='value'),
Delimiter(),
ScalarValue(data='value'),
SequenceEnd(),
],
start=0),
(SequenceNode(
items=[ScalarNode(data='value'),
ScalarNode(data='value')]), 5))
def test_1(self):
'''test that mapping_node_from_tokens works for the simplest case'''
self.assertEqual(
mapping_node_from_tokens(tokens=[
MappingStart(),
ScalarValue(data='key'),
Separator(),
ScalarValue(data='value'),
MappingEnd(),
],
start=0),
(MappingNode(
mapping={ScalarNode(data='key'): ScalarNode(data='value')}),
5))
def scalar_node_from_tokens(tokens: List['Token'],
start: int) -> Tuple['ScalarNode', int]:
if start >= len(tokens):
raise Exception('start is pass the number of tokens')
if not isinstance(tokens[start], ScalarValue):
raise Exception('Trying to get a scalar node from a non-scalar node')
return ScalarNode(data=tokens[start].data), start + 1 # type: ignore
def test_5(self):
'''test that sequence_node_from_tokens works with it contains a mapping'''
self.assertEqual(
sequence_node_from_tokens(tokens=[
SequenceStart(),
MappingStart(),
ScalarValue(data='key'),
Separator(),
ScalarValue(data='value'),
MappingEnd(),
SequenceEnd(),
],
start=0),
(SequenceNode(items=[
MappingNode(
mapping={ScalarNode(data='key'): ScalarNode(data='value')})
]), 7))
def test_4(self):
'''test that mapping_node_from_tokens works when the value is a sequence'''
self.assertEqual(
mapping_node_from_tokens(tokens=[
MappingStart(),
ScalarValue(data='key'),
Separator(),
SequenceStart(),
ScalarValue(data='value'),
SequenceEnd(),
MappingEnd(),
],
start=0),
(MappingNode(
mapping={
ScalarNode(data='key'):
SequenceNode(items=[ScalarNode(data='value')]),
}), 7))
def test_to_object(self):
value = 'value string'
node = ScalarNode(data=value)
expectedObject = value
self.assertEqual(
object_from_node(
node
), # sigh. I can't use keyword arguments with singledispatch functions
expectedObject)
def test_1(self):
'''test that sequence_node_from_tokens works for the simplest case'''
self.assertEqual(
sequence_node_from_tokens(tokens=[
SequenceStart(),
ScalarValue(data='value'),
SequenceEnd(),
],
start=0),
(SequenceNode(items=[ScalarNode(data='value')]), 3))
def test_2(self):
'''test that mapping_node_from_tokens works when there are two items'''
self.assertEqual(
mapping_node_from_tokens(tokens=[
MappingStart(),
ScalarValue(data='key'),
Separator(),
ScalarValue(data='value'),
Delimiter(),
ScalarValue(data='key1'),
Separator(),
ScalarValue(data='value'),
MappingEnd(),
],
start=0),
(MappingNode(
mapping={
ScalarNode(data='key'): ScalarNode(data='value'),
ScalarNode(data='key1'): ScalarNode(data='value'),
}), 9))
def test_4(self):
'''test that sequence_node_from_tokens works with there is a nested sequence'''
self.assertEqual(
sequence_node_from_tokens(tokens=[
SequenceStart(),
SequenceStart(),
ScalarValue(data='value'),
SequenceEnd(),
SequenceEnd(),
],
start=0),
(SequenceNode(
items=[SequenceNode(items=[ScalarNode(data='value')])]), 5))
def test_3(self):
'''test that mapping_node_from_tokens works when there is a nested mapping'''
self.assertEqual(
mapping_node_from_tokens(tokens=[
MappingStart(),
ScalarValue(data='key'),
Separator(),
MappingStart(),
ScalarValue(data='key1'),
Separator(),
ScalarValue(data='value'),
MappingEnd(),
MappingEnd(),
],
start=0),
(MappingNode(
mapping={
ScalarNode(data='key'):
MappingNode(
mapping={
ScalarNode(data='key1'): ScalarNode(data='value')
}),
}), 9))
def test_scalar_node_from_tokens(self):
self.assertEqual(
scalar_node_from_tokens(tokens=[ScalarValue(data='value')],
start=0),
(ScalarNode(data='value'), 1),
)
def test_to_object(self):
mapping = {ScalarNode(data='key'): ScalarNode(data='value')}
node = MappingNode(mapping=mapping)
expectedObject = {'key': 'value'}
self.assertEqual(object_from_node(node), expectedObject)
def test_to_object(self):
items = [ScalarNode(data='value')]
node = SequenceNode(items=items)
expectedObject = ['value']
self.assertEqual(object_from_node(node), expectedObject)