Add tests for improved code coverage

Author: devinslick

.coverage

@@ -291,6 +291,88 @@ def sign(self, message_bytes, pad, algo):
         await client2.close()
 
 
+@pytest.mark.asyncio
+async def test_json_response_non_dict_logging():
+    """Test JSON response handling when response is non-dict (array, etc)."""
+    client = FmdClient("https://fmd.example.com")
+    client.access_token = "token"
+
+    await client._ensure_session()
+    with aioresponses() as m:
+        # Return JSON array instead of dict
+        m.put("https://fmd.example.com/api/v1/pictures", payload=["item1", "item2"])
+
+        try:
+            result = await client.get_pictures()
+            # Should handle non-dict response gracefully
+            assert result == ["item1", "item2"]
+        finally:
+            await client.close()
+
+
+@pytest.mark.asyncio
+async def test_pictures_non_list_response():
+    """Test get_pictures handles non-list response gracefully."""
+    client = FmdClient("https://fmd.example.com")
+    client.access_token = "token"
+
+    await client._ensure_session()
+    with aioresponses() as m:
+        # Return non-list response
+        m.put("https://fmd.example.com/api/v1/pictures", payload={"Data": "not-a-list"})
+
+        try:
+            result = await client.get_pictures()
+            # Should return empty list for unexpected type
+            assert result == []
+        finally:
+            await client.close()
+
+
+@pytest.mark.asyncio
+async def test_export_data_zip_with_png(monkeypatch, tmp_path):
+    """Test export_data_zip detects PNG format correctly."""
+    client = FmdClient("https://fmd.example.com")
+    client.access_token = "token"
+    client._fmd_id = "test-device"
+
+    class DummyKey:
+        def decrypt(self, packet, padding_obj):
+            return b"\x00" * 32
+
+    client.private_key = DummyKey()
+
+    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+    session_key = b"\x00" * 32
+    aesgcm = AESGCM(session_key)
+    iv = b"\x01" * 12
+
+    # Create a PNG image (magic bytes: \x89PNG)
+    png_bytes = b"\x89PNG\r\n\x1a\n" + b"\x00" * 100
+    png_b64 = base64.b64encode(png_bytes).decode("utf-8")
+    ciphertext = aesgcm.encrypt(iv, png_b64.encode("utf-8"), None)
+    blob = b"\xaa" * 384 + iv + ciphertext
+    blob_b64 = base64.b64encode(blob).decode("utf-8").rstrip("=")
+
+    with aioresponses() as m:
+        m.put("https://fmd.example.com/api/v1/locationDataSize", payload={"Data": "0"})
+        m.put("https://fmd.example.com/api/v1/pictures", payload={"Data": [blob_b64]})
+
+        out_file = tmp_path / "export_png.zip"
+        try:
+            await client.export_data_zip(str(out_file))
+            import zipfile
+
+            with zipfile.ZipFile(out_file, "r") as zipf:
+                names = zipf.namelist()
+                # Should detect PNG and use .png extension
+                png_files = [n for n in names if n.endswith(".png")]
+                assert len(png_files) == 1
+        finally:
+            await client.close()
+
+
 @pytest.mark.asyncio
 async def test_set_ringer_mode_validation():
     """Test set_ringer_mode validates mode parameter."""

tests/unit/test_client.py

@@ -522,6 +522,30 @@ async def test_send_command_with_missing_private_key():
         await client.close()
 
 
+@pytest.mark.asyncio
+async def test_device_fetch_pictures_deprecated():
+    """Test fetch_pictures() deprecated wrapper emits warning."""
+    client = FmdClient("https://fmd.example.com")
+    client.access_token = "token"
+    device = Device(client, "test-device")
+
+    with aioresponses() as m:
+        m.put("https://fmd.example.com/api/v1/pictures", payload={"Data": ["blob1", "blob2"]})
+
+        try:
+            import warnings
+
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                result = await device.fetch_pictures(2)
+                assert len(w) == 1
+                assert issubclass(w[0].category, DeprecationWarning)
+                assert "fetch_pictures() is deprecated" in str(w[0].message)
+                assert len(result) == 2
+        finally:
+            await client.close()
+
+
 @pytest.mark.asyncio
 async def test_client_error_generic():
     """Test generic ClientError handling."""

tests/unit/test_coverage_improvements.py

@@ -77,6 +77,20 @@ def sign(self, message_bytes, pad, algo):
         await client.close()
 
 
+@pytest.mark.asyncio
+async def test_wipe_spaces_specific_error():
+    """Test that spaces in PIN trigger the alphanumeric error message."""
+    client = FmdClient("https://fmd.example.com")
+    device = Device(client, "test-device")
+
+    try:
+        # Space causes isalnum() to fail, hitting the alphanumeric check first
+        with pytest.raises(OperationError, match="alphanumeric ASCII"):
+            await device.wipe(pin="my pin", confirm=True)
+    finally:
+        await client.close()
+
+
 @pytest.mark.asyncio
 async def test_wipe_rejects_empty_pin():
     """Test that wipe rejects empty PIN."""

tests/unit/test_device_wipe_validation.py

@@ -46,3 +46,98 @@ def decrypt(self, packet, padding_obj):
 
     await resumed.close()
     await client.close()
+
+
+@pytest.mark.asyncio
+async def test_resume_with_der_key():
+    """Test resume() with DER-encoded private key (fallback path)."""
+    from cryptography.hazmat.primitives.asymmetric import rsa
+    from cryptography.hazmat.primitives import serialization
+
+    # Generate a real RSA key and encode as DER
+    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    der_bytes = key.private_bytes(
+        encoding=serialization.Encoding.DER,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    # Resume with DER bytes (should trigger ValueError in PEM load, then succeed with DER)
+    client = await FmdClient.resume(
+        "https://fmd.example.com",
+        "alice",
+        "token123",
+        der_bytes,
+        password_hash="$argon2id$v=19$m=131072,t=1,p=4$dummy$hash",
+    )
+
+    try:
+        assert client.access_token == "token123"
+        assert client.private_key is not None
+    finally:
+        await client.close()
+
+
+@pytest.mark.asyncio
+async def test_401_without_password_or_hash():
+    """Test 401 response when neither password nor hash available raises error."""
+    from fmd_api.exceptions import FmdApiException
+
+    client = FmdClient("https://fmd.example.com")
+    client.access_token = "old_token"
+    client._fmd_id = "alice"
+    client._password = None
+    client._password_hash = None
+
+    await client._ensure_session()
+    with aioresponses() as m:
+        # Returns 401 and no password/hash available
+        m.put("https://fmd.example.com/api/v1/locationDataSize", status=401)
+
+        try:
+            with pytest.raises(FmdApiException, match="401"):
+                await client.get_locations()
+        finally:
+            await client.close()
+
+
+@pytest.mark.asyncio
+async def test_reauth_with_hash_missing_fields():
+    """Test _reauth_with_hash raises when ID or hash missing."""
+    from fmd_api.exceptions import FmdApiException
+
+    client = FmdClient("https://fmd.example.com")
+    client._fmd_id = None
+    client._password_hash = None
+
+    try:
+        with pytest.raises(FmdApiException, match="Hash-based reauth not possible"):
+            await client._reauth_with_hash()
+    finally:
+        await client.close()
+
+
+@pytest.mark.asyncio
+async def test_from_auth_artifacts_missing_fields():
+    """Test from_auth_artifacts raises on missing required fields."""
+    incomplete = {"base_url": "https://fmd.example.com", "fmd_id": "alice"}
+
+    with pytest.raises(ValueError, match="Missing artifact fields"):
+        await FmdClient.from_auth_artifacts(incomplete)
+
+
+@pytest.mark.asyncio
+async def test_export_artifacts_without_private_key():
+    """Test export_auth_artifacts raises when private key not loaded."""
+    from fmd_api.exceptions import FmdApiException
+
+    client = FmdClient("https://fmd.example.com")
+    client._fmd_id = "alice"
+    client.access_token = "token"
+    client.private_key = None
+
+    try:
+        with pytest.raises(FmdApiException, match="Cannot export artifacts"):
+            await client.export_auth_artifacts()
+    finally:
+        await client.close()