zlmdb 25.10.1__cp311-cp311-macosx_10_9_universal2.whl

zlmdb/tests/lmdb/getmulti_test.py

@@ -0,0 +1,92 @@
+from __future__ import absolute_import
+from __future__ import with_statement
+import unittest
+
+from . import testlib
+import struct
+from .testlib import KEYSFIXED, ITEMS_MULTI_FIXEDKEY
+from .testlib import putBigDataMultiFixed
+
+
+class GetMultiTestBase(unittest.TestCase):
+    def tearDown(self):
+        testlib.cleanup()
+
+    def setUp(self, dupsort=None, dupfixed=None):
+        self.db_key = "testdb".encode("utf-8")
+        self.path, self.env = testlib.temp_env(max_dbs=1)
+        self.txn = self.env.begin(write=True)
+        self.db = self.env.open_db(
+            key=self.db_key, txn=self.txn, dupsort=dupsort, dupfixed=dupfixed
+        )
+        putBigDataMultiFixed(self.txn, db=self.db)
+        self.c = self.txn.cursor(db=self.db)
+
+    def matchList(self, ls_a, ls_b):
+        return (not (ls_a or ls_b)) or (
+            ls_a and ls_b and all(map(lambda x, y: x == y, ls_a, ls_b))
+        )
+
+
+class GetMultiTestNoDupsortNoDupfixed(GetMultiTestBase):
+    ITEMS2_MULTI_NODUP = ITEMS_MULTI_FIXEDKEY[1::2]
+
+    def setUp(self, dupsort=False, dupfixed=False):
+        super(GetMultiTestNoDupsortNoDupfixed, self).setUp(
+            dupsort=dupsort, dupfixed=dupfixed
+        )
+
+    def testGetMulti(self):
+        test_list = self.c.getmulti(KEYSFIXED)
+        self.assertEqual(self.matchList(test_list, self.ITEMS2_MULTI_NODUP), True)
+
+
+class GetMultiTestDupsortNoDupfixed(GetMultiTestBase):
+    def setUp(self, dupsort=True, dupfixed=False):
+        super(GetMultiTestDupsortNoDupfixed, self).setUp(
+            dupsort=dupsort, dupfixed=dupfixed
+        )
+
+    def testGetMulti(self):
+        test_list = self.c.getmulti(KEYSFIXED, dupdata=True)
+        self.assertEqual(self.matchList(test_list, ITEMS_MULTI_FIXEDKEY), True)
+
+
+class GetMultiTestDupsortDupfixed(GetMultiTestBase):
+    def setUp(self, dupsort=True, dupfixed=True):
+        super(GetMultiTestDupsortDupfixed, self).setUp(
+            dupsort=dupsort, dupfixed=dupfixed
+        )
+
+    def testGetMulti(self):
+        test_list = self.c.getmulti(KEYSFIXED, dupdata=True, dupfixed_bytes=1)
+        self.assertEqual(self.matchList(test_list, ITEMS_MULTI_FIXEDKEY), True)
+
+
+class GetMultiTestDupsortDupfixedKeyfixed(GetMultiTestBase):
+    def setUp(self, dupsort=True, dupfixed=True):
+        super(GetMultiTestDupsortDupfixedKeyfixed, self).setUp(
+            dupsort=dupsort, dupfixed=dupfixed
+        )
+
+    def testGetMulti(self):
+        val_bytes = 1
+        arr = bytearray(
+            self.c.getmulti(
+                KEYSFIXED, dupdata=True, dupfixed_bytes=val_bytes, keyfixed=True
+            )
+        )
+        asserts = []
+        for i, kv in enumerate(ITEMS_MULTI_FIXEDKEY):
+            key, val = kv
+            asserts.extend(
+                (
+                    struct.pack("b", arr[i * 2]) == key,
+                    struct.pack("b", arr[i * 2 + 1]) == val,
+                )
+            )
+        self.assertEqual(all(asserts), True)
+
+
+if __name__ == "__main__":
+    unittest.main()

zlmdb/tests/lmdb/iteration_test.py

@@ -0,0 +1,258 @@
+#! /usr/bin/env python
+#
+# Copyright 2013 The py-lmdb authors, all rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted only as authorized by the OpenLDAP
+# Public License.
+#
+# A copy of this license is available in the file LICENSE in the
+# top-level directory of the distribution or, alternatively, at
+# <http://www.OpenLDAP.org/license.html>.
+#
+# OpenLDAP is a registered trademark of the OpenLDAP Foundation.
+#
+# Individual files and/or contributed packages may be copyright by
+# other parties and/or subject to additional restrictions.
+#
+# This work also contains materials derived from public sources.
+#
+# Additional information about OpenLDAP can be obtained at
+# <http://www.openldap.org/>.
+#
+
+# test delete(dupdata)
+
+from __future__ import absolute_import
+from __future__ import with_statement
+import unittest
+
+from . import testlib
+from .testlib import B
+from .testlib import BT
+from .testlib import KEYS, ITEMS, KEYS2, ITEMS2
+from .testlib import putData, putBigData
+
+
+class IterationTestBase(unittest.TestCase):
+    def tearDown(self):
+        testlib.cleanup()
+
+    def setUp(self):
+        self.path, self.env = testlib.temp_env()  # creates 10 databases
+        self.txn = self.env.begin(write=True)
+        putData(self.txn)
+        self.c = self.txn.cursor()
+        self.empty_entry = (B(""), B(""))
+
+    def matchList(self, ls_a, ls_b):
+        return all(map(lambda x, y: x == y, ls_a, ls_b))
+
+
+class IterationTestBase2(unittest.TestCase):
+    """This puts more data than its predecessor"""
+
+    def tearDown(self):
+        testlib.cleanup()
+
+    def setUp(self):
+        self.path, self.env = testlib.temp_env()  # creates 10 databases
+        self.txn = self.env.begin(write=True)
+        putBigData(self.txn)  # HERE!
+        self.c = self.txn.cursor()
+        self.empty_entry = ("", "")
+
+    def matchList(self, ls_a, ls_b):
+        return all(map(lambda x, y: x == y, ls_a, ls_b))
+
+
+class IterationTest(IterationTestBase):
+    def testFromStart(self):
+        # From start
+        self.c.first()
+        self.assertEqual(self.c.key(), KEYS[0])  # start of db
+        test_list = [i for i in iter(self.c)]
+        self.assertEqual(self.matchList(test_list, ITEMS), True)
+        self.assertEqual(self.c.item(), self.empty_entry)  # end of db
+
+    def testFromStartWithIternext(self):
+        # From start with iternext
+        self.c.first()
+        self.assertEqual(self.c.key(), KEYS[0])  # start of db
+        test_list = [i for i in self.c.iternext()]
+        # remaining elements in db
+        self.assertEqual(self.matchList(test_list, ITEMS), True)
+        self.assertEqual(self.c.item(), self.empty_entry)  # end of db
+
+    def testFromStartWithNext(self):
+        # From start with next
+        self.c.first()
+        self.assertEqual(self.c.key(), KEYS[0])  # start of db
+        test_list = []
+        while 1:
+            test_list.append(self.c.item())
+            if not self.c.next():
+                break
+        self.assertEqual(self.matchList(test_list, ITEMS), True)
+
+    def testFromExistentKeySetKey(self):
+        self.c.first()
+        self.c.set_key(KEYS[1])
+        self.assertEqual(self.c.key(), KEYS[1])
+        test_list = [i for i in self.c.iternext()]
+        self.assertEqual(self.matchList(test_list, ITEMS[1:]), True)
+
+    def testFromExistentKeySetRange(self):
+        self.c.first()
+        self.c.set_range(KEYS[1])
+        self.assertEqual(self.c.key(), KEYS[1])
+        test_list = [i for i in self.c.iternext()]
+        self.assertEqual(self.matchList(test_list, ITEMS[1:]), True)
+
+    def testFromNonExistentKeySetRange(self):
+        self.c.first()
+        self.c.set_range(B("c"))
+        self.assertEqual(self.c.key(), B("d"))
+        test_list = [i for i in self.c.iternext()]
+        test_items = [i for i in ITEMS if i[0] > B("c")]
+        self.assertEqual(self.matchList(test_list, test_items), True)
+
+    def testFromLastKey(self):
+        self.c.last()
+        self.assertEqual(self.c.key(), KEYS[-1])
+        test_list = [i for i in self.c.iternext()]
+        self.assertEqual(self.matchList(test_list, ITEMS[-1:]), True)
+
+    def testFromNonExistentKeyPastEnd(self):
+        self.c.last()
+        self.assertEqual(self.c.key(), KEYS[-1])
+        # next() fails, leaving iterator in an unpositioned state.
+        self.c.next()
+        self.assertEqual(self.c.item(), self.empty_entry)
+        # iternext() from an unpositioned state proceeds from start of DB.
+        test_list = list(self.c.iternext())
+        self.assertEqual(test_list, ITEMS)
+
+
+class ReverseIterationTest(IterationTestBase):
+    def testFromStartRev(self):
+        # From start
+        self.c.first()
+        self.assertEqual(self.c.key(), KEYS[0])  # start of db
+        test_list = [i for i in self.c.iterprev()]
+        self.assertEqual(self.matchList(test_list, ITEMS[:1][::-1]), True)
+        self.assertEqual(self.c.item(), self.empty_entry)  # very start of db
+
+    def testFromExistentKeySetKeyRev(self):
+        self.c.first()
+        self.c.set_key(KEYS[2])
+        self.assertEqual(self.c.key(), KEYS[2])
+        test_list = [i for i in self.c.iterprev()]
+        self.assertEqual(self.matchList(test_list, ITEMS[:3][::-1]), True)
+
+    def testFromExistentKeySetRangeRev(self):
+        self.c.first()
+        self.c.set_range(KEYS[2])
+        self.assertEqual(self.c.key(), KEYS[2])
+        test_list = [i for i in self.c.iterprev()]
+        self.assertEqual(self.matchList(test_list, ITEMS[:3][::-1]), True)
+
+    def testFromNonExistentKeySetRangeRev(self):
+        self.c.first()
+        self.c.set_range(B("c"))
+        self.assertEqual(self.c.key(), B("d"))
+        test_list = [i for i in self.c.iterprev()]
+        test_items = [i for i in ITEMS if i[0] <= B("d")]
+        test_items = test_items[::-1]
+        self.assertEqual(self.matchList(test_list, test_items), True)
+
+    def testFromLastKeyRev(self):
+        self.c.last()
+        self.assertEqual(self.c.key(), KEYS[-1])
+        test_list = [i for i in self.c.iterprev()]
+        self.assertEqual(self.matchList(test_list, ITEMS[::-1]), True)
+
+    def testFromLastKeyWithPrevRev(self):
+        self.c.last()
+        self.assertEqual(self.c.key(), KEYS[-1])  # end of db
+        test_list = []
+        while 1:
+            test_list.append(self.c.item())
+            if not self.c.prev():
+                break
+        self.assertEqual(self.matchList(test_list, ITEMS[::-1]), True)
+
+    def testFromNonExistentKeyPastEndRev(self):
+        self.c.first()
+        self.assertEqual(self.c.key(), KEYS[0])
+        # prev() fails, leaving iterator in an unpositioned state.
+        self.c.prev()
+        self.assertEqual(self.c.item(), self.empty_entry)
+        # iterprev() from an unpositioned state proceeds from end of DB.
+        test_list = list(self.c.iterprev())
+        self.assertEqual(test_list, ITEMS[::-1])
+
+
+class IterationTestWithDupsBase(unittest.TestCase):
+    def tearDown(self):
+        testlib.cleanup()
+
+    def setUp(self):
+        self.path, self.env = testlib.temp_env()
+        db = self.env.open_db(B("db1"), dupsort=True)
+        self.txn = self.env.begin(db, write=True)
+        for _ in range(2):
+            putData(self.txn)
+        self.c = self.txn.cursor()
+        self.empty_entry = ("", "")
+
+    def matchList(self, ls_a, ls_b):
+        return all(map(lambda x, y: x == y, ls_a, ls_b))
+
+
+class IterationTestWithDups(IterationTestWithDupsBase):
+    pass
+
+
+class SeekIterationTest(IterationTestBase2):
+    def testForwardIterationSeek(self):
+        self.c.first()
+        test_list = []
+        for i in self.c.iternext():
+            test_list.append(i)
+            # skips d and e
+            if self.c.key() == B("baa"):
+                self.c.set_key(B("e"))
+        test_item = [i for i in ITEMS2 if i[0] not in (B("d"), B("e"))]
+        self.assertEqual(test_list, test_item)
+
+    def testPutDuringIteration(self):
+        self.c.first()
+        test_list = []
+        c = self.txn.cursor()
+        for i in c.iternext():
+            test_list.append(i)
+            # adds 'i' upon seeing 'e'
+            if c.key() == B("e"):
+                self.c.put(B("i"), B(""))
+        test_item = ITEMS2 + [(B("i"), B(""))]
+        self.assertEqual(test_list, test_item)
+
+    def testDeleteDuringIteration(self):
+        self.c.first()
+        test_list = []
+        for i in self.c.iternext():
+            # deletes 'e' upon seeing it
+            if self.c.key() == B("e"):
+                # Causes 'e' to be deleted, and advances cursor to next
+                # element.
+                self.c.delete()
+                i = self.c.item()
+            test_list.append(i)
+
+        test_item = [i for i in ITEMS2 if i[0] != B("e")]
+        self.assertEqual(test_list, test_item)
+
+
+if __name__ == "__main__":
+    unittest.main()

zlmdb/tests/lmdb/package_test.py

@@ -0,0 +1,70 @@
+#
+# Copyright 2013 The py-lmdb authors, all rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted only as authorized by the OpenLDAP
+# Public License.
+#
+# A copy of this license is available in the file LICENSE in the
+# top-level directory of the distribution or, alternatively, at
+# <http://www.OpenLDAP.org/license.html>.
+#
+# OpenLDAP is a registered trademark of the OpenLDAP Foundation.
+#
+# Individual files and/or contributed packages may be copyright by
+# other parties and/or subject to additional restrictions.
+#
+# This work also contains materials derived from public sources.
+#
+# Additional information about OpenLDAP can be obtained at
+# <http://www.openldap.org/>.
+#
+
+from __future__ import absolute_import
+import unittest
+
+import zlmdb.lmdb as lmdb
+
+
+class PackageExportsTest(unittest.TestCase):
+    """
+    Ensure the list of exported names matches a predefined list. Designed to
+    ensure future interface changes to cffi.py and cpython.c don't break
+    consistency of "from lmdb import *".
+    """
+
+    def test_exports(self):
+        assert sorted(lmdb.__all__) == [
+            "BadDbiError",
+            "BadRslotError",
+            "BadTxnError",
+            "BadValsizeError",
+            "CorruptedError",
+            "Cursor",
+            "CursorFullError",
+            "DbsFullError",
+            "DiskError",
+            "Environment",
+            "Error",
+            "IncompatibleError",
+            "InvalidError",
+            "InvalidParameterError",
+            "KeyExistsError",
+            "LockError",
+            "MapFullError",
+            "MapResizedError",
+            "MemoryError",
+            "NotFoundError",
+            "PageFullError",
+            "PageNotFoundError",
+            "PanicError",
+            "ReadersFullError",
+            "ReadonlyError",
+            "TlsFullError",
+            "Transaction",
+            "TxnFullError",
+            "VersionMismatchError",
+            "_Database",
+            "enable_drop_gil",
+            "version",
+        ]

zlmdb/tests/lmdb/test_lmdb.py

@@ -0,0 +1,188 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+import random
+import os
+import zlmdb.lmdb as lmdb
+import struct
+import platform
+
+import pytest
+
+try:
+    from tempfile import TemporaryDirectory
+except ImportError:
+    from backports.tempfile import TemporaryDirectory  # type:ignore
+
+
+def test_lmdb_create():
+    """
+    Test creation of LMDB database.
+    """
+    with TemporaryDirectory() as dbpath:
+        env = lmdb.open(dbpath)
+
+        with env.begin() as txn:
+            assert txn.id() == 0
+
+
+def test_lmdb_insert_empty_key_raises():
+    """
+    Test that LMDB raises on inserting record with empty (bytes) key.
+    """
+    with TemporaryDirectory() as dbpath:
+        env = lmdb.open(dbpath)
+
+        with env.begin(write=True) as txn:
+            key = b""
+            value = random.randint(0, 2**32 - 1)
+            data = struct.pack("<L", value)
+            with pytest.raises(lmdb.BadValsizeError):
+                txn.put(key, data)
+
+
+@pytest.mark.skipif(
+    platform.python_implementation() == "PyPy",
+    reason="behavioral difference on pypy (does not raise, but runs into traceback)",
+)
+def test_lmdb_insert_null_key_raises():
+    """
+    Test that LMDB raises on inserting record with NULL key.
+    """
+    with TemporaryDirectory() as dbpath:
+        env = lmdb.open(dbpath)
+
+        with env.begin(write=True) as txn:
+            key = None
+            value = random.randint(0, 2**32 - 1)
+            data = struct.pack("<L", value)
+            with pytest.raises(lmdb.BadValsizeError):
+                txn.put(key, data)
+
+
+def test_lmdb_insert_empty_value_ok():
+    """
+    Test that LMDB allows to insert record with empty (bytes) value.
+    """
+    with TemporaryDirectory() as dbpath:
+        env = lmdb.open(dbpath)
+
+        with env.begin(write=True) as txn:
+            key = b"foo"
+            data = b""
+            txn.put(key, data)
+
+        with env.begin() as txn:
+            cursor = txn.cursor()
+            assert cursor.first()
+            assert cursor.value() == b""
+            total = 1
+            while cursor.next():
+                total += 1
+            assert total == 1
+
+
+@pytest.mark.skipif(
+    platform.python_implementation() == "PyPy",
+    reason="behavioral difference on pypy (does not raise, but runs into traceback)",
+)
+def test_lmdb_insert_null_value_ok():
+    """
+    Test that LMDB allows to insert record with NULL value and
+    returns b'' value when retrieving the record (!).
+    """
+    with TemporaryDirectory() as dbpath:
+        env = lmdb.open(dbpath)
+
+        with env.begin(write=True) as txn:
+            key = b"foo"
+            data = None
+            txn.put(key, data)
+
+        with env.begin() as txn:
+            cursor = txn.cursor()
+            assert cursor.first()
+            assert cursor.value() == b""
+            total = 1
+            while cursor.next():
+                total += 1
+            assert total == 1
+
+
+def test_lmdb_insert():
+    """
+    Test inserting and retrieving a couple of records.
+    """
+    with TemporaryDirectory() as dbpath:
+        n = 100
+        total1 = 0
+        env = lmdb.open(dbpath)
+
+        with env.begin(write=True) as txn:
+            for i in range(n):
+                key = "key-{}".format(i).encode("utf8")
+                value = random.randint(0, 2**32 - 1)
+                total1 += value
+                data = struct.pack("<L", value)
+                txn.put(key, data)
+
+        with env.begin() as txn:
+            cursor = txn.cursor()
+            assert cursor.first()
+
+            count = 1
+            total2 = struct.unpack("<L", cursor.value())[0]
+
+            while cursor.next():
+                count += 1
+                total2 += struct.unpack("<L", cursor.value())[0]
+
+            assert count == n
+            assert total1 == total2
+
+
+def test_lmdb_delete():
+    """
+    Test inserting and deleting again a couple of records.
+    """
+    with TemporaryDirectory() as dbpath:
+        n = 100
+        env = lmdb.open(dbpath)
+
+        with env.begin(write=True) as txn:
+            for i in range(n):
+                key = "key-{}".format(i).encode("utf8")
+                value = os.urandom(16)
+                txn.put(key, value)
+
+        with env.begin(write=True) as txn:
+            for i in range(n):
+                key = "key-{}".format(i).encode("utf8")
+                assert txn.delete(key)
+
+        with env.begin() as txn:
+            cursor = txn.cursor()
+            assert not cursor.first()