assertpy2 2.0.0__py3-none-any.whl

assertpy2/contains.py

@@ -0,0 +1,386 @@
+# 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 ContainsMixin:
+    """Containment assertions mixin."""
+
+    def contains(self, *items) -> Self:
+        """Asserts that val contains the given item or items.
+
+        Checks if the collection contains the given item or items using ``in`` operator.
+
+        Args:
+            *items: the item or items expected to be contained
+
+        Examples:
+            Usage::
+
+                assert_that('foo').contains('f')
+                assert_that('foo').contains('f', 'oo')
+                assert_that(['a', 'b']).contains('b', 'a')
+                assert_that((1, 2, 3)).contains(3, 2, 1)
+                assert_that({'a': 1, 'b': 2}).contains('b', 'a')  # checks keys
+                assert_that({'a', 'b'}).contains('b', 'a')
+                assert_that([1, 2, 3]).is_type_of(list).contains(1, 2).does_not_contain(4, 5)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain the item or items
+
+        Tip:
+            Use the :meth:`~assertpy.dict.DictMixin.contains_key` alias when working with
+            *dict-like* objects to be self-documenting.
+
+        See Also:
+            :meth:`~assertpy.string.StringMixin.contains_ignoring_case` - for case-insensitive string contains
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        elif len(items) == 1:
+            if items[0] not in self.val:
+                if self._check_dict_like(self.val, return_as_bool=True):
+                    return self.error("Expected <%s> to contain key <%s>, but did not." % (self.val, items[0]))
+                else:
+                    return self.error("Expected <%s> to contain item <%s>, but did not." % (self.val, items[0]))
+        else:
+            missing = []
+            for i in items:
+                if i not in self.val:
+                    missing.append(i)
+            if missing:
+                if self._check_dict_like(self.val, return_as_bool=True):
+                    return self.error(
+                        "Expected <%s> to contain keys %s, but did not contain key%s %s."
+                        % (self.val, self._fmt_items(items), "" if len(missing) == 0 else "s", self._fmt_items(missing))
+                    )
+                else:
+                    return self.error(
+                        "Expected <%s> to contain items %s, but did not contain %s."
+                        % (self.val, self._fmt_items(items), self._fmt_items(missing))
+                    )
+        return self
+
+    def does_not_contain(self, *items) -> Self:
+        """Asserts that val does not contain the given item or items.
+
+        Checks if the collection excludes the given item or items using ``in`` operator.
+
+        Args:
+            *items: the item or items expected to be excluded
+
+        Examples:
+            Usage::
+
+                assert_that('foo').does_not_contain('x')
+                assert_that(['a', 'b']).does_not_contain('x', 'y')
+                assert_that((1, 2, 3)).does_not_contain(4, 5)
+                assert_that({'a': 1, 'b': 2}).does_not_contain('x', 'y')  # checks keys
+                assert_that({'a', 'b'}).does_not_contain('x', 'y')
+                assert_that([1, 2, 3]).is_type_of(list).contains(1, 2).does_not_contain(4, 5)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **does** contain the item or items
+
+        Tip:
+            Use the :meth:`~assertpy.dict.DictMixin.does_not_contain_key` alias when working with
+            *dict-like* objects to be self-documenting.
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        elif len(items) == 1:
+            if items[0] in self.val:
+                return self.error("Expected <%s> to not contain item <%s>, but did." % (self.val, items[0]))
+        else:
+            found = []
+            for i in items:
+                if i in self.val:
+                    found.append(i)
+            if found:
+                return self.error(
+                    "Expected <%s> to not contain items %s, but did contain %s."
+                    % (self.val, self._fmt_items(items), self._fmt_items(found))
+                )
+        return self
+
+    def contains_only(self, *items) -> Self:
+        """Asserts that val contains *only* the given item or items.
+
+        Checks if the collection contains only the given item or items using ``in`` operator.
+
+        Args:
+            *items: the *only* item or items expected to be contained
+
+        Examples:
+            Usage::
+
+                assert_that('foo').contains_only('f', 'o')
+                assert_that(['a', 'a', 'b']).contains_only('a', 'b')
+                assert_that((1, 1, 2)).contains_only(1, 2)
+                assert_that({'a': 1, 'a': 2, 'b': 3}).contains_only('a', 'b')
+                assert_that({'a', 'a', 'b'}).contains_only('a', 'b')
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val contains anything **not** item or items
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        else:
+            extra = []
+            for i in self.val:
+                if i not in items:
+                    extra.append(i)
+            if extra:
+                return self.error(
+                    "Expected <%s> to contain only %s, but did contain %s."
+                    % (self.val, self._fmt_items(items), self._fmt_items(extra))
+                )
+
+            missing = []
+            for i in items:
+                if i not in self.val:
+                    missing.append(i)
+            if missing:
+                return self.error(
+                    "Expected <%s> to contain only %s, but did not contain %s."
+                    % (self.val, self._fmt_items(items), self._fmt_items(missing))
+                )
+        return self
+
+    def contains_sequence(self, *items) -> Self:
+        """Asserts that val contains the given ordered sequence of items.
+
+        Checks if the collection contains the given sequence of items using ``in`` operator.
+
+        Args:
+            *items: the sequence of items expected to be contained
+
+        Examples:
+            Usage::
+
+                assert_that('foo').contains_sequence('f', 'o')
+                assert_that('foo').contains_sequence('o', 'o')
+                assert_that(['a', 'b', 'c']).contains_sequence('b', 'c')
+                assert_that((1, 2, 3)).contains_sequence(1, 2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contains the given sequence of items
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        if isinstance(self.val, str):
+            pos = 0
+            for item in items:
+                if not isinstance(item, str):
+                    raise TypeError("given args must be strings when val is a string")
+                idx = self.val.find(item, pos)
+                if idx == -1:
+                    return self.error(
+                        "Expected <%s> to contain sequence %s, but did not." % (self.val, self._fmt_items(items))
+                    )
+                pos = idx + len(item)
+            return self
+        try:
+            for i in range(len(self.val) - len(items) + 1):
+                for j in range(len(items)):
+                    if self.val[i + j] != items[j]:
+                        break
+                else:
+                    return self
+        except TypeError:
+            raise TypeError("val is not iterable") from None
+        return self.error("Expected <%s> to contain sequence %s, but did not." % (self.val, self._fmt_items(items)))
+
+    def contains_duplicates(self) -> Self:
+        """Asserts that val is iterable and *does* contain duplicates.
+
+        Examples:
+            Usage::
+
+                assert_that('foo').contains_duplicates()
+                assert_that(['a', 'a', 'b']).contains_duplicates()
+                assert_that((1, 1, 2)).contains_duplicates()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain any duplicates
+        """
+        try:
+            if len(self.val) != len(set(self.val)):
+                return self
+        except TypeError:
+            raise TypeError("val is not iterable") from None
+        return self.error("Expected <%s> to contain duplicates, but did not." % self.val)
+
+    def does_not_contain_duplicates(self) -> Self:
+        """Asserts that val is iterable and *does not* contain any duplicates.
+
+        Examples:
+            Usage::
+
+                assert_that('fox').does_not_contain_duplicates()
+                assert_that(['a', 'b', 'c']).does_not_contain_duplicates()
+                assert_that((1, 2, 3)).does_not_contain_duplicates()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **does** contain duplicates
+        """
+        try:
+            if len(self.val) == len(set(self.val)):
+                return self
+        except TypeError:
+            raise TypeError("val is not iterable") from None
+        return self.error("Expected <%s> to not contain duplicates, but did." % self.val)
+
+    def is_empty(self) -> Self:
+        """Asserts that val is empty.
+
+        Examples:
+            Usage::
+
+                assert_that('').is_empty()
+                assert_that([]).is_empty()
+                assert_that(()).is_empty()
+                assert_that({}).is_empty()
+                assert_that(set()).is_empty()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** empty
+        """
+        if len(self.val) != 0:
+            if isinstance(self.val, str):
+                return self.error("Expected <%s> to be empty string, but was not." % self.val)
+            else:
+                return self.error("Expected <%s> to be empty, but was not." % self.val)
+        return self
+
+    def is_not_empty(self) -> Self:
+        """Asserts that val is *not* empty.
+
+        Examples:
+            Usage::
+
+                assert_that('foo').is_not_empty()
+                assert_that(['a', 'b']).is_not_empty()
+                assert_that((1, 2, 3)).is_not_empty()
+                assert_that({'a': 1, 'b': 2}).is_not_empty()
+                assert_that({'a', 'b'}).is_not_empty()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** empty
+        """
+        if len(self.val) == 0:
+            if isinstance(self.val, str):
+                return self.error("Expected not empty string, but was empty.")
+            else:
+                return self.error("Expected not empty, but was empty.")
+        return self
+
+    def is_in(self, *items) -> Self:
+        """Asserts that val is equal to one of the given items.
+
+        Args:
+            *items: the items expected to contain val
+
+        Examples:
+            Usage::
+
+                assert_that('foo').is_in('foo', 'bar', 'baz')
+                assert_that(1).is_in(0, 1, 2, 3)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** in the given items
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        else:
+            for i in items:
+                if self.val == i:
+                    return self
+        return self.error("Expected <%s> to be in %s, but was not." % (self.val, self._fmt_items(items)))
+
+    def is_not_in(self, *items) -> Self:
+        """Asserts that val is not equal to one of the given items.
+
+        Args:
+            *items: the items expected to exclude val
+
+        Examples:
+            Usage::
+
+                assert_that('foo').is_not_in('bar', 'baz', 'box')
+                assert_that(1).is_not_in(-1, -2, -3)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** in the given items
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        else:
+            for i in items:
+                if self.val == i:
+                    return self.error("Expected <%s> to not be in %s, but was." % (self.val, self._fmt_items(items)))
+        return self

assertpy2/date.py

@@ -0,0 +1,219 @@
+# 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 datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+__tracebackhide__ = True
+
+
+class DateMixin:
+    """Date and time assertions mixin."""
+
+    def is_before(self, other) -> Self:
+        """Asserts that val is a date and is before other date.
+
+        Args:
+            other: the other date, expected to be after val
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                today = datetime.datetime.now()
+                yesterday = today - datetime.timedelta(days=1)
+
+                assert_that(yesterday).is_before(today)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** before the given date
+
+        See Also:
+            :meth:`~assertpy.string.NumericMixin.is_less_than` - numeric assertion, but also works with datetime BR
+            :meth:`~assertpy.string.NumericMixin.is_less_than_or_equal_to` - numeric assertion, but also works with datetime
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError("val must be datetime, but was type <%s>" % type(self.val).__name__)
+        if type(other) is not datetime.datetime:
+            raise TypeError("given arg must be datetime, but was type <%s>" % type(other).__name__)
+        if self.val >= other:
+            return self.error(
+                "Expected <%s> to be before <%s>, but was not."
+                % (self.val.strftime("%Y-%m-%d %H:%M:%S"), other.strftime("%Y-%m-%d %H:%M:%S"))
+            )
+        return self
+
+    def is_after(self, other) -> Self:
+        """Asserts that val is a date and is after other date.
+
+        Args:
+            other: the other date, expected to be before val
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                today = datetime.datetime.now()
+                yesterday = today - datetime.timedelta(days=1)
+
+                assert_that(today).is_after(yesterday)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** after the given date
+
+        See Also:
+            :meth:`~assertpy.string.NumericMixin.is_greater_than` - numeric assertion, but also works with datetime BR
+            :meth:`~assertpy.string.NumericMixin.is_greater_than_or_equal_to` - numeric assertion, but also works with datetime
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError("val must be datetime, but was type <%s>" % type(self.val).__name__)
+        if type(other) is not datetime.datetime:
+            raise TypeError("given arg must be datetime, but was type <%s>" % type(other).__name__)
+        if self.val <= other:
+            return self.error(
+                "Expected <%s> to be after <%s>, but was not."
+                % (self.val.strftime("%Y-%m-%d %H:%M:%S"), other.strftime("%Y-%m-%d %H:%M:%S"))
+            )
+        return self
+
+    def is_equal_to_ignoring_milliseconds(self, other) -> Self:
+        """Asserts that val is a date and is equal to other date to the second.
+
+        Args:
+            other: the other date, expected to be equal to the second
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                d1 = datetime.datetime(2020, 1, 2, 3, 4, 5, 6)       # 2020-01-02 03:04:05.000006
+                d2 = datetime.datetime(2020, 1, 2, 3, 4, 5, 777777)  # 2020-01-02 03:04:05.777777
+
+                assert_that(d1).is_equal_to_ignoring_milliseconds(d2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** equal to the given date to the second
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError("val must be datetime, but was type <%s>" % type(self.val).__name__)
+        if type(other) is not datetime.datetime:
+            raise TypeError("given arg must be datetime, but was type <%s>" % type(other).__name__)
+        if (
+            self.val.date() != other.date()
+            or self.val.hour != other.hour
+            or self.val.minute != other.minute
+            or self.val.second != other.second
+        ):
+            return self.error(
+                "Expected <%s> to be equal to <%s>, but was not."
+                % (self.val.strftime("%Y-%m-%d %H:%M:%S"), other.strftime("%Y-%m-%d %H:%M:%S"))
+            )
+        return self
+
+    def is_equal_to_ignoring_seconds(self, other) -> Self:
+        """Asserts that val is a date and is equal to other date to the minute.
+
+        Args:
+            other: the other date, expected to be equal to the minute
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                d1 = datetime.datetime(2020, 1, 2, 3, 4, 5)   # 2020-01-02 03:04:05
+                d2 = datetime.datetime(2020, 1, 2, 3, 4, 55)  # 2020-01-02 03:04:55
+
+                assert_that(d1).is_equal_to_ignoring_seconds(d2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** equal to the given date to the minute
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError("val must be datetime, but was type <%s>" % type(self.val).__name__)
+        if type(other) is not datetime.datetime:
+            raise TypeError("given arg must be datetime, but was type <%s>" % type(other).__name__)
+        if self.val.date() != other.date() or self.val.hour != other.hour or self.val.minute != other.minute:
+            return self.error(
+                "Expected <%s> to be equal to <%s>, but was not."
+                % (self.val.strftime("%Y-%m-%d %H:%M"), other.strftime("%Y-%m-%d %H:%M"))
+            )
+        return self
+
+    def is_equal_to_ignoring_time(self, other) -> Self:
+        """Asserts that val is a date and is equal to other date ignoring time.
+
+        Args:
+            other: the other date, expected to be equal ignoring time
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                d1 = datetime.datetime(2020, 1, 2, 3, 4, 5)     # 2020-01-02 03:04:05
+                d2 = datetime.datetime(2020, 1, 2, 13, 44, 55)  # 2020-01-02 13:44:55
+
+                assert_that(d1).is_equal_to_ignoring_time(d2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** equal to the given date ignoring time
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError("val must be datetime, but was type <%s>" % type(self.val).__name__)
+        if type(other) is not datetime.datetime:
+            raise TypeError("given arg must be datetime, but was type <%s>" % type(other).__name__)
+        if self.val.date() != other.date():
+            return self.error(
+                "Expected <%s> to be equal to <%s>, but was not."
+                % (self.val.strftime("%Y-%m-%d"), other.strftime("%Y-%m-%d"))
+            )
+        return self