def test_instance_converters(self):
class Type1(object):
def __init__(self, foo, bar):
self.foo = foo
self.bar = bar
type1 = lt.Object({
'foo': lt.String(),
'bar': lt.Integer()
}, constructor=Type1)
registry = new_registry()
strategy = registry.convert(type1)
for _ in six.moves.range(100):
assert isinstance(strategy.example(), Type1)
registry.register(
type1,
lambda _, type, context=None: hs.tuples(hs.text(), hs.integers())
)
strategy = registry.convert(type1)
for _ in six.moves.range(100):
assert isinstance(strategy.example(), tuple)
def test_later_converters_take_precedence(self):
def converter(_, type, context=None):
return hs.integers()
registry = new_registry()
registry.register(lt.String, converter)
strategy = registry.convert(lt.String())
for _ in six.moves.range(100):
assert isinstance(strategy.example(), six.integer_types)
def test_replacing_instance_converters(self):
type1 = lt.String()
registry = new_registry()
registry.register(
type1,
lambda _, type, context=None: hs.integers()
)
registry.register(
type1,
lambda _, type, context=None: hs.booleans()
)
strategy = registry.convert(type1)
for _ in six.moves.range(100):
assert isinstance(strategy.example(), bool)
import lollipop.types as lt
import lollipop.validators as lv
import string
EMAIL_REGEXP = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]{2,}\.[a-zA-Z0-9-.]{2,}$"
Email = lt.validated_type(lt.String, 'Email', lv.Regexp(EMAIL_REGEXP))
USER = lt.Object({
'name': lt.String(validate=lv.Length(min=1)),
'email': Email(),
'age': lt.Optional(lt.Integer(validate=lv.Range(min=18))),
})
import hypothesis as h
import hypothesis.strategies as hs
import lollipop_hypothesis as lh
# Use custom strategy for Email type
user_strategy = lh.type_strategy(USER)
print user_strategy.example()
def test_multiple_any_of_validators_resulting_in_no_values(self):
with pytest.raises(ValueError):
type_strategy(lt.String(validate=[lv.AnyOf(['foo']), lv.AnyOf(['bar'])]))
class TestRegistry:
@given(type_strategy(lt.String()))
def test_string(self, value):
assert isinstance(value, six.string_types)
@given(type_strategy(lt.String(validate=lv.Length(exact=6))))
def test_string_exact_length_validator(self, value):
assert len(value) == 6
@given(type_strategy(lt.String(validate=lv.Length(min=1))))
def test_string_min_length_validator(self, value):
assert len(value) >= 1
@given(type_strategy(lt.String(validate=lv.Length(max=10))))
def test_string_max_length_validator(self, value):
assert len(value) <= 10
@given(type_strategy(lt.String(validate=lv.Length(min=3, max=10))))
def test_string_min_and_max_length_validator(self, value):
assert 3 <= len(value) <= 10
EMAIL_REGEX = '^[^@]+@(\w{2,}\.)+\w{2,}$'
@given(type_strategy(lt.String(validate=lv.Regexp(EMAIL_REGEX))))
def test_string_regex(self, value):
assert re.match(self.EMAIL_REGEX, value)
@given(type_strategy(lt.Integer()))
def test_integer(self, value):
assert isinstance(value, six.integer_types)
@given(type_strategy(lt.Integer(validate=lv.Range(min=5))))
def test_integer_min_range_validator(self, value):
assert value >= 5
@given(type_strategy(lt.Integer(validate=lv.Range(max=5))))
def test_integer_max_range_validator(self, value):
assert value <= 5
@given(type_strategy(lt.Integer(validate=lv.Range(min=5, max=10))))
def test_integer_min_and_max_range_validator(self, value):
assert 5 <= value <= 10
@given(type_strategy(lt.Integer(validate=lv.Predicate(lambda x: x < 10))))
def test_integer_custom_validators(self, value):
assert value < 10
@given(type_strategy(lt.Float()))
def test_float(self, value):
assert isinstance(value, float)
@given(type_strategy(lt.Float(validate=lv.Range(min=5))))
def test_float_min_range_validator(self, value):
assert value >= 5
@given(type_strategy(lt.Float(validate=lv.Range(max=5))))
def test_float_max_range_validator(self, value):
assert value <= 5
@given(type_strategy(lt.Float(validate=lv.Range(min=5, max=10))))
def test_float_min_and_max_range_validator(self, value):
assert 5 <= value <= 10
@given(type_strategy(lt.Float(validate=lv.Predicate(lambda x: x < 10.0))))
def test_float_custom_validators(self, value):
assert value < 10.0
@given(type_strategy(lt.Boolean()))
def test_boolean(self, value):
assert isinstance(value, bool)
@given(type_strategy(lt.DateTime()))
def test_datetime(self, value):
assert isinstance(value, datetime.datetime)
@given(type_strategy(lt.Date()))
def test_date(self, value):
assert isinstance(value, datetime.date)
@given(type_strategy(lt.Time()))
def test_time(self, value):
assert isinstance(value, datetime.time)
@given(type_strategy(lt.List(lt.String())))
def test_list(self, items):
assert isinstance(items, list)
assert all(isinstance(item, six.string_types) for item in items)
@given(type_strategy(lt.List(lt.Integer(), validate=lv.Length(exact=6))))
def test_list_exact_length_validator(self, value):
assert len(value) == 6
@given(type_strategy(lt.List(lt.Integer(), validate=lv.Length(min=1))))
def test_list_min_length_validator(self, value):
assert len(value) >= 1
@given(type_strategy(lt.List(lt.Integer(), validate=lv.Length(max=10))))
def test_list_max_length_validator(self, value):
assert len(value) <= 10
@given(type_strategy(lt.List(lt.Integer(), validate=lv.Length(min=3, max=10))))
def test_list_min_and_max_length_validator(self, value):
assert 3 <= len(value) <= 10
@given(type_strategy(lt.List(lt.Integer(), validate=lv.Unique())))
def test_list_unique_validator(self, value):
assert sorted(set(value)) == sorted(value)
@given(type_strategy(
lt.List(lt.Tuple([lt.String(), lt.Integer()]),
validate=lv.Unique(key=lambda x: x[0]))
))
def test_list_unique_key_validator(self, value):
assert sorted({x[0] for x in value}) == sorted(map(lambda x: x[0], value))
@given(type_strategy(lt.Tuple([lt.String(), lt.Integer(), lt.Boolean()])))
def test_tuple(self, value):
assert isinstance(value, tuple)
assert len(value) == 3
assert isinstance(value[0], six.string_types)
assert isinstance(value[1], six.integer_types)
assert isinstance(value[2], bool)
@given(type_strategy(lt.Dict({'foo': lt.String(), 'bar': lt.Integer()})))
def test_dictionary(self, value):
assert isinstance(value, dict)
assert sorted(value.keys()) == sorted(['foo', 'bar'])
assert isinstance(value['foo'], six.string_types)
assert isinstance(value['bar'], six.integer_types)
@given(type_strategy(lt.Dict(lt.Integer())))
def test_variadic_dictionary(self, value):
assert isinstance(value, dict)
assert all(isinstance(item, six.string_types) for item in value.keys())
assert all(isinstance(item, six.integer_types) for item in value.values())
@given(type_strategy(lt.Dict(lt.String(), key_type=lt.Integer())))
def test_custom_dictionary_keys(self, value):
assert isinstance(value, dict)
assert all(isinstance(item, six.integer_types) for item in value.keys())
@given(type_strategy(lt.Object({'foo': lt.String(), 'bar': lt.Integer()},
constructor=namedtuple('Test', ['foo', 'bar']))))
def test_object(self, value):
assert hasattr(value, 'foo')
assert hasattr(value, 'bar')
assert isinstance(value.foo, six.string_types)
assert isinstance(value.bar, six.integer_types)
@given(type_strategy(lt.Constant(123)))
def test_constant(self, value):
assert value == 123
@given(type_strategy(lt.OneOf([lt.String(), lt.Integer(), lt.Boolean()])))
def test_one_of_type_list(self, value):
assert isinstance(value, six.string_types) \
or isinstance(value, six.integer_types) \
or isinstance(value, bool)
@given(type_strategy(lt.String(validate=lv.AnyOf(['foo', 'bar', 'baz']))))
def test_any_of_validator(self, value):
assert value in ['foo', 'bar', 'baz']
@given(type_strategy(lt.String(validate=[lv.AnyOf(['foo', 'bar', 'baz']),
lv.AnyOf(['bar', 'baz', 'bam'])])))
def test_multiple_any_of_validators(self, value):
assert value in ['bar', 'baz']
@given(type_strategy(lt.String(validate=[lv.AnyOf(['foo', 'bar']),
lv.AnyOf(['bar', 'baz'])])))
def test_multiple_any_of_validators_resulting_in_single_value(self, value):
assert value == 'bar'
def test_multiple_any_of_validators_resulting_in_no_values(self):
with pytest.raises(ValueError):
type_strategy(lt.String(validate=[lv.AnyOf(['foo']), lv.AnyOf(['bar'])]))
@given(type_strategy(lt.Optional(lt.String())))
def test_optional(self, value):
assert value is None or isinstance(value, six.string_types)
@given(type_strategy(lt.Optional(lt.String(), load_default='default')))
def test_optional_with_load_default(self, value):
assert value is not None
# @given(type_strategy(lt.DumpOnly(lt.String())))
# def test_dump_only(self, value):
# assert isinstance(value, six.string_types)
@given(type_strategy(lt.LoadOnly(lt.String())))
def test_load_only(self, value):
assert isinstance(value, six.string_types)
@given(type_strategy(
lt.Transform(lt.Integer(validate=lv.Range(min=0, max=100)),
post_load=lambda x: x + 100)
))
def test_transform_applies_post_load(self, value):
assert isinstance(value, int)
assert 100 <= value <= 200
def test_later_converters_take_precedence(self):
def converter(_, type, context=None):
return hs.integers()
registry = new_registry()
registry.register(lt.String, converter)
strategy = registry.convert(lt.String())
for _ in six.moves.range(100):
assert isinstance(strategy.example(), six.integer_types)
def test_instance_converters(self):
class Type1(object):
def __init__(self, foo, bar):
self.foo = foo
self.bar = bar
type1 = lt.Object({
'foo': lt.String(),
'bar': lt.Integer()
}, constructor=Type1)
registry = new_registry()
strategy = registry.convert(type1)
for _ in six.moves.range(100):
assert isinstance(strategy.example(), Type1)
registry.register(
type1,
lambda _, type, context=None: hs.tuples(hs.text(), hs.integers())
)
strategy = registry.convert(type1)
for _ in six.moves.range(100):
assert isinstance(strategy.example(), tuple)
def test_replacing_instance_converters(self):
type1 = lt.String()
registry = new_registry()
registry.register(
type1,
lambda _, type, context=None: hs.integers()
)
registry.register(
type1,
lambda _, type, context=None: hs.booleans()
)
strategy = registry.convert(type1)
for _ in six.moves.range(100):
assert isinstance(strategy.example(), bool)