inline-snapshot

By default, inline-snapshot manages everything inside snapshot(...). However, you can use "unmanaged" types that the library will ignore and refuse to update or fix, even if they cause tests to fail. This is useful for parts of the snapshot you want to control manually.

Unmanaged types include:

• dirty-equals expressions
• Dynamic code inside Is(...)
• Snapshots nested inside other snapshots
• f-strings

You can also define your own unmanaged types using the @declare_unmanaged decorator. Unmanaged types must be placed within supported containers like list, tuple, dict, namedtuple, dataclass, or attrs to be handled correctly.

from inline_snapshot import declare_unmanaged, snapshot

@declare_unmanaged
class AllEqual:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        return all(o == self.value for o in other)

def test_all_equal():
    # AllEqual is unmanaged, but the snapshot(1) inside it is managed
    assert {"text": "hello", "values": [1, 1, 1]} == snapshot(
        {"text": "hello", "values": AllEqual(snapshot(1))}
    )

The snapshot() function supports various comparison and structural patterns:

• Numeric Limits: Use comparison operators like <= and >= against a snapshot.
• Set Membership: Use the in operator to check if a value exists within a snapshot.
• Sub-snapshots (Indexing/Key Access): Create complex snapshots that can be accessed via keys or indices at runtime.
• External Storage: Use external("uuid:...") to store snapshots in external files instead of inlining them.
• Large/Multiline Strings: Use outsource() for large strings or simply use snapshot() for multiline string comparisons.

from inline_snapshot import external, outsource, snapshot

def test_advanced_patterns():
    # testing for numeric limits
    assert 5 <= snapshot()
    
    # test if something is part of a set
    assert "h" in snapshot("hello")

    # create sub-snapshots at runtime
    s = snapshot()
    assert s[0]["key"] == "value"

    # external storage
    assert outsource("large string") == snapshot()

    # multiline strings
    assert "line1\nline2" == snapshot()

The inline_snapshot.testing.Example class allows you to simulate and test inline-snapshot workflows (like creating or fixing snapshots) within your own test suites. This is particularly useful if you are building libraries that depend on inline-snapshot.

Key Concepts

• Immutability: Example objects are immutable. Calling a run_* method does not modify the existing object; instead, it returns a new Example object containing the updated files.
• Isolation: An Example is not connected to any directory. A temporary directory is only created when a run_* method is invoked.
• Chaining: Because run_* methods return new Example instances, you can chain them to perform complex, multi-step tests where each step operates on the files modified by the previous step.

from inline_snapshot import snapshot
from inline_snapshot.testing import Example

def test_workflow():
    # Create initial example
    e = Example({"test.py": "assert 1 == snapshot()"})
    
    # Chain runs: first create, then fix
    (e.run_pytest(["--inline-snapshot=create"], ...)
       .run_pytest(["--inline-snapshot=fix"], ...))

You can nest snapshot() calls inside other snapshots to handle complex logic or reuse data.

Conditional Snapshots

Use Python logic (like if/else) inside a snapshot to handle version-specific or environment-specific data. For example, you can switch between different snapshot values based on a library version.

Common Snapshot Parts

You can extract a common part of a snapshot into its own variable by calling snapshot() on it. This allows you to reuse that specific piece of data across multiple assertions while still allowing inline-snapshot to manage and update it if necessary.

from inline_snapshot import snapshot

def some_data(name):
    return {"header": "really long header\n" * 5, "your name": name}

def test_function():
    # Extract common part
    header = snapshot("really long header\nreally long header\nreally long header\nreally long header\nreally long header")

    assert some_data("Tom") == snapshot({"header": header, "your name": "Tom"})
    assert some_data("Bob") == snapshot({"header": header, "your name": "Bob"})