assertpy2 2.0.0__py3-none-any.whl

assertpy2/dict.py

@@ -0,0 +1,255 @@
+# Copyright (c) 2015-2019, Activision Publishing, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+__tracebackhide__ = True
+
+
+class DictMixin:
+    """Dict assertions mixin."""
+
+    def contains_key(self, *keys) -> Self:
+        """Asserts the val is a dict and contains the given key or keys.  Alias for :meth:`~assertpy.contains.ContainsMixin.contains`.
+
+        Checks if the dict contains the given key or keys using ``in`` operator.
+
+        Args:
+            *keys: the key or keys expected to be contained
+
+        Examples:
+            Usage::
+
+                assert_that({'a': 1, 'b': 2}).contains_key('a')
+                assert_that({'a': 1, 'b': 2}).contains_key('a', 'b')
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain the key or keys
+        """
+        self._check_dict_like(self.val, check_values=False, check_getitem=False)
+        return self.contains(*keys)
+
+    def does_not_contain_key(self, *keys) -> Self:
+        """Asserts the val is a dict and does not contain the given key or keys.  Alias for :meth:`~assertpy.contains.ContainsMixin.does_not_contain`.
+
+        Checks if the dict excludes the given key or keys using ``in`` operator.
+
+        Args:
+            *keys: the key or keys expected to be excluded
+
+        Examples:
+            Usage::
+
+                assert_that({'a': 1, 'b': 2}).does_not_contain_key('x')
+                assert_that({'a': 1, 'b': 2}).does_not_contain_key('x', 'y')
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **does** contain the key or keys
+        """
+        self._check_dict_like(self.val, check_values=False, check_getitem=False)
+        return self.does_not_contain(*keys)
+
+    def contains_value(self, *values) -> Self:
+        """Asserts that val is a dict and contains the given value or values.
+
+        Checks if the dict contains the given value or values in *any* key.
+
+        Args:
+            *values: the value or values expected to be contained
+
+        Examples:
+            Usage::
+
+                assert_that({'a': 1, 'b': 2}).contains_value(1)
+                assert_that({'a': 1, 'b': 2}).contains_value(1, 2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain the value or values
+        """
+        self._check_dict_like(self.val, check_getitem=False)
+        if len(values) == 0:
+            raise ValueError("one or more value args must be given")
+        missing = []
+        for v in values:
+            if v not in self.val.values():
+                missing.append(v)
+        if missing:
+            return self.error(
+                "Expected <%s> to contain values %s, but did not contain %s."
+                % (self.val, self._fmt_items(values), self._fmt_items(missing))
+            )
+        return self
+
+    def does_not_contain_value(self, *values) -> Self:
+        """Asserts that val is a dict and does not contain the given value or values.
+
+        Checks if the dict excludes the given value or values across *all* keys.
+
+        Args:
+            *values: the value or values expected to be excluded
+
+        Examples:
+            Usage::
+
+                assert_that({'a': 1, 'b': 2}).does_not_contain_value(3)
+                assert_that({'a': 1, 'b': 2}).does_not_contain_value(3, 4)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **does** contain the value or values
+        """
+        self._check_dict_like(self.val, check_getitem=False)
+        if len(values) == 0:
+            raise ValueError("one or more value args must be given")
+        else:
+            found = []
+            for v in values:
+                if v in self.val.values():
+                    found.append(v)
+            if found:
+                return self.error(
+                    "Expected <%s> to not contain values %s, but did contain %s."
+                    % (self.val, self._fmt_items(values), self._fmt_items(found))
+                )
+        return self
+
+    def contains_entry(self, *args, **kwargs) -> Self:
+        """Asserts that val is a dict and contains the given entry or entries.
+
+        Checks if the dict contains the given key-value pair or pairs.
+
+        Args:
+            *args: the entry or entries expected to be contained (as ``{k: v}`` args)
+            **kwargs: the entry or entries expected to be contained (as ``k=v`` kwargs)
+
+        Examples:
+            Usage::
+
+                # using args
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry({'a': 1})
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry({'a': 1}, {'b': 2})
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry({'a': 1}, {'b': 2}, {'c': 3})
+
+                # using kwargs
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry(a=1)
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry(a=1, b=2)
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry(a=1, b=2, c=3)
+
+                # or args and kwargs
+                assert_that({'a': 1, 'b': 2, 'c': 3}).contains_entry({'c': 3}, a=1, b=2)
+
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain the entry or entries
+        """
+        self._check_dict_like(self.val, check_values=False)
+        entries = list(args) + [{k: v} for k, v in kwargs.items()]
+        if len(entries) == 0:
+            raise ValueError("one or more entry args must be given")
+        missing = []
+        for e in entries:
+            if type(e) is not dict:
+                raise TypeError("given entry arg must be a dict")
+            if len(e) != 1:
+                raise ValueError("given entry args must contain exactly one key-value pair")
+            k = next(iter(e))
+            if k not in self.val:
+                missing.append(e)  # bad key
+            elif self.val[k] != e[k]:
+                missing.append(e)  # bad val
+        if missing:
+            return self.error(
+                "Expected <%s> to contain entries %s, but did not contain %s."
+                % (self.val, self._fmt_items(entries), self._fmt_items(missing))
+            )
+        return self
+
+    def does_not_contain_entry(self, *args, **kwargs) -> Self:
+        """Asserts that val is a dict and does not contain the given entry or entries.
+
+        Checks if the dict excludes the given key-value pair or pairs.
+
+        Args:
+            *args: the entry or entries expected to be excluded (as ``{k: v}`` args)
+            **kwargs: the entry or entries expected to be excluded (as ``k=v`` kwargs)
+
+        Examples:
+            Usage::
+
+                # using args
+                assert_that({'a': 1, 'b': 2, 'c': 3}).does_not_contain_entry({'a': 2})
+                assert_that({'a': 1, 'b': 2, 'c': 3}).does_not_contain_entry({'a': 2}, {'x': 4})
+
+                # using kwargs
+                assert_that({'a': 1, 'b': 2, 'c': 3}).does_not_contain_entry(a=2)
+                assert_that({'a': 1, 'b': 2, 'c': 3}).does_not_contain_entry(a=2, x=4)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **does** contain the entry or entries
+        """
+        self._check_dict_like(self.val, check_values=False)
+        entries = list(args) + [{k: v} for k, v in kwargs.items()]
+        if len(entries) == 0:
+            raise ValueError("one or more entry args must be given")
+        found = []
+        for e in entries:
+            if type(e) is not dict:
+                raise TypeError("given entry arg must be a dict")
+            if len(e) != 1:
+                raise ValueError("given entry args must contain exactly one key-value pair")
+            k = next(iter(e))
+            if k in self.val and e[k] == self.val[k]:
+                found.append(e)
+        if found:
+            return self.error(
+                "Expected <%s> to not contain entries %s, but did contain %s."
+                % (self.val, self._fmt_items(entries), self._fmt_items(found))
+            )
+        return self

assertpy2/dynamic.py

@@ -0,0 +1,113 @@
+# Copyright (c) 2015-2019, Activision Publishing, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import annotations
+
+import collections
+
+__tracebackhide__ = True
+
+
+class DynamicMixin:
+    """Dynamic assertions mixin.
+
+    When testing attributes of an object (or the contents of a dict), the
+    :meth:`~assertpy.base.BaseMixin.is_equal_to` assertion can be a bit verbose::
+
+        fred = Person('Fred', 'Smith')
+
+        assert_that(fred.first_name).is_equal_to('Fred')
+        assert_that(fred.name).is_equal_to('Fred Smith')
+        assert_that(fred.say_hello()).is_equal_to('Hello, Fred!')
+
+    Instead, use dynamic assertions in the form of ``has_<name>()`` where ``<name>`` is the name of
+    any attribute, property, or zero-argument method on the given object. Dynamic equality
+    assertions test if actual is equal to expected using the ``==`` operator. Using dynamic
+    assertions, we can rewrite the above example as::
+
+        assert_that(fred).has_first_name('Fred')
+        assert_that(fred).has_name('Fred Smith')
+        assert_that(fred).has_say_hello('Hello, Fred!')
+
+    Similarly, dynamic assertions also work on any *dict-like* object::
+
+        fred = {
+            'first_name': 'Fred',
+            'last_name': 'Smith',
+            'shoe_size': 12
+        }
+
+        assert_that(fred).has_first_name('Fred')
+        assert_that(fred).has_last_name('Smith')
+        assert_that(fred).has_shoe_size(12)
+    """
+
+    def __getattr__(self, attr):
+        """Asserts that val has attribute attr and that its value is equal to other via a dynamic
+        assertion of the form ``has_<attr>()``."""
+        if not attr.startswith("has_"):
+            raise AttributeError("assertpy has no assertion <%s()>" % attr)
+
+        attr_name = attr[4:]
+        err_msg = False
+        is_namedtuple = isinstance(self.val, tuple) and hasattr(self.val, "_fields")
+        is_dict = isinstance(self.val, collections.abc.Iterable) and hasattr(self.val, "__getitem__")
+
+        if not hasattr(self.val, attr_name):
+            if is_dict and not is_namedtuple:
+                if attr_name not in self.val:
+                    err_msg = "Expected key <%s>, but val has no key <%s>." % (attr_name, attr_name)
+            else:
+                err_msg = "Expected attribute <%s>, but val has no attribute <%s>." % (attr_name, attr_name)
+
+        def _wrapper(*args, **kwargs):
+            if err_msg:
+                return self.error(err_msg)  # ok to raise AssertionError now that we are inside wrapper
+            else:
+                if len(args) != 1:
+                    raise TypeError("assertion <%s()> takes exactly 1 argument (%d given)" % (attr, len(args)))
+
+                val_attr = self.val[attr_name] if is_dict and not is_namedtuple else getattr(self.val, attr_name)
+
+                if callable(val_attr):
+                    try:
+                        actual = val_attr()
+                    except TypeError:
+                        raise TypeError("val does not have zero-arg method <%s()>" % attr_name) from None
+                else:
+                    actual = val_attr
+
+                expected = args[0]
+                if actual != expected:
+                    return self.error(
+                        "Expected <%s> to be equal to <%s> on %s <%s>, but was not."
+                        % (actual, expected, "key" if is_dict else "attribute", attr_name)
+                    )
+            return self
+
+        return _wrapper

assertpy2/exception.py

@@ -0,0 +1,128 @@
+# Copyright (c) 2015-2019, Activision Publishing, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+__tracebackhide__ = True
+
+
+class _InertBuilder:
+    """No-op builder returned after a failed raises/when_called_with in soft mode.
+
+    Silently absorbs all chained assertions so they don't crash on wrong val type.
+    """
+
+    def __getattr__(self, name):
+        return lambda *args, **kwargs: self
+
+
+class ExceptionMixin:
+    """Expected exception mixin."""
+
+    def raises(self, ex) -> Self:
+        """Asserts that val is callable and set the expected exception.
+
+        Just sets the expected exception, but never calls val, and therefore never failes. You must
+        chain to :meth:`~when_called_with` to invoke ``val()``.
+
+        Args:
+            ex: the expected exception
+
+        Examples:
+            Usage::
+
+                assert_that(some_func).raises(RuntimeError).when_called_with('foo')
+
+        Returns:
+            AssertionBuilder: returns a new instance (now with the given expected exception) to chain to the next assertion
+        """
+        if not callable(self.val):
+            raise TypeError("val must be callable")
+        if not issubclass(ex, BaseException):
+            raise TypeError("given arg must be exception")
+
+        # chain on with ex as the expected exception
+        return self.builder(self.val, self.description, self.kind, ex, self.logger)
+
+    def when_called_with(self, *some_args, **some_kwargs) -> Self:
+        """Asserts that val, when invoked with the given args and kwargs, raises the expected exception.
+
+        Invokes ``val()`` with the given args and kwargs.  You must first set the expected
+        exception with :meth:`~raises`.
+
+        Args:
+            *some_args: the args to call ``val()``
+            **some_kwargs: the kwargs to call ``val()``
+
+        Examples:
+            Usage::
+
+                def some_func(a):
+                    raise RuntimeError('some error!')
+
+                assert_that(some_func).raises(RuntimeError).when_called_with('foo')
+
+        Returns:
+            AssertionBuilder: returns a new instance (now with the captured exception error message as the val) to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** raise the expected exception
+            TypeError: if expected exception not set via :meth:`raises`
+        """
+        if not self.expected:
+            raise TypeError("expected exception not set, raises() must be called first")
+        try:
+            self.val(*some_args, **some_kwargs)
+        except BaseException as e:
+            if issubclass(type(e), self.expected):
+                # chain on with error message
+                return self.builder(str(e), self.description, self.kind, logger=self.logger)
+            else:
+                # got exception, but wrong type, so raise
+                self.error(
+                    "Expected <%s> to raise <%s> when called with (%s), but raised <%s>."
+                    % (
+                        self.val.__name__,
+                        self.expected.__name__,
+                        self._fmt_args_kwargs(*some_args, **some_kwargs),
+                        type(e).__name__,
+                    )
+                )
+                return _InertBuilder()
+
+        # didn't fail as expected, so raise
+        self.error(
+            "Expected <%s> to raise <%s> when called with (%s)."
+            % (self.val.__name__, self.expected.__name__, self._fmt_args_kwargs(*some_args, **some_kwargs))
+        )
+        return _InertBuilder()