refactor commons (fixes #18 fixes #75 fixes #76 via #81)

Author: sseliverstov

allure-behave/src/listener.py

@@ -1,12 +1,12 @@
-from allure.logger import AllureLogger
-from allure.utils import uuid4
-from allure.utils import now
-from allure.types import LabelType, AttachmentType
-from allure.model2 import TestResult
-from allure.model2 import TestStepResult
-from allure.model2 import TestBeforeResult
-from allure.model2 import TestResultContainer
-from allure.model2 import Status, Parameter, Label
+from allure_commons.logger import AllureLogger
+from allure_commons.utils import uuid4
+from allure_commons.utils import now
+from allure_commons.types import LabelType, AttachmentType
+from allure_commons.model2 import TestResult
+from allure_commons.model2 import TestStepResult
+from allure_commons.model2 import TestBeforeResult
+from allure_commons.model2 import TestResultContainer
+from allure_commons.model2 import Status, Parameter, Label
 from allure_behave.utils import scenario_parameters
 from allure_behave.utils import scenario_severity
 from allure_behave.utils import scenario_tags

allure-behave/src/utils.py

@@ -1,9 +1,9 @@
 from behave.model import ScenarioOutline
 from behave.runner_util import make_undefined_step_snippet
-from allure.types import Severity
-from allure.model2 import Status, Parameter, Label
-from allure.model2 import StatusDetails
-from allure.utils import md5
+from allure_commons.types import Severity
+from allure_commons.model2 import Status, Parameter, Label
+from allure_commons.model2 import StatusDetails
+from allure_commons.utils import md5
 import traceback
 
 STATUS = {

allure-pytest/src/helper.py

@@ -1,134 +1,23 @@
 import pytest
-from functools import wraps
-from allure.utils import uuid4
-from allure.types import Severity
-from allure.types import LabelType, LinkType, AttachmentType
-
-from allure_pytest.utils import step_parameters
+import allure_commons
 from allure_pytest.utils import ALLURE_LABEL_PREFIX, ALLURE_LINK_PREFIX
 
 
 class AllureTestHelper(object):
 
     def __init__(self, config):
         self.config = config
-        self.attach = Attach(config)
-
-    @property
-    def attachment_type(self):
-        return AttachmentType
-
-    def label(self, label_type, *value):
-        allure_label = getattr(pytest.mark, '{prefix}.{label_type}'.format(prefix=ALLURE_LABEL_PREFIX,
-                                                                           label_type=label_type))
-        return allure_label(*value, label_type=label_type)
-
-    def severity(self, severity):
-        return self.label(LabelType.SEVERITY, severity.value)
 
-    @property
-    def severity_level(self):
-        return Severity
+    @allure_commons.hookimpl
+    def decorate_as_label(self, label_type, labels):
+        allure_label_marker = u'{prefix}.{label_type}'.format(prefix=ALLURE_LABEL_PREFIX, label_type=label_type)
+        allure_label = getattr(pytest.mark, allure_label_marker)
+        return allure_label(*labels, label_type=label_type)
 
-    def feature(self, *features):
-        return self.label(LabelType.FEATURE, *features)
-
-    def story(self, *stories):
-        return self.label(LabelType.STORY, *stories)
-
-    def link(self, url, link_type=LinkType.LINK, name=None):
-        allure_link = getattr(pytest.mark, '{prefix}.{link_type}'.format(prefix=ALLURE_LINK_PREFIX,
-                                                                         link_type=link_type))
-
-        pattern = dict(self.config.option.allure_link_pattern).get(str(link_type), '{}')
+    @allure_commons.hookimpl
+    def decorate_as_link(self, url, link_type, name):
+        allure_link_marker = u'{prefix}.{link_type}'.format(prefix=ALLURE_LINK_PREFIX, link_type=link_type)
+        pattern = dict(self.config.option.allure_link_pattern).get(str(link_type), u'{}')
         url = pattern.format(url)
-
+        allure_link = getattr(pytest.mark, allure_link_marker)
         return allure_link(url, name=name)
-
-    def issue(self, url, name=None):
-        return self.link(url, link_type=LinkType.ISSUE, name=name)
-
-    def testcase(self, url, name=None):
-        return self.link(url, link_type=LinkType.TEST_CASE, name=name)
-
-    def step(self, title):
-        if callable(title):
-            return LazyInitStepContext(self, title.__name__)(title)
-        else:
-            return LazyInitStepContext(self, title)
-
-    def __getattr__(self, attr):
-        for severity in Severity:
-            if severity.name == attr:
-                return self.severity(severity)
-
-        for attach_type in AttachmentType:
-            if attach_type.name == attr:
-                return attach_type
-
-        raise AttributeError
-
-    @pytest.hookimpl()
-    def pytest_namespace(self):
-        return {"allure": self}
-
-
-class StepContext:
-
-    def __init__(self, allure, title, params):
-        self.allure = allure
-        self.title = title
-        self._uuid = uuid4()
-        self.params = params
-
-    def __enter__(self):
-        self.allure.config.hook.pytest_allure_before_step(uuid=self._uuid,
-                                                          title=self.title,
-                                                          params=self.params)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.allure.config.hook.pytest_allure_after_step(uuid=self._uuid,
-                                                         title=self.title,
-                                                         exc_type=exc_type,
-                                                         exc_val=exc_val,
-                                                         exc_tb=exc_tb)
-
-    def __call__(self, func):
-        @wraps(func)
-        def impl(*a, **kw):
-            __tracebackhide__ = True
-            params = step_parameters(func, *a, **kw)
-            with StepContext(self.allure, self.title.format(*a, **kw), params):
-                return func(*a, **kw)
-        return impl
-
-
-class LazyInitStepContext(StepContext):
-
-    def __init__(self, allure_helper, title):
-        self.allure_helper = allure_helper
-        self.title = title
-        self._uuid = uuid4()
-        self.params = []
-
-    @property
-    def allure(self):
-        return self.allure_helper
-
-
-class Attach(object):
-
-    def __init__(self, config):
-        self.config = config
-
-    def __call__(self, body, name=None,  attachment_type=None, extension=None):
-        self.config.hook.pytest_allure_attach_data(body=body,
-                                                   name=name,
-                                                   attachment_type=attachment_type,
-                                                   extension=extension)
-
-    def file(self, source, name=None, attachment_type=None, extension=None):
-        self.config.hook.pytest_allure_attach_file(source=source,
-                                                   name=name,
-                                                   attachment_type=attachment_type,
-                                                   extension=extension)

allure-pytest/src/hooks.py

@@ -1,15 +1,18 @@
 import pytest
+import allure_commons
 
-from allure.utils import now
-from allure.utils import md5
-from allure.utils import uuid4
-from allure.logger import AllureLogger
-from allure.model2 import TestStepResult, TestResult, TestBeforeResult, TestAfterResult
-from allure.model2 import TestResultContainer
-from allure.model2 import StatusDetails
-from allure.model2 import Parameter
-from allure.model2 import Label, Link
-from allure.model2 import Status
+from allure_commons.utils import now
+from allure_commons.utils import md5
+from allure_commons.utils import uuid4
+
+from allure_commons.logger import AllureLogger
+
+from allure_commons.model2 import TestStepResult, TestResult, TestBeforeResult, TestAfterResult
+from allure_commons.model2 import TestResultContainer
+from allure_commons.model2 import StatusDetails
+from allure_commons.model2 import Parameter
+from allure_commons.model2 import Label, Link
+from allure_commons.model2 import Status
 
 from allure_pytest.utils import allure_parameters
 from allure_pytest.utils import allure_labels, allure_links
@@ -23,14 +26,14 @@ def __init__(self, config):
         self.allure_logger = AllureLogger(config.option.allure_report_dir)
         self._cache = ItemCache()
 
-    @pytest.hookimpl
-    def pytest_allure_before_step(self, uuid, title, params):
+    @allure_commons.hookimpl
+    def start_step(self, uuid, title, params):
         parameters = [Parameter(name=name, value=value) for name, value in params]
         step = TestStepResult(name=title, start=now(), parameters=parameters)
         self.allure_logger.start_step(None, uuid, step)
 
-    @pytest.hookimpl
-    def pytest_allure_after_step(self, uuid, exc_type, exc_val, exc_tb):
+    @allure_commons.hookimpl
+    def stop_step(self, uuid, exc_type, exc_val, exc_tb):
         status = Status.PASSED
         if exc_type is not None:
             if exc_type == pytest.skip.Exception:
@@ -40,13 +43,13 @@ def pytest_allure_after_step(self, uuid, exc_type, exc_val, exc_tb):
 
         self.allure_logger.stop_step(uuid, stop=now(), status=status)
 
-    @pytest.hookimpl
-    def pytest_allure_before_finalizer(self, parent_uuid, uuid, name):
+    @allure_commons.hookimpl
+    def start_fixture(self, parent_uuid, uuid, name):
         after_fixture = TestAfterResult(name=name, start=now())
         self.allure_logger.start_after_fixture(parent_uuid, uuid, after_fixture)
 
-    @pytest.hookimpl
-    def pytest_allure_after_finalizer(self, uuid, exc_type, exc_val, exc_tb):
+    @allure_commons.hookimpl
+    def stop_fixture(self, uuid, exc_type, exc_val, exc_tb):
         self.allure_logger.stop_after_fixture(uuid, stop=now())
 
     @pytest.hookimpl(hookwrapper=True, tryfirst=True)
@@ -109,7 +112,8 @@ def pytest_fixture_setup(self, fixturedef, request):
         self.allure_logger.stop_before_fixture(before_fixture_uuid, stop=now())
 
         for index, finalizer in enumerate(fixturedef._finalizer or ()):
-            fixturedef._finalizer[index] = FinalizerSpy(container_uuid, fixturedef.argname, finalizer, self.config)
+            name = u'{fixture}::{finalizer}'.format(fixture=fixturedef.argname, finalizer=finalizer.__name__)
+            fixturedef._finalizer[index] = allure_commons.fixture(finalizer, parent_uuid=container_uuid, name=name)
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_fixture_post_finalizer(self, fixturedef):
@@ -158,39 +162,15 @@ def pytest_runtest_makereport(self, item, call):
         else:
             self.allure_logger.update_test(uuid, status=status)
 
-    @pytest.hookimpl
-    def pytest_allure_attach_data(self, body, name, attachment_type, extension):
+    @allure_commons.hookimpl
+    def attach_data(self, body, name, attachment_type, extension):
         self.allure_logger.attach_data(uuid4(), body, name=name, attachment_type=attachment_type, extension=extension)
 
-    @pytest.hookimpl
-    def pytest_allure_attach_file(self, source, name, attachment_type, extension):
+    @allure_commons.hookimpl
+    def attach_file(self, source, name, attachment_type, extension):
         self.allure_logger.attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)
 
 
-class FinalizerSpy(object):
-    def __init__(self, parent_uuid, fixturename, finalizer, config):
-        self._parent_uuid = parent_uuid
-        self._config = config
-        self._finalizer = finalizer
-        self._uuid = uuid4()
-        self._name = "{fixture}::{finalizer}".format(fixture=fixturename, finalizer=finalizer.__name__)
-
-    def __call__(self, *args, **kwards):
-        with self:
-            return self._finalizer(*args, **kwards)
-
-    def __enter__(self):
-        self._config.hook.pytest_allure_before_finalizer(parent_uuid=self._parent_uuid,
-                                                         uuid=self._uuid,
-                                                         name=self._name)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._config.hook.pytest_allure_after_finalizer(uuid=self._uuid,
-                                                        exc_type=exc_type,
-                                                        exc_val=exc_val,
-                                                        exc_tb=exc_tb)
-
-
 class ItemCache(object):
 
     def __init__(self):

allure-pytest/src/listener.py

@@ -2,9 +2,9 @@
 import argparse
 from six import text_type
 
-from allure.types import Severity
-from allure.types import LabelType
-
+import allure
+import allure_commons
+from allure_commons.types import LabelType
 from allure_pytest.utils import allure_labels
 from allure_pytest.helper import AllureTestHelper
 from allure_pytest.listener import AllureListener
@@ -27,7 +27,7 @@ def a_label_type(string):
             return set((name.value, atom) for atom in atoms)
         return a_label_type
 
-    severities = [x.value for x in list(Severity)]
+    severities = [x.value for x in list(allure.severity_level)]
     parser.getgroup("general").addoption('--allure-severities',
                                          action="store",
                                          dest="allure_severities",
@@ -84,7 +84,8 @@ def pytest_configure(config):
         config.pluginmanager.register(test_listener)
 
         test_helper = AllureTestHelper(config)
-        config.pluginmanager.register(test_helper)
+        allure_commons.register(test_listener)
+        allure_commons.register(test_helper)
 
 
 def pytest_runtest_setup(item):
@@ -98,10 +99,5 @@ def pytest_runtest_setup(item):
         pytest.skip('Not suitable with selected labels: %s.' % ', '.join(text_type(l) for l in sorted(arg_labels)))
 
 
-def pytest_addhooks(pluginmanager):
-    import allure_pytest.hooks as hooks
-    # avoid warnings with pytest-2.8
-    method = getattr(pluginmanager, "add_hookspecs", None)
-    if method is None:
-        method = pluginmanager.addhooks
-    method(hooks)
+def pytest_namespace():
+    return {"allure": allure}