Added pydantic models to the project

Author: Pokhilenko

.env.example

@@ -1,2 +1 @@
-MY_NAME=Dmitrii
 DOMAIN=https://demoqa.com

lib/constants/__init__.py

@@ -0,0 +1,6 @@
+class Routes:
+    account_authorized = "/Account/v1/Authorized"
+    account_generate_token = "/Account/v1/GenerateToken"
+    account_user = "/Account/v1/User"
+    bookstore_books = "/BookStore/v1/Books"
+    bookstore_book = "/BookStore/v1/Book"

lib/constants/routes.py

@@ -1,5 +1,7 @@
 from playwright.sync_api import APIRequestContext
 
+from lib.serializers.models.all_books_modal import AllBooksModal
+
 
 class BookstoreHelper:
     def __init__(self, request_context: APIRequestContext):
@@ -9,4 +11,8 @@ def __init__(self, request_context: APIRequestContext):
 
     def get_books(self):
         response = self.request.get(self.get_books_url)
-        return response
+        books = response.json()
+
+        AllBooksModal.model_validate(books)
+
+        return books

lib/helpers/bookstore_helper.py

@@ -1,31 +1,30 @@
 from typing import Generator
+
 import pytest
 from playwright.sync_api import Playwright, APIRequestContext
 
+from lib.serializers.models.login_view_model import LoginViewModel
+from lib.serializers.models.register_view_model import RegisterViewModel
+
 
 class UserHelper:
     @pytest.fixture(scope="session")
-    def api_request_context(
-            self: Playwright, base_url
-    ) -> Generator[APIRequestContext, None, None]:
+    def api_request_context(self: Playwright, base_url) -> Generator[APIRequestContext, None, None]:
         request_context = self.request.new_context(base_url=base_url)
         yield request_context
         request_context.dispose()
 
     @staticmethod
-    def register_new_user(api_request_context: APIRequestContext, username, password):
-        payload = {
-            "userName": username,
-            "password": password
-        }
-        new_user = api_request_context.post("/Account/v1/User", form=payload)
-        assert new_user.ok
+    def register_new_user(api_request_context: APIRequestContext, username, password, successful=True):
+        user = RegisterViewModel(user_name=username, password=password)
+        response = api_request_context.post("/Account/v1/User", form=user.model_dump(by_alias=True))
+
+        if successful:
+            assert response.status == 201
+            return response.json()
 
     @staticmethod
     def login_to_bookstore(api_request_context: APIRequestContext, username, password):
-        payload = {
-            "userName": username,
-            "password": password
-        }
-        login = api_request_context.post("Account/v1/GenerateToken", form=payload)
+        user = LoginViewModel(user_name=username, password=password)
+        login = api_request_context.post("Account/v1/GenerateToken", form=user.model_dump(by_alias=True))
         assert login.ok

lib/helpers/user_helper.py

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+    Book Store API
+
+    Book Store Web API
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+# import models into model package

lib/serializers/__init__.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Book Store API
+
+    Book Store Web API
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional
+
+from pydantic import BaseModel, StrictStr
+from pydantic import Field
+
+from lib.serializers.models.collection_of_isbn import CollectionOfIsbn
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
+
+class AddListOfBooks(BaseModel):
+    """
+    
+    """  # noqa: E501
+    user_id: Optional[StrictStr] = Field(default=None, alias="userId")
+    collection_of_isbns: Optional[List[CollectionOfIsbn]] = Field(default=None, alias="collectionOfIsbns")
+    __properties: ClassVar[List[str]] = ["userId", "collectionOfIsbns"]
+
+    model_config = {
+        "populate_by_name": True,
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of AddListOfBooks from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude={
+            },
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in collection_of_isbns (list)
+        _items = []
+        if self.collection_of_isbns:
+            for _item in self.collection_of_isbns:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['collectionOfIsbns'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Dict) -> Self:
+        """Create an instance of AddListOfBooks from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "userId": obj.get("userId"),
+            "collectionOfIsbns": [CollectionOfIsbn.from_dict(_item) for _item in
+                                  obj.get("collectionOfIsbns")] if obj.get("collectionOfIsbns") is not None else None
+        })
+        return _obj

lib/serializers/models/__init__.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Book Store API
+
+    Book Store Web API
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional
+
+from pydantic import BaseModel
+
+from lib.serializers.models.book_modal import BookModal
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
+
+class AllBooksModal(BaseModel):
+    """
+    
+    """  # noqa: E501
+    books: Optional[List[BookModal]] = None
+    __properties: ClassVar[List[str]] = ["books"]
+
+    model_config = {
+        "populate_by_name": True,
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of AllBooksModal from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude={
+            },
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in books (list)
+        _items = []
+        if self.books:
+            for _item in self.books:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['books'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Dict) -> Self:
+        """Create an instance of AllBooksModal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "books": [BookModal.from_dict(_item) for _item in obj.get("books")] if obj.get(
+                "books") is not None else None
+        })
+        return _obj

lib/serializers/models/add_list_of_books.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    Book Store API
+
+    Book Store Web API
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from datetime import datetime
+from typing import Any, ClassVar, Dict, List, Optional, Union
+
+from pydantic import BaseModel, StrictFloat, StrictInt, StrictStr
+from pydantic import Field
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
+
+class BookModal(BaseModel):
+    """
+    
+    """  # noqa: E501
+    isbn: Optional[StrictStr] = None
+    title: Optional[StrictStr] = None
+    sub_title: Optional[StrictStr] = Field(default=None, alias="subTitle")
+    author: Optional[StrictStr] = None
+    publish_date: Optional[datetime] = None
+    publisher: Optional[StrictStr] = None
+    pages: Optional[Union[StrictFloat, StrictInt]] = None
+    description: Optional[StrictStr] = None
+    website: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["isbn", "title", "subTitle", "author", "publish_date", "publisher", "pages",
+                                         "description", "website"]
+
+    model_config = {
+        "populate_by_name": True,
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of BookModal from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude={
+            },
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Dict) -> Self:
+        """Create an instance of BookModal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "isbn": obj.get("isbn"),
+            "title": obj.get("title"),
+            "subTitle": obj.get("subTitle"),
+            "author": obj.get("author"),
+            "publish_date": obj.get("publish_date"),
+            "publisher": obj.get("publisher"),
+            "pages": obj.get("pages"),
+            "description": obj.get("description"),
+            "website": obj.get("website")
+        })
+        return _obj