busser-behave 0.1.3

data/vendor/behave/test/test_importer.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for behave.importing.
+The module provides a lazy-loading/importing mechanism.
+"""
+
+from __future__ import absolute_import
+from behave.importer import LazyObject, LazyDict, load_module, parse_scoped_name
+from behave.formatter.base import Formatter
+from nose.tools import eq_, assert_raises
+import sys
+import types
+# import unittest
+
+
+class TestTheory(object): pass
+class ImportModuleTheory(TestTheory):
+    """
+    Provides a test theory for importing modules.
+    """
+
+    @classmethod
+    def ensure_module_is_not_imported(cls, module_name):
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        cls.assert_module_is_not_imported(module_name)
+
+    @staticmethod
+    def assert_module_is_imported(module_name):
+        module = sys.modules.get(module_name, None)
+        assert module_name in sys.modules
+        assert module is not None
+
+    @staticmethod
+    def assert_module_is_not_imported(module_name):
+        assert module_name not in sys.modules
+
+    @staticmethod
+    def assert_module_with_name(module, name):
+        assert isinstance(module, types.ModuleType)
+        eq_(module.__name__, name)
+
+
+class TestLoadModule(object):
+    theory = ImportModuleTheory
+
+    def test_load_module__should_fail_for_unknown_module(self):
+        assert_raises(ImportError, load_module, "__unknown_module__")
+
+    def test_load_module__should_succeed_for_already_imported_module(self):
+        module_name = "behave.importer"
+        self.theory.assert_module_is_imported(module_name)
+
+        module = load_module(module_name)
+        self.theory.assert_module_with_name(module, module_name)
+        self.theory.assert_module_is_imported(module_name)
+
+    def test_load_module__should_succeed_for_existing_module(self):
+        module_name = "test._importer_candidate"
+        self.theory.ensure_module_is_not_imported(module_name)
+
+        module = load_module(module_name)
+        self.theory.assert_module_with_name(module, module_name)
+        self.theory.assert_module_is_imported(module_name)
+
+class TestLazyObject(object):
+
+    def test_get__should_succeed_for_known_object(self):
+        lazy = LazyObject("behave.importer", "LazyObject")
+        value = lazy.get()
+        assert value is LazyObject
+
+        lazy2 = LazyObject("behave.importer:LazyObject")
+        value2 = lazy2.get()
+        assert value2 is LazyObject
+
+        lazy3 = LazyObject("behave.formatter.steps", "StepsFormatter")
+        value3 = lazy3.get()
+        assert issubclass(value3, Formatter)
+
+    def test_get__should_fail_for_unknown_module(self):
+        lazy = LazyObject("__unknown_module__", "xxx")
+        assert_raises(ImportError, lazy.get)
+
+    def test_get__should_fail_for_unknown_object_in_module(self):
+        lazy = LazyObject("test._importer_candidate", "xxx")
+        assert_raises(ImportError, lazy.get)
+
+
+class LazyDictTheory(TestTheory):
+
+    @staticmethod
+    def safe_getitem(data, key):
+        return dict.__getitem__(data, key)
+
+    @classmethod
+    def assert_item_is_lazy(cls, data, key):
+        value = cls.safe_getitem(data, key)
+        cls.assert_is_lazy_object(value)
+
+    @classmethod
+    def assert_item_is_not_lazy(cls, data, key):
+        value = cls.safe_getitem(data, key)
+        cls.assert_is_not_lazy_object(value)
+
+    @staticmethod
+    def assert_is_lazy_object(obj):
+        assert isinstance(obj, LazyObject)
+
+    @staticmethod
+    def assert_is_not_lazy_object(obj):
+        assert not isinstance(obj, LazyObject)
+
+
+class TestLazyDict(object):
+    theory = LazyDictTheory
+
+    def test_unknown_item_access__should_raise_keyerror(self):
+        lazy_dict = LazyDict({"alice": 42})
+        item_access = lambda key: lazy_dict[key]
+        assert_raises(KeyError, item_access, "unknown")
+
+    def test_plain_item_access__should_succeed(self):
+        theory = LazyDictTheory
+        lazy_dict = LazyDict({"alice": 42})
+        theory.assert_item_is_not_lazy(lazy_dict, "alice")
+
+        value = lazy_dict["alice"]
+        eq_(value, 42)
+
+    def test_lazy_item_access__should_load_object(self):
+        ImportModuleTheory.ensure_module_is_not_imported("inspect")
+        lazy_dict = LazyDict({"alice": LazyObject("inspect:ismodule")})
+        self.theory.assert_item_is_lazy(lazy_dict, "alice")
+        self.theory.assert_item_is_lazy(lazy_dict, "alice")
+
+        value = lazy_dict["alice"]
+        self.theory.assert_is_not_lazy_object(value)
+        self.theory.assert_item_is_not_lazy(lazy_dict, "alice")
+
+    def test_lazy_item_access__should_fail_with_unknown_module(self):
+        lazy_dict = LazyDict({"bob": LazyObject("__unknown_module__", "xxx")})
+        item_access = lambda key: lazy_dict[key]
+        assert_raises(ImportError, item_access, "bob")
+
+    def test_lazy_item_access__should_fail_with_unknown_object(self):
+        lazy_dict = LazyDict({
+            "bob": LazyObject("behave.importer", "XUnknown")
+        })
+        item_access = lambda key: lazy_dict[key]
+        assert_raises(ImportError, item_access, "bob")

data/vendor/behave/test/test_log_capture.py

@@ -0,0 +1,29 @@
+from __future__ import absolute_import, with_statement
+
+from nose.tools import *
+from mock import patch
+
+from behave.log_capture import LoggingCapture
+from six.moves import range
+
+class TestLogCapture(object):
+    def test_get_value_returns_all_log_records(self):
+        class FakeConfig(object):
+            logging_filter = None
+            logging_format = None
+            logging_datefmt = None
+            logging_level = None
+
+        fake_records = [object() for x in range(0, 10)]
+
+        handler = LoggingCapture(FakeConfig())
+        handler.buffer = fake_records
+
+        with patch.object(handler.formatter, 'format') as format:
+            format.return_value = 'foo'
+            expected = '\n'.join(['foo'] * len(fake_records))
+
+            eq_(handler.getvalue(), expected)
+
+            calls = [args[0][0] for args in format.call_args_list]
+            eq_(calls, fake_records)

data/vendor/behave/test/test_matchers.py

@@ -0,0 +1,236 @@
+# -*- coding: UTF-8 -*-
+from __future__ import absolute_import, with_statement
+from mock import Mock, patch
+from nose.tools import *  # pylint: disable=wildcard-import, unused-wildcard-import
+import parse
+from behave.matchers import Match, Matcher, ParseMatcher, RegexMatcher, \
+    SimplifiedRegexMatcher, CucumberRegexMatcher
+from behave import matchers, runner
+
+
+class DummyMatcher(Matcher):
+    desired_result = None
+
+    def check_match(self, step):
+        return DummyMatcher.desired_result
+
+class TestMatcher(object):
+    # pylint: disable=invalid-name, no-self-use
+
+    def setUp(self):
+        DummyMatcher.desired_result = None
+
+    def test_returns_none_if_check_match_returns_none(self):
+        matcher = DummyMatcher(None, None)
+        assert matcher.match('just a random step') is None
+
+    def test_returns_match_object_if_check_match_returns_arguments(self):
+        arguments = ['some', 'random', 'objects']
+        func = lambda x: -x
+
+        DummyMatcher.desired_result = arguments
+        matcher = DummyMatcher(func, None)
+
+        match = matcher.match('just a random step')
+        assert isinstance(match, Match)
+        assert match.func is func
+        assert match.arguments == arguments
+
+class TestParseMatcher(object):
+    # pylint: disable=invalid-name, no-self-use
+
+    def setUp(self):
+        self.recorded_args = None
+
+    def record_args(self, *args, **kwargs):
+        self.recorded_args = (args, kwargs)
+
+    def test_returns_none_if_parser_does_not_match(self):
+        # pylint: disable=redefined-outer-name
+        # REASON: parse
+        matcher = ParseMatcher(None, 'a string')
+        with patch.object(matcher.parser, 'parse') as parse:
+            parse.return_value = None
+            assert matcher.match('just a random step') is None
+
+    def test_returns_arguments_based_on_matches(self):
+        func = lambda x: -x
+        matcher = ParseMatcher(func, 'foo')
+
+        results = parse.Result([1, 2, 3], {'foo': 'bar', 'baz': -45.3},
+                               {
+                                   0: (13, 14),
+                                   1: (16, 17),
+                                   2: (22, 23),
+                                   'foo': (32, 35),
+                                   'baz': (39, 44),
+                               })
+
+        expected = [
+            (13, 14, '1', 1, None),
+            (16, 17, '2', 2, None),
+            (22, 23, '3', 3, None),
+            (32, 35, 'bar', 'bar', 'foo'),
+            (39, 44, '-45.3', -45.3, 'baz'),
+        ]
+
+        with patch.object(matcher.parser, 'parse') as p:
+            p.return_value = results
+            m = matcher.match('some numbers 1, 2 and 3 and the bar is -45.3')
+            assert m.func is func
+            args = m.arguments
+            have = [(a.start, a.end, a.original, a.value, a.name) for a in args]
+            eq_(have, expected)
+
+    def test_named_arguments(self):
+        text = "has a {string}, an {integer:d} and a {decimal:f}"
+        matcher = ParseMatcher(self.record_args, text)
+        context = runner.Context(Mock())
+
+        m = matcher.match("has a foo, an 11 and a 3.14159")
+        m.run(context)
+        eq_(self.recorded_args, ((context,), {
+            'string': 'foo',
+            'integer': 11,
+            'decimal': 3.14159
+        }))
+
+    def test_positional_arguments(self):
+        text = "has a {}, an {:d} and a {:f}"
+        matcher = ParseMatcher(self.record_args, text)
+        context = runner.Context(Mock())
+
+        m = matcher.match("has a foo, an 11 and a 3.14159")
+        m.run(context)
+        eq_(self.recorded_args, ((context, 'foo', 11, 3.14159), {}))
+
+class TestRegexMatcher(object):
+    # pylint: disable=invalid-name, no-self-use
+    MATCHER_CLASS = RegexMatcher
+
+    def test_returns_none_if_regex_does_not_match(self):
+        RegexMatcher = self.MATCHER_CLASS
+        matcher = RegexMatcher(None, 'a string')
+        regex = Mock()
+        regex.match.return_value = None
+        matcher.regex = regex
+        assert matcher.match('just a random step') is None
+
+    def test_returns_arguments_based_on_groups(self):
+        RegexMatcher = self.MATCHER_CLASS
+        func = lambda x: -x
+        matcher = RegexMatcher(func, 'foo')
+
+        regex = Mock()
+        regex.groupindex = {'foo': 4, 'baz': 5}
+
+        match = Mock()
+        match.groups.return_value = ('1', '2', '3', 'bar', '-45.3')
+        positions = {
+            1: (13, 14),
+            2: (16, 17),
+            3: (22, 23),
+            4: (32, 35),
+            5: (39, 44),
+        }
+        match.start.side_effect = lambda idx: positions[idx][0]
+        match.end.side_effect = lambda idx: positions[idx][1]
+
+        regex.match.return_value = match
+        matcher.regex = regex
+
+        expected = [
+            (13, 14, '1', '1', None),
+            (16, 17, '2', '2', None),
+            (22, 23, '3', '3', None),
+            (32, 35, 'bar', 'bar', 'foo'),
+            (39, 44, '-45.3', '-45.3', 'baz'),
+        ]
+
+        m = matcher.match('some numbers 1, 2 and 3 and the bar is -45.3')
+        assert m.func is func
+        args = m.arguments
+        have = [(a.start, a.end, a.original, a.value, a.name) for a in args]
+        eq_(have, expected)
+
+
+
+class TestSimplifiedRegexMatcher(TestRegexMatcher):
+    MATCHER_CLASS = SimplifiedRegexMatcher
+
+    def test_steps_with_same_prefix_are_not_ordering_sensitive(self):
+        # -- RELATED-TO: issue #280
+        # pylint: disable=unused-argument
+        def step_func1(context): pass   # pylint: disable=multiple-statements
+        def step_func2(context): pass   # pylint: disable=multiple-statements
+        # pylint: enable=unused-argument
+        matcher1 = SimplifiedRegexMatcher(step_func1, "I do something")
+        matcher2 = SimplifiedRegexMatcher(step_func2, "I do something more")
+
+        # -- CHECK: ORDERING SENSITIVITY
+        matched1 = matcher1.match(matcher2.string)
+        matched2 = matcher2.match(matcher1.string)
+        assert matched1 is None
+        assert matched2 is None
+
+        # -- CHECK: Can match itself (if step text is simple)
+        matched1 = matcher1.match(matcher1.string)
+        matched2 = matcher2.match(matcher2.string)
+        assert isinstance(matched1, Match)
+        assert isinstance(matched2, Match)
+
+    @raises(AssertionError)
+    def test_step_should_not_use_regex_begin_marker(self):
+        SimplifiedRegexMatcher(None, "^I do something")
+
+    @raises(AssertionError)
+    def test_step_should_not_use_regex_end_marker(self):
+        SimplifiedRegexMatcher(None, "I do something$")
+
+    @raises(AssertionError)
+    def test_step_should_not_use_regex_begin_and_end_marker(self):
+        SimplifiedRegexMatcher(None, "^I do something$")
+
+
+class TestCucumberRegexMatcher(TestRegexMatcher):
+    MATCHER_CLASS = CucumberRegexMatcher
+
+    def test_steps_with_same_prefix_are_not_ordering_sensitive(self):
+        # -- RELATED-TO: issue #280
+        # pylint: disable=unused-argument
+        def step_func1(context): pass   # pylint: disable=multiple-statements
+        def step_func2(context): pass   # pylint: disable=multiple-statements
+        # pylint: enable=unused-argument
+        matcher1 = CucumberRegexMatcher(step_func1, "^I do something$")
+        matcher2 = CucumberRegexMatcher(step_func2, "^I do something more$")
+
+        # -- CHECK: ORDERING SENSITIVITY
+        matched1 = matcher1.match(matcher2.string[1:-1])
+        matched2 = matcher2.match(matcher1.string[1:-1])
+        assert matched1 is None
+        assert matched2 is None
+
+        # -- CHECK: Can match itself (if step text is simple)
+        matched1 = matcher1.match(matcher1.string[1:-1])
+        matched2 = matcher2.match(matcher2.string[1:-1])
+        assert isinstance(matched1, Match)
+        assert isinstance(matched2, Match)
+
+    def test_step_should_use_regex_begin_marker(self):
+        CucumberRegexMatcher(None, "^I do something")
+
+    def test_step_should_use_regex_end_marker(self):
+        CucumberRegexMatcher(None, "I do something$")
+
+    def test_step_should_use_regex_begin_and_end_marker(self):
+        CucumberRegexMatcher(None, "^I do something$")
+
+
+def test_step_matcher_current_matcher():
+    current_matcher = matchers.current_matcher
+    for name, klass in list(matchers.matcher_mapping.items()):
+        matchers.use_step_matcher(name)
+        matcher = matchers.get_matcher(lambda x: -x, 'foo')
+        assert isinstance(matcher, klass)
+
+    matchers.current_matcher = current_matcher

data/vendor/behave/test/test_model.py

@@ -0,0 +1,871 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=no-self-use, line-too-long
+
+from __future__ import absolute_import, print_function, with_statement
+import unittest
+from mock import Mock, patch
+from nose.tools import *  # pylint: disable=wildcard-import, unused-wildcard-import
+import six
+from six.moves import range     # pylint: disable=redefined-builtin
+from six.moves import zip       # pylint: disable=redefined-builtin
+if six.PY2:
+    import traceback2 as traceback
+    traceback_modname = "traceback2"
+else:
+    import traceback
+    traceback_modname = "traceback"
+
+from behave.model_core import FileLocation, Status
+from behave.model import Feature, Scenario, ScenarioOutline, Step
+from behave.model import Table, Row
+from behave.matchers import NoMatch
+from behave.runner import Context
+from behave.capture import CaptureController
+from behave.configuration import Configuration
+from behave.compat.collections import OrderedDict
+from behave import step_registry
+
+
+# -- CONVENIENCE-ALIAS:
+_text = six.text_type
+
+
+class TestFeatureRun(unittest.TestCase):
+    # pylint: disable=invalid-name
+
+    def setUp(self):
+        self.runner = Mock()
+        self.runner.aborted = False
+        self.runner.feature.tags = []
+        self.config = self.runner.config = Mock()
+        self.context = self.runner.context = Mock()
+        self.formatters = self.runner.formatters = [Mock()]
+        self.run_hook = self.runner.run_hook = Mock()
+
+    def test_formatter_feature_called(self):
+        feature = Feature('foo.feature', 1, u'Feature', u'foo',
+                          background=Mock())
+
+        feature.run(self.runner)
+
+        self.formatters[0].feature.assert_called_with(feature)
+
+    def test_formatter_background_called_when_feature_has_background(self):
+        feature = Feature('foo.feature', 1, u'Feature', u'foo',
+                          background=Mock())
+
+        feature.run(self.runner)
+
+        self.formatters[0].background.assert_called_with(feature.background)
+
+    def test_formatter_background_not_called_when_feature_has_no_background(self):
+        feature = Feature('foo.feature', 1, u'Feature', u'foo')
+
+        feature.run(self.runner)
+
+        assert not self.formatters[0].background.called
+
+    def test_run_runs_scenarios(self):
+        scenarios = [Mock(), Mock()]
+        for scenario in scenarios:
+            scenario.tags = []
+            scenario.run.return_value = False
+
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+        self.config.name = []
+
+        feature = Feature('foo.feature', 1, u'Feature', u'foo',
+                          scenarios=scenarios)
+
+        feature.run(self.runner)
+
+        for scenario in scenarios:
+            scenario.run.assert_called_with(self.runner)
+
+    def test_run_runs_named_scenarios(self):
+        scenarios = [Mock(Scenario), Mock(Scenario)]
+        scenarios[0].name = 'first scenario'
+        scenarios[1].name = 'second scenario'
+        scenarios[0].tags = []
+        scenarios[1].tags = []
+        # -- FAKE-CHECK:
+        scenarios[0].should_run_with_name_select.return_value = True
+        scenarios[1].should_run_with_name_select.return_value = False
+
+        for scenario in scenarios:
+            scenario.run.return_value = False
+
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+        self.config.name = ['first', 'third']
+        self.config.name_re = Configuration.build_name_re(self.config.name)
+
+        feature = Feature('foo.feature', 1, u'Feature', u'foo',
+                          scenarios=scenarios)
+
+        feature.run(self.runner)
+
+        scenarios[0].run.assert_called_with(self.runner)
+        assert not scenarios[1].run.called
+        scenarios[0].should_run_with_name_select.assert_called_with(self.config)
+        scenarios[1].should_run_with_name_select.assert_called_with(self.config)
+
+    def test_run_runs_named_scenarios_with_regexp(self):
+        scenarios = [Mock(), Mock()]
+        scenarios[0].name = 'first scenario'
+        scenarios[1].name = 'second scenario'
+        scenarios[0].tags = []
+        scenarios[1].tags = []
+        # -- FAKE-CHECK:
+        scenarios[0].should_run_with_name_select.return_value = False
+        scenarios[1].should_run_with_name_select.return_value = True
+
+        for scenario in scenarios:
+            scenario.run.return_value = False
+
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+        self.config.name = ['third .*', 'second .*']
+        self.config.name_re = Configuration.build_name_re(self.config.name)
+
+        feature = Feature('foo.feature', 1, u'Feature', u'foo',
+                          scenarios=scenarios)
+
+        feature.run(self.runner)
+
+        assert not scenarios[0].run.called
+        scenarios[1].run.assert_called_with(self.runner)
+        scenarios[0].should_run_with_name_select.assert_called_with(self.config)
+        scenarios[1].should_run_with_name_select.assert_called_with(self.config)
+
+    # @prepared
+    def test_run_exclude_named_scenarios_with_regexp(self):
+        # -- NOTE: Works here only because it is run against Mocks.
+        scenarios = [Mock(), Mock(), Mock()]
+        scenarios[0].name = "Alice in Florida"
+        scenarios[1].name = "Alice and Bob"
+        scenarios[2].name = "Bob in Paris"
+        scenarios[0].tags = []
+        scenarios[1].tags = []
+        scenarios[2].tags = []
+        # -- FAKE-CHECK:
+        scenarios[0].should_run_with_name_select.return_value = False
+        scenarios[1].should_run_with_name_select.return_value = False
+        scenarios[2].should_run_with_name_select.return_value = True
+
+        for scenario in scenarios:
+            scenario.run.return_value = False
+
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+        self.config.name = ["(?!Alice)"]    # Exclude all scenarios with "Alice"
+        self.config.name_re = Configuration.build_name_re(self.config.name)
+
+        feature = Feature('foo.feature', 1, u'Feature', u'foo',
+                          scenarios=scenarios)
+
+        feature.run(self.runner)
+
+        assert not scenarios[0].run.called
+        scenarios[0].should_run_with_name_select.assert_called_with(self.config)
+        scenarios[1].should_run_with_name_select.assert_called_with(self.config)
+        scenarios[2].should_run_with_name_select.assert_called_with(self.config)
+        scenarios[0].run.assert_not_called()
+        scenarios[1].run.assert_not_called()
+        scenarios[2].run.assert_called_with(self.runner)
+
+    def test_feature_hooks_not_run_if_feature_not_being_run(self):
+        self.config.tags.check.return_value = False  # pylint: disable=no-member
+
+        feature = Feature('foo.feature', 1, u'Feature', u'foo')
+        feature.run(self.runner)
+        assert not self.run_hook.called
+
+
+class TestScenarioRun(unittest.TestCase):
+    # pylint: disable=invalid-name
+
+    def setUp(self):
+        self.runner = Mock()
+        self.runner.aborted = False
+        self.runner.feature.tags = []
+        self.config = self.runner.config = Mock()
+        self.config.dry_run = False
+        self.context = self.runner.context = Mock()
+        self.formatters = self.runner.formatters = [Mock()]
+        self.run_hook = self.runner.run_hook = Mock()
+
+    def test_run_invokes_formatter_scenario_and_steps_correctly(self):
+        self.config.stdout_capture = False
+        self.config.log_capture = False
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+        steps = [Mock(), Mock()]
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo',
+                            steps=steps)
+
+        scenario.run(self.runner)
+
+        self.formatters[0].scenario.assert_called_with(scenario)
+        for step in steps:
+            step.run.assert_called_with(self.runner)
+
+    if six.PY3:
+        stringio_target = 'io.StringIO'
+    else:
+        stringio_target = 'StringIO.StringIO'
+
+    def test_handles_stdout_and_log_capture(self):
+        self.config.stdout_capture = True
+        self.config.log_capture = True
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+
+        steps = [Mock(), Mock()]
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo',
+                            steps=steps)
+
+        scenario.run(self.runner)
+
+        self.runner.setup_capture.assert_called_with()
+        self.runner.teardown_capture.assert_called_with()
+
+    def test_failed_step_causes_remaining_steps_to_be_skipped(self):
+        self.config.stdout_capture = False
+        self.config.log_capture = False
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+
+        steps = [Mock(), Mock()]
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo',
+                            steps=steps)
+        steps[0].run.return_value = False
+        steps[1].step_type = "when"
+        steps[1].name = "step1"
+
+        def step1_function(context):    # pylint: disable=unused-argument
+            pass
+        my_step_registry = step_registry.StepRegistry()
+        my_step_registry.add_step_definition("when", "step1", step1_function)
+
+        with patch("behave.step_registry.registry", my_step_registry):
+            assert scenario.run(self.runner)
+            eq_(steps[1].status, Status.skipped)
+
+    def test_failed_step_causes_context_failure_to_be_set(self):
+        self.config.stdout_capture = False
+        self.config.log_capture = False
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+
+        steps = [
+            Mock(step_type="given", name="step0"),
+            Mock(step_type="then", name="step1"),
+        ]
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo',
+                            steps=steps)
+        steps[0].run.return_value = False
+
+        assert scenario.run(self.runner)
+        # pylint: disable=protected-access
+        self.context._set_root_attribute.assert_called_with("failed", True)
+
+    def test_undefined_step_causes_failed_scenario_status(self):
+        self.config.stdout_capture = False
+        self.config.log_capture = False
+        self.config.tags.check.return_value = True  # pylint: disable=no-member
+
+        passed_step = Mock()
+        undefined_step = Mock()
+
+        steps = [passed_step, undefined_step]
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo',
+                            steps=steps)
+        passed_step.run.return_value = True
+        passed_step.status = Status.passed
+        undefined_step.run.return_value = False
+        undefined_step.status = Status.undefined
+
+        assert scenario.run(self.runner)
+        eq_(undefined_step.status, Status.undefined)
+        eq_(scenario.status, Status.failed)
+        # pylint: disable=protected-access
+        self.context._set_root_attribute.assert_called_with("failed", True)
+
+    def test_skipped_steps_set_step_status_and_scenario_status_if_not_set(self):
+        self.config.stdout_capture = False
+        self.config.log_capture = False
+        self.config.tags.check.return_value = False  # pylint: disable=no-member
+
+        steps = [Mock(), Mock()]
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo',
+                            steps=steps)
+
+        scenario.run(self.runner)
+
+        assert False not in [s.status == Status.skipped for s in steps]
+        eq_(scenario.status, Status.skipped)
+
+    def test_scenario_hooks_not_run_if_scenario_not_being_run(self):
+        self.config.tags.check.return_value = False  # pylint: disable=no-member
+
+        scenario = Scenario('foo.feature', 17, u'Scenario', u'foo')
+
+        scenario.run(self.runner)
+
+        assert not self.run_hook.called
+
+    def test_should_run_with_name_select(self):
+        scenario_name = u"first scenario"
+        scenario = Scenario("foo.feature", 17, u"Scenario", scenario_name)
+        self.config.name = ['first .*', 'second .*']
+        self.config.name_re = Configuration.build_name_re(self.config.name)
+
+        assert scenario.should_run_with_name_select(self.config)
+
+class TestScenarioOutline(unittest.TestCase):
+    # pylint: disable=invalid-name
+
+    def test_run_calls_run_on_each_generated_scenario(self):
+        # pylint: disable=protected-access
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        outline._scenarios = [Mock(), Mock()]
+        for scenario in outline._scenarios:
+            scenario.run.return_value = False
+
+        runner = Mock()
+        runner.context = Mock()
+
+        outline.run(runner)
+
+        for s in outline._scenarios:
+            s.run.assert_called_with(runner)
+
+    def test_run_stops_on_first_failure_if_requested(self):
+        # pylint: disable=protected-access
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        outline._scenarios = [Mock(), Mock()]
+        outline._scenarios[0].run.return_value = True
+
+        runner = Mock()
+        runner.context = Mock()
+        config = runner.config = Mock()
+        config.stop = True
+
+        outline.run(runner)
+
+        outline._scenarios[0].run.assert_called_with(runner)
+        assert not outline._scenarios[1].run.called
+
+    def test_run_sets_context_variable_for_outline(self):
+        # pylint: disable=protected-access
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        outline._scenarios = [Mock(), Mock(), Mock()]
+        for scenario in outline._scenarios:
+            scenario.run.return_value = False
+
+        runner = Mock()
+        context = runner.context = Mock()
+        config = runner.config = Mock()
+        config.stop = True
+
+        outline.run(runner)
+
+        eq_(context._set_root_attribute.call_args_list, [
+            (('active_outline', outline._scenarios[0]._row), {}),
+            (('active_outline', outline._scenarios[1]._row), {}),
+            (('active_outline', outline._scenarios[2]._row), {}),
+            (('active_outline', None), {}),
+        ])
+
+    def test_run_should_pass_when_all_examples_pass(self):
+        # pylint: disable=protected-access
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        outline._scenarios = [Mock(), Mock(), Mock()]
+        for scenario in outline._scenarios:
+            scenario.run.return_value = False
+
+        runner = Mock()
+        context = runner.context = Mock()
+        config = runner.config = Mock()
+        config.stop = True
+
+        resultFailed = outline.run(runner)
+        eq_(resultFailed, False)
+
+    def test_run_should_fail_when_first_examples_fails(self):
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        failed = True
+        # pylint: disable=protected-access
+        outline._scenarios = [Mock(), Mock()]
+        outline._scenarios[0].run.return_value = failed
+        outline._scenarios[1].run.return_value = not failed
+
+        runner = Mock()
+        context = runner.context = Mock()
+        config = runner.config = Mock()
+        config.stop = True
+
+        resultFailed = outline.run(runner)
+        eq_(resultFailed, True)
+
+    def test_run_should_fail_when_last_examples_fails(self):
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        failed = True
+        # pylint: disable=protected-access
+        outline._scenarios = [Mock(), Mock()]
+        outline._scenarios[0].run.return_value = not failed
+        outline._scenarios[1].run.return_value = failed
+
+        runner = Mock()
+        context = runner.context = Mock()
+        config = runner.config = Mock()
+        config.stop = True
+
+        resultFailed = outline.run(runner)
+        eq_(resultFailed, True)
+
+    def test_run_should_fail_when_middle_examples_fails(self):
+        outline = ScenarioOutline('foo.feature', 17, u'Scenario Outline',
+                                  u'foo')
+        failed = True
+        # pylint: disable=protected-access
+        outline._scenarios = [Mock(), Mock(), Mock()]
+        outline._scenarios[0].run.return_value = not failed
+        outline._scenarios[1].run.return_value = failed
+        outline._scenarios[2].run.return_value = not failed
+
+        runner = Mock()
+        context = runner.context = Mock()
+        config = runner.config = Mock()
+        config.stop = True
+
+        resultFailed = outline.run(runner)
+        eq_(resultFailed, True)
+
+
+def raiser(exception):
+    def func(*args, **kwargs):    # pylint: disable=unused-argument
+        raise exception
+    return func
+
+
+class TestStepRun(unittest.TestCase):
+    # pylint: disable=invalid-name
+
+    def setUp(self):
+        self.step_registry = Mock()
+        self.runner = Mock()
+        # self.capture_controller = self.runner.capture_controller = Mock()
+        self.capture_controller = CaptureController(self.runner.config)
+        self.runner.capture_controller = self.capture_controller
+        self.runner.step_registry = self.step_registry
+        self.config = self.runner.config = Mock()
+        self.config.outputs = [None]
+        self.context = self.runner.context = Mock()
+        print('context is %s' % self.context)
+        self.formatters = self.runner.formatters = [Mock()]
+        self.stdout_capture = self.capture_controller.stdout_capture = Mock()
+        self.stdout_capture.getvalue.return_value = ''
+        self.stderr_capture = self.capture_controller.stderr_capture = Mock()
+        self.stderr_capture.getvalue.return_value = ''
+        self.log_capture = self.capture_controller.log_capture = Mock()
+        self.log_capture.getvalue.return_value = ''
+        self.run_hook = self.runner.run_hook = Mock()
+
+    def test_run_appends_step_to_undefined_when_no_match_found(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        self.runner.step_registry.find_match.return_value = None
+        self.runner.undefined_steps = []
+        assert not step.run(self.runner)
+
+        assert step in self.runner.undefined_steps
+        eq_(step.status, Status.undefined)
+
+    def test_run_reports_undefined_step_via_formatter_when_not_quiet(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        self.runner.step_registry.find_match.return_value = None
+        assert not step.run(self.runner)
+
+        self.formatters[0].match.assert_called_with(NoMatch())
+        self.formatters[0].result.assert_called_with(step)
+
+    def test_run_with_no_match_does_not_touch_formatter_when_quiet(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        self.runner.step_registry.find_match.return_value = None
+        assert not step.run(self.runner, quiet=True)
+
+        assert not self.formatters[0].match.called
+        assert not self.formatters[0].result.called
+
+    def test_run_when_not_quiet_reports_match_and_result(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+
+        side_effects = (None, raiser(AssertionError('whee')),
+                        raiser(Exception('whee')))
+        for side_effect in side_effects:
+            match.run.side_effect = side_effect
+            step.run(self.runner)
+            self.formatters[0].match.assert_called_with(match)
+            self.formatters[0].result.assert_called_with(step)
+
+    def test_run_when_quiet_reports_nothing(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+
+        side_effects = (None, raiser(AssertionError('whee')),
+                        raiser(Exception('whee')))
+        for side_effect in side_effects:
+            match.run.side_effect = side_effect
+            step.run(self.runner, quiet=True)
+            assert not self.formatters[0].match.called
+            assert not self.formatters[0].result.called
+
+    def test_run_runs_before_hook_then_match_then_after_hook(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+
+        side_effects = (None, AssertionError('whee'), Exception('whee'))
+        for side_effect in side_effects:
+            # Make match.run() and runner.run_hook() the same mock so
+            # we can make sure things happen in the right order.
+            self.runner.run_hook = match.run = Mock()
+
+            def effect(thing):
+                # pylint: disable=unused-argument
+                def raiser_(*args, **kwargs):
+                    match.run.side_effect = None
+                    if thing:
+                        raise thing
+
+                def nonraiser(*args, **kwargs):
+                    match.run.side_effect = raiser_
+
+                return nonraiser
+
+            match.run.side_effect = effect(side_effect)
+            step.run(self.runner)
+
+            eq_(match.run.call_args_list, [
+                (('before_step', self.context, step), {}),
+                ((self.context,), {}),
+                (('after_step', self.context, step), {}),
+            ])
+
+
+    def test_run_sets_table_if_present(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo',
+                    table=Mock())
+        self.runner.step_registry.find_match.return_value = Mock()
+        step.run(self.runner)
+        eq_(self.context.table, step.table)
+
+    def test_run_sets_text_if_present(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo',
+                    text=Mock(name='text'))
+        self.runner.step_registry.find_match.return_value = Mock()
+        step.run(self.runner)
+
+        eq_(self.context.text, step.text)
+
+    def test_run_sets_status_to_passed_if_nothing_goes_wrong(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        step.error_message = None
+        self.runner.step_registry.find_match.return_value = Mock()
+        step.run(self.runner)
+
+        eq_(step.status, Status.passed)
+        eq_(step.error_message, None)
+
+    def test_run_sets_status_to_failed_on_assertion_error(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        self.runner.context = Context(self.runner)
+        self.runner.config.stdout_capture = True
+        self.runner.config.log_capture = False
+        self.runner.capture_controller = CaptureController(self.runner.config)
+        self.runner.capture_controller.setup_capture(self.runner.context)
+        step.error_message = None
+        match = Mock()
+        match.run.side_effect = raiser(AssertionError('whee'))
+        self.runner.step_registry.find_match.return_value = match
+        step.run(self.runner)
+
+        eq_(step.status, Status.failed)
+        assert step.error_message.startswith('Assertion Failed')
+
+    @patch('%s.format_exc' % traceback_modname)
+    def test_run_sets_status_to_failed_on_exception(self, format_exc):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        step.error_message = None
+        match = Mock()
+        match.run.side_effect = raiser(Exception('whee'))
+        self.runner.step_registry.find_match.return_value = match
+        format_exc.return_value = 'something to do with an exception'
+
+        step.run(self.runner)
+        eq_(step.status, Status.failed)
+        eq_(step.error_message, format_exc.return_value)
+
+    @patch('time.time')
+    def test_run_calculates_duration(self, time_time):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+
+        def time_time_1():
+            def time_time_2():
+                return 23
+            time_time.side_effect = time_time_2
+            return 17
+
+        side_effects = (None, raiser(AssertionError('whee')),
+                        raiser(Exception('whee')))
+        for side_effect in side_effects:
+            match.run.side_effect = side_effect
+            time_time.side_effect = time_time_1
+
+            step.run(self.runner)
+            eq_(step.duration, 23 - 17)
+
+    def test_run_captures_stdout_and_logging(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+
+        assert step.run(self.runner)
+
+        self.runner.start_capture.assert_called_with()
+        self.runner.stop_capture.assert_called_with()
+
+    def test_run_appends_any_captured_stdout_on_failure(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+        self.stdout_capture.getvalue.return_value = 'frogs'
+        match.run.side_effect = raiser(Exception('halibut'))
+
+        assert not step.run(self.runner)
+        assert 'Captured stdout:' in step.error_message
+        assert 'frogs' in step.error_message
+
+    def test_run_appends_any_captured_logging_on_failure(self):
+        step = Step('foo.feature', 17, u'Given', 'given', u'foo')
+        match = Mock()
+        self.runner.step_registry.find_match.return_value = match
+        self.log_capture.getvalue.return_value = 'toads'
+        match.run.side_effect = raiser(AssertionError('kipper'))
+
+        assert not step.run(self.runner)
+        assert 'Captured logging:' in step.error_message
+        assert 'toads' in step.error_message
+
+
+class TestTableModel(unittest.TestCase):
+    # pylint: disable=invalid-name
+    HEAD = [u'type of stuff', u'awesomeness', u'ridiculousness']
+    DATA = [
+        [u'fluffy', u'large', u'frequent'],
+        [u'lint', u'low', u'high'],
+        [u'green', u'variable', u'awkward'],
+    ]
+
+    def setUp(self):
+        self.table = Table(self.HEAD, 0, self.DATA)
+
+    def test_equivalence(self):
+        t1 = self.table
+        self.setUp()
+        eq_(t1, self.table)
+
+    def test_table_iteration(self):
+        for i, row in enumerate(self.table):
+            for j, cell in enumerate(row):
+                eq_(cell, self.DATA[i][j])
+
+    def test_table_row_by_index(self):
+        for i in range(3):
+            eq_(self.table[i], Row(self.HEAD, self.DATA[i], 0))
+
+    def test_table_row_name(self):
+        eq_(self.table[0]['type of stuff'], 'fluffy')
+        eq_(self.table[1]['awesomeness'], 'low')
+        eq_(self.table[2]['ridiculousness'], 'awkward')
+
+    def test_table_row_index(self):
+        eq_(self.table[0][0], 'fluffy')
+        eq_(self.table[1][1], 'low')
+        eq_(self.table[2][2], 'awkward')
+
+    @raises(KeyError)
+    def test_table_row_keyerror(self):
+        self.table[0]['spam']   # pylint: disable=pointless-statement
+
+    def test_table_row_items(self):
+        eq_(list(self.table[0].items()), list(zip(self.HEAD, self.DATA[0])))
+
+
+class TestModelRow(unittest.TestCase):
+    # pylint: disable=invalid-name, bad-whitespace
+    HEAD = [u'name',  u'sex',   u'age']
+    DATA = [u'Alice', u'female', u'12']
+
+    def setUp(self):
+        self.row = Row(self.HEAD, self.DATA, 0)
+
+    def test_len(self):
+        eq_(len(self.row), 3)
+
+    def test_getitem_with_valid_colname(self):
+        # pylint: disable=bad-whitespace
+        eq_(self.row['name'], u'Alice')
+        eq_(self.row['sex'],  u'female')
+        eq_(self.row['age'],  u'12')
+
+    @raises(KeyError)
+    def test_getitem_with_unknown_colname(self):
+        self.row['__UNKNOWN_COLUMN__']  # pylint: disable=pointless-statement
+
+    def test_getitem_with_valid_index(self):
+        eq_(self.row[0], u'Alice')
+        eq_(self.row[1], u'female')
+        eq_(self.row[2], u'12')
+
+    @raises(IndexError)
+    def test_getitem_with_invalid_index(self):
+        colsize = len(self.row)
+        eq_(colsize, 3)
+        self.row[colsize]   # pylint: disable=pointless-statement
+
+    def test_get_with_valid_colname(self):
+        # pylint: disable=bad-whitespace
+        eq_(self.row.get('name'), u'Alice')
+        eq_(self.row.get('sex'),  u'female')
+        eq_(self.row.get('age'),  u'12')
+
+    def test_getitem_with_unknown_colname_should_return_default(self):
+        eq_(self.row.get('__UNKNOWN_COLUMN__', 'XXX'), u'XXX')
+
+    def test_as_dict(self):
+        data1 = self.row.as_dict()
+        data2 = dict(self.row.as_dict())
+        assert isinstance(data1, dict)
+        assert isinstance(data2, dict)
+        assert isinstance(data1, OrderedDict)
+        # -- REQUIRES: Python2.7 or ordereddict installed.
+        # assert not isinstance(data2, OrderedDict)
+        eq_(data1, data2)
+        # pylint: disable=bad-whitespace
+        eq_(data1['name'], u'Alice')
+        eq_(data1['sex'],  u'female')
+        eq_(data1['age'],  u'12')
+
+
+class TestFileLocation(unittest.TestCase):
+    # pylint: disable=invalid-name
+    ordered_locations1 = [
+        FileLocation("features/alice.feature", 1),
+        FileLocation("features/alice.feature", 5),
+        FileLocation("features/alice.feature", 10),
+        FileLocation("features/alice.feature", 11),
+        FileLocation("features/alice.feature", 100),
+    ]
+    ordered_locations2 = [
+        FileLocation("features/alice.feature", 1),
+        FileLocation("features/alice.feature", 10),
+        FileLocation("features/bob.feature", 5),
+        FileLocation("features/charly.feature", None),
+        FileLocation("features/charly.feature", 0),
+        FileLocation("features/charly.feature", 100),
+    ]
+    same_locations = [
+        (FileLocation("alice.feature"),
+         FileLocation("alice.feature", None),
+        ),
+        (FileLocation("alice.feature", 10),
+         FileLocation("alice.feature", 10),
+        ),
+        (FileLocation("features/bob.feature", 11),
+         FileLocation("features/bob.feature", 11),
+        ),
+    ]
+
+    def test_compare_equal(self):
+        for value1, value2 in self.same_locations:
+            eq_(value1, value2)
+
+    def test_compare_equal_with_string(self):
+        for location in self.ordered_locations2:
+            eq_(location, location.filename)
+            eq_(location.filename, location)
+
+    def test_compare_not_equal(self):
+        for value1, value2 in self.same_locations:
+            assert not(value1 != value2)    # pylint: disable=unneeded-not, superfluous-parens
+
+        for locations in [self.ordered_locations1, self.ordered_locations2]:
+            for value1, value2 in zip(locations, locations[1:]):
+                assert value1 != value2
+
+    def test_compare_less_than(self):
+        for locations in [self.ordered_locations1, self.ordered_locations2]:
+            for value1, value2 in zip(locations, locations[1:]):
+                assert value1 < value2, "FAILED: %s < %s" % (_text(value1), _text(value2))
+                assert value1 != value2
+
+    def test_compare_less_than_with_string(self):
+        locations = self.ordered_locations2
+        for value1, value2 in zip(locations, locations[1:]):
+            if value1.filename == value2.filename:
+                continue
+            assert value1 < value2.filename, \
+                   "FAILED: %s < %s" % (_text(value1), _text(value2.filename))
+            assert value1.filename < value2, \
+                   "FAILED: %s < %s" % (_text(value1.filename), _text(value2))
+
+    def test_compare_greater_than(self):
+        for locations in [self.ordered_locations1, self.ordered_locations2]:
+            for value1, value2 in zip(locations, locations[1:]):
+                assert value2 > value1, "FAILED: %s > %s" % (_text(value2), _text(value1))
+                assert value2 != value1
+
+    def test_compare_less_or_equal(self):
+        for value1, value2 in self.same_locations:
+            assert value1 <= value2, "FAILED: %s <= %s" % (_text(value1), _text(value2))
+            assert value1 == value2
+
+        for locations in [self.ordered_locations1, self.ordered_locations2]:
+            for value1, value2 in zip(locations, locations[1:]):
+                assert value1 <= value2, "FAILED: %s <= %s" % (_text(value1), _text(value2))
+                assert value1 != value2
+
+    def test_compare_greater_or_equal(self):
+        for value1, value2 in self.same_locations:
+            assert value2 >= value1, "FAILED: %s >= %s" % (_text(value2), _text(value1))
+            assert value2 == value1
+
+        for locations in [self.ordered_locations1, self.ordered_locations2]:
+            for value1, value2 in zip(locations, locations[1:]):
+                assert value2 >= value1, "FAILED: %s >= %s" % (_text(value2), _text(value1))
+                assert value2 != value1
+
+    def test_filename_should_be_same_as_self(self):
+        for location in self.ordered_locations2:
+            assert location == location.filename
+            assert location.filename == location
+
+    def test_string_conversion(self):
+        for location in self.ordered_locations2:
+            expected = u"%s:%s" % (location.filename, location.line)
+            if location.line is None:
+                expected = location.filename
+            assert six.text_type(location) == expected
+
+    def test_repr_conversion(self):
+        for location in self.ordered_locations2:
+            expected = u'<FileLocation: filename="%s", line=%s>' % \
+                       (location.filename, location.line)
+            actual = repr(location)
+            assert actual == expected, "FAILED: %s == %s" % (actual, expected)