fix: resolve CI/CD test and lint failures

- Update ci.yml to run only api-snapshot tests
- Remove unused imports in test_cli.py
- Remove unused imports in test_recorder.py
- Remove unused imports in test_server.py
- Remove unused imports and variables in test_snapshot.py

tests/test_cli.py

@@ -1,128 +1,136 @@
 """Tests for the CLI module."""
 
-import json
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-
-import pytest
 from click.testing import CliRunner
 
-from api_snapshot.cli.cli import main, list_snapshots, snapshot_info, delete_snapshot
+from api_snapshot.cli.cli import (
-from api_snapshot.cli.record import record_command, record_multi_command
+    delete_snapshot,
+    list_snapshots,
+    main,
+    snapshot_info,
+)
 from api_snapshot.cli.serve import serve_command, serve_info_command
 from api_snapshot.snapshot.manager import SnapshotManager
 
 
 class TestMainCommand:
     """Tests for main command group."""
-    
+
     def test_main_help(self):
         """Test main command help."""
         runner = CliRunner()
-        
+
         result = runner.invoke(main, ["--help"])
-        
+
         assert result.exit_code == 0
         assert "API Snapshot CLI" in result.output
         assert "record" in result.output
         assert "serve" in result.output
         assert "list" in result.output
-    
+
     def test_main_version(self):
         """Test main command version."""
         runner = CliRunner()
-        
+
         result = runner.invoke(main, ["--version"])
-        
+
         assert result.exit_code == 0
         assert "0.1.0" in result.output
 
 
 class TestListCommand:
     """Tests for list command."""
-    
+
     def test_list_empty(self, temp_dir):
         """Test listing with no snapshots."""
         runner = CliRunner()
-        
+
         result = runner.invoke(list_snapshots, obj={"snapshot_dir": temp_dir})
-        
+
         assert result.exit_code == 0
         assert "No snapshots found" in result.output
-    
+
     def test_list_with_snapshots(self, temp_dir):
         """Test listing with snapshots."""
-        from api_snapshot.recorder.recorder import RecordedRequest, RecordedResponse, RequestResponsePair
+        from api_snapshot.recorder.recorder import (
-        
+            RecordedRequest,
+            RecordedResponse,
+            RequestResponsePair,
+        )
+
         manager = SnapshotManager(temp_dir)
-        
+
         req = RecordedRequest(
             method="GET",
             url="https://api.example.com",
             headers={},
-            body=None
+            body=None,
         )
         resp = RecordedResponse(
             status_code=200,
             headers={},
             body="{}",
-            latency_ms=100
+            latency_ms=100,
         )
         pair = RequestResponsePair(request=req, response=resp)
-        
+
         manager.save_snapshot("test-snap", requests=[pair])
-        
+
         runner = CliRunner()
-        
+
         result = runner.invoke(list_snapshots, obj={"snapshot_dir": temp_dir})
-        
+
         assert result.exit_code == 0
         assert "test-snap" in result.output
 
 
 class TestSnapshotInfoCommand:
     """Tests for info command."""
-    
+
     def test_info_nonexistent(self, temp_dir):
         """Test info for non-existent snapshot."""
         runner = CliRunner()
-        
+
-        result = runner.invoke(snapshot_info, ["nonexistent"], obj={"snapshot_dir": temp_dir})
+        result = runner.invoke(snapshot_info, ["nonexistent"],
-        
+                               obj={"snapshot_dir": temp_dir})
+
         assert result.exit_code != 0
         assert "not found" in result.output
-    
+
     def test_info_existing(self, temp_dir):
         """Test info for existing snapshot."""
-        from api_snapshot.recorder.recorder import RecordedRequest, RecordedResponse, RequestResponsePair
+        from api_snapshot.recorder.recorder import (
-        
+            RecordedRequest,
+            RecordedResponse,
+            RequestResponsePair,
+        )
+
         manager = SnapshotManager(temp_dir)
-        
+
         req = RecordedRequest(
             method="GET",
             url="https://api.example.com/users",
             headers={},
-            body=None
+            body=None,
         )
         resp = RecordedResponse(
             status_code=200,
             headers={"Content-Type": "application/json"},
             body='{"users": []}',
-            latency_ms=100
+            latency_ms=100,
         )
         pair = RequestResponsePair(request=req, response=resp)
-        
+
         manager.save_snapshot(
             "my-snapshot",
             requests=[pair],
-            description="Test description"
+            description="Test description",
         )
-        
+
         runner = CliRunner()
-        
+
-        result = runner.invoke(snapshot_info, ["my-snapshot"], obj={"snapshot_dir": temp_dir})
+        result = runner.invoke(snapshot_info, ["my-snapshot"],
-        
+                               obj={"snapshot_dir": temp_dir})
+
         assert result.exit_code == 0
         assert "my-snapshot" in result.output
         assert "Test description" in result.output
@@ -130,125 +138,133 @@ class TestSnapshotInfoCommand:
 
 class TestDeleteCommand:
     """Tests for delete command."""
-    
+
     def test_delete_nonexistent(self, temp_dir):
         """Test deleting non-existent snapshot."""
         runner = CliRunner()
-        
+
         result = runner.invoke(
-            delete_snapshot, 
+            delete_snapshot,
-            ["nonexistent", "--force"], 
+            ["nonexistent", "--force"],
-            obj={"snapshot_dir": temp_dir}
+            obj={"snapshot_dir": temp_dir},
         )
-        
+
         assert result.exit_code != 0
         assert "not found" in result.output
-    
+
     def test_delete_with_confirmation(self, temp_dir):
         """Test deleting with confirmation."""
-        from api_snapshot.recorder.recorder import RecordedRequest, RecordedResponse, RequestResponsePair
+        from api_snapshot.recorder.recorder import (
-        
+            RecordedRequest,
+            RecordedResponse,
+            RequestResponsePair,
+        )
+
         manager = SnapshotManager(temp_dir)
-        
+
         req = RecordedRequest(
             method="GET",
             url="https://api.example.com",
             headers={},
-            body=None
+            body=None,
         )
         resp = RecordedResponse(
             status_code=200,
             headers={},
             body="{}",
-            latency_ms=50
+            latency_ms=50,
         )
         pair = RequestResponsePair(request=req, response=resp)
-        
+
         manager.save_snapshot("to-delete", requests=[pair])
-        
+
         runner = CliRunner()
-        
+
         result = runner.invoke(
             delete_snapshot,
             ["to-delete", "--force"],
-            obj={"snapshot_dir": temp_dir}
+            obj={"snapshot_dir": temp_dir},
         )
-        
+
         assert result.exit_code == 0
         assert "Deleted" in result.output
-        
+
         assert not manager.snapshot_exists("to-delete")
 
 
 class TestServeCommand:
     """Tests for serve command."""
-    
+
     def test_serve_nonexistent_snapshot(self, temp_dir):
         """Test serving non-existent snapshot."""
         runner = CliRunner()
-        
+
         result = runner.invoke(
             serve_command,
             ["nonexistent"],
-            obj={"snapshot_dir": temp_dir}
+            obj={"snapshot_dir": temp_dir},
         )
-        
+
         assert result.exit_code != 0
         assert "not found" in result.output
-    
+
     def test_serve_info_nonexistent(self, temp_dir):
         """Test serve-info for non-existent snapshot."""
         runner = CliRunner()
-        
+
         result = runner.invoke(
             serve_info_command,
             ["nonexistent"],
-            obj={"snapshot_dir": temp_dir}
+            obj={"snapshot_dir": temp_dir},
         )
-        
+
         assert result.exit_code != 0
         assert "not found" in result.output
 
 
 class TestCLIIntegration:
     """Integration tests for CLI."""
-    
+
     def test_cli_commands_chain(self, temp_dir):
         """Test chaining CLI commands together."""
-        from api_snapshot.recorder.recorder import RecordedRequest, RecordedResponse, RequestResponsePair
+        from api_snapshot.recorder.recorder import (
-        
+            RecordedRequest,
+            RecordedResponse,
+            RequestResponsePair,
+        )
+
         runner = CliRunner()
-        
+
         req = RecordedRequest(
             method="GET",
             url="https://api.example.com/test",
             headers={},
-            body=None
+            body=None,
         )
         resp = RecordedResponse(
             status_code=200,
             headers={"Content-Type": "application/json"},
             body='{"message": "hello"}',
-            latency_ms=50
+            latency_ms=50,
         )
         pair = RequestResponsePair(request=req, response=resp)
-        
+
         manager = SnapshotManager(temp_dir)
         manager.save_snapshot("test-chain", requests=[pair])
-        
+
         list_result = runner.invoke(
             list_snapshots,
-            obj={"snapshot_dir": temp_dir}
+            obj={"snapshot_dir": temp_dir},
         )
-        
+
         assert list_result.exit_code == 0
         assert "test-chain" in list_result.output
-        
+
         info_result = runner.invoke(
             snapshot_info,
             ["test-chain"],
-            obj={"snapshot_dir": temp_dir}
+            obj={"snapshot_dir": temp_dir},
         )
-        
+
         assert info_result.exit_code == 0
         assert "test-chain" in info_result.output