def test_tracker_set_status():
""" Test that the SnapshotTracker.set_status method functions as expected. """
# Arrange
statuses = [
SnapshotStatus.UNCHECKED,
SnapshotStatus.PASSED,
SnapshotStatus.WRITTEN,
SnapshotStatus.FAILED,
]
snapshot_file = Path(__file__)
function_name = "test_function"
metadata = SnapshotMetadata(
caller_info=CallerInfo(snapshot_file, function_name, dict()),
update_on_next_run=False,
test_runner_provided_name="",
user_provided_name="",
)
# Act
tracker = SnapshotTracker()
tracker.set_status(
statuses=statuses,
snapshot_file=snapshot_file,
function_name=function_name,
metadata=metadata,
)
# Assert
assert tracker.snapshots == {
snapshot_file: {
function_name:
[dict(metadata=metadata.as_dict(), snapshots=statuses)]
}
}
def single_function_with_args(foo: str = "FOO",
bar: bool = True,
pi: float = 3.14) -> Result_Expected:
""" Single function call, with arguments. """
expected = CallerInfo(FILE, "single_function_with_args",
dict(foo=foo, bar=bar, pi=pi))
return get_caller_info(), expected
def nested_function() -> Result_Expected:
""" Nested function call. """
def inner():
""" Inner (nested) function. """
return get_caller_info(frame_index=3)
expected = CallerInfo(FILE, "nested_function", {})
return inner(), expected
def get_caller_info(frame_index: int = 2) -> CallerInfo:
""" Calls the `snappiershot.inspection.CallerInfo.from_call_stack` method.
This simulates the expected call stack during normal snappiershot runtime.
Returns:
The resultant CallerInfo object.
"""
return CallerInfo.from_call_stack(frame_index)
def _empty_caller_info(tmp_path: Path, mocker: MockerFixture) -> CallerInfo:
""" Mocks the call to the "from_call_stack" method of snappiershot.inspection.CallerInfo.
The method returns an CallerInfo object that contains no arguments.
"""
empty_caller_info = CallerInfo(tmp_path, "test_function", args=dict())
mocker.patch(
"snappiershot.snapshot.snapshot.CallerInfo.from_call_stack",
return_value=empty_caller_info,
)
return empty_caller_info
def test_encoded_metadata(config: Config, snapshot_file: Path):
""" Test that SnapshotMetadata gets encoded to eliminate serialization errors. """
# Arrange
args = dict(unhandled_type=SimpleNamespace(complex=3 + 4j))
caller_info = CallerInfo(snapshot_file, "test_function", args)
metadata = SnapshotMetadata(caller_info, update_on_next_run=False)
snapshot_file_object = _SnapshotFile(config, metadata)
# Act
snapshot_file_object._changed_flag = True
snapshot_file_object.write()
# Assert
assert snapshot_file.exists()
print(snapshot_file.read_text())
def test_tracker_get_status_report():
""" Test that the SnapshotTracker.get_status_report method functions as expected. """
# Arrange
expected = StatusReport(1, 2, 3, 4, 5)
tracker = SnapshotTracker()
snapshot_file = Path(__file__)
function_name = "test_function"
metadata = SnapshotMetadata(
caller_info=CallerInfo(snapshot_file, function_name, dict()),
update_on_next_run=False,
test_runner_provided_name="",
user_provided_name="",
)
tracker.snapshots = {
snapshot_file: {
function_name: [
dict(
metadata=metadata.as_dict(),
snapshots=[SnapshotStatus.UNCHECKED] * expected.unchecked,
),
dict(
metadata=metadata.as_dict(),
snapshots=[SnapshotStatus.FAILED] * expected.failed,
),
dict(
metadata=metadata.as_dict(),
snapshots=[SnapshotStatus.PASSED] * expected.passed,
),
dict(
metadata=metadata.as_dict(),
snapshots=[SnapshotStatus.RECORDED] * expected.recorded,
),
dict(
metadata=metadata.as_dict(),
snapshots=[SnapshotStatus.WRITTEN] * expected.written,
),
]
}
}
# Act
status_report = tracker.get_status_report()
# Assert
assert status_report == expected
def staticmethod_cls_arg(cls=None) -> Result_Expected:
""" Static method call, but the first argument is "cls". """
expected = CallerInfo(FILE, "ClassTestObject.staticmethod_cls_arg",
dict(cls=None))
return get_caller_info(), expected
def classmethod_no_self_arg(notcls) -> Result_Expected:
""" Class method call, but the "self" argument is mis-named. """
expected = CallerInfo(FILE, "ClassTestObject.classmethod_no_self_arg",
{})
return get_caller_info(), expected
def staticmethod_() -> Result_Expected:
""" Static method call. """
expected = CallerInfo(FILE, "ClassTestObject.staticmethod_", {})
return get_caller_info(), expected
def classmethod_(cls) -> Result_Expected:
""" Class method call. """
expected = CallerInfo(FILE, "ClassTestObject.classmethod_", {})
return get_caller_info(), expected
def method(self) -> Result_Expected:
""" Method call. """
expected = CallerInfo(FILE, "ClassTestObject.method", {})
return get_caller_info(), expected
def single_function_no_args() -> Result_Expected:
""" Single function call, with no arguments. """
expected = CallerInfo(FILE, "single_function_no_args", {})
return get_caller_info(), expected
def inner():
""" Inner function definition. """
CallerInfo.from_call_stack(1)
def method(self) -> Result_Expected:
""" Method call within nested class definition. """
expected = CallerInfo(FILE, "ClassTestObject.NestedClass.method",
{})
return get_caller_info(), expected
class TestSnapshotMetadata:
""" Tests for the snappiershot.snapshot.SnapshotMetadata object. """
FAKE_CALLER_INFO = CallerInfo(
file=Path("fake/file/path"),
function="fake_fully_qualified_function_name",
args={
"foo": 1,
"bar": "two"
},
)
DEFAULT_METADATA_KWARGS = dict(
caller_info=FAKE_CALLER_INFO,
update_on_next_run=False,
test_runner_provided_name="",
user_provided_name="",
)
@staticmethod
@pytest.mark.parametrize(
"metadata_kwargs, expected_error",
[
({
**DEFAULT_METADATA_KWARGS, "caller_info": None
}, TypeError),
({
**DEFAULT_METADATA_KWARGS, "update_on_next_run": "foo"
}, TypeError),
({
**DEFAULT_METADATA_KWARGS, "test_runner_provided_name": 1.23
}, TypeError),
({
**DEFAULT_METADATA_KWARGS, "user_provided_name": 1.23
}, TypeError),
],
)
def test_metadata_validate(metadata_kwargs: Dict,
expected_error: Type[Exception]):
""" Checks that validation of the metadata values occurs as expected. """
# Arrange
# Act & Assert
with pytest.raises(expected_error):
SnapshotMetadata(**metadata_kwargs)
@staticmethod
@pytest.mark.parametrize(
"metadata_kwargs, metadata_dict, matches",
[
(DEFAULT_METADATA_KWARGS, {
"arguments": FAKE_CALLER_INFO.args
}, True),
(DEFAULT_METADATA_KWARGS, {
"arguments": {
"foo": 1,
"bar": 2
}
}, False),
],
)
def test_metadata_matches(metadata_kwargs: Dict, metadata_dict: Dict,
matches: bool):
""" Checks that the SnapshotMetadata.matches method functions as expected. """
# Arrange
metadata = SnapshotMetadata(**metadata_kwargs)
# Act
result = metadata.matches(metadata_dict)
# Assert
assert result == matches
