support next model version (fixes #40 via #42)

* rename report files

* delete PENDING status

* fix tests

* children ids and containers

* pyflakes

* bump version

* fix tox.ini =)

Author: sseliverstov

allure-pytest/setup.py

@@ -2,7 +2,7 @@
 from setuptools import setup
 
 PACKAGE = "pytest-allure-adaptor"
-VERSION = "2.0.1"
+VERSION = "2.0.3"
 
 install_requires = [
     "pytest>=2.7.3",

allure-pytest/src/allure/constants.py

@@ -9,8 +9,7 @@ class Status(object):
     FAILED = 'failed'
     BROKEN = 'broken'
     PASSED = 'passed'
-    CANCELED = 'canceled'
-    PENDING = 'pending'
+    SKIPPED = 'skipped'
 
 
 class Severity(Enum):

allure-pytest/src/allure/listener.py

@@ -6,8 +6,8 @@
 from allure.utils import allure_parameters
 from allure.utils import allure_labels, allure_links
 from allure.utils import allure_full_name, allure_package
-from allure.model2 import TestStepResult, TestGroupResult, TestCaseResult
-from allure.model2 import ExecutableItem
+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
@@ -32,33 +32,33 @@ def pytest_allure_after_step(self, uuid, exc_type, exc_val, exc_tb):
         status = Status.PASSED
         if exc_type is not None:
             if exc_type == pytest.skip.Exception:
-                status = Status.CANCELED
+                status = Status.SKIPPED
             else:
                 status = Status.FAILED
 
         self.allure_logger.stop_step(uuid, stop=now(), status=status)
 
     @pytest.hookimpl
     def pytest_allure_before_finalizer(self, parent_uuid, uuid, name):
-        self.allure_logger.start_after_fixture(parent_uuid, uuid, name=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):
-        self.allure_logger.stop_after_fixture(uuid)
+        self.allure_logger.stop_after_fixture(uuid, stop=now())
 
     @pytest.hookimpl(hookwrapper=True, tryfirst=True)
     def pytest_runtest_protocol(self, item, nextitem):
         uuid = self._cache.set(item.nodeid)
-        parent_ids = []
         for fixturedef in _test_fixtures(item):
             group_uuid = self._cache.get(fixturedef)
-            if not group_uuid and fixturedef.baseid:
+            if not group_uuid:
                 group_uuid = self._cache.set(fixturedef)
-                group = TestGroupResult(id=group_uuid)
+                group = TestResultContainer(id=group_uuid)
                 self.allure_logger.start_group(group_uuid, group)
-            parent_ids.append(group_uuid)
+            self.allure_logger.update_group(group_uuid, children=uuid)
 
-        test_case = TestCaseResult(name=item.name, id=uuid, parentIds=parent_ids)
+        test_case = TestResult(name=item.name, id=uuid)
         self.allure_logger.schedule_test(uuid, test_case)
 
         yield
@@ -80,45 +80,47 @@ def pytest_runtest_call(self, item):
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_fixture_setup(self, fixturedef, request):
-        uuid = uuid4()
-        node_id = request.node.nodeid
-        parent_uuid = self._cache.get(node_id) if fixturedef.scope == 'function' else self._cache.get(fixturedef)
-        parameters = allure_parameters(fixturedef, request)
+        fixture_name = fixturedef.argname
+
+        container_uuid = self._cache.get(fixturedef)
+
+        if not container_uuid:
+            container_uuid = self._cache.set(fixturedef)
+            container = TestResultContainer(id=container_uuid)
+            self.allure_logger.start_group(container_uuid, container)
 
-        # ToDo autouse fixtures
-        if fixturedef.baseid and parent_uuid:
-            fixture = ExecutableItem(start=now(), name=fixturedef.argname)
-            self.allure_logger.start_before_fixture(parent_uuid, uuid, fixture)
+        self.allure_logger.update_group(container_uuid, start=now())
 
-        if parameters and parent_uuid:
+        before_fixture_uuid = uuid4
+        before_fixture = TestBeforeResult(name=fixture_name, start=now())
+        self.allure_logger.start_before_fixture(container_uuid, before_fixture_uuid, before_fixture)
+
+        parameters = allure_parameters(fixturedef, request)
+        if parameters:
             test_uuid = self._cache.get(request._pyfuncitem.nodeid)
             parameters = Parameter(**parameters) if parameters else []
             self.allure_logger.update_test(test_uuid, parameters=parameters)
 
         yield
 
-        # ToDo autouse fixtures
-        if fixturedef.baseid and parent_uuid:
-            self.allure_logger.stop_before_fixture(uuid, stop=now())
+        self.allure_logger.stop_before_fixture(before_fixture_uuid, stop=now())
 
-            for index, finalizer in enumerate(fixturedef._finalizer or ()):
-                fixturedef._finalizer[index] = FinalizerSpy(parent_uuid, fixturedef.argname, finalizer, self.config)
+        for index, finalizer in enumerate(fixturedef._finalizer or ()):
+            fixturedef._finalizer[index] = FinalizerSpy(container_uuid, fixturedef.argname, finalizer, self.config)
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_fixture_post_finalizer(self, fixturedef):
         yield
-        # ToDo autouse fixtures
-        if hasattr(fixturedef, 'cached_result') and fixturedef.scope != 'function' and fixturedef.baseid \
-                and self._cache.get(fixturedef):
-            uuid = self._cache.pop(fixturedef)
-            self.allure_logger.stop_group(uuid)
+        if hasattr(fixturedef, 'cached_result') and self._cache.get(fixturedef):
+            container_uuid = self._cache.pop(fixturedef)
+            self.allure_logger.stop_group(container_uuid, stop=now())
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_makereport(self, item, call):
         uuid = self._cache.set(item.nodeid)
         report = (yield).get_result()
         allure_item = self.allure_logger.get_item(uuid)
-        status = allure_item.status or Status.PENDING
+        status = allure_item.status or None
         status_details = None
 
         if call.excinfo and hasattr(call.excinfo.value, 'msg'):
@@ -134,15 +136,15 @@ def pytest_runtest_makereport(self, item, call):
             if report.failed:
                 status = Status.BROKEN
             if report.skipped:
-                status = Status.CANCELED
+                status = Status.SKIPPED
 
         if report.when == 'call':
             if report.passed and status == Status.PASSED:
                 pass
             if report.failed:
                 status = Status.FAILED
             if report.skipped:
-                status = Status.CANCELED
+                status = Status.SKIPPED
 
         if report.when == 'teardown':
             if report.failed and status == Status.PASSED:
@@ -208,7 +210,7 @@ def _test_fixtures(item):
     if hasattr(item, "fixturenames"):
         for name in item.fixturenames:
             fixturedef = fixturemanager.getfixturedefs(name, item.nodeid)
-            if fixturedef and fixturedef[-1].scope != 'function':
+            if fixturedef:
                 fixturedefs.append(fixturedef[-1])
 
     return fixturedefs

allure-pytest/src/allure/logger.py

@@ -29,10 +29,14 @@ def get_item(self, uuid):
     def start_group(self, uuid, group):
         self._items[uuid] = group
 
-    def stop_group(self, uuid):
+    def stop_group(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
         group = self._items.pop(uuid)
         group.write(self._report_dir)
 
+    def update_group(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+
     def start_before_fixture(self, parent_uuid, uuid, fixture):
         self._items.get(parent_uuid).befores.append(fixture)
         self._items[uuid] = fixture
@@ -41,12 +45,12 @@ def stop_before_fixture(self, uuid, **kwargs):
         self._update_item(uuid, **kwargs)
         self._items.pop(uuid)
 
-    def start_after_fixture(self, parent_uuid, uuid, **kwargs):
-        fixture = ExecutableItem(start=now(), **kwargs)
+    def start_after_fixture(self, parent_uuid, uuid, fixture):
         self._items.get(parent_uuid).afters.append(fixture)
         self._items[uuid] = fixture
 
-    def stop_after_fixture(self, uuid):
+    def stop_after_fixture(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
         fixture = self._items.pop(uuid)
         fixture.stop = now()
 
@@ -61,8 +65,13 @@ def close_test(self, uuid):
         test_case.write(self._report_dir)
 
     def start_step(self, uuid, step):
-        last_uuid = next(reversed(self._items))
-        self._items[last_uuid].steps.append(step)
+        parent_uuid = None
+        for _uuid in reversed(self._items):
+            if isinstance(self._items[_uuid], ExecutableItem):
+                parent_uuid = _uuid
+                break
+        if parent_uuid:
+            self._items[parent_uuid].steps.append(step)
         self._items[uuid] = step
 
     def stop_step(self, uuid, **kwargs):

allure-pytest/src/allure/model2.py

@@ -6,8 +6,8 @@
 import uuid
 
 
-TEST_GROUP_PATTERN = "{prefix}-testgroup.json"
-TEST_CASE_PATTERN = "{prefix}-testcase.json"
+TEST_GROUP_PATTERN = "{prefix}-container.json"
+TEST_CASE_PATTERN = "{prefix}-result.json"
 ATTACHMENT_PATTERN = '{prefix}-attachment.{ext}'
 INDENT = 4
 
@@ -24,11 +24,10 @@ def _write(report_dir, item, glob):
 
 
 @attrs
-class TestGroupResult(object):
+class TestResultContainer(object):
     id = attrib(default=None)
-    parentIds = attrib(default=Factory(list))
-    type = attrib(default=None)
     name = attrib(default=None)
+    children = attrib(default=Factory(list))
     description = attrib(default=None)
     descriptionHtml = attrib(default=None)
     befores = attrib(default=Factory(list))
@@ -44,24 +43,22 @@ def write(self, report_dir):
 @attrs
 class ExecutableItem(object):
     name = attrib(default=None)
+    status = attrib(default=None)
+    statusDetails = attrib(default=None)
+    stage = attrib(default=None)
     description = attrib(default=None)
     descriptionHtml = attrib(default=None)
     steps = attrib(default=Factory(list))
     attachments = attrib(default=Factory(list))
+    parameters = attrib(default=Factory(list))
     start = attrib(default=None)
     stop = attrib(default=None)
 
 
 @attrs
-class TestCaseResult(ExecutableItem):
+class TestResult(ExecutableItem):
     id = attrib(default=None)
     fullName = attrib(default=None)
-    parentIds = attrib(default=Factory(list))
-    status = attrib(default=None)
-    statusDetails = attrib(default=None)
-    parameters = attrib(default=Factory(list))
-    befores = attrib(default=Factory(list))
-    afters = attrib(default=Factory(list))
     labels = attrib(default=Factory(list))
     links = attrib(default=Factory(list))
 
@@ -72,9 +69,16 @@ def write(self, report_dir):
 @attrs
 class TestStepResult(ExecutableItem):
     id = attrib(default=None)
-    status = attrib(default=None)
-    parameters = attrib(default=Factory(list))
-    statusDetails = attrib(default=None)
+
+
+@attrs
+class TestBeforeResult(ExecutableItem):
+    pass
+
+
+@attrs
+class TestAfterResult(ExecutableItem):
+    pass
 
 
 @attrs
@@ -98,6 +102,8 @@ class Link(object):
 
 @attrs
 class StatusDetails(object):
+    known = attrib(default=None)
+    flaky = attrib(default=None)
     message = attrib(default=None)
     trace = attrib(default=None)