assertpy2 2.0.0__py3-none-any.whl

assertpy2/base.py

@@ -0,0 +1,435 @@
+# 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 BaseMixin:
+    """Base mixin."""
+
+    def described_as(self, description) -> Self:
+        """Describes the assertion.  On failure, the description is included in the error message.
+
+        This is not an assertion itself.  But if the any of the following chained assertions fail,
+        the description will be included in addition to the regular error message.
+
+        Args:
+            description: the error message description
+
+        Examples:
+            Usage::
+
+                assert_that(1).described_as('error msg desc').is_equal_to(2)  # fails
+                # [error msg desc] Expected <1> to be equal to <2>, but was not.
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+        """
+        self.description = str(description)
+        return self
+
+    def is_equal_to(self, other, **kwargs) -> Self:
+        """Asserts that val is equal to other.
+
+        Checks actual is equal to expected using the ``==`` operator. When val is *dict-like*,
+        optionally ignore or include keys when checking equality.
+
+        Args:
+            other: the expected value
+            **kwargs: see below
+
+        Keyword Args:
+            ignore: the dict key (or list of keys) to ignore
+            include: the dict key (of list of keys) to include
+
+        Examples:
+            Usage::
+
+                assert_that(1 + 2).is_equal_to(3)
+                assert_that('foo').is_equal_to('foo')
+                assert_that(123).is_equal_to(123)
+                assert_that(123.4).is_equal_to(123.4)
+                assert_that(['a', 'b']).is_equal_to(['a', 'b'])
+                assert_that((1, 2, 3)).is_equal_to((1, 2, 3))
+                assert_that({'a': 1, 'b': 2}).is_equal_to({'a': 1, 'b': 2})
+                assert_that({'a', 'b'}).is_equal_to({'a', 'b'})
+
+            When the val is *dict-like*, keys can optionally be *ignored* when checking equality::
+
+                # ignore a single key
+                assert_that({'a': 1, 'b': 2}).is_equal_to({'a': 1}, ignore='b')
+
+                # ignore multiple keys
+                assert_that({'a': 1, 'b': 2, 'c': 3}).is_equal_to({'a': 1}, ignore=['b', 'c'])
+
+                # ignore nested keys
+                assert_that({'a': {'b': 2, 'c': 3, 'd': 4}}).is_equal_to({'a': {'d': 4}}, ignore=[('a', 'b'), ('a', 'c')])
+
+            When the val is *dict-like*, only certain keys can be *included* when checking equality::
+
+                # include a single key
+                assert_that({'a': 1, 'b': 2}).is_equal_to({'a': 1}, include='a')
+
+                # include multiple keys
+                assert_that({'a': 1, 'b': 2, 'c': 3}).is_equal_to({'a': 1, 'b': 2}, include=['a', 'b'])
+
+            Failure produces a nice error message::
+
+                assert_that(1).is_equal_to(2)  # fails
+                # Expected <1> to be equal to <2>, but was not.
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if actual is **not** equal to expected
+
+        Tip:
+            Using :meth:`is_equal_to` with a ``float`` val is just asking for trouble. Instead, you'll
+            always want to use *fuzzy* numeric assertions like :meth:`~assertpy.numeric.NumericMixin.is_close_to`
+            or :meth:`~assertpy.numeric.NumericMixin.is_between`.
+
+        See Also:
+            :meth:`~assertpy.string.StringMixin.is_equal_to_ignoring_case` - for case-insensitive string equality
+        """
+        if self._check_dict_like(self.val, check_values=False, return_as_bool=True) and self._check_dict_like(
+            other, check_values=False, return_as_bool=True
+        ):
+            if self._dict_not_equal(self.val, other, ignore=kwargs.get("ignore"), include=kwargs.get("include")):
+                self._dict_err(self.val, other, ignore=kwargs.get("ignore"), include=kwargs.get("include"))
+        else:
+            if self.val != other:
+                return self.error("Expected <%s> to be equal to <%s>, but was not." % (self.val, other))
+        return self
+
+    def is_not_equal_to(self, other) -> Self:
+        """Asserts that val is not equal to other.
+
+        Checks actual is not equal to expected using the ``!=`` operator.
+
+        Args:
+            other: the expected value
+
+        Examples:
+            Usage::
+
+                assert_that(1 + 2).is_not_equal_to(4)
+                assert_that('foo').is_not_equal_to('bar')
+                assert_that(123).is_not_equal_to(456)
+                assert_that(123.4).is_not_equal_to(567.8)
+                assert_that(['a', 'b']).is_not_equal_to(['c', 'd'])
+                assert_that((1, 2, 3)).is_not_equal_to((1, 2, 4))
+                assert_that({'a': 1, 'b': 2}).is_not_equal_to({'a': 1, 'b': 3})
+                assert_that({'a', 'b'}).is_not_equal_to({'a', 'x'})
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if actual **is** equal to expected
+        """
+        if self.val == other:
+            return self.error("Expected <%s> to be not equal to <%s>, but was." % (self.val, other))
+        return self
+
+    def is_same_as(self, other) -> Self:
+        """Asserts that val is identical to other.
+
+        Checks actual is identical to expected using the ``is`` operator.
+
+        Args:
+            other: the expected value
+
+        Examples:
+            Basic types are identical::
+
+                assert_that(1).is_same_as(1)
+                assert_that('foo').is_same_as('foo')
+                assert_that(123.4).is_same_as(123.4)
+
+            As are immutables like ``tuple``::
+
+                assert_that((1, 2, 3)).is_same_as((1, 2, 3))
+
+            But mutable collections like ``list``, ``dict``, and ``set`` are not::
+
+                # these all fail...
+                assert_that(['a', 'b']).is_same_as(['a', 'b'])  # fails
+                assert_that({'a': 1, 'b': 2}).is_same_as({'a': 1, 'b': 2})  # fails
+                assert_that({'a', 'b'}).is_same_as({'a', 'b'})  # fails
+
+            Unless they are the same object::
+
+                x = {'a': 1, 'b': 2}
+                y = x
+                assert_that(x).is_same_as(y)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if actual is **not** identical to expected
+        """
+        if self.val is not other:
+            return self.error("Expected <%s> to be identical to <%s>, but was not." % (self.val, other))
+        return self
+
+    def is_not_same_as(self, other) -> Self:
+        """Asserts that val is not identical to other.
+
+        Checks actual is not identical to expected using the ``is`` operator.
+
+        Args:
+            other: the expected value
+
+        Examples:
+            Usage::
+
+                assert_that(1).is_not_same_as(2)
+                assert_that('foo').is_not_same_as('bar')
+                assert_that(123.4).is_not_same_as(567.8)
+                assert_that((1, 2, 3)).is_not_same_as((1, 2, 4))
+
+                # mutable collections, even if equal, are not identical...
+                assert_that(['a', 'b']).is_not_same_as(['a', 'b'])
+                assert_that({'a': 1, 'b': 2}).is_not_same_as({'a': 1, 'b': 2})
+                assert_that({'a', 'b'}).is_not_same_as({'a', 'b'})
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if actual **is** identical to expected
+        """
+        if self.val is other:
+            return self.error("Expected <%s> to be not identical to <%s>, but was." % (self.val, other))
+        return self
+
+    def is_true(self) -> Self:
+        """Asserts that val is true.
+
+        Examples:
+            Usage::
+
+                assert_that(True).is_true()
+                assert_that(1).is_true()
+                assert_that('foo').is_true()
+                assert_that(1.0).is_true()
+                assert_that(['a', 'b']).is_true()
+                assert_that((1, 2, 3)).is_true()
+                assert_that({'a': 1, 'b': 2}).is_true()
+                assert_that({'a', 'b'}).is_true()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** false
+        """
+        if not self.val:
+            return self.error("Expected <%s> to be <True>, but was not." % self.val)
+        return self
+
+    def is_false(self) -> Self:
+        """Asserts that val is false.
+
+        Examples:
+            Usage::
+
+                assert_that(False).is_false()
+                assert_that(0).is_false()
+                assert_that('').is_false()
+                assert_that(0.0).is_false()
+                assert_that([]).is_false()
+                assert_that(()).is_false()
+                assert_that({}).is_false()
+                assert_that(set()).is_false()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** true
+        """
+        if self.val:
+            return self.error("Expected <%s> to be <False>, but was not." % self.val)
+        return self
+
+    def is_none(self) -> Self:
+        """Asserts that val is none.
+
+        Examples:
+            Usage::
+
+                assert_that(None).is_none()
+                assert_that(print('hello world')).is_none()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** none
+        """
+        if self.val is not None:
+            return self.error("Expected <%s> to be <None>, but was not." % self.val)
+        return self
+
+    def is_not_none(self) -> Self:
+        """Asserts that val is not none.
+
+        Examples:
+            Usage::
+
+                assert_that(0).is_not_none()
+                assert_that('foo').is_not_none()
+                assert_that(False).is_not_none()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** none
+        """
+        if self.val is None:
+            return self.error("Expected not <None>, but was.")
+        return self
+
+    def _type(self, val):
+        if hasattr(val, "__name__"):
+            return val.__name__
+        return val.__class__.__name__
+
+    def is_type_of(self, some_type) -> Self:
+        """Asserts that val is of the given type.
+
+        Args:
+            some_type (type): the expected type
+
+        Examples:
+            Usage::
+
+                assert_that(1).is_type_of(int)
+                assert_that('foo').is_type_of(str)
+                assert_that(123.4).is_type_of(float)
+                assert_that(['a', 'b']).is_type_of(list)
+                assert_that((1, 2, 3)).is_type_of(tuple)
+                assert_that({'a': 1, 'b': 2}).is_type_of(dict)
+                assert_that({'a', 'b'}).is_type_of(set)
+                assert_that(True).is_type_of(bool)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** of the given type
+        """
+        if type(some_type) is not type and not issubclass(type(some_type), type):
+            raise TypeError("given arg must be a type")
+        if type(self.val) is not some_type:
+            t = self._type(self.val)
+            return self.error("Expected <%s:%s> to be of type <%s>, but was not." % (self.val, t, some_type.__name__))
+        return self
+
+    def is_instance_of(self, some_class) -> Self:
+        """Asserts that val is an instance of the given class.
+
+        Args:
+            some_class: the expected class
+
+        Examples:
+            Usage::
+
+                assert_that(1).is_instance_of(int)
+                assert_that('foo').is_instance_of(str)
+                assert_that(123.4).is_instance_of(float)
+                assert_that(['a', 'b']).is_instance_of(list)
+                assert_that((1, 2, 3)).is_instance_of(tuple)
+                assert_that({'a': 1, 'b': 2}).is_instance_of(dict)
+                assert_that({'a', 'b'}).is_instance_of(set)
+                assert_that(True).is_instance_of(bool)
+
+            With a user-defined class::
+
+                class Foo: pass
+                f = Foo()
+                assert_that(f).is_instance_of(Foo)
+                assert_that(f).is_instance_of(object)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** an instance of the given class
+        """
+        try:
+            if not isinstance(self.val, some_class):
+                t = self._type(self.val)
+                return self.error(
+                    "Expected <%s:%s> to be instance of class <%s>, but was not." % (self.val, t, some_class.__name__)
+                )
+        except TypeError:
+            raise TypeError("given arg must be a class") from None
+        return self
+
+    def is_length(self, length) -> Self:
+        """Asserts that val is the given length.
+
+        Checks val is the given length using the ``len()`` built-in.
+
+        Args:
+            length (int): the expected length
+
+        Examples:
+            Usage::
+
+                assert_that('foo').is_length(3)
+                assert_that(['a', 'b']).is_length(2)
+                assert_that((1, 2, 3)).is_length(3)
+                assert_that({'a': 1, 'b': 2}).is_length(2)
+                assert_that({'a', 'b'}).is_length(2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** the given length
+        """
+        if type(length) is not int:
+            raise TypeError("given arg must be an int")
+        if length < 0:
+            raise ValueError("given arg must be a positive int")
+        if len(self.val) != length:
+            return self.error("Expected <%s> to be of length <%d>, but was <%d>." % (self.val, length, len(self.val)))
+        return self

assertpy2/collection.py

@@ -0,0 +1,217 @@
+# 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
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+__tracebackhide__ = True
+
+
+class CollectionMixin:
+    """Collection assertions mixin."""
+
+    def is_iterable(self) -> Self:
+        """Asserts that val is iterable.
+
+        Examples:
+            Usage::
+
+                assert_that('foo').is_iterable()
+                assert_that(['a', 'b']).is_iterable()
+                assert_that((1, 2, 3)).is_iterable()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** iterable
+        """
+        if not isinstance(self.val, collections.abc.Iterable):
+            return self.error("Expected iterable, but was not.")
+        return self
+
+    def is_not_iterable(self) -> Self:
+        """Asserts that val is not iterable.
+
+        Examples:
+            Usage::
+
+                assert_that(1).is_not_iterable()
+                assert_that(123.4).is_not_iterable()
+                assert_that(True).is_not_iterable()
+                assert_that(None).is_not_iterable()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** iterable
+        """
+        if isinstance(self.val, collections.abc.Iterable):
+            return self.error("Expected not iterable, but was.")
+        return self
+
+    def is_subset_of(self, *supersets) -> Self:
+        """Asserts that val is iterable and a subset of the given superset (or supersets).
+
+        Args:
+            *supersets: the expected superset (or supersets)
+
+        Examples:
+            Usage::
+
+                assert_that('foo').is_subset_of('abcdefghijklmnopqrstuvwxyz')
+                assert_that(['a', 'b']).is_subset_of(['a', 'b', 'c'])
+                assert_that((1, 2, 3)).is_subset_of([1, 2, 3, 4])
+                assert_that({'a': 1, 'b': 2}).is_subset_of({'a': 1, 'b': 2, 'c': 3})
+                assert_that({'a', 'b'}).is_subset_of({'a', 'b', 'c'})
+
+                # or multiple supersets (as comma-separated args)
+                assert_that('aBc').is_subset_of('abc', 'ABC')
+                assert_that((1, 2, 3)).is_subset_of([1, 3, 5], [2, 4, 6])
+
+                assert_that({'a': 1, 'b': 2}).is_subset_of({'a': 1, 'c': 3})  # fails
+                # Expected <{'a': 1, 'b': 2}> to be subset of <{'a': 1, 'c': 3}>, but <{'b': 2}> was missing.
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** subset of given superset (or supersets)
+        """
+        if not isinstance(self.val, collections.abc.Iterable):
+            raise TypeError("val is not iterable")
+        if len(supersets) == 0:
+            raise ValueError("one or more superset args must be given")
+
+        missing = []
+        if hasattr(self.val, "keys") and callable(self.val.keys) and hasattr(self.val, "__getitem__"):
+            # flatten superset dicts
+            superdict = {}
+            for idx, j in enumerate(supersets):
+                self._check_dict_like(j, check_values=False, name="arg #%d" % (idx + 1))
+                for k in j:
+                    superdict.update({k: j[k]})
+
+            for i in self.val:
+                if i not in superdict:
+                    missing.append({i: self.val[i]})  # bad key
+                elif self.val[i] != superdict[i]:
+                    missing.append({i: self.val[i]})  # bad val
+            if missing:
+                return self.error(
+                    "Expected <%s> to be subset of %s, but %s %s missing."
+                    % (
+                        self.val,
+                        self._fmt_items(superdict),
+                        self._fmt_items(missing),
+                        "was" if len(missing) == 1 else "were",
+                    )
+                )
+        else:
+            # flatten supersets
+            superset = set()
+            for j in supersets:
+                try:
+                    for k in j:
+                        superset.add(k)
+                except TypeError:
+                    superset.add(j)
+
+            for i in self.val:
+                if i not in superset:
+                    missing.append(i)
+            if missing:
+                return self.error(
+                    "Expected <%s> to be subset of %s, but %s %s missing."
+                    % (
+                        self.val,
+                        self._fmt_items(superset),
+                        self._fmt_items(missing),
+                        "was" if len(missing) == 1 else "were",
+                    )
+                )
+
+        return self
+
+    def is_sorted(self, key=lambda x: x, reverse=False) -> Self:
+        """Asserts that val is iterable and is sorted.
+
+        Args:
+            key (function): the one-arg function to extract the sort comparison key.  Defaults to
+                ``lambda x: x`` to just compare items directly.
+            reverse (bool): if ``True``, then comparison key is reversed.  Defaults to ``False``.
+
+        Examples:
+            Usage::
+
+                assert_that(['a', 'b', 'c']).is_sorted()
+                assert_that((1, 2, 3)).is_sorted()
+
+                # with a key function
+                assert_that('aBc').is_sorted(key=str.lower)
+
+                # reverse order
+                assert_that(['c', 'b', 'a']).is_sorted(reverse=True)
+                assert_that((3, 2, 1)).is_sorted(reverse=True)
+
+                assert_that((1, 2, 3, 4, -5, 6)).is_sorted()  # fails
+                # Expected <(1, 2, 3, 4, -5, 6)> to be sorted, but subset <4, -5> at index 3 is not.
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** sorted
+        """
+        if not isinstance(self.val, collections.abc.Iterable):
+            raise TypeError("val is not iterable")
+
+        prev = None
+        for i, x in enumerate(self.val):
+            if i > 0:
+                if reverse:
+                    if key(x) > key(prev):
+                        return self.error(
+                            "Expected <%s> to be sorted reverse, but subset %s at index %s is not."
+                            % (self.val, self._fmt_items([prev, x]), i - 1)
+                        )
+                else:
+                    if key(x) < key(prev):
+                        return self.error(
+                            "Expected <%s> to be sorted, but subset %s at index %s is not."
+                            % (self.val, self._fmt_items([prev, x]), i - 1)
+                        )
+            prev = x
+
+        return self