Refactor tests to use to_bytes() instead of temp files (#73)

Convert tests that don't need file-based operations to use
to_bytes()/open_bytes() for in-memory roundtrips:

- test_kdf_config.py: All tests converted
- test_cipher_config.py: All tests converted
- test_field_references.py: Roundtrip test converted
- test_twofish.py: Removed redundant file-based test that duplicated
  test_to_bytes_roundtrip, converted test_modify_and_resave

Tests that explicitly verify file I/O behavior (reload, save,
open_interactive, dump_xml, create_keyfile, KDBX3 upgrade confirmation)
retain tempfile usage as intended.

Closes #67

Author: coreyleavitt

tests/test_cipher_config.py

@@ -1,6 +1,6 @@
 """Tests for cipher configuration on save."""
 
-import tempfile
+import warnings
 from pathlib import Path
 
 import pytest
@@ -16,43 +16,25 @@ def test_save_with_chacha20(self) -> None:
         db = Database.create(password="test")
         db.root_group.create_entry(title="Test")
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            filepath = Path(f.name)
-
-        try:
-            db.save(filepath=filepath, cipher=Cipher.CHACHA20)
-
-            # Verify we can reopen and cipher was changed
-            db2 = Database.open(filepath, password="test")
-            assert db2.find_entries(title="Test", first=True) is not None
-        finally:
-            filepath.unlink(missing_ok=True)
+        data = db.to_bytes(cipher=Cipher.CHACHA20)
+        db2 = Database.open_bytes(data, password="test")
+        assert db2.find_entries(title="Test", first=True) is not None
 
     def test_save_with_aes256(self) -> None:
         """Test saving with AES-256-CBC cipher."""
         db = Database.create(password="test")
         db.root_group.create_entry(title="Test")
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            filepath = Path(f.name)
-
-        try:
-            db.save(filepath=filepath, cipher=Cipher.AES256_CBC)
-
-            # Verify we can reopen
-            db2 = Database.open(filepath, password="test")
-            assert db2.find_entries(title="Test", first=True) is not None
-        finally:
-            filepath.unlink(missing_ok=True)
+        data = db.to_bytes(cipher=Cipher.AES256_CBC)
+        db2 = Database.open_bytes(data, password="test")
+        assert db2.find_entries(title="Test", first=True) is not None
 
     def test_to_bytes_with_chacha20(self) -> None:
         """Test to_bytes() with ChaCha20 cipher."""
         db = Database.create(password="test")
         db.root_group.create_entry(title="Test")
 
         data = db.to_bytes(cipher=Cipher.CHACHA20)
-
-        # Verify we can reopen from bytes
         db2 = Database.open_bytes(data, password="test")
         assert db2.find_entries(title="Test", first=True) is not None
 
@@ -68,106 +50,56 @@ def test_change_cipher_preserves_data(self) -> None:
         )
         entry.set_custom_property("custom_key", "custom_value")
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            filepath = Path(f.name)
-
-        try:
-            # Save with different cipher
-            db.save(filepath=filepath, cipher=Cipher.CHACHA20)
-
-            # Reopen and verify all data
-            db2 = Database.open(filepath, password="test")
-            entry2 = db2.find_entries(title="Important", first=True)
-            assert entry2 is not None
-            assert entry2.username == "[email protected]"
-            assert entry2.password == "secret123"
-            assert entry2.url == "https://example.com"
-            assert entry2.notes == "Some notes here"
-            assert entry2.get_custom_property("custom_key") == "custom_value"
-        finally:
-            filepath.unlink(missing_ok=True)
+        data = db.to_bytes(cipher=Cipher.CHACHA20)
+        db2 = Database.open_bytes(data, password="test")
+        entry2 = db2.find_entries(title="Important", first=True)
+        assert entry2 is not None
+        assert entry2.username == "[email protected]"
+        assert entry2.password == "secret123"
+        assert entry2.url == "https://example.com"
+        assert entry2.notes == "Some notes here"
+        assert entry2.get_custom_property("custom_key") == "custom_value"
 
     def test_cipher_with_kdf_config(self) -> None:
         """Test using both cipher and kdf_config together."""
         db = Database.create(password="test")
         db.root_group.create_entry(title="Test")
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            filepath = Path(f.name)
-
-        try:
-            db.save(
-                filepath=filepath,
-                cipher=Cipher.CHACHA20,
-                kdf_config=Argon2Config.fast(),
-            )
-
-            # Verify we can reopen
-            db2 = Database.open(filepath, password="test")
-            assert db2.find_entries(title="Test", first=True) is not None
-        finally:
-            filepath.unlink(missing_ok=True)
+        data = db.to_bytes(cipher=Cipher.CHACHA20, kdf_config=Argon2Config.fast())
+        db2 = Database.open_bytes(data, password="test")
+        assert db2.find_entries(title="Test", first=True) is not None
 
 
 class TestCipherConfigOnUpgrade:
     """Tests for using cipher parameter during KDBX3 upgrade."""
 
     def test_kdbx3_upgrade_with_chacha20(self) -> None:
         """Test KDBX3 upgrade with ChaCha20 cipher."""
-        import warnings
-
         test_file = Path(__file__).parent / "fixtures" / "test3.kdbx"
         test_key = Path(__file__).parent / "fixtures" / "test3.key"
+        keyfile_data = test_key.read_bytes()
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            temp_path = Path(f.name)
-
-        try:
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore")
-                db = Database.open(test_file, password="password", keyfile=test_key)
-
-            # Upgrade with ChaCha20 cipher
-            db.save(
-                filepath=temp_path,
-                allow_upgrade=True,
-                cipher=Cipher.CHACHA20,
-                kdf_config=Argon2Config.fast(),
-            )
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            db = Database.open(test_file, password="password", keyfile=test_key)
 
-            # Verify the file was saved and can be reopened
-            db2 = Database.open(temp_path, password="password", keyfile=test_key)
-            assert db2.root_group is not None
-        finally:
-            temp_path.unlink(missing_ok=True)
+        data = db.to_bytes(cipher=Cipher.CHACHA20, kdf_config=Argon2Config.fast())
+        db2 = Database.open_bytes(data, password="password", keyfile_data=keyfile_data)
+        assert db2.root_group is not None
 
     def test_kdbx3_upgrade_preserves_default_cipher(self) -> None:
         """Test KDBX3 upgrade preserves original cipher if none specified."""
-        import warnings
-
         test_file = Path(__file__).parent / "fixtures" / "test3.kdbx"
         test_key = Path(__file__).parent / "fixtures" / "test3.key"
+        keyfile_data = test_key.read_bytes()
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            db = Database.open(test_file, password="password", keyfile=test_key)
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            temp_path = Path(f.name)
-
-        try:
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore")
-                db = Database.open(test_file, password="password", keyfile=test_key)
-
-            # Upgrade without specifying cipher (should preserve existing)
-            db.save(
-                filepath=temp_path,
-                allow_upgrade=True,
-                kdf_config=Argon2Config.fast(),
-            )
-
-            # Verify file exists and can be opened
-            db2 = Database.open(temp_path, password="password", keyfile=test_key)
-            assert db2.root_group is not None
-        finally:
-            temp_path.unlink(missing_ok=True)
+        data = db.to_bytes(kdf_config=Argon2Config.fast())
+        db2 = Database.open_bytes(data, password="password", keyfile_data=keyfile_data)
+        assert db2.root_group is not None
 
 
 class TestCipherEnum:

tests/test_field_references.py

@@ -283,11 +283,6 @@ class TestFieldReferenceRoundtrip:
 
     def test_reference_survives_save_reload(self) -> None:
         """Test that references survive save and reload."""
-        import tempfile
-        from pathlib import Path
-
-        from kdbxtool import Argon2Config
-
         db = Database.create(password="test")
         main_entry = db.root_group.create_entry(
             title="Main",
@@ -298,24 +293,17 @@ def test_reference_survives_save_reload(self) -> None:
             password=main_entry.ref("password"),
         )
 
-        with tempfile.NamedTemporaryFile(suffix=".kdbx", delete=False) as f:
-            filepath = Path(f.name)
-
-        try:
-            db.save(filepath=filepath, kdf_config=Argon2Config.fast())
+        data = db.to_bytes()
+        db2 = Database.open_bytes(data, password="test")
 
-            # Reload and verify
-            db2 = Database.open(filepath, password="test")
-            ref_entry2 = db2.find_entries(title="Reference", first=True)
-            assert ref_entry2 is not None
+        ref_entry2 = db2.find_entries(title="Reference", first=True)
+        assert ref_entry2 is not None
 
-            # Raw value should still be the reference
-            assert "{REF:" in ref_entry2.password
+        # Raw value should still be the reference
+        assert "{REF:" in ref_entry2.password
 
-            # Deref should still resolve
-            assert ref_entry2.deref("password") == "original_password"
-        finally:
-            filepath.unlink(missing_ok=True)
+        # Deref should still resolve
+        assert ref_entry2.deref("password") == "original_password"
 
     def test_update_original_affects_reference(self) -> None:
         """Test that updating original entry affects referenced values."""