Now you can use allure steps in behave fixtures (fixes #128) (#160)

now you can use allure steps in behave fixtures

Author: sseliverstov

allure-behave/features/hook.feature

@@ -185,3 +185,64 @@ Feature: Hook
      Then allure report has a scenario with name "Scenario with "before_feature" hook and attachment"
       And this scenario has before fixture "before_feature"
       And this before has attachment
+
+
+  Scenario Outline: Hook step as context
+    Given feature definition
+        """
+        Feature: Hook
+          Scenario: Scenario with "<when> <where>" hook and step inside
+            Given simple passed step
+        """
+      And hooks implementation
+        """
+        import allure
+        import allure_commons
+
+
+        @allure_commons.fixture
+        def <when>_<where>(context, <where>):
+            with allure.step('Step inside fixture'):
+              pass
+        """
+     When I run behave with allure formatter
+     Then allure report has a scenario with name "Scenario with "<when> <where>" hook and step inside"
+      And this scenario has <when> fixture "<when>_<where>"
+      And this <when> contains step "Step inside fixture"
+
+    Examples: fixtures
+            | when   | where    |
+            | before | scenario |
+            | after  | scenario |
+
+
+  Scenario Outline: Hook step as function
+    Given feature definition
+        """
+        Feature: Hook
+          Scenario:  Scenario with "<when> <where>" hook and step as function inside
+            Given simple passed step
+        """
+      And hooks implementation
+        """
+        import allure
+        import allure_commons
+
+        @allure.step('Step function')
+        def step():
+            pass
+
+        @allure_commons.fixture
+        def <when>_<where>(context):
+            step()
+        """
+     When I run behave with allure formatter
+     Then allure report has a scenario with name "Scenario with "<when> <where>" hook and step as function inside"
+      And this scenario has <when> fixture "<when>_<where>"
+      And this <when> contains step "Step function"
+
+    Examples: fixtures
+            | when   | where |
+            | before | all   |
+            | after  | all   |
+

allure-behave/src/formatter.py

@@ -33,7 +33,7 @@ def match(self, match):
         self.listener.match_step(match)
 
     def result(self, result):
-        self.listener.stop_step(result)
+        self.listener.stop_behave_step(result)
 
     def eof(self):
         self.listener.stop_feature()

allure-behave/src/listener.py

@@ -19,8 +19,9 @@
 from allure_behave.utils import scenario_history_id
 from allure_behave.utils import step_status, step_status_details
 from allure_behave.utils import scenario_status, scenario_status_details
-from allure_behave.utils import fixture_status, fixture_status_details
 from allure_behave.utils import step_table
+from allure_behave.utils import get_status, get_status_details
+
 
 
 BEFORE_FIXTURES = ['before_all', 'before_tag', 'before_feature', 'before_scenario']
@@ -63,9 +64,10 @@ def start_fixture(self, parent_uuid, uuid, name, parameters):
     @allure_commons.hookimpl
     def stop_fixture(self, parent_uuid, uuid, name, exc_type, exc_val, exc_tb):
         if name in FIXTURES:
-            status = fixture_status(exc_val, exc_tb)
-            status_details = fixture_status_details(exc_val, exc_tb)
-            self.logger.stop_before_fixture(uuid=uuid, stop=now(), status=status, statusDetails=status_details)
+            self.logger.stop_before_fixture(uuid=uuid,
+                                            stop=now(),
+                                            status=get_status(exc_val),
+                                            statusDetails=get_status_details(exc_type, exc_val, exc_tb))
 
     def start_feature(self):
         self.execution_context.enter()
@@ -120,9 +122,9 @@ def schedule_step(self, step):
 
     def match_step(self, match):
         step = self.steps.popleft()
-        self.start_step(step)
+        self.start_behave_step(step)
 
-    def start_step(self, step):
+    def start_behave_step(self, step):
 
         self.current_step_uuid = uuid4()
         name = u'{keyword} {title}'.format(keyword=step.keyword, title=step.name)
@@ -136,16 +138,30 @@ def start_step(self, step):
         if step.table:
             self.logger.attach_data(uuid4(), step_table(step), name='.table', attachment_type=AttachmentType.CSV)
 
-    def stop_step(self, result):
+    def stop_behave_step(self, result):
         status = step_status(result)
         status_details = step_status_details(result)
         self.logger.stop_step(self.current_step_uuid, stop=now(), status=status, statusDetails=status_details)
 
     def flush_steps(self):
         while self.steps:
             step = self.steps.popleft()
-            self.start_step(step)
-            self.stop_step(step)
+            self.start_behave_step(step)
+            self.stop_behave_step(step)
+
+    @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.logger.start_step(None, uuid, step)
+
+    @allure_commons.hookimpl
+    def stop_step(self, uuid, exc_type, exc_val, exc_tb):
+        self.logger.stop_step(uuid,
+                              stop=now(),
+                              status=get_status(exc_val),
+                              statusDetails=get_status_details(exc_type, exc_val, exc_tb))
+
 
     @allure_commons.hookimpl
     def attach_data(self, body, name, attachment_type, extension):

allure-behave/src/utils.py

@@ -64,27 +64,27 @@ def scenario_status_details(scenario):
             return step_status_details(step)
 
 
-def fixture_status(exception, exc_traceback):
+def get_status_details(exc_type, exception, exc_traceback):
     if exception:
-        return Status.FAILED if isinstance(exception, AssertionError) else Status.BROKEN
-    else:
-        return Status.BROKEN if exc_traceback else Status.PASSED
-
-
-def fixture_status_details(exception, exc_traceback):
-    if exception:
-        return StatusDetails(message=format_exception(type(exception), exception),
+        return StatusDetails(message=format_exception(exc_type, exception),
                              trace=format_traceback(exc_traceback))
-    return None
 
 
 def step_status(result):
-    if result.exception and not isinstance(result.exception, AssertionError):
-        return Status.BROKEN
+    if result.exception:
+        return get_status(result.exception)
     else:
         return STATUS.get(result.status, None)
 
 
+def get_status(exception):
+    if exception and isinstance(exception, AssertionError):
+        return Status.FAILED
+    elif exception:
+        return Status.BROKEN
+    return Status.PASSED
+
+
 def step_status_details(result):
     if result.exception:
         return StatusDetails(message=format_exception(type(result.exception), result.exception),