예제 #1
0
    def test_compact_index_with_different_types(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        ind_id = UniqueHashIndex(db.path, "id")
        db.set_indexes([ind_id])
        db.create()
        l = []
        for i in range(10):
            c = dict(i=i)
            c.update(db.insert(c))
            l.append(c)

        #        with name
        for i in range(10):
            curr = l[i]
            c = db.get("id", curr["_id"])
            c["update"] = True
            c.update(db.update(c))

        db.compact_index(ind_id.name)
        for j in range(10):
            curr = l[j]
            c = db.get("id", curr["_id"])
            assert c["_id"] == curr["_id"]
            assert c["i"] == j

        #        with instance
        for i in range(10):
            curr = l[i]
            c = db.get("id", curr["_id"])
            c["update"] = True
            c.update(db.update(c))

        ind_id = db.indexes_names[ind_id.name]
        db.compact_index(ind_id)
        for j in range(10):
            curr = l[j]
            c = db.get("id", curr["_id"])
            assert c["_id"] == curr["_id"]
            assert c["i"] == j

        #        with different instance
        for i in range(10):
            curr = l[i]
            c = db.get("id", curr["_id"])
            c["update"] = True
            c.update(db.update(c))

        with pytest.raises(DatabaseException):
            db.compact_index(UniqueHashIndex(db.path, "id"))

        for j in range(10):
            curr = l[j]
            c = db.get("id", curr["_id"])
            assert c["_id"] == curr["_id"]
            assert c["i"] == j

        db.close()
예제 #2
0
    def test_add_duplicate_index_throws_exception(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))

        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        new_index = UniqueHashIndex(db.path, "another_index")
        db.add_index(new_index)

        new_index = UniqueHashIndex(db.path, "another_index")
        with pytest.raises(IndexException):
            db.add_index(new_index)
예제 #3
0
    def test_get_after_delete(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes(
            [UniqueHashIndex(db.path, "id"), CustomHashIndex(db.path, "custom")]
        )
        db.create()

        for x in range(100):
            doc = dict(test=6)
            doc.update(db.insert(doc))
            if doc["test"] > 5:
                self.counter["r"] += 1
            else:
                self.counter["l"] += 1

        counted_bef = db.count(db.all, "custom")
        elem = db.all("custom", with_doc=True, limit=1)

        doc = next(elem)["doc"]
        assert db.delete(doc) == True

        counted_aft = db.count(db.all, "custom")
        assert counted_bef - 1 == counted_aft

        from_ind = db.get("custom", 1, with_doc=True)
        assert from_ind["doc"]["_id"] != doc["_id"]

        alls = db.all("custom", with_doc=True, limit=90)
        for curr in alls:
            assert db.delete(curr["doc"]) == True

        from_ind = db.get("custom", 1, with_doc=True)
        assert from_ind["doc"] != {}
예제 #4
0
    def test_add_new_index_to_existing_db(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))

        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        new_index = UniqueHashIndex(db.path, "unique_hash_index")
        db.add_index(new_index)

        new_index = Md5Index(db.path, "md5_index")
        db.add_index(new_index)

        new_index = WithAIndex(db.path, "with_a_index")
        db.add_index(new_index)

        assert len(db.indexes) == 4
예제 #5
0
    def test_all_same_keys(self, tmpdir, inserts):

        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id"), WithAIndex(db.path, "with_a")])

        db.create()
        l = 0
        r = 0
        z = 0
        data = []
        for i in range(inserts):
            a = random.randint(0, 10)
            if a > 5:
                r += 1
            elif a == 0:
                z += 1
            else:
                l += 1
            c = dict(a=a)
            db.insert(c)
            data.append(c)

        assert l + r + z == db.count(db.all, "id")

        assert l + r == db.count(db.all, "with_a")
예제 #6
0
    def test_custom_index_2(self, tmpdir):

        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id"), WithAIndex(db.path, "with_a")])
        db.create()

        all_ins = []
        for i in range(10):
            curr = dict(something="other")
            if i % 2 == 0:
                curr["a"] = str(i)
            all_ins.append(curr)
            db.insert(curr)

        l_0 = len(list(db.all("id")))
        l_1 = len(list(db.all("with_a")))
        assert l_1 != l_0

        all_a = list(db.all("with_a", with_doc=True))
        curr_a = all_a[0]["doc"]
        del curr_a["a"]
        db.update(curr_a)
        l_2 = len(list(db.all("with_a")))
        assert l_2 + 1 == l_1

        curr_a = all_a[-1]["doc"]
        db.delete(curr_a)

        l_3 = len(list(db.all("with_a")))
        assert l_3 + 2 == l_1
예제 #7
0
    def test_compact2(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        l = []
        for i in range(10):
            if i % 2 == 0:
                c = dict(i=i, even=True)
            else:
                c = dict(i=i)
            c.update(db.insert(c))
            l.append(c)

        for i, curr in enumerate(db.all("id")):
            if i % 2:
                db.delete(curr)

        db.compact()
        db.compact()
        db.compact()
        assert len(list(db.all("id", with_doc=True))) == 5

        for curr in db.all("id"):
            db.delete(curr)

        assert len(list(db.all("id", with_doc=True))) == 0
예제 #8
0
    def test_compact(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        l = []
        for i in range(10):
            c = dict(i=i)
            db.insert(c)
            l.append(c)

        for i in range(10):
            curr = l[i]
            c = db.get("id", curr["_id"])
            c["update"] = True
            c.update(db.update(c))

        db.compact()

        for j in range(10):
            curr = l[j]
            c = db.get("id", curr["_id"])
            assert c["_id"] == curr["_id"]
            assert c["i"] == j

        db.close()
예제 #9
0
    def test_adv1(self, tmpdir, inserts):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        l = []
        for i in range(inserts):
            c = dict(i=i)
            db.insert(c)
            l.append(c)
        for j in range(inserts):
            curr = l[j]
            c = db.get("id", curr["_id"])
            assert c["_id"] == curr["_id"]
            assert c["i"] == j
        for i in range(inserts):
            curr = l[i]
            c = db.get("id", curr["_id"])
            c["update"] = True
            db.update(c)

        for j in range(inserts):
            curr = l[i]
            c = db.get("id", curr["_id"])
            assert c["update"] == True

        for j in range(inserts):
            curr = l[j]
            c = db.get("id", curr["_id"])
            assert db.delete(c) == True

        for j in range(inserts):
            with pytest.raises(RecordDeleted):
                db.get("id", l[j]["_id"])

        db.close()
예제 #10
0
    def test_removing_index_from_db_2(self, tmpdir):
        """indexes are added from strings"""

        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        path_indexes = os.path.join(db.path, "_indexes")

        def file_exists_in_indexes_dir(name):
            return [f for f in os.listdir(path_indexes) if name in f]

        file_names = (
            "tests/index_files/03md5_index.py",
            "tests/index_files/04withA_index.py",
            "tests/index_files/05custom_hash_index.py",
        )

        indexes_names = [db.add_index(open(f).read()) for f in file_names]

        for index_name in indexes_names:
            assert db.get_index_details(index_name)
            assert file_exists_in_indexes_dir(index_name)

            db.destroy_index(index_name)

            assert not file_exists_in_indexes_dir(index_name)
            with pytest.raises(IndexException):
                db.get_index_details(index_name)
예제 #11
0
    def test_update_custom_unique(self, tmpdir, inserts):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes(
            [UniqueHashIndex(db.path, "id"), CustomHashIndex(db.path, "custom")]
        )
        db.create()

        ins = []

        for x in range(inserts):
            doc = dict(test=1)
            db.insert(doc)
            ins.append(doc)
            self.counter["ins"] += 1

        assert len(ins) == db.count(db.all, "id")
        assert len(ins) == db.count(db.all, "custom")
        assert len(ins) == db.count(db.get_many, "custom", key=0, limit=inserts + 1)
        assert 0 == db.count(db.get_many, "custom", key=1, limit=inserts + 1)

        sample = random.sample(ins, inserts // 10)
        for curr in sample:
            curr["test"] = 10
            db.update(curr)
            self.counter["upd"] += 1

        assert self.counter["ins"] == db.count(db.all, "id")
        assert self.counter["ins"] == db.count(db.all, "custom")
        assert self.counter["upd"] == db.count(
            db.get_many, "custom", key=1, limit=inserts + 1
        )
        assert self.counter["ins"] - self.counter["upd"] == db.count(
            db.get_many, "custom", key=0, limit=inserts + 1
        )
예제 #12
0
    def test_delete_with_id_and_rev_only(self, tmpdir, inserts):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        ins = []
        for x in range(inserts):
            doc = dict(x=x)
            db.insert(doc)
            ins.append(doc)
            self.counter["ins"] += 1

        for i in range(inserts // 10):
            curr = ins.pop(random.randint(0, len(ins) - 1))
            d = {"_id": curr["_id"], "_rev": curr["_rev"]}
            db.delete(d)

        assert len(ins) == db.count(db.all, "id")

        for x in range(inserts):
            doc = dict(x=x)
            db.insert(doc)
            ins.append(doc)
            self.counter["ins"] += 1

        for i in range(inserts // 10):
            curr = ins.pop(random.randint(0, len(ins) - 1))
            db.delete(curr)

        assert len(ins) == db.count(db.all, "id")
예제 #13
0
    def test_wrong_id(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        with pytest.raises(IndexPreconditionsException):
            db.insert(dict(_id="1", a=1))

        with pytest.raises(IndexPreconditionsException):
            db.insert(dict(_id=1, a=1))
예제 #14
0
 def test_destroy(self, tmpdir):
     db = self._db(os.path.join(str(tmpdir), "db"))
     db.set_indexes([UniqueHashIndex(db.path, "id")])
     db.create()
     for i in range(5):
         db.insert(dict(i=i))
     db.destroy()
     db = self._db(os.path.join(str(tmpdir), "db"))
     with pytest.raises(DatabasePathException):
         db.open()
예제 #15
0
    def test_similar(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id"), Md5Index(db.path, "md5")])
        db.create()

        a = dict(a="pigmej")
        db.insert(a)
        db.get("md5", "pigmej")

        with pytest.raises(RecordNotFound):
            db.get("md5", "pigme")
예제 #16
0
    def test_double_insert(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        a_id = "54bee5c4628648b5a742379a1de89b2d"
        a1 = dict(a=1, _id=a_id)
        db.insert(a1)
        a2 = dict(a=2, _id=a_id)
        with pytest.raises(IndexException):
            db.insert(a2)
예제 #17
0
    def test_insert_with_id(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        # db.set_indexes([UniqueHashIndex(db.path, 'id')])
        # db.initialize()
        db.add_index(UniqueHashIndex(db.path, "id"), False)
        db.create()

        doc = dict(a=1, _id=random_hex_32())
        ins = db.insert(doc)
        assert ins["_id"] == doc["_id"]
        db.close()
예제 #18
0
    def test_create_with_path(self, tmpdir):
        p = os.path.join(str(tmpdir), "db")

        db = self._db(None)
        db.create(p, with_id_index=False)

        ind = UniqueHashIndex(p, "id")
        db.add_index(ind)

        for x in range(10):
            db.insert(dict(x=x))

        assert db.count(db.all, "id") == 10
예제 #19
0
    def test_auto_add_id_index_without_initialize(self, tmpdir):
        p = os.path.join(str(tmpdir), "db")

        db = self._db(None)
        db.create(p)

        ind = UniqueHashIndex(p, "id")
        with pytest.raises(IndexException):
            db.add_index(ind)

        for x in range(10):
            db.insert(dict(x=x))

        assert db.count(db.all, "id") == 10
예제 #20
0
    def test_create_index_duplicate_from_string(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        path_indexes = os.path.join(db.path, "_indexes")

        file_name = "tests/index_files/04withA_index.py"

        db.add_index(open(file_name).read())
        l = len(db.indexes)
        with pytest.raises(IndexException):
            db.add_index(open(file_name).read())

        assert l == len(db.indexes)
예제 #21
0
    def test_create_index_duplicate_from_object(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        hash_index = HashIndex(db.path, "my_index")
        db.add_index(hash_index)

        l = len(db.indexes)
        hash_index = HashIndex(db.path, "my_index")
        with pytest.raises(IndexException):
            db.add_index(hash_index)

        assert l == len(db.indexes)
예제 #22
0
    def test_offset_in_functions(self, tmpdir, inserts):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes(
            [UniqueHashIndex(db.path, "id"), CustomHashIndex(db.path, "custom")]
        )
        db.create()
        offset = inserts // 10 or 1
        real_inserts = inserts if inserts < 1000 else 1000
        for x in range(real_inserts):
            db.insert(dict(test=x))
        assert real_inserts - offset == db.count(db.all, "id", offset=offset)
        assert real_inserts - offset == db.count(db.all, "custom", offset=offset)
        assert 1 == db.count(db.get_many, "custom", 1, limit=1, offset=offset)

        db.close()
예제 #23
0
    def test_update_index(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        hash_index = HashIndex(db.path, "my_index")
        db.add_index(hash_index)
        assert db.get_index_details(hash_index.name)

        db.destroy_index(hash_index.name)
        with pytest.raises(IndexNotFoundException):
            db.get_index_details(hash_index.name)

        new_index = Md5Index(db.path, "my_index")
        db.add_index(new_index)
        assert db.get_index_details(new_index.name)
예제 #24
0
    def test_all(self, tmpdir, inserts):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        l = []
        for i in range(inserts):
            c = dict(i=i)
            db.insert(c)
            l.append(c)

        assert db.count(db.all, "id") == inserts

        to_delete = random.randint(0, inserts - 1)
        db.delete(l[to_delete])

        assert db.count(db.all, "id") == inserts - 1
예제 #25
0
    def test_open_with_path(self, tmpdir):
        p = os.path.join(str(tmpdir), "db")

        db = self._db(p)
        ind = UniqueHashIndex(p, "id")
        db.set_indexes([ind])
        db.create(with_id_index=False)

        for x in range(10):
            db.insert(dict(x=x))

        db.close()

        db = self._db(p)
        db.open(p)

        assert db.count(db.all, "id") == 10
예제 #26
0
 def test_open_close(self, tmpdir):
     db = self._db(os.path.join(str(tmpdir), "db"))
     db.set_indexes([UniqueHashIndex(db.path, "id")])
     db.create()
     l = []
     for i in range(5):
         c = dict(i=i)
         db.insert(c)
         l.append(c)
     db.close()
     db.open()
     db.close()
     db2 = self._db(os.path.join(str(tmpdir), "db"))
     # db2.set_indexes([UniqueHashIndex(db.path, 'id')])
     db2.open()
     for j in range(5):
         assert l[j] == db2.get("id", l[j]["_id"])
     db2.close()
예제 #27
0
    def test_adding_index_creates_dot_py_file(self, tmpdir):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()

        path_indexes = os.path.join(db.path, "_indexes")

        before = set(os.listdir(path_indexes))

        new_index = Md5Index(db.path, "md5_index")
        db.add_index(new_index)

        after = set(os.listdir(path_indexes))

        added_file = tuple(after - before)[0]

        assert len(after) == len(before) + 1
        assert new_index.name + ".py" in added_file
예제 #28
0
    def test_create_path_delayed2(self, tmpdir):
        p = os.path.join(str(tmpdir), "db")

        db = self._db(None)
        db.initialize(p)
        db.create(with_id_index=False)

        ind = UniqueHashIndex(p, "id")
        db.add_index(ind)

        for x in range(10):
            db.insert(dict(x=x))

        db.close()

        db = self._db(p)
        db.open(p)

        assert db.count(db.all, "id") == 10
예제 #29
0
    def test_update_custom_same_key_new_value(self, tmpdir, inserts):
        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes(
            [UniqueHashIndex(db.path, "id"), CustomHashIndex(db.path, "custom")]
        )
        db.create()

        inserted = []
        for x in range(inserts):
            inserted.append(db.insert(dict(test=x)))
            inserted[-1]["test"] = x
        for el in inserted[::20]:
            for i in range(4):
                curr = db.get("id", el["_id"], with_storage=True)
                assert el["test"] == curr["test"]
                el["test"] += random.randint(1, 3)
                db.update(el)
        assert len(inserted) == db.count(db.all, "custom")

        db.close()
예제 #30
0
    def test_add_new_index_from_string(self, tmpdir):

        db = self._db(os.path.join(str(tmpdir), "db"))
        db.set_indexes([UniqueHashIndex(db.path, "id")])
        db.create()
        file_names = (
            "tests/index_files/03md5_index.py",
            "tests/index_files/04withA_index.py",
            "tests/index_files/05custom_hash_index.py",
        )

        indexes_names = [db.add_index(open(f).read()) for f in file_names]

        assert len(db.indexes) == len(file_names) + 1  # 'id' + from files

        for y in range(100):
            db.insert(dict(a="blah", test=y, name=str(y), y=y))

        for index_name in indexes_names:
            assert db.count(db.all, index_name) == 100