def test_validates_data_from_database(dav, dav2):
"""
This is a bit of a weird test. Basically we serialize data from one
descriptor and parse it as another. This will sometimes produce a
WrongFormat. That's fine. If it doesn't then there are two cases:
1. These two types have a compatible representation. There's not much
to do about that.
2. A different exception is thrown. That's embarrassing and is only
working by coincidence. That's bad too.
This is mostly checking for consistency rather than correctness I'm afraid.
It's hard to catch all the different behaviours you can get here.
"""
converter = ConverterTable.default().specification_for(dav.descriptor)
basic = converter.to_basic(dav.value)
converter2 = ConverterTable().default().specification_for(dav2.descriptor)
try:
result = converter2.from_basic(basic)
except BadData:
return
basic2 = converter2.to_basic(result)
try:
converter.from_basic(basic2)
except BadData:
pass
def test_can_not_save_as_incompatible_examples(dav, dav2):
strategy = small_table.strategy(dav.descriptor)
assume(not strategy.could_have_produced(dav2.value))
ft = ConverterTable.default()
try:
converter = ft.specification_for(dav.descriptor)
except NotSerializeable:
assume(False)
with pytest.raises(WrongFormat):
converter.to_basic(dav2.value)
def test_storage_does_not_return_things_not_matching_strategy():
table = StrategyTable()
strategy = JustStrategy(PickyStrategyLazyFormat())
strategy.could_have_produced = lambda *args: False
table.define_specification_for(PickyStrategyLazyFormat,
lambda s, d: strategy)
converters = ConverterTable(strategy_table=table)
converters.define_specification_for(
PickyStrategyLazyFormat,
lambda s, d: JustConverter(PickyStrategyLazyFormat()))
database = ExampleDatabase(
converters=converters,
backend=SQLiteBackend(),
)
stor = database.storage_for(PickyStrategyLazyFormat)
database.backend.save(stor.key, 'null')
assert list(database.backend.fetch(stor.key)) != []
assert list(stor.fetch()) == []
assert list(database.backend.fetch(stor.key)) == []
def __init__(
self,
converters=None,
backend=None,
format=None,
):
self.converters = converters or ConverterTable.default()
self.strategies = self.converters.strategy_table
self.backend = backend or SQLiteBackend()
self.format = format or JSONFormat()
if self.format.data_type() != self.backend.data_type():
raise ValueError(
('Inconsistent data types: format provides data of type %s '
'but backend expects data of type %s' %
(self.format.data_type(), self.backend.data_type())))
self.storage_cache = {}
def test_cannot_save_an_example_in_the_wrong_format():
example = falsify(TestRun.run, IsBadAndShouldFeelBad)[0]
converter = ConverterTable.default().specification_for(
IsBadButItsNotMyFault)
with pytest.raises(WrongFormat):
converter.to_basic(example)
def test_simple_data_validation(descriptor, data):
converter = ConverterTable.default().specification_for(descriptor)
with pytest.raises(BadData):
converter.from_basic(data)
def test_simple_back_conversions(descriptor, value):
converter = ConverterTable.default().specification_for(descriptor)
with pytest.raises(BadData):
converter.from_basic(value)
def test_simple_conversions(descriptor, value):
converter = ConverterTable.default().specification_for(descriptor)
with pytest.raises(WrongFormat):
converter.to_basic(value)
steps=steps,
init_args=init_args,
init_kwargs=init_kwargs
)
return TestRun(self.descriptor, steps)
def unpack(self, x):
steps = x.steps
if self.requires_init:
return ((x.init_args, x.init_kwargs), steps)
else:
return steps
def simplify(self, x):
pruned = x.prune()
if pruned:
yield pruned
for y in super(StatefulStrategy, self).simplify(x):
yield y
StrategyTable.default().define_specification_for_classes(
define_stateful_strategy,
subclasses_of=StatefulTest
)
ConverterTable.default().define_specification_for_classes(
StatefulConverter,
subclasses_of=StatefulTest
)
def test_storage_cleans_up_invalid_data_from_the_db():
database = ExampleDatabase()
ints = database.storage_for(int)
database.backend.save(ints.key, '[false, false, true]')
assert list(database.backend.fetch(ints.key)) != []
assert list(ints.fetch()) == []
assert list(database.backend.fetch(ints.key)) == []
class Awkward(str):
pass
ConverterTable.default().mark_not_serializeable(Awkward)
class AwkwardStrategy(SearchStrategy):
descriptor = Awkward
parameter = params.CompositeParameter()
def produce(self, random, pv):
return Awkward()
StrategyTable.default().define_specification_for(
Awkward, lambda s, d: AwkwardStrategy())
def test_can_verify_a_non_serializale_type():
