v = int
return R2
@foreach(
(class_name, cls, value, nullable_or_not)
for class_name, cls, non_null_val in (
('bytes', bytes_type, b'\xE2\x9C\x93\'\\\"\xE2\x9C\x93'),
('text', text_type, 'Herv\u00E9\'\\\"Herv\u00E9'),
('ascii-only text', text_type, 'ASCII'),
) + tuple(
(t.__name__, t, t(42))
for t in integer_types
) + (
('float', float, 0.3),
('bool', bool, True),
('sequence (nonempty)', seq_of(int), (1, 2, 3)),
('sequence (empty)', seq_of(int), []),
('set (nonempty)', set_of(int), (1, 2, 3)),
('set (empty)', set_of(int), []),
('dict (nonempty)', dict_of(text_type, int), {'one':1, 'two':2}),
('dict (empty)', dict_of(text_type, int), []),
('datetime', datetime, datetime(2016, 4, 15, 10, 1, 59)),
('timedelta', timedelta, timedelta(days=1, hours=2, minutes=3, seconds=4)),
(lambda R2: ('other record', R2, R2(2)))(_other_record()),
)
for nullable_or_not, vals in (
(lambda f: f, (non_null_val,)),
(nullable, (non_null_val, None)),
)
for value in vals
)
class MyRecord(Record):
v = seq_of(
int,
nullable=True,
default=(1, 2, 3),
)
class MyRecord(Record):
v = seq_of(MyClass)
class MyRecord1(Record):
v = seq_of(int, nullable=True)
class MyRecord2(Record):
v = seq_of(int, nullable=False)
class Pack(Record):
# Incidently 'wolves' is a good example of the can of worms proper de-pluralisation is, Ruby on Rails notwithstanding
wolves = seq_of(Wolf)
class MyRecord(Record):
v = seq_of(
int,
check=lambda s: len(s) == 3,
)
class MyRecord(Record):
v = nullable(seq_of(int))
class MyRecord(Record):
v = seq_of(Field(int))
class Record2(Record):
elems = seq_of(MyClass2)
class MyRecord(Record):
elems = seq_of(MyClass1)
class Record1(Record):
elems = seq_of(MyClass1)
@test('one_of also accepts a `coerce` kwarg')
def _():
class MyRecord(Record):
v = one_of('a', 'b', 'c', coerce=text_type.lower)
assert_eq(MyRecord('C').v, 'c')
#----------------------------------------------------------------------------------------------------------------------------------
# nonempty
@foreach((
(bytes_type, 'byte strings', b''),
(text_type, 'text strings', ''),
(seq_of(int), 'seqeuence fields', ()),
(set_of(int), 'set fields', ()),
(dict_of(int, int), 'dict fields', {}),
))
def _(ftype, ftype_name, empty_val):
@test('in general {} fields can be empty'.format(ftype_name))
def _():
class MyRecord(Record):
v = ftype
assert_eq(len(MyRecord(empty_val).v), 0)
@test("nonempty {} can't be empty".format(ftype_name))
def _():
class MyRecord(Record):
v = nonempty(ftype)
class Roof(Record):
materials = seq_of(text_type)
class MyRecord(Record):
children = seq_of(RecursiveType)
class MyRecord(Record):
v = seq_of(
int,
coerce=lambda v: map(int, v),
)
class MyRecord(Record):
elems = seq_of(pair_of(int))
class MyRecord(Record):
mylist = seq_of(int)