pytestomatio 2.8.2.dev36__tar.gz → 2.8.2.dev38__tar.gz

{pytestomatio-2.8.2.dev36/pytestomatio.egg-info → pytestomatio-2.8.2.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytestomatio
-Version: 2.8.2.dev36
+Version: 2.8.2.dev38
 Summary: Pytest plugin to sync test with testomat.io
 Author: Oleksii Ostapov, TikoQA
 Project-URL: Testomat.io, https://testomat.io/
@@ -19,7 +19,6 @@ Requires-Dist: boto3>=1.28.28
 Requires-Dist: libcst==1.1.0
 Requires-Dist: commitizen>=3.18.1
 Requires-Dist: autopep8>=2.1.0
-Requires-Dist: pytest-xdist>=3.6.1
 
 [![Support Ukraine Badge](https://bit.ly/support-ukraine-now)](https://github.com/support-ukraine/support-ukraine)
 

{pytestomatio-2.8.2.dev36 → pytestomatio-2.8.2.dev38}/pyproject.toml

@@ -3,7 +3,6 @@ requires = ["setuptools>=65.5.1", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools.packages.find]
-include = ["pytestomatio"]
 exclude = [".github", "tests", "build", "dist", ".venv", "pytestomatio.egg-info", ".env", ".gitignore", "CHANGELOG.md"]
 
 [tool.commitizen]
@@ -11,10 +10,10 @@ name = "cz_conventional_commits"
 tag_format = "$version"
 version_scheme = "pep440"
 version_provider = "pep621"
-update_changelog_on_bump = true
+update_changelog_on_bump = false
 [project]
 name = "pytestomatio"
-version = "2.8.2.dev36"
+version = "2.8.2.dev38"
 
 dependencies = [
     "requests>=2.29.0",
@@ -22,8 +21,7 @@ dependencies = [
     "boto3>=1.28.28",
     "libcst==1.1.0",
     "commitizen>=3.18.1",
-    "autopep8>=2.1.0",
-    "pytest-xdist>=3.6.1"
+    "autopep8>=2.1.0"
 ]
 
 authors = [

pytestomatio-2.8.2.dev38/pytestomatio/connect/connector.py

@@ -0,0 +1,190 @@
+import requests
+from requests.exceptions import HTTPError, ConnectionError
+import logging
+from os.path import join, normpath
+from os import getenv
+from pytestomatio.utils.helper import safe_string_list
+from pytestomatio.testing.testItem import TestItem
+
+log = logging.getLogger('pytestomatio')
+
+
+class Connector:
+    def __init__(self, base_url: str = '', api_key: str = None):
+        self.base_url = base_url
+        self.session = requests.Session()
+        self.session.verify = True
+        self.jwt: str = ''
+        self.api_key = api_key
+
+    def load_tests(
+            self,
+            tests: list[TestItem],
+            no_empty: bool = False,
+            no_detach: bool = False,
+            structure: bool = False,
+            create: bool = False,
+            directory: str = None
+    ):
+        request = {
+            "framework": "pytest",
+            "language": "python",
+            "noempty": no_empty,
+            "no-detach": no_detach,
+            "structure": structure if not no_empty else False,
+            "create": create,
+            "sync": True,
+            "tests": []
+        }
+        for test in tests:
+            request['tests'].append({
+                "name": test.sync_title,
+                "suites": [
+                    test.class_name
+                ],
+                "code": test.source_code,
+                "file": test.file_path if structure else (
+                    test.file_name if directory is None else normpath(join(directory, test.file_name))),
+                "labels": safe_string_list(getenv('TESTOMATIO_SYNC_LABELS')),
+            })
+
+        try:
+            response = self.session.post(f'{self.base_url}/api/load?api_key={self.api_key}', json=request)
+        except ConnectionError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except HTTPError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except Exception as e:
+            log.error(f'Generic exception happened. Please report an issue. {e}')
+            return
+
+        if response.status_code < 400:
+            log.info(f'Tests loaded to {self.base_url}')
+        else:
+            log.error(f'Failed to load tests to {self.base_url}. Status code: {response.status_code}')
+
+    def get_tests(self, test_metadata: list[TestItem]) -> dict:
+        # with safe_request('Failed to get test ids from testomat.io'):
+        response = self.session.get(f'{self.base_url}/api/test_data?api_key={self.api_key}')
+        return response.json()
+
+    def create_test_run(self, title: str, group_title, env: str, label: str, shared_run: bool, parallel, ci_build_url: str) -> dict | None:
+        request = {
+            "api_key": self.api_key,
+            "title": title,
+            "group_title": group_title,
+            "env": env,
+            "label": label,
+            "parallel": parallel,
+            "ci_build_url": ci_build_url,
+        }
+        filtered_request = {k: v for k, v in request.items() if v is not None}
+        try:
+            response = self.session.post(f'{self.base_url}/api/reporter', json=filtered_request)
+        except ConnectionError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except HTTPError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except Exception as e:
+            log.error(f'Generic exception happened. Please report an issue. {e}')
+            return
+
+        if response.status_code == 200:
+            log.info(f'Test run created {response.json()["uid"]}')
+            return response.json()
+
+    def update_test_run(self, id: str, title: str, group_title,
+                        env: str, label: str, shared_run: bool, parallel, ci_build_url: str) -> dict | None:
+        request = {
+            "api_key": self.api_key,
+            "title": title,
+            "group_title": group_title,
+            # "env": env, TODO: enabled when bug with 500 response fixed
+            # "label": label, TODO: enabled when bug with 500 response fixed
+            "parallel": parallel,
+            "ci_build_url": ci_build_url,
+        }
+        filtered_request = {k: v for k, v in request.items() if v is not None}
+
+        try:
+            response = self.session.put(f'{self.base_url}/api/reporter/{id}', json=filtered_request)
+        except ConnectionError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except HTTPError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except Exception as e:
+            log.error(f'Generic exception happened. Please report an issue. {e}')
+            return
+
+        if response.status_code == 200:
+            log.info(f'Test run updated {response.json()["uid"]}')
+            return response.json()
+
+    def update_test_status(self, run_id: str,
+                           status: str,
+                           title: str,
+                           suite_title: str,
+                           suite_id: str,
+                           test_id: str,
+                           message: str,
+                           stack: str,
+                           run_time: float,
+                           artifacts: list[str],
+                           steps: str,
+                           code: str,
+                           example: dict) -> None:
+
+        request = {
+            "status": status,  # Enum: "passed" "failed" "skipped"
+            "title": title,
+            "suite_title": suite_title,
+            "suite_id": suite_id,
+            "test_id": test_id,
+            "message": message,
+            "stack": stack,
+            "run_time": run_time,
+            "example": example,
+            "artifacts": artifacts,
+            "steps": steps,
+            "code": code
+        }
+        filtered_request = {k: v for k, v in request.items() if v is not None}
+        try:
+            response = self.session.post(f'{self.base_url}/api/reporter/{run_id}/testrun?api_key={self.api_key}',
+                                         json=filtered_request)
+        except ConnectionError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except HTTPError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except Exception as e:
+            log.error(f'Generic exception happened. Please report an issue. {e}')
+            return
+        if response.status_code == 200:
+            log.info('Test status updated')
+
+    # TODO: I guess this class should be just an API client and used within testRun (testRunConfig)
+    def finish_test_run(self, run_id: str, is_final=False) -> None:
+        status_event = 'finish_parallel' if is_final else 'finish'
+        try:
+            self.session.put(f'{self.base_url}/api/reporter/{run_id}?api_key={self.api_key}',
+                             json={"status_event": status_event})
+        except ConnectionError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except HTTPError:
+            log.error(f'Failed to connect to {self.base_url}')
+            return
+        except Exception as e:
+            log.error(f'Generic exception happened. Please report an issue. {e}')
+            return
+
+    def disconnect(self):
+        self.session.close()

pytestomatio-2.8.2.dev38/pytestomatio/connect/s3_connector.py

@@ -0,0 +1,69 @@
+import boto3
+import logging
+from io import BytesIO
+
+log = logging.getLogger(__name__)
+log.setLevel('INFO')
+
+
+def parse_endpoint(endpoint: str or None) -> str or None:
+    if endpoint is None:
+        return
+    if endpoint.startswith('https://'):
+        return endpoint[8:]
+    elif endpoint.startswith('http://'):
+        return endpoint[7:]
+    return endpoint
+
+
+class S3Connector:
+    def __init__(self, aws_access_key_id: str or None = None,
+                 aws_secret_access_key: str or None = None,
+                 endpoint: str or None = None,
+                 bucket_name: str or None = None):
+
+        self.endpoint = parse_endpoint(endpoint)
+        self.bucket_name = bucket_name
+        self.client = None
+        self._is_logged_in = False
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+
+    def login(self):
+        log.debug('creating s3 session')
+        self.client = boto3.client(
+            's3',
+            endpoint_url=f'https://{self.endpoint}',
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key)
+        self._is_logged_in = True
+        log.info('s3 session created')
+
+    def upload_file(self, file_path: str, key: str = None, bucket_name: str = None) -> str or None:
+        if not self._is_logged_in:
+            log.warning('s3 session is not created, creating new one')
+            return
+        if not key:
+            key = file_path
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        if bucket_name is None:
+            raise Exception('bucket name is not defined')
+        log.info(f'uploading artifact {file_path} to s3://{bucket_name}/{key}')
+        self.client.upload_file(file_path, bucket_name, key)
+        log.info(f'artifact {file_path} uploaded to s3://{bucket_name}/{key}')
+        return f'https://{bucket_name}.{self.endpoint}/{key}'
+
+    def upload_file_object(self, file_bytes: bytes, key: str, bucket_name: str = None) -> str or None:
+        if not self._is_logged_in:
+            log.warning('s3 session is not created, creating new one')
+            return
+        file = BytesIO(file_bytes)
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        if bucket_name is None:
+            raise Exception('bucket name is not defined')
+        log.info(f'uploading artifact {key} to s3://{bucket_name}/{key}')
+        self.client.upload_fileobj(file, bucket_name, key)
+        log.info(f'artifact {key} uploaded to s3://{bucket_name}/{key}')
+        return f'https://{bucket_name}.{self.endpoint}/{key}'

pytestomatio-2.8.2.dev38/pytestomatio/decor/decorator_updater.py

@@ -0,0 +1,15 @@
+import os
+from pytestomatio.decor.pep8 import update_tests as update_tests_pep8
+from pytestomatio.decor.default import update_tests as update_tests_default
+
+
+def update_tests(file: str,
+                 mapped_tests: list[tuple[str, int]],
+                 all_tests: list[str],
+                 decorator_name: str,
+                 remove=False):
+    code_style = os.getenv('TESTOMATIO_CODE_STYLE', 'default')
+    if code_style == 'pep8':
+        update_tests_pep8(file, mapped_tests, all_tests, decorator_name, remove)
+    else:
+        update_tests_default(file, mapped_tests, all_tests, decorator_name, remove)

pytestomatio-2.8.2.dev38/pytestomatio/decor/default.py

@@ -0,0 +1,85 @@
+import libcst as cst
+from typing import List, Tuple, Union
+
+
+class DecoratorUpdater(cst.CSTTransformer):
+    def __init__(self, mapped_tests: List[Tuple[str, int]], all_tests: List[str], decorator_name: str):
+        self.mapped_tests = mapped_tests
+        self.all_tests = all_tests
+        self.decorator_name = decorator_name
+
+    def _get_id_by_title(self, title: str):
+        for pair in self.mapped_tests:
+            if pair[0] == title:
+                return pair[1]
+
+    def _remove_decorator(self, node: cst.FunctionDef) -> cst.FunctionDef:
+        node.decorator_list = [decorator for decorator in node.decorator_list if
+                               not (isinstance(decorator, cst.Call) and decorator.func.attr == self.decorator_name)]
+        return node
+
+    def remove_decorators(self, tree: cst.Module) -> cst.Module:
+        for node in cst.walk(tree):
+            if isinstance(node, cst.FunctionDef):
+                self.visit_FunctionDef(node, remove=True)
+        return tree
+
+    def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef) -> cst.FunctionDef:
+        if original_node.name.value in self.all_tests:
+            test_id = self._get_id_by_title(original_node.name.value)
+            if test_id is None:
+                return updated_node
+
+            deco_name = f'pytest.mark.{self.decorator_name}("{test_id}")'
+            decorator = cst.Decorator(decorator=cst.parse_expression(deco_name))
+
+            # Check if the decorator already exists
+            for existing_decorator in original_node.decorators:
+                if isinstance(existing_decorator.decorator, cst.Call) and \
+                        isinstance(existing_decorator.decorator.func, cst.Attribute) and \
+                        existing_decorator.decorator.func.attr.value == self.decorator_name:
+                    # The decorator already exists, so we don't add it
+                    return updated_node
+
+            # The decorator doesn't exist, so we add it
+            return updated_node.with_changes(decorators=[decorator] + list(updated_node.decorators))
+        return updated_node
+
+
+class DecoratorRemover(cst.CSTTransformer):
+    def __init__(self, decorator_name: str):
+        self.decorator_name = decorator_name
+
+    def leave_Decorator(self, original_node: cst.Decorator, updated_node: cst.Decorator) -> Union[
+        cst.Decorator, cst.RemovalSentinel]:
+        if isinstance(original_node.decorator, cst.Call) and \
+                isinstance(original_node.decorator.func, cst.Attribute) and \
+                original_node.decorator.func.attr.value == self.decorator_name and \
+                isinstance(original_node.decorator.func.value, cst.Attribute) and \
+                original_node.decorator.func.value.attr.value == 'mark' and \
+                isinstance(original_node.decorator.func.value.value, cst.Name) and \
+                original_node.decorator.func.value.value.value == 'pytest':
+            return cst.RemovalSentinel.REMOVE
+        return updated_node
+
+
+def update_tests(file: str,
+                 mapped_tests: List[Tuple[str, int]],
+                 all_tests: List[str],
+                 decorator_name: str,
+                 remove=False):
+    with open(file, 'r') as f:
+        source_code = f.read()
+
+    tree = cst.parse_module(source_code)
+    transform = DecoratorUpdater(mapped_tests, all_tests, decorator_name)
+    if remove:
+        transform = DecoratorRemover(decorator_name)
+        tree = tree.visit(transform)
+    else:
+        transform = DecoratorUpdater(mapped_tests, all_tests, decorator_name)
+        tree = tree.visit(transform)
+    updated_source_code = tree.code
+
+    with open(file, "w") as file:
+        file.write(updated_source_code)

pytestomatio-2.8.2.dev38/pytestomatio/decor/pep8.py

@@ -0,0 +1,79 @@
+import ast
+import autopep8
+
+pytest_mark = 'pytest', 'mark'
+
+
+class DecoratorUpdater(ast.NodeTransformer):
+    def __init__(self, mapped_tests: list[tuple[str, int]], all_tests: list[str], decorator_name: str):
+        self.mapped_tests = mapped_tests
+        self.all_tests = all_tests
+        self.decorator_name = decorator_name
+
+    def _get_id_by_title(self, title: str):
+        for pair in self.mapped_tests:
+            if pair[0] == title:
+                return pair[1]
+
+    def _remove_decorator(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        node.decorator_list = [decorator for decorator in node.decorator_list if
+                               not (isinstance(decorator, ast.Call) and decorator.func.attr == self.decorator_name)]
+        return node
+
+    def remove_decorators(self, tree: ast.Module) -> ast.Module:
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                self.visit_FunctionDef(node, remove=True)
+        return tree
+
+    def visit_FunctionDef(self, node: ast.FunctionDef, remove=False) -> ast.FunctionDef:
+        if remove:
+            return self._remove_decorator(node)
+        else:
+            if node.name in self.all_tests:
+                if not any(isinstance(decorator, ast.Call) and
+                           decorator.func.attr == self.decorator_name
+                           for decorator in node.decorator_list):
+                    test_id = self._get_id_by_title(node.name)
+                    deco_name = f'mark.{self.decorator_name}(\'{test_id}\')'
+                    decorator = ast.Name(id=deco_name, ctx=ast.Load())
+                    node.decorator_list = [decorator] + node.decorator_list
+        return node
+
+    def insert_pytest_mark_import(self, tree: ast.Module, module_name: str, decorator_name: str) -> None:
+        # Check if the import statement already exists
+        if not any(
+                isinstance(node, ast.ImportFrom) and
+                node.module == module_name and
+                any(alias.name == decorator_name for alias in node.names)
+                for node in tree.body
+        ):
+            import_node = ast.ImportFrom(
+                module=module_name,
+                names=[ast.alias(name=decorator_name, asname=None)],
+                level=0
+            )
+            tree.body.insert(0, import_node)
+
+
+def update_tests(file: str,
+                 mapped_tests: list[tuple[str, int]],
+                 all_tests: list[str],
+                 decorator_name: str,
+                 remove=False):
+    with open(file, 'r') as f:
+        source_code = f.read()
+
+    tree = ast.parse(source_code)
+    transform = DecoratorUpdater(mapped_tests, all_tests, decorator_name)
+    if remove:
+        transform.remove_decorators(tree)
+    else:
+        tree = transform.visit(tree)
+        transform.insert_pytest_mark_import(tree, *pytest_mark)
+    updated_source_code = ast.unparse(tree)
+
+    pep8_source_code = autopep8.fix_code(updated_source_code)
+
+    with open(file, "w") as file:
+        file.write(pep8_source_code)

{pytestomatio-2.8.2.dev36 → pytestomatio-2.8.2.dev38}/pytestomatio/main.py

@@ -2,13 +2,13 @@ import os, pytest, logging, json, time
 
 from pytest import Parser, Session, Config, Item, CallInfo
 from pytestomatio.connect.connector import Connector
-from pytestomatio.decor.decorator_updater import update_tests
-from pytestomatio.testing.testItem import TestItem
 from pytestomatio.connect.s3_connector import S3Connector
+from pytestomatio.testing.testItem import TestItem
+from pytestomatio.decor.decorator_updater import update_tests
+
 from pytestomatio.utils.helper import add_and_enrich_tests, get_test_mapping, collect_tests, read_env_s3_keys
 from pytestomatio.utils.parser_setup import parser_options
 from pytestomatio.utils import validations
-from xdist.plugin import is_xdist_controller, get_xdist_worker_id
 
 from pytestomatio.testomatio.testRunConfig import TestRunConfig
 from pytestomatio.testomatio.testomatio import Testomatio
@@ -20,6 +20,7 @@ log.setLevel('INFO')
 metadata_file = 'metadata.json'
 decorator_name = 'testomatio'
 testomatio = 'testomatio'
+TESTOMATIO_URL = 'https://app.testomat.io'
 
 
 def pytest_addoption(parser: Parser) -> None:
@@ -42,11 +43,11 @@ def pytest_configure(config: Config):
     if option == 'debug':
         return
 
-    is_parallel = config.getoption('numprocesses') is not None
+    is_parallel = hasattr(config.option, 'numprocesses')
 
     pytest.testomatio = Testomatio(TestRunConfig(is_parallel))
 
-    url = os.environ.get('TESTOMATIO_URL') or config.getini('testomatio_url')
+    url = os.environ.get('TESTOMATIO_URL') or config.getini('testomatio_url') or TESTOMATIO_URL
     project = os.environ.get('TESTOMATIO')
 
     pytest.testomatio.connector = Connector(url, project)

pytestomatio-2.8.2.dev38/pytestomatio/testing/code_collector.py

@@ -0,0 +1,15 @@
+import importlib.util
+import inspect
+
+
+def get_functions_source_by_name(abs_file_path: str, all_tests: list[str]):
+    spec = importlib.util.spec_from_file_location('name', abs_file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    functions = inspect.getmembers(module, inspect.isfunction)
+    classes = inspect.getmembers(module, inspect.isclass)
+    for class_name, cls in classes:
+        functions += inspect.getmembers(cls, inspect.isfunction)
+    for function_name, function in functions:
+        if function_name in all_tests:
+            yield function_name, inspect.getsource(function)