def test_non_parsable_sub_entities():
"""Test that ValueError is raised if one of sub-entities can't be parsed.
1. Create json parser that raises exception when either parse_embedded_link or
parse_embedded_representation is called.
2. Create an entity parser with the parser.
3. Try to call parse_entities method.
4. Check that ValueError is raised.
5. Check the error message.
"""
class _SubEntityErrorParser(JSONParser):
def parse_embedded_link(self, data):
raise Exception()
def parse_embedded_representation(self, data):
raise Exception()
parser = EntityParser(
data={"entities": [{}, {
"href": "/target"
}]},
parser=_SubEntityErrorParser(),
)
with pytest.raises(ValueError) as error_info:
parser.parse_entities()
assert error_info.value.args[
0] == "Failed to parse entity's sub-entities", "Wrong error"
def test_parse(component_validator):
"""Test that entity data is properly parsed.
1. Create an entity.
2. Create an entity parser.
3. Replace parser methods so that they return predefined data.
4. Parse the entity.
5. Check the entity data.
"""
entity = Entity(
classes=("parsed class 1", "parsed class 2"),
properties={
"property 1": 1,
"property 2": [1, 2]
},
entities=(
EmbeddedLink(target="/embedded/link/target",
relations=["relation"]),
EmbeddedRepresentation(relations=["relation"]),
),
links=[Link(target="/link/target", relations=["relation"])],
actions=[Action(target="/action/target", name="action")],
title="parsed title",
)
parser = EntityParser(data={}, parser=JSONParser())
parser.parse_classes = lambda: entity.classes
parser.parse_properties = lambda: entity.properties
parser.parse_entities = lambda: entity.entities
parser.parse_links = lambda: entity.links
parser.parse_actions = lambda: entity.actions
parser.parse_title = lambda: entity.title
actual_entity = parser.parse()
component_validator.validate_entity(actual_entity, entity)
def test_sub_entities(sub_entities_data):
"""Test that sub-entities are properly parsed.
1. Create json parser with overridden parse_embedded_link and parse_embedded_representation.
2. Create an entity parser with the parser.
3. Parse fields.
4. Check the parsed fields.
"""
class _SubEntitiesParser(JSONParser):
def parse_embedded_link(self, data):
if "href" not in data:
pytest.fail(
"Try to parse embedded link instead of embedded representation"
)
return sub_entities_data.index(data)
def parse_embedded_representation(self, data):
if "href" in data:
pytest.fail(
"Try to parse embedded representation instead of embedded link"
)
return sub_entities_data.index(data)
parser = EntityParser(data={"entities": sub_entities_data},
parser=_SubEntitiesParser())
actual_sub_entities = parser.parse_entities()
assert actual_sub_entities == tuple(range(
len(sub_entities_data))), "Wrong sub-entities"