busser-behave 0.1.3

data/vendor/behave/features/feature.exclude_from_run.feature

@@ -0,0 +1,96 @@
+Feature: Exclude Feature from Test Run
+
+    As a test writer
+    I want sometimes to decide at runtime
+    that a feature is excluded from a test run
+    So that the command-line configuration becomes simpler
+    (and auto-configuration is supported).
+
+    . MECHANISM:
+    .   The "before_feature()" hook can decide just before a feature should run
+    .   that the feature should be excluded from the test-run.
+    .   NOTE: Hooks are not called in dry-run mode.
+    .
+    . RATIONALE:
+    .   There are certain situations where it is better to skip a feature
+    .   than to run and fail the feature.
+    .
+    .   Reasons for these cases are of often test environment related:
+    .     * test environment does not fulfill the desired criteria
+    .     * used testbed does not fulfill test requirements
+    .
+    .   Instead of providing the exclude-feature selection on the command-line,
+    .   the test (environment) and configuration logic should determine
+    .   if a test should be excluded (as auto-configuration functionality).
+    .
+    . EXAMPLE:
+    .   Certain features should not run on Windows (or Linux, ...).
+    .
+    . EVALUATION ORDER:
+    .   Before the user can exclude a feature from a test-run,
+    .   additional mechanisms decide, if the feature is part of the selected run-set.
+    .   These are:
+    .     * tags
+    .     * ...
+    .
+    . RELATED:
+    .   * features/scenario.exclude_from_run.feature
+
+
+    @setup
+    Scenario:
+        Given a new working directory
+        And a file named "features/alice.feature" with:
+            """
+            Feature: Alice
+              Scenario: Alice in Wonderland
+                 Given a step passes
+                  When another step passes
+                  Then some step passes
+
+              Scenario: Alice and Bob
+                 Given another step passes
+            """
+        And a file named "features/bob.feature" with:
+            """
+            Feature: Bob
+              Scenario: Bob in Berlin
+                 Given some step passes
+                 When another step passes
+            """
+        And a file named "features/steps/steps.py" with:
+            """
+            from behave import step
+
+            @step('{word:w} step passes')
+            def step_passes(context, word):
+                pass
+            """
+
+
+    Scenario: Exclude a feature from the test run (using: before_feature() hook)
+        Given a file named "features/environment.py" with:
+            """
+            import sys
+
+            def should_exclude_feature(feature):
+                if "Alice" in feature.name:
+                    return True
+                return False
+
+            def before_feature(context, feature):
+                if should_exclude_feature(feature):
+                    sys.stdout.write("EXCLUDED-BY-USER: Feature %s\n" % feature.name)
+                    feature.skip()
+            """
+        When I run "behave -f plain -T features/"
+        Then it should pass with:
+            """
+            1 feature passed, 0 failed, 1 skipped
+            1 scenario passed, 0 failed, 2 skipped
+            2 steps passed, 0 failed, 4 skipped, 0 undefined
+            """
+        And the command output should contain:
+            """
+            EXCLUDED-BY-USER: Feature Alice
+            """

data/vendor/behave/features/formatter.help.feature

@@ -0,0 +1,30 @@
+Feature: Help Formatter
+
+  As a tester
+  I want to know which formatter are supported
+  To be able to select one.
+
+  Scenario:
+    Given a new working directory
+    When I run "behave --format=help"
+    Then it should pass
+    And the command output should contain:
+      """
+      Available formatters:
+        json           JSON dump of test run
+        json.pretty    JSON dump of test run (human readable)
+        null           Provides formatter that does not output anything.
+        plain          Very basic formatter with maximum compatibility
+        pretty         Standard colourised pretty formatter
+        progress       Shows dotted progress for each executed scenario.
+        progress2      Shows dotted progress for each executed step.
+        progress3      Shows detailed progress for each step of a scenario.
+        rerun          Emits scenario file locations of failing scenarios
+        sphinx.steps   Generate sphinx-based documentation for step definitions.
+        steps          Shows step definitions (step implementations).
+        steps.catalog  Shows non-technical documentation for step definitions.
+        steps.doc      Shows documentation for step definitions.
+        steps.usage    Shows how step definitions are used by steps.
+        tags           Shows tags (and how often they are used).
+        tags.location  Shows tags and the location where they are used.
+      """

data/vendor/behave/features/formatter.json.feature

@@ -0,0 +1,420 @@
+@sequential
+Feature: JSON Formatter
+
+    In order to process data with other tools
+    As a tester
+    I want that behave generates test run data in JSON format.
+
+
+    @setup
+    Scenario: Feature Setup
+        Given a new working directory
+        And a file named "features/steps/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-STEP"
+            """
+
+    Scenario: Use JSON formatter on simple feature
+        Given a file named "features/simple_feature_with_name.feature" with:
+            """
+            Feature: Simple, empty Feature
+            """
+        When I run "behave -f json.pretty features/simple_feature_with_name.feature"
+        Then it should pass with:
+            """
+            0 features passed, 0 failed, 1 skipped
+            0 scenarios passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            [
+              {
+                "keyword": "Feature",
+                "location": "features/simple_feature_with_name.feature:1",
+                "name": "Simple, empty Feature",
+                "status": "skipped",
+                "tags": []
+              }
+            ]
+            """
+
+    Scenario: Use JSON formatter on simple feature with description
+        Given a file named "features/simple_feature_with_description.feature" with:
+            """
+            Feature: Simple feature with description
+
+                First feature description line.
+                Second feature description line.
+
+                Third feature description line (following an empty line).
+            """
+        When I run "behave -f json.pretty features/simple_feature_with_description.feature"
+        Then it should pass with:
+            """
+            0 features passed, 0 failed, 1 skipped
+            0 scenarios passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            [
+              {
+                "description": [
+                  "First feature description line.",
+                  "Second feature description line.",
+                  "Third feature description line (following an empty line)."
+                ],
+                "keyword": "Feature",
+                "location": "features/simple_feature_with_description.feature:1",
+                "name": "Simple feature with description",
+                "status": "skipped",
+                "tags": []
+              }
+            ]
+            """
+
+    Scenario: Use JSON formatter on simple feature with tags
+        Given a file named "features/simple_feature_with_tags.feature" with:
+            """
+            @foo @bar
+            Feature: Simple feature with tags
+            """
+        When I run "behave -f json.pretty features/simple_feature_with_tags.feature"
+        Then it should pass with:
+            """
+            0 features passed, 0 failed, 1 skipped
+            0 scenarios passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            [
+              {
+                "keyword": "Feature",
+                "location": "features/simple_feature_with_tags.feature:2",
+                "name": "Simple feature with tags",
+                "status": "skipped",
+                "tags": [
+                  "foo",
+                  "bar"
+                ]
+              }
+            ]
+            """
+
+    Scenario: Use JSON formatter with feature and one scenario without steps
+        Given a file named "features/simple_scenario.feature" with:
+            """
+            Feature:
+              Scenario: Simple scenario without steps
+            """
+        When I run "behave -f json.pretty features/simple_scenario.feature"
+        Then it should pass with:
+            """
+            1 feature passed, 0 failed, 0 skipped
+            1 scenario passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            [
+              {
+                "elements": [
+                  {
+                    "keyword": "Scenario",
+                    "location": "features/simple_scenario.feature:2",
+                    "name": "Simple scenario without steps",
+                    "status": "passed",
+                    "steps": [],
+                    "tags": [],
+                    "type": "scenario"
+                  }
+                ],
+                "keyword": "Feature",
+                "location": "features/simple_scenario.feature:1",
+                "name": "",
+                "status": "passed",
+                "tags": []
+              }
+            ]
+            """
+
+    Scenario: Use JSON formatter with feature and one scenario with description
+        Given a file named "features/simple_scenario_with_description.feature" with:
+            """
+            Feature:
+              Scenario: Simple scenario with description but without steps
+
+                First scenario description line.
+                Second scenario description line.
+
+                Third scenario description line (after an empty line).
+            """
+        When I run "behave -f json.pretty features/simple_scenario_with_description.feature"
+        Then it should pass with:
+            """
+            1 feature passed, 0 failed, 0 skipped
+            1 scenario passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            [
+              {
+                "elements": [
+                  {
+                    "description": [
+                      "First scenario description line.",
+                      "Second scenario description line.",
+                      "Third scenario description line (after an empty line)."
+                    ],
+                    "keyword": "Scenario",
+                    "location": "features/simple_scenario_with_description.feature:2",
+                    "name": "Simple scenario with description but without steps",
+                    "status": "passed",
+                    "steps": [],
+                    "tags": [],
+                    "type": "scenario"
+                  }
+                ],
+                "keyword": "Feature",
+                "location": "features/simple_scenario_with_description.feature:1",
+                "name": "",
+                "status": "passed",
+                "tags": []
+              }
+            ]
+            """
+
+    Scenario: Use JSON formatter with feature and one scenario with tags
+        Given a file named "features/simple_scenario_with_tags.feature" with:
+            """
+            Feature:
+
+              @foo
+              @bar
+              Scenario: Simple scenario with tags but without steps
+            """
+        When I run "behave -f json.pretty features/simple_scenario_with_tags.feature"
+        Then it should pass with:
+            """
+            1 feature passed, 0 failed, 0 skipped
+            1 scenario passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            [
+              {
+                "elements": [
+                  {
+                    "keyword": "Scenario",
+                    "location": "features/simple_scenario_with_tags.feature:5",
+                    "name": "Simple scenario with tags but without steps",
+                    "status": "passed",
+                    "steps": [],
+                    "tags": [
+                      "foo",
+                      "bar"
+                    ],
+                    "type": "scenario"
+                  }
+                ],
+                "keyword": "Feature",
+                "location": "features/simple_scenario_with_tags.feature:1",
+                "name": "",
+                "status": "passed",
+                "tags": []
+              }
+            ]
+            """
+
+
+    Scenario: Use JSON formatter with type-converted step parameters
+
+      Ensure that step parameters (match arguments) leads to valid JSON
+      even when type converters are used which create non-simple types.
+
+      Given a file named "features/step_params_with_type_converter.feature" with:
+          """
+          Feature:
+            Scenario: Use type converter
+                Given "1+2j" as complex number
+                And "red" as color
+          """
+      And a file named "features/steps/type_converter_steps.py" with:
+          """
+          from behave import step, register_type
+          import parse
+
+          # -- TYPES AND TYPE CONVERTERS:
+          class Color(object):
+              def __init__(self, color_name):
+                  self.name = color_name
+
+          @parse.with_pattern("\w+")
+          def parse_color(text):
+              return Color(text.strip())
+
+          @parse.with_pattern(".+")
+          def parse_complex(text):
+              return complex(text)
+
+          register_type(Color=parse_color)
+          register_type(Complex=parse_complex)
+
+          # -- STEPS:
+          @step('"{number:Complex}" as complex number')
+          def step_complex_number(context, number):
+              context.number = number
+
+          @step('"{color:Color}" as color')
+          def step_color(context, color):
+              context.color = color
+          """
+      When I run "behave -f json.pretty features/step_params_with_type_converter.feature"
+      Then it should pass with:
+            """
+            1 scenario passed, 0 failed, 0 skipped
+            """
+      And the command output should contain:
+          """
+          "match": {
+            "arguments": [
+              {
+                "name": "number",
+                "value": "1+2j"
+              }
+            ],
+            "location": "features/steps/type_converter_steps.py:21"
+          },
+          "name": "\"1+2j\" as complex number",
+          """
+      And the command output should contain:
+          """
+          "match": {
+            "arguments": [
+              {
+                "name": "color",
+                "value": "red"
+              }
+            ],
+            "location": "features/steps/type_converter_steps.py:25"
+          },
+          "name": "\"red\" as color",
+          """
+      But note that "both matched arguments.values are provided as string"
+
+
+    @xfail
+    @regression_problem.with_duration
+    Scenario: Use JSON formatter with feature and one scenario with steps
+        Given a file named "features/scenario_with_steps.feature" with:
+            """
+            Feature:
+              Scenario: Simple scenario with with steps
+                  Given a step passes
+                  When a step passes
+                  Then a step passes
+                  And a step passes
+                  But a step passes
+            """
+        When I run "behave -f json.pretty features/scenario_with_steps.feature"
+        Then it should pass with:
+            """
+            1 feature passed, 0 failed, 0 skipped
+            1 scenario passed, 0 failed, 0 skipped
+            """
+        And the command output should contain:
+            """
+            "steps": [
+                {
+                  "keyword": "Given",
+                  "location": "features/scenario_with_steps.feature:2",
+                  "match": {
+                    "arguments": [],
+                    "location": "features/steps/steps.py:3"
+                  },
+                  "name": "a step passes",
+                  "result": {
+                    "duration": XXX,
+                    "status": "passed",
+                  }
+                  "step_type": "given",
+                },
+                {
+                  "keyword": "When",
+                  "location": "features/scenario_with_steps.feature:3",
+                  "match": {
+                    "arguments": [],
+                    "location": "features/steps/steps.py:3"
+                  },
+                  "name": "a step passes",
+                  "result": {
+                    "duration": XXX,
+                    "status": "passed",
+                  }
+                  "step_type": "when",
+                },
+                {
+                  "keyword": "Then",
+                  "location": "features/scenario_with_steps.feature:4",
+                  "match": {
+                    "arguments": [],
+                    "location": "features/steps/steps.py:3"
+                  },
+                  "name": "a step passes",
+                  "result": {
+                    "duration": XXX,
+                    "status": "passed",
+                  }
+                  "step_type": "then",
+                },
+                {
+                  "keyword": "And",
+                  "location": "features/scenario_with_steps.feature:5",
+                  "match": {
+                    "arguments": [],
+                    "location": "features/steps/steps.py:3"
+                  },
+                  "name": "a step passes",
+                  "result": {
+                    "duration": XXX,
+                    "status": "passed",
+                  }
+                  "step_type": "then",
+                },
+                {
+                  "keyword": "But",
+                  "location": "features/scenario_with_steps.feature:6",
+                  "match": {
+                    "arguments": [],
+                    "location": "features/steps/steps.py:3"
+                  },
+                  "name": "a step passes",
+                  "result": {
+                    "duration": XXX,
+                    "status": "passed",
+                  }
+                  "step_type": "then",
+                }
+            ],
+            """
+
+    @wip
+    Scenario: Use JSON formatter with feature and two scenarios
+
+    @wip
+    Scenario: Use JSON formatter with feature and background
+
+    @wip
+    Scenario: Use JSON formatter with feature and scenario outline without steps
+    Scenario: Use JSON formatter with feature and scenario outline with description
+    Scenario: Use JSON formatter with feature and scenario outline with tags
+    Scenario: Use JSON formatter with feature and scenario outline with steps
+    Scenario: Use JSON formatter with feature and scenario outline with steps and examples
+
+