busser-behave 0.1.3

data/vendor/behave/features/step_param.builtin_types.with_integer.feature

@@ -0,0 +1,305 @@
+@sequential
+Feature: Parse integer data types in step parameters (type transformation)
+
+  As a test writer
+  I want write steps with parameter that should have integer data types
+  So that I can just use the step parameter with the correct type
+
+
+  Behave uses the parse module (inverse of Python string.format).
+  Therefore, the following ``parse types`` for integer numbers are already supported:
+
+    ===== =========================================== ============= ================================
+    Type  Characters Matched (regex class)            Output Type   Example(s)
+    ===== =========================================== ============= ================================
+     d     Digits (effectively integer numbers)        int           12345  0b101  0o761  0x1ABE
+     n     Numbers with thousands separators (, or .)  int           12,345
+     b     Binary numbers                              int           10111  0b1011
+     o     Octal numbers                               int           07654  0o123
+     x     Hexadecimal numbers (lower and upper case)  int           DEADBEAF  0xBEEF
+    ===== =========================================== ============= ================================
+
+    SEE ALSO:
+      * http://pypi.python.org/pypi/parse
+      * string.format: http://docs.python.org/library/string.html#format-string-syntax
+
+
+  @setup
+  Scenario: Feature Setup
+    Given a new working directory
+    And a file named "features/steps/integer_param_steps.py" with:
+        """
+        from behave import then, step
+        from six import integer_types
+
+        class NotMatched(object): pass
+
+        @step('a integer param with "{value:d}"')
+        def step_integer_param_with(context, value):
+            assert isinstance(value, integer_types), "value.type=%s" % type(value)
+            context.value = value
+
+        @step('a integer param with "{value}"')
+        def step_integer_param_otherwise(context, value):
+            context.value = NotMatched
+
+        @step('a number param with "{value:n}"')
+        def step_number_param_with(context, value):
+            step_integer_param_with(context, value)
+
+        @step('a number param with "{value}"')
+        def step_number_param_otherwise(context, value):
+            step_integer_param_otherwise(context, value)
+
+        @step('a binary number param with "{value:b}"')
+        def step_binary_param_with(context, value):
+            step_integer_param_with(context, value)
+
+        @step('a binary number param with "{value}"')
+        def step_binary_param_otherwise(context, value):
+            step_integer_param_otherwise(context, value)
+
+        @step('a octal number param with "{value:o}"')
+        def step_hexadecimal_param_with(context, value):
+            step_integer_param_with(context, value)
+
+        @step('a octal number param with "{value}"')
+        def step_hexadecimal_param_otherwise(context, value):
+            step_integer_param_otherwise(context, value)
+
+        @step('a hexadecimal number param with "{value:x}"')
+        def step_hexadecimal_param_with(context, value):
+            step_integer_param_with(context, value)
+
+        @step('a hexadecimal number param with "{value}"')
+        def step_hexadecimal_param_otherwise(context, value):
+            step_integer_param_otherwise(context, value)
+
+        @then('the value should be {outcome} as integer number')
+        def step_value_should_be_matched_as_number(context, outcome):
+            if outcome == "matched":
+                assert isinstance(context.value, integer_types), \
+                        "Unexpected type: %s" % type(context.value)
+            else:
+                assert context.value is NotMatched
+
+        @then('the value should be {outcome} as integer number with "{expected:d}"')
+        def step_value_should_be_matched_as_number_with_expected(context, outcome, expected):
+            step_value_should_be_matched_as_number(context, outcome)
+            assert context.value == expected, \
+                "FAILED: value(%s) == expected(%s)" % (context.value, expected)
+        """
+
+
+  Scenario: Use type "d" (Digits) for integer params
+    Given a file named "features/example.int_param.with_type_d.feature" with:
+        """
+        Feature: Use type "d" (Digits) for integer params
+
+          Scenario Outline: Good cases
+            Given a integer param with "<Value>"
+            Then the value should be matched as integer number with "<Expected Value>"
+
+          Examples:
+            | Value  | Expected Value | Case |
+            |  -1    |   -1 | Negative number |
+            |  +1    |    1 | With plus sign  |
+            |   0    |    0 |   |
+            |   1    |    1 |   |
+            |  10    |   10 |   |
+            |  42    |   42 |   |
+
+
+          Scenario Outline: Bad cases (not matched)
+            Given a integer param with "<Value>"
+            Then the value should be <Outcome> as integer number
+
+          Examples:
+            | Value  | Outcome     | Reason |
+            |  1.23  | not-matched | Float number |
+            |  1E+2  | not-matched | Float number |
+            |  Alice | not-matched | Not a number |
+
+
+          Scenario Outline: Conversion from other number system (base=2, 8, 16)
+            Given a integer param with "<Value>"
+            Then the value should be matched as integer number with "<Expected Value>"
+
+          Examples:
+            | Value   | Expected Value | Case |
+            |  0b1011 |    11 | Binary number |
+            |  0o123  |    83 | Octal number  |
+            |  0xBEEF | 48879 | Hexadecimal number |
+        """
+    When I run "behave -f plain features/example.int_param.with_type_d.feature"
+    Then it should pass with:
+        """
+        12 scenarios passed, 0 failed, 0 skipped
+        """
+
+  Scenario: Use type "n" (Number) for integer params
+
+    This data type supports numbers with thousands separators (',' or '.').
+
+    Given a file named "features/example.int_param.with_type_n.feature" with:
+        """
+        Feature: Use type "n" (Number) for integer params
+
+          Scenario Outline: Good cases
+            Given a number param with "<Value>"
+            Then the value should be matched as integer number with "<Expected Value>"
+
+          Examples:
+            | Value       | Expected Value |
+            |          -1 |       -1 |
+            |           0 |        0 |
+            |           1 |        1 |
+            |          10 |       10 |
+            |      12.345 |    12345 |
+            |      12,543 |    12543 |
+            |  12,345.678 | 12345678 |
+            |  12.345,678 | 12345678 |
+
+
+          Scenario Outline: Bad cases (not matched)
+            Given a number param with "<Value>"
+            Then the value should be <Outcome> as integer number
+
+          Examples:
+            | Value   | Outcome     | Reason |
+            |  123.34 | not-matched | Separator in wrong position |
+            |  1.23   | not-matched | Float number or separator in wrong position |
+            |  1E+2   | not-matched | Float number |
+            |  Alice  | not-matched | Not a number |
+        """
+    When I run "behave -f plain features/example.int_param.with_type_n.feature"
+    Then it should pass with:
+        """
+        12 scenarios passed, 0 failed, 0 skipped
+        """
+
+  Scenario: Use type "b" (Binary Number) for integer params
+    Given a file named "features/example.int_param.with_type_b.feature" with:
+        """
+        Feature: Use type "b" (Binary number) for integer params
+
+          Scenario Outline: Good cases
+            Given a binary number param with "<Value>"
+            Then the value should be matched as integer number with "<Expected Value>"
+
+          Examples:
+            | Value    | Expected Value | Case |
+            |        0 |    0 |                |
+            |        1 |    1 |                |
+            |       10 |    2 |                |
+            |       11 |    3 |                |
+            |      100 |    4 |                |
+            |      101 |    5 |                |
+            |     0111 |    7 | With padded, leading zero      |
+            |   0b1001 |    9 | With binary number prefix "0b" |
+            |   0b1011 |   11 | With binary number prefix "0b" |
+            | 10000000 |  128 | Larger binary number |
+
+          Scenario Outline: Bad cases (not matched)
+            Given a binary number param with "<Value>"
+            Then the value should be <Outcome> as integer number
+
+          Examples:
+            | Value  | Outcome     | Reason |
+            |    21  | not-matched | Invalid binary number |
+            |  0b21  | not-matched | Invalid binary number with binary number prefix |
+            |  1.23  | not-matched | Float number |
+            |  1E+2  | not-matched | Float number |
+            |  Alice | not-matched | Not a number |
+        """
+    When I run "behave -f plain features/example.int_param.with_type_b.feature"
+    Then it should pass with:
+        """
+        15 scenarios passed, 0 failed, 0 skipped
+        """
+
+  Scenario: Use type "o" (octal number) for integer params
+    Given a file named "features/example.int_param.with_type_o.feature" with:
+        """
+        Feature: Use type "o" (octal number) for integer params
+
+          Scenario Outline: Good cases
+            Given a octal number param with "<Value>"
+            Then the value should be matched as integer number with "<Expected Value>"
+
+          Examples:
+            | Value    | Expected Value | Case |
+            |        0 |    0 |                |
+            |       12 |   10 |                |
+            |       21 |   17 |                |
+            |       65 |   53 |                |
+            |      123 |   83 |                |
+            |      0o1 |    1 | With leading octal prefix |
+            |     0o12 |   10 |                |
+            |     0o21 |   17 |                |
+
+
+          Scenario Outline: Bad cases (not matched)
+            Given a octal number param with "<Value>"
+            Then the value should be <Outcome> as integer number
+
+          Examples:
+            | Value  | Outcome     | Reason |
+            |     8  | not-matched | Invalid octal number |
+            |    81  | not-matched | Invalid octal number |
+            |  0o81  | not-matched | Invalid octal number with octal number prefix |
+            |  1.23  | not-matched | Float number |
+            |  1E+2  | not-matched | Float number |
+            |  Alice | not-matched | Not a number |
+        """
+    When I run "behave -f plain features/example.int_param.with_type_o.feature"
+    Then it should pass with:
+        """
+        14 scenarios passed, 0 failed, 0 skipped
+        """
+
+  Scenario: Use type "x" (hexadecimal number) for integer params
+    Given a file named "features/example.int_param.with_type_x.feature" with:
+        """
+        Feature: Use type "x" (hexadecimal number) for integer params
+
+          Scenario Outline: Good cases: <Value>
+            Given a hexadecimal number param with "<Value>"
+            Then the value should be matched as integer number with "<Expected Value>"
+
+          Examples:
+            | Value    | Expected Value | Case       |
+            |        0 |          0 |                |
+            |       12 |         18 |                |
+            |       21 |         33 |                |
+            |       65 |        101 |                |
+            |      123 |        291 |                |
+            |     beef |      48879 | With hexadecimal letters (lowercase)  |
+            |     BEEF |      48879 | With hexadecimal letters (uppercase)  |
+            | deadbeef | 3735928559 | Larger hex number              |
+            | DeadBeef | 3735928559 | Larger hex number (mixed case) |
+            |     0x01 |          1 | With hexadecimal prefix |
+            |     0x12 |         18 |                |
+            |     0x21 |         33 |                |
+            |   0xbeef |      48879 |                |
+            |   0xBeEF |      48879 |                |
+
+
+          Scenario Outline: Bad cases (not matched)
+            Given a hexadecimal number param with "<Value>"
+            Then the value should be <Outcome> as integer number
+
+          Examples:
+            | Value  | Outcome     | Reason |
+            |     G  | not-matched | Invalid hex digit |
+            |    G1  | not-matched | Invalid hex number |
+            |  0x1G  | not-matched | Invalid hex number with hex number prefix |
+            |  1.23  | not-matched | Float number |
+            |  1E+2  | not-matched | Float number |
+            |  Alice | not-matched | Not a number |
+        """
+    When I run "behave -f plain features/example.int_param.with_type_x.feature"
+    Then it should pass with:
+        """
+        20 scenarios passed, 0 failed, 0 skipped
+        """

data/vendor/behave/features/step_param.custom_types.feature

@@ -0,0 +1,134 @@
+@sequential
+@todo
+Feature: Parse custom data types in step parameters (type transformation)
+
+  As a test writer
+  I want to provide own type parsers (and matcher)
+  to simplify writing step definitions.
+
+  . WORKS ONLY WITH MATCHERS:
+  .   * parse
+  .   * cfparse (parse with cardinality field extension)
+
+
+  @setup
+  Scenario: Feature Setup
+    Given a new working directory
+    And a file named "features/steps/type_converter_steps.py" with:
+        """
+        from behave import then, step, register_type
+        import parse
+
+        @parse.with_pattern(r"\d+")  # -- ONLY FOR: Zero and positive integers.
+        def parse_number(text):
+            return int(text)
+
+        register_type(Number=parse_number)
+        class NotMatched(object): pass
+
+        @step('a param with "Number:{value:Number}"')
+        def step_param_with_number_value(context, value):
+            assert isinstance(value, int)
+            context.value = value
+
+        @step('a param with "{type:w}:{value}"')
+        def step_param_with_unknown_type_value(context, type, value):
+            context.value = NotMatched
+
+        @then('the param should be "{outcome}"')
+        def step_value_should_be_matched_or_not_matched(context, outcome):
+            if outcome == "matched":
+                assert isinstance(context.value, int), \
+                        "Unexpected type: %s" % type(context.value)
+                assert context.value is not NotMatched
+            elif outcome == "not matched":
+                assert context.value is NotMatched
+            else:
+              raise ValueError("INVALID: outcome=%s (use: matched, not matched)" % outcome)
+        """
+    And a file named "features/steps/common_steps.py" with:
+        """
+        from behave4cmd0 import passing_steps
+        """
+    And a file named "behave.ini" with:
+        """
+        [behave]
+        show_skipped = false
+        show_timings = false
+        """
+
+
+  Scenario: Use own custom type for numbers
+    Given a file named "features/example.number_type.feature" with:
+        """
+        Feature: Simple Custom Type for Numbers
+
+          Scenario Outline: Numbers
+            Given a param with "Number:<value>"
+            Then the param should be "<outcome>"
+
+          Examples: Good cases for type=Number
+            | value  | outcome | Case |
+            |   0    | matched | Zero |
+            |   1    | matched | One  |
+            |  10    | matched | Positive number with 2 digits.  |
+            |  42    | matched | Another positive number. |
+
+          Examples: Bad cases for type=Number
+            | value  | outcome     | Case |
+            |  +1    | not matched | Positive number with plus sign. |
+            |  -1    | not matched | Negative number. |
+            | 1.234  | not matched | BAD: Floating-point number. |
+            | ABC    | not matched | BAD: Not a number. |
+        """
+    When I run "behave -f plain features/example.number_type.feature"
+    Then it should pass with:
+        """
+        8 scenarios passed, 0 failed, 0 skipped
+        """
+
+
+  Scenario: Type conversion fails
+    Given a file named "features/steps/bad_type_converter_steps.py" with:
+        """
+        from behave import step, register_type
+        import parse
+
+        @parse.with_pattern(r".*")  # -- NOTE: Wildcard pattern, accepts anything.
+        def parse_fails(text):
+            raise ValueError(text)
+
+        register_type(BadType=parse_fails)
+
+        @step('a param with "BadType:{value:BadType}"')
+        def step_param_with_badtype_value(context, value):
+            assert False, "SHOULD_NEVER_COME_HERE: BadType converter raises error."
+        """
+    And a file named "features/example.type_conversion_fails.feature" with:
+        """
+        Feature: Type Conversion Fails
+          Scenario: BadType raises ValueError during type conversion
+            Given a param with "BadType:BAD_VALUE"
+
+          Scenario: Ensure other scenarios are executed
+            Then another step passes
+        """
+    When I run "behave -f plain features/example.type_conversion_fails.feature"
+    Then it should fail with:
+        """
+        1 scenario passed, 1 failed, 0 skipped
+        1 step passed, 1 failed, 0 skipped, 0 undefined
+        """
+    And the command output should contain:
+        """
+        Scenario: BadType raises ValueError during type conversion
+          Given a param with "BadType:BAD_VALUE" ... failed
+        Traceback (most recent call last):
+        """
+    And the command output should contain:
+        """
+        File "features/steps/bad_type_converter_steps.py", line 6, in parse_fails
+          raise ValueError(text)
+        """
+    And the command output should contain "ValueError: BAD_VALUE"
+    And the command output should contain "StepParseError: BAD_VALUE"

data/vendor/behave/features/steps/behave_active_tags_steps.py

@@ -0,0 +1,86 @@
+# -*- coding: UTF-8 -*-
+"""
+
+.. code-block:: gherkin
+
+    Given I setup the current values for active tags with:
+        | category | value |
+        | foo      | xxx   |
+    Then the following active tag combinations are enabled:
+        | tags                        | enabled? |
+        | @active.with_foo=xxx        | yes      |
+        | @active.with_foo=other      | no       |
+
+"""
+
+from behave import given, when, then, step
+from behave.tag_matcher import ActiveTagMatcher
+from behave.tag_expression import TagExpression
+from behave.userdata import parse_bool
+from hamcrest import assert_that, equal_to
+
+
+# -----------------------------------------------------------------------------
+# UTILITY FUNCTIONS:
+# -----------------------------------------------------------------------------
+def normalize_tags(tags):
+    # -- STRIP: Leading '@' from tags.
+    return [TagExpression.normalize_tag(tag)  for tag in tags]
+
+
+# -----------------------------------------------------------------------------
+# STEP DEFINITIONS:
+# -----------------------------------------------------------------------------
+@given(u'I setup the current values for active tags with')
+def step_given_setup_the_current_values_for_active_tags_with(context):
+    assert context.table, "REQUIRE: table"
+    context.table.require_columns(["category", "value"])
+
+    active_values = getattr(context, "active_value_provider", None)
+    if active_values is None:
+        # -- SETUP DATA:
+        context.active_value_provider = active_values = {}
+
+    for row in context.table.rows:
+        category = row["category"]
+        value = row["value"]
+        active_values[category] = value
+
+
+@then(u'the following active tag combinations are enabled')
+def step_then_following_active_tags_combinations_are_enabled(context):
+    assert context.table, "REQUIRE: table"
+    assert context.active_value_provider, "REQUIRE: active_value_provider"
+    context.table.require_columns(["tags", "enabled?"])
+    ignore_unknown_categories = getattr(context,
+        "active_tags_ignore_unknown_categories",
+        ActiveTagMatcher.ignore_unknown_categories)
+
+    table = context.table
+    annotate_column_id = 0
+    active_tag_matcher = ActiveTagMatcher(context.active_value_provider)
+    active_tag_matcher.ignore_unknown_categories = ignore_unknown_categories
+    mismatched_rows = []
+    for row_index, row in enumerate(table.rows):
+        tags = normalize_tags(row["tags"].split())
+        expected_enabled = parse_bool(row["enabled?"])
+        actual_enabled = active_tag_matcher.should_run_with(tags)
+
+        if actual_enabled != expected_enabled:
+            # -- ANNOTATE MISMATCH IN EXTRA COLUMN:
+            if annotate_column_id == 0:
+                annotate_column_id = table.ensure_column_exists("MISMATCH!")
+            row.cells[annotate_column_id] = "= %s" % actual_enabled
+            mismatched_rows.append(row_index)
+
+    # -- FINALLY: Ensure that there are no mismatched rows.
+    assert_that(mismatched_rows, equal_to([]), "No mismatched rows:")
+
+
+@step(u'unknown categories are ignored in active tags')
+def step_unknown_categories_are_ignored_in_active_tags(context):
+    context.active_tags_ignore_unknown_categories = True
+
+@step(u'unknown categories are not ignored in active tags')
+def step_unknown_categories_are_not_ignored_in_active_tags(context):
+    context.active_tags_ignore_unknown_categories = False