python: use repr for everything except str and bytes (#378)

Author: nedtwigg

python/example-pytest-selfie/tests/simple_inline_test.py

@@ -10,4 +10,8 @@
 
 
 def test_write():
-    expect_selfie("B").to_be_TODO()
+    expect_selfie("B").to_be("B")
+    expect_selfie(20000).to_be(20_000)
+    expect_selfie([1, 2, 3]).to_be([1, 2, 3])
+    expect_selfie(("a", 2, 3)).to_be(("a", 2, 3))
+    expect_selfie({"a": 1, "b": 2}).to_be({"a": 1, "b": 2})

python/fullstack-pytest.code-workspace

@@ -0,0 +1,14 @@
+{
+	"folders": [
+		{
+			"path": "example-pytest-selfie"
+		},
+		{
+			"path": "pytest-selfie"
+		},
+		{
+			"path": "selfie-lib"
+		}
+	],
+	"settings": {}
+}

python/selfie-lib/selfie_lib/CacheSelfie.py

@@ -23,10 +23,10 @@ def to_match_disk_TODO(self, sub: str = "") -> T:
         return self._to_match_disk_impl(sub, True)
 
     def _to_match_disk_impl(self, sub: str, is_todo: bool) -> T:
-        from .Selfie import get_system
+        from .Selfie import _selfieSystem
 
         call = recordCall(False)
-        system = get_system()
+        system = _selfieSystem()
         if system.mode.can_write(is_todo, call, system):
             actual = self.generator()
             self.disk.write_disk(
@@ -55,10 +55,10 @@ def to_be(self, expected: str) -> T:
         return self._to_be_impl(expected)
 
     def _to_be_impl(self, snapshot: Optional[str]) -> T:
-        from .Selfie import get_system
+        from .Selfie import _selfieSystem
 
         call = recordCall(False)
-        system = get_system()
+        system = _selfieSystem()
         writable = system.mode.can_write(snapshot is None, call, system)
         if writable:
             actual = self.generator()

python/selfie-lib/selfie_lib/Literals.py

@@ -1,7 +1,8 @@
 from calendar import c
 from enum import Enum, auto
-from typing import Protocol, TypeVar
+from typing import Any, Protocol, TypeVar
 from abc import abstractmethod
+
 from .EscapeLeadingWhitespace import EscapeLeadingWhitespace
 import io
 import re
@@ -247,22 +248,17 @@ def handle_escape_sequences(line: str) -> str:
         )
 
 
-class LiteralBoolean(LiteralFormat[bool]):
+class LiteralRepr(LiteralFormat[Any]):
     def encode(
-        self, value: bool, language: Language, encoding_policy: EscapeLeadingWhitespace
+        self, value: Any, language: Language, encoding_policy: EscapeLeadingWhitespace
     ) -> str:
-        return str(value)
-
-    def __to_boolean_strict(self, string: str) -> bool:
-        if string.lower() == "true":
-            return True
-        elif string.lower() == "false":
-            return False
+        if isinstance(value, int):
+            return LiteralInt().encode(value, language, encoding_policy)
         else:
-            raise ValueError("String is not a valid boolean representation: " + string)
+            return repr(value)
 
-    def parse(self, string: str, language: Language) -> bool:
-        return self.__to_boolean_strict(string)
+    def parse(self, string: str, language: Language) -> Any:
+        return eval(string)
 
 
 class TodoStub(Enum):

python/selfie-lib/selfie_lib/Selfie.py

@@ -1,6 +1,6 @@
-from typing import TypeVar, Generic, Protocol, Union
-from .SelfieImplementations import StringSelfie, IntSelfie, BooleanSelfie
-from .SnapshotSystem import _selfieSystem, SnapshotSystem
+from typing import TypeVar, Any, Protocol, Union, overload
+from .SelfieImplementations import ReprSelfie, StringSelfie
+from .SnapshotSystem import _selfieSystem
 from .Snapshot import Snapshot
 from .CacheSelfie import CacheSelfie
 from .RoundTrip import Roundtrip
@@ -16,21 +16,27 @@ def __call__(self) -> T:
         raise NotImplementedError
 
 
-def get_system() -> SnapshotSystem:
-    return _selfieSystem()
+@overload
+def expect_selfie(actual: str) -> StringSelfie: ...
 
 
-def expect_selfie(actual: Union[str, int, bool]):
-    if isinstance(actual, int):
-        return IntSelfie(actual)
-    elif isinstance(actual, str):
+# @overload
+# def expect_selfie(actual: bytes) -> BinarySelfie: ...
+
+
+@overload
+def expect_selfie[T](actual: T) -> ReprSelfie[T]: ...
+
+
+def expect_selfie(
+    actual: Union[str, Any],
+) -> Union[StringSelfie, ReprSelfie]:
+    if isinstance(actual, str):
         snapshot = Snapshot.of(actual)
         diskStorage = _selfieSystem().disk_thread_local()
         return StringSelfie(snapshot, diskStorage)
-    elif isinstance(actual, bool):
-        return BooleanSelfie(actual)
     else:
-        raise NotImplementedError()
+        return ReprSelfie(actual)
 
 
 def cache_selfie_string(to_cache: Cacheable[str]) -> CacheSelfie[str]:
@@ -43,5 +49,5 @@ def cache_selfie_generic(
     roundtrip: Roundtrip[T, str], to_cache: Cacheable[T]
 ) -> CacheSelfie[T]:
     """Create a CacheSelfie instance for caching generic objects with specified roundtrip."""
-    deferred_disk_storage = get_system().disk_thread_local()
+    deferred_disk_storage = _selfieSystem().disk_thread_local()
     return CacheSelfie(deferred_disk_storage, roundtrip, to_cache)

python/selfie-lib/selfie_lib/SelfieImplementations.py

@@ -5,20 +5,33 @@
 from .SnapshotSystem import DiskStorage, SnapshotSystem, _selfieSystem, Mode
 from .WriteTracker import recordCall as recordCall
 from .Literals import (
-    LiteralValue,
-    LiteralString,
     LiteralFormat,
+    LiteralRepr,
+    LiteralString,
+    LiteralValue,
     TodoStub,
-    LiteralInt,
-    LiteralBoolean,
 )
 
 
 from abc import ABC, abstractmethod
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional
 from itertools import chain
 
 
+class ReprSelfie[T]:
+    def __init__(self, actual: T):
+        self.actual = actual
+
+    def to_be_TODO(self, unused_arg: Optional[T] = None) -> T:
+        return _toBeDidntMatch(None, self.actual, LiteralRepr())
+
+    def to_be(self, expected: T) -> T:
+        if self.actual == expected:
+            return _checkSrc(self.actual)
+        else:
+            return _toBeDidntMatch(expected, self.actual, LiteralRepr())
+
+
 class FluentFacet(ABC):
     @abstractmethod
     def facet(self, facet: str) -> "StringFacet":
@@ -95,7 +108,7 @@ def facet_binary(self, facet: str) -> "BinaryFacet":
         raise NotImplementedError()
 
 
-class StringSelfie(DiskSelfie, StringFacet):
+class StringSelfie(DiskSelfie, StringFacet, ReprSelfie[str]):
     def __init__(
         self,
         actual: Snapshot,
@@ -147,7 +160,7 @@ def __actual(self) -> str:
     def to_be_TODO(self, unused_arg: Any = None) -> str:
         return _toBeDidntMatch(None, self.__actual(), LiteralString())
 
-    def to_be(self, expected: Union[str, int, bool]) -> str:
+    def to_be(self, expected: str) -> str:
         actual_string = self.__actual()
 
         # Check if expected is a string
@@ -234,39 +247,3 @@ def _serializeOnlyFacets(snapshot: Snapshot, keys: List[str]) -> str:
         return writer_str[len(EMPTY_KEY_AND_FACET) : -1]
     else:
         return writer_str[:-1]
-
-
-class IntSelfie:
-    def __init__(self, actual: int):
-        self.actual = actual
-
-    def to_be_TODO(self, unused_arg: Any = None):
-        return _toBeDidntMatch(None, self.actual, LiteralInt())
-
-    def to_be(self, expected: Union[str, int, bool]) -> int:
-        if not isinstance(expected, int):
-            raise TypeError("Expected value must be an int")
-
-        # Compare actual to expected; handle match or mismatch.
-        if self.actual == expected:
-            return _checkSrc(self.actual)
-        else:
-            return _toBeDidntMatch(expected, self.actual, LiteralInt())
-
-
-class BooleanSelfie:
-    def __init__(self, actual: bool):
-        self.actual = actual
-
-    def to_be_TODO(self, unused_arg: Any = None):
-        return _toBeDidntMatch(None, self.actual, LiteralBoolean())
-
-    def to_be(self, expected: Union[str, int, bool]) -> bool:
-        if not isinstance(expected, bool):
-            raise TypeError("Expected value must be a bool")
-
-        # Compare actual to expected; handle match or mismatch.
-        if self.actual == expected:
-            return _checkSrc(self.actual)
-        else:
-            return _toBeDidntMatch(expected, self.actual, LiteralBoolean())

python/selfie-lib/tests/LiteralBoolean_test.py

@@ -18,7 +18,7 @@ To start snapshot testing in Python, all you need is to add a [single dependency
 Selfie snapshot testing works with the following Python test runners:
 
 - Pytest
-- PRs welcome for other test runners
+- PRs welcome for other test runners (see [here](https://github.com/diffplug/selfie/issues/350) for a guide)
 
 Both disk and inline snapshots can be used with Python test code.