def test_will_handle_a_really_weird_failure(self, rnd):
db = ExampleDatabase()
@given(
specifier,
settings=Settings(
database=db,
max_examples=max_examples,
min_satisfying_examples=2,
average_list_length=2.0,
), random=rnd
)
def nope(x):
s = hashlib.sha1(repr(x).encode(u'utf-8')).digest()
assert Random(s).randint(0, 1) == Random(s).randint(0, 1)
if Random(s).randint(0, 1):
raise Rejected(u'%r with digest %r' % (
x, s
))
try:
try:
nope()
except Rejected:
pass
try:
nope()
except Rejected:
pass
finally:
db.close()
def test_garbage_collects_the_database():
key = b'hi there'
n = 200
db = ExampleDatabase(':memory:')
assert list(db.fetch(key)) == []
seen = set()
go = True
def f(data):
x = hbytes(data.draw_bytes(512))
if not go:
return
if sum(x) >= 5000 and len(seen) < n:
seen.add(x)
if x in seen:
data.mark_interesting()
runner = TestRunner(
f, settings=settings(database=db, max_shrinks=2 * n), database_key=key)
runner.run()
assert runner.last_data.status == Status.INTERESTING
assert len(seen) == n
assert set(db.fetch(key)) == seen
go = False
runner = TestRunner(
f, settings=settings(database=db, max_shrinks=2 * n), database_key=key)
runner.run()
assert 0 < len(set(db.fetch(key))) < n
def test_saves_data_while_shrinking():
key = b'hi there'
n = 5
db = ExampleDatabase(':memory:')
assert list(db.fetch(key)) == []
seen = set()
def f(data):
x = data.draw_bytes(512)
if sum(x) >= 5000 and len(seen) < n:
seen.add(hbytes(x))
if hbytes(x) in seen:
data.mark_interesting()
runner = ConjectureRunner(
f, settings=settings(database=db), database_key=key)
runner.run()
assert runner.last_data.status == Status.INTERESTING
assert len(seen) == n
in_db = set(
v
for vs in db.data.values()
for v in vs
)
assert in_db.issubset(seen)
assert in_db == seen
def test_storage_cleans_up_invalid_data_from_the_db():
database = ExampleDatabase()
ints = database.storage_for(integers())
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)) == []
def test_will_handle_a_really_weird_failure(self, s):
db = ExampleDatabase()
@given(specifier)
@Settings(
settings,
database=db,
max_examples=max_examples,
min_satisfying_examples=2,
)
@seed(s)
def nope(x):
s = hashlib.sha1(repr(x).encode('utf-8')).digest()
assert Random(s).randint(0, 1) == Random(s).randint(0, 1)
if Random(s).randint(0, 1):
raise Rejected('%r with digest %r' % (
x, s
))
try:
try:
nope()
except Rejected:
pass
try:
nope()
except Rejected:
pass
finally:
db.close()
def via_database(spec, strat, template):
db = ExampleDatabase()
s = db.storage_for(strat, strat)
s.save(template)
results = list(s.fetch())
assert len(results) == 1
return results[0]
def test_storage_does_not_error_if_the_database_is_invalid():
database = ExampleDatabase()
strat = integers()
key = u'wtf'
ints = database.storage(key)
database.backend.save(key, u'["hi", "there"]')
assert list(ints.fetch(strat)) == []
def test_will_handle_a_really_weird_failure(self):
db = ExampleDatabase()
@given(
specifier,
settings=Settings(
database=db,
max_examples=max_examples,
min_satisfying_examples=2,
average_list_length=2.0,
)
)
def nope(x):
s = hashlib.sha1(show(x).encode('utf-8')).digest()
if Random(s).randint(0, 1):
raise Rejected()
try:
try:
nope()
except Rejected:
pass
try:
nope()
except Rejected:
pass
finally:
db.close()
def test_can_round_trip_through_the_database(self, template, rnd):
empty_db = ExampleDatabase(backend=SQLiteBackend(":memory:"))
try:
storage = empty_db.storage("round trip")
storage.save(template, strat)
values = list(storage.fetch(strat))
assert len(values) == 1
assert strat.to_basic(template) == strat.to_basic(values[0])
finally:
empty_db.close()
def via_database(spec, strat, template):
db = ExampleDatabase()
key = u'via_database'
try:
s = db.storage(key)
s.save(template, strat)
results = list(s.fetch(strat))
assert len(results) == 1
return results[0]
finally:
db.close()
def test_will_find_a_failure_from_the_database(self):
db = ExampleDatabase()
@given(specifier, settings=Settings(max_examples=10, database=db))
def nope(x):
raise Rejected()
try:
for i in hrange(3):
self.assertRaises(Rejected, nope) # pragma: no cover
finally:
db.close()
def test_can_round_trip_through_the_database(self, template):
empty_db = ExampleDatabase(
backend=SQLiteBackend(':memory:'),
)
try:
storage = empty_db.storage_for(specifier)
storage.save(template)
values = list(storage.fetch())
assert len(values) == 1
assert strat.to_basic(template) == strat.to_basic(values[0])
finally:
empty_db.close()
def run_round_trip(specifier, value, format=None, backend=None):
if backend is not None:
backend = backend()
else:
backend = SQLiteBackend()
db = ExampleDatabase(format=format, backend=backend)
try:
storage = db.storage(u'round trip')
storage.save(value, specifier)
saved = list(storage.fetch(specifier))
assert len(saved) == 1
assert specifier.to_basic(saved[0]) == specifier.to_basic(value)
finally:
db.close()
def test_can_load_data_from_a_corpus():
key = b'hi there'
db = ExampleDatabase()
value = b'=\xc3\xe4l\x81\xe1\xc2H\xc9\xfb\x1a\xb6bM\xa8\x7f'
db.save(key, value)
def f(data):
if data.draw_bytes(len(value)) == value:
data.mark_interesting()
runner = ConjectureRunner(
f, settings=settings(database=db), database_key=key)
runner.run()
last_data, = runner.interesting_examples.values()
assert last_data.buffer == value
assert len(list(db.fetch(key))) == 1
def test_will_find_a_failure_from_the_database():
db = ExampleDatabase()
class Rejected(Exception):
pass
@given(dav_strategy, settings=Settings(max_examples=10, database=db))
def nope(x):
raise Rejected()
try:
with pytest.raises(Rejected):
nope() # pragma: no branch
finally:
db.close()
def test_can_load_data_from_a_corpus():
key = b"hi there"
db = ExampleDatabase()
value = b"=\xc3\xe4l\x81\xe1\xc2H\xc9\xfb\x1a\xb6bM\xa8\x7f"
db.save(key, value)
def f(data):
if data.draw_bytes(len(value)) == value:
data.mark_interesting()
runner = TestRunner(f, settings=settings(database=db), database_key=key)
runner.run()
assert runner.last_data.status == Status.INTERESTING
assert runner.last_data.buffer == value
assert len(list(db.fetch(key))) == 1
def test_stops_after_max_examples_when_reading():
key = b"key"
db = ExampleDatabase(":memory:")
for i in range(10):
db.save(key, hbytes([i]))
seen = []
def f(data):
seen.append(data.draw_bytes(1))
runner = TestRunner(f, settings=settings(max_examples=1, database=db), database_key=key)
runner.run()
assert len(seen) == 1
def test_can_handle_more_than_max_iterations_in_db():
"""This is checking that if we store a large number of examples in the DB
and then subsequently reduce max_examples below that count, we a) don't
error (which is how this bug was found) and b) stop at max_examples rather
than continuing onwards."""
db = ExampleDatabase()
try:
settings = hs.Settings(database=db, max_examples=10, max_iterations=10)
seen = []
first = [True]
for _ in range(10):
first[0] = True
@given(integers(), settings=settings)
def test_seen(x):
if x not in seen:
if first[0]:
first[0] = False
seen.append(x)
if x not in seen:
raise ValueError(u'Weird')
try:
test_seen()
except ValueError:
pass
assert len(seen) >= 3
seen = []
@given(
integers(), settings=hs.Settings(
max_examples=1, max_iterations=2, database=db))
def test_seen(x):
seen.append(x)
assume(False)
with pytest.raises(Unsatisfiable):
test_seen()
assert len(seen) == 2
finally:
db.close()
def test_stops_after_max_iterations_when_generating():
key = b"key"
value = b"rubber baby buggy bumpers"
max_iterations = 100
db = ExampleDatabase(":memory:")
db.save(key, value)
seen = []
def f(data):
seen.append(data.draw_bytes(len(value)))
data.mark_invalid()
runner = TestRunner(
f, settings=settings(max_examples=1, max_iterations=max_iterations, database=db), database_key=key
)
runner.run()
assert len(seen) == max_iterations
assert value in seen
def test_stops_after_max_iterations_when_reading():
key = b'key'
max_iterations = 1
db = ExampleDatabase(':memory:')
for i in range(10):
db.save(key, hbytes([i]))
seen = []
def f(data):
seen.append(data.draw_bytes(1))
data.mark_invalid()
runner = ConjectureRunner(f, settings=settings(
max_examples=1, max_iterations=max_iterations,
database=db,
), database_key=key)
runner.run()
assert len(seen) == max_iterations
def test_can_handle_more_than_max_examples_values_in_db():
"""This is checking that if we store a large number of examples in the DB
and then subsequently reduce max_examples below that count, we a) don't
error (which is how this bug was found) and b) stop at max_examples rather
than continuing onwards."""
db = ExampleDatabase()
try:
settings = hs.settings(database=db, max_examples=10)
seen = []
first = [True]
for _ in range(10):
first[0] = True
@given(integers())
@settings
def test_seen(x):
if x not in seen:
if first[0]:
first[0] = False
seen.append(x)
assert x in seen
try:
test_seen()
except AssertionError:
pass
assert len(seen) >= 2
seen = []
@given(integers())
@hs.settings(max_examples=1, database=db)
def test_seen(x):
seen.append(x)
test_seen()
assert len(seen) == 1
finally:
db.close()
def test_can_time_out_when_reading_from_database():
should_timeout = False
limit = 0
examples = []
db = ExampleDatabase()
try:
@given(integers(), settings=hs.Settings(timeout=0.1, database=db))
def test_run_test(x):
examples.append(x)
if should_timeout:
time.sleep(0.5)
assert x >= limit
for i in hrange(10):
limit = -i
examples = []
with pytest.raises(AssertionError):
test_run_test()
examples = []
limit = 0
with pytest.raises(AssertionError):
test_run_test()
limit = min(examples) - 1
should_timeout = True
examples = []
with pytest.raises(Timeout):
test_run_test()
assert len(examples) == 1
finally:
db.close()
def test_storage_has_specifier_in_repr():
db = ExampleDatabase()
d = tuples(integers(), integers())
s = db.storage_for(d)
assert repr(d) in repr(s)
def test_can_save_all_strings(s):
db = ExampleDatabase()
storage = db.storage(u'text')
storage.save(tuple(s), text())
def test_can_save_all_strings(s):
db = ExampleDatabase()
storage = db.storage_for(text())
storage.save(tuple(s))
def test_storage_does_not_error_if_the_database_is_invalid():
database = ExampleDatabase()
ints = database.storage_for(integers())
database.backend.save(ints.key, '["hi", "there"]')
assert list(ints.fetch()) == []
def test_storage_has_specifier_in_repr():
db = ExampleDatabase()
d = (int, int)
s = db.storage_for(d)
assert repr(d) in repr(s)
