busser-behave 0.1.3

data/vendor/behave/issue.features/issue0072.feature

@@ -0,0 +1,32 @@
+@issue
+Feature: Issue #72: Using 'GHERKIN_COLORS' fails with Exception
+
+    > Trying: GHERKIN_COLORS=executing=white behave
+    > It fails:
+    >
+    >    Traceback (most recent call last):
+    >      ...
+    >      File "/.../behave/formatter/ansi_escapes.py", line 38, in <module>
+    >        escapes[alias] = ''.join([colors[c] for c in aliases[alias].split(',')])
+    >    TypeError: list indices must be integers, not str
+    >
+    > The reason is that the global variable colors is defined twice in this module.
+    > The second variable overrides/modifies the first (without intention).
+
+
+  Scenario: Using GHERKIN_COLORS in new working dir
+    Given a new working directory
+     And I set the environment variable "GHERKIN_COLORS" to "executing=white"
+    When I run "behave"
+    Then it should fail with:
+      """
+      No steps directory in '{__WORKDIR__}/features'
+      """
+     But the command output should not contain:
+      """
+      Traceback (most recent call last):
+      """
+     And the command output should not contain:
+      """
+      TypeError: list indices must be integers, not str
+      """

data/vendor/behave/issue.features/issue0073.feature

@@ -0,0 +1,228 @@
+@issue
+Feature: Issue #73: the current_matcher is not predictable
+
+  . behave provides 2 matchers: ParseMatcher (parse) and RegexpMatcher (re).
+  . The ParseMatcher is used per default when the test runner starts.
+  .
+  . A step definition file may change the matcher several times
+  . by calling `use_step_matcher("re")` or `use_step_matcher("parse")`.
+  . In order to make the writing of step definitions more predictable,
+  . the matcher should be reset to the default matcher
+  . before loading each step definition.
+  .
+  . A project can define its own default matcher by calling the
+  . `use_step_matcher(...)` in the "environment.py" hook.
+  . This matcher will be used as default before a step definition is loaded.
+
+
+  Scenario: Verify that ParseMatcher is the default matcher
+    Given a new working directory
+    And   a file named "features/steps/parse_steps.py" with:
+        """
+        from behave import step
+
+        @step(u'a step {outcome:w}')
+        def step_passes(context, outcome):
+            assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+        """
+    And   a file named "features/passing.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When  a step passes
+            Then  a step passes
+        """
+    When I run "behave -f plain features/passing.feature"
+    Then it should pass with
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+
+
+  Scenario: Use only RegexMatcher in Step Definitions
+    Given a new working directory
+    And   a file named "features/environment.py" with:
+        """
+        from behave import use_step_matcher
+        use_step_matcher("re")
+        """
+    And   a file named "features/steps/regexp_steps.py" with:
+        """
+        from behave import step
+
+        @step(u'a step (?P<outcome>passes|fails)')
+        def step_passes(context, outcome):
+            assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+        """
+    And   a file named "features/passing.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When  a step passes
+            Then  a step passes
+        """
+    When I run "behave -f plain features/passing.feature"
+    Then it should pass with
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+
+
+  Scenario: Use ParseMatcher and RegexMatcher in Step Definitions (default=re)
+    Given a new working directory
+    And   a file named "features/environment.py" with:
+        """
+        from behave import use_step_matcher
+        use_step_matcher("re")
+        """
+     And   a file named "features/steps/eparse_steps.py" with:
+         """
+         from behave import step, use_step_matcher
+         use_step_matcher("parse")
+
+         @step(u'an extraordinary step {outcome:w}')
+         def step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+         """
+    And   a file named "features/steps/regexp_steps.py" with:
+        """
+        from behave import step
+
+        @step(u'a step (?P<outcome>passes|fails)')
+        def step_passes(context, outcome):
+            assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+        """
+     And   a file named "features/steps/xparse_steps.py" with:
+         """
+         from behave import step, use_step_matcher
+         use_step_matcher("parse")
+
+         @step(u'another step {outcome:w}')
+         def step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+         """
+   And   a file named "features/passing3.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When  another step passes
+            Then  an extraordinary step passes
+        """
+    When I run "behave -f plain features/passing3.feature"
+    Then it should pass with
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+
+
+  Scenario: Mix ParseMatcher and RegexMatcher in Step Definitions (default=re)
+    Given a new working directory
+    And   a file named "features/environment.py" with:
+        """
+        from behave import use_step_matcher
+        use_step_matcher("re")
+        """
+     And   a file named "features/steps/given_steps.py" with:
+         """
+         from behave import step, use_step_matcher
+
+         use_step_matcher("parse")
+         @given(u'a step {outcome:w}')
+         def given_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+
+         use_step_matcher("re")
+         @given(u'another step (?P<outcome>passes|fails)')
+         def given_another_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+
+         use_step_matcher("parse")
+         @given(u'an extraordinary step {outcome:w}')
+         def given_extraordinary_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+         """
+     And   a file named "features/steps/when_steps.py" with:
+         """
+         from behave import step, use_step_matcher
+
+         @when(u'a step (?P<outcome>passes|fails)')
+         def when_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+
+         use_step_matcher("parse")
+         @when(u'another step {outcome:w}')
+         def when_another_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+
+         use_step_matcher("re")
+         @when(u'an extraordinary step (?P<outcome>passes|fails)')
+         def when_extraordinary_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+         """
+     And   a file named "features/steps/then_steps.py" with:
+         """
+         from behave import step, use_step_matcher
+
+         use_step_matcher("parse")
+         @then(u'a step {outcome:w}')
+         def then_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+
+         use_step_matcher("re")
+         @then(u'another step (?P<outcome>passes|fails)')
+         def then_another_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+
+         use_step_matcher("parse")
+         @then(u'an extraordinary step {outcome:w}')
+         def then_extraordinary_step_passes(context, outcome):
+             assert outcome == "passes", "FAIL: outcome={0}".format(outcome)
+         """
+   And   a file named "features/passing3.feature" with:
+        """
+        Feature:
+          Scenario: 1
+            Given a step passes
+            When  another step passes
+            Then  an extraordinary step passes
+
+          Scenario: 2
+            Given another step passes
+            When  an extraordinary step passes
+            Then  a step passes
+
+          Scenario: 3
+            Given an extraordinary step passes
+            When  a step passes
+            Then  another step passes
+        """
+    When I run "behave -c -f pretty --no-timings features/passing3.feature"
+    Then it should pass with:
+        """
+        3 scenarios passed, 0 failed, 0 skipped
+        9 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:  # features/passing3.feature:1
+          Scenario: 1                         # features/passing3.feature:2
+            Given a step passes               # features/steps/given_steps.py:4
+            When another step passes          # features/steps/when_steps.py:8
+            Then an extraordinary step passes # features/steps/then_steps.py:14
+
+          Scenario: 2                         # features/passing3.feature:7
+            Given another step passes         # features/steps/given_steps.py:9
+            When an extraordinary step passes # features/steps/when_steps.py:13
+            Then a step passes                # features/steps/then_steps.py:4
+
+          Scenario: 3                          # features/passing3.feature:12
+            Given an extraordinary step passes # features/steps/given_steps.py:14
+            When a step passes                 # features/steps/when_steps.py:3
+            Then another step passes           # features/steps/then_steps.py:9
+        """

data/vendor/behave/issue.features/issue0075.feature

@@ -0,0 +1,18 @@
+@issue
+Feature: Issue #75: behave @features_from_text_file does not work
+
+  . Feature of Cucumber. Reading the source code, I see it partly implemented.
+  .
+  .   $ behave @list_of_features.txt
+  .   https://github.com/jeamland/behave/blob/master/behave/runner.py#L416:L430
+  .
+  . However it fails because:
+  .  * it does not remove the @ from the path
+  .  * it does not search the steps/ directory in the parents of the feature files themselves
+
+
+  @reuse.colocated_test
+  Scenario: Use feature listfile
+    Given I use the current directory as working directory
+    When I run "behave -f plain features/runner.feature_listfile.feature"
+    Then it should pass

data/vendor/behave/issue.features/issue0077.feature

@@ -0,0 +1,89 @@
+@issue
+Feature: Issue #77: Does not capture stdout from sub-processes
+
+  . My step functions are using wrapper objects to interact with SUT.
+  . Those wrappers use this kind of thing to invoke executables:
+  .
+  .   subprocess.check_call('myprog', ..., stderr=subprocess.STDOUT)
+  .
+  . However, the output from those calls does not appear in the stdout
+  . captured by behave when a step fails.
+
+
+  Background: Test Setup
+    Given a new working directory
+    Given a file named "hello.py" with:
+        """
+        import sys
+
+        def hello():
+            result = 0
+            args = sys.argv[1:]
+            if args and args[0].startswith("--fail"):
+                result = 1
+                args   = args[1:]
+            message = " ".join(args)
+            sys.stdout.write("Hello {0}\n".format(message))
+            sys.exit(result)
+
+        if __name__ == "__main__":
+            hello()
+        """
+    And   a file named "features/steps/subprocess_call_steps.py" with:
+        """
+        from behave import given, when, then
+        import subprocess
+        import os.path
+        import sys
+
+        PYTHON = sys.executable
+        HERE = os.path.dirname(__file__)
+
+        @when(u'I make a subprocess call "hello {commandline}"')
+        def step(context, commandline):
+            result = subprocess_call_hello(commandline.split())
+            assert result == 0
+
+        def subprocess_call_hello(args):
+            command_args = [ PYTHON, "hello.py" ] + args
+            result = subprocess.check_call(command_args, stderr=subprocess.STDOUT)
+            return result
+            # result = subprocess.check_output(command_args, stderr=subprocess.STDOUT)
+            # return result
+        """
+
+  Scenario: Subprocess call shows generated output
+    Given a file named "features/issue77_hello_OK.feature" with:
+        """
+        Feature:
+          Scenario:
+            When I make a subprocess call "hello world."
+        """
+    When I run "behave -f plain features/issue77_hello_OK.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:
+        """
+        Hello world.
+        """
+
+  Scenario: Subprocess call fails with captured output
+    Given a file named "features/issue77_hello_FAIL.feature" with:
+        """
+        Feature:
+          Scenario:
+            When I make a subprocess call "hello --fail FAIL."
+        """
+    When I run "behave -f plain features/issue77_hello_FAIL.feature"
+    Then it should fail with:
+        """
+        0 scenarios passed, 1 failed, 0 skipped
+        0 steps passed, 1 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Hello FAIL.
+        """

data/vendor/behave/issue.features/issue0080.feature

@@ -0,0 +1,49 @@
+@issue
+Feature: Issue #80: source file names not properly printed with python3
+
+  . $ behave -f pretty example/example.feature
+  . Scenario: run a simple test         # example/example.feature:3
+  .    Given we have behave installed   # <string>:3
+  .    When we implement a test         # <string>:7
+  .    Then behave will test it for us! # <string>:11
+
+
+  Background: Test Setup
+    Given a new working directory
+    And   a file named "features/steps/steps.py" with:
+        """
+        from behave import given, when, then
+
+        @given(u'a step passes')
+        def step(context):
+            pass
+
+        @when(u'a step passes')
+        def step(context):
+            pass
+
+        @then(u'a step passes')
+        def step(context):
+            pass
+        """
+    And   a file named "features/basic.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given a step passes
+            When  a step passes
+            Then  a step passes
+        """
+
+  Scenario: Show step locations
+    When I run "behave -c -f pretty --no-timings features/basic.feature"
+    Then it should pass
+    And the command output should contain:
+        """
+        Feature:  # features/basic.feature:1
+          Scenario:             # features/basic.feature:2
+            Given a step passes # features/steps/steps.py:3
+            When a step passes  # features/steps/steps.py:7
+            Then a step passes  # features/steps/steps.py:11
+        """
+    And the command output should not contain "# <string>:"

data/vendor/behave/issue.features/issue0081.feature

@@ -0,0 +1,138 @@
+@issue
+Feature: Issue #81: Allow defining steps in a separate library
+
+  . The current design forces steps.py to be in a particular folder.
+  . This does not allow to reuse a common library of BDD steps across
+  . multiple software projects in a company.
+  . It would be great if one could define a separate lib with common steps
+  . (e.g. steps4mycompany.py)
+
+
+  Background: Test Setup
+    Given a new working directory
+    And   an empty file named "step_library42/__init__.py"
+    And   a file named "step_library42/alice_steps.py" with:
+        """
+        # -- ALICE-STEPS: Anonymous step names.
+        from behave import given, when, then
+
+        @given(u'I use the step library "{library}"')
+        def step(context, library):
+            pass
+
+        @when(u'I use steps from this step library')
+        def step(context):
+            pass
+
+        @then(u'these steps are executed')
+        def step(context):
+            pass
+        """
+    And   a file named "features/use_step_library.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given I use the step library "alice"
+            When  I use steps from this step library
+            Then  these steps are executed
+        """
+
+  Scenario: Proof of Concept
+    Given a file named "features/steps/use_step_libs.py" with:
+        """
+        from step_library42.alice_steps import *
+        """
+    When I run "behave --no-timings -f plain features/use_step_library.feature"
+    Then it should pass with:
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:
+           Scenario:
+             Given I use the step library "alice" ... passed
+              When I use steps from this step library ... passed
+              Then these steps are executed ... passed
+        """
+
+  Scenario: With --format=pretty
+    Given a file named "features/steps/use_step_libs.py" with:
+        """
+        from step_library42.alice_steps import *
+        """
+    When I run "behave -c -f pretty features/use_step_library.feature"
+    Then it should pass with:
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:  # features/use_step_library.feature:1
+          Scenario:                                 # features/use_step_library.feature:2
+            Given I use the step library "alice"    # step_library42/alice_steps.py:4
+            When I use steps from this step library # step_library42/alice_steps.py:8
+            Then these steps are executed           # step_library42/alice_steps.py:12
+        """
+
+  Scenario: Selective step import from step library
+    Given a file named "step_library42/bob_steps.py" with:
+        """
+        # -- BOB-STEPS: Explicit step function names (otherwise same as alice).
+        from behave import given, when, then
+
+        @given(u'I use the step library "{library}"')
+        def given_I_use_the_step_library(context, library):
+            pass
+
+        @when(u'I use steps from this step library')
+        def when_I_use_steps_from_this_step_library(context):
+            pass
+
+        @then(u'these steps are executed')
+        def then_these_steps_are_executed(context):
+            pass
+        """
+    And a file named "features/steps/use_step_libs.py" with:
+        """
+        from step_library42.bob_steps import given_I_use_the_step_library
+        from step_library42.bob_steps import when_I_use_steps_from_this_step_library
+        from step_library42.bob_steps import then_these_steps_are_executed
+        """
+    When I run "behave -c -f pretty features/use_step_library.feature"
+    Then it should pass with:
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:  # features/use_step_library.feature:1
+          Scenario:                                 # features/use_step_library.feature:2
+            Given I use the step library "alice"    # step_library42/bob_steps.py:4
+            When I use steps from this step library # step_library42/bob_steps.py:8
+            Then these steps are executed           # step_library42/bob_steps.py:12
+        """
+
+  Scenario: Import step library in "environment.py"
+    Given a file named "features/environment.py" with:
+        """
+        from step_library42.alice_steps import *
+        """
+    And   an empty file named "features/steps/__init__.py"
+    When I run "behave -c -f pretty features/use_step_library.feature"
+    Then it should pass with:
+        """
+        1 scenario passed, 0 failed, 0 skipped
+        3 steps passed, 0 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Feature:  # features/use_step_library.feature:1
+          Scenario:                                 # features/use_step_library.feature:2
+            Given I use the step library "alice"    # step_library42/alice_steps.py:4
+            When I use steps from this step library # step_library42/alice_steps.py:8
+            Then these steps are executed           # step_library42/alice_steps.py:12
+        """