refactor: Better exception def

Author: marioevz

src/ethereum_test_fixtures/pre_alloc_groups.py

@@ -1,33 +1,19 @@
 """Pre-allocation group models for test fixture generation."""
 
+import json
 from pathlib import Path
 from typing import Any, Dict, List
 
 from filelock import FileLock
 from pydantic import Field, computed_field
 
-from ethereum_test_base_types import Account, Address, CamelModel, EthereumTestRootModel
+from ethereum_test_base_types import CamelModel, EthereumTestRootModel
 from ethereum_test_forks import Fork
 from ethereum_test_types import Alloc, Environment
-from ethereum_test_types.account_types import CollisionError
 
 from .blockchain import FixtureHeader
 
 
-class Collision(CamelModel):
-    """Model to describe two different accounts set to the same addres by two different tests."""
-
-    address: Address
-    account_1: Account
-    account_2: Account
-
-    def exception(self) -> CollisionError:
-        """Return the collision exception."""
-        return CollisionError(
-            address=self.address, account_1=self.account_1, account_2=self.account_2
-        )
-
-
 class PreAllocGroup(CamelModel):
     """
     Pre-allocation group for tests with identical Environment and fork values.
@@ -83,14 +69,14 @@ def to_file(self, file: Path) -> None:
                             # and is not reported to the master thread.
                             # We signal here that the groups created contain a collision.
                             collision_file_path = file.with_suffix(".fail")
-                            collision_exception = Collision(
+                            collision_exception = Alloc.CollisionError(
                                 address=account,
                                 account_1=existing_account,
                                 account_2=new_account,
                             )
                             with open(collision_file_path, "w") as f:
-                                f.write(collision_exception.model_dump_json(indent=2))
-                            raise collision_exception.exception()
+                                f.write(json.dumps(collision_exception.to_json()))
+                            raise collision_exception
                 self.test_ids.extend(previous_pre_alloc_group.test_ids)
 
             with open(file, "w") as f:
@@ -112,7 +98,7 @@ def from_folder(cls, folder: Path) -> "PreAllocGroups":
         # First check for collision failures
         for fail_file in folder.glob("*.fail"):
             with open(fail_file) as f:
-                raise Collision.model_validate_json(f.read()).exception()
+                raise Alloc.CollisionError.from_json(json.loads(f.read()))
         data = {}
         for file in folder.glob("*.json"):
             with open(file) as f:

src/ethereum_test_types/account_types.py

@@ -1,14 +1,14 @@
 """Account-related types for Ethereum tests."""
 
+import json
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from typing import Dict, List, Literal, Optional, Tuple
+from typing import Any, Dict, List, Literal, Optional, Self, Tuple
 
 from coincurve.keys import PrivateKey
 from ethereum_types.bytes import Bytes20
 from ethereum_types.numeric import U256, Bytes32, Uint
 from pydantic import PrivateAttr
-from typing_extensions import Self
 
 from ethereum_test_base_types import (
     Account,
@@ -133,25 +133,6 @@ def copy(self) -> Self:
         return self.__class__(Address(self), key=self.key, nonce=self.nonce)
 
 
-class CollisionError(Exception):
-    """Exception raised when two tests describe different accounts at the same address."""
-
-    def __init__(self, address: Address, account_1: Account, account_2: Account):
-        """Initialize the exception."""
-        self.address = address
-        self.account_1 = account_1
-        self.account_2 = account_2
-
-    def __str__(self) -> str:
-        """Exception message."""
-        return (
-            "Overlapping key defining different accounts detected:\n"
-            f"address={self.address}:\n"
-            f"account_1={self.account_1.model_dump_json(indent=2)}\n"
-            f"account_2={self.account_2.model_dump_json(indent=2)}"
-        )
-
-
 class Alloc(BaseAlloc):
     """Allocation of accounts in the state, pre and post test execution."""
 
@@ -164,12 +145,6 @@ class UnexpectedAccountError(Exception):
         address: Address
         account: Account | None
 
-        def __init__(self, address: Address, account: Account | None, *args):
-            """Initialize the exception."""
-            super().__init__(args)
-            self.address = address
-            self.account = account
-
         def __str__(self):
             """Print exception string."""
             return f"unexpected account in allocation {self.address}: {self.account}"
@@ -180,15 +155,50 @@ class MissingAccountError(Exception):
 
         address: Address
 
-        def __init__(self, address: Address, *args):
-            """Initialize the exception."""
-            super().__init__(args)
-            self.address = address
-
         def __str__(self):
             """Print exception string."""
             return f"Account missing from allocation {self.address}"
 
+    @dataclass(kw_only=True)
+    class CollisionError(Exception):
+        """Different accounts at the same address."""
+
+        address: Address
+        account_1: Account | None
+        account_2: Account | None
+
+        def to_json(self) -> Dict[str, Any]:
+            """Dump to json object."""
+            return {
+                "address": self.address.hex(),
+                "account_1": self.account_1.model_dump(mode="json")
+                if self.account_1 is not None
+                else None,
+                "account_2": self.account_2.model_dump(mode="json")
+                if self.account_2 is not None
+                else None,
+            }
+
+        @classmethod
+        def from_json(cls, obj: Dict[str, Any]) -> Self:
+            """Parse from a json dict."""
+            return cls(
+                address=Address(obj["address"]),
+                account_1=Account.model_validate(obj["account_1"])
+                if obj["account_1"] is not None
+                else None,
+                account_2=Account.model_validate(obj["account_2"])
+                if obj["account_2"] is not None
+                else None,
+            )
+
+        def __str__(self) -> str:
+            """Print exception string."""
+            return (
+                "Overlapping key defining different accounts detected:\n"
+                f"{json.dumps(self.to_json(), indent=2)}"
+            )
+
     class KeyCollisionMode(Enum):
         """Mode for handling key collisions when merging allocations."""
 
@@ -216,7 +226,7 @@ def merge(
                     account_1 = alloc_1[key]
                     account_2 = alloc_2[key]
                     if account_1 != account_2:
-                        raise CollisionError(
+                        raise Alloc.CollisionError(
                             address=key,
                             account_1=account_1,
                             account_2=account_2,
@@ -309,15 +319,17 @@ def verify_post_alloc(self, got_alloc: "Alloc"):
             if account is None:
                 # Account must not exist
                 if address in got_alloc.root and got_alloc.root[address] is not None:
-                    raise Alloc.UnexpectedAccountError(address, got_alloc.root[address])
+                    raise Alloc.UnexpectedAccountError(
+                        address=address, account=got_alloc.root[address]
+                    )
             else:
                 if address in got_alloc.root:
                     got_account = got_alloc.root[address]
                     assert isinstance(got_account, Account)
                     assert isinstance(account, Account)
                     account.check_alloc(address, got_account)
                 else:
-                    raise Alloc.MissingAccountError(address)
+                    raise Alloc.MissingAccountError(address=address)
 
     def deploy_contract(
         self,