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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
|
import unittest
from mopidy.models.fields import (
Boolean,
Collection,
Field,
Identifier,
Integer,
String,
)
def create_instance(field):
"""Create an instance of a dummy class for testing fields."""
class Dummy:
attr = field
attr._name = "attr"
return Dummy()
class FieldDescriptorTest(unittest.TestCase):
def test_raw_field_accesible_through_class(self):
field = Field()
instance = create_instance(field)
assert field == instance.__class__.attr
def test_field_knows_its_name(self):
instance = create_instance(Field())
assert "attr" == instance.__class__.attr._name
def test_field_has_none_as_default(self):
instance = create_instance(Field())
assert instance.attr is None
def test_field_does_not_store_default(self):
instance = create_instance(Field())
assert not hasattr(instance, "_attr")
def test_field_assigment_and_retrival(self):
instance = create_instance(Field())
instance.attr = 1234
assert 1234 == instance.attr
def test_field_can_be_reassigned(self):
instance = create_instance(Field())
instance.attr = 1234
instance.attr = 5678
assert 5678 == instance.attr
def test_field_can_be_deleted(self):
instance = create_instance(Field())
instance.attr = 1234
del instance.attr
assert instance.attr is None
assert not hasattr(instance, "_attr")
def test_field_can_be_set_to_none(self):
instance = create_instance(Field())
instance.attr = 1234
instance.attr = None
assert instance.attr is None
assert not hasattr(instance, "_attr")
def test_field_can_be_set_default(self):
default = object()
instance = create_instance(Field(default=default))
instance.attr = 1234
instance.attr = default
assert default == instance.attr
assert not hasattr(instance, "_attr")
class FieldTest(unittest.TestCase):
def test_default_handling(self):
instance = create_instance(Field(default=1234))
assert 1234 == instance.attr
def test_type_checking(self):
instance = create_instance(Field(type=set))
instance.attr = set()
with self.assertRaises(TypeError):
instance.attr = 1234
def test_choices_checking(self):
instance = create_instance(Field(choices=(1, 2, 3)))
instance.attr = 1
with self.assertRaises(TypeError):
instance.attr = 4
def test_default_respects_type_check(self):
with self.assertRaises(TypeError):
create_instance(Field(type=int, default="123"))
def test_default_respects_choices_check(self):
with self.assertRaises(TypeError):
create_instance(Field(choices=(1, 2, 3), default=5))
class StringTest(unittest.TestCase):
def test_default_handling(self):
instance = create_instance(String(default="abc"))
assert "abc" == instance.attr
def test_native_str_allowed(self):
instance = create_instance(String())
instance.attr = "abc"
assert "abc" == instance.attr
def test_unicode_allowed(self):
instance = create_instance(String())
instance.attr = "abc"
assert "abc" == instance.attr
def test_other_disallowed(self):
instance = create_instance(String())
with self.assertRaises(TypeError):
instance.attr = 1234
def test_empty_string(self):
instance = create_instance(String())
instance.attr = ""
assert "" == instance.attr
class IdentifierTest(unittest.TestCase):
def test_default_handling(self):
instance = create_instance(Identifier(default="abc"))
assert "abc" == instance.attr
def test_native_str_allowed(self):
instance = create_instance(Identifier())
instance.attr = "abc"
assert "abc" == instance.attr
def test_unicode_allowed(self):
instance = create_instance(Identifier())
instance.attr = "abc"
assert "abc" == instance.attr
def test_unicode_with_nonascii_allowed(self):
instance = create_instance(Identifier())
instance.attr = "æøå"
assert "æøå" == instance.attr
def test_other_disallowed(self):
instance = create_instance(Identifier())
with self.assertRaises(TypeError):
instance.attr = 1234
def test_empty_string(self):
instance = create_instance(Identifier())
instance.attr = ""
assert "" == instance.attr
class IntegerTest(unittest.TestCase):
def test_default_handling(self):
instance = create_instance(Integer(default=1234))
assert 1234 == instance.attr
def test_int_allowed(self):
instance = create_instance(Integer())
instance.attr = int(123)
assert 123 == instance.attr
def test_float_disallowed(self):
instance = create_instance(Integer())
with self.assertRaises(TypeError):
instance.attr = 123.0
def test_numeric_string_disallowed(self):
instance = create_instance(Integer())
with self.assertRaises(TypeError):
instance.attr = "123"
def test_other_disallowed(self):
instance = create_instance(String())
with self.assertRaises(TypeError):
instance.attr = tuple()
def test_min_validation(self):
instance = create_instance(Integer(min=0))
instance.attr = 0
assert 0 == instance.attr
with self.assertRaises(ValueError):
instance.attr = -1
def test_max_validation(self):
instance = create_instance(Integer(max=10))
instance.attr = 10
assert 10 == instance.attr
with self.assertRaises(ValueError):
instance.attr = 11
class BooleanTest(unittest.TestCase):
def test_default_handling(self):
instance = create_instance(Boolean(default=True))
assert instance.attr is True
def test_true_allowed(self):
instance = create_instance(Boolean())
instance.attr = True
assert instance.attr is True
def test_false_allowed(self):
instance = create_instance(Boolean())
instance.attr = False
assert instance.attr is False
def test_int_forbidden(self):
instance = create_instance(Boolean())
with self.assertRaises(TypeError):
instance.attr = 1
class CollectionTest(unittest.TestCase):
def test_container_instance_is_default(self):
instance = create_instance(Collection(type=int, container=frozenset))
assert frozenset() == instance.attr
def test_empty_collection(self):
instance = create_instance(Collection(type=int, container=frozenset))
instance.attr = []
assert frozenset() == instance.attr
def test_collection_gets_stored_in_container(self):
instance = create_instance(Collection(type=int, container=frozenset))
instance.attr = [1, 2, 3]
assert frozenset([1, 2, 3]) == instance.attr
def test_collection_with_wrong_type(self):
instance = create_instance(Collection(type=int, container=frozenset))
with self.assertRaises(TypeError):
instance.attr = [1, "2", 3]
def test_collection_with_string(self):
instance = create_instance(Collection(type=int, container=frozenset))
with self.assertRaises(TypeError):
instance.attr = "123"
def test_strings_should_not_be_considered_a_collection(self):
instance = create_instance(Collection(type=str, container=tuple))
with self.assertRaises(TypeError):
instance.attr = b"123"
|
