asteex 0.0.1__tar.gz

asteex-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 KillAChicken
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

asteex-0.0.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: asteex
+Version: 0.0.1
+Summary: Test framework for asynchronous test execution
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Dynamic: license-file
+
+asteex
+======
+
+asteex is a package for asyncronous test execution.
+
+Installation
+============
+
+.. code-block:: text
+
+    $ python -m pip install asteex

asteex-0.0.1/README_PYPI.rst

@@ -0,0 +1,11 @@
+asteex
+======
+
+asteex is a package for asyncronous test execution.
+
+Installation
+============
+
+.. code-block:: text
+
+    $ python -m pip install asteex

asteex-0.0.1/VERSION

@@ -0,0 +1 @@
+0.0.1

asteex-0.0.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools >= 82.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+dynamic = ["version"]
+name = "asteex"
+requires-python = ">=3.10"
+description = "Test framework for asynchronous test execution"
+readme = {file = "README_PYPI.rst", content-type = "text/x-rst"}
+
+[project.entry-points."asteex.reporter_factory"]
+"asteex.log" = "asteex.core.reporter.log:LogReporter"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = {file = "VERSION"}

asteex-0.0.1/setup.cfg

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

asteex-0.0.1/src/asteex/__init__.py

@@ -0,0 +1,6 @@
+"""Package to execute test automation."""
+
+import logging
+
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

asteex-0.0.1/src/asteex/abstract/__init__.py

@@ -0,0 +1 @@
+"""Package with base and abstract classes of the asteex package."""

asteex-0.0.1/src/asteex/abstract/case.py

@@ -0,0 +1,27 @@
+"""Module for a base asteex test case."""
+
+from abc import ABC, abstractmethod
+
+
+class Case(ABC):
+    """Class for a asteex test case."""
+
+    @abstractmethod
+    def get_id(self):
+        """Get the unique identifier of the test case.
+
+        :returns: string id.
+        """
+
+    @abstractmethod
+    def get_dependencies(self):
+        """Get names of the variables that must be present in the execution context.
+
+        :returns: iterable with string names.
+        """
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        case_id = self.get_id()
+
+        return f"{class_name}(case_id='{case_id}')"

asteex-0.0.1/src/asteex/abstract/context.py

@@ -0,0 +1,21 @@
+"""Module for a base entities of a asteex context."""
+
+
+class Source:
+    """Class for a base source to provide a context value."""
+
+    def __init__(self, strategy):
+        self.__strategy = str(strategy)
+
+    def get_strategy(self):
+        """Get the strategy with which the value should be requested from the source.
+
+        :returns: string strategy.
+        """
+        return self.__strategy
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        strategy = self.__strategy
+
+        return f"{class_name}(strategy='{strategy}')"

asteex-0.0.1/src/asteex/abstract/executor.py

@@ -0,0 +1,26 @@
+"""Module for a base asteex executor."""
+
+from abc import ABC, abstractmethod
+
+
+class ExecutionError(Exception):
+    """Exception class for errors raised during the execution."""
+
+
+class Executor(ABC):
+    """Class for a base executor."""
+
+    @abstractmethod
+    def execute(self, instances):
+        """Execute test instances.
+
+        :param instances:
+            async iterable with :class:`Instances <asteex.abstract.instance.Instance>`.
+        :returns: async iterable with :class:`Results <asteex.abstract.result.Result>`.
+        :raises: :class:`ExecutionError`.
+        """
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+
+        return f"{class_name}()"

asteex-0.0.1/src/asteex/abstract/generator.py

@@ -0,0 +1,24 @@
+"""Module for a base asteex generator."""
+
+from abc import ABC, abstractmethod
+
+
+class GenerationError(Exception):
+    """Exception class for errors raised during the generation."""
+
+
+class Generator(ABC):
+    """Class for a base generator."""
+
+    @abstractmethod
+    def generate(self):
+        """Generate test instances.
+
+        :returns: async iterable with :class:`Instances <asteex.abstract.instance.Instance>`.
+        :raises: :class:`GenerationError`.
+        """
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+
+        return f"{class_name}()"

asteex-0.0.1/src/asteex/abstract/instance.py

@@ -0,0 +1,39 @@
+"""Module for a base asteex test instance."""
+
+from abc import ABC, abstractmethod
+
+
+class InstanceError(Exception):
+    """Exception class for errors raised by instances."""
+
+
+class Instance(ABC):
+    """Class for a asteex test instance."""
+
+    @abstractmethod
+    def get_id(self):
+        """Get the unique identifier of the instance.
+
+        :returns: string id.
+        """
+
+    @abstractmethod
+    def get_case(self):
+        """Get test case.
+
+        :returns: :class:`Case <asteex.abstract.case.Case>`.
+        """
+
+    @abstractmethod
+    def get_context_sources(self):
+        """Get information about origins of the context values.
+
+        :returns: dictionary with string names as keys and
+            :class:`Source <asteex.abstract.context.Source>` as values.
+        """
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        instance_id = self.get_id()
+
+        return f"{class_name}(instance_id='{instance_id}')"

asteex-0.0.1/src/asteex/abstract/reporter.py

@@ -0,0 +1,24 @@
+"""Module for a base asteex reporter."""
+
+from abc import ABC, abstractmethod
+
+
+class ReportError(Exception):
+    """Exception class for errors raised during the reporting."""
+
+
+class Reporter(ABC):
+    """Class for a base reporter."""
+
+    @abstractmethod
+    async def report(self, results):
+        """Report test results.
+
+        :param results: async iterable with :class:`Results <asteex.abstract.result.Result>`.
+        :raises: :class:`ReportError`.
+        """
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+
+        return f"{class_name}()"

asteex-0.0.1/src/asteex/abstract/result.py

@@ -0,0 +1,58 @@
+"""Module for a base asteex test result."""
+
+from abc import ABC, abstractmethod
+
+
+class Result(ABC):
+    """Class for a base test result."""
+
+    @abstractmethod
+    def get_instance(self):
+        """Get the executed test instance.
+
+        :returns: executed :class:`Instance <asteex.abstract.instance.Instance>`.
+        """
+
+    @abstractmethod
+    def get_status(self):
+        """Get the status of the test execution.
+
+        :returns: string status.
+        """
+
+    @abstractmethod
+    def get_reason(self):
+        """Get the reason for the status.
+
+        :returns: string reason.
+        """
+
+    @abstractmethod
+    def get_case(self):
+        """Get the executed case.
+
+        :returns: executed :class:`Case <asteex.abstract.case.Case>` or None,
+            if no case was retrieved.
+        """
+
+    @abstractmethod
+    def get_context(self):
+        """Get the execution context.
+
+        :returns: dictionary with string names and arbitrary values, or None, if no context
+            was created.
+        """
+
+    @abstractmethod
+    def get_exception_information(self):
+        """Get information about the exception raised during the execution.
+
+        :returns: a tuple (type, value, traceback) similar to one returned by :meth:`sys.exc_info`.
+        """
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        instance = self.get_instance()
+        status = self.get_status()
+
+        return f"{class_name}(instance={instance}, status='{status}')"

asteex-0.0.1/src/asteex/core/__init__.py

@@ -0,0 +1 @@
+"""Package with core implementation of the asteex entities."""

asteex-0.0.1/src/asteex/core/case/__init__.py

@@ -0,0 +1 @@
+"""Package for asteex test cases."""

asteex-0.0.1/src/asteex/core/case/executable/__init__.py

@@ -0,0 +1 @@
+"""Package for asteex executable test cases."""

asteex-0.0.1/src/asteex/core/case/executable/abstract.py

@@ -0,0 +1,21 @@
+"""Module for the abstract executable asteex test case."""
+
+from abc import abstractmethod
+
+from asteex.abstract.case import Case
+
+
+class ExecutionError(Exception):
+    """Class for errors raised during the execution."""
+
+
+class ExecutableCase(Case):
+    """Class for a asteex test case that can be executed."""
+
+    @abstractmethod
+    async def execute(self, context):
+        """Execute the test case.
+
+        :param context: dictionary with string keys.
+        :raises: :class:`ExecutionError`.
+        """

asteex-0.0.1/src/asteex/core/case/executable/delegate.py

@@ -0,0 +1,306 @@
+"""Module for a test cases that delegates execution to a callable object."""
+
+import inspect
+import logging
+
+from asteex.core.case.executable.abstract import ExecutableCase, ExecutionError
+from asteex.core.decorator.argument import ContextMapper, CopyError
+
+
+class BuildError(Exception):
+    """Exception for errors raised on attempt to build a test case."""
+
+
+class DelegateCase(ExecutableCase):
+    """Class for a asteex test case based on a callable."""
+
+    def __init__(self, delegate, case_id, dependencies=()):
+        super().__init__()
+
+        if not callable(delegate):
+            raise ValueError("Can't create a delegate case from a non-callable object")
+        self.__delegate = delegate
+
+        self.__id = str(case_id)
+
+        logger = logging.getLogger(__name__)
+        logger.debug("Try to refine dependencies for a new delegate case.")
+        try:
+            dependencies = tuple(str(dependency) for dependency in dependencies)
+        except TypeError as error:
+            logger.exception("Can't iterate over dependencies of a new delegate case.")
+            raise ValueError("Can't iterate over dependencies of a new delegate case") from error
+        self.__dependencies = dependencies
+        logger.debug("Refined dependencies for a new delegate case.")
+
+    def get_id(self):
+        """Get the unique identifier of the test case.
+
+        :returns: string id.
+        """
+        return self.__id
+
+    def get_dependencies(self):
+        """Get names of the required variables.
+
+        :returns: tuple with string names of the required variables.
+        """
+        return self.__dependencies
+
+    async def execute(self, context):
+        """Execute the test case.
+
+        :param context: dictionary with string keys.
+        :raises: :class:`ExecutionError <asteex.core.case.execution.abstract.ExecutionError>`.
+        """
+        logger = logging.getLogger(__name__)
+
+        logger.debug("Try to execute the delegate of the case %s.", self)
+        try:
+            execution = self.__delegate(context=context)
+
+            if inspect.isawaitable(execution):
+                await execution
+        except Exception as error:
+            logger.exception("An error is raised during the execution.")
+            raise ExecutionError("An error is raised during the execution") from error
+
+        logger.info("Executed the delegate of the case %s.", self)
+
+
+class DelegateCaseBuilder(ContextMapper):
+    """Class to create delegate cases from callables."""
+
+    def __init__(self):
+        super().__init__()
+        self.__case_id = None
+        self.__additional_dependencies = frozenset()
+        self.__enhancers = ()
+
+    def set_case_id(self, case_id):
+        """Set identifier for new test cases.
+
+        :param case_id: string identifier or None.
+            None value implies that the builder has to deduce case identifiers from callables.
+        :returns: self.
+        """
+        if case_id is not None:
+            case_id = str(case_id)
+        self.__case_id = case_id
+
+        logger = logging.getLogger(__name__)
+        logger.info("Set case identifier in %s.", self)
+
+        return self
+
+    def get_case_id(self):
+        """Get identifier for new test cases.
+
+        :returns: string identifier or None.
+        """
+        return self.__case_id
+
+    def add_dependencies(self, dependencies, overwrite=False):
+        """Add dependencies.
+
+        :param dependencies: iterable with string names of the dependencies.
+        :param overwrite: boolean whether the new dependencies should overwrite the existing ones.
+        :returns: self.
+        :raises: :class:`ValueError` if dependencies is not a valid iterable.
+        """
+        logger = logging.getLogger(__name__)
+        logger.debug("Try to set additional case dependencies in %s.", self)
+
+        try:
+            refined_case_dependencies = frozenset(str(dependency) for dependency in dependencies)
+        except TypeError as error:
+            logger.exception("Can't iterate over case dependencies.")
+            raise ValueError("Can't iterate over case dependencies") from error
+
+        if overwrite:
+            self.__additional_dependencies = refined_case_dependencies
+        else:
+            self.__additional_dependencies = self.__additional_dependencies.union(
+                refined_case_dependencies,
+            )
+
+        logger.info("Set additional case dependencies in %s.", self)
+
+        return self
+
+    def get_additional_dependencies(self):
+        """Get additional dependencies.
+
+        :returns: set with string names of the dependencies.
+        """
+        return self.__additional_dependencies
+
+    def add_enhancers(self, enhancers, overwrite=False):
+        """Add enhancers for new test cases.
+
+        :param enhancers: iterable with callables that accepts two parameters. Each callable will
+            receive a :class:`DelegateCase` for the first parameter and a callable for
+            the second parameter. The function must return :class:`DelegateCase`.
+        :param overwrite: boolean whether the new enhancers should overwrite the existing ones.
+        :returns: self.
+        :raises: :class:`ValueError` if enhancers is not a valid iterable.
+        """
+        logger = logging.getLogger(__name__)
+        logger.debug("Try to set case enhancers in %s.", self)
+
+        try:
+            refined_case_enhancers = tuple(enhancers)
+        except TypeError as error:
+            logger.exception("Can't iterate over case enhancers.")
+            raise ValueError("Can't iterate over case enhancers") from error
+
+        if overwrite:
+            self.__enhancers = refined_case_enhancers
+        else:
+            self.__enhancers = self.__enhancers + refined_case_enhancers
+
+        logger.info("Set case enhancers in %s.", self)
+
+        return self
+
+    def get_enhancers(self):
+        """Get enhancers for new test cases.
+
+        :returns: tuple with callables that accepts two parameters. Each callable accepts
+            a :class:`DelegateCase` for the first parameter and a callable for the second parameter.
+            Each callable returns :class:`DelegateCase`.
+        """
+        return self.__enhancers
+
+    def build_from_callable(self, callable_):
+        """Create a delegate case from a callable.
+
+        :param callable_: a callable to use as a base for the delegate case.
+        :returns: a new :class`DelegateCase`.
+        :raises: :class:`BuildError` if an error occurs on attempt to create or enhance a case.
+        """
+        logger = logging.getLogger(__name__)
+        logger.debug("Try to create a delegate case from '%s'.", callable_)
+
+        try:
+            case = self._create_case(callable_)
+        except Exception as error:
+            logger.exception("Can't create a delegate case.")
+            raise BuildError("Can't create a delegate case") from error
+
+        for enhancer in self.get_enhancers():
+            try:
+                case = enhancer(case, callable_)
+            except Exception as error:
+                logger.exception("Can't enhance a delegate case.")
+                raise BuildError("Can't enhance a delegate case") from error
+
+        logger.info("Created a delegate case from '%s'.", callable_)
+        return case
+
+    def _copy_data(self, other):
+        """Copy data from this instance to another.
+
+        :param other: instance of the same type.
+        :raises: :class:`CopyError <asteex.core.decorator.argument.CopyError>`
+            if data can't be copied.
+        """
+        super()._copy_data(other)
+
+        logger = logging.getLogger(__name__)
+
+        try:
+            other.set_case_id(self.get_case_id())
+        except Exception as error:
+            logger.exception("Can't copy case identifier to another instance.")
+            raise CopyError("Can't copy case identifier to another instance") from error
+
+        try:
+            other.add_dependencies(self.get_additional_dependencies(), overwrite=True)
+        except Exception as error:
+            logger.exception("Can't copy case dependencies to another instance.")
+            raise CopyError("Can't copy case dependencies to another instance") from error
+
+        try:
+            other.add_enhancers(self.get_enhancers(), overwrite=True)
+        except Exception as error:
+            logger.exception("Can't copy case enhancers to another instance.")
+            raise CopyError("Can't copy case enhancers to another instance") from error
+
+    def _create_case_id(self, callable_):
+        """Create an identifier for a delegate case from a callable.
+
+        :param callable_: callable for a delegate for the case.
+        :returns: string id.
+        """
+        case_id = self.get_case_id()
+        if case_id is None:
+            refined_case_id = str(callable_)
+        else:
+            refined_case_id = case_id
+
+        return refined_case_id
+
+    def _create_case_dependencies(self, callable_):
+        """Create dependencies for a delegate case from a callable.
+
+        :param callable_: callable for a delegate for the case.
+        :returns: set with string names.
+        """
+        case_dependencies = set(self.get_additional_dependencies())
+
+        positional_arguments, keyword_arguments = self.build_call_arguments(callable_)
+
+        arguments_with_dependencies = set().union(positional_arguments).union(keyword_arguments)
+        arguments_with_dependencies.difference_update(self.get_arguments_mapped_to_context())
+
+        dependency_map = self.get_arguments_mapped_to_context_names()
+
+        case_dependencies.update(
+            dependency_map.get(argument, argument) for argument in arguments_with_dependencies
+        )
+
+        return case_dependencies
+
+    def _create_case_delegate(self, callable_):
+        """Create a delegate for a delegate case from a callable.
+
+        :param callable_: callable for a delegate for the case.
+        :returns: callable, suitable for :class:`DelegateCase`.
+        """
+        arguments_mapped_to_context_names = self.get_arguments_mapped_to_context_names().copy()
+        arguments_mapped_to_context = set(self.get_arguments_mapped_to_context())
+
+        positional_arguments, keyword_arguments = self.build_call_arguments(callable_)
+
+        def _delegate(context):
+            def _get_delegate_value(argument):
+                if argument in arguments_mapped_to_context:
+                    value = context
+                else:
+                    mapped_argument = arguments_mapped_to_context_names.get(argument, argument)
+                    value = context[mapped_argument]
+
+                return value
+
+            arg_values = [_get_delegate_value(argument) for argument in positional_arguments]
+            kwarg_values = {
+                argument: _get_delegate_value(argument)
+                for argument in keyword_arguments
+            }
+
+            return callable_(*arg_values, **kwarg_values)
+
+        return _delegate
+
+    def _create_case(self, callable_):
+        """Create a delegate case from a callable.
+
+        :param callable_: callable for a delegate for the case.
+        :returns: :class:`DelegateCase`.
+        """
+        return DelegateCase(
+            delegate=self._create_case_delegate(callable_),
+            case_id=self._create_case_id(callable_),
+            dependencies=self._create_case_dependencies(callable_),
+        )

asteex-0.0.1/src/asteex/core/context/__init__.py

@@ -0,0 +1 @@
+"""Package for asteex context entities."""

asteex-0.0.1/src/asteex/core/context/source/__init__.py

@@ -0,0 +1 @@
+"""Package for sources of context values."""