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 __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():