busser-behave 0.1.3

data/vendor/behave/test/test_formatter.py

@@ -0,0 +1,265 @@
+# -*- coding: UTF-8 -*-
+
+from __future__ import absolute_import
+import struct
+import sys
+import tempfile
+import unittest
+import six
+from mock import Mock, patch
+from nose.tools import *    # pylint: disable=wildcard-import, unused-wildcard-import
+
+from behave.formatter._registry import make_formatters
+from behave.formatter import pretty
+from behave.formatter.base import StreamOpener
+from behave.model import Tag, Feature, Scenario, Step
+from behave.model_core import Status
+from behave.matchers import Match
+
+
+class TestGetTerminalSize(unittest.TestCase):
+    def setUp(self):
+        try:
+            self.ioctl_patch = patch("fcntl.ioctl")
+            self.ioctl = self.ioctl_patch.start()
+        except ImportError:
+            self.ioctl_patch = None
+            self.ioctl = None
+        self.zero_struct = struct.pack("HHHH", 0, 0, 0, 0)
+
+    def tearDown(self):
+        if self.ioctl_patch:
+            self.ioctl_patch.stop()
+
+    def test_windows_fallback(self):    # pylint: disable=no-self-use
+        platform = sys.platform
+        sys.platform = "windows"
+
+        eq_(pretty.get_terminal_size(), (80, 24))
+
+        sys.platform = platform
+
+    def test_termios_fallback(self):    # pylint: disable=no-self-use
+        try:
+            import termios
+            return
+        except ImportError:
+            pass
+
+        eq_(pretty.get_terminal_size(), (80, 24))
+
+    def test_exception_in_ioctl(self):
+        try:
+            import termios
+        except ImportError:
+            return
+
+        def raiser(*args, **kwargs):    # pylint: disable=unused-argument
+            raise Exception("yeehar!")
+
+        self.ioctl.side_effect = raiser
+
+        eq_(pretty.get_terminal_size(), (80, 24))
+        self.ioctl.assert_called_with(0, termios.TIOCGWINSZ, self.zero_struct)
+
+    def test_happy_path(self):
+        try:
+            import termios
+        except ImportError:
+            return
+
+        self.ioctl.return_value = struct.pack("HHHH", 17, 23, 5, 5)
+
+        eq_(pretty.get_terminal_size(), (23, 17))
+        self.ioctl.assert_called_with(0, termios.TIOCGWINSZ, self.zero_struct)
+
+    def test_zero_size_fallback(self):
+        try:
+            import termios
+        except ImportError:
+            return
+
+        self.ioctl.return_value = self.zero_struct
+
+        eq_(pretty.get_terminal_size(), (80, 24))
+        self.ioctl.assert_called_with(0, termios.TIOCGWINSZ, self.zero_struct)
+
+
+def _tf():
+    """Open a temp file that looks a bunch like stdout."""
+    if six.PY3:
+        # in python3 it's got an encoding and accepts new-style strings
+        return tempfile.TemporaryFile(mode="w", encoding="UTF-8")
+
+    # pre-python3 it's not got an encoding and accepts encoded data
+    # (old-style strings)
+    return tempfile.TemporaryFile(mode="w")
+
+
+class FormatterTests(unittest.TestCase):
+    formatter_name = "plain"    # SANE DEFAULT, overwritten by concrete classes
+
+    def setUp(self):
+        self.config = Mock()
+        self.config.color = True
+        self.config.outputs = [StreamOpener(stream=sys.stdout)]
+        self.config.format = [self.formatter_name]
+
+    _line = 0
+    @property
+    def line(self):
+        self._line += 1
+        return self._line
+
+    def _formatter(self, file_object, config):  # pylint: disable=no-self-use
+        stream_opener = StreamOpener(stream=file_object)
+        f = make_formatters(config, [stream_opener])[0]
+        f.uri("<string>")
+        return f
+
+    def _feature(self, keyword=u"k\xe9yword", name=u"name", tags=None,
+                 location=u"location", # pylint: disable=unused-argument
+                 description=None, scenarios=None, background=None):
+        if tags is None:
+            tags = [u"spam", u"ham"]
+        if description is None:
+            description = [u"description"]
+        if scenarios is None:
+            scenarios = []
+        line = self.line
+        tags = [Tag(name, line) for name in tags]
+        return Feature("<string>", line, keyword, name, tags=tags,
+                       description=description, scenarios=scenarios,
+                       background=background)
+
+    def _scenario(self, keyword=u"k\xe9yword", name=u"name", tags=None, steps=None):
+        if tags is None:
+            tags = []
+        if steps is None:
+            steps = []
+        line = self.line
+        tags = [Tag(name, line) for name in tags]
+        return Scenario("<string>", line, keyword, name, tags=tags, steps=steps)
+
+    def _step(self, keyword=u"k\xe9yword", step_type="given", name=u"name",
+              text=None, table=None):
+        line = self.line
+        return Step("<string>", line, keyword, step_type, name, text=text,
+                    table=table)
+
+    def _match(self, arguments=None):   # pylint: disable=no-self-use
+        def dummy():
+            pass
+
+        return Match(dummy, arguments)
+
+    def test_feature(self):
+        # this test does not actually check the result of the formatting; it
+        # just exists to make sure that formatting doesn't explode in the face of
+        # unicode and stuff
+        p = self._formatter(_tf(), self.config)
+        f = self._feature()
+        p.feature(f)
+
+    def test_scenario(self):
+        p = self._formatter(_tf(), self.config)
+        f = self._feature()
+        p.feature(f)
+        s = self._scenario()
+        p.scenario(s)
+
+    def test_step(self):
+        p = self._formatter(_tf(), self.config)
+        f = self._feature()
+        p.feature(f)
+        scenario = self._scenario()
+        p.scenario(scenario)
+        s = self._step()
+        p.step(s)
+        p.match(self._match([]))
+        s.status = Status.passed
+        p.result(s)
+
+
+class TestPretty(FormatterTests):
+    formatter_name = "pretty"
+
+
+class TestPlain(FormatterTests):
+    formatter_name = "plain"
+
+
+class TestJson(FormatterTests):
+    formatter_name = "json"
+
+
+class TestTagsCount(FormatterTests):
+    formatter_name = "tags"
+
+    def test_tag_counts(self):
+        p = self._formatter(_tf(), self.config)
+
+        s = self._scenario(tags=[u"ham", u"foo"])
+        f = self._feature(scenarios=[s])  # feature.tags= ham, spam
+        p.feature(f)
+        p.scenario(s)
+
+        eq_(p.tag_counts, {"ham": [f, s], "spam": [f], "foo": [s]})
+
+
+class MultipleFormattersTests(FormatterTests):
+    formatters = []
+
+    def setUp(self):
+        self.config = Mock()
+        self.config.color = True
+        self.config.outputs = [StreamOpener(stream=sys.stdout)
+                               for i in self.formatters]
+        self.config.format = self.formatters
+
+    def _formatters(self, file_object, config): # pylint: disable=no-self-use
+        stream_opener = StreamOpener(stream=file_object)
+        formatters = make_formatters(config, [stream_opener])
+        for f in formatters:
+            f.uri("<string>")
+        return formatters
+
+    def test_feature(self):
+        # this test does not actually check the result of the formatting; it
+        # just exists to make sure that formatting doesn't explode in the face of
+        # unicode and stuff
+        formatters = self._formatters(_tf(), self.config)
+        f = self._feature()
+        for p in formatters:
+            p.feature(f)
+
+    def test_scenario(self):
+        formatters = self._formatters(_tf(), self.config)
+        f = self._feature()
+        for p in formatters:
+            p.feature(f)
+            s = self._scenario()
+            p.scenario(s)
+
+    def test_step(self):
+        formatters = self._formatters(_tf(), self.config)
+        f = self._feature()
+        for p in formatters:
+            p.feature(f)
+            scenario = self._scenario()
+            p.scenario(scenario)
+            s = self._step()
+            p.step(s)
+            p.match(self._match([]))
+            s.status = Status.passed
+            p.result(s)
+
+
+class TestPrettyAndPlain(MultipleFormattersTests):
+    formatters = ["pretty", "plain"]
+
+class TestPrettyAndJSON(MultipleFormattersTests):
+    formatters = ["pretty", "json"]
+
+class TestJSONAndPlain(MultipleFormattersTests):
+    formatters = ["json", "plain"]

data/vendor/behave/test/test_formatter_progress.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""
+Test progress formatters:
+  * behave.formatter.progress.ScenarioProgressFormatter
+  * behave.formatter.progress.StepProgressFormatter
+"""
+
+from __future__ import absolute_import
+from .test_formatter import FormatterTests as FormatterTest
+from .test_formatter import MultipleFormattersTests as MultipleFormattersTest
+
+class TestScenarioProgressFormatter(FormatterTest):
+    formatter_name = "progress"
+
+
+class TestStepProgressFormatter(FormatterTest):
+    formatter_name = "progress2"
+
+
+class TestPrettyAndScenarioProgress(MultipleFormattersTest):
+    formatters = ['pretty', 'progress']
+
+class TestPlainAndScenarioProgress(MultipleFormattersTest):
+    formatters = ['plain', 'progress']
+
+class TestJSONAndScenarioProgress(MultipleFormattersTest):
+    formatters = ['json', 'progress']
+
+class TestPrettyAndStepProgress(MultipleFormattersTest):
+    formatters = ['pretty', 'progress2']
+
+class TestPlainAndStepProgress(MultipleFormattersTest):
+    formatters = ['plain', 'progress2']
+
+class TestJSONAndStepProgress(MultipleFormattersTest):
+    formatters = ['json', 'progress2']
+
+class TestScenarioProgressAndStepProgress(MultipleFormattersTest):
+    formatters = ['progress', 'progress2']

data/vendor/behave/test/test_formatter_rerun.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""
+Test behave formatters:
+  * behave.formatter.rerun.RerunFormatter
+"""
+
+from __future__ import absolute_import
+from behave.model_core import Status
+from .test_formatter import FormatterTests as FormatterTest, _tf
+from .test_formatter import MultipleFormattersTests as MultipleFormattersTest
+from nose.tools import *
+
+class TestRerunFormatter(FormatterTest):
+    formatter_name = "rerun"
+
+    def test_feature_with_two_passing_scenarios(self):
+        p = self._formatter(_tf(), self.config)
+        f = self._feature()
+        scenarios = [ self._scenario(), self._scenario() ]
+        for scenario in scenarios:
+            f.add_scenario(scenario)
+
+        # -- FORMATTER CALLBACKS:
+        p.feature(f)
+        for scenario in f.scenarios:
+            p.scenario(scenario)
+            assert scenario.status == Status.passed
+        p.eof()
+        eq_([], p.failed_scenarios)
+        # -- EMIT REPORT:
+        p.close()
+
+    def test_feature_with_one_passing_one_failing_scenario(self):
+        p = self._formatter(_tf(), self.config)
+        f = self._feature()
+        passing_scenario = self._scenario()
+        failing_scenario = self._scenario()
+        failing_scenario.steps.append(self._step())
+        scenarios = [ passing_scenario, failing_scenario ]
+        for scenario in scenarios:
+            f.add_scenario(scenario)
+
+        # -- FORMATTER CALLBACKS:
+        p.feature(f)
+        for scenario in f.scenarios:
+            p.scenario(scenario)
+
+        failing_scenario.steps[0].status = Status.failed
+        assert scenarios[0].status == Status.passed
+        assert scenarios[1].status == Status.failed
+        p.eof()
+        eq_([ failing_scenario ], p.failed_scenarios)
+        # -- EMIT REPORT:
+        p.close()
+
+    def test_feature_with_one_passing_two_failing_scenario(self):
+        p = self._formatter(_tf(), self.config)
+        f = self._feature()
+        passing_scenario = self._scenario()
+        failing_scenario1 = self._scenario()
+        failing_scenario1.steps.append(self._step())
+        failing_scenario2 = self._scenario()
+        failing_scenario2.steps.append(self._step())
+        scenarios = [ failing_scenario1, passing_scenario, failing_scenario2 ]
+        for scenario in scenarios:
+            f.add_scenario(scenario)
+
+        # -- FORMATTER CALLBACKS:
+        p.feature(f)
+        for scenario in f.scenarios:
+            p.scenario(scenario)
+
+        failing_scenario1.steps[0].status = Status.failed
+        failing_scenario2.steps[0].status = Status.failed
+        assert scenarios[0].status == Status.failed
+        assert scenarios[1].status == Status.passed
+        assert scenarios[2].status == Status.failed
+        p.eof()
+        eq_([ failing_scenario1, failing_scenario2 ], p.failed_scenarios)
+        # -- EMIT REPORT:
+        p.close()
+
+
+class TestRerunAndPrettyFormatters(MultipleFormattersTest):
+    formatters = ["rerun", "pretty"]
+
+class TestRerunAndPlainFormatters(MultipleFormattersTest):
+    formatters = ["rerun", "plain"]
+
+class TestRerunAndScenarioProgressFormatters(MultipleFormattersTest):
+    formatters = ["rerun", "progress"]
+
+class TestRerunAndStepProgressFormatters(MultipleFormattersTest):
+    formatters = ["rerun", "progress2"]
+
+class TestRerunAndJsonFormatter(MultipleFormattersTest):
+    formatters = ["rerun", "json"]

data/vendor/behave/test/test_formatter_tags.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""
+Test formatters:
+  * behave.formatter.tags.TagsCountFormatter
+  * behave.formatter.tags.TagsLocationFormatter
+"""
+
+from __future__ import absolute_import
+from .test_formatter import FormatterTests as FormatterTest
+from .test_formatter import MultipleFormattersTests as MultipleFormattersTest
+
+# -----------------------------------------------------------------------------
+# FORMATTER TESTS: With TagCountFormatter
+# -----------------------------------------------------------------------------
+class TestTagsCountFormatter(FormatterTest):
+    formatter_name = "tags"
+
+# -----------------------------------------------------------------------------
+# FORMATTER TESTS: With TagLocationFormatter
+# -----------------------------------------------------------------------------
+class TestTagsLocationFormatter(FormatterTest):
+    formatter_name = "tags.location"
+
+
+# -----------------------------------------------------------------------------
+# MULTI-FORMATTER TESTS: With TagCountFormatter
+# -----------------------------------------------------------------------------
+class TestPrettyAndTagsCount(MultipleFormattersTest):
+    formatters = ["pretty", "tags"]
+
+class TestPlainAndTagsCount(MultipleFormattersTest):
+    formatters = ["plain", "tags"]
+
+class TestJSONAndTagsCount(MultipleFormattersTest):
+    formatters = ["json", "tags"]
+
+class TestRerunAndTagsCount(MultipleFormattersTest):
+    formatters = ["rerun", "tags"]
+
+
+# -----------------------------------------------------------------------------
+# MULTI-FORMATTER TESTS: With TagLocationFormatter
+# -----------------------------------------------------------------------------
+class TestPrettyAndTagsLocation(MultipleFormattersTest):
+    formatters = ["pretty", "tags.location"]
+
+class TestPlainAndTagsLocation(MultipleFormattersTest):
+    formatters = ["plain", "tags.location"]
+
+class TestJSONAndTagsLocation(MultipleFormattersTest):
+    formatters = ["json", "tags.location"]
+
+class TestRerunAndTagsLocation(MultipleFormattersTest):
+    formatters = ["rerun", "tags.location"]
+
+class TestTagsCountAndTagsLocation(MultipleFormattersTest):
+    formatters = ["tags", "tags.location"]