blob: 07bfc5234ade5103d8f0e34ca26516043ade9ff1 [file] [log] [blame]
# SPDX-License-Identifier: MIT
"""
Tests for methods from `attrib._cmp`.
"""
import pytest
from attr._cmp import cmp_using
# Test parameters.
EqCSameType = cmp_using(eq=lambda a, b: a == b, class_name="EqCSameType")
PartialOrderCSameType = cmp_using(
eq=lambda a, b: a == b,
lt=lambda a, b: a < b,
class_name="PartialOrderCSameType",
)
FullOrderCSameType = cmp_using(
eq=lambda a, b: a == b,
lt=lambda a, b: a < b,
le=lambda a, b: a <= b,
gt=lambda a, b: a > b,
ge=lambda a, b: a >= b,
class_name="FullOrderCSameType",
)
EqCAnyType = cmp_using(
eq=lambda a, b: a == b, require_same_type=False, class_name="EqCAnyType"
)
PartialOrderCAnyType = cmp_using(
eq=lambda a, b: a == b,
lt=lambda a, b: a < b,
require_same_type=False,
class_name="PartialOrderCAnyType",
)
eq_data = [
(EqCSameType, True),
(EqCAnyType, False),
]
order_data = [
(PartialOrderCSameType, True),
(PartialOrderCAnyType, False),
(FullOrderCSameType, True),
]
eq_ids = [c[0].__name__ for c in eq_data]
order_ids = [c[0].__name__ for c in order_data]
cmp_data = eq_data + order_data
cmp_ids = eq_ids + order_ids
class TestEqOrder:
"""
Tests for eq and order related methods.
"""
#########
# eq
#########
@pytest.mark.parametrize(
("cls", "requires_same_type"), cmp_data, ids=cmp_ids
)
def test_equal_same_type(self, cls, requires_same_type):
"""
Equal objects are detected as equal.
"""
assert cls(1) == cls(1)
assert not (cls(1) != cls(1))
@pytest.mark.parametrize(
("cls", "requires_same_type"), cmp_data, ids=cmp_ids
)
def test_unequal_same_type(self, cls, requires_same_type):
"""
Unequal objects of correct type are detected as unequal.
"""
assert cls(1) != cls(2)
assert not (cls(1) == cls(2))
@pytest.mark.parametrize(
("cls", "requires_same_type"), cmp_data, ids=cmp_ids
)
def test_equal_different_type(self, cls, requires_same_type):
"""
Equal values of different types are detected appropriately.
"""
assert (cls(1) == cls(1.0)) == (not requires_same_type)
assert not (cls(1) != cls(1.0)) == (not requires_same_type)
#########
# lt
#########
@pytest.mark.parametrize(
("cls", "requires_same_type"), eq_data, ids=eq_ids
)
def test_lt_unorderable(self, cls, requires_same_type):
"""
TypeError is raised if class does not implement __lt__.
"""
with pytest.raises(TypeError):
cls(1) < cls(2)
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_lt_same_type(self, cls, requires_same_type):
"""
Less-than objects are detected appropriately.
"""
assert cls(1) < cls(2)
assert not (cls(2) < cls(1))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_not_lt_same_type(self, cls, requires_same_type):
"""
Not less-than objects are detected appropriately.
"""
assert cls(2) >= cls(1)
assert not (cls(1) >= cls(2))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_lt_different_type(self, cls, requires_same_type):
"""
Less-than values of different types are detected appropriately.
"""
if requires_same_type:
# Unlike __eq__, NotImplemented will cause an exception to be
# raised from __lt__.
with pytest.raises(TypeError):
cls(1) < cls(2.0)
else:
assert cls(1) < cls(2.0)
assert not (cls(2) < cls(1.0))
#########
# le
#########
@pytest.mark.parametrize(
("cls", "requires_same_type"), eq_data, ids=eq_ids
)
def test_le_unorderable(self, cls, requires_same_type):
"""
TypeError is raised if class does not implement __le__.
"""
with pytest.raises(TypeError):
cls(1) <= cls(2)
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_le_same_type(self, cls, requires_same_type):
"""
Less-than-or-equal objects are detected appropriately.
"""
assert cls(1) <= cls(1)
assert cls(1) <= cls(2)
assert not (cls(2) <= cls(1))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_not_le_same_type(self, cls, requires_same_type):
"""
Not less-than-or-equal objects are detected appropriately.
"""
assert cls(2) > cls(1)
assert not (cls(1) > cls(1))
assert not (cls(1) > cls(2))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_le_different_type(self, cls, requires_same_type):
"""
Less-than-or-equal values of diff. types are detected appropriately.
"""
if requires_same_type:
# Unlike __eq__, NotImplemented will cause an exception to be
# raised from __le__.
with pytest.raises(TypeError):
cls(1) <= cls(2.0)
else:
assert cls(1) <= cls(2.0)
assert cls(1) <= cls(1.0)
assert not (cls(2) <= cls(1.0))
#########
# gt
#########
@pytest.mark.parametrize(
("cls", "requires_same_type"), eq_data, ids=eq_ids
)
def test_gt_unorderable(self, cls, requires_same_type):
"""
TypeError is raised if class does not implement __gt__.
"""
with pytest.raises(TypeError):
cls(2) > cls(1)
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_gt_same_type(self, cls, requires_same_type):
"""
Greater-than objects are detected appropriately.
"""
assert cls(2) > cls(1)
assert not (cls(1) > cls(2))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_not_gt_same_type(self, cls, requires_same_type):
"""
Not greater-than objects are detected appropriately.
"""
assert cls(1) <= cls(2)
assert not (cls(2) <= cls(1))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_gt_different_type(self, cls, requires_same_type):
"""
Greater-than values of different types are detected appropriately.
"""
if requires_same_type:
# Unlike __eq__, NotImplemented will cause an exception to be
# raised from __gt__.
with pytest.raises(TypeError):
cls(2) > cls(1.0)
else:
assert cls(2) > cls(1.0)
assert not (cls(1) > cls(2.0))
#########
# ge
#########
@pytest.mark.parametrize(
("cls", "requires_same_type"), eq_data, ids=eq_ids
)
def test_ge_unorderable(self, cls, requires_same_type):
"""
TypeError is raised if class does not implement __ge__.
"""
with pytest.raises(TypeError):
cls(2) >= cls(1)
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_ge_same_type(self, cls, requires_same_type):
"""
Greater-than-or-equal objects are detected appropriately.
"""
assert cls(1) >= cls(1)
assert cls(2) >= cls(1)
assert not (cls(1) >= cls(2))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_not_ge_same_type(self, cls, requires_same_type):
"""
Not greater-than-or-equal objects are detected appropriately.
"""
assert cls(1) < cls(2)
assert not (cls(1) < cls(1))
assert not (cls(2) < cls(1))
@pytest.mark.parametrize(
("cls", "requires_same_type"), order_data, ids=order_ids
)
def test_ge_different_type(self, cls, requires_same_type):
"""
Greater-than-or-equal values of diff. types are detected appropriately.
"""
if requires_same_type:
# Unlike __eq__, NotImplemented will cause an exception to be
# raised from __ge__.
with pytest.raises(TypeError):
cls(2) >= cls(1.0)
else:
assert cls(2) >= cls(2.0)
assert cls(2) >= cls(1.0)
assert not (cls(1) >= cls(2.0))
class TestDundersUnnamedClass:
"""
Tests for dunder attributes of unnamed classes.
"""
cls = cmp_using(eq=lambda a, b: a == b)
def test_class(self):
"""
Class name and qualified name should be well behaved.
"""
assert self.cls.__name__ == "Comparable"
assert self.cls.__qualname__ == "Comparable"
def test_eq(self):
"""
__eq__ docstring and qualified name should be well behaved.
"""
method = self.cls.__eq__
assert method.__doc__.strip() == "Return a == b. Computed by attrs."
assert method.__name__ == "__eq__"
def test_ne(self):
"""
__ne__ docstring and qualified name should be well behaved.
"""
method = self.cls.__ne__
assert method.__doc__.strip() == (
"Check equality and either forward a NotImplemented or\n"
" return the result negated."
)
assert method.__name__ == "__ne__"
class TestTotalOrderingException:
"""
Test for exceptions related to total ordering.
"""
def test_eq_must_specified(self):
"""
`total_ordering` requires `__eq__` to be specified.
"""
with pytest.raises(ValueError) as ei:
cmp_using(lt=lambda a, b: a < b)
assert ei.value.args[0] == (
"eq must be define is order to complete ordering from "
"lt, le, gt, ge."
)
class TestNotImplementedIsPropagated:
"""
Test related to functions that return NotImplemented.
"""
def test_not_implemented_is_propagated(self):
"""
If the comparison function returns NotImplemented,
the dunder method should too.
"""
C = cmp_using(eq=lambda a, b: NotImplemented if a == 1 else a == b)
assert C(2) == C(2)
assert C(1) != C(1)
class TestDundersPartialOrdering:
"""
Tests for dunder attributes of classes with partial ordering.
"""
cls = PartialOrderCSameType
def test_class(self):
"""
Class name and qualified name should be well behaved.
"""
assert self.cls.__name__ == "PartialOrderCSameType"
assert self.cls.__qualname__ == "PartialOrderCSameType"
def test_eq(self):
"""
__eq__ docstring and qualified name should be well behaved.
"""
method = self.cls.__eq__
assert method.__doc__.strip() == "Return a == b. Computed by attrs."
assert method.__name__ == "__eq__"
def test_ne(self):
"""
__ne__ docstring and qualified name should be well behaved.
"""
method = self.cls.__ne__
assert method.__doc__.strip() == (
"Check equality and either forward a NotImplemented or\n"
" return the result negated."
)
assert method.__name__ == "__ne__"
def test_lt(self):
"""
__lt__ docstring and qualified name should be well behaved.
"""
method = self.cls.__lt__
assert method.__doc__.strip() == "Return a < b. Computed by attrs."
assert method.__name__ == "__lt__"
def test_le(self):
"""
__le__ docstring and qualified name should be well behaved.
"""
method = self.cls.__le__
assert method.__doc__.strip().startswith(
"Return a <= b. Computed by @total_ordering from"
)
assert method.__name__ == "__le__"
def test_gt(self):
"""
__gt__ docstring and qualified name should be well behaved.
"""
method = self.cls.__gt__
assert method.__doc__.strip().startswith(
"Return a > b. Computed by @total_ordering from"
)
assert method.__name__ == "__gt__"
def test_ge(self):
"""
__ge__ docstring and qualified name should be well behaved.
"""
method = self.cls.__ge__
assert method.__doc__.strip().startswith(
"Return a >= b. Computed by @total_ordering from"
)
assert method.__name__ == "__ge__"
class TestDundersFullOrdering:
"""
Tests for dunder attributes of classes with full ordering.
"""
cls = FullOrderCSameType
def test_class(self):
"""
Class name and qualified name should be well behaved.
"""
assert self.cls.__name__ == "FullOrderCSameType"
assert self.cls.__qualname__ == "FullOrderCSameType"
def test_eq(self):
"""
__eq__ docstring and qualified name should be well behaved.
"""
method = self.cls.__eq__
assert method.__doc__.strip() == "Return a == b. Computed by attrs."
assert method.__name__ == "__eq__"
def test_ne(self):
"""
__ne__ docstring and qualified name should be well behaved.
"""
method = self.cls.__ne__
assert method.__doc__.strip() == (
"Check equality and either forward a NotImplemented or\n"
" return the result negated."
)
assert method.__name__ == "__ne__"
def test_lt(self):
"""
__lt__ docstring and qualified name should be well behaved.
"""
method = self.cls.__lt__
assert method.__doc__.strip() == "Return a < b. Computed by attrs."
assert method.__name__ == "__lt__"
def test_le(self):
"""
__le__ docstring and qualified name should be well behaved.
"""
method = self.cls.__le__
assert method.__doc__.strip() == "Return a <= b. Computed by attrs."
assert method.__name__ == "__le__"
def test_gt(self):
"""
__gt__ docstring and qualified name should be well behaved.
"""
method = self.cls.__gt__
assert method.__doc__.strip() == "Return a > b. Computed by attrs."
assert method.__name__ == "__gt__"
def test_ge(self):
"""
__ge__ docstring and qualified name should be well behaved.
"""
method = self.cls.__ge__
assert method.__doc__.strip() == "Return a >= b. Computed by attrs."
assert method.__name__ == "__ge__"