implement a snapshot_arg() function to simplify some advanced snapshot usages

[15r10nk]

Problem:

snapshot() can not only be used in assertions but also used as argument for functions or methods (everything callable).

One example:

from inline_snapshot import snapshot


def check_string(string, length, is_upper):
    assert len(string) == length
    assert string.isupper() == is_upper


def test_string_len():
    check_string("abc", length=snapshot(3),is_upper=snapshot(False))

The problem is that you have to use the following code to create the snapshots

def test_string_len():
    check_string("abc", length=snapshot(),is_upper=snapshot())

Idea:

I want to move the snapshot inside the function and call it snapshot_arg which will then manage the value of the argument.

from inline_snapshot import snapshot_arg


def check_string(string, length, is_upper):
    assert len(string) == snapshot_arg(length)
    assert string.isupper() == snapshot_arg(is_upper)


def test_string_len():
    check_string("abc")

inline-snapshot will then create the arguments without the use of snapshot().

def test_string_len():
    check_string("abc", length=3,is_upper=False)

inline-snapshot will use the default arguments to decide if a argument has to be created.

There are some rules to follow.

• snapshot_arg(arg) can only be used for arguments.
• inline-snapshot will "manage" the argument of the function and try to change the code if it has to.
  This can become a problem if you try to use it for existing code. There are maybe ways to make smarter decision here, but not in the first iteration.

possible use cases:

• dirty-equal like expressions like IsJson() in Allow fixing whole snapshot regardless of managed/unmanaged values #196
• maybe it is possible to integrate it directly into dirty-equal
• integration into python unittest self.assertEqual(value, ...) (... is already supported https://github.com/15r10nk/inline-snapshot/releases/tag/0.20.0)
• pandas.assert_frame_equal https://github.com/15r10nk/inline-snapshot-pandas#readme

feedback is very welcome.

[alexmojaki]

The problem is that you have to use the following code to create the snapshots

I'm not convinced that's a significant problem. That's pretty easy to write. Also I would have dealt with this case like this:

from inline_snapshot import snapshot


def string_props(string):
    return {"length": len(string), "is_upper": string.isupper()}


def test_string_len():
    assert string_props("abc") == snapshot(0)
    # becomes after fixing:
    assert string_props("abc") == snapshot({"length": 3, "is_upper": False})

inline-snapshot will then create the arguments without the use of snapshot().

But check_string("abc") will raise a TypeError. How much magic are you planning?

inline-snapshot will use the default arguments to decide if a argument has to be created.

What does this mean? Did you mean to add defaults to the params of check_string? Will it also allow fixing snapshots?

possible use cases:

I don't understand how these would work.

[15r10nk]

But check_string("abc") will raise a TypeError. How much magic are you planning?

sorry my example was missing default args.

from inline_snapshot import snapshot


def check_string(string, length=..., is_upper=...):
    assert len(string) == length
    assert string.isupper() == is_upper


def test_string_len():
    check_string("abc", length=3, is_upper=False)

I have not decided if I want to use ... or some other sentinel like to_create where I can fake some typing to make type checkers happy.

inline-snapshot will use the default arguments to decide if a argument has to be created.

What does this mean? Did you mean to add defaults to the params of check_string? Will it also allow fixing snapshots?

I mean that the new params will only be created when they are not equal to the default arg of the function.

example:

import subprocess


def check_cmd(args, stdout=b"", stderr=b"", returncode=0):
    result = subprocess.run(args, capture_output=True)

    assert result.stdout == snapshot_arg(stdout)
    assert result.stderr == snapshot_arg(stderr)
    assert result.returncode == snapshot_arg(returncode)


check_cmd(["some_command", "--arg"])

The new arguments in this example will only be created if they are different from the default value. I use this pattern to test inline-snapshot itself https://15r10nk.github.io/inline-snapshot/latest/testing/. Be able to use this without writing stderr=snapshot() every time some_command could produce some output on stderr improves the usability.
And more important, it saves you from adding a lot of parameters to your test if you change your code in a way which produces output on stderr for example.

I don't understand how these would work.

example for IsJson (from #196):

@declare_unmanaged
class IsJson:
    def __init__(self, json_value):
        self.json_snapshot = snapshot_arg(json_value)

    def __eq__(self, json_string):
        return self.json_snapshot == json.loads(json_string)

def test_json()
    assert {"a": '{"b": 1}'} == snapshot({"a": IsJson({"b": 2})})

The other examples could work in a similar way. All would need some patching of existing code but the idea is that the interface of the existing library functions can stay the same.

This would allow to add snapshot capabilities to other libraries without changing existing test code which uses these libraries. Existing IsJson(...) expressions could be fixed by inline-snapshot or existing code which is using unittest.assertEqual.

Working with existing code would mean that I have to be really careful what I fix

expected_value = 8
self.assertEqual(4+1,expected_value)

should probably not be changed to

expected_value = 8
self.assertEqual(4+1,5)

The goal here is to provide a something which works for the most of the existing patterns and creates no problems for the other ones.

[alexmojaki]

I'll note that this also works:

import unittest
from inline_snapshot import snapshot


class MyTestCase(unittest.TestCase):
    def test_something(self):
        self.assertEqual(True, snapshot(""))