dependency_injection.py/tests.py at master · AspenWeb/dependency_injection.py · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
from pytest import raises
from dependency_injection import get_signature, resolve_dependencies, CantUseThis


# get_signature
# ===============

def test_get_signature_infers_defaults():
    def func(foo='bar'): pass
    signature = get_signature(func)
    assert signature.parameters == ('foo',)
    assert signature.required == tuple()
    assert signature.optional == {'foo': 'bar'}


def test_get_signature_returns_empty_dict_for_no_defaults():
    def func(foo, bar, baz): pass
    signature = get_signature(func)
    assert signature.parameters == ('foo', 'bar', 'baz')
    assert signature.required == ('foo', 'bar', 'baz')
    assert signature.optional == {}


def test_get_signature_works_with_mixed_arg_kwarg():
    def func(foo, bar, baz='buz'): pass
    signature = get_signature(func)
    assert signature.parameters == ('foo', 'bar', 'baz')
    assert signature.required == ('foo', 'bar')
    assert signature.optional == {'baz': 'buz'}


def test_get_signature_doesnt_conflate_objects_defined_inside():
    def func(foo, bar, baz=2):
        blah = foo * 42
        return blah
    signature = get_signature(func)
    assert signature.parameters == ('foo', 'bar', 'baz')
    assert signature.required == ('foo', 'bar')
    assert signature.optional == {'baz': 2}


# resolve_dependencies
# ====================

def test_resolve_dependencies_resolves_dependencies():
    def func(foo): pass
    deps = resolve_dependencies(func, {'foo': 1})
    assert deps.signature.parameters == ('foo',)
    assert deps.signature.required == ('foo',)
    assert deps.signature.optional == {}
    assert deps.as_args == (1,)
    assert deps.as_kwargs == {'foo': 1}


def test_resolve_dependencies_resolves_two_dependencies():
    def func(foo, bar): pass
    deps = resolve_dependencies(func, {'foo': 1, 'bar': True})
    assert deps.as_args == (1, True)
    assert deps.as_kwargs == {'foo': 1, 'bar': True}


def test_resolve_dependencies_resolves_kwarg():
    def func(foo, bar=False): pass
    deps = resolve_dependencies(func, {'foo': 1, 'bar': True})
    assert deps.as_args == (1, True)
    assert deps.as_kwargs == {'foo': 1, 'bar': True}


def test_resolve_dependencies_honors_kwarg_default():
    def func(foo, bar=False): pass
    deps = resolve_dependencies(func, {'foo': 1})
    assert deps.as_args == (1, False)
    assert deps.as_kwargs == {'foo': 1, 'bar': False}


def test_resolve_dependencies_honors_kwarg_default_of_None():
    def func(foo, bar=None): pass
    deps = resolve_dependencies(func, {'foo': 1})
    assert deps.as_args == (1, None)
    assert deps.as_kwargs == {'foo': 1, 'bar': None}


def test_resolve_dependencies_doesnt_get_hung_up_on_None_though():
    def func(foo, bar=None): pass
    deps = resolve_dependencies(func, {'foo': 1, 'bar': True})
    assert deps.as_args == (1, True)
    assert deps.as_kwargs == {'foo': 1, 'bar': True}


# Non-Function Callables
# ======================
# https://github.com/gittip/dependency_injection.py/issues/2

def check_callable(cllbl):
    deps = resolve_dependencies(cllbl, {'foo': 1, 'bar': True})
    assert deps.as_args == (1, True)
    assert deps.as_kwargs == {'foo': 1, 'bar': True}


def test_resolve_dependencies_can_work_with_oldstyle___new__():
    class Foo():
        def __new__(cls, foo, bar=None):
            pass
    check_callable(Foo)


def test_resolve_dependencies_can_work_with_newstyle___new__():
    class Foo(object):
        def __new__(cls, foo, bar=None):
            pass
    check_callable(Foo)


def test_resolve_dependencies_can_work_with_oldstyle___init__():
    class Foo():
        def __init__(self, foo, bar=None):
            pass
    check_callable(Foo)


def test_resolve_dependencies_can_work_with_newstyle___init__():
    class Foo(object):
        def __init__(self, foo, bar=None):
            pass
    check_callable(Foo)


def test_resolve_dependencies_can_work_with_oldstyle_class_without___new___or___init__():
    class Foo():
        pass
    deps = resolve_dependencies(Foo, {})
    assert deps.as_args == ()
    assert deps.as_kwargs == {}


def test_resolve_dependencies_can_work_with_newstyle_class_without___new___or___init__():
    class Foo(object):
        pass
    deps = resolve_dependencies(Foo, {})
    assert deps.as_args == ()
    assert deps.as_kwargs == {}


def test_resolve_dependencies_can_work_with_an_unbound_method():
    class Foo(object):
        def method(self, foo, bar=None):
            pass
    check_callable(Foo.method)


def test_resolve_dependencies_can_work_with_a_bound_method():
    class Foo(object):
        def method(self, foo, bar=None):
            pass
    check_callable(Foo().method)


def test_resolve_dependencies_can_work_with___call__():
    class Foo(object):
        def __call__(self, foo, bar=None):
            pass
    check_callable(Foo())


def test_resolve_dependencies_raises_CantUseThis():
    Foo = object()
    value = raises(CantUseThis, resolve_dependencies, Foo, {}).value
    class_str = str(Foo)  # Varies slightly between Python 2 and 3
    assert str(value) == "Sorry, we can't get a signature for {0}.".format(class_str)