busser-behave 0.1.3

data/vendor/behave/test/test_userdata.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from behave.configuration import Configuration
+from behave.userdata import UserData, parse_user_define
+from behave._types import Unknown
+from unittest import TestCase
+from nose.tools import eq_
+
+
+class TestParseUserDefine(TestCase):
+    """Test parse_user_define() function."""
+
+    def test_parse__name_value(self):
+        parts = parse_user_define("person=Alice")
+        self.assertEqual(parts, ("person", "Alice"))
+
+    def test_parse__name_only_for_boolean_flag(self):
+        parts = parse_user_define("boolean_flag")
+        self.assertEqual(parts, ("boolean_flag", "true"))
+
+    def test_parse__name_value_with_padded_whitespace(self):
+        texts = [
+            "  person=Alice",
+            "person=Alice  ",
+            "person = Alice",
+        ]
+        for text in texts:
+            parts = parse_user_define(text)
+            self.assertEqual(parts, ("person", "Alice"))
+
+    def test_parse__name_value_with_quoted_name_value_pair(self):
+        texts = [
+            '"person=Alice and Bob"',
+            "'person=Alice and Bob'",
+        ]
+        for text in texts:
+            parts = parse_user_define(text)
+            self.assertEqual(parts, ("person", "Alice and Bob"))
+
+    def test_parse__name_value_with_quoted_value(self):
+        texts = [
+            'person="Alice and Bob"',
+            "person='Alice and Bob'",
+        ]
+        for text in texts:
+            parts = parse_user_define(text)
+            self.assertEqual(parts, ("person", "Alice and Bob"))
+
+
+
+
+class TestUserData(TestCase):
+    """Test UserData class."""
+
+    def test_userdata_is_dictlike(self):
+        userdata = UserData(name="Foo", number=42)
+        value1 = userdata["name"]
+        value2 = userdata.get("number")
+        value3 = userdata.get("unknown", Unknown)
+        assert isinstance(userdata, dict)
+        self.assertEqual(value1, "Foo")
+        self.assertEqual(value2, 42)
+        assert value3 is Unknown
+
+    def test_getas__with_known_param_and_valid_text(self):
+        userdata = UserData(param="42")
+        assert "param" in userdata, "ENSURE: known param"
+
+        value = userdata.getas(int, "param")
+        assert isinstance(value, int)
+        self.assertEqual(value, 42)
+
+    def test_getas__with_known_param_and_invalid_text_raises_ValueError(self):
+        userdata = UserData(param="__BAD_NUMBER__")
+        assert "param" in userdata, "ENSURE: known param"
+        self.assertRaises(ValueError, userdata.getas, int, "param")
+
+    def test_getas__with_known_param_and_preconverted_value(self):
+        userdata = UserData(param=42)
+        assert "param" in userdata, "ENSURE: known param"
+
+        value = userdata.getas(int, "param")
+        assert isinstance(value, int)
+        self.assertEqual(value, 42)
+
+    def test_getas__with_known_param_and_preconverted_value_and_valuetype(self):
+        userdata = UserData(param=42)
+        assert "param" in userdata, "ENSURE: known param"
+
+        def parse_int(text):
+            return int(text)
+
+        value = userdata.getas(parse_int, "param", valuetype=int)
+        assert isinstance(value, int)
+        self.assertEqual(value, 42)
+
+    def test_getas__with_unknown_param_without_default_returns_none(self):
+        userdata = UserData()
+        assert "param" not in userdata, "ENSURE: unknown param"
+
+        value = userdata.getas(int, "param")
+        assert value is None
+
+    def test_getas__with_unknown_param_returns_default_value(self):
+        userdata = UserData()
+        assert "param" not in userdata, "ENSURE: unknown param"
+
+        value = userdata.getas(int, "param", 123)
+        assert isinstance(value, int)
+        self.assertEqual(value, 123)
+
+
+    def test_getint__with_known_param_and_valid_text(self):
+        userdata = UserData(param="42")
+        value = userdata.getint("param")
+        assert isinstance(value, int)
+        self.assertEqual(value, 42)
+
+    def test_getint__with_known_param_and_invalid_text_raises_ValueError(self):
+        userdata = UserData(param="__BAD_NUMBER__")
+        self.assertRaises(ValueError, userdata.getint, "param")
+
+    def test_getint__with_unknown_param_without_default_returns_zero(self):
+        userdata = UserData()
+        value = userdata.getint("param")
+        self.assertEqual(value, 0)
+
+    def test_getint__with_unknown_param_returns_default_value(self):
+        userdata = UserData()
+        value = userdata.getint("param", 123)
+        assert isinstance(value, int)
+        self.assertEqual(value, 123)
+
+    def test_getfloat__with_known_param_and_valid_text(self):
+        for valid_text in ["1.2", "2", "-1E+3", "+2.34E-5"]:
+            userdata = UserData(param=valid_text)
+            value = userdata.getfloat("param")
+            assert isinstance(value, float)
+            self.assertEqual(value, float(valid_text))
+
+    def test_getfloat__with_known_param_and_invalid_text_raises_ValueError(self):
+        userdata = UserData(param="__BAD_NUMBER__")
+        self.assertRaises(ValueError, userdata.getfloat, "param")
+
+    def test_getfloat__with_unknown_param_without_default_returns_zero(self):
+        userdata = UserData()
+        value = userdata.getfloat("param")
+        self.assertEqual(value, 0.0)
+
+    def test_getfloat__with_unknown_param_returns_default_value(self):
+        userdata = UserData()
+        value = userdata.getint("param", 1.2)
+        assert isinstance(value, float)
+        self.assertEqual(value, 1.2)
+
+
+    def test_getbool__with_known_param_and_valid_text(self):
+        for true_text in ["true", "TRUE", "True", "yes", "on", "1"]:
+            userdata = UserData(param=true_text)
+            value = userdata.getbool("param")
+            assert isinstance(value, bool), "text=%s" % true_text
+            self.assertEqual(value, True)
+
+        for false_text in ["false", "FALSE", "False", "no", "off", "0"]:
+            userdata = UserData(param=false_text)
+            value = userdata.getbool("param")
+            assert isinstance(value, bool), "text=%s" % false_text
+            self.assertEqual(value, False)
+
+    def test_getbool__with_known_param_and_invalid_text_raises_ValueError(self):
+        userdata = UserData(param="__BAD_VALUE__")
+        self.assertRaises(ValueError, userdata.getbool, "param")
+
+    def test_getbool__with_unknown_param_without_default_returns_false(self):
+        userdata = UserData()
+        value = userdata.getfloat("param")
+        self.assertEqual(value, False)
+
+    def test_getbool__with_unknown_param_returns_default_value(self):
+        userdata = UserData()
+        value = userdata.getint("param", 1.2)
+        assert isinstance(value, float)
+        self.assertEqual(value, 1.2)

data/vendor/behave/tests/README.txt

@@ -0,0 +1,12 @@
+This is the new directory root for:
+
+* unit tests
+* functional tests (that do not use feature files)
+
+The tests here use the :pypi:`pytest` test framework for testing.
+
+.. note::
+
+    Other tests in the collocated "../test/" directory will be eventually
+    cleaned and converted in (clean) pytests ;-)
+

data/vendor/behave/tests/api/_test_async_step34.py

@@ -0,0 +1,130 @@
+# -*- coding: UTF-8 -*-
+"""
+Unit tests for :mod:`behave.api.async_test`.
+"""
+
+# -- IMPORTS:
+from __future__ import absolute_import, print_function
+from behave.api.async_step import AsyncContext, use_or_create_async_context
+from behave._stepimport import use_step_import_modules
+from behave.runner import Context, Runner
+import sys
+from mock import Mock
+import pytest
+
+from .testing_support import StopWatch, SimpleStepContainer
+from .testing_support_async import AsyncStepTheory
+
+
+# -----------------------------------------------------------------------------
+# ASYNC STEP EXAMPLES:
+# -----------------------------------------------------------------------------
+# if python_version >= 3.5:
+#     @step('an async coroutine step waits "{duration:f}" seconds')
+#     @async_run_until_complete
+#     async def step_async_step_waits_seconds(context, duration):
+#         print("async_step: Should sleep for %.3f seconds" % duration)
+#         await asyncio.sleep(duration)
+#
+# if python_version >= 3.4:
+#     @step('a tagged-coroutine async step waits "{duration:f}" seconds')
+#     @async_run_until_complete
+#     @asyncio.coroutine
+#     def step_async_step_waits_seconds2(context, duration):
+#         print("async_step2: Should sleep for %.3f seconds" % duration)
+#         yield from asyncio.sleep(duration)
+#
+# -----------------------------------------------------------------------------
+# TEST MARKERS:
+# -----------------------------------------------------------------------------
+python_version = float("%s.%s" % sys.version_info[:2])
+
+# xfail = pytest.mark.xfail
+py34_or_newer = pytest.mark.skipif(python_version < 3.4, reason="Needs Python >= 3.4")
+
+# -----------------------------------------------------------------------------
+# TESTSUITE:
+# -----------------------------------------------------------------------------
+@py34_or_newer
+class TestAsyncStepDecorator34(object):
+
+    def test_step_decorator_async_run_until_complete2(self):
+        step_container = SimpleStepContainer()
+        with use_step_import_modules(step_container):
+            # -- STEP-DEFINITIONS EXAMPLE (as MODULE SNIPPET):
+            # VARIANT 2: Use @asyncio.coroutine def step_impl()
+            from behave import step
+            from behave.api.async_step import async_run_until_complete
+            import asyncio
+
+            @step('a tagged-coroutine async step waits "{duration:f}" seconds')
+            @async_run_until_complete
+            @asyncio.coroutine
+            def step_async_step_waits_seconds2(context, duration):
+                yield from asyncio.sleep(duration)
+
+        # -- USES: async def step_impl(...) as async-step (coroutine)
+        AsyncStepTheory.validate(step_async_step_waits_seconds2)
+
+        # -- RUN ASYNC-STEP: Verify that it is behaving correctly.
+        # ENSURE: Execution of async-step matches expected duration.
+        context = Context(runner=Runner(config={}))
+        with StopWatch() as stop_watch:
+            step_async_step_waits_seconds2(context, duration=0.2)
+        assert abs(stop_watch.duration - 0.2) <= 0.05
+
+
+class TestAsyncContext(object):
+    @staticmethod
+    def make_context():
+        return Context(runner=Runner(config={}))
+
+    def test_use_or_create_async_context__when_missing(self):
+        # -- CASE: AsynContext attribute is created with default_name
+        context = self.make_context()
+        context._push()
+
+        async_context = use_or_create_async_context(context)
+        assert isinstance(async_context, AsyncContext)
+        assert async_context.name == "async_context"
+        assert getattr(context, "async_context", None) is async_context
+
+        context._pop()
+        assert getattr(context, "async_context", None) is None
+
+    def test_use_or_create_async_context__when_exists(self):
+        # -- CASE: AsynContext attribute exists with default_name
+        context = self.make_context()
+        async_context0 = context.async_context = AsyncContext()
+        assert context.async_context.name == "async_context"
+        assert hasattr(context, AsyncContext.default_name)
+
+        async_context = use_or_create_async_context(context)
+        assert isinstance(async_context, AsyncContext)
+        assert async_context.name == "async_context"
+        assert getattr(context, "async_context", None) is async_context
+        assert async_context is async_context0
+
+    def test_use_or_create_async_context__when_missing_with_name(self):
+        # -- CASE: AsynContext attribute is created with own name
+        loop0 = Mock()
+        context = self.make_context()
+        async_context = use_or_create_async_context(context, "acontext", loop=loop0)
+        assert isinstance(async_context, AsyncContext)
+        assert async_context.name == "acontext"
+        assert getattr(context, "acontext", None) is async_context
+        assert async_context.loop is loop0
+
+    def test_use_or_create_async_context__when_exists_with_name(self):
+        # -- CASE: AsynContext attribute exists with own name
+        loop0 = Mock()
+        context = self.make_context()
+        async_context0 = context.acontext = AsyncContext(name="acontext", loop=loop0)
+        assert context.acontext.name == "acontext"
+
+        loop1 = Mock()
+        async_context = use_or_create_async_context(context, "acontext", loop=loop1)
+        assert isinstance(async_context, AsyncContext)
+        assert async_context is async_context0
+        assert getattr(context, "acontext", None) is async_context
+        assert async_context.loop is loop0

data/vendor/behave/tests/api/_test_async_step35.py

@@ -0,0 +1,75 @@
+# -*- coding: UTF-8 -*-
+"""
+Unit tests for :mod:`behave.api.async_test` for Python 3.5 (or newer).
+"""
+
+# -- IMPORTS:
+from __future__ import absolute_import, print_function
+import sys
+from behave._stepimport import use_step_import_modules
+from behave.runner import Context, Runner
+import pytest
+
+from .testing_support import StopWatch, SimpleStepContainer
+from .testing_support_async import AsyncStepTheory
+
+
+# -----------------------------------------------------------------------------
+# SUPPORT:
+# -----------------------------------------------------------------------------
+
+
+# -----------------------------------------------------------------------------
+# ASYNC STEP EXAMPLES:
+# -----------------------------------------------------------------------------
+# if python_version >= 3.5:
+#     @step('an async coroutine step waits "{duration:f}" seconds')
+#     @async_run_until_complete
+#     async def step_async_step_waits_seconds(context, duration):
+#         print("async_step: Should sleep for %.3f seconds" % duration)
+#         await asyncio.sleep(duration)
+#
+# if python_version >= 3.4:
+#     @step('a tagged-coroutine async step waits "{duration:f}" seconds')
+#     @async_run_until_complete
+#     @asyncio.coroutine
+#     def step_async_step_waits_seconds2(context, duration):
+#         print("async_step2: Should sleep for %.3f seconds" % duration)
+#         yield from asyncio.sleep(duration)
+#
+# -----------------------------------------------------------------------------
+# TEST MARKERS:
+# -----------------------------------------------------------------------------
+# xfail = pytest.mark.xfail
+python_version = float("%s.%s" % sys.version_info[:2])
+py35_or_newer = pytest.mark.skipif(python_version < 3.5, reason="Needs Python >= 3.5")
+
+# -----------------------------------------------------------------------------
+# TESTSUITE:
+# -----------------------------------------------------------------------------
+@py35_or_newer
+class TestAsyncStepDecorator35(object):
+
+    def test_step_decorator_async_run_until_complete1(self):
+        step_container = SimpleStepContainer()
+        with use_step_import_modules(step_container):
+            # -- STEP-DEFINITIONS EXAMPLE (as MODULE SNIPPET):
+            # VARIANT 1: Use async def step_impl()
+            from behave import step
+            from behave.api.async_step import async_run_until_complete
+            import asyncio
+
+            @step('an async coroutine step waits "{duration:f}" seconds')
+            @async_run_until_complete
+            async def step_async_step_waits_seconds(context, duration):
+                await asyncio.sleep(duration)
+
+        # -- USES: async def step_impl(...) as async-step (coroutine)
+        AsyncStepTheory.validate(step_async_step_waits_seconds)
+
+        # -- RUN ASYNC-STEP: Verify that it is behaving correctly.
+        # ENSURE: Execution of async-step matches expected duration.
+        context = Context(runner=Runner(config={}))
+        with StopWatch() as stop_watch:
+            step_async_step_waits_seconds(context, 0.2)
+        assert abs(stop_watch.duration - 0.2) <= 0.05

data/vendor/behave/tests/api/test_async_step.py

@@ -0,0 +1,18 @@
+# -*- coding: UTF-8 -*-
+"""
+Unit test facade to protect py.test runner from Python 3.4/3.5 grammar changes.
+"""
+
+from __future__ import absolute_import
+import sys
+
+python_version = sys.version_info[:2]
+if python_version >= (3, 5):
+    # -- PROTECTED-IMPORT:
+    # Older Python version have problems with grammer extensions (async/await).
+    from ._test_async_step35 import TestAsyncStepDecorator35
+    from ._test_async_step34 import TestAsyncStepDecorator34, TestAsyncContext
+elif (3, 4) <= python_version < (3, 5):
+    # -- PROTECTED-IMPORT:
+    # Older Python version have problems with grammer extensions (yield-from).
+    from ._test_async_step34 import TestAsyncStepDecorator34, TestAsyncContext

data/vendor/behave/tests/api/testing_support.py

@@ -0,0 +1,94 @@
+# -*- coding: UTF-8 -*-
+"""
+Test support functionality for other tests.
+"""
+
+# -- IMPORTS:
+from __future__ import absolute_import
+from behave.step_registry import StepRegistry
+from behave.matchers import ParseMatcher, CFParseMatcher, RegexMatcher
+import time
+
+
+# -----------------------------------------------------------------------------
+# TEST SUPPORT:
+# -----------------------------------------------------------------------------
+class StopWatch(object):
+    def __init__(self):
+        self.start_time = None
+        self.duration = None
+
+    def start(self):
+        self.start_time = self.now()
+        self.duration = None
+
+    def stop(self):
+        self.duration = self.now() - self.start_time
+
+    @staticmethod
+    def now():
+        return time.time()
+
+    @property
+    def elapsed(self):
+        assert self.start_time is not None
+        return self.now() - self.start_time
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+# -- NEEDED-UNTIL: stepimport functionality is completly provided.
+class MatcherFactory(object):
+    matcher_mapping = {
+        "parse": ParseMatcher,
+        "cfparse": CFParseMatcher,
+        "re": RegexMatcher,
+    }
+    default_matcher = ParseMatcher
+
+    def __init__(self, matcher_mapping=None, default_matcher=None):
+        self.matcher_mapping = matcher_mapping or self.matcher_mapping
+        self.default_matcher = default_matcher or self.default_matcher
+        self.current_matcher = self.default_matcher
+        self.type_registry = {}
+        # self.type_registry = ParseMatcher.custom_types.copy()
+
+    def register_type(self, **kwargs):
+        self.type_registry.update(**kwargs)
+
+    def use_step_matcher(self, name):
+        self.current_matcher = self.matcher_mapping[name]
+
+    def use_default_step_matcher(self, name=None):
+        if name:
+            self.default_matcher = self.matcher_mapping[name]
+        self.current_matcher = self.default_matcher
+
+    def make_matcher(self, func, step_text, step_type=None):
+        return self.current_matcher(func, step_text, step_type=step_type,
+                                    custom_types=self.type_registry)
+
+    def step_matcher(self, name):
+        """
+        DEPRECATED, use :method:`~MatcherFactory.use_step_matcher()` instead.
+        """
+        # -- BACKWARD-COMPATIBLE NAME: Mark as deprecated.
+        import warnings
+        warnings.warn("Use 'use_step_matcher()' instead",
+                      PendingDeprecationWarning, stacklevel=2)
+        self.use_step_matcher(name)
+
+
+class SimpleStepContainer(object):
+    def __init__(self, step_registry=None):
+        if step_registry is None:
+            step_registry = StepRegistry()
+        matcher_factory = MatcherFactory()
+
+        self.step_registry = step_registry
+        self.step_registry.matcher_factory = matcher_factory
+        self.matcher_factory = matcher_factory