def test_example3_overriding_default(self):
from ducktype import isducktype
class A(object):
attr1 = None
class B(object):
attr1 = None
attr2 = None
class C(B):
@classmethod
def __ducktypecheck__(cls, maybe_duck):
return hasattr(maybe_duck, 'attr1')
class D(B):
def __ducktypecheck__(self, maybe_duck):
return hasattr(maybe_duck, 'attr1')
# A must not ducktype B
assert isducktype(A, B) is False
# Returns A.__ducktypecheck__(C)
assert isducktype(A, C)
assert isducktype(A, D) is False
assert isducktype(A, D())
def test_example2_comparing_objects(self):
from ducktype import isducktype
class A(object):
_protected = 'hidden'
__private = 'hidden'
attr1 = None
def method1(self, arg, kwargs=True):
return kwargs
def method2(self, arg):
return arg
class B(object):
attr1 = None
def method1(self, **kwargs):
return kwargs
def method2(self, arg1, arg2=None):
return None
class C(object):
attr1 = False
def method1(self, arg, kwarg):
return arg
class D(object):
attr1 = False
method1 = None
method2 = None
class E(object):
def method1(self, **kwargs):
return kwargs
def method2(self, arg1, arg2=None):
return None
# it doesn't care if it's an instance or a class
assert isducktype(A, B)
assert isducktype(A(), B)
assert isducktype(A, B())
assert isducktype(A(), B())
# You can call each A method as if it was C
assert isducktype(A, C)
# Reverse is not True
assert isducktype(C, A) is False
# Whereas D as same members as A, two are not functions
assert isducktype(A, D) is False
assert isducktype(D, A) is False
# E need attribute "attr1" to ducktype A
assert isducktype(A, E)
assert isducktype(E, A) is False
def test_when_a_routine_as_varargs_or_keywords_its_always_a_duck_type(self):
func_a = lambda *a1: None
func_b = lambda **b1: None
func_c = lambda *c1, **c2: None
func_d = lambda d1, d2, d3: None
self.assertTrue(isducktype(func_a, func_d))
self.assertTrue(isducktype(func_b, func_d))
self.assertTrue(isducktype(func_c, func_d))
def test_if_cls_is_tuple_test_until_one_is_true(self):
duck1, typecheck1 = self.a_duck_with_type_check(False)
duck2, typecheck2 = self.a_duck_with_type_check(True)
duck3, typecheck3 = self.a_duck_with_type_check(True)
isducktype(self.bird, (duck1, duck2, duck3))
typecheck1.assert_called_once_with(self.bird)
typecheck2.assert_called_once_with(self.bird)
self.assertFalse(typecheck3.called)
def test_a_routine_ducktype_another_when_it_has_same_number_of_args(self):
func_a = lambda a1, a2=None: None
func_b = lambda b1: None
func_c = lambda c1, c2: None
self.assertFalse(isducktype(func_b, func_c))
self.assertFalse(isducktype(func_c, func_b))
self.assertTrue(isducktype(func_b, func_a))
self.assertTrue(isducktype(func_a, func_b))
self.assertTrue(isducktype(func_c, func_a))
self.assertTrue(isducktype(func_a, func_c))
def test_example1_comparing_functions(self):
from ducktype import isducktype
func_a = lambda a1, a2, a3=None: None
func_b = lambda *b1: None
func_c = lambda **c2: None
func_d = lambda d1, d2: None
func_e = lambda e1: None
func_f = lambda f1, f2, f3, f4: None
assert isducktype(func_b, func_a)
assert isducktype(func_c, func_a)
assert isducktype(func_d, func_a)
assert isducktype(func_a, func_e) is False
assert isducktype(func_e, func_a) is False
assert isducktype(func_f, func_a) is False
# with a tuple (== Or)
assert isducktype(func_e, (func_a, func_b))
assert isducktype(func_e, (func_a, func_d)) is False
def test_it_calls_ducktypecheck_if_object_got_it(self):
duck, typecheck = self.a_duck_with_type_check(True)
isducktype(self.bird, duck)
typecheck.assert_called_once_with(self.bird)
def test_an_object_dont_ducktype_another_when_its_methods_are_just_attr(self):
self.assertFalse(isducktype(A, D))
self.assertFalse(isducktype(D, A))
def test_an_object_ducktype_another_when_it_has_at_least_same_public_members_names(self):
self.assertTrue(isducktype(A, B))
self.assertTrue(isducktype(A(), B))
self.assertTrue(isducktype(A, B()))
self.assertTrue(isducktype(A(), B()))
def test_an_object_ducktype_another_when_its_methods_have_at_least_same_number_of_args(self):
self.assertTrue(isducktype(A, C))
self.assertTrue(isducktype(A(), C))
self.assertTrue(isducktype(A, C()))
self.assertTrue(isducktype(A(), C()))
