plexus-python-pulse-common 1.1.85__tar.gz → 1.1.87__tar.gz

{plexus_python_pulse_common-1.1.85 → plexus_python_pulse_common-1.1.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-pulse-common
-Version: 1.1.85
+Version: 1.1.87
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_pulse_common-1.1.85 → plexus_python_pulse_common-1.1.87}/src/plexus/pulse/common/utils/ormutils.py

@@ -948,6 +948,14 @@ def make_snapshot_model_trigger[SnapshotModelT: SnapshotModelMixin](engine: sa.E
                 NEW."expired_at" := NULL;
                 NEW."record_sqn" := nextval('{record_sqn_seq_name}');
             ELSE
+                -- Serialize transitions even when there is no active version.
+                PERFORM "sqn" FROM "{table_name}"
+                WHERE "record_sqn" = NEW."record_sqn"
+                ORDER BY "sqn" LIMIT 1 FOR UPDATE;
+                IF NOT FOUND THEN
+                    RAISE EXCEPTION 'record_sqn % does not exist', NEW."record_sqn";
+                END IF;
+
                 IF NEW."created_at" IS NULL THEN
                     NEW."created_at" := CURRENT_TIMESTAMP;
                 END IF;
@@ -1019,6 +1027,14 @@ def make_revision_model_trigger[RevisionModelT: RevisionModelMixin](engine: sa.E
                 NEW."record_sqn" := nextval('{record_sqn_seq_name}');
                 NEW."revision" := 1;
             ELSE
+                -- Serialize transitions even when there is no active version.
+                PERFORM "sqn" FROM "{table_name}"
+                WHERE "record_sqn" = NEW."record_sqn"
+                ORDER BY "sqn" LIMIT 1 FOR UPDATE;
+                IF NOT FOUND THEN
+                    RAISE EXCEPTION 'record_sqn % does not exist', NEW."record_sqn";
+                END IF;
+
                 SELECT MAX("created_at") INTO NEW."created_at"
                 FROM "{table_name}"
                 WHERE "record_sqn" = NEW."record_sqn";
@@ -1070,6 +1086,7 @@ def clone_sequence_model_instance[SequenceModelT: SequenceModelMixin](
         return instance
     if clear_meta_fields:
         result.sqn = None
+        result.model_fields_set.discard("sqn")
     return result
 
 
@@ -1087,6 +1104,9 @@ def clone_changing_model_instance[ChangingModelT: ChangingModelMixin](
         result.sqn = None
         result.created_at = None
         result.updated_at = None
+        result.model_fields_set.discard("sqn")
+        result.model_fields_set.discard("created_at")
+        result.model_fields_set.discard("updated_at")
     return result
 
 
@@ -1105,6 +1125,10 @@ def clone_snapshot_model_instance[SnapshotModelT: SnapshotModelMixin](
         result.created_at = None
         result.expired_at = None
         result.record_sqn = None
+        result.model_fields_set.discard("sqn")
+        result.model_fields_set.discard("created_at")
+        result.model_fields_set.discard("expired_at")
+        result.model_fields_set.discard("record_sqn")
     return result
 
 
@@ -1125,6 +1149,12 @@ def clone_revision_model_instance[RevisionModelT: RevisionModelMixin](
         result.expired_at = None
         result.record_sqn = None
         result.revision = None
+        result.model_fields_set.discard("sqn")
+        result.model_fields_set.discard("created_at")
+        result.model_fields_set.discard("updated_at")
+        result.model_fields_set.discard("expired_at")
+        result.model_fields_set.discard("record_sqn")
+        result.model_fields_set.discard("revision")
     return result
 
 
@@ -1144,6 +1174,41 @@ def db_make_order_by_clause[SequenceModelT: SequenceModelMixin](
     return order_criteria
 
 
+def db_lock_model_record[ModelT: RevisionModelMixin | SnapshotModelMixin](
+    db: sa_orm.Session,
+    model: type[ModelT],
+    record_sqn: int,
+) -> None:
+    """
+    Lock the first history row, including when the record is inactive.
+
+    Select by ``record_sqn`` rather than assuming it equals the first ``sqn``: trigger-managed
+    records use a separate sequence. Every lifecycle writer must acquire this same lock before
+    reading current state.
+    Locks last until caller commit or rollback. Do not delete the first history row.
+    """
+    db_anchor = (
+        db
+        .query(model)
+        .where(model.record_sqn == record_sqn)
+        .order_by(model.sqn)
+        .limit(1)
+        .with_for_update()
+        .populate_existing()
+        .one_or_none()
+    )
+    if db_anchor is None:
+        raise sa_exc.NoResultFound(f"'{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+
+
+# Mutating helpers flush but never begin, commit, or roll back transactions. Callers must roll
+# back on failure. Row locks serialize cooperating writers on databases supporting SELECT FOR UPDATE;
+# SQLite callers must serialize writes themselves (e.g. begin an IMMEDIATE transaction before
+# reading).
+# At stronger isolation levels, callers must also handle serialization failures by retrying
+# transactions. History rows used as lock anchors must not be deleted while a record exists.
+
+
 def db_create_sequence_model[SequenceModelT: SequenceModelMixin](
     db: sa_orm.Session,
     model: type[SequenceModelT],
@@ -1201,11 +1266,11 @@ def db_update_sequence_model[SequenceModelT: SequenceModelMixin](
     instance: SequenceModelMixin,
     sqn: int,
 ) -> SequenceModelT:
-    db_instance = db.query(model).where(model.sqn == sqn).one_or_none()
+    db_instance = db.query(model).where(model.sqn == sqn).with_for_update().populate_existing().one_or_none()
     if db_instance is None:
         raise sa_exc.NoResultFound(f"'{model_name_of(model)}' of specified sqn '{sqn}' not found")
 
-    db_instance = model_copy_from(db_instance, clone_sequence_model_instance(model, instance), exclude_none=True)
+    db_instance = model_copy_from(db_instance, clone_sequence_model_instance(model, instance), exclude_unset=True)
     clone_sequence_model_instance(model, db_instance, validate_only=True)
     db.flush()
 
@@ -1217,7 +1282,7 @@ def db_delete_sequence_model[SequenceModelT: SequenceModelMixin](
     model: type[SequenceModelT],
     sqn: int,
 ) -> SequenceModelT:
-    db_instance = db.query(model).where(model.sqn == sqn).one_or_none()
+    db_instance = db.query(model).where(model.sqn == sqn).with_for_update().populate_existing().one_or_none()
     if db_instance is None:
         raise sa_exc.NoResultFound(f"'{model_name_of(model)}' of specified sqn '{sqn}' not found")
 
@@ -1265,11 +1330,11 @@ def db_update_changing_model[ChangingModelT: ChangingModelMixin](
     sqn: int,
     updated_at: datetime.datetime,
 ) -> ChangingModelT:
-    db_instance = db.query(model).where(model.sqn == sqn).one_or_none()
+    db_instance = db.query(model).where(model.sqn == sqn).with_for_update().populate_existing().one_or_none()
     if db_instance is None:
         raise sa_exc.NoResultFound(f"'{model_name_of(model)}' of specified sqn '{sqn}' not found")
 
-    db_instance = model_copy_from(db_instance, clone_changing_model_instance(model, instance), exclude_none=True)
+    db_instance = model_copy_from(db_instance, clone_changing_model_instance(model, instance), exclude_unset=True)
     db_instance.updated_at = updated_at
     clone_changing_model_instance(model, db_instance, validate_only=True)
     db.flush()
@@ -1425,7 +1490,14 @@ def db_update_snapshot_model[SnapshotModelT: SnapshotModelMixin](
     record_sqn: int,
     updated_at: datetime.datetime,
 ) -> SnapshotModelT:
-    db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
+    db_lock_model_record(db, model, record_sqn)
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sqn == record_sqn, model.expired_at.is_(None))
+        .populate_existing()
+        .one_or_none()
+    )
     if db_instance is None:
         raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
@@ -1450,10 +1522,12 @@ def db_expire_snapshot_model[SnapshotModelT: SnapshotModelMixin](
     record_sqn: int,
     updated_at: datetime.datetime,
 ) -> SnapshotModelT:
+    db_lock_model_record(db, model, record_sqn)
     db_instance = (
         db
         .query(model)
         .where(model.record_sqn == record_sqn, model.expired_at.is_(None))
+        .populate_existing()
         .one_or_none()
     )
     if db_instance is None:
@@ -1472,16 +1546,24 @@ def db_activate_snapshot_model[SnapshotModelT: SnapshotModelMixin](
     record_sqn: int,
     updated_at: datetime.datetime,
 ) -> SnapshotModelT:
-    db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
+    db_lock_model_record(db, model, record_sqn)
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sqn == record_sqn, model.expired_at.is_(None))
+        .populate_existing()
+        .one_or_none()
+    )
     if db_instance is not None:
         raise sa_exc.MultipleResultsFound(
-            f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' already exists")
+            f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' already exists")
 
     db_instance = (
         db
         .query(model)
         .where(model.record_sqn == record_sqn, model.expired_at.is_not(None))
-        .order_by(model.created_at.desc())
+        .order_by(model.created_at.desc(), model.sqn.desc())
+        .populate_existing()
         .first()
     )
     if db_instance is None:
@@ -1653,7 +1735,14 @@ def db_update_revision_model[RevisionModelT: RevisionModelMixin](
     record_sqn: int,
     updated_at: datetime.datetime,
 ) -> RevisionModelT:
-    db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
+    db_lock_model_record(db, model, record_sqn)
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sqn == record_sqn, model.expired_at.is_(None))
+        .populate_existing()
+        .one_or_none()
+    )
     if db_instance is None:
         raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
@@ -1680,10 +1769,12 @@ def db_expire_revision_model[RevisionModelT: RevisionModelMixin](
     record_sqn: int,
     updated_at: datetime.datetime,
 ) -> RevisionModelT:
+    db_lock_model_record(db, model, record_sqn)
     db_instance = (
         db
         .query(model)
         .where(model.record_sqn == record_sqn, model.expired_at.is_(None))
+        .populate_existing()
         .one_or_none()
     )
     if db_instance is None:
@@ -1702,7 +1793,14 @@ def db_activate_revision_model[RevisionModelT: RevisionModelMixin](
     record_sqn: int,
     updated_at: datetime.datetime,
 ) -> RevisionModelT:
-    db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
+    db_lock_model_record(db, model, record_sqn)
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sqn == record_sqn, model.expired_at.is_(None))
+        .populate_existing()
+        .one_or_none()
+    )
     if db_instance is not None:
         raise sa_exc.MultipleResultsFound(
             f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' already exists")
@@ -1712,6 +1810,7 @@ def db_activate_revision_model[RevisionModelT: RevisionModelMixin](
         .query(model)
         .where(model.record_sqn == record_sqn, model.expired_at.is_not(None))
         .order_by(model.revision.desc())
+        .populate_existing()
         .first()
     )
     if db_instance is None:

{plexus_python_pulse_common-1.1.85 → plexus_python_pulse_common-1.1.87}/src/plexus_python_pulse_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-pulse-common
-Version: 1.1.85
+Version: 1.1.87
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_pulse_common-1.1.85 → plexus_python_pulse_common-1.1.87}/test/plexus_tests/pulse/common/utils/ormutils_test.py

@@ -17,9 +17,17 @@ from sqlmodel import Field, SQLModel
 
 from plexus.pulse.common.utils.apiutils import managed_db_session
 from plexus.pulse.common.utils.ormutils import (
-    changing_model_mixin, make_base_model, make_changing_model_mixin,
-    make_revision_model_mixin, make_revision_model_trigger, make_sequence_model_mixin, make_snapshot_model_mixin,
-    make_snapshot_model_trigger, model_copy_from, revision_model_mixin, snapshot_model_mixin,
+    changing_model_mixin,
+    make_base_model,
+    make_changing_model_mixin,
+    make_revision_model_mixin,
+    make_revision_model_trigger,
+    make_sequence_model_mixin,
+    make_snapshot_model_mixin,
+    make_snapshot_model_trigger,
+    model_copy_from,
+    revision_model_mixin,
+    snapshot_model_mixin,
 )
 from plexus.pulse.common.utils.ormutils import (
     db_activate_revision_model,
@@ -1266,3 +1274,189 @@ class OrmUtilsTest(unittest.TestCase):
         for options in ({"include": {"name": True}}, {"by_alias": True}):
             with self.subTest(options=options), self.assertRaises(TypeError):
                 model_copy_from(CopyRecord(), CopyRecord(), **options)
+
+
+@pytest.mark.parametrize(
+    "functions",
+    [
+        (DummySnapshotModel,
+         db_create_snapshot_model,
+         db_update_snapshot_model,
+         db_expire_snapshot_model,
+         db_activate_snapshot_model,
+         ),
+        (DummyRevisionModel,
+         db_create_revision_model,
+         db_update_revision_model,
+         db_expire_revision_model,
+         db_activate_revision_model,
+         ),
+    ],
+)
+@pytest.mark.parametrize("operation", ["update", "expire", "activate"])
+def test_lifecycle_serializes_on_history_row(fixture_postgresql_test, functions, operation):
+    """An uncommitted transition blocks every other transition, even activation."""
+    info = fixture_postgresql_test.info
+    maker = ConnectionMaker.create(
+        make_scheme(Dialects.postgresql, Drivers.psycopg),
+        host=info.host,
+        port=info.port,
+        username=info.user,
+        database=info.dbname,
+        engine_opts={"connect_args": {"options": "-c timezone=UTC"}},
+    )
+    engine = maker.engine
+    model, create, update, expire, activate = functions
+    now = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
+    payload = DummyModel(dummy_array=[], dummy_json={})
+    try:
+        DummyBaseModel.metadata.create_all(engine)
+        with maker.make_session() as session, session.begin():
+            record_sqn = create(session, model, payload, now).record_sqn
+            # The first history row is now inactive, but remains the lock anchor.
+            update(session, model, payload, record_sqn, now + datetime.timedelta(hours=1))
+
+        with maker.make_session() as first_session, maker.make_session() as second_session:
+            # Expiration locks the anchor until the caller finishes its transaction.
+            expire(first_session, model, record_sqn, now + datetime.timedelta(days=1))
+            second_session.execute(sa.text("SET LOCAL lock_timeout = '200ms'"))
+            with pytest.raises(sa_exc.OperationalError) as error:
+                if operation == "update":
+                    update(second_session, model, payload, record_sqn, now + datetime.timedelta(days=2))
+                elif operation == "expire":
+                    expire(second_session, model, record_sqn, now + datetime.timedelta(days=2))
+                else:
+                    activate(second_session, model, record_sqn, now + datetime.timedelta(days=2))
+            assert error.value.orig.sqlstate == "55P03"  # lock_not_available
+            second_session.rollback()
+            first_session.commit()
+
+            # The anchor still exists with no active version; activation can proceed.
+            active = activate(second_session, model, record_sqn, now + datetime.timedelta(days=2))
+            assert active.expired_at is None
+            second_session.commit()
+    finally:
+        maker.reset_engine()
+
+
+def test_revision_update_refreshes_cached_version(fixture_postgresql_test):
+    """A long-lived session must not overwrite a concurrently expired version."""
+    info = fixture_postgresql_test.info
+    maker = ConnectionMaker.create(
+        make_scheme(Dialects.postgresql, Drivers.psycopg),
+        host=info.host,
+        port=info.port,
+        username=info.user,
+        database=info.dbname,
+        engine_opts={"connect_args": {"options": "-c timezone=UTC"}},
+    )
+    engine = maker.engine
+    now = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
+    payload = DummyModel(dummy_array=[], dummy_json={})
+    try:
+        DummyBaseModel.metadata.create_all(engine)
+        with maker.make_session() as session, session.begin():
+            record_sqn = db_create_revision_model(session, DummyRevisionModel, payload, now).record_sqn
+        with maker.make_session() as stale_session, maker.make_session() as writer_session:
+            cached = db_read_active_revision_model_of_record(stale_session, DummyRevisionModel, record_sqn)
+            db_update_revision_model(writer_session,
+                                     DummyRevisionModel,
+                                     payload,
+                                     record_sqn,
+                                     now + datetime.timedelta(days=1))
+            writer_session.commit()
+            result = db_update_revision_model(stale_session,
+                                              DummyRevisionModel,
+                                              payload,
+                                              record_sqn,
+                                              now + datetime.timedelta(days=2))
+            assert result.revision == 3
+            assert cached.expired_at == now + datetime.timedelta(days=1)
+            stale_session.commit()
+    finally:
+        maker.reset_engine()
+
+
+NullableUpdateBase = make_base_model()
+
+
+class NullableSequenceUpdateModel(NullableUpdateBase, make_sequence_model_mixin("sqlite"), table=True):
+    name: str | None = None
+    count: int = 0
+
+
+class NullableChangingUpdateModel(NullableUpdateBase, make_changing_model_mixin("sqlite"), table=True):
+    name: str | None = None
+    count: int = 0
+
+
+class NullableUpdateInput(pdt.BaseModel):
+    """Non-table input, including metadata that the helpers must ignore."""
+    sqn: int | None = None
+    name: str | None = None
+    count: int | None = 0
+    created_at: datetime.datetime | None = None
+    updated_at: datetime.datetime | None = None
+
+
+@pytest.fixture(params=[NullableSequenceUpdateModel, NullableChangingUpdateModel])
+def nullable_update_session(request):
+    model = request.param
+    engine = sa.create_engine("sqlite://")
+    NullableUpdateBase.metadata.create_all(engine)
+    now = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
+    try:
+        with sa.orm.Session(engine) as session:
+            row = model(name="keep", count=7)
+            if model is NullableChangingUpdateModel:
+                row.created_at = now
+                row.updated_at = now
+            session.add(row)
+            session.flush()
+            sqn = row.sqn
+
+            def update(payload):
+                if model is NullableChangingUpdateModel:
+                    return db_update_changing_model(session, model, payload, sqn, now + datetime.timedelta(days=1))
+                return db_update_sequence_model(session, model, payload, sqn)
+
+            yield session, model, sqn, now, update
+    finally:
+        engine.dispose()
+
+
+def test_update_explicit_none_clears_nullable_field(nullable_update_session):
+    session, model, sqn, now, update = nullable_update_session
+    supplied_time = now - datetime.timedelta(days=1)
+    result = update(NullableUpdateInput(
+        name=None, count=7, sqn=sqn + 100,
+        created_at=supplied_time, updated_at=supplied_time,
+    ))
+    # Reload to verify persistence, not just the Python object's value.
+    session.expire_all()
+    stored = session.get(model, sqn)
+    assert stored is result
+    assert stored.name is None
+    assert stored.count == 7
+    assert stored.sqn == sqn
+    if model is NullableChangingUpdateModel:
+        assert stored.created_at == now
+        assert stored.updated_at == now + datetime.timedelta(days=1)
+
+
+def test_update_explicit_default_is_copied(nullable_update_session):
+    session, model, sqn, _, update = nullable_update_session
+    update(NullableUpdateInput(name="changed", count=0))
+    session.expire_all()
+    stored = session.get(model, sqn)
+    assert stored.name == "changed"
+    assert stored.count == 0
+
+
+def test_update_none_rejected_for_non_nullable_field(nullable_update_session):
+    session, model, sqn, _, update = nullable_update_session
+    with pytest.raises(pdt.ValidationError):
+        update(NullableUpdateInput(name="changed", count=None))
+    stored = session.get(model, sqn)
+    assert stored.name == "keep"
+    assert stored.count == 7

{plexus_python_pulse_common-1.1.85 → plexus_python_pulse_common-1.1.87}/test/plexus_tests/pulse/common/utils/s3utils_test.py

@@ -43,8 +43,9 @@ class S3UtilsTest(unittest.TestCase):
             result = list(s3_list_objects(client, "dummy-bucket", "dummy_prefix/"))
 
             for key, text in data:
-                self.assertTrue(any(o.key == key for o in result))
-                self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
+                with self.subTest(progressed_client=False, key=key):
+                    self.assertTrue(any(o.key == key for o in result))
+                    self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
 
         with moto.mock_aws(), s3_make_progressed_client() as client:
             client.create_bucket(Bucket="dummy-bucket")
@@ -61,8 +62,9 @@ class S3UtilsTest(unittest.TestCase):
             result = list(s3_list_objects(client, "dummy-bucket", "dummy_prefix/"))
 
             for key, text in data:
-                self.assertTrue(any(o.key == key for o in result))
-                self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
+                with self.subTest(progressed_client=True, key=key):
+                    self.assertTrue(any(o.key == key for o in result))
+                    self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
 
     def test_s3_list_files__random_text_files(self):
         with moto.mock_aws(), s3_make_client() as client:
@@ -80,8 +82,9 @@ class S3UtilsTest(unittest.TestCase):
             result = list(s3_list_files(client, "dummy-bucket", "dummy_prefix/"))
 
             for key, text in data:
-                self.assertTrue(any(o.key == key for o in result))
-                self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
+                with self.subTest(progressed_client=False, key=key):
+                    self.assertTrue(any(o.key == key for o in result))
+                    self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
 
         with moto.mock_aws(), s3_make_progressed_client() as client:
             client.create_bucket(Bucket="dummy-bucket")
@@ -98,8 +101,9 @@ class S3UtilsTest(unittest.TestCase):
             result = list(s3_list_files(client, "dummy-bucket", "dummy_prefix/"))
 
             for key, text in data:
-                self.assertTrue(any(o.key == key for o in result))
-                self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
+                with self.subTest(progressed_client=True, key=key):
+                    self.assertTrue(any(o.key == key for o in result))
+                    self.assertEqual(s3_pull_text(client, "dummy-bucket", key), text)
 
     data_s3_list_files = [
         (
@@ -498,14 +502,15 @@ class S3UtilsTest(unittest.TestCase):
                 ["s3utils_archive/archive.uncompressed.zip", "s3utils_archive/archive.compressed.zip"],
                 [local_members, None],
             ):
-                archive_size, member_zip_infos, missed_members = s3_archive_list_files(client,
-                                                                                       "dummy-bucket",
-                                                                                       archive_key,
-                                                                                       members)
+                with self.subTest(archive_key=archive_key, members=members):
+                    archive_size, member_zip_infos, missed_members = s3_archive_list_files(client,
+                                                                                           "dummy-bucket",
+                                                                                           archive_key,
+                                                                                           members)
 
-                self.assertEqual(archive_size - sum(info.compress_size for info in member_zip_infos), 2470)
-                self.assertEqual(set(info.filename for info in member_zip_infos), set(local_members))
-                self.assertEqual(len(missed_members), 0)
+                    self.assertEqual(archive_size - sum(info.compress_size for info in member_zip_infos), 2470)
+                    self.assertEqual(set(info.filename for info in member_zip_infos), set(local_members))
+                    self.assertEqual(len(missed_members), 0)
 
             for archive_key, (members, members_expect) in itertools.product(
                 ["s3utils_archive/archive.uncompressed.zip", "s3utils_archive/archive.compressed.zip"],
@@ -533,13 +538,14 @@ class S3UtilsTest(unittest.TestCase):
                   ),
                  ],
             ):
-                archive_size, member_zip_infos, missed_members = s3_archive_list_files(client,
-                                                                                       "dummy-bucket",
-                                                                                       archive_key,
-                                                                                       members)
+                with self.subTest(archive_key=archive_key, members=members):
+                    archive_size, member_zip_infos, missed_members = s3_archive_list_files(client,
+                                                                                           "dummy-bucket",
+                                                                                           archive_key,
+                                                                                           members)
 
-                self.assertEqual(sorted(list(info.filename for info in member_zip_infos)), sorted(members_expect))
-                self.assertEqual(len(missed_members), 0)
+                    self.assertEqual(sorted(list(info.filename for info in member_zip_infos)), sorted(members_expect))
+                    self.assertEqual(len(missed_members), 0)
 
     def test_s3_archive_open_member(self):
         with (
@@ -562,6 +568,7 @@ class S3UtilsTest(unittest.TestCase):
             ):
                 for local_member in local_members:
                     with (
+                        self.subTest(archive_key=archive_key, mode=mode, member=local_member),
                         open(local_root / local_member, mode) as local_fh,
                         s3_archive_open_member(client, "dummy-bucket", archive_key, local_member, mode) as s3_fh,
                     ):
@@ -589,14 +596,25 @@ class S3UtilsTest(unittest.TestCase):
                 [False, True, s3_archive_use_ranged_requests()],
                 [False, True, s3_archive_use_chunked_reads()],
             ):
-                for member, opener in s3_archive_open_members(
-                    client,
-                    "dummy-bucket",
-                    archive_key,
-                    members,
-                    mode,
+                with self.subTest(
+                    archive_key=archive_key,
+                    members=members,
+                    mode=mode,
                     use_ranged_requests=use_ranged_requests,
                     use_chunked_reads=use_chunked_reads,
                 ):
-                    with open(local_root / member, mode) as local_fh, opener() as s3_fh:
-                        self.assertEqual(local_fh.read(), s3_fh.read())
+                    for member, opener in s3_archive_open_members(
+                        client,
+                        "dummy-bucket",
+                        archive_key,
+                        members,
+                        mode,
+                        use_ranged_requests=use_ranged_requests,
+                        use_chunked_reads=use_chunked_reads,
+                    ):
+                        with (
+                            self.subTest(member=member),
+                            open(local_root / member, mode) as local_fh,
+                            opener() as s3_fh,
+                        ):
+                            self.assertEqual(local_fh.read(), s3_fh.read())