Can we support other types for dictionary key mapping?

[tcw165]

Technically, a dictionary could have any type for the key if key value is hash-able. We do have some Protobuf generated interface that is using integer for key, but currently not supported by Decoy.

We are a big fan of Decoy style of testing. Please show me a guidance to support dict-matching with int type or being more flexible of types?

[mcous]

Oh yeah, maybe our DictMatching type annotations are too strict. I'd def accept a PR to loosen this up! Does it work at runtime if you throw a # type: ignore on it?

In the mean time, matchers are simply classes with an __eq__ method, so you could implement a custom matcher yourself pretty easily. Maybe something like this would work? (Below code is completely untested, just did a quick copy paste from matchers.py with some type annotation updates)

class _AnyKeyDictMatching:
    _values: Mapping[Any, Any]

    def __init__(self, values: Mapping[Any, Any]) -> None:
        self._values = values

    def __eq__(self, target: object) -> bool:
        """Return true if target matches all given keys/values."""
        is_match = True

        for key, value in self._values.items():
            if is_match:
                try:
                    is_match = key in target and target[key] == value  # type: ignore[index,operator]
                except TypeError:
                    is_match = False

        return is_match

    def __repr__(self) -> str:
        """Return a string representation of the matcher."""
        return f"<DictMatching {self._values!r}>"


def AnyKeyDictMatching(values: Mapping[Any, Any]) -> Any:
    """Match any dictionary with the passed in keys / values.

    Arguments:
        values: Keys and values to check.

    !!! example
        ```python
        value = {"hello": "world", "goodbye": "so long"}
        assert value == matchers.DictMatching({"hello": "world"})
        ```
    """
    return _AnyKeyDictMatching(values)