added unit test for blobs, removed most unneeded comments

Author: felix314159

src/ethereum_test_types/blob_types.py

@@ -437,73 +437,6 @@ def corrupt_byte(b: bytes) -> Bytes:
             self.proof = Bytes(b"".join(corrupt_byte(bytes([byte])) for byte in self.proof))
 
 
-# --------- generate static blobs ------------
-# fork_list = [Cancun, Prague, Osaka]
-# amount_static_blobs_per_fork = 10
-# for f in fork_list:
-#     for seed in range(amount_static_blobs_per_fork):
-#         if seed < 4:
-#             timestamp = 0
-#         elif seed < 7:
-#             timestamp = 1000000000
-#         else:
-#             timestamp = 1747905411
-
-#         static_blob: Blob = Blob.from_fork(f, seed, timestamp)
-#         static_blob.write_to_file()
-# --------------------------------------------
-
-# myosaka: Fork = Osaka
-# start = time.perf_counter()
-# amount_of_blobs = 1000
-# for s in range(amount_of_blobs):
-#     b: Blob = Blob.from_fork(myosaka, s)
-#     b.write_to_file()
-# end = time.perf_counter()
-# duration_ms = (end - start) * 1000
-# print(f"Generated and wrote {amount_of_blobs} blobs to disk in: {duration_ms:.3f} ms")
-
-
-# myosaka: Fork = Osaka
-# print(f"Fork test print: {myosaka.name()}")
-# myprague: Fork = Prague
-# mycancun: Fork = Cancun
-# myseed: int = 1337  # fork+seed is the unique ID of a blob
-# mytimestamp: int = 168123123
-# # test 1: blob construction
-# b: Blob = Blob.from_fork(myosaka, myseed, mytimestamp)
-# # test 2: reconstruction from json
-# json_str: str = b.write_to_file()
-# restored: Blob = Blob.from_file("blob_1337_cell_proofs_128")
-# assert b.data == restored.data
-# assert b.commitment == restored.commitment
-# assert b.proof == restored.proof
-# assert b.cells == restored.cells
-# assert b.versioned_hash == restored.versioned_hash
-# assert b.name == restored.name
-# assert b.fork == restored.fork
-# assert b.seed == restored.seed
-# assert b.timestamp == restored.timestamp
-# print(type(b.proof), len(b.proof))
-# # test 3: write to file
-# b.write_to_file()
-# # test 4: read from file
-# bzzz = Blob.from_file("blob_1337_cell_proofs_128")
-# print("read osaka blob file from cache dir")
-# # test 5: prague blob creation + write
-# d: Blob = Blob.from_fork(myprague, myseed, 123)
-# d.write_to_file()
-# # test 6: reading prague from file
-# e: Blob = Blob.from_file("blob_1337_cell_proofs_0")
-# print("read prague blob file from cache dir")
-# # test 7: cancun (will overwrite prague blob cuz same target filename)
-# dddddde: Blob = Blob.from_fork(mycancun, myseed, 123)
-# dddddde.write_to_file()
-# print("line above should say file existed already (cancun overwrites prague)")
-# # test 8: non-blob forks can't create blobs
-# # myparis: Fork = Paris
-# # parisapriaparip: Blob = Blob.from_fork(myparis, myseed, 123)
-
 # test fork_at for when timestamp > 0
 # transitionfork: Fork = Cancun
 # new_timestamp = 15000  # is supposed to return prague, but still returns cancun.. TODO: ?
@@ -519,21 +452,3 @@ def corrupt_byte(b: bytes) -> Bytes:
 # assert transitionforkblob.fork == restored_transitionforkblob.fork
 # assert transitionforkblob.seed == restored_transitionforkblob.seed
 # assert transitionforkblob.timestamp == restored_transitionforkblob.timestamp
-
-# # test proof corruption
-# #  osaka
-# testseed = 55
-# ddd: Blob = Blob.from_fork(Osaka, testseed + 10)
-# assert isinstance(ddd.proof[0], bytes)  # mypy fix
-# oldValue = ddd.proof[0][5]
-# for m in Blob.ProofCorruptionMode:
-#     ddd.corrupt_proof(m)
-# print("proof corruption works (osaka):", oldValue != ddd.proof[0][5])
-# #   prague
-# eeeeeeeeee: Blob = Blob.from_fork(Prague, testseed + 11)
-# assert isinstance(eeeeeeeeee.proof[5], int)  # mypy fix
-# oldValue = eeeeeeeeee.proof[5]
-# for m in Blob.ProofCorruptionMode:
-#     eeeeeeeeee.corrupt_proof(m)
-# print("proof corruption works (prague):", oldValue != eeeeeeeeee.proof[5])
-# print("pydantic model works")

src/ethereum_test_types/tests/test_blob_types.py

@@ -0,0 +1,77 @@
+"""Test suite for blobs."""
+
+import copy
+
+import pytest
+
+from ethereum_test_forks import (
+    Cancun,
+    Osaka,
+    Prague,
+)
+
+from ..blob_types import Blob
+
+
+@pytest.mark.parametrize("seed", [0, 10, 100])
+@pytest.mark.parametrize("fork", [Cancun, Prague, Osaka])
+def test_blob_creation_and_writing_and_reading(
+    seed,
+    fork,
+):  # noqa: F811
+    """
+    Generates blobs for different forks and ensures writing to file
+    and reading from file works as expected.
+    """
+    timestamp = 100
+    b = Blob.from_fork(fork=fork, seed=seed, timestamp=timestamp)
+    b.write_to_file()
+
+    # read from file
+    #       determine what filename would be
+    cell_proof_amount = str(fork.get_blob_constant("AMOUNT_CELL_PROOFS"))
+    file_name = "blob_" + str(seed) + "_cell_proofs_" + cell_proof_amount + ".json"
+    #       read
+    restored = Blob.from_file(file_name)
+
+    # ensure file you read equals file you wrote
+    assert b.data == restored.data
+    assert b.commitment == restored.commitment
+    assert b.proof == restored.proof
+    assert b.cells == restored.cells
+    assert b.versioned_hash == restored.versioned_hash
+    assert b.name == restored.name
+    assert b.fork == restored.fork
+    assert b.seed == restored.seed
+    assert b.timestamp == restored.timestamp
+
+    print("SUCCESSFUL UNIT TEST")
+
+
+@pytest.mark.parametrize(
+    "corruption_mode",
+    [
+        Blob.ProofCorruptionMode.CORRUPT_ALL_BYTES,
+        Blob.ProofCorruptionMode.CORRUPT_FIRST_BYTE,
+        Blob.ProofCorruptionMode.CORRUPT_LAST_BYTE,
+        Blob.ProofCorruptionMode.CORRUPT_TO_ALL_ZEROES,
+    ],
+)
+@pytest.mark.parametrize("fork", [Cancun, Prague, Osaka])
+def test_blob_proof_corruption(
+    corruption_mode,
+    fork,
+):
+    """
+    Generates blobs for different forks, corrupts their proofs and ensures that
+    the corrupted proof is not equal to the correct proof.
+    """
+    timestamp = 100
+    b = Blob.from_fork(fork=fork, timestamp=timestamp)
+    old_valid_proof = copy.deepcopy(b.proof)  # important to deepcopy
+
+    b.corrupt_proof(corruption_mode)
+    assert b.proof != old_valid_proof, (
+        f"Proof corruption mode {corruption_mode} for fork {fork.name()} failed, "
+        "proof is unchanged!"
+    )