busser-behave 0.1.3

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

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""
+Step definition for Context object tests.
+
+EXAMPLE
+    Scenario: Show that Context parameter
+      Given I set the parameter "person" to "Alice" in the behave context
+      Then the behave context should have a parameter named "person"
+      And  the behave context object should contain:
+        | Parameter | Value   |
+        | person    | "Alice" |
+
+    Scenario: Show that Context parameter are not present in next scenario
+      Then the behave context should not have a parameter named "person"
+"""
+
+from __future__ import absolute_import
+from behave import given, then, step
+from hamcrest import assert_that, equal_to
+import six
+
+# -----------------------------------------------------------------------------
+# STEPS:
+# -----------------------------------------------------------------------------
+@step(u'I set the context parameter "{param_name}" to "{value}"')
+def step_set_behave_context_parameter_to(context, param_name, value):
+    setattr(context, param_name, value)
+
+@step(u'the parameter "{param_name}" exists in the behave context')
+def step_behave_context_parameter_exists(context, param_name):
+    assert hasattr(context, param_name)
+
+@step(u'the parameter "{param_name}" does not exist in the behave context')
+def step_behave_context_parameter_not_exists(context, param_name):
+    assert not hasattr(context, param_name)
+
+@given(u'the behave context has a parameter "{param_name}"')
+def given_behave_context_has_parameter_named(context, param_name):
+    step_behave_context_parameter_exists(context, param_name)
+
+@given(u'the behave context does not have a parameter "{param_name}"')
+def given_behave_context_does_not_have_parameter_named(context, param_name):
+    step_behave_context_parameter_not_exists(context, param_name)
+
+@step(u'the behave context should have a parameter "{param_name}"')
+def step_behave_context_should_have_parameter_named(context, param_name):
+    step_behave_context_parameter_exists(context, param_name)
+
+@step(u'the behave context should not have a parameter "{param_name}"')
+def step_behave_context_should_not_have_parameter_named(context, param_name):
+    step_behave_context_parameter_not_exists(context, param_name)
+
+@then(u'the behave context should contain')
+def then_behave_context_should_contain_with_table(context):
+    assert context.table, "ENSURE: table is provided."
+    for row in context.table.rows:
+        param_name  = row["Parameter"]
+        param_value = row["Value"]
+        if param_value.startswith('"') and param_value.endswith('"'):
+            param_value = param_value[1:-1]
+        actual = six.text_type(getattr(context, param_name, None))
+        assert hasattr(context, param_name)
+        assert_that(actual, equal_to(param_value))
+
+@given(u'the behave context contains')
+def given_behave_context_contains_with_table(context):
+    then_behave_context_should_contain_with_table(context)

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

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""
+Provides step definitions that test tag logic for selected features, scenarios.
+
+.. code-block:: Gherkin
+
+    # -- Scenario: Select scenarios with tags
+    Given I use the behave model builder with:
+        | statement  | name   | tags      | Comment |
+        | Scenario   | A1     | @foo      |          |
+        | Scenario   | A3     | @foo @bar |          |
+        | Scenario   | B3     |           | Untagged |
+    When I run the behave with tags
+    Then the following scenarios are selected with cmdline:
+        | cmdline                    | selected           | Logic comment |
+        | --tags=@foo                | A1, A3, B2         | @foo          |
+        | --tags=-@foo               | A1, A3, B2         | @foo          |
+
+.. code-block:: Gherkin
+
+    # IDEA:
+    # -- Scenario: Select scenarios with tags
+    Given I use the behave model builder with:
+        | statement  | name   | tags      | Comment |
+        | Feature    | Alice  | @alice    |          |
+        | Scenario   | A1     | @foo      |          |
+        | Scenario   | A2     | @bar      |          |
+        | Scenario   | A3     | @foo @bar |          |
+        | Feature    | Bob    | @bob      |          |
+        | Scenario   | B1     | @bar      |          |
+        | Scenario   | B2     | @foo      |          |
+        | Scenario   | B3     |           | Untagged |
+    When I run the behave with options "--tags=@foo"
+    Then the following scenarios are selected:
+        | statement  | name   | selected  |
+        | Scenario   | A1     | yes       |
+        | Scenario   | A2     | no        |
+        | Scenario   | A3     | yes       |
+        | Scenario   | B1     | no        |
+        | Scenario   | B2     | yes       |
+        | Scenario   | B3     | no        |
+"""
+
+from __future__ import absolute_import
+from behave import given, when, then
+from behave_model_util import BehaveModelBuilder, convert_comma_list
+from behave_model_util import \
+    run_model_with_cmdline, collect_selected_and_skipped_scenarios
+from hamcrest import assert_that, equal_to
+
+
+# -----------------------------------------------------------------------------
+# STEP DEFINITIONS:
+# -----------------------------------------------------------------------------
+@given('a behave model with')
+def step_given_a_behave_model_with_table(context):
+    """
+    Build a behave feature model from a tabular description.
+
+    .. code-block:: gherkin
+
+        # -- Scenario: Select scenarios with tags
+        Given I use the behave model builder with:
+            | statement  | name   | tags      | Comment |
+            | Scenario   | S0     |           | Untagged |
+            | Scenario   | S1     | @foo      |          |
+            | Scenario   | S3     | @foo @bar |          |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(BehaveModelBuilder.REQUIRED_COLUMNS)
+    model_builder = BehaveModelBuilder()
+    context.behave_model = model_builder.build_model_from_table(context.table)
+
+
+@when('I run the behave model with "{hint}"')
+def step_when_run_behave_model_with_hint(context, hint):
+    pass    # -- ONLY: SYNTACTIC SUGAR
+
+
+@then('the following scenarios are selected with cmdline')
+def step_then_scenarios_are_selected_with_cmdline(context):
+    """
+    .. code-block:: Gherkin
+
+        Then the following scenarios are selected with cmdline:
+            | cmdline      | selected?    | Logic comment |
+            | --tags=@foo  | A1, A3, B2   | @foo          |
+    """
+    assert context.behave_model, "REQUIRE: context attribute"
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["cmdline", "selected?"])
+
+    model = context.behave_model
+    for row_index, row in enumerate(context.table.rows):
+        cmdline = row["cmdline"]
+        expected_selected_names = convert_comma_list(row["selected?"])
+
+        # -- STEP: Run model with cmdline tags
+        run_model_with_cmdline(model, cmdline)
+        selected, skipped = collect_selected_and_skipped_scenarios(model)
+        actual_selected = [scenario.name  for scenario in selected]
+
+        # -- CHECK:
+        assert_that(actual_selected, equal_to(expected_selected_names),
+                    "cmdline=%s (row=%s)" % (cmdline, row_index))

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

@@ -0,0 +1,105 @@
+# -*- coding: UTF-8 -*-
+
+from __future__ import absolute_import
+from behave.model import Feature, Scenario, reset_model
+from behave.model_core import Status
+from behave.runner import ModelRunner
+from behave.parser import parse_tags
+from behave.configuration import Configuration
+
+
+# -----------------------------------------------------------------------------
+# TYPE CONVERTERS:
+# -----------------------------------------------------------------------------
+def convert_comma_list(text):
+    text = text.strip()
+    return [part.strip()  for part in text.split(",")]
+
+def convert_model_element_tags(text):
+    return parse_tags(text.strip())
+
+
+# -----------------------------------------------------------------------------
+# TEST DOMAIN, FIXTURES, STEP UTILS:
+# -----------------------------------------------------------------------------
+class Model(object):
+    def __init__(self, features=None):
+        self.features = features or []
+
+class BehaveModelBuilder(object):
+    REQUIRED_COLUMNS = ["statement", "name"]
+    OPTIONAL_COLUMNS = ["tags"]
+
+    def __init__(self):
+        self.features = []
+        self.current_feature = None
+        self.current_scenario = None
+
+    def build_feature(self, name=u"", tags=None):
+        if not name:
+            name = u"alice"
+        filename = u"%s.feature" % name
+        line = 1
+        feature = Feature(filename, line, u"Feature", name, tags=tags)
+        self.features.append(feature)
+        self.current_feature = feature
+        return feature
+
+    def build_scenario(self, name="", tags=None):
+        if not self.current_feature:
+            self.build_feature()
+        filename = self.current_feature.filename
+        line = self.current_feature.line + 1
+        scenario = Scenario(filename, line, u"Scenario", name, tags=tags)
+        self.current_feature.add_scenario(scenario)
+        self.current_scenario = scenario
+        return scenario
+
+    def build_unknown(self, statement, name=u"", row_index=None):
+        # pylint: disable=no-self-use
+        assert False, u"UNSUPPORTED: statement=%s, name=%s (row=%s)" % \
+                      (statement, name, row_index)
+
+    def build_model_from_table(self, table):
+        table.require_columns(self.REQUIRED_COLUMNS)
+        for row_index, row in enumerate(table.rows):
+            statement = row["statement"]
+            name = row["name"]
+            tags = row.get("tags", [])
+            if tags:
+                tags = convert_model_element_tags(tags)
+
+            if statement == "Feature":
+                self.build_feature(name, tags)
+            elif statement == "Scenario":
+                self.build_scenario(name, tags)
+            else:
+                self.build_unknown(statement, name, row_index=row_index)
+        return Model(self.features)
+
+def run_model_with_cmdline(model, cmdline):
+    reset_model(model.features)
+    command_args = cmdline
+    config = Configuration(command_args,
+                           load_config=False,
+                           default_format="null",
+                           stdout_capture=False,
+                           stderr_capture=False,
+                           log_capture=False)
+    model_runner = ModelRunner(config, model.features)
+    return model_runner.run()
+
+def collect_selected_and_skipped_scenarios(model):  # pylint: disable=invalid-name
+    selected = []
+    skipped = []
+    for feature in model.features:
+        scenarios = feature.scenarios
+        for scenario in scenarios:
+            if scenario.status == Status.skipped:
+                skipped.append(scenario)
+            else:
+                assert scenario.status != Status.untested
+                selected.append(scenario)
+    return (selected, skipped)
+
+

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

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""
+Provides step definitions that test how the behave runner selects feature files.
+
+EXAMPLE:
+    Given behave has the following feature fileset:
+      '''
+      features/alice.feature
+      features/bob.feature
+      features/barbi.feature
+      '''
+    When behave includes feature files with "features/a.*\.feature"
+    And  behave excludes feature files with "features/b.*\.feature"
+    Then the following feature files are selected:
+      '''
+      features/alice.feature
+      '''
+"""
+
+from __future__ import absolute_import
+from behave import given, when, then
+from behave.runner_util import FeatureListParser
+from hamcrest import assert_that, equal_to
+from copy import copy
+import re
+import six
+
+# -----------------------------------------------------------------------------
+# STEP UTILS:
+# -----------------------------------------------------------------------------
+class BasicBehaveRunner(object):
+    def __init__(self, config=None):
+        self.config = config
+        self.feature_files = []
+
+    def select_files(self):
+        """
+        Emulate behave runners file selection by using include/exclude patterns.
+        :return: List of selected feature filenames.
+        """
+        selected = []
+        for filename in self.feature_files:
+            if not self.config.exclude(filename):
+                selected.append(six.text_type(filename))
+        return selected
+
+# -----------------------------------------------------------------------------
+# STEP DEFINITIONS:
+# -----------------------------------------------------------------------------
+@given('behave has the following feature fileset')
+def step_given_behave_has_feature_fileset(context):
+    assert context.text is not None, "REQUIRE: text"
+    behave_runner = BasicBehaveRunner(config=copy(context.config))
+    behave_runner.feature_files = FeatureListParser.parse(context.text)
+    context.behave_runner = behave_runner
+
+@when('behave includes all feature files')
+def step_when_behave_includes_all_feature_files(context):
+    assert context.behave_runner, "REQUIRE: context.behave_runner"
+    context.behave_runner.config.include_re = None
+
+@when('behave includes feature files with "{pattern}"')
+def step_when_behave_includes_feature_files_with_pattern(context, pattern):
+    assert context.behave_runner, "REQUIRE: context.behave_runner"
+    context.behave_runner.config.include_re = re.compile(pattern)
+
+@when('behave excludes no feature files')
+def step_when_behave_excludes_no_feature_files(context):
+    assert context.behave_runner, "REQUIRE: context.behave_runner"
+    context.behave_runner.config.exclude_re = None
+
+@when('behave excludes feature files with "{pattern}"')
+def step_when_behave_excludes_feature_files_with_pattern(context, pattern):
+    assert context.behave_runner, "REQUIRE: context.behave_runner"
+    context.behave_runner.config.exclude_re = re.compile(pattern)
+
+@then('the following feature files are selected')
+def step_then_feature_files_are_selected_with_text(context):
+    assert context.text is not None, "REQUIRE: text"
+    assert context.behave_runner, "REQUIRE: context.behave_runner"
+    selected_files = context.text.strip().splitlines()
+    actual_files = context.behave_runner.select_files()
+    assert_that(actual_files, equal_to(selected_files))

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

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""
+Provides step definitions that test tag expressions (and tag logic).
+
+.. code-block:: gherkin
+
+    Given the default tags "-@foo"
+    And   the tag expression "@foo"
+    Then the tag expression selects elements with tags:
+        | tags         | selected? |
+        | @foo         |   yes     |
+        | @other       |   no      |
+
+.. code-block:: gherkin
+
+    Given the named model elements with tags:
+        | name | tags   |
+        | S1   | @foo   |
+    Then the tag expression select model elements with:
+        | tag expression | selected?    |
+        |  @foo          | S1, S3       |
+        | -@foo          | S0, S2, S3   |
+"""
+
+from __future__ import absolute_import
+from behave import given, then, register_type
+from behave.tag_expression import TagExpression
+from behave_model_util import convert_comma_list, convert_model_element_tags
+from hamcrest import assert_that, equal_to
+
+
+# -----------------------------------------------------------------------------
+# TEST DOMAIN, FIXTURES, STEP UTILS:
+# -----------------------------------------------------------------------------
+class ModelElement(object):
+    def __init__(self, name, tags=None):
+        self.name = name
+        self.tags = tags or []
+
+# -----------------------------------------------------------------------------
+# TYPE CONVERTERS:
+# -----------------------------------------------------------------------------
+def convert_tag_expression(text):
+    parts = text.strip().split()
+    return TagExpression(parts)
+register_type(TagExpression=convert_tag_expression)
+
+def convert_yesno(text):
+    text = text.strip().lower()
+    assert text in convert_yesno.choices
+    return text in convert_yesno.true_choices
+convert_yesno.choices = ("yes", "no", "true", "false")
+convert_yesno.true_choices = ("yes", "true")
+
+
+# -----------------------------------------------------------------------------
+# STEP DEFINITIONS:
+# -----------------------------------------------------------------------------
+@given('the tag expression "{tag_expression:TagExpression}"')
+def step_given_the_tag_expression(context, tag_expression):
+    """
+    Define a tag expression that is used later-on.
+
+    .. code-block:: gherkin
+
+        Given the tag expression "@foo"
+    """
+    context.tag_expression = tag_expression
+
+@given('the default tags "{default_tags:TagExpression}"')
+def step_given_the_tag_expression(context, default_tags):
+    """
+    Define a tag expression that is used later-on.
+
+    .. code-block:: gherkin
+
+        Given the tag expression "@foo"
+    """
+    context.default_tags = default_tags
+    tag_expression = getattr(context, "tag_expression", None)
+    if tag_expression is None:
+        context.tag_expression = default_tags
+
+@then('the tag expression selects elements with tags')
+def step_then_tag_expression_selects_elements_with_tags(context):
+    """
+    Checks if a tag expression selects an element with the given tags.
+
+    .. code-block:: gherkin
+        Then the tag expression selects elements with tags:
+            | tags         | selected? |
+            | @foo         |   yes     |
+            | @other       |   no      |
+    """
+    assert context.tag_expression, "REQUIRE: context.tag_expression"
+    context.table.require_columns(["tags", "selected?"])
+    tag_expression = context.tag_expression
+    expected = []
+    actual   = []
+    for row in context.table.rows:
+        element_tags = convert_model_element_tags(row["tags"])
+        expected_element_selected = convert_yesno(row["selected?"])
+        actual_element_selected = tag_expression.check(element_tags)
+        expected.append((element_tags, expected_element_selected))
+        actual.append((element_tags, actual_element_selected))
+
+    # -- PERFORM CHECK:
+    assert_that(actual, equal_to(expected))
+
+
+@given('the model elements with name and tags')
+def step_given_named_model_elements_with_tags(context):
+    """
+    .. code-block:: gherkin
+
+        Given the model elements with name and tags:
+            | name | tags   |
+            | S1   | @foo   |
+        Then the tag expression select model elements with:
+            | tag expression | selected?    |
+            |  @foo          | S1, S3       |
+            | -@foo          | S0, S2, S3   |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["name", "tags"])
+
+    # -- PREPARE:
+    model_element_names = set()
+    model_elements = []
+    for row in context.table.rows:
+        name = row["name"].strip()
+        tags = convert_model_element_tags(row["tags"])
+        assert name not in model_element_names, "DUPLICATED: name=%s" % name
+        model_elements.append(ModelElement(name, tags=tags))
+        model_element_names.add(name)
+
+    # -- SETUP:
+    context.model_elements = model_elements
+
+
+@then('the tag expression selects model elements with')
+def step_given_named_model_elements_with_tags(context):
+    """
+    .. code-block:: gherkin
+
+        Then the tag expression select model elements with:
+            | tag expression | selected?    |
+            |  @foo          | S1, S3       |
+            | -@foo          | S0, S2, S3   |
+    """
+    assert context.model_elements, "REQUIRE: context attribute"
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["tag expression", "selected?"])
+
+    for row_index, row in enumerate(context.table.rows):
+        tag_expression_text = row["tag expression"]
+        tag_expression = convert_tag_expression(tag_expression_text)
+        expected_selected_names = convert_comma_list(row["selected?"])
+
+        actual_selected = []
+        for model_element in context.model_elements:
+            if tag_expression.check(model_element.tags):
+                actual_selected.append(model_element.name)
+
+        assert_that(actual_selected, equal_to(expected_selected_names),
+            "tag_expression=%s (row=%s)" % (tag_expression_text, row_index))