add more tests

Author: boblat

src/_algopy_testing/primitives/bytes.py

@@ -43,11 +43,8 @@ def __bool__(self) -> bool:
     def __add__(self, other: Bytes | bytes) -> Bytes:
         """Concatenate Bytes with another Bytes or bytes literal e.g. `Bytes(b"Hello ")
         + b"World"`."""
-        if isinstance(other, Bytes):
-            return _checked_result(self.value + other.value, "+")
-        else:
-            result = self.value + as_bytes(other)
-            return _checked_result(result, "+")
+        result = self.value + as_bytes(other)
+        return _checked_result(result, "+")
 
     def __radd__(self, other: bytes) -> Bytes:
         """Concatenate Bytes with another Bytes or bytes literal e.g. `b"Hello " +

src/_algopy_testing/primitives/fixed_bytes.py

@@ -20,24 +20,31 @@
 _TBytesLength_Arg = typing.TypeVar("_TBytesLength_Arg", bound=int)
 
 
+def _create_class(cls: type, length: int) -> type:
+    cls_name = f"{cls.__name__}[{length}]"
+    return types.new_class(
+        cls_name,
+        bases=(cls,),
+        exec_body=lambda ns: ns.update(
+            _length=length,
+        ),
+    )
+
+
 class _FixedBytesMeta(type):
     __concrete__: typing.ClassVar[dict[type, type]] = {}
 
     # get or create a type that is parametrized with element_t and length
     def __getitem__(cls, length_t: type) -> type:
+        if length_t == typing.Any:
+            return cls
+
         cache = cls.__concrete__
         if c := cache.get(length_t, None):
             return c
 
         length = get_int_literal_from_type_generic(length_t)
-        cls_name = f"{cls.__name__}[{length}]"
-        cache[length_t] = c = types.new_class(
-            cls_name,
-            bases=(cls,),
-            exec_body=lambda ns: ns.update(
-                _length=length,
-            ),
-        )
+        cache[length_t] = c = _create_class(cls, length)
 
         return c
 
@@ -63,9 +70,13 @@ def __init__(self, value: Bytes | bytes | None = None, /):
         if value is None:
             self.value = b"\x00" * self._length
             return
+
         self.value = as_bytes(value)
+        if not hasattr(self, "_length"):
+            self._length = len(self.value)
+
         if len(self.value) != self._length:
-            raise TypeError(f"expected value of length {self._length}, not {len(self.value)}")
+            raise ValueError(f"expected value of length {self._length}, not {len(self.value)}")
 
     def __repr__(self) -> str:
         return repr(self.value)
@@ -74,10 +85,10 @@ def __str__(self) -> str:
         return str(self.value)
 
     def __bool__(self) -> bool:
-        return bool(self.value)
+        return bool(self._length)
 
     def __len__(self) -> int:
-        return len(self.value)
+        return self._length
 
     # mypy suggests due to Liskov below should be other: object
     # need to consider ramifications here, ignoring it for now
@@ -96,25 +107,19 @@ def __hash__(self) -> int:
     def __add__(self, other: FixedBytes[_TBytesLength_Arg] | Bytes | bytes) -> Bytes:
         """Concatenate FixedBytes with another Bytes or bytes literal e.g.
         `FixedBytes[typing.Literal[5]](b"Hello ") + b"World"`."""
-        if isinstance(other, (Bytes | FixedBytes)):
-            return _checked_result(self.value + other.value, "+")
-        else:
-            result = self.value + as_bytes(other)
-            return _checked_result(result, "+")
+        result = self.value + as_bytes(other)
+        return _checked_result(result, "+")
 
-    def __radd__(self, other: Bytes | bytes) -> Bytes:
+    def __radd__(self, other: FixedBytes[_TBytesLength_Arg] | Bytes | bytes) -> Bytes:
         """Concatenate FixedBytes with another Bytes or bytes literal e.g. `b"Hello " +
         FixedBytes[typing.Literal[5]](b"World")`."""
-        if isinstance(other, (Bytes | FixedBytes)):
-            return _checked_result(other.value + self.value, "+")
-        else:
-            result = as_bytes(other) + self.value
-            return _checked_result(result, "+")
+        result = as_bytes(other) + self.value
+        return _checked_result(result, "+")
 
     @property
     def length(self) -> UInt64:
         """Returns the length of the Bytes."""
-        return UInt64(len(self.value))
+        return UInt64(self._length)
 
     def __getitem__(
         self, index: UInt64 | int | slice
@@ -126,6 +131,8 @@ def __getitem__(
         else:
             int_index = index.value if isinstance(index, UInt64) else index
             int_index = len(self.value) + int_index if int_index < 0 else int_index
+            if (int_index >= len(self.value)) or (int_index < 0):
+                raise ValueError("FixedBytes index out of range")
             # my_bytes[0:1] => b'j' whereas my_bytes[0] => 106
             return Bytes(self.value[slice(int_index, int_index + 1)])
 
@@ -139,55 +146,77 @@ def __reversed__(self) -> Iterator[Bytes]:
         return _FixedBytesIter(self, -1)
 
     @typing.overload
-    def __and__(self, other: FixedBytes[_TBytesLength]) -> FixedBytes[_TBytesLength]:  # type: ignore[overload-overlap]
-        ...
-
+    def __and__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
     @typing.overload
-    def __and__(self, other: FixedBytes[typing.Any] | bytes | Bytes) -> Bytes: ...
-
-    def __and__(
-        self, other: FixedBytes[typing.Any] | bytes | Bytes
-    ) -> FixedBytes[_TBytesLength] | Bytes:
+    def __and__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __and__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
         """Compute the bitwise AND of the FixedBytes with another FixedBytes, Bytes, or
         bytes.
 
         Returns FixedBytes if other has the same length, otherwise returns Bytes.
         """
         return self._operate_bitwise(other, "and_")
 
-    def __rand__(self, other: FixedBytes[typing.Any] | bytes | Bytes) -> Bytes:
+    @typing.overload
+    def __rand__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __rand__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __rand__(
+        self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes
+    ) -> typing.Self | Bytes:
         return self & other
 
-    @typing.overload
-    def __or__(self, other: FixedBytes[_TBytesLength]) -> FixedBytes[_TBytesLength]:  # type: ignore[overload-overlap]
-        ...
+    def __iand__(self, other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        other_bytes = as_bytes(other)
+        other_fixed_bytes = self.__class__(other_bytes)
+        result = self._operate_bitwise(other_fixed_bytes, "and_")
+        assert isinstance(result, self.__class__)
+        return result
 
     @typing.overload
-    def __or__(self, other: FixedBytes[typing.Any] | bytes | Bytes) -> Bytes: ...
-
-    def __or__(
-        self, other: FixedBytes[typing.Any] | bytes | Bytes
-    ) -> FixedBytes[_TBytesLength] | Bytes:
+    def __or__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __or__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __or__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
         return self._operate_bitwise(other, "or_")
 
-    def __ror__(self, other: FixedBytes[typing.Any] | bytes | Bytes) -> Bytes:
+    @typing.overload
+    def __ror__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __ror__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __ror__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
         return self | other
 
-    @typing.overload
-    def __xor__(self, other: FixedBytes[_TBytesLength]) -> FixedBytes[_TBytesLength]:  # type: ignore[overload-overlap]
-        ...
+    def __ior__(self, other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        other_bytes = as_bytes(other)
+        other_fixed_bytes = self.__class__(other_bytes)
+        result = self._operate_bitwise(other_fixed_bytes, "or_")
+        assert isinstance(result, self.__class__)
+        return result
 
     @typing.overload
-    def __xor__(self, other: FixedBytes[typing.Any] | bytes | Bytes) -> Bytes: ...
-
-    def __xor__(
-        self, other: FixedBytes[typing.Any] | bytes | Bytes
-    ) -> FixedBytes[_TBytesLength] | Bytes:
+    def __xor__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __xor__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __xor__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
         return self._operate_bitwise(other, "xor")
 
-    def __rxor__(self, other: FixedBytes[typing.Any] | bytes | Bytes) -> Bytes:
+    @typing.overload
+    def __rxor__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __rxor__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __rxor__(
+        self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes
+    ) -> typing.Self | Bytes:
         return self ^ other
 
+    def __ixor__(self, other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        other_bytes = as_bytes(other)
+        other_fixed_bytes = self.__class__(other_bytes)
+        result = self._operate_bitwise(other_fixed_bytes, "xor")
+        assert isinstance(result, self.__class__)
+        return result
+
     def __invert__(self) -> typing.Self:
         """Compute the bitwise inversion of the Bytes.
 
@@ -198,9 +227,9 @@ def __invert__(self) -> typing.Self:
 
     def _operate_bitwise(
         self,
-        other: FixedBytes[typing.Any] | bytes | Bytes,
+        other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes,
         operator_name: str,
-    ) -> FixedBytes[_TBytesLength] | Bytes:
+    ) -> typing.Self | Bytes:
         op = getattr(operator, operator_name)
         maybe_bytes = as_bytes(other)
         # pad the shorter of self.value and other bytes with leading zero
@@ -227,27 +256,32 @@ def from_base32(cls, value: str) -> typing.Self:
         """Creates Bytes from a base32 encoded string e.g.
         `Bytes.from_base32("74======")`"""
         bytes_value = base64.b32decode(value)
-        return cls(bytes_value)
+        c = _create_class(cls, len(bytes_value)) if not hasattr(cls, "_length") else cls
+        return c(bytes_value)  # type: ignore[no-any-return]
 
     @classmethod
     def from_base64(cls, value: str) -> typing.Self:
         """Creates Bytes from a base64 encoded string e.g.
         `Bytes.from_base64("RkY=")`"""
         bytes_value = base64.b64decode(value)
-        return cls(bytes_value)
+        c = _create_class(cls, len(bytes_value)) if not hasattr(cls, "_length") else cls
+        return c(bytes_value)  # type: ignore[no-any-return]
 
     @classmethod
     def from_hex(cls, value: str) -> typing.Self:
         """Creates Bytes from a hex/octal encoded string e.g. `Bytes.from_hex("FF")`"""
         bytes_value = base64.b16decode(value)
-        return cls(bytes_value)
+        c = _create_class(cls, len(bytes_value)) if not hasattr(cls, "_length") else cls
+        return c(bytes_value)  # type: ignore[no-any-return]
 
     @classmethod
     def from_bytes(cls, value: Bytes | bytes) -> typing.Self:
         """Construct an instance from the underlying bytes (no validation)"""
-        result = cls()
-        result.value = as_bytes(value)
-        return result
+        bytes_value = as_bytes(value)
+        c = _create_class(cls, len(bytes_value)) if not hasattr(cls, "_length") else cls
+        result = c()
+        result.value = bytes_value
+        return result  # type: ignore[no-any-return]
 
     @property
     def bytes(self) -> Bytes: