Fix issue #29: Add tests for error responses, add user_input validation for create and update actions

Author: Ihor Bilous

examples/testing/projects.py

@@ -24,5 +24,5 @@ def find_project_by_name(project_name: str, projects: list[Project]) -> Optional
 projects = projects_api.get_list()
 project_id = find_project_by_name(project_name, projects)
 project = projects_api.get_by_id(project_id)
-updated_projected = projects_api.update(project_id, "Updated-project-name")
+updated_project = projects_api.update(project_id, "Updated-project-name")
 deleted_object = projects_api.delete(project_id)

mailtrap/api/resources/projects.py

@@ -1,6 +1,7 @@
 from mailtrap.http import HttpClient
 from mailtrap.schemas.base import DeletedObject
 from mailtrap.schemas.projects import Project
+from mailtrap.schemas.projects import ProjectInput
 
 
 class ProjectsApi:
@@ -19,13 +20,15 @@ def get_by_id(self, project_id: int) -> Project:
         return Project(**response)
 
     def create(self, project_name: str) -> Project:
+        ProjectInput(name=project_name)
         response = self.client.post(
             f"/api/accounts/{self.account_id}/projects",
             json={"project": {"name": project_name}},
         )
         return Project(**response)
 
     def update(self, project_id: int, project_name: str) -> Project:
+        ProjectInput(name=project_name)
         response = self.client.patch(
             f"/api/accounts/{self.account_id}/projects/{project_id}",
             json={"project": {"name": project_name}},

mailtrap/http.py

@@ -32,8 +32,8 @@ def _handle_failed_response(self, response: Response) -> NoReturn:
         status_code = response.status_code
         try:
             data = response.json()
-        except ValueError:
-            raise APIError(status_code, errors=["Unknown Error"])
+        except ValueError as exc:
+            raise APIError(status_code, errors=["Unknown Error"]) from exc
 
         errors = _extract_errors(data)
 

mailtrap/schemas/inboxes.py

@@ -1,6 +1,7 @@
-
 from typing import Optional
+
 from pydantic import BaseModel
+
 from mailtrap.schemas.permissions import Permissions
 
 
@@ -26,5 +27,7 @@ class Inbox(BaseModel):
     pop3_ports: list[int]
     max_message_size: int
     permissions: Permissions
-    password: Optional[str] = None  # Password is only available if you have admin permissions for the inbox.
+    password: Optional[str] = (
+        None  # Password is only available if you have admin permissions for the inbox.
+    )
     last_message_sent_at: Optional[str] = None

mailtrap/schemas/projects.py

@@ -1,4 +1,6 @@
 from pydantic import BaseModel
+from pydantic import Field
+
 from mailtrap.schemas.inboxes import Inbox
 from mailtrap.schemas.permissions import Permissions
 
@@ -14,3 +16,7 @@ class Project(BaseModel):
     share_links: ShareLinks
     inboxes: list[Inbox]
     permissions: Permissions
+
+
+class ProjectInput(BaseModel):
+    name: str = Field(min_length=2, max_length=100)

tests/unit/api/test_projects.py

@@ -2,6 +2,7 @@
 
 import pytest
 import responses
+from pydantic import ValidationError
 
 from mailtrap.api.resources.projects import ProjectsApi
 from mailtrap.config import MAILTRAP_HOST
@@ -40,6 +41,34 @@ def sample_project_dict() -> dict[str, Any]:
 
 
 class TestProjectsApi:
+
+    @pytest.mark.parametrize(
+        "status_code,response_json,expected_error_message",
+        [
+            (401, {"error": "Incorrect API token"}, "Incorrect API token"),
+            (403, {"errors": "Access forbidden"}, "Access forbidden"),
+        ],
+    )
+    @responses.activate
+    def test_get_list_should_raise_api_errors(
+        self,
+        client: ProjectsApi,
+        status_code: int,
+        response_json: dict,
+        expected_error_message: str,
+    ) -> None:
+        responses.add(
+            responses.GET,
+            BASE_PROJECTS_URL,
+            status=status_code,
+            json=response_json,
+        )
+
+        with pytest.raises(APIError) as exc_info:
+            client.get_list()
+
+        assert expected_error_message in str(exc_info.value)
+
     @responses.activate
     def test_get_list_should_return_project_list(
         self, client: ProjectsApi, sample_project_dict: dict
@@ -57,20 +86,34 @@ def test_get_list_should_return_project_list(
         assert all(isinstance(p, Project) for p in projects)
         assert projects[0].id == PROJECT_ID
 
+    @pytest.mark.parametrize(
+        "status_code,response_json,expected_error_message",
+        [
+            (401, {"error": "Incorrect API token"}, "Incorrect API token"),
+            (403, {"errors": "Access forbidden"}, "Access forbidden"),
+            (404, {"error": "Not Found"}, "Not Found"),
+        ],
+    )
     @responses.activate
-    def test_get_by_id_should_raise_not_found_error(self, client: ProjectsApi) -> None:
+    def test_get_by_id_should_raise_api_errors(
+        self,
+        client: ProjectsApi,
+        status_code: int,
+        response_json: dict,
+        expected_error_message: str,
+    ) -> None:
         url = f"{BASE_PROJECTS_URL}/{PROJECT_ID}"
         responses.add(
             responses.GET,
             url,
-            status=404,
-            json={"error": "Not Found"},
+            status=status_code,
+            json=response_json,
         )
 
         with pytest.raises(APIError) as exc_info:
             client.get_by_id(PROJECT_ID)
 
-        assert "Not Found" in str(exc_info)
+        assert expected_error_message in str(exc_info.value)
 
     @responses.activate
     def test_get_by_id_should_return_single_project(
@@ -89,6 +132,54 @@ def test_get_by_id_should_return_single_project(
         assert isinstance(project, Project)
         assert project.id == PROJECT_ID
 
+    @pytest.mark.parametrize(
+        "status_code,response_json,expected_error_message",
+        [
+            (401, {"error": "Incorrect API token"}, "Incorrect API token"),
+            (403, {"errors": "Access forbidden"}, "Access forbidden"),
+        ],
+    )
+    @responses.activate
+    def test_create_should_raise_api_errors(
+        self,
+        client: ProjectsApi,
+        status_code: int,
+        response_json: dict,
+        expected_error_message: str,
+    ) -> None:
+        responses.add(
+            responses.POST,
+            BASE_PROJECTS_URL,
+            status=status_code,
+            json=response_json,
+        )
+
+        with pytest.raises(APIError) as exc_info:
+            client.create(project_name="New Project")
+
+        assert expected_error_message in str(exc_info.value)
+
+    @pytest.mark.parametrize(
+        "project_name, expected_errors",
+        [
+            (None, ["Input should be a valid string"]),
+            ("", ["String should have at least 2 characters"]),
+            ("a", ["String should have at least 2 characters"]),
+            ("a" * 101, ["String should have at most 100 characters"]),
+        ],
+    )
+    def test_create_should_raise_validation_error_on_pydantic_validation(
+        self, client: ProjectsApi, project_name: str, expected_errors: list[str]
+    ) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            client.create(project_name=project_name)
+
+        errors = exc_info.value.errors()
+        error_messages = [err["msg"] for err in errors]
+
+        for expected_msg in expected_errors:
+            assert any(expected_msg in actual_msg for actual_msg in error_messages)
+
     @responses.activate
     def test_create_should_return_new_project(
         self, client: ProjectsApi, sample_project_dict: dict
@@ -105,20 +196,55 @@ def test_create_should_return_new_project(
         assert isinstance(project, Project)
         assert project.name == "Test Project"
 
+    @pytest.mark.parametrize(
+        "status_code,response_json,expected_error_message",
+        [
+            (401, {"error": "Incorrect API token"}, "Incorrect API token"),
+            (403, {"errors": "Access forbidden"}, "Access forbidden"),
+            (404, {"error": "Not Found"}, "Not Found"),
+        ],
+    )
     @responses.activate
-    def test_update_should_raise_not_found_error(self, client: ProjectsApi) -> None:
+    def test_update_should_raise_api_errors(
+        self,
+        client: ProjectsApi,
+        status_code: int,
+        response_json: dict,
+        expected_error_message: str,
+    ) -> None:
         url = f"{BASE_PROJECTS_URL}/{PROJECT_ID}"
         responses.add(
             responses.PATCH,
             url,
-            status=404,
-            json={"error": "Not Found"},
+            status=status_code,
+            json=response_json,
         )
 
         with pytest.raises(APIError) as exc_info:
             client.update(PROJECT_ID, project_name="Update Project Name")
 
-        assert "Not Found" in str(exc_info)
+        assert expected_error_message in str(exc_info.value)
+
+    @pytest.mark.parametrize(
+        "project_name, expected_errors",
+        [
+            (None, ["Input should be a valid string"]),
+            ("", ["String should have at least 2 characters"]),
+            ("a", ["String should have at least 2 characters"]),
+            ("a" * 101, ["String should have at most 100 characters"]),
+        ],
+    )
+    def test_update_should_raise_validation_error_on_pydantic_validation(
+        self, client: ProjectsApi, project_name: str, expected_errors: list[str]
+    ) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            client.update(project_id=PROJECT_ID, project_name=project_name)
+
+        errors = exc_info.value.errors()
+        error_messages = [err["msg"] for err in errors]
+
+        for expected_msg in expected_errors:
+            assert any(expected_msg in actual_msg for actual_msg in error_messages)
 
     @responses.activate
     def test_update_should_return_updated_project(
@@ -141,20 +267,34 @@ def test_update_should_return_updated_project(
         assert isinstance(project, Project)
         assert project.name == updated_name
 
+    @pytest.mark.parametrize(
+        "status_code,response_json,expected_error_message",
+        [
+            (401, {"error": "Incorrect API token"}, "Incorrect API token"),
+            (403, {"errors": "Access forbidden"}, "Access forbidden"),
+            (404, {"error": "Not Found"}, "Not Found"),
+        ],
+    )
     @responses.activate
-    def test_delete_should_raise_not_found_error(self, client: ProjectsApi) -> None:
+    def test_delete_should_raise_api_errors(
+        self,
+        client: ProjectsApi,
+        status_code: int,
+        response_json: dict,
+        expected_error_message: str,
+    ) -> None:
         url = f"{BASE_PROJECTS_URL}/{PROJECT_ID}"
         responses.add(
             responses.DELETE,
             url,
-            status=404,
-            json={"error": "Not Found"},
+            status=status_code,
+            json=response_json,
         )
 
         with pytest.raises(APIError) as exc_info:
             client.delete(PROJECT_ID)
 
-        assert "Not Found" in str(exc_info)
+        assert expected_error_message in str(exc_info.value)
 
     @responses.activate
     def test_delete_should_return_deleted_object(self, client: ProjectsApi) -> None: