busser-behave 0.1.3

data/vendor/behave/features/step.execute_steps.feature

@@ -0,0 +1,59 @@
+Feature: Execute Steps within a Step Function (Nested Steps)
+
+    As a tester
+    I want to reuse existing steps and call several ones within another step
+    So that I can comply with the the DRY principle.
+
+  Scenario: Execute a number of simple steps (GOOD CASE)
+    Given a new working directory
+    And   a file named "features/steps/steps.py" with:
+      """
+      from behave import given, when, then
+
+      @given(u'I go to the supermarket')
+      def step_given_I_go_to_the_supermarket(context):
+          context.shopping_cart = {}
+
+      @when(u'I buy {amount:n} {item:w}')
+      def step_when_I_buy(context, amount, item):
+          assert amount >= 0
+          if not item in context.shopping_cart:
+              context.shopping_cart[item] = 0
+          context.shopping_cart[item] += amount
+
+      # -- HERE: Is the interesting functionality.
+      @when(u'I buy the usual things')
+      def step_when_I_buy_the_usual_things(context):
+          context.execute_steps(u'''
+              When I buy 2 apples
+              And  I buy 3 bananas
+          ''')
+
+      @then(u'I have {amount:n} {item:w}')
+      def step_then_I_have(context, amount, item):
+          actual = context.shopping_cart.get(item, 0)
+          assert amount == actual
+      """
+    And   a file named "features/use_nested_steps.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given I go to the supermarket
+          When  I buy the usual things
+          Then  I have 2 apples
+          And   I have 3 bananas
+      """
+    When I run "behave -f plain features/use_nested_steps.feature"
+    Then it should pass with:
+      """
+      1 feature passed, 0 failed, 0 skipped
+      1 scenario passed, 0 failed, 0 skipped
+      4 steps passed, 0 failed, 0 skipped, 0 undefined
+      """
+
+  @not_implemented
+  Scenario: A Nested Step Fails with Assert
+
+  @not_implemented
+  Scenario: A Nested Step Fails with Exception
+

data/vendor/behave/features/step.execute_steps.with_table.feature

@@ -0,0 +1,65 @@
+Feature: Execute nested steps that use a table
+
+  Scenario:
+    Given a new working directory
+    And a file named "features/steps/steps.py" with:
+      """
+      from behave import given, when, then, step
+      import six
+      @given('the following nested steps')
+      def step_given_following_nested_steps(context):
+          assert context.text, "ENSURE: multi-line text is provided."
+          context.nested_steps = six.text_type(context.text)
+
+      @step('I execute the nested steps {comment}')
+      def step_execute_nested_steps_with_table(context, comment):
+          assert context.nested_steps, "ENSURE: nested steps are provided."
+          context.execute_steps(context.nested_steps)
+
+      @then('the step "{expected_step}" was called')
+      def then_step_was_called(context, expected_step):
+          assert context.steps_called, "ENSURE: steps_called is provided."
+          assert expected_step in context.steps_called
+
+      @then('the table should be equal to')
+      def then_table_should_be_equal_to(context):
+          assert context.table, "ENSURE: table is provided."
+          expected_table = context.table
+          actual_table   = context.the_table
+          assert actual_table == expected_table
+
+      # -- SPECIAL-STEP:
+      @step('I setup an address book with')
+      def step_setup_address_book_with_friends(context):
+          assert context.table, "ENSURE: table is provided."
+          if not hasattr(context, "steps_called"):
+              context.steps_called = []
+          context.steps_called.append("I setup an address book with")
+          context.the_table = context.table
+      """
+    And a file named "features/execute_nested_steps_with_table.feature" with:
+      '''
+      Feature:
+        Scenario:
+          Given the following nested steps:
+            """
+            When I setup an address book with:
+              | Name  | Telephone Number |
+              | Alice | 555 1111         |
+              | Bob   | 555 2222         |
+            """
+          When I execute the nested steps with a table
+          Then the step "I setup an address book with" was called
+          And  the table should be equal to:
+              | Name  | Telephone Number |
+              | Alice | 555 1111         |
+              | Bob   | 555 2222         |
+      '''
+    When I run "behave -f plain features/execute_nested_steps_with_table.feature"
+    Then it should pass with:
+        """
+        1 feature passed, 0 failed, 0 skipped
+        1 scenario passed, 0 failed, 0 skipped
+        4 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+

data/vendor/behave/features/step.import_other_step_module.feature

@@ -0,0 +1,103 @@
+Feature: Ensure that a step module can import another step module
+
+  As a test writer
+  I want to import step definitions from another module in a step module
+  So that I can reuse other steps and call them directly.
+
+  . When a step module imports another step module
+  . this should not cause AmbiguousStep errors
+  . due to duplicated registration of the same step functions.
+  .
+  . NOTES:
+  .   * In general you should avoid this case (provided as example here).
+  .   * Use "context.execute_steps(...)" to avoid importing other step modules
+  .   * Use step-libraries; this will in general use sane imports of other step modules
+
+
+  Scenario: Step module that imports another step module
+    Given a new working directory
+    And a file named "features/steps/alice1_steps.py" with:
+      """
+      from behave import given
+
+      @given(u'I call Alice')
+      def step_call_alice(context):
+          pass
+      """
+    And   a file named "features/steps/bob1_steps.py" with:
+      """
+      from behave import given
+      from alice1_steps import step_call_alice
+
+      @given(u'I call Bob')
+      def step_call_bob(context):
+          pass
+
+      @given(u'I call Bob and Alice')
+      def step_call_bob_and_alice(context):
+          step_call_bob(context)
+          step_call_alice(context)
+      """
+    And a file named "features/example.import_step_module.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given I call Bob and Alice
+      """
+    When I run "behave -f plain --no-timings features/example.import_step_module.feature"
+    Then it should pass with:
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        1 step passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:
+            Scenario:
+              Given I call Bob and Alice ... passed
+        """
+
+
+  Scenario: Step module that imports another step module (cross-wise)
+    Given a new working directory
+    And a file named "features/steps/alice2_steps.py" with:
+      """
+      from behave import given
+      import bob2_steps     # -- BAD: Import other step module, cross-wise.
+
+      @given(u'I call Alice')
+      def step_call_alice(context):
+          pass
+      """
+    And   a file named "features/steps/bob2_steps.py" with:
+      """
+      from behave import given
+      import alice2_steps     # -- BAD: Import other step module, cross-wise.
+
+      @given(u'I call Bob')
+      def step_call_bob(context):
+          pass
+      """
+    And a file named "features/example.cross_imported_step_modules.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given I call Alice
+          And   I call Bob
+      """
+    When I run "behave -f plain --no-timings features/example.cross_imported_step_modules.feature"
+    Then it should pass with:
+        """
+        1 feature passed, 0 failed, 0 skipped
+        1 scenario passed, 0 failed, 0 skipped
+        2 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:
+            Scenario:
+              Given I call Alice ... passed
+              And I call Bob ... passed
+        """
+
+

data/vendor/behave/features/step.pending_steps.feature

@@ -0,0 +1,128 @@
+Feature: Pending Step (Exists with NotImplementedError Marker)
+
+   . TERMINOLOGY:
+   .  * An undefined step is a step without matching step implementation.
+   .  * A pending step exists,
+   .    but contains only the undefined step snippet as implementation,
+   .    that marks it as NotImplemented.
+   .
+   . RELATED TO:
+   .  * step.undefined_steps.feature
+
+
+    @setup
+    Scenario: Feature Setup
+      Given a new working directory
+      And a file named "behave.ini" with:
+        """
+        [behave]
+        show_skipped = false
+        show_timings = false
+        """
+      And a file named "features/steps/passing_steps.py" with:
+        """
+        from behave import step
+
+        @step('{word:w} step passes')
+        def step_passes(context, word):
+            pass
+
+        @step('{word:w} step fails')
+        def step_fails(context, word):
+            assert False, "XFAIL"
+        """
+      And a file named "features/steps/pending_steps.py" with:
+        """
+        from behave import given, when, then
+
+        @given('a pending step is used')
+        def step_pending_given(context):
+            raise NotImplementedError('STEP: Given a pending step is used')
+
+        @when('a pending step is used')
+        def step_pending_when(context):
+            raise NotImplementedError('STEP: When a pending step is used')
+
+        @then('a pending step is used')
+        def step_pending_then(context):
+            raise NotImplementedError('STEP: Then a pending step is used')
+        """
+      And a file named "features/use_pending_steps.feature" with:
+        """
+        Feature:
+          Scenario: 1
+            Given a step passes
+            And a pending step is used
+            When another step passes
+
+          Scenario: 2
+            Given a step passes
+            When a pending step is used
+            Then some step passes
+
+          Scenario: 3
+            Given a step passes
+            When another step passes
+            Then a pending step is used
+        """
+
+    Scenario: Pending given step (not implemented)
+      When I run "behave -f plain features/use_pending_steps.feature:2"
+      Then it should fail
+      And the command output should contain:
+        """
+        Feature:
+           Scenario: 1
+             Given a step passes ... passed
+               And a pending step is used ... failed
+        """
+      But the command output should contain:
+        """
+        NotImplementedError: STEP: Given a pending step is used
+        """
+      And the command output should contain:
+        """
+        File "features/steps/pending_steps.py", line 5, in step_pending_given
+          raise NotImplementedError('STEP: Given a pending step is used')
+        """
+
+    Scenario: Pending when step (not implemented)
+      When I run "behave -f plain features/use_pending_steps.feature:7"
+      Then it should fail
+      And the command output should contain:
+        """
+        Feature:
+           Scenario: 2
+             Given a step passes ... passed
+              When a pending step is used ... failed
+        """
+      But the command output should contain:
+        """
+        NotImplementedError: STEP: When a pending step is used
+        """
+      And the command output should contain:
+        """
+        File "features/steps/pending_steps.py", line 9, in step_pending_when
+          raise NotImplementedError('STEP: When a pending step is used')
+        """
+
+    Scenario: Pending then step (not implemented)
+      When I run "behave -f plain features/use_pending_steps.feature:12"
+      Then it should fail
+      And the command output should contain:
+        """
+        Feature:
+          Scenario: 3
+            Given a step passes ... passed
+            When another step passes ... passed
+            Then a pending step is used ... failed
+        """
+      But the command output should contain:
+        """
+        NotImplementedError: STEP: Then a pending step is used
+        """
+      And the command output should contain:
+        """
+        File "features/steps/pending_steps.py", line 13, in step_pending_then
+          raise NotImplementedError('STEP: Then a pending step is used')
+        """

data/vendor/behave/features/step.undefined_steps.feature

@@ -0,0 +1,307 @@
+Feature: Undefined Step
+
+  . TERMINOLOGY:
+  .  * An undefined step is a step without matching step implementation.
+  .
+  . SPECIFICATION:
+  .  * An undefined step should be reported after the run.
+  .  * An undefined step should cause its scenario to fail.
+  .  * If an undefined step is detected the remaining scenario steps are skipped.
+  .  * All undefined steps in a scenario should be reported (issue #42).
+  .  * Undefined steps should be detected even after a step fails in a scenario.
+  .  * Each undefined step should be reported only once.
+  .  * If a scenario is disabled (by tag expression, etc.),
+  .    the undefined step discovery should not occur.
+  .    This allows to prepare scenarios that are not intended to run (yet).
+  .  * Option --dry-run should discover undefined steps, too.
+  .
+  . RELATED TO:
+  .  * issue #42  Multiple undefined steps in same scenario are detected.
+
+
+    @setup
+    Scenario: Feature Setup
+      Given a new working directory
+      And a file named "features/steps/passing_steps.py" with:
+        """
+        from behave import step
+
+        @step('a step passes')
+        def step_passes(context):
+            pass
+
+        @step('a step fails')
+        def step_fails(context):
+            assert False, "XFAIL"
+        """
+      And a file named "features/undefined_last_step.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When an undefined step is used
+        """
+
+    Scenario: An undefined step should be reported
+      When I run "behave -f plain -T features/undefined_last_step.feature"
+      Then it should fail
+      And the command output should contain:
+        """
+        Feature:
+           Scenario:
+             Given a step passes ... passed
+              When an undefined step is used ... undefined
+        """
+      And the command output should contain:
+        """
+        You can implement step definitions for undefined steps with these snippets:
+
+        @when(u'an undefined step is used')
+        def step_impl(context):
+            raise NotImplementedError(u'STEP: When an undefined step is used')
+        """
+      And an undefined-step snippet should exist for "When an undefined step is used"
+
+
+    Scenario: An undefined step should cause its scenario to fail
+      When I run "behave -f plain features/undefined_last_step.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 1 failed, 0 skipped
+        1 step passed, 0 failed, 0 skipped, 1 undefined
+        """
+
+
+    Scenario: Additional scenario steps after an undefined step are skipped
+      Given a file named "features/undefined_step_and_more.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When an undefined step is used
+            Then a step passes
+            And  a step fails
+        """
+      When I run "behave -f plain -T features/undefined_step_and_more.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 1 failed, 0 skipped
+        1 step passed, 0 failed, 2 skipped, 1 undefined
+        """
+      And the command output should contain:
+        """
+        Feature:
+           Scenario:
+             Given a step passes ... passed
+              When an undefined step is used ... undefined
+        """
+
+
+    Scenario: Two undefined steps in same scenario should be detected
+      Given a file named "features/two_undefined_steps1.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When an undefined step is used
+            And  a step fails
+            Then another undefined step is used
+        """
+      When I run "behave -f plain -T features/two_undefined_steps1.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 1 failed, 0 skipped
+        1 step passed, 0 failed, 1 skipped, 2 undefined
+        """
+      And the command output should contain:
+        """
+        Feature:
+           Scenario:
+             Given a step passes ... passed
+              When an undefined step is used ... undefined
+        """
+      And undefined-step snippets should exist for:
+        | Step |
+        | When an undefined step is used |
+        | Then another undefined step is used |
+      But the command output should not contain:
+        """
+        And a step fails ... skipped
+        Then another undefined step is used ... undefined
+        """
+
+
+    Scenario: Two undefined steps in different scenarios
+      Given a file named "features/two_undefined_steps2.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When an undefined step is used
+
+          Scenario:
+            Given another undefined step is used
+            When a step passes
+        """
+      When I run "behave -f plain -T features/two_undefined_steps2.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 2 failed, 0 skipped
+        1 step passed, 0 failed, 1 skipped, 2 undefined
+        """
+      And the command output should contain:
+        """
+        Feature:
+           Scenario:
+             Given a step passes ... passed
+              When an undefined step is used ... undefined
+
+           Scenario:
+             Given another undefined step is used ... undefined
+        """
+      And undefined-step snippets should exist for:
+        | Step |
+        | When an undefined step is used |
+        | Given another undefined step is used |
+
+
+    Scenario: Undefined step in Scenario Outline
+      Given a file named "features/undefined_step_in_scenario_outline.feature" with:
+        """
+        Feature:
+          Scenario Outline:
+            Given a step <outcome1>
+            When an undefined step is used
+            Then a step <outcome2>
+
+          Examples:
+            | outcome1 | outcome2 |
+            |  passes  | passes   |
+            |  passes  | fails    |
+            |  fails   | passes   |
+            |  fails   | fails    |
+        """
+      When I run "behave -f plain -T features/undefined_step_in_scenario_outline.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 4 failed, 0 skipped
+        2 steps passed, 2 failed, 4 skipped, 4 undefined
+        """
+      And an undefined-step snippet should exist for "When an undefined step is used"
+      And the command output should contain:
+        """
+        Feature:
+           Scenario Outline:  -- @1.1
+             Given a step passes ... passed
+              When an undefined step is used ... undefined
+
+           Scenario Outline:  -- @1.2
+             Given a step passes ... passed
+              When an undefined step is used ... undefined
+
+           Scenario Outline:  -- @1.3
+             Given a step fails ... failed
+             Assertion Failed: XFAIL
+
+           Scenario Outline:  -- @1.4
+             Given a step fails ... failed
+             Assertion Failed: XFAIL
+        """
+
+
+    Scenario: Two undefined step in Scenario Outline
+      Given a file named "features/two_undefined_step_in_scenario_outline.feature" with:
+        """
+        Feature:
+          Scenario Outline:
+            Given a step <outcome1>
+            When an undefined step is used
+            Then a step <outcome2>
+            And another undefined step is used
+
+          Examples:
+            | outcome1 | outcome2 |
+            |  passes  | passes   |
+            |  passes  | fails    |
+            |  fails   | passes   |
+            |  fails   | fails    |
+        """
+      When I run "behave -f plain features/two_undefined_step_in_scenario_outline.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 4 failed, 0 skipped
+        2 steps passed, 2 failed, 4 skipped, 8 undefined
+        """
+      And undefined-step snippets should exist for:
+        | Step |
+        | When an undefined step is used |
+        | Then another undefined step is used |
+
+
+    Scenario: Undefined steps are detected if scenario is selected via tag
+      Given a file named "features/undefined_steps_with_tagged_scenario.feature" with:
+        """
+        Feature:
+
+          @selected
+          Scenario: S1
+            Given a step passes
+            And an undefined step Alice
+            When a step fails
+            Then an undefined step Bob
+
+          @selected
+          Scenario: S2
+            Given a step passes
+            When an undefined step Charly
+
+          @not_selected
+          Scenario: S3
+            Given an undefined step Delta
+            Then a step fails
+        """
+      When I run "behave -f plain --tags=@selected features/undefined_steps_with_tagged_scenario.feature"
+      Then it should fail with:
+        """
+        0 features passed, 1 failed, 0 skipped
+        0 scenarios passed, 2 failed, 1 skipped
+        2 steps passed, 0 failed, 3 skipped, 3 undefined
+        """
+      And undefined-step snippets should exist for:
+        | Step |
+        | Given an undefined step Alice      |
+        | Then an undefined step Bob    |
+        | When an undefined step Charly |
+      But undefined-step snippets should not exist for:
+        | Step |
+        | Given a step passes |
+        | Given an undefined step Delta |
+        | When a step fails |
+        | Then a step fails |
+
+
+    Scenario: Undefined steps are detected if --dry-run option is used
+      When I run "behave -f plain --dry-run features/undefined_steps_with_tagged_scenario.feature"
+      Then it should fail with:
+        """
+        0 features passed, 0 failed, 0 skipped, 1 untested
+        0 scenarios passed, 0 failed, 0 skipped, 3 untested
+        0 steps passed, 0 failed, 0 skipped, 4 undefined, 4 untested
+        """
+      And undefined-step snippets should exist for:
+        | Step |
+        | Given an undefined step Alice      |
+        | Then an undefined step Bob    |
+        | When an undefined step Charly |
+        | Given an undefined step Delta |
+      But undefined-step snippets should not exist for:
+        | Step |
+        | Given a step passes |
+        | When a step fails |
+        | Then a step fails |