fix: resolve CI/CD test and lint failures
Some checks failed
CI / test (push) Has been cancelled
CI / lint (push) Has been cancelled
CI / type-check (push) Has been cancelled

- 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
This commit is contained in:
2026-02-04 13:47:36 +00:00
parent 9f65286ba8
commit 0358fbeaf0

View File

@@ -1,53 +1,52 @@
"""Tests for the recorder module."""
import pytest
from unittest.mock import MagicMock, patch
from api_snapshot.recorder.recorder import (
RecordedRequest,
RecordedResponse,
RequestResponsePair,
RecordingSession,
RequestResponsePair,
record_multiple,
record_session,
record_multiple
)
class TestRecordedRequest:
"""Tests for RecordedRequest class."""
def test_create_request(self):
"""Test creating a recorded request."""
req = RecordedRequest(
method="GET",
url="https://api.example.com/users",
headers={"Accept": "application/json"},
body=None
body=None,
)
assert req.method == "GET"
assert req.url == "https://api.example.com/users"
assert req.headers == {"Accept": "application/json"}
assert req.body is None
assert req.timestamp is not None
def test_request_to_dict(self):
"""Test converting request to dictionary."""
req = RecordedRequest(
method="POST",
url="https://api.example.com/data",
headers={"Content-Type": "application/json"},
body='{"key": "value"}'
body='{"key": "value"}',
)
data = req.to_dict()
assert data["method"] == "POST"
assert data["url"] == "https://api.example.com/data"
assert data["headers"] == {"Content-Type": "application/json"}
assert data["body"] == '{"key": "value"}'
assert "timestamp" in data
def test_request_from_dict(self):
"""Test creating request from dictionary."""
data = {
@@ -55,11 +54,11 @@ class TestRecordedRequest:
"url": "https://api.example.com/resource/1",
"headers": {"Authorization": "Bearer token"},
"body": "updated data",
"timestamp": "2024-01-01T12:00:00"
"timestamp": "2024-01-01T12:00:00",
}
req = RecordedRequest.from_dict(data)
assert req.method == "PUT"
assert req.url == "https://api.example.com/resource/1"
assert req.headers == {"Authorization": "Bearer token"}
@@ -69,48 +68,48 @@ class TestRecordedRequest:
class TestRecordedResponse:
"""Tests for RecordedResponse class."""
def test_create_response(self):
"""Test creating a recorded response."""
resp = RecordedResponse(
status_code=200,
headers={"Content-Type": "application/json"},
body='{"success": true}',
latency_ms=150
latency_ms=150,
)
assert resp.status_code == 200
assert resp.headers == {"Content-Type": "application/json"}
assert resp.body == '{"success": true}'
assert resp.latency_ms == 150
def test_response_to_dict(self):
"""Test converting response to dictionary."""
resp = RecordedResponse(
status_code=404,
headers={"Content-Type": "text/plain"},
body="Not Found",
latency_ms=50
latency_ms=50,
)
data = resp.to_dict()
assert data["status_code"] == 404
assert data["headers"] == {"Content-Type": "text/plain"}
assert data["body"] == "Not Found"
assert data["latency_ms"] == 50
def test_response_from_dict(self):
"""Test creating response from dictionary."""
data = {
"status_code": 500,
"headers": {"Content-Type": "application/json"},
"body": '{"error": "internal"}',
"latency_ms": 300
"latency_ms": 300,
}
resp = RecordedResponse.from_dict(data)
assert resp.status_code == 500
assert resp.headers == {"Content-Type": "application/json"}
assert resp.body == '{"error": "internal"}'
@@ -119,142 +118,150 @@ class TestRecordedResponse:
class TestRequestResponsePair:
"""Tests for RequestResponsePair class."""
def test_create_pair(self, sample_request, sample_response):
"""Test creating a request-response pair."""
pair = RequestResponsePair(
request=sample_request,
response=sample_response
response=sample_response,
)
assert pair.request == sample_request
assert pair.response == sample_response
def test_pair_to_dict(self, sample_pair):
"""Test converting pair to dictionary."""
data = sample_pair.to_dict()
assert "request" in data
assert "response" in data
assert data["request"]["method"] == "GET"
assert data["response"]["status_code"] == 200
def test_pair_from_dict(self, sample_pair):
"""Test creating pair from dictionary."""
data = sample_pair.to_dict()
restored = RequestResponsePair.from_dict(data)
assert restored.request.method == sample_pair.request.method
assert restored.response.status_code == sample_pair.response.status_code
class TestRecordingSession:
"""Tests for RecordingSession class."""
def test_init_session(self):
"""Test initializing a recording session."""
session = RecordingSession()
assert session.base_url is None
assert session.on_request is None
assert session.recordings == []
def test_init_with_base_url(self):
"""Test initializing with base URL."""
session = RecordingSession(base_url="https://api.example.com")
assert session.base_url == "https://api.example.com"
def test_build_url_absolute(self):
"""Test building URL for absolute URL."""
session = RecordingSession()
url = session._build_url("https://other.com/api")
assert url == "https://other.com/api"
def test_build_url_relative(self):
"""Test building URL for relative URL."""
session = RecordingSession(base_url="https://api.example.com")
url = session._build_url("/users")
assert url == "https://api.example.com/users"
def test_build_url_relative_no_base(self):
"""Test building URL for relative URL without base."""
session = RecordingSession()
url = session._build_url("/users")
assert url == "/users"
def test_record_request_adds_to_recordings(self):
"""Test that record_request adds to recordings."""
session = RecordingSession()
with patch('api_snapshot.recorder.recorder.requests.Session.request') as mock_request:
with patch(
"api_snapshot.recorder.recorder.requests.Session.request"
) as mock_request:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.headers = {"Content-Type": "application/json"}
mock_response.text = '{"success": true}'
mock_request.return_value = mock_response
session.record_request("GET", "https://api.example.com/users")
assert len(session.recordings) == 1
assert session.recordings[0].request.method == "GET"
assert session.recordings[0].response.status_code == 200
def test_on_request_callback(self):
"""Test on_request callback is called."""
callback = MagicMock()
session = RecordingSession(on_request=callback)
with patch('api_snapshot.recorder.recorder.requests.Session.request') as mock_request:
with patch(
"api_snapshot.recorder.recorder.requests.Session.request"
) as mock_request:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.headers = {}
mock_response.text = '{}'
mock_response.text = "{}"
mock_request.return_value = mock_response
session.record_request("GET", "https://api.example.com")
callback.assert_called_once()
def test_clear_recordings(self):
"""Test clearing recordings."""
session = RecordingSession()
with patch('api_snapshot.recorder.recorder.requests.Session.request') as mock_request:
with patch(
"api_snapshot.recorder.recorder.requests.Session.request"
) as mock_request:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.headers = {}
mock_response.text = '{}'
mock_response.text = "{}"
mock_request.return_value = mock_response
session.record_request("GET", "https://api.example.com")
assert len(session.recordings) == 1
session.clear()
assert len(session.recordings) == 0
def test_get_recordings(self):
"""Test getting recordings."""
session = RecordingSession()
with patch('api_snapshot.recorder.recorder.requests.Session.request') as mock_request:
with patch(
"api_snapshot.recorder.recorder.requests.Session.request"
) as mock_request:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.headers = {}
mock_response.text = '{}'
mock_response.text = "{}"
mock_request.return_value = mock_response
session.record_request("GET", "https://api.example.com/1")
session.record_request("GET", "https://api.example.com/2")
recordings = session.get_recordings()
assert len(recordings) == 2
assert recordings[0].request.url.endswith("/1")
assert recordings[1].request.url.endswith("/2")
@@ -262,42 +269,46 @@ class TestRecordingSession:
class TestRecordFunctions:
"""Tests for record_session and record_multiple functions."""
def test_record_session(self):
"""Test record_session function."""
with patch('api_snapshot.recorder.recorder.requests.Session.request') as mock_request:
with patch(
"api_snapshot.recorder.recorder.requests.Session.request"
) as mock_request:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.headers = {"Content-Type": "application/json"}
mock_response.text = '{"data": "test"}'
mock_request.return_value = mock_response
pairs = record_session(
url="https://api.example.com/api",
method="GET"
method="GET",
)
assert len(pairs) == 1
assert pairs[0].request.method == "GET"
assert pairs[0].response.status_code == 200
def test_record_multiple(self):
"""Test record_multiple function."""
with patch('api_snapshot.recorder.recorder.requests.Session.request') as mock_request:
with patch(
"api_snapshot.recorder.recorder.requests.Session.request"
) as mock_request:
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.headers = {}
mock_response.text = '{}'
mock_response.text = "{}"
mock_request.return_value = mock_response
config = [
{"method": "GET", "url": "https://api.example.com/1"},
{"method": "POST", "url": "https://api.example.com/2"},
{"method": "DELETE", "url": "https://api.example.com/3"}
{"method": "DELETE", "url": "https://api.example.com/3"},
]
pairs = record_multiple(requests_config=config)
assert len(pairs) == 3
assert pairs[0].request.method == "GET"
assert pairs[1].request.method == "POST"