busser-behave 0.1.3

data/vendor/behave/features/scenario_outline.tagged_examples.feature

@@ -0,0 +1,118 @@
+Feature: ScenarioOutline with tagged Examples
+
+  As a tester
+  I want to select (or exclude) a specific Examples table of a ScenarioOutline
+  To run only the scenarios from the Examples table of interest.
+
+  | SPECIFICATION:
+  |   Scenarios from a Examples table inherit the tags from
+  |   its ScenarioOutline tags and its Examples tags:
+  |
+  |       scenario.tags = scenario_outline.tags + examples.tags
+  |
+  |   Therefore, examples.tags can easily be used to select all scenarios
+  |   of this Examples table.
+  |
+  |   NOTE: This allows to provide multiple Examples sections,
+  |     one for each stage of testing and/or one for each test team
+  |     (development testing, integration testing, system tests, ...).
+
+  @setup
+  Scenario: Feature Setup
+    Given a new working directory
+    And a file named "behave.ini" with:
+      """
+      [behave]
+      show_timestamps = false
+      show_skipped = false
+      """
+    And a file named "features/steps/steps.py" with:
+      """
+      from behave import step
+
+      @step('{word:w} step passes')
+      def step_passes(context, word):
+          pass
+      """
+    And a file named "features/tagged_examples.feature" with:
+      """
+      Feature:
+
+        @zap
+        Scenario Outline:
+          Given <variant> step passes
+
+          @foo
+          Examples: Alice
+            | variant | Comment |
+            | a       | First  case |
+            | another | Second case |
+
+          @bar
+          Examples: Bob
+            | variant | Comment |
+            | weird   | First case |
+      """
+    And a file named "behave.ini" with:
+        """
+        [behave]
+        show_skipped = false
+        show_timings = false
+        """
+
+  Scenario: Use all Examples (and Scenarios)
+    When I run "behave -f plain features/tagged_examples.feature"
+    Then it should pass with:
+      """
+      1 feature passed, 0 failed, 0 skipped
+      3 scenarios passed, 0 failed, 0 skipped
+      """
+
+  Scenario: Select all Examples (and Scenarios)
+    When I run "behave -f plain --tags=@zap features/tagged_examples.feature"
+    Then it should pass with:
+      """
+      1 feature passed, 0 failed, 0 skipped
+      3 scenarios passed, 0 failed, 0 skipped
+      """
+
+  Scenario: Select only first Examples table
+    When I run "behave -f plain --tags=@foo features/tagged_examples.feature"
+    Then it should pass with:
+      """
+      1 feature passed, 0 failed, 0 skipped
+      2 scenarios passed, 0 failed, 1 skipped
+      """
+    And the command output should contain:
+      """
+      Scenario Outline:  -- @1.1 Alice
+        Given a step passes ... passed
+
+      Scenario Outline:  -- @1.2 Alice
+        Given another step passes ... passed
+      """
+    But the command output should not contain:
+      """
+      Scenario Outline:  -- @2.1 Bob
+      """
+
+  Scenario: Select only second Examples table
+    When I run "behave -f plain --tags=@bar features/tagged_examples.feature"
+    Then it should pass with:
+      """
+      1 feature passed, 0 failed, 0 skipped
+      1 scenario passed, 0 failed, 2 skipped
+      """
+    And the command output should contain:
+      """
+      Scenario Outline:  -- @2.1 Bob
+        Given weird step passes ... passed
+      """
+    But the command output should not contain:
+      """
+      Scenario Outline:  -- @1.1 Alice
+        Given a step passes ... passed
+
+      Scenario Outline:  -- @1.2 Alice
+        Given another step passes ... passed
+      """

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

@@ -0,0 +1,225 @@
+Feature: Async-Test Support (async-step, ...)
+
+  As a test writer and step provider
+  I want to test async frameworks or protocols (that use asyncio)
+
+  . USE CASES:
+  .   * async-step with run-to-complete semantics (like synchronous step)
+  .   * async-dispatch-and-collect-results-later:
+  .     one or more steps dispatch async-calls (tasks)
+  .     and final step(s) that waits until tasks have been completed
+  .     (collects the results of the async-calls and verifies them)
+  .
+  . TERMINOLOGY: async-step
+  .  An async-step is either
+  .    * an async-function as coroutine using async/await keywords (Python 3.5)
+  .    * an async-function tagged with @asyncio.coroutine and using "yield from"
+  .
+  .  # -- EXAMPLE CASE 1 (since Python 3.5):
+  .  async def coroutine1(duration):
+  .      await asyncio.sleep(duration)
+  .
+  .  # -- EXAMPLE CASE 2 (since Python 3.4):
+  .  @asyncio.coroutine
+  .  def coroutine2(duration):
+  .      yield from asyncio.sleep(duration)
+  .
+  . RATIONALE:
+  .   By using async-steps, an additional layer of indirection is avoided.
+  .   The async-step can directly interact with other async-functions.
+
+
+    @use.with_python.version=3.5
+    @use.with_python.version=3.6
+    Scenario: Use async-step with @async_run_until_complete (async)
+      Given a new working directory
+      And a file named "features/steps/async_steps35.py" with:
+        """
+        from behave import step
+        from behave.api.async_step import async_run_until_complete
+        import asyncio
+
+        @step('an async-step waits {duration:f} seconds')
+        @async_run_until_complete
+        async def step_async_step_waits_seconds(context, duration):
+            await asyncio.sleep(duration)
+        """
+      And a file named "features/async_run.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given an async-step waits 0.2 seconds
+        """
+      When I run "behave -f plain --show-timings features/async_run.feature"
+      Then it should pass with:
+        """
+        Feature:
+           Scenario:
+             Given an async-step waits 0.2 seconds ... passed in 0.2
+        """
+
+
+    @use.with_python.version=3.4
+    @use.with_python.version=3.5
+    @use.with_python.version=3.6
+    Scenario: Use async-step with @async_run_until_complete (@coroutine)
+      Given a new working directory
+      And a file named "features/steps/async_steps34.py" with:
+        """
+        from behave import step
+        from behave.api.async_step import async_run_until_complete
+        import asyncio
+
+        @step('an async-step waits {duration:f} seconds')
+        @async_run_until_complete
+        @asyncio.coroutine
+        def step_async_step_waits_seconds2(context, duration):
+            yield from asyncio.sleep(duration)
+        """
+      And a file named "features/async_run.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given an async-step waits 0.3 seconds
+        """
+      When I run "behave -f plain --show-timings features/async_run.feature"
+      Then it should pass with:
+        """
+        Feature:
+           Scenario:
+             Given an async-step waits 0.3 seconds ... passed in 0.3
+        """
+
+    @use.with_python.version=3.5
+    @use.with_python.version=3.6
+    Scenario: Use @async_run_until_complete(timeout=...) and TIMEOUT occurs (async)
+      Given a new working directory
+      And a file named "features/steps/async_steps_timeout35.py" with:
+        """
+        from behave import step
+        from behave.api.async_step import async_run_until_complete
+        import asyncio
+
+        @step('an async-step waits {duration:f} seconds with timeout')
+        @async_run_until_complete(timeout=0.1)  # BAD-TIMEOUT-BY-DESIGN
+        async def step_async_step_waits_seconds_with_timeout35(context, duration):
+            await asyncio.sleep(duration)
+        """
+      And a file named "features/async_timeout35.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given an async-step waits 1.0 seconds with timeout
+        """
+      When I run "behave -f plain --show-timings features/async_timeout35.feature"
+      Then it should fail with:
+        """
+        0 steps passed, 1 failed, 0 skipped, 0 undefined
+        """
+      And the command output should contain:
+        """
+        Given an async-step waits 1.0 seconds with timeout ... failed in 0.1
+        """
+      And the command output should contain:
+        """
+        Assertion Failed: TIMEOUT-OCCURED: timeout=0.1
+        """
+
+    @use.with_python.version=3.4
+    @use.with_python.version=3.5
+    @use.with_python.version=3.6
+    Scenario: Use @async_run_until_complete(timeout=...) and TIMEOUT occurs (@coroutine)
+      Given a new working directory
+      And a file named "features/steps/async_steps_timeout34.py" with:
+        """
+        from behave import step
+        from behave.api.async_step import async_run_until_complete
+        import asyncio
+
+        @step('an async-step waits {duration:f} seconds with timeout')
+        @async_run_until_complete(timeout=0.2)  # BAD-TIMEOUT-BY-DESIGN
+        @asyncio.coroutine
+        def step_async_step_waits_seconds_with_timeout34(context, duration):
+            yield from asyncio.sleep(duration)
+        """
+      And a file named "features/async_timeout34.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given an async-step waits 1.0 seconds with timeout
+        """
+      When I run "behave -f plain --show-timings features/async_timeout34.feature"
+      Then it should fail with:
+        """
+        0 steps passed, 1 failed, 0 skipped, 0 undefined
+        """
+      And the command output should contain:
+        """
+        Given an async-step waits 1.0 seconds with timeout ... failed in 0.2
+        """
+      And the command output should contain:
+        """
+        Assertion Failed: TIMEOUT-OCCURED: timeout=0.2
+        """
+
+    @use.with_python.version=3.4
+    @use.with_python.version=3.5
+    @use.with_python.version=3.6
+    Scenario: Use async-dispatch and async-collect concepts
+      Given a new working directory
+      And a file named "features/steps/async_dispatch_steps.py" with:
+        """
+        from behave import given, then, step
+        from behave.api.async_step import use_or_create_async_context, AsyncContext
+        from hamcrest import assert_that, equal_to, empty
+        import asyncio
+
+        @asyncio.coroutine
+        def async_func(param):
+            yield from asyncio.sleep(0.2)
+            return str(param).upper()
+
+        @given('I dispatch an async-call with param "{param}"')
+        def step_dispatch_async_call(context, param):
+            async_context = use_or_create_async_context(context, "async_context1")
+            task = async_context.loop.create_task(async_func(param))
+            async_context.tasks.append(task)
+
+        @then('the collected result of the async-calls is "{expected}"')
+        def step_collected_async_call_result_is(context, expected):
+            async_context = context.async_context1
+            done, pending = async_context.loop.run_until_complete(
+                asyncio.wait(async_context.tasks, loop=async_context.loop))
+
+            parts = [task.result() for task in done]
+            joined_result = ", ".join(sorted(parts))
+            assert_that(joined_result, equal_to(expected))
+            assert_that(pending, empty())
+        """
+      And a file named "features/async_dispatch.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given I dispatch an async-call with param "Alice"
+            And   I dispatch an async-call with param "Bob"
+            Then the collected result of the async-calls is "ALICE, BOB"
+        """
+      When I run "behave -f plain --show-timings features/async_dispatch.feature"
+      Then it should pass with:
+        """
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+      And the command output should contain:
+        """
+        Given I dispatch an async-call with param "Alice" ... passed in 0.00
+        """
+      And the command output should contain:
+        """
+        And I dispatch an async-call with param "Bob" ... passed in 0.00
+        """
+      And the command output should contain:
+        """
+        Then the collected result of the async-calls is "ALICE, BOB" ... passed in 0.2
+        """
+      But note that "the async-collect step waits 0.2 seconds for both async-tasks to finish"
+      And note that "the async-dispatch steps do not wait at all"

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

@@ -0,0 +1,106 @@
+Feature: Duplicated Step Definitions
+
+  As I tester and test writer
+  I want to know when step definitions are duplicated
+  So that I can fix these problems.
+
+
+  Scenario: Duplicated Step in same File
+    Given a new working directory
+    And a file named "features/steps/alice_steps.py" with:
+      """
+      from behave import given, when, then
+
+      @given(u'I call Alice')
+      def step(context):
+          pass
+
+      @given(u'I call Alice')
+      def step(context):
+          pass
+      """
+    And a file named "features/duplicated_step_alice.feature" with:
+      """
+      Feature:
+        Scenario: Duplicated Step
+          Given I call Alice
+      """
+    When I run "behave -f plain features/duplicated_step_alice.feature"
+    Then it should fail
+    And the command output should contain:
+        """
+        AmbiguousStep: @given('I call Alice') has already been defined in
+        existing step @given('I call Alice') at features/steps/alice_steps.py:3
+        """
+    And the command output should contain:
+        """
+        File "features/steps/alice_steps.py", line 7, in <module>
+        @given(u'I call Alice')
+        """
+
+
+  Scenario: Duplicated Step Definition in another File
+    Given a new working directory
+    And a file named "features/steps/bob1_steps.py" with:
+      """
+      from behave import given
+
+      @given('I call Bob')
+      def step_call_bob1(context):
+          pass
+      """
+    And   a file named "features/steps/bob2_steps.py" with:
+      """
+      from behave import given
+
+      @given('I call Bob')
+      def step_call_bob2(context):
+          pass
+      """
+    And a file named "features/duplicated_step_bob.feature" with:
+      """
+      Feature:
+        Scenario: Duplicated Step
+          Given I call Bob
+      """
+    When I run "behave -f plain features/duplicated_step_bob.feature"
+    Then it should fail
+    And the command output should contain:
+        """
+        AmbiguousStep: @given('I call Bob') has already been defined in
+        existing step @given('I call Bob') at features/steps/bob1_steps.py:3
+        """
+    And the command output should contain:
+        """
+        File "features/steps/bob2_steps.py", line 3, in <module>
+        @given('I call Bob')
+        """
+
+  @xfail
+  Scenario: Duplicated Same Step Definition via import from another File
+    Given a new working directory
+    And a file named "features/steps/charly1_steps.py" with:
+      """
+      from behave import given
+
+      @given('I call Charly')
+      def step_call_charly1(context):
+          pass
+      """
+    And   a file named "features/steps/charly2_steps.py" with:
+      """
+      import charly1_steps
+      """
+    And a file named "features/duplicated_step_via_import.feature" with:
+      """
+      Feature:
+        Scenario: Duplicated same step via import
+          Given I call Charly
+      """
+    When I run "behave -f plain features/duplicated_step_via_import.feature"
+    Then it should pass
+    And the command output should not contain:
+        """
+        AmbiguousStep: @given('I call Charly') has already been defined in
+        existing step @given('I call Charly') at features/steps/charly1_steps.py:3
+        """