def test_extract_facts(tmpdir, session):
"""Test extraction of facts for the current snapshot with a basic config."""
out_dir = tmpdir.join('output')
extracted_facts = session.extract_facts(nodes='basic',
output_directory=str(out_dir))
written_facts = load_facts(str(out_dir))
expected_facts = load_facts(join(_this_dir, 'facts', 'expected_facts'))
assert validate_facts(
expected_facts,
extracted_facts) == {}, 'Extracted facts match expected facts'
assert validate_facts(
expected_facts,
written_facts) == {}, 'Written facts match expected facts'
def test_validate_facts_not_matching_data():
"""Test that fact validation works for mismatched facts."""
expected = {"node1": {"foo": 1, "bar": 1, "baz": 1}, "node2": {"foo": 2}}
actual = {
"node1": {
"foo": 0,
"bar": 1
}, # 'foo' doesn't match expected
# also missing 'baz': 1
"node2": {
"foo": 2
},
"node3": {
"foo": 3
},
}
version = "version"
res = validate_facts(
_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version),
)
# Result should identify the mismatched value and the missing key
assert res == {
"node1": {
"foo": {
"expected": 1,
"actual": 0
},
"baz": {
"expected": 1,
"key_present": False
},
}
}
def test_extract_facts_specific_snapshot(tmpdir, session):
"""Test extraction of facts for a specific snapshot."""
out_dir = tmpdir.join("output")
extracted_facts = session.extract_facts(
output_directory=str(out_dir), snapshot=_PREVIOUS_SNAPSHOT
)
written_facts = load_facts(str(out_dir))
expected_facts = load_facts(join(_this_dir, "facts", "expected_facts2"))
assert (
validate_facts(expected_facts, extracted_facts) == {}
), "Extracted facts match expected facts"
assert (
validate_facts(expected_facts, written_facts) == {}
), "Written facts match expected facts"
def test_extract_facts(tmpdir, session):
"""Test extraction of facts for the current snapshot with a basic config."""
out_dir = tmpdir.join("output")
extracted_facts = session.extract_facts(
nodes="basic", output_directory=str(out_dir)
)
written_facts = load_facts(str(out_dir))
expected_facts = load_facts(join(_this_dir, "facts", "expected_facts"))
assert (
validate_facts(expected_facts, extracted_facts) == {}
), "Extracted facts match expected facts"
assert (
validate_facts(expected_facts, written_facts) == {}
), "Written facts match expected facts"
def test_validate_facts_not_matching_data():
"""Test that fact validation works for mismatched facts."""
expected = {
'node1': {'foo': 1, 'bar': 1, 'baz': 1},
'node2': {'foo': 2},
}
actual = {
'node1': {'foo': 0, 'bar': 1}, # 'foo' doesn't match expected
# also missing 'baz': 1
'node2': {'foo': 2},
'node3': {'foo': 3},
}
version = 'version'
res = validate_facts(_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version))
# Result should identify the mismatched value and the missing key
assert res == {
'node1': {
'foo': {
'expected': 1,
'actual': 0,
},
'baz': {
'expected': 1,
'key_present': False,
}
}
}
def test_validate_facts_not_matching_version():
"""Test that fact validation detects mismatched versions."""
expected = {
'node1': {'foo': 1},
'node2': {'foo': 2},
}
actual = {
'node1': {'foo': 1},
'node2': {'foo': 2},
'node3': {'foo': 3},
}
version_expected = 'correct_version'
version_actual = 'fake_version'
res = validate_facts(_encapsulate_nodes_facts(expected, version_expected),
_encapsulate_nodes_facts(actual, version_actual))
# One result per expected node for mismatched version
assert len(res) == len(expected)
for node in expected:
# Make sure version mismatch details are in results details
assert res[node] == {
'Version': {
'actual': version_actual,
'expected': version_expected,
}
}
def test_validate_facts():
"""Test that fact validation works for matching facts."""
expected = {
'node1': {
'foo': 1
},
'node2': {
'foo': 2
},
}
actual = {
'node1': {
'foo': 1
},
'node2': {
'foo': 2
},
'node3': {
'foo': 3
},
}
version = 'fake_version'
res = validate_facts(_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version))
# No results from matching (subset) expected and actual
assert len(res) == 0
def test_extract_facts_specific_snapshot(tmpdir, session):
"""Test extraction of facts for a specific snapshot."""
out_dir = tmpdir.join('output')
non_current_snapshot = session.list_snapshots()[-1]
extracted_facts = session.extract_facts(output_directory=str(out_dir),
snapshot=non_current_snapshot)
written_facts = load_facts(str(out_dir))
expected_facts = load_facts(join(_this_dir, 'facts', 'expected_facts2'))
assert validate_facts(
expected_facts,
extracted_facts) == {}, 'Extracted facts match expected facts'
assert validate_facts(
expected_facts,
written_facts) == {}, 'Written facts match expected facts'
def test_validate_facts():
"""Test that fact validation works for matching facts."""
expected = {"node1": {"foo": 1}, "node2": {"foo": 2}}
actual = {"node1": {"foo": 1}, "node2": {"foo": 2}, "node3": {"foo": 3}}
version = "fake_version"
res = validate_facts(
_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version),
)
# No results from matching (subset) expected and actual
assert len(res) == 0
def test_validate_facts_verbose():
"""Test that fact validation returns both matching and mismatched facts when running in verbose mode."""
expected = {
'node1': {
'foo': 1,
'bar': 1,
'baz': 1
},
'node2': {
'foo': 2
},
}
actual = {
'node1': {
'foo': 0,
'bar': 1
}, # 'foo' doesn't match expected
# also missing 'baz': 1
'node2': {
'foo': 2
},
'node3': {
'foo': 3
},
}
version = 'version'
res = validate_facts(_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version),
verbose=True)
# Verbose validation should return both matching and mismatched facts
assert res == {
'node1': {
'foo': {
'expected': 1,
'actual': 0,
},
'bar': {
'expected': 1,
'actual': 1,
},
'baz': {
'expected': 1,
'key_present': False,
}
},
'node2': {
'foo': {
'expected': 2,
'actual': 2,
},
}
}
def validate_facts(self, expected_facts):
# type: (Text) -> Dict[Text, Any]
"""
Return a dictionary of mismatched facts between the loaded expected facts and the actual facts.
:param expected_facts: path to directory to read expected fact YAML files from
:type expected_facts: Text
:return: facts about the specified nodes on the current network snapshot
:rtype: dict
"""
actual_facts = get_facts(self)
expected_facts_ = load_facts(expected_facts)
return validate_facts(expected_facts_, actual_facts)
def validate_facts(self, expected_facts, snapshot=None):
# type: (Text, Optional[Text]) -> Dict[Text, Any]
"""
Return a dictionary of mismatched facts between the loaded expected facts and the actual facts.
:param expected_facts: path to directory to read expected fact YAML files from
:type expected_facts: Text
:param snapshot: name of the snapshot to validate facts for, defaults to the current snapshot
:type snapshot: Text
:return: facts about the specified nodes on the current network snapshot
:rtype: dict
"""
actual_facts = get_facts(self, snapshot=snapshot)
expected_facts_ = load_facts(expected_facts)
return validate_facts(expected_facts_, actual_facts)
def test_validate_facts_verbose():
"""Test that fact validation returns both matching and mismatched facts when running in verbose mode."""
expected = {"node1": {"foo": 1, "bar": 1, "baz": 1}, "node2": {"foo": 2}}
actual = {
"node1": {
"foo": 0,
"bar": 1
}, # 'foo' doesn't match expected
# also missing 'baz': 1
"node2": {
"foo": 2
},
"node3": {
"foo": 3
},
}
version = "version"
res = validate_facts(
_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version),
verbose=True,
)
# Verbose validation should return both matching and mismatched facts
assert res == {
"node1": {
"foo": {
"expected": 1,
"actual": 0
},
"bar": {
"expected": 1,
"actual": 1
},
"baz": {
"expected": 1,
"key_present": False
},
},
"node2": {
"foo": {
"expected": 2,
"actual": 2
}
},
}
def test_validate_facts_no_matching_node():
"""Test that fact validation works when actual facts are missing expected node."""
expected = {"node1": {"foo": 1, "bar": 1, "baz": 1}, "node2": {"foo": 2}}
actual = {
"node1": {
"foo": 1,
"bar": 1,
"baz": 1
},
# missing node2
}
version = "version"
res = validate_facts(
_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version),
)
# Result should identify the missing node
assert res == {"node2": {"foo": {"expected": 2, "key_present": False}}}
def test_validate_facts_not_matching_version():
"""Test that fact validation detects mismatched versions."""
expected = {"node1": {"foo": 1}, "node2": {"foo": 2}}
actual = {"node1": {"foo": 1}, "node2": {"foo": 2}, "node3": {"foo": 3}}
version_expected = "correct_version"
version_actual = "fake_version"
res = validate_facts(
_encapsulate_nodes_facts(expected, version_expected),
_encapsulate_nodes_facts(actual, version_actual),
)
# One result per expected node for mismatched version
assert len(res) == len(expected)
for node in expected:
# Make sure version mismatch details are in results details
assert res[node] == {
"Version": {
"actual": version_actual,
"expected": version_expected
}
}
def test_validate_facts_no_matching_node():
"""Test that fact validation works when actual facts are missing expected node."""
expected = {
'node1': {'foo': 1, 'bar': 1, 'baz': 1},
'node2': {'foo': 2},
}
actual = {
'node1': {'foo': 1, 'bar': 1, 'baz': 1},
# missing node2
}
version = 'version'
res = validate_facts(_encapsulate_nodes_facts(expected, version),
_encapsulate_nodes_facts(actual, version))
# Result should identify the missing node
assert res == {
'node2': {
'foo': {
'expected': 2,
'key_present': False,
},
}
}
