busser-behave 0.1.3

data/vendor/behave/tests/unit/test_capture.py

@@ -0,0 +1,280 @@
+# -*- coding: UTF-8 -*-
+"""
+Unittests for :mod:`behave.capture` module.
+"""
+
+from __future__ import absolute_import, print_function
+import sys
+from behave.capture import Captured, CaptureController
+from mock import Mock
+import pytest
+
+# -----------------------------------------------------------------------------
+# TEST SUPPORT:
+# -----------------------------------------------------------------------------
+def create_capture_controller(config=None):
+    if not config:
+        config = Mock()
+        config.stdout_capture = True
+        config.stderr_capture = True
+        config.log_capture = True
+        config.logging_filter = None
+        config.logging_level = "INFO"
+    return CaptureController(config)
+
+def setup_capture_controller(capture_controller, context=None):
+    if not context:
+        context = Mock()
+    context.aborted = False
+    context.config = capture_controller.config
+    capture_controller.setup_capture(context)
+
+
+# -----------------------------------------------------------------------------
+# FIXTURES:
+# -----------------------------------------------------------------------------
+@pytest.fixture
+def capture_controller():
+    """Provides a capture_controller that is already setup and automatically
+    performs a teardown afterwards.
+    """
+    capture_controller = create_capture_controller()
+    setup_capture_controller(capture_controller)
+    yield capture_controller
+    # -- CLEANUP:
+    capture_controller.teardown_capture()
+
+
+# -----------------------------------------------------------------------------
+# TEST SUITE:
+# -----------------------------------------------------------------------------
+class TestCaptured(object):
+
+    def test_default_ctor(self):
+        captured = Captured()
+        assert captured.stdout == u""
+        assert captured.stderr == u""
+        assert captured.log_output == u""
+        assert not captured
+
+    def test_ctor_with_params(self):
+        captured = Captured(u"STDOUT", u"STDERR", u"LOG_OUTPUT")
+        assert captured.stdout == u"STDOUT"
+        assert captured.stderr == u"STDERR"
+        assert captured.log_output == u"LOG_OUTPUT"
+
+        captured = Captured(stdout=u"STDOUT")
+        assert captured.stdout == u"STDOUT"
+        assert captured.stderr == u""
+        assert captured.log_output == u""
+
+        captured = Captured(stderr=u"STDERR")
+        assert captured.stdout == u""
+        assert captured.stderr == u"STDERR"
+        assert captured.log_output == u""
+
+        captured = Captured(log_output=u"LOG_OUTPUT")
+        assert captured.stdout == u""
+        assert captured.stderr == u""
+        assert captured.log_output == u"LOG_OUTPUT"
+
+    def test_reset(self):
+        captured = Captured("STDOUT", "STDERR", "LOG_OUTPUT")
+        captured.reset()
+        assert captured.stdout == u""
+        assert captured.stderr == u""
+        assert captured.log_output == u""
+        assert not captured
+
+    def test_bool_conversion__returns_false_without_captured_output(self):
+        captured = Captured()
+        assert bool(captured) == False
+
+    @pytest.mark.parametrize("params", [
+        dict(stdout="xxx"),
+        dict(stderr="yyy"),
+        dict(log_output="zzz"),
+        dict(stderr="yyy", log_output="zzz"),
+        dict(stdout="xxx", stderr="yyy", log_output="zzz"),
+    ])
+    def test_bool_conversion__returns_true_with_captured_output(self, params):
+        captured = Captured(**params)
+        assert bool(captured)
+
+    @pytest.mark.parametrize("params, expected", [
+        (dict(), ""),
+        (dict(stdout="STDOUT"), "STDOUT"),
+        (dict(stderr="STDERR"), "STDERR"),
+        (dict(log_output="LOG_OUTPUT"), "LOG_OUTPUT"),
+        (dict(stdout="STDOUT", stderr="STDERR"), "STDOUT\nSTDERR"),
+        (dict(stdout="STDOUT", log_output="LOG_OUTPUT"), "STDOUT\nLOG_OUTPUT"),
+        (dict(stdout="STDOUT", stderr="STDERR", log_output="LOG_OUTPUT"),
+         "STDOUT\nSTDERR\nLOG_OUTPUT"),
+    ])
+    def test_output__contains_concatenated_parts(self, params, expected):
+        captured = Captured(**params)
+        assert captured.output == expected
+
+    def test_add__without_captured_data(self):
+        captured1 = Captured()
+        captured2 = Captured("STDOUT", "STDERR", "LOG_OUTPUT")
+        captured1.add(captured2)
+        assert captured1.stdout == "STDOUT"
+        assert captured1.stderr == "STDERR"
+        assert captured1.log_output == "LOG_OUTPUT"
+
+    def test_add__with_captured_data(self):
+        captured1 = Captured("stdout1", "stderr1", "log_output1")
+        captured2 = Captured("STDOUT2", "STDERR2", "LOG_OUTPUT2")
+
+        captured1.add(captured2)
+        assert captured1.stdout == "stdout1\nSTDOUT2"
+        assert captured1.stderr == "stderr1\nSTDERR2"
+        assert captured1.log_output == "log_output1\nLOG_OUTPUT2"
+
+    def test_operator_add(self):
+        captured1 = Captured("stdout1", "stderr1", "log_output1")
+        captured2 = Captured("STDOUT2", "STDERR2", "LOG_OUTPUT2")
+
+        captured3 = captured1 + captured2
+        assert captured3.stdout == "stdout1\nSTDOUT2"
+        assert captured3.stderr == "stderr1\nSTDERR2"
+        assert captured3.log_output == "log_output1\nLOG_OUTPUT2"
+        # -- ENSURE: captured1 is not modified.
+        assert captured1.stdout == "stdout1"
+        assert captured1.stderr == "stderr1"
+        assert captured1.log_output == "log_output1"
+        # -- ENSURE: captured2 is not modified.
+        assert captured2.stdout == "STDOUT2"
+        assert captured2.stderr == "STDERR2"
+        assert captured2.log_output == "LOG_OUTPUT2"
+
+    def test_operator_iadd(self):
+        captured1 = Captured("stdout1", "stderr1", "log_output1")
+        captured2 = Captured("STDOUT2", "STDERR2", "LOG_OUTPUT2")
+
+        captured1 += captured2
+        assert captured1.stdout == "stdout1\nSTDOUT2"
+        assert captured1.stderr == "stderr1\nSTDERR2"
+        assert captured1.log_output == "log_output1\nLOG_OUTPUT2"
+        # -- ENSURE: captured2 is not modified.
+        assert captured2.stdout == "STDOUT2"
+        assert captured2.stderr == "STDERR2"
+        assert captured2.log_output == "LOG_OUTPUT2"
+
+    def test_make_report__with_all_sections(self):
+        captured = Captured(stdout="xxx", stderr="yyy", log_output="zzz")
+        expected = """\
+Captured stdout:
+xxx
+
+Captured stderr:
+yyy
+
+Captured logging:
+zzz"""
+        assert captured.make_report() == expected
+
+    def test_make_report__should_only_contain_nonempty_data_sections(self):
+        captured1 = Captured(stdout="xxx")
+        expected = "Captured stdout:\nxxx"
+        assert captured1.make_report() == expected
+
+        captured2 = Captured(stderr="yyy")
+        expected = "Captured stderr:\nyyy"
+        assert captured2.make_report() == expected
+
+        captured3 = Captured(log_output="zzz")
+        expected = "Captured logging:\nzzz"
+        assert captured3.make_report() == expected
+
+
+class Theory4ActiveCaptureController(object):
+    @staticmethod
+    def check_invariants(controller):
+        if controller.config.capture_stdout:
+            assert controller.stdout_capture is not None
+            assert sys.stdout is controller.stdout_capture
+        else:
+            assert controller.stdout_capture is None
+            assert sys.stdout is not controller.stdout_capture
+
+        if controller.config.capture_stderr:
+            assert controller.stderr_capture is not None
+            assert sys.stderr is controller.stderr_capture
+        else:
+            assert controller.stderr_capture is None
+            assert sys.stderr is not controller.stderr_capture
+
+        if controller.config.capture_log:
+            assert controller.log_capture is not None
+            # assert sys.stderr is controller.stderr_capture
+        else:
+            assert controller.log_capture is None
+            # assert sys.stderr is not controller.stderr_capture
+
+
+class TestCaptureController(object):
+
+    # @pytest.no_capture
+    def test_basics(self):
+        capture_controller = create_capture_controller()
+        context = Mock()
+        context.aborted = False
+        context.config = capture_controller.config
+
+        capture_controller.setup_capture(context)
+        # XXX AVOID: Due to pytest capture mode
+        # Theory4ActiveCaptureController.check_invariants(capture_controller)
+
+        capture_controller.start_capture()
+        sys.stdout.write("HELLO\n")
+        sys.stderr.write("world\n")
+        capture_controller.stop_capture()
+        assert capture_controller.captured.output == "HELLO\nworld\n"
+
+        # -- FINALLY:
+        capture_controller.teardown_capture()
+
+    def test_capturing__retrieve_captured_several_times(self, capture_controller):
+        capture_controller.start_capture()
+        sys.stdout.write("HELLO\n")
+        sys.stderr.write("Alice\n")
+        assert capture_controller.captured.output == "HELLO\nAlice\n"
+
+        print("Sam")
+        sys.stderr.write("Bob\n")
+        capture_controller.stop_capture()
+        assert capture_controller.captured.output == "HELLO\nSam\nAlice\nBob\n"
+
+
+    def test_capturing__with_several_start_stop_cycles(self, capture_controller):
+        capture_controller.start_capture()
+        sys.stdout.write("HELLO\n")
+        sys.stderr.write("Alice\n")
+        capture_controller.stop_capture()
+        assert capture_controller.captured.output == "HELLO\nAlice\n"
+
+        sys.stdout.write("__UNCAPTURED:stdout;\n")
+        sys.stderr.write("__UNCAPTURED:stderr;\n")
+
+        capture_controller.start_capture()
+        sys.stdout.write("Sam\n")
+        sys.stderr.write("Bob\n")
+        capture_controller.stop_capture()
+        assert capture_controller.captured.output == "HELLO\nSam\nAlice\nBob\n"
+
+
+    def test_make_capture_report(self, capture_controller):
+        capture_controller.start_capture()
+        print("HELLO")
+        sys.stderr.write("Alice\n")
+        capture_controller.stop_capture()
+        report = capture_controller.make_capture_report()
+        expected = """\
+Captured stdout:
+HELLO
+
+Captured stderr:
+Alice"""
+        assert report == expected

data/vendor/behave/tests/unit/test_model_core.py

@@ -0,0 +1,56 @@
+# -*- coding: UTF-8 -*-
+"""
+(Additional) Unit tests for :mod:`behave.model_core` module.
+"""
+
+from __future__ import print_function
+from behave.model_core import Status
+import pytest
+
+
+# -----------------------------------------------------------------------------
+# TESTS:
+# -----------------------------------------------------------------------------
+class TestStatus(object):
+    """Test Status enum class.
+    In addition, checks if it is partly backward compatibility to
+    string-based status.
+
+    EXAMPLE::
+
+        status = Status.passed
+        assert status == "passed"
+        assert status != "failed"
+        assert status == Status.from_name("passed")
+    """
+
+    @pytest.mark.parametrize("enum_value", list(Status.__members__.values()))
+    def test_equals__with_string_value(self, enum_value):
+        """Ensure that Status enum value can be compared with a string-status"""
+        assert enum_value == enum_value.name
+
+    @pytest.mark.parametrize("enum_value", list(Status.__members__.values()))
+    def test_equals__with_unknown_name(self, enum_value):
+        assert enum_value != "__UNKNOWN__"
+        assert not (enum_value == "__UNKNOWN__")
+
+    @pytest.mark.parametrize("enum_value, similar_name", [
+        (Status.passed, "Passed"),
+        (Status.failed, "FAILED"),
+        (Status.passed, "passed1"),
+        (Status.failed, "failed2"),
+    ])
+    def test_equals__with_similar_name(self, enum_value, similar_name):
+        assert enum_value != similar_name
+
+    @pytest.mark.parametrize("enum_value", list(Status.__members__.values()))
+    def test_from_name__with_known_names(self, enum_value):
+        assert enum_value == Status.from_name(enum_value.name)
+
+
+    @pytest.mark.parametrize("unknown_name", [
+        "Passed", "Failed", "passed2", "failed1"
+    ])
+    def test_from_name__with_unknown_name_raises_lookuperror(self, unknown_name):
+        with pytest.raises(LookupError):
+            Status.from_name(unknown_name)

data/vendor/behave/tests/unit/test_textutil.py

@@ -0,0 +1,267 @@
+# -*- coding: UTF-8 -*-
+"""
+Unit tests for :mod:`behave.textutil`.
+"""
+
+from __future__ import absolute_import, print_function
+from behave.textutil import text, is_ascii_encoding, select_best_encoding
+import pytest
+import codecs
+import six
+
+# -----------------------------------------------------------------------------
+# TEST SUPPORT:
+# -----------------------------------------------------------------------------
+class ConvertableToUnicode(object):
+    """Class that can be converted into a unicode string.
+    If parameter is a bytes-string, it is converted into unicode.
+
+    .. code-block:: python
+
+        obj1 = ConvertableToUnicode(u"Ärgernis")
+        obj2 = ConvertableToUnicode(u"Ärgernis".encode("latin-1")
+
+        # -- CASE Python2: string is a bytes-string
+        text_value21 = unicode(obj1)
+        text_value22 = unicode(obj2)
+
+        # -- CASE Python3: string is a unicode-string
+        text_value31 = str(obj1)
+        text_value32 = str(obj2)
+    """
+    encoding = "utf-8"
+
+    def __init__(self, text, encoding=None):
+        self.text = text
+        self.encoding = encoding or self.__class__.encoding
+
+    def __str__(self):
+        """Convert into a unicode string."""
+        text = self.text
+        if isinstance(text, six.binary_type):
+            text = codecs.decode(text, self.encoding)
+        return text
+
+    if six.PY2:
+        __unicode__ = __str__
+        __str__ = lambda self: self.__unicode__().encode(self.encoding)
+
+class ConvertableToString(object):
+    encoding = "utf-8"
+
+    def __init__(self, text, encoding=None):
+        self.text = text
+        self.encoding = encoding or self.__class__.encoding
+
+    def __str__(self):
+        text = self.text
+        if isinstance(text, six.binary_type):
+            text = codecs.decode(text, self.encoding)
+        return text
+
+    if six.PY2:
+        __unicode__ = __str__
+
+        def __str__(self):
+            # MAYBE: self.__unicode__().encode(self.encoding)
+            text = self.text
+            if isinstance(text, six.text_type):
+                text = codecs.encode(text, self.encoding)
+            return text
+
+class ConvertableToPy2String(object):
+    encoding = "utf-8"
+
+    def __init__(self, text, encoding=None):
+        self.text = text
+        self.encoding = encoding or self.__class__.encoding
+
+    def __str__(self):
+        text = self.text
+        if six.PY2:
+            if isinstance(text, six.text_type):
+                text = codecs.encode(text, self.encoding)
+        else:
+            if isinstance(text, six.bytes_type):
+                text = codecs.decode(text, self.encoding)
+        return text
+
+    if six.PY2:
+        __unicode__ = __str__
+
+        def __str__(self):
+            # MAYBE: self.__unicode__().encode(self.encoding)
+            text = self.text
+            if isinstance(text, six.text_type):
+                text = codecs.encode(text, self.encoding)
+            return text
+
+# def raise_exception(exception_class, *args):
+#     raise exception_class(*args)
+#
+# def catch_raised_exception_and_return_as_text(exception_class, *args, **kwargs):
+#     encoding = kwargs.pop("encoding", None)
+#     try:
+#         raise_exception(*args)
+#     except Exception as e:
+#         return text(e, encoding=encoding)
+
+
+# -----------------------------------------------------------------------------
+# TEST SUITE
+# -----------------------------------------------------------------------------
+xfail = pytest.mark.xfail
+requires_python2 = pytest.mark.skipif(not six.PY2, reason="requires python2")
+
+UNICODE_TEXT_VALUES1 = [u"Alice", u"Bob"]
+UNICODE_TEXT_VALUES = [u"Café", u"100€ (Euro)", u"Frühaufsteher"]
+BYTES_TEXT_TUPLES_WITH_UTF8_ENCODING = [
+    (codecs.encode(_text, "utf-8"), _text) for _text in UNICODE_TEXT_VALUES
+]
+
+
+class TestTextConversion(object):
+    """Unit tests for the :func:`behave.textutil.text()` function."""
+
+    @pytest.mark.parametrize("value", UNICODE_TEXT_VALUES)
+    def test_text__with_unicode_value(self, value):
+        value_id = id(value)
+        actual_text = text(value)
+        assert actual_text == value
+        assert id(actual_text) == value_id  # PARANOID check w/ unicode copy.
+
+    @pytest.mark.parametrize("bytes_value, expected_text",
+                             BYTES_TEXT_TUPLES_WITH_UTF8_ENCODING)
+    def test_text__with_bytes_value(self, bytes_value, expected_text):
+        actual_text = text(bytes_value)
+        assert actual_text == expected_text
+
+
+    @pytest.mark.parametrize("text_value, encoding", [
+        (u"Ärgernis", "UTF-8"),
+        (u"Übermut", "UTF-8"),
+    ])
+    def test_text__with_bytes_value_and_encoding(self, text_value, encoding):
+        bytes_value = text_value.encode(encoding)
+        assert isinstance(bytes_value, bytes)
+
+        actual = text(bytes_value, encoding)
+        assert isinstance(actual, six.text_type)
+        assert actual == text_value
+
+    def test_text__with_exception_traceback(self): pass
+
+    @pytest.mark.parametrize("text_value", UNICODE_TEXT_VALUES)
+    def test_text__with_object_convertable_to_unicode(self, text_value):
+        obj = ConvertableToUnicode(text_value)
+        actual_text = text(obj)
+        assert actual_text == text_value
+        assert isinstance(actual_text, six.text_type)
+
+    # @pytest.mark.parametrize("expected, text_value, encoding", [
+    #     (u"Ärgernis", u"Ärgernis".encode("UTF-8"), "UTF-8"),
+    #     (u"Übermut",  u"Übermut".encode("latin-1"), "latin-1"),
+    # ])
+    # def test_text__with_object_convertable_to_unicode2(self, expected,
+    #                                                    text_value, encoding):
+    #     obj = ConvertableToUnicode(text_value, encoding)
+    #     actual_text = text(obj)
+    #     assert actual_text == expected
+    #     assert isinstance(actual_text, six.text_type)
+
+    @pytest.mark.parametrize("text_value", UNICODE_TEXT_VALUES)
+    def test_text__with_object_convertable_to_string(self, text_value):
+        obj = ConvertableToString(text_value)
+        actual_text = text(obj)
+        assert actual_text == text_value
+        assert isinstance(actual_text, six.text_type)
+
+    @xfail
+    @requires_python2
+    @pytest.mark.parametrize("text_value", UNICODE_TEXT_VALUES)
+    def test_text__with_object_convertable_to_py2string_only(self, text_value):
+        class ConvertableToPy2String(object):
+            """Lacks feature: convertable-to-unicode (only: to-string)"""
+            def __init__(self, message=""):
+                self.message = message or ""
+                if self.message and isinstance(self.message, six.text_type):
+                    self.message = self.message.encode("UTF-8")
+
+            def __str__(self):
+                # assert isinstance(self.message, str)
+                return self.message
+
+        obj = ConvertableToPy2String(text_value.encode("UTF-8"))
+        actual = text(obj)
+        print(u"actual: %s" % actual)
+        print(u"text_value: %s" % text_value)
+        assert actual == text_value
+
+
+class TestObjectToTextConversion(object):
+    """Unit tests for the :func:`behave.textutil.text()` function.
+    Explore case with object-to-text conversion.
+    """
+    ENCODING = "UTF-8"
+
+    # -- CASE: object=exception
+    @pytest.mark.parametrize("message", [
+        u"Ärgernis", u"Übermütig"
+    ])
+    def test_text__with_assert_failed_and_unicode_message(self, message):
+        with pytest.raises(AssertionError) as e:
+            assert False, message
+
+        text2 = text(e)
+        expected = u"AssertionError: %s" % message
+        assert text2.endswith(expected)
+
+    @requires_python2
+    @pytest.mark.parametrize("message", [
+        u"Ärgernis", u"Übermütig"
+    ])
+    def test_text__with_assert_failed_and_bytes_message(self, message):
+        # -- ONLY PYTHON2: Use case makes no sense for Python 3.
+        bytes_message = message.encode(self.ENCODING)
+        with pytest.raises(AssertionError) as e:
+            assert False, bytes_message
+
+        text2 = text(e)
+        expected = u"AssertionError: %s" % message
+        assert text2.endswith(expected)
+
+    @pytest.mark.parametrize("exception_class, message", [
+        (AssertionError, u"Ärgernis"),
+        (RuntimeError, u"Übermütig"),
+    ])
+    def test_text__with_raised_exception_and_unicode_message(self,
+                                                             exception_class,
+                                                             message):
+        with pytest.raises(exception_class) as e:
+            raise exception_class(message)
+
+        text2 = text(e)
+        expected = u"%s: %s" % (exception_class.__name__, message)
+        assert isinstance(text2, six.text_type)
+        assert text2.endswith(expected)
+
+    @requires_python2
+    @pytest.mark.parametrize("exception_class, message", [
+        (AssertionError, u"Ärgernis"),
+        (RuntimeError, u"Übermütig"),
+    ])
+    def test_text__with_raised_exception_and_bytes_message(self, exception_class,
+                                                           message):
+        # -- ONLY PYTHON2: Use case makes no sense for Python 3.
+        bytes_message = message.encode(self.ENCODING)
+        with pytest.raises(exception_class) as e:
+            raise exception_class(bytes_message)
+
+        text2 = text(e)
+        unicode_message = bytes_message.decode(self.ENCODING)
+        expected = u"%s: %s" % (exception_class.__name__, unicode_message)
+        assert isinstance(text2, six.text_type)
+        assert text2.endswith(expected)
+        # -- DIAGNOSTICS:
+        print(u"text2: "+ text2)
+        print(u"expected: " + expected)