partest 0.1.8__tar.gz

partest-0.1.8/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: partest
+Version: 0.1.8
+Summary: This is a module for the rapid implementation of test cases with coverage tracking. This module contains a call counter for specific endpoints and their methods. As well as the function of determining the types of tests that need to be counted.
+Home-page: https://github.com/Dec01/partest
+Author: dec01
+Author-email: parschin.ewg@yandex.ru
+Project-URL: GitHub, https://github.com/Dec01/partest
+Keywords: autotest partest test coverage
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: allure-pytest>=2.8.18
+Requires-Dist: pytest-asyncio>=0.23.7
+Requires-Dist: pytest==8.3.3
+
+## HI!
+
+This is a framework for API autotests with coverage assessment. Detailed instructions in the process of writing. It is better to check with the author how to use it. Tools are used:
+
+* pytest
+* httpx
+* allure
+
+Files are required for specific work:
+
+**conftest.py** - it must have a fixture's inside:
+
+```commandline
+@pytest.fixture(scope="session")
+def api_client(domain):
+    return ApiClient(domain=domain)
+```
+```commandline
+@pytest.fixture(scope='session', autouse=True)
+def clear_call_data():
+    """Фикстура для очистки данных перед запуском тестов."""
+    global call_count, call_type
+    api_call_storage.call_count.clear()
+    api_call_storage.call_type.clear()
+    yield
+```
+
+**confpartest.py** - It must have variables inside:
+
+```
+swagger_files = {
+    'test1': ['local', '../public/swagger/app-openapi.yaml'],
+    'test2': ['local', '../public/swagger/app-openapi2.yaml'],
+    'test3': ['url', 'https://url.ru']
+}
+
+test_types_coverage = ['default', '405', 'param']
+```
+
+The project must have a test that displays information about the coverage in allure. The name of it **test_zorro.py**:
+
+```commandline
+
+    async def test_display_final_call_counts(self):
+        report_lines = []
+        total_coverage_percentage = 0
+        total_endpoints = 0
+        total_calls_excluding_generation = 0
+
+        for (method, endpoint, description), count in call_count.items():
+            types = set(call_type[(method, endpoint, description)])
+            total_endpoints += 1
+
+            # Подсчет вызовов, исключая тип 'generation_data'
+            if 'generation_data' not in types:
+                total_calls_excluding_generation += count
+
+            # Проверка на наличие обязательных типов тестов
+            coverage_status = "Недостаточное покрытие ❌"
+            matched_types = set(types).intersection(types)  
+            count_matched = len(matched_types)
+
+            # Логика для определения статуса покрытия и расчета процента
+            if count_matched == len(types):  # Все типы присутствуют
+                coverage_status = "Покрытие выполнено ✅"
+                total_coverage_percentage += 100
+            elif count_matched == 2:  
+                coverage_status = "Покрытие выполнено на 66% 🔔"
+                total_coverage_percentage += 66
+            elif count_matched == 1:  
+                coverage_status = "Покрытие выполнено на 33% ❌"
+                total_coverage_percentage += 33
+            else: 
+                coverage_status = "Недостаточное покрытие ❌"
+                total_coverage_percentage += 0
+
+            report_line = (
+                f"\n{description}\nЭндпоинт: {endpoint}\nМетод: {method} | "
+                f"Обращений: {count}, Типы тестов: {', '.join(types)}\n{coverage_status}\n"
+            )
+            report_lines.append(report_line)
+
+        # Вычисление общего процента покрытия
+        if total_endpoints > 0:
+            average_coverage_percentage = total_coverage_percentage / total_endpoints
+        else:
+            average_coverage_percentage = 0
+
+        border = "*" * 50
+        summary = f"{border}\nОбщий процент покрытия: {average_coverage_percentage:.2f}%\nОбщее количество вызовов (исключая 'generation_data'): {total_calls_excluding_generation}\n{border}\n"
+
+        # Добавляем сводку в начало отчета
+        report_lines.insert(0, summary)
+
+        create_chart(call_count)
+
+        with open('api_call_counts.png', 'rb') as f:
+            allure.attach(f.read(), name='Оценка покрытия', attachment_type=allure.attachment_type.PNG)
+
+        allure.attach("\n".join(report_lines), name='Отчет по вызовам API', attachment_type=allure.attachment_type.TEXT)
+
+        assert True
+
+```
+
+
+What does the test look like:
+
+```commandline
+    async def test_get(self, api_client):
+        endpoint = 'https://ya.ru'
+        response = await api_client.make_request(
+            'GET',
+            endpoint,
+            params='limit=1',
+            expected_status_code=200,
+            validate_model=Models.ValidateGet,
+            type=types.type_default
+        )
+        assert response is not None
+        assert isinstance(response, dict)
+```
+
+All available data that the client can accept:
+```
+method: str,
+endpoint: str,
+add_url1: Optional[str] = '',
+add_url2: Optional[str] = '',
+add_url3: Optional[str] = '',
+params: Optional[Dict[str, Any]] = None,
+headers: Optional[Dict[str, str]] = None,
+data: Optional[Dict[str, Any]] = None,
+expected_status_code: Optional[int] = None,
+validate_model: Optional[Type[BaseModel]] = None,
+type: Optional[str] = None```

partest-0.1.8/README.md

@@ -0,0 +1,136 @@
+## HI!
+
+This is a framework for API autotests with coverage assessment. Detailed instructions in the process of writing. It is better to check with the author how to use it. Tools are used:
+
+* pytest
+* httpx
+* allure
+
+Files are required for specific work:
+
+**conftest.py** - it must have a fixture's inside:
+
+```commandline
+@pytest.fixture(scope="session")
+def api_client(domain):
+    return ApiClient(domain=domain)
+```
+```commandline
+@pytest.fixture(scope='session', autouse=True)
+def clear_call_data():
+    """Фикстура для очистки данных перед запуском тестов."""
+    global call_count, call_type
+    api_call_storage.call_count.clear()
+    api_call_storage.call_type.clear()
+    yield
+```
+
+**confpartest.py** - It must have variables inside:
+
+```
+swagger_files = {
+    'test1': ['local', '../public/swagger/app-openapi.yaml'],
+    'test2': ['local', '../public/swagger/app-openapi2.yaml'],
+    'test3': ['url', 'https://url.ru']
+}
+
+test_types_coverage = ['default', '405', 'param']
+```
+
+The project must have a test that displays information about the coverage in allure. The name of it **test_zorro.py**:
+
+```commandline
+
+    async def test_display_final_call_counts(self):
+        report_lines = []
+        total_coverage_percentage = 0
+        total_endpoints = 0
+        total_calls_excluding_generation = 0
+
+        for (method, endpoint, description), count in call_count.items():
+            types = set(call_type[(method, endpoint, description)])
+            total_endpoints += 1
+
+            # Подсчет вызовов, исключая тип 'generation_data'
+            if 'generation_data' not in types:
+                total_calls_excluding_generation += count
+
+            # Проверка на наличие обязательных типов тестов
+            coverage_status = "Недостаточное покрытие ❌"
+            matched_types = set(types).intersection(types)  
+            count_matched = len(matched_types)
+
+            # Логика для определения статуса покрытия и расчета процента
+            if count_matched == len(types):  # Все типы присутствуют
+                coverage_status = "Покрытие выполнено ✅"
+                total_coverage_percentage += 100
+            elif count_matched == 2:  
+                coverage_status = "Покрытие выполнено на 66% 🔔"
+                total_coverage_percentage += 66
+            elif count_matched == 1:  
+                coverage_status = "Покрытие выполнено на 33% ❌"
+                total_coverage_percentage += 33
+            else: 
+                coverage_status = "Недостаточное покрытие ❌"
+                total_coverage_percentage += 0
+
+            report_line = (
+                f"\n{description}\nЭндпоинт: {endpoint}\nМетод: {method} | "
+                f"Обращений: {count}, Типы тестов: {', '.join(types)}\n{coverage_status}\n"
+            )
+            report_lines.append(report_line)
+
+        # Вычисление общего процента покрытия
+        if total_endpoints > 0:
+            average_coverage_percentage = total_coverage_percentage / total_endpoints
+        else:
+            average_coverage_percentage = 0
+
+        border = "*" * 50
+        summary = f"{border}\nОбщий процент покрытия: {average_coverage_percentage:.2f}%\nОбщее количество вызовов (исключая 'generation_data'): {total_calls_excluding_generation}\n{border}\n"
+
+        # Добавляем сводку в начало отчета
+        report_lines.insert(0, summary)
+
+        create_chart(call_count)
+
+        with open('api_call_counts.png', 'rb') as f:
+            allure.attach(f.read(), name='Оценка покрытия', attachment_type=allure.attachment_type.PNG)
+
+        allure.attach("\n".join(report_lines), name='Отчет по вызовам API', attachment_type=allure.attachment_type.TEXT)
+
+        assert True
+
+```
+
+
+What does the test look like:
+
+```commandline
+    async def test_get(self, api_client):
+        endpoint = 'https://ya.ru'
+        response = await api_client.make_request(
+            'GET',
+            endpoint,
+            params='limit=1',
+            expected_status_code=200,
+            validate_model=Models.ValidateGet,
+            type=types.type_default
+        )
+        assert response is not None
+        assert isinstance(response, dict)
+```
+
+All available data that the client can accept:
+```
+method: str,
+endpoint: str,
+add_url1: Optional[str] = '',
+add_url2: Optional[str] = '',
+add_url3: Optional[str] = '',
+params: Optional[Dict[str, Any]] = None,
+headers: Optional[Dict[str, str]] = None,
+data: Optional[Dict[str, Any]] = None,
+expected_status_code: Optional[int] = None,
+validate_model: Optional[Type[BaseModel]] = None,
+type: Optional[str] = None```

partest-0.1.8/partest/__init__.py

@@ -0,0 +1,7 @@
+from .coverage import *
+from .call_storage import *
+from .client import *
+from .test_types import *
+from .allure_graph import *
+from .methods import *
+from .parparser import *

partest-0.1.8/partest/allure_graph.py

@@ -0,0 +1,20 @@
+import matplotlib.pyplot as plt
+
+def create_chart(call_count):
+    ''' Creating a graph that contains data on endpoint calls '''
+    methods = []
+    counts = []
+
+    for (method, endpoint, description), count in call_count.items():
+        methods.append(f"{description} ({method})")
+        counts.append(count)
+
+    plt.figure(figsize=(10, 6))
+    plt.barh(methods, counts, color='skyblue')
+    plt.xlabel('Количество вызовов')
+    plt.title('Количество вызовов API по методам и описаниям')
+    plt.tight_layout()
+
+    # Сохранение графика в файл
+    plt.savefig('api_call_counts.png')
+    plt.close()

partest-0.1.8/partest/call_storage.py

@@ -0,0 +1,4 @@
+''' Data on the number of requests and types of tests are collected here. '''
+
+call_count = {}
+call_type = {}

partest-0.1.8/partest/client.py

@@ -0,0 +1,146 @@
+import httpx
+from typing import Optional, Dict, Any, Type
+
+from pydantic import BaseModel, ValidationError
+from partest import track_api_calls
+from partest.utils import Logger, errordesc, StatusCode
+
+
+class ApiClient:
+    """
+    ApiClient serves not only as a client for making requests for endpoints, but also for processing these requests.
+
+    Attributes
+    ----------
+    :param domain:
+    :param verify:
+    :param follow_redirects:
+
+    """
+
+
+    def __init__(self, domain, verify=False, follow_redirects=True):
+        self.domain = domain
+        self.verify = verify
+        self.follow_redirects = follow_redirects
+        self.logger = Logger()
+
+    @track_api_calls
+    async def make_request(
+        self,
+        method: str,
+        endpoint: str,
+        add_url1: Optional[str] = '',
+        add_url2: Optional[str] = '',
+        add_url3: Optional[str] = '',
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        expected_status_code: Optional[int] = None,
+        validate_model: Optional[Type[BaseModel]] = None,
+        type: Optional[str] = None
+
+    ) -> Optional[Dict[str, Any]]:
+
+        url = f"{self.domain}{endpoint}{add_url1}{add_url2}{add_url3}"
+        self.logger.log_request(method, url, params=params, headers=headers, data=data)
+
+        async with httpx.AsyncClient(verify=self.verify, follow_redirects=self.follow_redirects) as client:
+            try:
+                response = await self._perform_request(client, method, url, params, headers, data)
+
+                self.logger.log_response(response)
+
+                if expected_status_code is not None:
+                    self._check_status_code(response.status_code, expected_status_code, response, data, validate_model)
+
+                return response.json()
+
+            except httpx.HTTPStatusError as err:
+                return self._handle_http_error(err, data)
+
+            except httpx.RequestError as e:
+                self.logger.error(f"An error occurred: {e}")
+                return None
+
+    async def _perform_request(self, client, method: str, url: str, params: Optional[Dict[str, Any]],
+                               headers: Optional[Dict[str, str]], data: Optional[Dict[str, Any]]) -> httpx.Response:
+        if method == "GET":
+            return await client.get(url, params=params, headers=headers)
+        elif method == "POST":
+            return await client.post(url, json=data, params=params, headers=headers)
+        elif method == "PUT":
+            return await client.put(url, json=data, params=params, headers=headers)
+        elif method == "PATCH":
+            return await client.patch(url, json=data, params=params, headers=headers)
+        elif method == "DELETE":
+            return await client.delete(url, params=params, headers=headers)
+        else:
+            raise ValueError("Unsupported HTTP method")
+
+    def _check_status_code(self, actual_code: int, expected_code: int, response: httpx.Response,
+                           request_data: Optional[Dict[str, Any]], validate_model: Optional[Type[BaseModel]]):
+        """ We check whether the actual status code corresponds to the expected status code. """
+        if actual_code != expected_code:
+            error_description = errordesc()
+            error_description.codeExpected = expected_code
+            error_description.codeActual = actual_code
+            error_description.responseBody = response
+            error_description.requestBody = request_data
+            self.logger.error(errordesc.status(
+                codeExpected=expected_code,
+                codeActual=error_description.codeActual,
+                responseBody=error_description.responseBody
+            ))
+            raise AssertionError(f"Expected status code {expected_code}, but got {actual_code}")
+
+        if validate_model:
+            try:
+                data = response.json()
+                assert validate_model.response_default(data)
+            except ValidationError as e:
+                self.logger.error(errordesc.validate(
+                    validateModel=validate_model,
+                    validateData=data,
+                    error=str(e)
+                ))
+                raise AssertionError(f"Response data validation failed: {e}")
+
+    def _handle_http_error(self, err: httpx.HTTPStatusError, request_data: Optional[Dict[str, Any]]):
+        """ Exception handling. """
+        error_description = errordesc()
+        error_description.codeExpected = StatusCode.ok
+        error_description.codeActual = err.response.status_code
+        error_description.responseBody = err.response
+        error_description.requestBody = request_data
+        self.logger.error(errordesc.status(
+            codeExpected=StatusCode.ok,
+            codeActual=error_description.codeActual,
+            responseBody=error_description.responseBody
+        ))
+        return None
+
+class Get(ApiClient):
+    async def get(self, endpoint, add_url1=None, add_url2=None, add_url3=None, params=None, headers=None, data=None, expected_status_code=None, validate_model=None):
+        return await self.make_request("GET", endpoint, add_url1=add_url1, add_url2=add_url2, add_url3=add_url3, params=params, data=data, headers=headers,
+                                       expected_status_code=expected_status_code, validate_model=validate_model)
+
+class Post(ApiClient):
+    async def post(self, endpoint, add_url1=None, add_url2=None, add_url3=None, params=None, data=None, headers=None, expected_status_code=None, validate_model=None):
+        return await self.make_request("POST", endpoint, add_url1=add_url1, add_url2=add_url2, add_url3=add_url3, params=params, data=data, headers=headers,
+                                       expected_status_code=expected_status_code, validate_model=validate_model)
+
+class Patch(ApiClient):
+    async def patch(self, endpoint, add_url1=None, add_url2=None, add_url3=None, params=None, data=None, headers=None, expected_status_code=None, validate_model=None):
+        return await self.make_request("PATCH", endpoint, add_url1=add_url1, add_url2=add_url2, add_url3=add_url3, params=params, data=data, headers=headers,
+                                       expected_status_code=expected_status_code, validate_model=validate_model)
+
+class Put(ApiClient):
+    async def put(self, endpoint, add_url1=None, add_url2=None, add_url3=None, params=None, data=None, headers=None, expected_status_code=None, validate_model=None):
+        return await self.make_request("PUT", endpoint, add_url1=add_url1, add_url2=add_url2, add_url3=add_url3, params=params, data=data, headers=headers,
+                                       expected_status_code=expected_status_code, validate_model=validate_model)
+
+class Delete(ApiClient):
+    async def delete(self, endpoint, add_url1=None, add_url2=None, add_url3=None, params=None, data=None, headers=None, expected_status_code=None, validate_model=None):
+        return await self.make_request("DELETE", endpoint, add_url1=add_url1, add_url2=add_url2, add_url3=add_url3, params=params, data=data, headers=headers,
+                                       expected_status_code=expected_status_code, validate_model=validate_model)

partest-0.1.8/partest/coverage.py

@@ -0,0 +1,90 @@
+import re
+from functools import wraps
+from typing import Callable
+from uuid import UUID
+
+from confpartest import swagger_files
+from partest.call_storage import call_count, call_type
+from partest.parparser import SwaggerSettings
+
+swagger_settings = SwaggerSettings(swagger_files)
+paths_info = swagger_settings.collect_paths_info()
+
+def track_api_calls(func: Callable) -> Callable:
+    """Decorator for tracking API calls."""
+
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        method = args[1]
+        endpoint = args[2]
+        test_type = kwargs.get('type', 'unknown')
+
+        # Собираем параметры пути из paths_info
+        path_params = {}
+        for path in paths_info:
+            for param in path['parameters']:
+                if param.type == 'path':
+                    if param.name not in path_params:
+                        if param.schema is not None:
+                            if 'enum' in param.schema:
+                                path_params[param.name] = param.schema['enum']
+                            else:
+                                path_params[param.name] = []
+                        else:
+                            path_params[param.name] = []
+
+        # Processing the add_url parameters
+        for i in range(1, 4):
+            add_url = kwargs.get(f'add_url{i}')
+            if add_url:
+                new_param = re.sub(r'^.', '', add_url)
+                matched = False
+                remaining_param = None
+                for param_name, enum_values in path_params.items():
+                    if new_param in enum_values:
+                        endpoint += '/{' + f'{param_name}' + '}'
+                        matched = True
+                        break
+                    else:
+                        remaining_param = param_name
+
+                if not matched and remaining_param:
+                    # If no match is found, add the remaining parameter
+                    endpoint += '/{' + f'{remaining_param}' + '}'
+
+        # Check if the current method and endpoint match any of the paths_info
+        if method is not None and endpoint is not None:
+            matched_any = False  # Flag for tracking whether a match has been found
+            for path in paths_info:
+                if path['method'] == method and path['path'] == endpoint:
+                    key = (method, endpoint, path['description'])
+
+                    if key not in call_count:
+                        call_count[key] = 0
+                        call_type[key] = []
+                    call_count[key] += 1
+                    call_type[key].append(test_type)
+                    matched_any = True
+                    break
+
+            # After checking all the paths, add the not found endpoints with 0 calls
+            for path in paths_info:
+                key = (path['method'], path['path'], path['description'])
+                if key not in call_count:
+                    call_count[key] = 0
+                    call_type[key] = []
+
+        response = await func(*args, **kwargs)
+
+        return response
+
+    return wrapper
+
+
+def is_valid_uuid(uuid_to_test, version=4):
+    """Checks whether the string is a valid UUID."""
+    try:
+        uuid_obj = UUID(uuid_to_test, version=version)
+    except ValueError:
+        return False
+    return str(uuid_obj) == uuid_to_test

partest-0.1.8/partest/methods.py

@@ -0,0 +1,2 @@
+class MethodsList:
+    methods = {'GET': 'GET', 'POST': 'POST', 'PATCH': 'PATCH', 'PUT': 'PUT', 'DELETE': 'DELETE'}

partest-0.1.8/partest/parparser.py

@@ -0,0 +1,214 @@
+import yaml
+import requests
+
+class Parameter:
+    """Class representing a parameter in an API path."""
+    def __init__(self, name, param_type, required=False, description='', schema=None):
+        self.name = name
+        self.type = param_type
+        self.required = required
+        self.description = description
+        self.schema = schema
+
+    def __repr__(self):
+        return f"Parameter(name={self.name}, type={self.type}, required={self.required}, description={self.description}, schema={self.schema})"
+
+
+class RequestBody:
+    """Class representing the request body of an API path."""
+    def __init__(self, content):
+        self.content = content
+
+    @staticmethod
+    def resolve_schema(schema_ref, swagger_dict):
+        return OpenAPIParser.resolve_ref(schema_ref, swagger_dict)
+
+    def __repr__(self):
+        return f"RequestBody(content={self.content})"
+
+
+class Response:
+    """Class representing a response from an API path."""
+    def __init__(self, status_code, content):
+        self.status_code = status_code
+        self.content = content
+
+    @staticmethod
+    def resolve_schema(schema_ref, swagger_dict):
+        return OpenAPIParser.resolve_ref(schema_ref, swagger_dict)
+
+    def __repr__(self):
+        return f"Response(status_code={self.status_code}, content={self.content})"
+
+
+class Path:
+    """Class representing a path in an API."""
+    def __init__(self, path, method, description, parameters, request_body, responses):
+        self.path = path
+        self.method = method
+        self.description = description
+        self.parameters = parameters
+        self.request_body = request_body
+        self.responses = responses
+
+    def __repr__(self):
+        return f"Path(path={self.path}, method={self.method}, description={self.description}, parameters={self.parameters}, request_body={self.request_body}, responses={self.responses})"
+
+
+class OpenAPIParser:
+    """Class for parsing OpenAPI specifications."""
+    def __init__(self, swagger_dict):
+        self.swagger_dict = swagger_dict
+
+    @staticmethod
+    def resolve_ref(ref, swagger_dict):
+        parts = ref.split('/')
+        resolved = swagger_dict
+        for part in parts[1:]:
+            resolved = resolved[part]
+        return resolved
+
+    @classmethod
+    def load_swagger_yaml(cls, source_type, file_path=None):
+        """Loads the Swagger YAML file from a local file or a URL."""
+        if source_type == 'local':
+            with open(file_path, 'r') as file:
+                swagger_dict = yaml.safe_load(file)
+        elif source_type == 'url':
+            response = requests.get(file_path)
+            response.raise_for_status()
+            swagger_dict = yaml.safe_load(response.text)
+        else:
+            raise ValueError("Invalid source type. Use 'local' or 'url'.")
+
+        return cls(swagger_dict)
+
+    def extract_paths_info(self):
+        """Extracts path information from the Swagger specification."""
+        paths = self.swagger_dict.get('paths', {})
+        result = []
+
+        for path, methods in paths.items():
+            for method, details in methods.items():
+                parameters = self.extract_parameters(details)
+                request_body = self.extract_request_body(details)
+                responses = self.extract_responses(details)
+                description = self.safe_get_description(details)
+                result.append(Path(
+                    path=path,
+                    method=method.upper(),
+                    description=description,
+                    parameters=parameters,
+                    request_body=request_body,
+                    responses=responses
+                ))
+
+        return result
+
+    def extract_parameters(self, details):
+        """Extracts parameters from the method details."""
+        parameters = []
+        if 'parameters' in details:
+            for param in details['parameters']:
+                resolved_param = self.resolve_param(param)
+                parameters.append(resolved_param)
+        return parameters
+
+    def extract_request_body(self, details):
+        """Extracts the request body from method details."""
+        if 'requestBody' in details:
+            content = details['requestBody'].get('content', {})
+            if 'application/json' in content:
+                if 'schema' in content['application/json'] and '$ref' in content['application/json']['schema']:
+                    schema_ref = content['application/json']['schema']['$ref']
+                    resolved_schema = RequestBody.resolve_schema(schema_ref, self.swagger_dict)
+                    content['application/json']['schema'] = resolved_schema
+                return RequestBody(content['application/json'])
+        return None
+
+    def extract_responses(self, details):
+        """Extracts responses from method details."""
+        responses = {}
+        if 'responses' in details:
+            for code, response in details['responses'].items():
+                if 'content' in response and 'application/json' in response['content']:
+                    content = response['content']['application/json']
+                    if 'schema' in content and '$ref' in content['schema']:
+                        schema_ref = content['schema']['$ref']
+                        resolved_schema = Response.resolve_schema(schema_ref, self.swagger_dict)
+                        content['schema'] = resolved_schema
+                    responses[code] = Response(code, response)
+        return responses
+
+    def resolve_param(self, param):
+        """Resolves a parameter definition."""
+        if '$ref' in param:
+            resolved_param = self.resolve_ref(param['$ref'], self.swagger_dict)
+            schema_content = None
+            if 'schema' in resolved_param and '$ref' in resolved_param['schema']:
+                schema_ref = resolved_param['schema']['$ref']
+                schema_content = self.resolve_ref(schema_ref, self.swagger_dict)
+            return Parameter(
+                name=resolved_param['name'],
+                param_type=resolved_param['in'],
+                required=resolved_param.get('required', False),
+                description=resolved_param.get('description', ''),
+                schema=schema_content
+            )
+        else:
+            schema_content = None
+            if 'schema' in param and '$ref' in param['schema']:
+                schema_ref = param['schema']['$ref']
+                schema_content = self.resolve_ref(schema_ref, self.swagger_dict)
+
+            return Parameter(
+                name=param['name'],
+                param_type=param['in'],
+                required=param.get('required', False),
+                description=param.get('description', ''),
+                schema=schema_content
+            )
+
+    def safe_get_description(self, details):
+        """Safely retrieves the description from details."""
+        if isinstance(details, dict):
+            return details.get('description', '')
+        elif isinstance(details, list) and details:
+            return details[0].get('description', '') if isinstance(details[0], dict) else ''
+        return ''
+
+
+class SwaggerSettings:
+    """Class for managing Swagger settings and loading Swagger files."""
+    def __init__(self, swagger_files):
+        self.local_files = []
+        self.swaggers = []
+        self.add_swagger(swagger_files)
+
+    def add_swagger(self, swagger_dict):
+        """Adds swaggger definitions from a dictionary to the swaggers list."""
+        for name, (source_type, path) in swagger_dict.items():
+            self.swaggers.append((source_type, path))
+
+    def load_swagger(self):
+        """Loads swaggger definitions and returns their data."""
+        all_extracted_data = []
+        for source_type, path in self.swaggers:
+            parser = OpenAPIParser.load_swagger_yaml(source_type, path)
+            extracted_data = parser.extract_paths_info()
+            all_extracted_data.extend(extracted_data)
+        return all_extracted_data
+
+    def collect_paths_info(self):
+        """Collects path information from all swagger definitions."""
+        extracted_data = self.load_swagger()
+        paths_info = []
+
+        for item in extracted_data:
+            paths_info.append({
+                'description': item.description,
+                'path': item.path,
+                'method': item.method,
+                'parameters': item.parameters
+            })
+        return paths_info

partest-0.1.8/partest/test_types.py

@@ -0,0 +1,8 @@
+
+class TypesTestCases:
+    type_default = 'default'
+    type_405 = '405'
+    type_params = 'params'
+    type_elem = 'elem'
+    type_gen = 'generation_data'
+    type_health = 'health'

partest-0.1.8/partest/utils/__init__.py

@@ -0,0 +1,4 @@
+from .logger import *
+from .date import *
+from .ascii import *
+from .checking import *

partest-0.1.8/partest/utils/ascii.py

@@ -0,0 +1,14 @@
+class BColors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKCYAN = '\033[96m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+
+class MethodTypes:
+    type_list = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']

partest-0.1.8/partest/utils/checking.py

@@ -0,0 +1,73 @@
+import json
+
+
+class errordesc:
+    def __init__(self):
+        self.codeExpected = None
+        self.codeActual = None
+        self.responseBody = None
+        self.responseHeader = None
+        self.requestHeader = None
+        self.requestBody = None
+        self.payloadElement = None
+        self.dataElement = None
+
+
+    @classmethod
+    def status(cls, codeExpected=200, codeActual=None, responseBody=None):
+        try:
+            body = f'Response body: \n{json.dumps(responseBody.json(), indent=4, ensure_ascii=False)}\n'
+        except:
+            body = f'Response (non-JSON): {responseBody.text}\n'
+        finally:
+            desc = (f"\n\n---->\nОшибка! Пришел некорректный статус код!\n"
+                    f"Ожидали код: {codeExpected} <\> Получили код: {codeActual}\n"
+                    f"{body}\n<----\n\n")
+        return desc
+
+    @classmethod
+    def validate(cls, validateData=None, validateModel=None, error=None):
+        try:
+            return "\n\n---->\nОшибка валидации, объекты сравнения:", error, validateModel, '\n', validateData, "\nПодробнее в принт-логах.\n<----\n\n"
+        except:
+            return "Нет тела или модели"
+
+    @classmethod
+    def _ifelse(cls):
+        try:
+            return "\n\n---->\nНе выполнены условия для выполнения теста, падение.\n<----\n\n"
+        except:
+            return "Чёт пошло не так"
+
+    @classmethod
+    def element(cls, payloadElement=None, dataElement=None, requestBody=None, responseBody=None ):
+        try:
+            if requestBody is not None and responseBody is not None:
+                _resp_body = f'Response body: \n{json.dumps(responseBody.json(), indent=4, ensure_ascii=False)}\n'
+                _req_body = f'Request body: \n{json.dumps(requestBody.json(), indent=4, ensure_ascii=False)}\n'
+            else:
+                _resp_body = ""
+                _req_body = ""
+        except:
+            if requestBody is not None and responseBody is not None:
+                _resp_body = f'Response (non-JSON): {responseBody.text}\n'
+                _req_body = f'Request (non-JSON): {requestBody.text}\n'
+            else:
+                _resp_body = ""
+                _req_body = ""
+        finally:
+            desc = (f"\n\n---->\nОшибка! Получили не то значение элемента что ожидали!\n"
+                    f"Ожидали значение: {payloadElement} <\> Получили значение: {dataElement}\n"
+                    f"{_resp_body}\n{_req_body}\n<----\n\n")
+        return desc
+
+    def __str__(self):
+     return "Ответ не валиден"
+
+class StatusCode:
+    ok = 200
+    bad_request = 400
+    not_allowed = 405
+    forbidden = 403
+    not_found = 404
+    exception_400 = [200, 400]

partest-0.1.8/partest/utils/date.py

@@ -0,0 +1,24 @@
+from datetime import datetime, timedelta
+
+
+class DateGen:
+    def __init__(self):
+        self._current_date = datetime.now()
+        self._formats = {
+            "default": "%Y-%m-%dT%H:%M:00+03:00",
+            "short": "%Y-%m-%d",
+            "long": "%Y-%m-%d %H:%M:%S",
+        }
+
+    @classmethod
+    def get_start_date(cls, days=0, format="default"):
+        start_date = cls()._current_date - timedelta(days=days)
+        return start_date.strftime(cls()._formats[format])
+
+    @classmethod
+    def get_end_date(cls, days=0, format="default"):
+        end_date = cls()._current_date + timedelta(days=days)
+        return end_date.strftime(cls()._formats[format])
+
+    def __str__(self):
+     return self._current_date.strftime("%Y-%m-%d")

partest-0.1.8/partest/utils/logger.py

@@ -0,0 +1,38 @@
+import configparser
+import json
+import logging
+
+from faker.providers.bank.en_PH import logger
+
+
+class Logger:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.setup_logger()
+
+    def setup_logger(self):
+        parser = configparser.ConfigParser()
+        parser.read('pytest.ini')
+
+    def get_log(self):
+        return self.logger
+
+    def log_request(self, method, url, params=None, headers=None, data=None):
+        self.logger.info(
+            f'{"=" * 14}REQUEST INFO{"=" * 14}\nRequest Method: {method} \nURL: {url} \nParams: {params} \nHeaders: {headers} \nData: {data}\n{"=" * 13}↓RESPONSE INFO↓{"=" * 13}')
+
+    def log_response(self, response):
+        try:
+            self.logger.info(
+                f'Response StatusCode: {response.status_code}\nCookies: {response.cookies}\nHeaders: {response.headers}, \nData: {json.dumps(response.json(), indent=4, ensure_ascii=False)}')
+        except json.JSONDecodeError:
+            self.logger.info(f'Response (non-JSON): {response.text}\n')
+
+    def error(self, message):
+        self.logger.error(message)
+
+    def log_str(self, str):
+        return self.logger.info(str)
+
+    def __str__(self):
+        return logger.info()

partest-0.1.8/partest/zorro_report.py

@@ -0,0 +1,66 @@
+import allure
+
+from partest.test_types import TypesTestCases
+from partest.allure_graph import create_chart
+from partest.call_storage import call_count, call_type
+from confpartest import test_types_coverage, test_types_exception
+
+types = TypesTestCases
+required_types = test_types_coverage
+exception_types = test_types_exception
+
+def zorro():
+    """Function for displaying the total number of API calls and test types."""
+    report_lines = []
+    total_coverage_percentage = 0
+    total_endpoints = 0
+    total_calls_excluding_generation = 0
+
+    for (method, endpoint, description), count in call_count.items():
+        types = set(call_type[(method, endpoint, description)])
+        total_endpoints += 1
+
+        if 'generation_data' in types and len(types) == 1:
+            pass
+        else:
+            total_calls_excluding_generation += count
+
+        coverage_status = "Недостаточное покрытие ❌"
+        present_types = [test_type for test_type in required_types if test_type in types]
+        coverage_count = len(present_types)
+        required_count = len(required_types)
+
+        if any(exception_type in types for exception_type in exception_types):
+            coverage_percentage = 100
+            coverage_status = "Покрытие выполнено на 100% ✅ (исключение)"
+        elif coverage_count == required_count:
+            coverage_percentage = 100
+            coverage_status = "Покрытие выполнено ✅"
+        elif coverage_count > 0:
+            coverage_percentage = (coverage_count / required_count) * 100
+            coverage_status = f"Покрытие выполнено на {coverage_percentage:.2f}% 🔔"
+        else:
+            coverage_percentage = 0
+
+        total_coverage_percentage += coverage_percentage
+
+        report_line = (
+            f"\n{description}\nЭндпоинт: {endpoint}\nМетод: {method} | "
+            f"Обращений: {count}, Типы тестов: {', '.join(types)}\n{coverage_status}\n"
+        )
+        report_lines.append(report_line)
+
+    if total_endpoints > 0:
+        average_coverage_percentage = total_coverage_percentage / total_endpoints
+    else:
+        average_coverage_percentage = 0
+
+    border = "*" * 50
+    summary = f"{border}\nОбщий процент покрытия: {average_coverage_percentage:.2f}%\nОбщее количество вызовов (исключая 'generation_data'): {total_calls_excluding_generation}\n{border}\n"
+    report_lines.insert(0, summary)
+    create_chart(call_count)
+
+    with open('api_call_counts.png', 'rb') as f:
+        allure.attach(f.read(), name='Оценка покрытия', attachment_type=allure.attachment_type.PNG)
+
+    allure.attach("\n".join(report_lines), name='Отчет по вызовам API', attachment_type=allure.attachment_type.TEXT)

partest-0.1.8/partest.egg-info/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: partest
+Version: 0.1.8
+Summary: This is a module for the rapid implementation of test cases with coverage tracking. This module contains a call counter for specific endpoints and their methods. As well as the function of determining the types of tests that need to be counted.
+Home-page: https://github.com/Dec01/partest
+Author: dec01
+Author-email: parschin.ewg@yandex.ru
+Project-URL: GitHub, https://github.com/Dec01/partest
+Keywords: autotest partest test coverage
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: allure-pytest>=2.8.18
+Requires-Dist: pytest-asyncio>=0.23.7
+Requires-Dist: pytest==8.3.3
+
+## HI!
+
+This is a framework for API autotests with coverage assessment. Detailed instructions in the process of writing. It is better to check with the author how to use it. Tools are used:
+
+* pytest
+* httpx
+* allure
+
+Files are required for specific work:
+
+**conftest.py** - it must have a fixture's inside:
+
+```commandline
+@pytest.fixture(scope="session")
+def api_client(domain):
+    return ApiClient(domain=domain)
+```
+```commandline
+@pytest.fixture(scope='session', autouse=True)
+def clear_call_data():
+    """Фикстура для очистки данных перед запуском тестов."""
+    global call_count, call_type
+    api_call_storage.call_count.clear()
+    api_call_storage.call_type.clear()
+    yield
+```
+
+**confpartest.py** - It must have variables inside:
+
+```
+swagger_files = {
+    'test1': ['local', '../public/swagger/app-openapi.yaml'],
+    'test2': ['local', '../public/swagger/app-openapi2.yaml'],
+    'test3': ['url', 'https://url.ru']
+}
+
+test_types_coverage = ['default', '405', 'param']
+```
+
+The project must have a test that displays information about the coverage in allure. The name of it **test_zorro.py**:
+
+```commandline
+
+    async def test_display_final_call_counts(self):
+        report_lines = []
+        total_coverage_percentage = 0
+        total_endpoints = 0
+        total_calls_excluding_generation = 0
+
+        for (method, endpoint, description), count in call_count.items():
+            types = set(call_type[(method, endpoint, description)])
+            total_endpoints += 1
+
+            # Подсчет вызовов, исключая тип 'generation_data'
+            if 'generation_data' not in types:
+                total_calls_excluding_generation += count
+
+            # Проверка на наличие обязательных типов тестов
+            coverage_status = "Недостаточное покрытие ❌"
+            matched_types = set(types).intersection(types)  
+            count_matched = len(matched_types)
+
+            # Логика для определения статуса покрытия и расчета процента
+            if count_matched == len(types):  # Все типы присутствуют
+                coverage_status = "Покрытие выполнено ✅"
+                total_coverage_percentage += 100
+            elif count_matched == 2:  
+                coverage_status = "Покрытие выполнено на 66% 🔔"
+                total_coverage_percentage += 66
+            elif count_matched == 1:  
+                coverage_status = "Покрытие выполнено на 33% ❌"
+                total_coverage_percentage += 33
+            else: 
+                coverage_status = "Недостаточное покрытие ❌"
+                total_coverage_percentage += 0
+
+            report_line = (
+                f"\n{description}\nЭндпоинт: {endpoint}\nМетод: {method} | "
+                f"Обращений: {count}, Типы тестов: {', '.join(types)}\n{coverage_status}\n"
+            )
+            report_lines.append(report_line)
+
+        # Вычисление общего процента покрытия
+        if total_endpoints > 0:
+            average_coverage_percentage = total_coverage_percentage / total_endpoints
+        else:
+            average_coverage_percentage = 0
+
+        border = "*" * 50
+        summary = f"{border}\nОбщий процент покрытия: {average_coverage_percentage:.2f}%\nОбщее количество вызовов (исключая 'generation_data'): {total_calls_excluding_generation}\n{border}\n"
+
+        # Добавляем сводку в начало отчета
+        report_lines.insert(0, summary)
+
+        create_chart(call_count)
+
+        with open('api_call_counts.png', 'rb') as f:
+            allure.attach(f.read(), name='Оценка покрытия', attachment_type=allure.attachment_type.PNG)
+
+        allure.attach("\n".join(report_lines), name='Отчет по вызовам API', attachment_type=allure.attachment_type.TEXT)
+
+        assert True
+
+```
+
+
+What does the test look like:
+
+```commandline
+    async def test_get(self, api_client):
+        endpoint = 'https://ya.ru'
+        response = await api_client.make_request(
+            'GET',
+            endpoint,
+            params='limit=1',
+            expected_status_code=200,
+            validate_model=Models.ValidateGet,
+            type=types.type_default
+        )
+        assert response is not None
+        assert isinstance(response, dict)
+```
+
+All available data that the client can accept:
+```
+method: str,
+endpoint: str,
+add_url1: Optional[str] = '',
+add_url2: Optional[str] = '',
+add_url3: Optional[str] = '',
+params: Optional[Dict[str, Any]] = None,
+headers: Optional[Dict[str, str]] = None,
+data: Optional[Dict[str, Any]] = None,
+expected_status_code: Optional[int] = None,
+validate_model: Optional[Type[BaseModel]] = None,
+type: Optional[str] = None```

partest-0.1.8/partest.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+setup.cfg
+setup.py
+partest/__init__.py
+partest/allure_graph.py
+partest/call_storage.py
+partest/client.py
+partest/coverage.py
+partest/methods.py
+partest/parparser.py
+partest/test_types.py
+partest/zorro_report.py
+partest.egg-info/PKG-INFO
+partest.egg-info/SOURCES.txt
+partest.egg-info/dependency_links.txt
+partest.egg-info/requires.txt
+partest.egg-info/top_level.txt
+partest/utils/__init__.py
+partest/utils/ascii.py
+partest/utils/checking.py
+partest/utils/date.py
+partest/utils/logger.py

partest-0.1.8/partest.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

partest-0.1.8/partest.egg-info/requires.txt

@@ -0,0 +1,6 @@
+httpx>=0.27.2
+pyyaml>=6.0.2
+matplotlib>=3.9.2
+allure-pytest>=2.8.18
+pytest-asyncio>=0.23.7
+pytest==8.3.3

partest-0.1.8/partest.egg-info/top_level.txt

@@ -0,0 +1 @@
+partest

partest-0.1.8/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

partest-0.1.8/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+
+def readme():
+  with open('README.md', 'r') as f:
+    return f.read()
+
+
+setup(
+  name='partest',
+  version='0.1.8',
+  author='dec01',
+  author_email='parschin.ewg@yandex.ru',
+  description='This is a module for the rapid implementation of test cases with coverage tracking. This module contains a call counter for specific endpoints and their methods. As well as the function of determining the types of tests that need to be counted.',
+  long_description=readme(),
+  long_description_content_type='text/markdown',
+  url='https://github.com/Dec01/partest',
+  packages=find_packages(exclude=['src']),
+  install_requires=['httpx>=0.27.2', 'pyyaml>=6.0.2', 'matplotlib>=3.9.2', 'allure-pytest>=2.8.18', 'pytest-asyncio>=0.23.7', 'pytest==8.3.3'],
+  classifiers=[
+    'Programming Language :: Python :: 3',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: OS Independent'
+  ],
+  keywords='autotest partest test coverage',
+  project_urls={
+    'GitHub': 'https://github.com/Dec01/partest'
+  },
+  python_requires='>=3.8'
+)