joythief.data_structures module

class joythief.data_structures.DictContaining(**kwargs: Any)

class joythief.data_structures.DictContaining(content: Mapping[Hashable, Any], /, **kwargs: Any)

class joythief.data_structures.DictContaining(content: Iterable[tuple[Hashable, Any]], /, **kwargs: Any)

Bases: Matcher[Mapping[Hashable, Any]], dict[Hashable, Any]

Match the specified keys in a mapping, ignoring any extra keys.

Parameters:

• content (Any) – mapping or iterable of key-value pairs to include in the comparison

• **kwargs (Any) – additional key-value pairs to include in the comparison

Raises:

ValueError – if no keys are specified (use InstanceOf with dict instead).

Added in version 0.7.0.

Changed in version 0.8.0: added optionally().

assert (
    actual
    == DictContaining([("foo", 123), ("bar", 456)], baz=InstanceOf(int))
)

Note: this subclasses dict so that pytest will show the common and differing items, e.g.:

>       assert mapping == dict(foo=123, bar=456)
E       AssertionError: assert DictContaining(**{'foo': 123, 'bar': 0, 'baz': 789}) == {'foo': 123, 'bar': 456}
E
E         Common items:
E         {'foo': 123}
E         Differing items:
E         {'bar': 0} != {'bar': 456}
E         Left contains 1 more item:
E         {'baz': 789}
# ...

static optionally(value)

Matcher factory for keys that may not be present.

assert (
    actual
    == DictContaining(foo=DictContaining.optionally(123))
)

Note: this allows keys to be missing entirely, but matches the value strictly. For the equivalent of typing.Optional, use Nullable. These can be combined if required, e.g. to allow the key "foo" to be either: missing; present with the value 123; or present with the value None, use:

assert (
    actual
    == DictContaining(foo=DictContaining.optionally(Nullable(123)))
)

Parameters:

value (T | Matcher[T])

Return type:

T | Matcher[T]