def test_respects_max_examples_in_database_usage():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    do_we_care = True
    counter = [0]

    def check(x):
        counter[0] += 1
        return do_we_care and any(x)

    def stuff():
        try:
            find(st.binary(min_size=100),
                 check,
                 settings=settings(database=database, max_examples=10),
                 database_key=key)
        except NoSuchExample:
            pass

    stuff()
    assert len(set(database.fetch(key))) > 10
    do_we_care = False
    counter[0] = 0
    stuff()
    assert counter == [10]
def test_clears_out_database_as_things_get_boring():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    do_we_care = True

    def stuff():
        try:
            find(st.binary(min_size=50),
                 lambda x: do_we_care and any(x),
                 settings=settings(database=database, max_examples=10),
                 database_key=key)
        except NoSuchExample:
            pass

    stuff()
    assert len(set(database.fetch(key))) > 1
    do_we_care = False
    stuff()
    initial = len(set(database.fetch(key)))
    assert initial > 0

    for _ in range(initial):
        stuff()
        keys = set(database.fetch(key))
        if not keys:
            break
    else:
        assert False
def test_respects_max_examples_in_database_usage():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    do_we_care = True
    counter = [0]

    def check(x):
        counter[0] += 1
        return do_we_care and any(x)

    def stuff():
        try:
            find(
                st.binary(min_size=100), check,
                settings=settings(database=database, max_examples=10),
                database_key=key
            )
        except NoSuchExample:
            pass
    stuff()
    assert len(set(database.fetch(key))) > 10
    do_we_care = False
    counter[0] = 0
    stuff()
    assert counter == [10]
def test_clears_out_database_as_things_get_boring():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    do_we_care = True

    def stuff():
        try:
            find(
                st.binary(min_size=50), lambda x: do_we_care and any(x),
                settings=settings(database=database, max_examples=10),
                database_key=key
            )
        except NoSuchExample:
            pass
    stuff()
    assert len(set(database.fetch(key))) > 1
    do_we_care = False
    stuff()
    assert len(set(database.fetch(key))) > 0

    for _ in range(100):
        stuff()
        if not set(database.fetch(key)):
            break
    else:
        assert False
def test_saves_incremental_steps_in_database():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    find(st.binary(min_size=10),
         lambda x: any(x),
         settings=settings(database=database),
         database_key=key)
    assert len(set(database.fetch(key))) > 1
def test_saves_incremental_steps_in_database():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    find(
        st.binary(min_size=10), lambda x: any(x),
        settings=settings(database=database), database_key=key
    )
    assert len(set(database.fetch(key))) > 1
def test_ignores_badly_stored_values():
    backend = SQLiteExampleDatabase(':memory:')
    backend.create_db_if_needed()
    with backend.cursor() as cursor:
        cursor.execute("""
            insert into hypothesis_data_mapping(key, value)
            values(?, ?)
        """, (base64.b64encode(b'foo'), u'kittens'))
    assert list(backend.fetch(b'foo')) == []
def test_backend_returns_what_you_put_in(xs):
    backend = SQLiteExampleDatabase(':memory:')
    mapping = {}
    for key, value in xs:
        mapping.setdefault(key, set()).add(value)
        backend.save(key, value)
    for key, values in mapping.items():
        backend_contents = list(backend.fetch(key))
        distinct_backend_contents = set(backend_contents)
        assert len(backend_contents) == len(distinct_backend_contents)
        assert distinct_backend_contents == set(values)
def test_backend_returns_what_you_put_in(xs):
    backend = SQLiteExampleDatabase(':memory:')
    mapping = {}
    for key, value in xs:
        mapping.setdefault(key, set()).add(value)
        backend.save(key, value)
    for key, values in mapping.items():
        backend_contents = list(backend.fetch(key))
        distinct_backend_contents = set(backend_contents)
        assert len(backend_contents) == len(distinct_backend_contents)
        assert distinct_backend_contents == set(values)
def test_does_not_commit_in_error_state():
    backend = SQLiteExampleDatabase(':memory:')
    backend.create_db_if_needed()
    try:
        with backend.cursor() as cursor:
            cursor.execute("""
                insert into hypothesis_data_mapping(key, value)
                values("a", "b")
            """)
            raise ValueError()
    except ValueError:
        pass

    assert list(backend.fetch(b'a')) == []
def exampledatabase(request, tmpdir):
    if request.param == 'memory':
        return ExampleDatabase()
    if request.param == 'sql':
        return SQLiteExampleDatabase(str(tmpdir.join('example.db')))
    if request.param == 'directory':
        return DirectoryBasedExampleDatabase(str(tmpdir.join('examples')))
    assert False
def test_trashes_all_invalid_examples():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    finicky = False

    def stuff():
        try:
            find(st.binary(min_size=100),
                 lambda x: assume(not finicky) and any(x),
                 settings=settings(database=database, timeout=5),
                 database_key=key)
        except Unsatisfiable:
            pass

    stuff()
    assert len(set(database.fetch(key))) > 1
    finicky = True
    stuff()
    assert len(set(database.fetch(key))) == 0
    def __init__(self):
        super(DatabaseComparison, self).__init__()
        self.tempd = tempfile.mkdtemp()
        exampledir = os.path.join(self.tempd, 'examples')

        self.dbs = [
            DirectoryBasedExampleDatabase(exampledir),
            InMemoryExampleDatabase(), SQLiteExampleDatabase(':memory:'),
            DirectoryBasedExampleDatabase(exampledir),
        ]
def test_trashes_all_invalid_examples():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    finicky = False

    def stuff():
        try:
            find(
                st.binary(min_size=100),
                lambda x: assume(not finicky) and any(x),
                settings=settings(database=database, timeout=5),
                database_key=key
            )
        except Unsatisfiable:
            pass
    stuff()
    assert len(set(database.fetch(key))) > 1
    finicky = True
    stuff()
    assert len(set(database.fetch(key))) == 0
Example #15
0
    def __init__(self):
        super(DatabaseComparison, self).__init__()
        self.tempd = tempfile.mkdtemp()
        exampledir = os.path.join(self.tempd, 'examples')

        self.dbs = [
            DirectoryBasedExampleDatabase(exampledir),
            InMemoryExampleDatabase(),
            DirectoryBasedExampleDatabase(exampledir),
        ]

        with validate_deprecation():
            self.dbs.append(SQLiteExampleDatabase(':memory:'))
Example #16
0
def test_ignores_badly_stored_values():
    backend = SQLiteExampleDatabase(':memory:')
    backend.create_db_if_needed()
    with backend.cursor() as cursor:
        cursor.execute("""
            insert into hypothesis_data_mapping(key, value)
            values(?, ?)
        """, (base64.b64encode(b'foo'), u'kittens'))
    assert list(backend.fetch(b'foo')) == []
def test_trashes_invalid_examples():
    key = b"a database key"
    database = SQLiteExampleDatabase(':memory:')
    finicky = False

    def stuff():
        try:
            find(st.binary(min_size=100),
                 lambda x: assume(not finicky) and has_a_non_zero_byte(x),
                 settings=settings(
                     database=database,
                     strict=False,
                     max_shrinks=10,
                 ),
                 database_key=key)
        except Unsatisfiable:
            pass

    stuff()
    original = len(set(database.fetch(key)))
    assert original > 1
    finicky = True
    stuff()
    assert len(set(database.fetch(key))) < original
def test_does_not_commit_in_error_state():
    backend = SQLiteExampleDatabase(':memory:')
    backend.create_db_if_needed()
    try:
        with backend.cursor() as cursor:
            cursor.execute("""
                insert into hypothesis_data_mapping(key, value)
                values("a", "b")
            """)
            raise ValueError()
    except ValueError:
        pass

    assert list(backend.fetch(b'a')) == []
def test_can_delete_keys():
    backend = SQLiteExampleDatabase(':memory:')
    backend.save(b'foo', b'bar')
    backend.save(b'foo', b'baz')
    backend.delete(b'foo', b'bar')
    assert list(backend.fetch(b'foo')) == [b'baz']
def test_can_double_close():
    backend = SQLiteExampleDatabase(':memory:')
    backend.create_db_if_needed()
    backend.close()
    backend.close()
def test_can_delete_keys():
    backend = SQLiteExampleDatabase(':memory:')
    backend.save(b'foo', b'bar')
    backend.save(b'foo', b'baz')
    backend.delete(b'foo', b'bar')
    assert list(backend.fetch(b'foo')) == [b'baz']
def test_can_double_close():
    backend = SQLiteExampleDatabase(':memory:')
    backend.create_db_if_needed()
    backend.close()
    backend.close()
def test_selects_sqlite_if_already_sqlite(tmpdir):
    path = str(tmpdir.join('hi'))
    SQLiteExampleDatabase(path).save(b"foo", b"bar")
    assert isinstance(ExampleDatabase(path), SQLiteExampleDatabase)