chore: import upstream snapshot with attribution

tests/backend/image_util/test_vendor_mutable_defaults.py

@@ -0,0 +1,106 @@
+"""Tests for the mutable default argument fix in imwatermark/vendor.py
+and the bare except fix in sqlite_database.py."""
+
+from logging import Logger
+from unittest import mock
+
+import pytest
+
+from invokeai.backend.image_util.imwatermark.vendor import EmbedMaxDct, WatermarkEncoder
+
+
+class TestSetByBitsNoSharedState:
+    """set_by_bits() used to have bits=[] as a default arg.
+    If it were still mutable, successive calls without an explicit arg
+    would accumulate state. After the fix (bits=None), each call gets
+    a fresh list."""
+
+    def test_set_by_bits_default_is_independent(self):
+        enc1 = WatermarkEncoder()
+        enc1.set_by_bits()
+        assert enc1._watermarks == []
+        assert enc1._wmLen == 0
+
+        enc2 = WatermarkEncoder()
+        enc2.set_by_bits()
+        assert enc2._watermarks == []
+        assert enc2._wmLen == 0
+
+    def test_set_by_bits_with_explicit_arg(self):
+        enc = WatermarkEncoder()
+        enc.set_by_bits([1, 0, 1])
+        assert enc._watermarks == [1, 0, 1]
+        assert enc._wmLen == 3
+        assert enc._wmType == "bits"
+
+
+class TestEmbedMaxDctNoSharedState:
+    """EmbedMaxDct.__init__ used to have watermarks=[] and scales=[0,36,36].
+    After the fix (both default to None), each instance gets its own list."""
+
+    def test_default_watermarks_independent(self):
+        e1 = EmbedMaxDct()
+        e1._watermarks.append(999)
+
+        e2 = EmbedMaxDct()
+        assert 999 not in e2._watermarks
+        assert e2._watermarks == []
+
+    def test_default_scales_independent(self):
+        e1 = EmbedMaxDct()
+        e1._scales.append(72)
+
+        e2 = EmbedMaxDct()
+        assert e2._scales == [0, 36, 36]
+
+    def test_explicit_args_still_work(self):
+        wm = [1, 0, 1, 1]
+        sc = [0, 50, 50]
+        e = EmbedMaxDct(watermarks=wm, wmLen=4, scales=sc, block=8)
+        assert e._watermarks == wm
+        assert e._wmLen == 4
+        assert e._scales == sc
+        assert e._block == 8
+
+
+class TestTransactionExceptException:
+    """The transaction() context manager used to have a bare `except:`.
+    After the fix it uses `except Exception:`, so BaseException subclasses
+    like KeyboardInterrupt and SystemExit should propagate instead of
+    being silently caught and rolled back."""
+
+    @staticmethod
+    def _make_db():
+        """Create a minimal SqliteDatabase-like object with transaction()."""
+        # Import here so the test stays focused; we just need the real class.
+        from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
+
+        logger = mock.MagicMock(spec=Logger)
+        db = SqliteDatabase(db_path=None, logger=logger, verbose=False)
+        return db
+
+    def test_regular_exception_rolls_back(self):
+        db = self._make_db()
+
+        # create a table first in a successful transaction
+        with db.transaction() as cursor:
+            cursor.execute("CREATE TABLE t (id INTEGER)")
+
+        # now try to insert and fail — the insert should be rolled back
+        with pytest.raises(ValueError):
+            with db.transaction() as cursor:
+                cursor.execute("INSERT INTO t VALUES (42)")
+                raise ValueError("boom")
+
+        # the row should not exist after rollback
+        with db.transaction() as cursor:
+            cursor.execute("SELECT * FROM t")
+            assert cursor.fetchone() is None
+
+    def test_keyboard_interrupt_propagates(self):
+        with pytest.raises(KeyboardInterrupt):
+            raise KeyboardInterrupt()
+
+    def test_system_exit_propagates(self):
+        with pytest.raises(SystemExit):
+            raise SystemExit(1)