def test_extra_key_in_fixture_element(simple_list_schema):
"""Missing data that was expected by the fixture represents a mismatch."""
fixture: Dict = {
"the_list": [
{
"some_text": "foo",
"some_number": 27
},
{
"some_text": "bar"
}
]
}
actual: Dict = {
"the_list": [
{
"some_text": "foo"
},
{
"some_text": "bar"
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(simple_list_schema)
assert compare(fixture, actual) is False
def test_fixture_none_raises(simple_list_schema):
"""This should simply never happen, because the comparison algorithm should never try to traverse a null as a
folder."""
compare: CompareComplexVariable = CompareComplexVariable(
simple_list_schema)
with pytest.raises(AssertionError):
compare(None, {})
def test_nested_keyed_list_extra_value_in_fixture(keyed_list_in_list_schema):
fixture: Dict = {
"the_list": [
{
"the_keyed_list": {
"susan": {"some_text": "A"},
"bob": {"some_text": "B"}
}
},
{
"the_keyed_list": {
"steve": {"some_text": "C"},
"charlene": {"some_text": "D"}
}
}
]
}
actual: Dict = {
"the_list": [
{
"the_keyed_list": {
"susan": {"some_text": "A"},
"bob": {"some_text": "B"}
}
},
{
"the_keyed_list": {
"charlene": {"some_text": "D"}
}
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(keyed_list_in_list_schema)
assert compare(fixture, actual) is False
def test_nested_list_actual_has_more_elements(list_in_list_schema):
fixture: Dict = {
"outer": [
{
"inner": [
{"some_text": "A"},
{"some_text": "B"}
]
},
{
"inner": [
{"some_text": "D"}
]
}
]
}
actual: Dict = {
"outer": [
{
"inner": [
{"some_text": "A"},
{"some_text": "B"}
]
},
{
"inner": [
{"some_text": "C"},
{"some_text": "D"}
]
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(list_in_list_schema)
assert compare(fixture, actual) is False
def test_nested_folder_only_in_actual(folder_in_list_schema):
"""See note above about missing data."""
fixture: Dict = {
"the_list": [
{},
{
"the_folder": {
"some_text": "bar"
}
}
]
}
actual: Dict = {
"the_list": [
{
"the_folder": {
"some_text": "foo"
}
},
{
"the_folder": {
"some_text": "bar"
}
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(folder_in_list_schema)
assert compare(fixture, actual) is True
def test_nested_folder_contains_mismatch(folder_in_list_schema):
fixture: Dict = {
"the_list": [
{
"the_folder": {
"some_text": "FOO"
}
},
{
"the_folder": {
"some_text": "bar"
}
}
]
}
actual: Dict = {
"the_list": [
{
"the_folder": {
"some_text": "foo"
}
},
{
"the_folder": {
"some_text": "bar"
}
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(folder_in_list_schema)
assert compare(fixture, actual) is False
def test_triply_nested_folder_actual_has_extra(nested_folder_schema):
actual: Dict = {
"some_text": "Foo",
"parent": {
"some_text": "X",
"child": {
"some_text": "Y",
"grandchild": {
"some_text": "Z"
}
}
}
}
fixture: Dict = {
"some_text": "Foo",
"parent": {
"some_text": "X",
"child": {
"some_text": "Y"
}
}
}
compare: CompareComplexVariable = CompareComplexVariable(
nested_folder_schema)
assert compare(fixture, actual) is True
def test_extra_key_in_actual_element(simple_list_schema):
"""Missing data in the FIXTURE represents lack of test coverage."""
msg: str = """This test demonstrates a subtle limitation of the expected value comparison (EVC) system. The EVC
allows a Polytropos user to create fixtures that do not cover every known variable, such that they do not need to be
identical to the actual output in order to be failure-free. This is equivalent to incomplete test coverage in code.
Without vastly complicating the EVC system, there is no way to track whether a particular nested variable was
captured in one list item but not another. DO NOT assume that, because element 1 of the fixture has variable X and
element 2 does not, the actual value of element 2 explicitly lacks variable X."""
warnings.warn(msg, RuntimeWarning)
fixture: Dict = {
"the_list": [{
"some_text": "foo"
}, {
"some_text": "bar",
"some_number": 42
}]
}
actual: Dict = {
"the_list": [{
"some_text": "foo",
"some_number": 27
}, {
"some_text": "bar",
"some_number": 42
}]
}
compare: CompareComplexVariable = CompareComplexVariable(
simple_list_schema)
assert compare(fixture, actual) is True
def test_nested_keyed_list_only_in_actual(keyed_list_in_list_schema):
"""See warnings above about missing data"""
fixture: Dict = {
"the_list": [
{
"the_keyed_list": {
"susan": {"some_text": "A"},
"bob": {"some_text": "B"}
}
},
{}
]
}
actual: Dict = {
"the_list": [
{
"the_keyed_list": {
"susan": {"some_text": "A"},
"bob": {"some_text": "B"}
}
},
{
"the_keyed_list": {
"steve": {"some_text": "C"},
"charlene": {"some_text": "D"}
}
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(keyed_list_in_list_schema)
assert compare(fixture, actual) is True
def test_mismatch_in_one_element(simple_list_schema):
fixture: Dict = {
"the_list": [
{
"some_text": "foo",
"some_number": 27
},
{
"some_text": "BAR"
}
]
}
actual: Dict = {
"the_list": [
{
"some_text": "foo",
"some_number": 27
},
{
"some_text": "bar"
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(simple_list_schema)
assert compare(fixture, actual) is False
def test_nested_mismatch_on_lower_level(nested_folder_schema):
fixture: Dict = {
"some_text": "Foo",
"parent": {
"some_text": "X",
"child": {
"some_text": "Y",
"grandchild": {
"some_text": "Z"
}
}
}
}
actual: Dict = {
"some_text": "Bar",
"parent": {
"some_text": "X",
"child": {
"some_text": "Y",
"grandchild": {
"some_text": "Z"
}
}
}
}
compare: CompareComplexVariable = CompareComplexVariable(
nested_folder_schema)
assert compare(fixture, actual) is False
def test_keyed_list_element_only_in_actual(keyed_list_in_list_schema):
fixture: Dict = {
"the_list": [
{
"the_keyed_list": {
"susan": {"some_text": "A"},
"bob": {"some_text": "B"}
}
},
{
"the_keyed_list": {
"steve": {},
"charlene": {"some_text": "D"}
}
}
]
}
actual: Dict = {
"the_list": [
{
"the_keyed_list": {
"susan": {"some_text": "A"},
"bob": {"some_text": "B"}
}
},
{
"the_keyed_list": {
"steve": {"some_text": "C"},
"charlene": {"some_text": "D"}
}
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(keyed_list_in_list_schema)
assert compare(fixture, actual) is True
def test_nested_named_list_identical(named_list_in_list_schema):
fixture: Dict = {
"the_list": [{
"the_named_list": {
"susan": {
"some_text": "A"
},
"bob": {
"some_text": "B"
}
}
}, {
"the_named_list": {
"rick": {
"some_text": "C"
},
"charlene": {
"some_text": "D"
}
}
}]
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(
named_list_in_list_schema)
assert compare(fixture, actual) is True
def test_nested_list_extra_value_in_actual(list_in_list_schema):
"""See warning above about missing data"""
fixture: Dict = {
"outer": [{
"inner": [{
"some_text": "A"
}, {
"some_text": "B"
}]
}, {
"inner": [{}, {
"some_text": "D"
}]
}]
}
actual: Dict = {
"outer": [{
"inner": [{
"some_text": "A"
}, {
"some_text": "B"
}]
}, {
"inner": [{
"some_text": "C"
}, {
"some_text": "D"
}]
}]
}
compare: CompareComplexVariable = CompareComplexVariable(
list_in_list_schema)
assert compare(fixture, actual) is True
def test_keyed_list_in_folder_mismatch(keyed_list_in_nested_folder_schema):
fixture: Dict = {
"parent": {
"child": {
"grandchild": {
"the_keyed_list": {
"Steve": {
"some_text": "Foo"
}
}
}
}
}
}
actual: Dict = {
"parent": {
"child": {
"grandchild": {
"the_keyed_list": {
"Steve": {
"some_text": "Bar"
}
}
}
}
}
}
compare: CompareComplexVariable = CompareComplexVariable(
keyed_list_in_nested_folder_schema)
assert compare(fixture, actual) is False
def test_nested_list_extra_value_in_fixture(list_in_list_schema):
fixture: Dict = {
"outer": [
{
"inner": [
{"some_text": "A"},
{"some_text": "B"}
]
},
{
"inner": [
{"some_text": "C"},
{"some_text": "D"}
]
}
]
}
actual: Dict = {
"outer": [
{
"inner": [
{"some_text": "A"},
{"some_text": "B"}
]
},
{
"inner": [
{},
{"some_text": "D"}
]
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(list_in_list_schema)
assert compare(fixture, actual) is False
def test_nested_folder_empty_in_fixture(folder_in_list_schema):
"""See warning above about missing data in the fixture."""
fixture: Dict = {
"the_list": [
{
"the_folder": {}
},
{
"the_folder": {
"some_text": "bar"
}
}
]
}
actual: Dict = {
"the_list": [
{
"the_folder": {
"some_text": "foo"
}
},
{
"the_folder": {
"some_text": "bar"
}
}
]
}
compare: CompareComplexVariable = CompareComplexVariable(folder_in_list_schema)
assert compare(fixture, actual) is True
def test_only_actual_has_folder_empty(simple_schema):
"""Missing data in the FIXTURE represents lack of test coverage."""
fixture: Dict = {
"some_text": "Foo",
}
actual: Dict = {"some_text": "Foo", "the_folder": {}}
compare: CompareComplexVariable = CompareComplexVariable(simple_schema)
assert compare(fixture, actual) is True
def test_different_number_empty_elements(simple_list_schema):
fixture: Dict = {
"the_list": [{}] * 3
}
actual: Dict = {
"the_list": [{}] * 5
}
compare: CompareComplexVariable = CompareComplexVariable(simple_list_schema)
assert compare(fixture, actual) is False
def test_empty_lists(simple_list_schema):
fixture: Dict = {
"the_list": []
}
actual: Dict = {
"the_list": []
}
compare: CompareComplexVariable = CompareComplexVariable(simple_list_schema)
assert compare(fixture, actual) is True
def _inspect_complex(self, data_type: str, f_val: Optional[Any], a_tree: Dict, path: ListType) -> None:
assert f_val != POLYTROPOS_NA # Should have been handled at _inspect
a_val: Optional[Any] = nesteddicts.get(a_tree, path, default=POLYTROPOS_CONFIRMED_NA)
if a_val == POLYTROPOS_CONFIRMED_NA:
self._record_missing(path, data_type, json.dumps(f_val, sort_keys=True))
return
compare: CompareComplexVariable = CompareComplexVariable(self.schema)
if compare(f_val, a_val, path=path):
self._record_match(path, data_type, json.dumps(f_val, sort_keys=True))
else:
self._record_mismatch(path, data_type, json.dumps(f_val, sort_keys=True), json.dumps(a_val, sort_keys=True))
def test_fixture_has_more_elements(simple_list_schema):
fixture: Dict = {"the_list": [{"some_text": "foo", "some_number": 27}]}
actual: Dict = {
"the_list": [{
"some_text": "foo",
"some_number": 27
}, {
"some_text": "bar"
}]
}
compare: CompareComplexVariable = CompareComplexVariable(
simple_list_schema)
assert compare(fixture, actual) is False
def test_identical_simple_lists(simple_list_schema):
fixture: Dict = {
"the_list": [{
"some_text": "foo",
"some_number": 27
}, {
"some_text": "bar"
}]
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(
simple_list_schema)
assert compare(fixture, actual) is True
def test_unrecognized_nested_folder_raises(nested_folder_schema):
fixture: Dict = {
"parent": {
"not_a_thing": {
"grandchild": {
"some_text": "Z"
}
}
}
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(
nested_folder_schema)
with pytest.raises(ValueError):
compare(fixture, actual)
def test_nested_folder_identical(folder_in_list_schema):
fixture: Dict = {
"the_list": [{
"the_folder": {
"some_text": "foo"
}
}, {
"the_folder": {
"some_text": "bar"
}
}]
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(
folder_in_list_schema)
assert compare(fixture, actual) is True
def test_list_in_folder_identical(list_in_nested_folder_schema):
fixture: Dict = {
"parent": {
"child": {
"grandchild": {
"the_list": [{
"some_text": "Foo"
}]
}
}
}
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(
list_in_nested_folder_schema)
assert compare(fixture, actual) is True
def test_nested_named_list_key_mismatch(named_list_in_list_schema):
fixture: Dict = {
"the_list": [{
"the_named_list": {
"susan": {
"some_text": "A"
},
"bob": {
"some_text": "B"
}
}
}, {
"the_named_list": {
"rick": {
"some_text": "C"
},
"charlene": {
"some_text": "D"
}
}
}]
}
actual: Dict = {
"the_list": [{
"the_named_list": {
"susan": {
"some_text": "A"
},
"bob": {
"some_text": "B"
}
}
}, {
"the_named_list": {
"steve": {
"some_text": "C"
},
"charlene": {
"some_text": "D"
}
}
}]
}
compare: CompareComplexVariable = CompareComplexVariable(
named_list_in_list_schema)
assert compare(fixture, actual) is False
def test_triply_nested_folder_identical(nested_folder_schema):
fixture: Dict = {
"some_text": "Foo",
"parent": {
"some_text": "X",
"child": {
"some_text": "Y",
"grandchild": {
"some_text": "Z"
}
}
}
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(
nested_folder_schema)
assert compare(fixture, actual) is True
def test_nested_list_identical(list_in_list_schema):
fixture: Dict = {
"outer": [
{
"inner": [
{"some_text": "A"},
{"some_text": "B"}
]
},
{
"inner": [
{"some_text": "C"},
{"some_text": "D"}
]
}
]
}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(list_in_list_schema)
assert compare(fixture, actual) is True
def test_unrecognized_folder_raises(simple_schema):
fixture: Dict = {"not_a_thing": {"some_text": "Bar"}}
actual: Dict = copy.deepcopy(fixture)
compare: CompareComplexVariable = CompareComplexVariable(simple_schema)
with pytest.raises(ValueError):
compare(fixture, actual)