real-ladybug 0.0.1.dev1__cp311-cp311-win_amd64.whl

real_ladybug-source/tools/python_api/test/test_torch_geometric_remote_backend.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+TINY_SNB_KNOWS_GROUND_TRUTH = {
+    0: [2, 3, 5],
+    2: [0, 3, 5],
+    3: [0, 2, 5],
+    5: [0, 2, 3],
+    7: [8, 9],
+}
+
+TINY_SNB_PERSON_IDS_GROUND_TRUTH = [0, 2, 3, 5, 7, 8, 9, 10]
+
+# TODO: FIX-ME. Re-enable the tests when StorageDriver is fixed.
+# def test_remote_backend_graph_store(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, gs = db.get_torch_geometric_remote_backend()
+#     edge_idx = gs.get_edge_index(("person", "knows", "person"), layout="coo", is_sorted=False)
+#     assert edge_idx.shape == torch.Size([2, 14])
+#     for i in range(14):
+#         src = edge_idx[0, i].item()
+#         src_id = fs["person", "ID", src].item()
+#         dst = edge_idx[1, i].item()
+#         dst_id = fs["person", "ID", dst].item()
+#         assert src_id in TINY_SNB_KNOWS_GROUND_TRUTH
+#         assert dst_id in TINY_SNB_KNOWS_GROUND_TRUTH[src_id]
+#
+#
+# def test_remote_backend_feature_store_idx(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, _ = db.get_torch_geometric_remote_backend()
+#     id_set = set(TINY_SNB_PERSON_IDS_GROUND_TRUTH)
+#     index_to_id = {}
+#     # Individual index access
+#     for i in range(len(id_set)):
+#         assert fs["person", "ID", i].item() in id_set
+#         id_set.remove(fs["person", "ID", i].item())
+#         index_to_id[i] = fs["person", "ID", i].item()
+#
+#     # Range index access
+#     for i in range(len(index_to_id) - 3):
+#         ids = fs["person", "ID", i : i + 3]
+#         for j in range(3):
+#             assert ids[j].item() == index_to_id[i + j]
+#
+#     # Multiple index access
+#     indicies = random.sample(range(len(index_to_id)), 4)
+#     ids = fs["person", "ID", indicies]
+#     for i in range(4):
+#         idx = indicies[i]
+#         assert ids[i].item() == index_to_id[idx]
+#
+#     # No index access
+#     ids = fs["person", "ID", None]
+#     assert len(ids) == len(index_to_id)
+#     for i in range(len(ids)):
+#         assert ids[i].item() == index_to_id[i]
+#
+#
+# def test_remote_backend_feature_store_types_1d(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, _ = db.get_torch_geometric_remote_backend()
+#     for i in range(3):
+#         assert fs["npyoned", "i64", i].item() - i == 1
+#         assert fs["npyoned", "i32", i].item() - i == 1
+#         assert fs["npyoned", "i16", i].item() - i == 1
+#         assert fs["npyoned", "f64", i].item() - i - 1 < 1e-6
+#         assert fs["npyoned", "f32", i].item() - i - 1 < 1e-6
+#
+#
+# def test_remote_backend_feature_store_types_2d(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, _ = db.get_torch_geometric_remote_backend()
+#     for i in range(3):
+#         i64 = fs["npytwod", "i64", i]
+#         assert i64.shape == torch.Size([1, 3])
+#         base_number = (i * 3) + 1
+#         for j in range(3):
+#             assert i64[0, j].item() == base_number + j
+#         i32 = fs["npytwod", "i32", i]
+#         assert i32.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert i32[0, j].item() == base_number + j
+#         i16 = fs["npytwod", "i16", i]
+#         assert i16.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert i16[0, j].item() == base_number + j
+#         f64 = fs["npytwod", "f64", i]
+#         assert f64.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert f64[0, j].item() - (base_number + j) - 1 < 1e-6
+#         f32 = fs["npytwod", "f32", i]
+#         assert f32.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert f32[0, j].item() - (base_number + j) - 1 < 1e-6
+#
+#
+# def test_remote_backend_20k(conn_db_readwrite: ConnDB) -> None:
+#     _, db = conn_db_readwrite
+#     conn = lb.Connection(db, num_threads=1)
+#     conn.execute("CREATE NODE TABLE npy20k (id INT64,f32 FLOAT[10],PRIMARY KEY(id));")
+#     conn.execute(
+#         f"""
+#         COPY npy20k FROM (
+#           "{LBUG_ROOT}/dataset/npy-20k/id_int64.npy",
+#           "{LBUG_ROOT}/dataset/npy-20k/two_dim_float.npy") BY COLUMN;
+#         """
+#     )
+#     del conn
+#     fs, _ = db.get_torch_geometric_remote_backend(8)
+#     for i in range(20000):
+#         assert fs["npy20k", "id", i].item() == i

real_ladybug-source/tools/python_api/test/test_udf.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta  # noqa: TC003
+
+import pandas as pd
+import pyarrow as pa
+import pytest
+from real_ladybug import Type
+from type_aliases import ConnDB
+
+
+def udf_helper(conn, functionName, params, expectedResult):
+    plist = ", ".join(f"${i + 1}" for i in range(len(params)))
+    queryString = f"RETURN {functionName}({plist})"
+    result = conn.execute(queryString, {str(i + 1): params[i] for i in range(len(params))})
+    assert result.get_next()[0] == expectedResult
+
+
+def udf_predicate_test(conn, functionName, params, expectedResult):
+    conn.execute("CREATE node table tbl (id INT64, primary key (id))")
+    for i in params:
+        conn.execute("CREATE (t:tbl {id: $num})", {"num": i})
+    result = conn.execute(f"MATCH (t:tbl) WHERE {functionName}(t.id % 8) RETURN COUNT(*)")
+    assert result.get_next()[0] == expectedResult
+
+
+def test_udf(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+
+    def add5int(x: int) -> int:
+        print(x)
+        return x + 5
+
+    add5IntArgs = ["add5int", add5int]
+
+    def add5float(x: float) -> float:
+        return x + 5.0
+
+    add5FloatArgs = ["add5float", add5float]
+
+    def intToString(x: int) -> str:
+        return str(x)
+
+    intToStringArgs = ["intToString", intToString]
+
+    def sumOf7(a, b, c, d, e, f, g) -> int:
+        return a + b + c + d + e + f + g
+
+    sumOf7Args = ["sumOf7", sumOf7, [Type.INT64] * 7]
+
+    def dateToDatetime(a: date) -> datetime:
+        return datetime(a.year, a.month, a.day)
+
+    dateToDatetimeArgs = ["dateToDatetime", dateToDatetime]
+
+    def datetimeToDate(a: datetime) -> date:
+        return a.date()
+
+    datetimeToDateArgs = ["datetimeToDate", datetimeToDate, [Type.TIMESTAMP], Type.DATE]
+
+    def addToDate(a: datetime, b: timedelta) -> datetime:
+        return a + b
+
+    addToDateArgs = ["addToDate", addToDate, [Type.TIMESTAMP, Type.INTERVAL], Type.TIMESTAMP]
+
+    def concatThreeLists(a: list[int], b: list[int], c: list[int]) -> list[int]:
+        return a + b + c
+
+    concatThreeListsArgs = ["concatThreeLists", concatThreeLists]
+
+    def mergeMaps(a, b):
+        return a | b
+
+    mergeMapsArgs = ["mergeMaps", mergeMaps, ["MAP(STRING, INT64)"] * 2, "MAP(STRING, INT64)"]
+
+    def mergeMaps2(a: dict[str, int], b: dict[str, int]) -> dict[str, int]:
+        return a | b
+
+    mergeMaps2Args = ["mergeMaps2", mergeMaps2]
+
+    def selectIfSeven(a: int) -> bool:
+        return a == 7
+
+    selectIfSevenArgs = ["selectIfSeven", selectIfSeven]
+
+    def distancePrimer(pointA, pointB):
+        return {"x": (pointA["x"] - pointB["x"]) ** 2, "y": (pointA["y"] - pointB["y"]) ** 2}
+
+    distanceArgs = [
+        "UDFDist",
+        distancePrimer,
+        ["STRUCT(x INT32, y INT32)", "STRUCT(x INT32, y INT32)"],
+        "STRUCT(x INT32, y INT32)",
+    ]
+
+    conn.create_function(*add5IntArgs)
+    conn.create_function(*add5FloatArgs)
+    conn.create_function(*intToStringArgs)
+    conn.create_function(*sumOf7Args)
+    conn.create_function(*dateToDatetimeArgs)
+    conn.create_function(*datetimeToDateArgs)
+    conn.create_function(*addToDateArgs)
+    conn.create_function(*concatThreeListsArgs)
+    conn.create_function(*mergeMapsArgs)
+    conn.create_function(*mergeMaps2Args)
+    conn.create_function(*selectIfSevenArgs)
+    conn.create_function(*distanceArgs)
+
+    udf_helper(conn, "add5int", [10], 15)
+    udf_helper(conn, "add5int", [9], 14)
+    udf_helper(conn, "add5int", [1283], 1288)
+    udf_helper(conn, "add5float", [2.2], 7.2)
+    udf_helper(conn, "intToString", [123], "123")
+    udf_helper(conn, "sumOf7", [1, 2, 3, 4, 5, 6, 7], sum(range(8)))
+    udf_helper(conn, "dateToDatetime", [date(2024, 4, 25)], datetime(2024, 4, 25))
+    udf_helper(conn, "datetimeToDate", [datetime(2024, 4, 25, 15, 39, 20)], date(2024, 4, 25))
+    udf_helper(
+        conn,
+        "addToDate",
+        [datetime(2024, 4, 25, 15, 39, 20), datetime(2025, 5, 26) - datetime(2024, 4, 25, 15, 39, 20)],
+        datetime(2025, 5, 26),
+    )
+    udf_helper(conn, "concatThreeLists", [[1, 2, 3], [4, 5, 6], [-1, -2, -3]], [1, 2, 3, 4, 5, 6, -1, -2, -3])
+    udf_helper(
+        conn,
+        "mergeMaps",
+        [{"key": ["a", "b", "c"], "value": [1, 2, 3]}, {"key": ["x", "y", "z"], "value": [100, 200, 300]}],
+        {"a": 1, "b": 2, "c": 3, "x": 100, "y": 200, "z": 300},
+    )
+    udf_helper(
+        conn,
+        "mergeMaps2",
+        [{"key": ["a", "b", "c"], "value": [1, 2, 3]}, {"key": ["x", "y", "z"], "value": [100, 200, 300]}],
+        {"a": 1, "b": 2, "c": 3, "x": 100, "y": 200, "z": 300},
+    )
+    udf_predicate_test(conn, "selectIfSeven", range(65), 8)
+    udf_helper(conn, "UDFDist", [{"x": 1, "y": 10}, {"x": 4, "y": 6}], {"x": 9, "y": 16})
+
+    df = pd.DataFrame({"col": list(range(5000))})
+    result = conn.execute("LOAD FROM df RETURN add5int(col) as ans").get_as_df()
+    assert list(result["ans"]) == list(map(add5int, range(5000)))
+
+    df = pd.DataFrame({
+        "col1": pd.Series(
+            [{"a": 1, "b": 2, "c": 3}, {"l": 1, "m": 2, "n": 3}], dtype=pd.ArrowDtype(pa.map_(pa.string(), pa.int64()))
+        ),
+        "col2": pd.Series(
+            [{"x": -1, "y": -2, "z": -3}, {"one": -1, "two": -2, "three": -3}],
+            dtype=pd.ArrowDtype(pa.map_(pa.string(), pa.int64())),
+        ),
+    })
+    # result = conn.execute("LOAD FROM df RETURN mergeMaps(col1, col2) as ans").get_as_arrow()
+    # assert result["ans"].to_pylist() == [
+    #     [("a", 1), ("b", 2), ("c", 3), ("x", -1), ("y", -2), ("z", -3)],
+    #     [("l", 1), ("m", 2), ("n", 3), ("one", -1), ("two", -2), ("three", -3)],
+    # ]
+
+
+def test_udf_null(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+
+    def get5(x: int) -> int:
+        return 5
+
+    conn.create_function("get5", get5)
+    assert conn.execute("RETURN get5(NULL)").get_next() == [None]
+
+    conn.remove_function("get5")
+    conn.create_function("get5", get5, default_null_handling=False)
+    assert conn.execute("RETURN get5(NULL)").get_next() == [5]
+
+
+def test_udf_except(conn_db_readwrite: ConnDB) -> None:
+    class TestException(Exception):
+        pass
+
+    conn, _ = conn_db_readwrite
+
+    def throw() -> int:
+        errmsg = "test"
+        raise TestException(errmsg)
+
+    conn.create_function("testexcept", throw)
+
+    pytest.raises(RuntimeError, conn.execute, "RETURN testexcept()")
+
+    conn.remove_function("testexcept")
+    conn.create_function("testexcept", throw, catch_exceptions=True)
+
+    assert conn.execute("RETURN testexcept()").get_next() == [None]
+
+
+def test_udf_remove(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+
+    def myfunction() -> int:
+        return 1
+
+    conn.create_function("myfunction", myfunction)
+
+    with pytest.raises(RuntimeError, match=r"Catalog exception: function notmyfunction doesn't exist."):
+        conn.remove_function("notmyfunction")
+
+    conn.remove_function("myfunction")
+
+    with pytest.raises(RuntimeError, match=r"Catalog exception: function list_create doesn't exist."):
+        conn.remove_function("list_create")

real_ladybug-source/tools/python_api/test/test_version.py

@@ -0,0 +1,6 @@
+def test_version() -> None:
+    import real_ladybug as lb
+
+    assert lb.version != ""
+    assert lb.storage_version > 0
+    assert lb.version == lb.__version__

real_ladybug-source/tools/python_api/test/test_wal.py

@@ -0,0 +1,80 @@
+import subprocess
+import sys
+import time
+from pathlib import Path
+from textwrap import dedent
+
+import real_ladybug as lb
+
+from conftest import get_db_file_path
+
+
+def run_query_in_new_process(tmp_path: Path, build_dir: Path, queries: str):
+    db_path = get_db_file_path(tmp_path)
+    code = (
+        dedent(
+            f"""
+        import sys
+        sys.path.append(r"{build_dir!s}")
+
+        import real_ladybug as lb
+        db = lb.Database(r"{db_path!s}")
+        """
+        )
+        + queries
+    )
+    return subprocess.Popen([sys.executable, "-c", code])
+
+
+def run_query_then_kill(tmp_path: Path, build_dir: Path, queries: str):
+    proc = run_query_in_new_process(tmp_path, build_dir, queries)
+    time.sleep(5)
+    proc.kill()
+    proc.wait(5)
+    db_path = get_db_file_path(tmp_path)
+    # Force remove the lock file. Safe since proc.wait() ensures the process has terminated.
+    Path(f"{db_path!s}.lock").unlink(missing_ok=True)
+
+
+# Kill the database while it's in the middle of executing a long persistent query
+# When we reload the database we will replay from the WAL (which will be incomplete)
+def test_replay_after_kill(tmp_path: Path, build_dir: Path) -> None:
+    queries = dedent("""
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE tab (id INT64, PRIMARY KEY (id));")
+    conn.execute("UNWIND RANGE(1,100000) AS x UNWIND RANGE(1, 100000) AS y CREATE (:tab {id: x * 100000 + y});")
+    """)
+    run_query_then_kill(tmp_path, build_dir, queries)
+    db_path = get_db_file_path(tmp_path)
+    with lb.Database(db_path) as db, lb.Connection(db) as conn:
+        # previously committed queries should be valid after replaying WAL
+        result = conn.execute("CALL show_tables() RETURN *")
+        assert result.has_next()
+        assert result.get_next()[1] == "tab"
+        assert not result.has_next()
+        result.close()
+
+
+def test_replay_with_exception(tmp_path: Path, build_dir: Path) -> None:
+    queries = dedent("""
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE tab (id INT64, PRIMARY KEY (id));")
+    # some of these queries will throw exceptions
+    for i in range(10):
+        try:
+            conn.execute(f"CREATE (:tab {{id: {i // 2}}})")
+            assert i % 2 == 0
+        except:
+            assert i % 2 == 1
+    conn.execute("UNWIND RANGE(1,100000) AS x UNWIND RANGE(1, 100000) AS y CREATE (:tab {id: x * 100000 + y});")
+    """)
+    run_query_then_kill(tmp_path, build_dir, queries)
+    db_path = get_db_file_path(tmp_path)
+    with lb.Database(db_path) as db, lb.Connection(db) as conn:
+        # previously committed queries should be valid after replaying WAL
+        result = conn.execute("match (t:tab) where t.id <= 5 return t.id")
+        assert result.get_num_tuples() == 5
+        for i in range(5):
+            assert result.get_next()[0] == i
+        assert not result.has_next()
+        result.close()

real_ladybug-source/tools/python_api/test/type_aliases.py

@@ -0,0 +1,10 @@
+import sys
+
+from real_ladybug import Connection, Database
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+ConnDB: TypeAlias = tuple[Connection, Database]

real_ladybug-source/tools/rust_api/update_version.py

@@ -0,0 +1,47 @@
+"""Updates the version in Cargo.toml to match the version in the main CMakeLists.txt"""
+
+import os
+import re
+from pathlib import Path
+
+LBUG_RS_ROOT = Path(__file__).parent
+LBUG_ROOT = LBUG_RS_ROOT.parent.parent
+
+
+def get_lbug_version():
+    cmake_file = LBUG_ROOT / "CMakeLists.txt"
+    with open(cmake_file) as f:
+        for line in f:
+            if line.startswith("project(Lbug VERSION"):
+                version = line.split(" ")[2].strip()
+                # Make version semver-compatible
+                components = version.split(".")
+                if len(components) >= 4:
+                    version = ".".join(components[0:3]) + "-pre." + ".".join(components[3:])
+                return version
+
+
+if __name__ == "__main__":
+    version = get_lbug_version()
+    version_changed = False
+    with open(LBUG_RS_ROOT / "Cargo.toml", encoding="utf-8") as file:
+        data = file.readlines()
+        section = None
+        for index, line in enumerate(data):
+            if line.startswith("["):
+                section = line.strip().strip("[]")
+            if line.startswith("version = ") and section == "package":
+                toml_version = re.match('version = "(.*)"', line).group(1)
+                if toml_version != version:
+                    version_changed = True
+                    print(
+                        f"Updating version in Cargo.toml from {toml_version} to {version}"
+                    )
+                    data[index] = re.sub(
+                        'version = ".*"', f'version = "{version}"', line
+                    )
+                    break
+
+    if version_changed:
+        with open(LBUG_RS_ROOT / "Cargo.toml", "w", encoding="utf-8") as file:
+            file.writelines(data)

real_ladybug-source/tools/shell/test/conftest.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+
+import pexpect
+import pytest
+
+from test_helper import LBUG_EXEC_PATH, LBUG_ROOT, deleteIfExists
+
+
+def pytest_addoption(parser) -> None:
+    parser.addoption(
+        "--start-offset",
+        action="store",
+        type=int,
+        help="Skip the first 'n' tests",
+    )
+
+
+def pytest_collection_modifyitems(config, items) -> None:
+    start_offset = config.getoption("--start-offset")
+    if not start_offset:
+        # --skiplist not given in cli, therefore move on
+        return
+
+    skipped = pytest.mark.skip(reason="included in --skiplist")
+    skipped_items = items[:start_offset]
+    for item in skipped_items:
+        item.add_marker(skipped)
+
+
+class TestResult:
+    def __init__(self, stdout, stderr, status_code) -> None:
+        self.stdout: str | bytes = stdout
+        self.stderr: str | bytes = stderr
+        self.status_code: int = status_code
+
+    def check_stdout(self, expected: str | list[str] | bytes) -> None:
+        if isinstance(expected, list):
+            expected = "\n".join(expected)
+        assert self.status_code == 0
+        assert expected in self.stdout
+
+    def check_not_stdout(self, expected: str | list[str] | bytes) -> None:
+        if isinstance(expected, list):
+            expected = "\n".join(expected)
+        assert self.status_code == 0
+        assert expected not in self.stdout
+
+    def check_stderr(self, expected: str) -> None:
+        assert expected in self.stderr
+
+
+class ShellTest:
+    def __init__(self) -> None:
+        self.shell = LBUG_EXEC_PATH
+        self.arguments = [self.shell]
+        self.statements: list[str] = []
+        self.input = None
+        self.output = None
+        self.environment = {}
+        self.shell_process = None
+
+    def add_argument(self, *args):
+        self.arguments.extend(args)
+        return self
+
+    def statement(self, stmt):
+        self.statements.append(stmt)
+        return self
+
+    def query(self, *stmts):
+        self.statements.extend(stmts)
+        return self
+
+    def input_file(self, file_path):
+        self.input = file_path
+        return self
+
+    def output_file(self, file_path):
+        self.output = file_path
+        return self
+
+    # Test Running methods
+
+    def get_command(self, cmd: str) -> list[str]:
+        command = self.arguments
+        if self.input:
+            command += [cmd]
+        return command
+
+    def get_input_data(self, cmd: str):
+        if self.input:
+            with open(self.input, "rb") as f:
+                input_data = f.read()
+        else:
+            input_data = bytearray(cmd, "utf8")
+        return input_data
+
+    def get_output_pipe(self):
+        output_pipe = subprocess.PIPE
+        if self.output:
+            output_pipe = open(self.output, "w+")
+        return output_pipe
+
+    def get_statements(self):
+        statements = []
+        for statement in self.statements:
+            statements.append(statement)
+        return "\n".join(statements)
+
+    def get_output_data(self, res):
+        if self.output:
+            stdout = open(self.output).read()
+        else:
+            stdout = res.stdout.decode("utf8").strip()
+        stderr = res.stderr.decode("utf8").strip()
+        return stdout, stderr
+
+    def run(self):
+        statements = self.get_statements()
+        command = self.get_command(statements)
+        input_data = self.get_input_data(statements)
+        output_pipe = self.get_output_pipe()
+
+        my_env = os.environ.copy()
+        for key, val in self.environment.items():
+            my_env[key] = val
+
+        res = subprocess.run(
+            command,
+            input=input_data,
+            stdout=output_pipe,
+            stderr=subprocess.PIPE,
+            env=my_env,
+            check=False,
+        )
+
+        stdout, stderr = self.get_output_data(res)
+        return TestResult(stdout, stderr, res.returncode)
+
+    def start(self) -> None:
+        command = " ".join(self.arguments)
+
+        my_env = os.environ.copy()
+        for key, val in self.environment.items():
+            my_env[key] = val
+
+        self.shell_process = pexpect.spawn(command, encoding="utf_8", env=my_env)
+
+    def send_finished_statement(self, stmt: str) -> None:
+        if self.shell_process:
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+            self.shell_process.send(stmt)
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+
+    def send_statement(self, stmt: str) -> None:
+        if self.shell_process:
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+            self.shell_process.send(stmt)
+
+    def send_control_statement(self, stmt: str) -> None:
+        if self.shell_process:
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+            self.shell_process.sendcontrol(stmt)
+
+
+@pytest.fixture()
+def temp_db(tmp_path):
+    shutil.rmtree(tmp_path, ignore_errors=True)
+    return str(tmp_path)
+
+
+@pytest.fixture()
+def get_tmp_path(tmp_path):
+    return str(tmp_path)
+
+
+@pytest.fixture()
+def history_path():
+    path = os.path.join(LBUG_ROOT, "tools", "shell", "test", "files")
+    deleteIfExists(os.path.join(path, "history.txt"))
+    return path
+
+
+@pytest.fixture()
+def csv_path():
+    return os.path.join(LBUG_ROOT, "tools", "shell", "test", "files", "vPerson.csv")
+
+
+@pytest.fixture()
+def init_path():
+    return os.path.join(LBUG_ROOT, "tools", "shell", "test", "files", "start.cypher")
+
+
+@pytest.fixture
+def test(request):
+    return request.getfixturevalue(request.param)
+
+
+@pytest.fixture
+def multiline():
+    test = ShellTest()
+    test.start()
+    return test
+
+
+@pytest.fixture
+def singleline():
+    test = ShellTest()
+    test.start()
+    test.send_finished_statement(":singleline\r")
+    assert (
+        test.shell_process.expect_exact(["Single line mode enabled", pexpect.EOF]) == 0
+    )
+    return test