all fixed tests and various bugs in the mixins

Author: pietro convalle

answerking_app/tests/test_categories.py

@@ -4,14 +4,8 @@
 
 from answerking_app.models.models import Category, Item
 from answerking_app.utils.ErrorType import ErrorMessage
-from answerking_app.utils.model_types import (
-    CategoryType,
-    DetailError,
-    IDType,
-    ItemType,
-    NewCategoryName,
-    NewCategoryType,
-)
+from answerking_app.utils.model_types import (CategoryType, DetailError,
+                                              ItemType)
 
 client = Client()
 
@@ -104,7 +98,7 @@ def test_get_all_with_categories_returns_ok(self):
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 200)
 
-    def test_get_id_valid_returns_ok(self):
+    def test_get_valid_id_returns_ok(self):
         # Arrange
         expected: CategoryType = {
             "id": self.test_cat_1.id,
@@ -132,20 +126,25 @@ def test_get_id_valid_returns_ok(self):
         # Act
         response = client.get(f"/api/categories/{self.test_cat_1.id}")
         actual = response.json()
-
         # Assert
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 200)
 
-    def test_get_id_invalid_returns_not_found(self):
+    def test_get_invalid_id_returns_not_found(self):
         # Arrange
-        expected: DetailError = {"detail": "/api/categories/f not found"}
+        expected: DetailError = {
+            "detail": "Not Found",
+            "status": 404,
+            "title": "Resource not found",
+            "type": "http://testserver/problems/not_found/",
+        }
 
         # Act
         response = client.get("/api/categories/f")
         actual = response.json()
 
         # Assert
+        self.assertIsInstance(actual.pop("traceId"), str)
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 404)
 
@@ -161,10 +160,9 @@ def test_post_valid_with_items_returns_ok(self):
             "stock": self.test_item_3.stock,
             "calories": self.test_item_3.calories,
         }
-        post_data: NewCategoryType = {"name": "Vegetarian", "items": [item]}
+        post_data: CategoryType = {"name": "Vegetarian", "items": [item]}
 
-        expected_id: IDType = {"id": self.test_cat_2.id + 1}
-        expected: CategoryType = {**post_data, **expected_id}
+        expected: CategoryType = {**post_data, "id": self.test_cat_2.id + 1}
 
         # Act
         response = client.post(
@@ -188,9 +186,9 @@ def test_post_valid_with_items_returns_ok(self):
     def test_post_valid_without_items_returns_ok(self):
         # Arrange
         old_list = client.get("/api/categories").json()
-        post_data: NewCategoryType = {"name": "Gluten Free", "items": []}
-        expected_id: IDType = {"id": self.test_cat_2.id + 1}
-        expected: CategoryType = {**post_data, **expected_id}
+        post_data: CategoryType = {"name": "Gluten Free", "items": []}
+
+        expected: CategoryType = {**post_data, "id": self.test_cat_2.id + 1}
 
         # Act
         response = client.post(
@@ -210,7 +208,13 @@ def test_post_valid_without_items_returns_ok(self):
     def test_post_invalid_json_returns_bad_request(self):
         # Arrange
         invalid_json_data: str = '{"invalid": }'
-        expected_json_error: str = "JSON parse error -"
+        expected: DetailError = {
+            "detail": "Parsing JSON Error",
+            "errors": "JSON parse error - Expecting value: line 1 column 13 (char 12)",
+            "status": 400,
+            "title": "Invalid input json.",
+            "type": "http://testserver/problems/error/",
+        }
 
         # Act
         response = client.post(
@@ -221,17 +225,23 @@ def test_post_invalid_json_returns_bad_request(self):
         actual = response.json()
 
         # Assert
-        self.assertRaises(ParseError)
-        self.assertIn(expected_json_error, actual["detail"])
+        self.assertIsInstance(actual.pop("traceId"), str)
+        self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 400)
 
     def test_post_invalid_details_returns_bad_request(self):
         # Arrange
-        invalid_post_data: NewCategoryType = {
+        invalid_post_data: CategoryType = {
             "name": "Vegetarian%",
             "items": [],
         }
-        expected_failure_error: dict = {"name": ["Enter a valid value."]}
+        expected: DetailError = {
+            "detail": "Validation Error",
+            "errors": {"name": ["Enter a valid value."]},
+            "status": 400,
+            "title": "Invalid input.",
+            "type": "http://testserver/problems/error/",
+        }
 
         # Act
         response = client.post(
@@ -242,7 +252,8 @@ def test_post_invalid_details_returns_bad_request(self):
         actual = response.json()
 
         # Assert
-        self.assertEqual(expected_failure_error, actual)
+        self.assertIsInstance(actual.pop("traceId"), str)
+        self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 400)
 
     def test_put_valid_without_items_returns_no_items(self):
@@ -251,14 +262,13 @@ def test_put_valid_without_items_returns_no_items(self):
             f"/api/categories/{self.test_cat_1.id}"
         ).json()
 
-        post_data: NewCategoryName = {"name": "New Name"}
-        expected_id: IDType = {"id": self.test_cat_1.id}
+        post_data: CategoryType = {"name": "New Name"}
+
         expected: CategoryType = {
             **post_data,
-            **expected_id,
+            "id": self.test_cat_1.id,
             "items": [],
         }
-
         # Act
         response = client.put(
             f"/api/categories/{self.test_cat_1.id}",
@@ -278,22 +288,34 @@ def test_put_valid_without_items_returns_no_items(self):
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 200)
 
-    def test_put_invalid_id_returns_bad_request(self):
+    def test_put_invalid_id_returns_not_found(self):
         # Arrange
-        expected: DetailError = {"detail": "/api/categories/f not found"}
+        expected: DetailError = {
+            "detail": "Not Found",
+            "status": 404,
+            "title": "Resource not found",
+            "type": "http://testserver/problems/not_found/",
+        }
 
         # Act
         response = client.get("/api/categories/f")
         actual = response.json()
 
         # Assert
+        self.assertIsInstance(actual.pop("traceId"), str)
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 404)
 
     def test_put_invalid_json_returns_bad_request(self):
         # Arrange
         invalid_json_data: str = '{"invalid": }'
-        expected_json_error: str = "JSON parse error -"
+        expected: DetailError = {
+            "detail": "Parsing JSON Error",
+            "errors": "JSON parse error - Expecting value: line 1 column 13 (char 12)",
+            "status": 400,
+            "title": "Invalid input json.",
+            "type": "http://testserver/problems/error/",
+        }
 
         # Act
         response = client.put(
@@ -304,17 +326,23 @@ def test_put_invalid_json_returns_bad_request(self):
         actual = response.json()
 
         # Assert
-        self.assertRaises(ParseError)
-        self.assertIn(expected_json_error, actual["detail"])
+        self.assertIsInstance(actual.pop("traceId"), str)
+        self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 400)
 
     def test_put_invalid_name_returns_bad_request(self):
         # Arrange
-        invalid_post_data: NewCategoryType = {
+        invalid_post_data: CategoryType = {
             "name": "New Name*",
             "items": [],
         }
-        expected_failure_error: dict = {"name": ["Enter a valid value."]}
+        expected: DetailError = {
+            "detail": "Validation Error",
+            "errors": {"name": ["Enter a valid value."]},
+            "status": 400,
+            "title": "Invalid input.",
+            "type": "http://testserver/problems/error/",
+        }
 
         # Act
         response = client.put(
@@ -325,10 +353,11 @@ def test_put_invalid_name_returns_bad_request(self):
         actual = response.json()
 
         # Assert
-        self.assertEqual(expected_failure_error, actual)
+        self.assertIsInstance(actual.pop("traceId"), str)
+        self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 400)
 
-    def test_put_invalid_item_returns_bad_request(self):
+    def test_put_not_existing_item_returns_not_found(self):
         # Arrange
         item: ItemType = {
             "id": -1,
@@ -338,11 +367,17 @@ def test_put_invalid_item_returns_bad_request(self):
             "stock": self.test_item_1.stock,
             "calories": self.test_item_1.calories,
         }
-        invalid_post_data: NewCategoryType = {
+        invalid_post_data: CategoryType = {
             "name": "New Name",
             "items": [item],
         }
-        expected_failure_error: dict = {"detail": "This item does not exist"}
+        expected: DetailError = {
+            "detail": "Object was not Found",
+            "errors": ["Item matching query does not exist."],
+            "status": 404,
+            "title": "Resource not found",
+            "type": "http://testserver/problems/error/",
+        }
 
         # Act
         response = client.put(
@@ -353,8 +388,9 @@ def test_put_invalid_item_returns_bad_request(self):
         actual = response.json()
 
         # Assert
-        self.assertEqual(expected_failure_error, actual)
-        self.assertEqual(response.status_code, 400)
+        self.assertIsInstance(actual.pop("traceId"), str)
+        self.assertEqual(expected, actual)
+        self.assertEqual(response.status_code, 404)
 
     def test_put_wrong_item_except_id_returns_correct_item_details(self):
         # Arrange
@@ -366,7 +402,7 @@ def test_put_wrong_item_except_id_returns_correct_item_details(self):
             "stock": 666,
             "calories": 666,
         }
-        invalid_post_data: NewCategoryType = {
+        invalid_post_data: CategoryType = {
             "name": "Burgers",
             "items": [item_with_wrong_info],
         }
@@ -412,13 +448,18 @@ def test_delete_valid_returns_ok(self):
 
     def test_delete_invalid_id_returns_not_found(self):
         # Arrange
-        expected: DetailError = {"detail": "/api/categories/f not found"}
-
+        expected: DetailError = {
+            "detail": "Not Found",
+            "status": 404,
+            "title": "Resource not found",
+            "type": "http://testserver/problems/not_found/",
+        }
         # Act
         response = client.delete("/api/categories/f")
         actual = response.json()
 
         # Assert
+        self.assertIsInstance(actual.pop("traceId"), str)
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 404)
 
@@ -461,15 +502,17 @@ def test_put_add_duplicated_item_in_url_to_category_return_400(self):
             content_type="application/json",
         )
         actual = response.json()
-        error_msg: ErrorMessage = {
-            "error": {
-                "message": "Resource update failure",
-                "details": "Item already in category",
-            }
+        expected: DetailError = {
+            "detail": "A server error occurred.",
+            "status": 400,
+            "title": "A server error occurred.",
+            "type": "http://testserver/problems/error/",
         }
+
         # Assert
+        self.assertIsInstance(actual.pop("traceId"), str)
         self.assertEqual(response.status_code, 400)
-        self.assertEqual(actual, error_msg)
+        self.assertEqual(actual, expected)
 
 
 class CategoryTestsDB(TransactionTestCase):
@@ -508,7 +551,7 @@ def tearDown(self):
 
     def test_post_duplicated_name_returns_400(self):
         # Arrange
-        post_data: NewCategoryType = {"name": "Vegan", "items": []}
+        post_data: CategoryType = {"name": "Vegan", "items": []}
         client.post(
             "/api/categories", post_data, content_type="application/json"
         )
@@ -518,16 +561,23 @@ def test_post_duplicated_name_returns_400(self):
             "/api/categories", post_data, content_type="application/json"
         )
 
-        expected: DetailError = {"detail": "This name already exists"}
+        expected: DetailError = {
+            "detail": "This name already exists",
+            "status": 400,
+            "title": "A server error occurred.",
+            "type": "http://testserver/problems/error/",
+        }
+
         actual = response.json()
 
         # Assert
+        self.assertIsInstance(actual.pop("traceId"), str)
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 400)
 
     def test_put_duplicated_name_returns_400(self):
         # Arrange
-        post_data: NewCategoryType = {"name": "Vegan", "items": []}
+        post_data: CategoryType = {"name": "Vegan", "items": []}
 
         client.post(
             "/api/categories", post_data, content_type="application/json"
@@ -540,8 +590,14 @@ def test_put_duplicated_name_returns_400(self):
             content_type="application/json",
         )
         actual = response.json()
-        expected: DetailError = {"detail": "This name already exists"}
+        expected: DetailError = {
+            "detail": "This name already exists",
+            "status": 400,
+            "title": "A server error occurred.",
+            "type": "http://testserver/problems/error/",
+        }
 
         # Assert
+        self.assertIsInstance(actual.pop("traceId"), str)
         self.assertEqual(expected, actual)
         self.assertEqual(response.status_code, 400)