busser-behave 0.1.3

data/vendor/behave/test/_importer_candidate.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+name = "Hello"

data/vendor/behave/test/reporters/test_summary.py

@@ -0,0 +1,240 @@
+# -*- coding: UTF-8 -*-
+
+from __future__ import absolute_import, division
+from mock import Mock, patch
+from nose.tools import *
+
+from behave.model import ScenarioOutline, Scenario
+from behave.model_core import Status
+from behave.reporter.summary import SummaryReporter, format_summary
+
+class TestFormatStatus(object):
+    def test_passed_entry_contains_label(self):
+        summary = {
+            Status.passed.name: 1,
+            Status.skipped.name: 0,
+            Status.failed.name: 0,
+            Status.undefined.name: 0,
+        }
+
+        assert format_summary('fnord', summary).startswith('1 fnord passed')
+
+    def test_passed_entry_is_pluralised(self):
+        summary = {
+            Status.passed.name: 10,
+            Status.skipped.name: 0,
+            Status.failed.name: 0,
+            Status.undefined.name: 0,
+        }
+
+        assert format_summary('fnord', summary).startswith('10 fnords passed')
+
+    def test_remaining_fields_are_present(self):
+        summary = {
+            Status.passed.name: 10,
+            Status.skipped.name: 1,
+            Status.failed.name: 2,
+            Status.undefined.name: 3,
+        }
+
+        output = format_summary('fnord', summary)
+
+        assert '1 skipped' in output
+        assert '2 failed' in output
+        assert '3 undefined' in output
+
+    def test_missing_fields_are_not_present(self):
+        summary = {
+            Status.passed.name: 10,
+            Status.skipped.name: 1,
+            Status.failed.name: 2,
+        }
+
+        output = format_summary('fnord', summary)
+
+        assert '1 skipped' in output
+        assert '2 failed' in output
+        assert Status.undefined.name not in output
+
+class TestSummaryReporter(object):
+    @patch('sys.stdout')
+    def test_duration_is_totalled_up_and_outputted(self, stdout):
+        features = [Mock(), Mock(), Mock(), Mock()]
+        features[0].duration = 1.9
+        features[0].status = Status.passed
+        features[0].__iter__ = Mock(return_value=iter([]))
+        features[1].duration = 2.7
+        features[1].status = Status.passed
+        features[1].__iter__ = Mock(return_value=iter([]))
+        features[2].duration = 3.5
+        features[2].status = Status.passed
+        features[2].__iter__ = Mock(return_value=iter([]))
+        features[3].duration = 4.3
+        features[3].status = Status.passed
+        features[3].__iter__ = Mock(return_value=iter([]))
+
+        config = Mock()
+        reporter = SummaryReporter(config)
+
+        [reporter.feature(f) for f in features]
+        eq_(round(reporter.duration, 3), 12.400)
+
+        reporter.end()
+        output = stdout.write.call_args_list[-1][0][0]
+        minutes = int(reporter.duration / 60.0)
+        seconds = reporter.duration % 60
+
+        assert '%dm' % (minutes,) in output
+        assert '%02.1f' % (seconds,) in output
+
+    @patch('sys.stdout')
+    @patch('behave.reporter.summary.format_summary')
+    def test_feature_status_is_collected_and_reported(self, format_summary,
+                                                      stdout):
+        features = [Mock(), Mock(), Mock(), Mock(), Mock()]
+        features[0].duration = 1.9
+        features[0].status = Status.passed
+        features[0].__iter__ = Mock(return_value=iter([]))
+        features[1].duration = 2.7
+        features[1].status = Status.failed
+        features[1].__iter__ = Mock(return_value=iter([]))
+        features[2].duration = 3.5
+        features[2].status = Status.skipped
+        features[2].__iter__ = Mock(return_value=iter([]))
+        features[3].duration = 4.3
+        features[3].status = Status.passed
+        features[3].__iter__ = Mock(return_value=iter([]))
+        features[4].duration = 5.1
+        features[4].status = Status.untested
+        features[4].__iter__ = Mock(return_value=iter([]))
+
+        config = Mock()
+        reporter = SummaryReporter(config)
+
+        [reporter.feature(f) for f in features]
+        reporter.end()
+
+        expected = {
+            Status.passed.name: 2,
+            Status.failed.name: 1,
+            Status.skipped.name: 1,
+            Status.untested.name: 1,
+        }
+
+        eq_(format_summary.call_args_list[0][0], ('feature', expected))
+
+    @patch('sys.stdout')
+    @patch('behave.reporter.summary.format_summary')
+    def test_scenario_status_is_collected_and_reported(self, format_summary,
+                                                       stdout):
+        feature = Mock()
+        scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
+        scenarios[0].status = Status.failed
+        scenarios[0].__iter__ = Mock(return_value=iter([]))
+        scenarios[1].status = Status.failed
+        scenarios[1].__iter__ = Mock(return_value=iter([]))
+        scenarios[2].status = Status.skipped
+        scenarios[2].__iter__ = Mock(return_value=iter([]))
+        scenarios[3].status = Status.passed
+        scenarios[3].__iter__ = Mock(return_value=iter([]))
+        scenarios[4].status = Status.untested
+        scenarios[4].__iter__ = Mock(return_value=iter([]))
+        feature.status = Status.failed
+        feature.duration = 12.3
+        feature.__iter__ = Mock(return_value=iter(scenarios))
+
+        config = Mock()
+        reporter = SummaryReporter(config)
+
+        reporter.feature(feature)
+        reporter.end()
+
+        expected = {
+            Status.passed.name: 1,
+            Status.failed.name: 2,
+            Status.skipped.name: 1,
+            Status.untested.name: 1,
+        }
+
+        eq_(format_summary.call_args_list[1][0], ('scenario', expected))
+
+    @patch('behave.reporter.summary.format_summary')
+    @patch('sys.stdout')
+    def test_scenario_outline_status_is_collected_and_reported(self, stdout,
+                                                               format_summary):
+        feature = Mock()
+        scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
+                      Mock(), Mock(), Mock() ]
+        subscenarios = [ Mock(), Mock(), Mock(), Mock() ]
+        subscenarios[0].status = Status.passed
+        subscenarios[0].__iter__ = Mock(return_value=iter([]))
+        subscenarios[1].status = Status.failed
+        subscenarios[1].__iter__ = Mock(return_value=iter([]))
+        subscenarios[2].status = Status.failed
+        subscenarios[2].__iter__ = Mock(return_value=iter([]))
+        subscenarios[3].status = Status.skipped
+        subscenarios[3].__iter__ = Mock(return_value=iter([]))
+        scenarios[0]._scenarios = subscenarios
+        scenarios[1].status = Status.failed
+        scenarios[1].__iter__ = Mock(return_value=iter([]))
+        scenarios[2].status = Status.skipped
+        scenarios[2].__iter__ = Mock(return_value=iter([]))
+        scenarios[3].status = Status.passed
+        scenarios[3].__iter__ = Mock(return_value=iter([]))
+        feature.status = Status.failed
+        feature.duration = 12.4
+        feature.__iter__ = Mock(return_value=iter(scenarios))
+
+        config = Mock()
+        reporter = SummaryReporter(config)
+
+        reporter.feature(feature)
+        reporter.end()
+
+        expected = {
+            Status.passed.name: 2,
+            Status.failed.name: 3,
+            Status.skipped.name: 2,
+            Status.untested.name: 0,
+            }
+
+        eq_(format_summary.call_args_list[1][0], ('scenario', expected))
+
+    @patch('sys.stdout')
+    @patch('behave.reporter.summary.format_summary')
+    def test_step_status_is_collected_and_reported(self, format_summary,
+                                                   stdout):
+        feature = Mock()
+        scenario = Mock()
+        steps = [Mock(), Mock(), Mock(), Mock(), Mock()]
+        steps[0].status = Status.failed
+        steps[0].__iter__ = Mock(return_value=iter([]))
+        steps[1].status = Status.passed
+        steps[1].__iter__ = Mock(return_value=iter([]))
+        steps[2].status = Status.passed
+        steps[2].__iter__ = Mock(return_value=iter([]))
+        steps[3].status = Status.skipped
+        steps[4].__iter__ = Mock(return_value=iter([]))
+        steps[4].status = Status.undefined
+        steps[4].__iter__ = Mock(return_value=iter([]))
+        feature.status = Status.failed
+        feature.duration = 12.3
+        feature.__iter__ = Mock(return_value=iter([scenario]))
+        scenario.status = Status.failed
+        scenario.__iter__ = Mock(return_value=iter(steps))
+
+        config = Mock()
+        reporter = SummaryReporter(config)
+
+        reporter.feature(feature)
+        reporter.end()
+
+        expected = {
+            Status.passed.name: 2,
+            Status.failed.name: 1,
+            Status.skipped.name: 1,
+            Status.untested.name: 0,
+            Status.undefined.name: 1,
+        }
+
+        eq_(format_summary.call_args_list[2][0], ('step', expected))

data/vendor/behave/test/test_ansi_escapes.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=C0103,R0201,W0401,W0614,W0621
+#   C0103   Invalid name (setUp(), ...)
+#   R0201   Method could be a function
+#   W0401   Wildcard import
+#   W0614   Unused import ... from wildcard import
+#   W0621   Redefining name ... from outer scope
+
+from __future__ import absolute_import
+from nose import tools
+from behave.formatter import ansi_escapes
+import unittest
+from six.moves import range
+
+class StripEscapesTest(unittest.TestCase):
+    ALL_COLORS = list(ansi_escapes.colors.keys())
+    CURSOR_UPS = [ ansi_escapes.up(count)  for count in range(10) ]
+    TEXTS = [
+        u"lorem ipsum",
+        u"Alice\nBob\nCharly\nDennis",
+    ]
+
+    @classmethod
+    def colorize(cls, text, color):
+        color_escape = ""
+        if color:
+            color_escape = ansi_escapes.colors[color]
+        return color_escape + text + ansi_escapes.escapes["reset"]
+
+    @classmethod
+    def colorize_text(cls, text, colors=None):
+        if not colors:
+            colors = []
+        colors_size = len(colors)
+        color_index = 0
+        colored_chars = []
+        for char in text:
+            color = colors[color_index]
+            colored_chars.append(cls.colorize(char, color))
+            color_index += 1
+            if color_index >= colors_size:
+                color_index = 0
+        return "".join(colored_chars)
+
+    def test_should_return_same_text_without_escapes(self):
+        for text in self.TEXTS:
+            tools.eq_(text, ansi_escapes.strip_escapes(text))
+
+    def test_should_return_empty_string_for_any_ansi_escape(self):
+        # XXX-JE-CHECK-PY23: If list() is really needed.
+        for text in list(ansi_escapes.colors.values()):
+            tools.eq_("", ansi_escapes.strip_escapes(text))
+        for text in list(ansi_escapes.escapes.values()):
+            tools.eq_("", ansi_escapes.strip_escapes(text))
+
+
+    def test_should_strip_color_escapes_from_text(self):
+        for text in self.TEXTS:
+            colored_text = self.colorize_text(text, self.ALL_COLORS)
+            tools.eq_(text, ansi_escapes.strip_escapes(colored_text))
+            self.assertNotEqual(text, colored_text)
+
+            for color in self.ALL_COLORS:
+                colored_text = self.colorize(text, color)
+                tools.eq_(text, ansi_escapes.strip_escapes(colored_text))
+                self.assertNotEqual(text, colored_text)
+
+    def test_should_strip_cursor_up_escapes_from_text(self):
+        for text in self.TEXTS:
+            for cursor_up in self.CURSOR_UPS:
+                colored_text = cursor_up + text + ansi_escapes.escapes["reset"]
+                tools.eq_(text, ansi_escapes.strip_escapes(colored_text))
+                self.assertNotEqual(text, colored_text)

data/vendor/behave/test/test_configuration.py

@@ -0,0 +1,172 @@
+import os.path
+import sys
+import tempfile
+from nose.tools import *
+from behave import configuration
+from behave.configuration import Configuration, UserData
+from unittest import TestCase
+
+
+# one entry of each kind handled
+TEST_CONFIG="""[behave]
+outfiles= /absolute/path1
+          relative/path2
+paths = /absolute/path3
+        relative/path4
+tags = @foo,~@bar
+       @zap
+format=pretty
+       tag-counter
+stdout_capture=no
+bogus=spam
+
+[behave.userdata]
+foo    = bar
+answer = 42
+"""
+
+
+ROOTDIR_PREFIX = ""
+if sys.platform.startswith("win"):
+    # -- OR: ROOTDIR_PREFIX = os.path.splitdrive(sys.executable)
+    # NOTE: python2 requires lower-case drive letter.
+    ROOTDIR_PREFIX = os.environ.get("BEHAVE_ROOTDIR_PREFIX", "c:")
+
+class TestConfiguration(object):
+
+    def test_read_file(self):
+        tn = tempfile.mktemp()
+        tndir = os.path.dirname(tn)
+        with open(tn, "w") as f:
+            f.write(TEST_CONFIG)
+
+        # -- WINDOWS-REQUIRES: normpath
+        d = configuration.read_configuration(tn)
+        eq_(d["outfiles"], [
+            os.path.normpath(ROOTDIR_PREFIX + "/absolute/path1"),
+            os.path.normpath(os.path.join(tndir, "relative/path2")),
+        ])
+        eq_(d["paths"], [
+            os.path.normpath(ROOTDIR_PREFIX + "/absolute/path3"),
+            os.path.normpath(os.path.join(tndir, "relative/path4")),
+            ])
+        eq_(d["format"], ["pretty", "tag-counter"])
+        eq_(d["tags"], ["@foo,~@bar", "@zap"])
+        eq_(d["stdout_capture"], False)
+        ok_("bogus" not in d)
+        eq_(d["userdata"], {"foo": "bar", "answer": "42"})
+
+    def ensure_stage_environment_is_not_set(self):
+        if "BEHAVE_STAGE" in os.environ:
+            del os.environ["BEHAVE_STAGE"]
+
+    def test_settings_without_stage(self):
+        # -- OR: Setup with default, unnamed stage.
+        self.ensure_stage_environment_is_not_set()
+        assert "BEHAVE_STAGE" not in os.environ
+        config = Configuration("")
+        eq_("steps", config.steps_dir)
+        eq_("environment.py", config.environment_file)
+
+    def test_settings_with_stage(self):
+        config = Configuration(["--stage=STAGE1"])
+        eq_("STAGE1_steps", config.steps_dir)
+        eq_("STAGE1_environment.py", config.environment_file)
+
+    def test_settings_with_stage_and_envvar(self):
+        os.environ["BEHAVE_STAGE"] = "STAGE2"
+        config = Configuration(["--stage=STAGE1"])
+        eq_("STAGE1_steps", config.steps_dir)
+        eq_("STAGE1_environment.py", config.environment_file)
+        del os.environ["BEHAVE_STAGE"]
+
+    def test_settings_with_stage_from_envvar(self):
+        os.environ["BEHAVE_STAGE"] = "STAGE2"
+        config = Configuration("")
+        eq_("STAGE2_steps", config.steps_dir)
+        eq_("STAGE2_environment.py", config.environment_file)
+        del os.environ["BEHAVE_STAGE"]
+
+
+class TestConfigurationUserData(TestCase):
+    """Test userdata aspects in behave.configuration.Configuration class."""
+
+    def test_cmdline_defines(self):
+        config = Configuration([
+            "-D", "foo=foo_value",
+            "--define=bar=bar_value",
+            "--define", "baz=BAZ_VALUE",
+        ])
+        eq_("foo_value", config.userdata["foo"])
+        eq_("bar_value", config.userdata["bar"])
+        eq_("BAZ_VALUE", config.userdata["baz"])
+
+    def test_cmdline_defines_override_configfile(self):
+        userdata_init = {"foo": "XXX", "bar": "ZZZ", "baz": 42}
+        config = Configuration(
+                    "-D foo=foo_value --define bar=123",
+                    load_config=False, userdata=userdata_init)
+        eq_("foo_value", config.userdata["foo"])
+        eq_("123", config.userdata["bar"])
+        eq_(42, config.userdata["baz"])
+
+    def test_cmdline_defines_without_value_are_true(self):
+        config = Configuration("-D foo --define bar -Dbaz")
+        eq_("true", config.userdata["foo"])
+        eq_("true", config.userdata["bar"])
+        eq_("true", config.userdata["baz"])
+        eq_(True, config.userdata.getbool("foo"))
+
+    def test_cmdline_defines_with_empty_value(self):
+        config = Configuration("-D foo=")
+        eq_("", config.userdata["foo"])
+
+    def test_cmdline_defines_with_assign_character_as_value(self):
+        config = Configuration("-D foo=bar=baz")
+        eq_("bar=baz", config.userdata["foo"])
+
+    def test_cmdline_defines__with_quoted_name_value_pair(self):
+        cmdlines = [
+            '-D "person=Alice and Bob"',
+            "-D 'person=Alice and Bob'",
+        ]
+        for cmdline in cmdlines:
+            config = Configuration(cmdline, load_config=False)
+            eq_(config.userdata, dict(person="Alice and Bob"))
+
+    def test_cmdline_defines__with_quoted_value(self):
+        cmdlines = [
+            '-D person="Alice and Bob"',
+            "-D person='Alice and Bob'",
+        ]
+        for cmdline in cmdlines:
+            config = Configuration(cmdline, load_config=False)
+            eq_(config.userdata, dict(person="Alice and Bob"))
+
+    def test_setup_userdata(self):
+        config = Configuration("", load_config=False)
+        config.userdata = dict(person1="Alice", person2="Bob")
+        config.userdata_defines = [("person2", "Charly")]
+        config.setup_userdata()
+
+        expected_data = dict(person1="Alice", person2="Charly")
+        eq_(config.userdata, expected_data)
+
+    def test_update_userdata__with_cmdline_defines(self):
+        # -- NOTE: cmdline defines are reapplied.
+        config = Configuration("-D person2=Bea", load_config=False)
+        config.userdata = UserData(person1="AAA", person3="Charly")
+        config.update_userdata(dict(person1="Alice", person2="Bob"))
+
+        expected_data = dict(person1="Alice", person2="Bea", person3="Charly")
+        eq_(config.userdata, expected_data)
+        eq_(config.userdata_defines, [("person2", "Bea")])
+
+    def test_update_userdata__without_cmdline_defines(self):
+        config = Configuration("", load_config=False)
+        config.userdata = UserData(person1="AAA", person3="Charly")
+        config.update_userdata(dict(person1="Alice", person2="Bob"))
+
+        expected_data = dict(person1="Alice", person2="Bob", person3="Charly")
+        eq_(config.userdata, expected_data)
+        self.assertFalse(config.userdata_defines)