busser-behave 0.1.3

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

@@ -0,0 +1,12 @@
+@issue
+Feature: Issue #186: ScenarioOutline uses wrong return value when if fails
+
+  ScenarioOutline returns encountered a failure only if the last scenario failed.
+  Failures in earlier examples return the wrong result.
+  Ensure that ScenarioOutline run-logic behaves as expected.
+
+  @reuse.colocated_test
+  Scenario: Reuse existing test
+    Given I use the current directory as working directory
+    When I run "behave -f plain features/scenario_outline.basics.feature"
+    Then it should pass

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

@@ -0,0 +1,60 @@
+@issue
+Feature: Issue #188: Better diagnostics if nested step is undefined
+  
+  . Currently if nested step has no match, it's shown like this:
+  .
+  .     Assertion Failed: Sub-step failed: When I do strange thign
+  .     Substep info: None
+  .
+  . Took some time to find that typo.
+  . The suggestion is to fill substep error_message with at least "No match for step"
+  . so it would become:
+  .
+  .     Assertion Failed: Sub-step failed: When I do strange thign
+  .     Substep info: No match for step
+  .
+  . IMPLEMENTATION NOTE:
+  . A slightly different output is provided:
+  .
+  .     Assertion Failed: UNDEFINED SUB-STEP: When I do strange thign
+
+
+  Scenario: Nested steps contain an undefined step
+    Given a new working directory
+    And a file named "features/steps/steps.py" with:
+      """
+      from behave import step
+
+      @step('{word:w} step passes')
+      def step_passes(context, word):
+          pass
+
+      @then('a good diagnostic message is shown')
+      def step_good_diagnostic_message_is_shown(context):
+          pass
+
+      @step('I execute nested steps with an undefined step')
+      def step_passes(context):
+          context.execute_steps(u'''
+            Given another step passes
+            When an undefined, nested step is executed
+            Then third step passes
+          ''')
+      """
+    And a file named "features/example.execute_nested_undefined_step.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given a step passes
+          When I execute nested steps with an undefined step
+          Then a good diagnostic message is shown
+      """
+    When I run "behave -f plain -T features/example.execute_nested_undefined_step.feature"
+    Then it should fail with:
+      """
+      Scenario:
+        Given a step passes ... passed
+        When I execute nested steps with an undefined step ... failed
+      Assertion Failed: UNDEFINED SUB-STEP: When an undefined, nested step is executed
+      """
+

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

@@ -0,0 +1,178 @@
+@issue
+Feature: Issue #191 Using context.execute_steps() may change context.table/.text
+
+  . PROBLEM DESCRIPTION:
+  . When you execute nested steps via "context.execute_steps()" in a
+  . step implementation, the following context attributes of the current step
+  . may be modified and may be longer valid:
+  .   * context.text (multi-line text)
+  .   * context.table
+
+
+  @setup
+  Scenario: Feature Setup
+    Given a new working directory
+    And a file named "features/steps/common_steps.py" with:
+        """
+        from behave import given, step
+
+        @step('{word:w} step passes')
+        def step_passes(context, word):
+            pass
+
+        @given('I define the following nested steps')
+        def step_define_nested_steps(context):
+            assert context.text is not None, "REQUIRE: text"
+            context.nested_steps = context.text
+        """
+    And a file named "features/steps/table_steps.py" with:
+        """
+        from behave import when, then, step
+
+        @step('I use another table with')
+        def step_use_another_table_with(context):
+            assert context.table, "REQUIRE: table"
+            context.nested_table = context.table
+
+        @when('I execute the nested steps and use the table')
+        def step_execute_nested_steps_and_use_table(context):
+            assert context.table, "REQUIRE: table"
+            assert context.nested_steps, "REQUIRE: context.nested_steps"
+            context.my_table1 = context.table
+            context.execute_steps(context.nested_steps)
+            context.my_table2 = context.table
+
+        @then('the original table is restored after the nested steps are executed')
+        def step_table_is_restored(context):
+            assert context.my_table1 is not None
+            assert context.my_table2 is not None
+            assert context.my_table1 is context.my_table2
+        """
+    And a file named "features/steps/text_steps.py" with:
+        """
+        from behave import when, then, step
+
+        @step('I use another step with text "{text}"')
+        def step_use_another_text_with(context, text):
+            assert context.text is None
+            context.text = text     # -- MODIFY: context.text (emulation)
+
+        @step('I use another text with')
+        def step_use_another_text_with(context):
+            assert context.text is not None, "REQUIRE: text"
+            context.nested_text = context.text
+
+        @when('I execute the nested steps and use the text')
+        def step_execute_nested_steps_and_use_text(context):
+            assert context.text is not None, "REQUIRE: text"
+            assert context.nested_steps, "REQUIRE: context.nested_steps"
+            context.my_text1 = context.text
+            context.execute_steps(context.nested_steps)
+            context.my_text2 = context.text
+
+        @then('the original text is restored after the nested steps are executed')
+        def step_text_is_restored(context):
+            assert context.my_text1 is not None
+            assert context.my_text2 is not None
+            assert context.my_text1 is context.my_text2
+        """
+
+  @nested_steps.with_table
+  Scenario: After executing simple nested steps the original table is restored
+    Given a file named "features/example.nested_simple_steps_and_table.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given I define the following nested steps:
+                '''
+                Given a step passes
+                When another step passes
+                '''
+            When I execute the nested steps and use the table:
+                | Name   | Age |
+                | Alice  | 21  |
+                | Bob    | 32  |
+            Then the original table is restored after the nested steps are executed
+        """
+    When I run "behave -f plain -T features/example.nested_simple_steps_and_table.feature"
+    Then it should pass with:
+      """
+      1 scenario passed, 0 failed, 0 skipped
+      3 steps passed, 0 failed, 0 skipped, 0 undefined
+      """
+
+  @nested_steps.with_table
+  Scenario: After executing nested steps with a table the original table is restored
+    Given a file named "features/example.nested_steps_and_table.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given I define the following nested steps:
+                '''
+                Given I use another table with:
+                    | Person | Registered |
+                    | Anton  | true  |
+                    | Barby  | false |
+                '''
+            When I execute the nested steps and use the table:
+                | Name   | Age |
+                | Charly | 41  |
+                | Doro   | 52  |
+            Then the original table is restored after the nested steps are executed
+        """
+    When I run "behave -f plain -T features/example.nested_steps_and_table.feature"
+    Then it should pass with:
+      """
+      1 scenario passed, 0 failed, 0 skipped
+      3 steps passed, 0 failed, 0 skipped, 0 undefined
+      """
+
+
+  @nested_steps.with_text
+  Scenario: After executing simple nested steps the original text is restored
+    Given a file named "features/example.nested_simple_steps_and_text.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given I define the following nested steps:
+                '''
+                Given a step passes
+                When another step passes
+                '''
+            When I execute the nested steps and use the text:
+                '''
+                Lorem ipsum
+                Ipsum lorem
+                '''
+            Then the original text is restored after the nested steps are executed
+        """
+    When I run "behave -f plain -T features/example.nested_simple_steps_and_text.feature"
+    Then it should pass with:
+      """
+      1 scenario passed, 0 failed, 0 skipped
+      3 steps passed, 0 failed, 0 skipped, 0 undefined
+      """
+
+  @nested_steps.with_text
+  Scenario: After executing nested steps with a text the original text is restored
+    Given a file named "features/example.nested_steps_and_text.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given I define the following nested steps:
+                '''
+                Given I use another step with text "Hello Alice"
+                '''
+            When I execute the nested steps and use the text:
+                '''
+                Lorem ipsum
+                Ipsum lorem
+                '''
+            Then the original text is restored after the nested steps are executed
+        """
+    When I run "behave -f plain -T features/example.nested_steps_and_text.feature"
+    Then it should pass with:
+      """
+      1 scenario passed, 0 failed, 0 skipped
+      3 steps passed, 0 failed, 0 skipped, 0 undefined
+      """

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

@@ -0,0 +1,215 @@
+@issue
+Feature: Issue #194: Nested steps prevent that original stdout/stderr is restored
+
+  . When nested steps are used,
+  . the original stdout/stderr streams are not restored after the scenario.
+  . This is caused by starting/stopping capture again while executing nested steps.
+  .
+  . ENSURE THAT:
+  .   * Original streams are restored in after_scenario() hook.
+  .   * Nested steps should not replace existing capture objects.
+
+  @setup
+  Scenario: Feature Setup
+    Given a new working directory
+    And a file named "behave.ini" with:
+        """
+        [behave]
+        log_capture = false
+        logging_level  = INFO
+        logging_format = LOG.%(levelname)-8s  %(name)s: %(message)s
+        """
+    And a file named "features/steps/use_behave4cmd_steps.py" with:
+        """
+        import behave4cmd0.passing_steps
+        import behave4cmd0.failing_steps
+        import behave4cmd0.note_steps
+        """
+    And a file named "features/steps/stdout_steps.py" with:
+        """
+        from behave import given, when, then, step, matchers
+        import parse
+        import sys
+
+        # -- USER-DEFINED DATA TYPES:
+        @parse.with_pattern(r"stdout|stderr")
+        def parse_stream_name(text):
+            assert text in ("stdout", "stderr")
+            return text
+
+        matchers.register_type(StreamName=parse_stream_name)
+
+        # -- UTILITY FUNCTIONS:
+        def write_text_to(stream, text, enforce_newline=True):
+            if enforce_newline and not text.endswith("\n"):
+                text += "\n"
+            stream.write(text)
+
+        # -- STEP DEFINITIONS:
+        @step('I write "{text}" to {stream_name:StreamName}')
+        def step_write_text_to_stdxxx(context, text, stream_name):
+            stream = getattr(sys, stream_name)
+            write_text_to(stream, text)
+
+        @step('I execute the following steps')
+        def step_execute_steps(context):
+            assert context.text, "REQUIRE: context.text"
+            context.execute_steps(context.text)
+            sys.stdout.write("STDOUT:AFTER-EXECUTE-STEPS\n")
+            sys.stderr.write("STDERR:AFTER-EXECUTE-STEPS\n")
+        """
+    And a file named "features/environment.py" with:
+        """
+        import sys
+
+        stdout_id = 0
+        stderr_id = 0
+
+        def stdout_print(text):
+            sys.__stdout__.write(text + "\n")
+
+        def inspect_stdout(context, scope, statement):
+            global stdout_id
+            stream_id = id(sys.stdout)
+            stream_class = sys.stdout.__class__.__name__
+            expected_id = stdout_id
+            if stream_id != expected_id:
+                name = statement.name
+                stdout_print("CHANGED-STDOUT %s:%s: stream.id=%s:%d (was: %d)" % \
+                            (scope, name, stream_class, stream_id, expected_id))
+                stdout_id = stream_id
+
+        def inspect_stderr(context, scope, statement):
+            global stderr_id
+            stream_id = id(sys.stderr)
+            stream_class = sys.stderr.__class__.__name__
+            expected_id = stderr_id
+            if stream_id != expected_id:
+                name = statement.name
+                stdout_print("CHANGED-STDERR %s:%s: stream.id=%s:%d (was: %d)" % \
+                            (scope, name, stream_class, stream_id, expected_id))
+                stderr_id = stream_id
+
+        def inspect_stdxxx(context, scope, statement):
+            inspect_stdout(context, scope, statement)
+            inspect_stderr(context, scope, statement)
+
+        def before_all(context):
+            context.config.setup_logging(filename="behave.log")
+
+        def before_scenario(context, scenario):
+            inspect_stdxxx(context, "before_scenario", scenario)
+
+        def after_scenario(context, scenario):
+            inspect_stdxxx(context, "after_scenario", scenario)
+            # -- ENSURE: Original streams are restored.
+            assert sys.stdout is sys.__stdout__
+            assert sys.stderr is sys.__stderr__
+            stdout_print("AFTER-SCENARIO %s: Streams are restored." % scenario.name)
+
+        def before_step(context, step):
+            inspect_stdxxx(context, "before_step", step)
+
+        def after_step(context, step):
+            inspect_stdxxx(context, "after_step", step)
+        """
+
+  Scenario: Stdout capture works with nested steps
+    Given a file named "features/stdout.failing_with_nested.feature" with
+        """
+        Feature:
+          Scenario: Failing with nested steps
+            Given I write "STDOUT:Hello Alice" to stdout
+            When  I write "STDOUT:Hello Bob" to stdout
+            Then  I execute the following steps:
+              '''
+              * I write "STDOUT:Hello nested.Alice" to stdout
+              * I write "STDOUT:Hello nested.Bob" to stdout
+              '''
+            And I write "STDOUT:Hello Charly" to stdout
+            And another step fails
+
+          Scenario: Another failing
+            Given I write "STDOUT:Hello Dora" to stdout
+            And another step fails
+        """
+    When I run "behave -f plain features/stdout.failing_with_nested.feature"
+    Then it should fail with:
+        """
+        0 scenarios passed, 2 failed, 0 skipped
+        5 steps passed, 2 failed, 0 skipped, 0 undefined
+        """
+    And note that "the summary is only shown if hooks have no errors"
+    And the command output should contain:
+        """
+        Captured stdout:
+        STDOUT:Hello Alice
+        STDOUT:Hello Bob
+        STDOUT:Hello nested.Alice
+        STDOUT:Hello nested.Bob
+        STDOUT:AFTER-EXECUTE-STEPS
+        STDOUT:Hello Charly
+        """
+    And the command output should contain:
+        """
+        Captured stdout:
+        STDOUT:Hello Dora
+        """
+    And the command output should contain:
+        """
+        AFTER-SCENARIO Failing with nested steps: Streams are restored.
+        """
+    And the command output should contain:
+        """
+        AFTER-SCENARIO Another failing: Streams are restored.
+        """
+
+  Scenario: Stderr capture works with nested steps
+    Given a file named "features/stderr.failing_with_nested.feature" with
+        """
+        Feature:
+          Scenario: Failing with nested steps
+            Given I write "STDERR:Hello Alice" to stderr
+            When  I write "STDERR:Hello Bob" to stderr
+            Then  I execute the following steps:
+              '''
+              * I write "STDERR:Hello nested.Alice" to stderr
+              * I write "STDERR:Hello nested.Bob" to stderr
+              '''
+            And I write "STDERR:Hello Charly" to stderr
+            And another step fails
+
+          Scenario: Another failing
+            Given I write "STDERR:Hello Dora" to stderr
+            And another step fails
+        """
+    When I run "behave -f plain features/stderr.failing_with_nested.feature"
+    Then it should fail with:
+        """
+        0 scenarios passed, 2 failed, 0 skipped
+        5 steps passed, 2 failed, 0 skipped, 0 undefined
+        """
+    And note that "the summary is only shown if hooks have no errors"
+    And the command output should contain:
+        """
+        Captured stderr:
+        STDERR:Hello Alice
+        STDERR:Hello Bob
+        STDERR:Hello nested.Alice
+        STDERR:Hello nested.Bob
+        STDERR:AFTER-EXECUTE-STEPS
+        STDERR:Hello Charly
+        """
+    And the command output should contain:
+        """
+        Captured stderr:
+        STDERR:Hello Dora
+        """
+    And the command output should contain:
+        """
+        AFTER-SCENARIO Failing with nested steps: Streams are restored.
+        """
+    And the command output should contain:
+        """
+        AFTER-SCENARIO Another failing: Streams are restored.
+        """