tinymongo 0.1.9__tar.gz → 1.0.0__tar.gz

tinymongo-1.0.0/LICENSE.txt

@@ -0,0 +1,10 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Stephen Chapman
+
+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.
+~

tinymongo-1.0.0/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: tinymongo
+Version: 1.0.0
+Summary: A flat file drop in replacement for mongodb. Requires TinyDB
+Author-email: Stephen Chapman <schapman1974@gmail.com>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2016 Stephen Chapman
+        
+        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.
+        ~
+        
+Project-URL: Homepage, https://github.com/schapman1974/tinymongo
+Project-URL: Source, https://github.com/schapman1974/tinymongo
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Database
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: tinydb==3.2.1
+Requires-Dist: tinydb-serialization==1.0.4
+Requires-Dist: pymongo>=3.4.0
+Requires-Dist: pyarrow>=10.0.0
+Requires-Dist: portalocker>=2.7.0
+Provides-Extra: uv
+Requires-Dist: uvicorn>=0.23.0; extra == "uv"
+Dynamic: license-file
+
+[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/schapman1974/tinymongo) 
+
+
+![logo](artwork/tinymongo.png)
+
+[![Build Status](https://travis-ci.org/schapman1974/tinymongo.svg?branch=master)](https://travis-ci.org/schapman1974/tinymongo)
+
+# Purpose
+
+A simple wrapper to make a drop in replacement for mongodb out of
+[tinydb](http://tinydb.readthedocs.io/en/latest/).  This module is an
+attempt to add an interface familiar to those currently using pymongo.
+
+# Status
+
+Unit testing is currently being worked on and functionality is being
+added to the library.  Current coverage is 93%.  Current builds tested
+on Python versions 2.7 and 3.3+.
+
+# Installation
+
+The latest stable release can be installed via `pip install tinymongo`.
+
+The library is currently under rapid development and a more recent version
+may be desired.
+
+In this case, simply clone this repository, navigate
+to the root project directory, and `pip install -e .`
+
+or use `pip install -e git+https://github.com/schapman1974/tinymongo.git#egg=tinymongo`
+
+This
+is a pure python distribution and - thus - should require no external
+compilers or tools besides those contained within Python itself.
+
+# Notes for this fork
+
+- **Default storage:** this fork uses Parquet v2 files by default (via `pyarrow`) for improved I/O performance and reliability. If `pyarrow` is not available, it falls back to TinyDB's default JSON storage.
+- **Concurrency:** writes use atomic temp-file replace and optional advisory locks (`portalocker`) to reduce corruption risk under concurrent writers.
+- **Tests & CI:** a GitHub Actions workflow is included at `.github/workflows/ci.yml` to run unit tests and linters across Python versions. See `requirements-dev.txt` for dev dependencies.
+
+
+# Examples
+
+The quick start is shown below.  For a more detailed look at tinymongo,
+take a look at demo.py within the repository.
+
+```python
+    from tinymongo import TinyMongoClient
+
+    # you can include a folder name or absolute path
+    # as a parameter if not it will default to "tinydb"
+    connection = TinyMongoClient()
+
+    # either creates a new database file or accesses an existing one named `my_tiny_database`
+    db = connection.my_tiny_database
+
+    # either creates a new collection or accesses an existing one named `users`
+    collection = db.users
+
+    # insert data adds a new record returns _id
+    record_id = collection.insert_one({"username": "admin", "password": "admin", "module":"somemodule"}).inserted_id
+    user_info = collection.find_one({"_id": record_id})  # returns the record inserted
+
+    # you can also use it directly
+    db.users.insert_one({"username": "admin"})
+
+    # returns a list of all users of 'module'
+    users = db.users.find({'module': 'module'})
+
+    #update data returns True if successful and False if unsuccessful
+    upd = db.users.update_one({"username": "admin"}, {"$set": {"module":"someothermodule"}})
+
+    # Sorting users by its username DESC
+    # omitting `filter` returns all records
+    db.users.find(sort=[('username', -1)])
+
+    # Pagination of the results
+    # Getting the first 20 records
+    db.users.find(sort=[('username', -1)], skip=0, limit=20)
+    # Getting next 20 records
+    db.users.find(sort=[('username', -1)], skip=20, limit=20)
+
+    # Getting the total of records
+    db.users.count()
+
+```
+
+# Custom Storages and Serializers
+
+> HINT: Learn more about TinyDB storages and Serializers in [documentation](https://tinydb.readthedocs.io/en/latest/usage.html#storages-middlewares)
+
+## Custom Storages
+
+You have to subclass `TinyMongoClient` and provide custom storages like
+CachingMiddleware or other available TinyDB Extension.
+
+### Caching Middleware
+
+```python
+    from tinymongo import TinyMongoClient
+    from tinydb.storages import JSONStorage
+    from tinydb.middlewares import CachingMiddleware
+
+    class CachedClient(TinyMongoClient):
+        """This client has cache"""
+        @property
+        def _storage(self):
+            return CachingMiddleware(JSONStorage)
+
+    connection = CachedClient('/path/to/folder')
+```
+
+> HINT: You can nest middlewares: `FirstMiddleware(SecondMiddleware(JSONStorage))`
+
+
+## Serializers
+
+To convert your data to a format that is writable to disk TinyDB uses the Python JSON module by default. It's great when only simple data types are involved but it cannot handle more complex data types like custom classes.
+
+To support serialization of complex types you can write
+your own serializers using the `tinydb-serialization` extension.
+
+First you need to install it `pip install tinydb-serialization`
+
+## Handling datetime objects
+
+You can create a serializer for the python `datetime` using
+the following snippet:
+
+```python
+    from datetime import datetime
+    from tinydb_serialization import Serializer
+
+    class DatetimeSerializer(Serializer):
+        OBJ_CLASS = datetime
+
+        def __init__(self, format='%Y-%m-%dT%H:%M:%S', *args, **kwargs):
+            super(DatetimeSerializer, self).__init__(*args, **kwargs)
+            self._format = format
+
+        def encode(self, obj):
+            return obj.strftime(self._format)
+
+        def decode(self, s):
+            return datetime.strptime(s, self._format)
+```
+
+> NOTE: this serializer is available in `tinymongo.serializers.DateTimeSerializer`
+
+
+Now you have to subclass `TinyMongoClient` and provide customs storage.
+
+```python
+    from tinymongo import TinyMongoClient
+    from tinymongo.serializers import DateTimeSerializer
+    from tinydb_serialization import SerializationMiddleware
+
+
+    class CustomClient(TinyMongoClient):
+        @property
+        def _storage(self):
+            serialization = SerializationMiddleware()
+            serialization.register_serializer(DateTimeSerializer(), 'TinyDate')
+            # register other custom serializers
+            return serialization
+
+
+    connection = CustomClient('/path/to/folder')
+```
+
+# Flask-Admin
+
+This extension can work with Flask-Admin which gives a web based administrative
+panel to your TinyDB. Flask-Admin has features like filtering, search, web forms to
+perform CRUD (Create, Read, Update, Delete) of the TinyDB records.
+
+You can find the example of Flask-Admin with TinyMongo in [Flask-Admin Examples Repository](https://github.com/flask-admin/flask-admin/tree/master/examples/tinymongo)
+
+> NOTE: To use Flask-Admin you need to register a DateTimeSerialization as showed in the previous topic.
+
+# Contributions
+
+Contributions are welcome!  Currently, the most valuable contributions
+would be:
+
+* adding test cases
+* adding functionality consistent with pymongo
+* documentation
+* identifying bugs and issues
+
+# Future Development
+
+I will also be adding support for gridFS by storing the files somehow and indexing them in a db like mongo currently does
+
+More to come......
+
+# License
+
+MIT License

{tinymongo-0.1.9 → tinymongo-1.0.0}/README.md

@@ -1,7 +1,9 @@
+[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/schapman1974/tinymongo) 
+
 
 ![logo](artwork/tinymongo.png)
 
-[![Build Status](https://travis-ci.org/jjonesAtMoog/tinymongo.svg?branch=master)](https://travis-ci.org/jjonesAtMoog/tinymongo)
+[![Build Status](https://travis-ci.org/schapman1974/tinymongo.svg?branch=master)](https://travis-ci.org/schapman1974/tinymongo)
 
 # Purpose
 
@@ -23,14 +25,21 @@ The library is currently under rapid development and a more recent version
 may be desired.
 
 In this case, simply clone this repository, navigate
-to the root project directory, and `python setup.py install`
+to the root project directory, and `pip install -e .`
 
-or use `pip install git+https://github.com/schapman1974/tinymongo.git#egg=tinymongo`
+or use `pip install -e git+https://github.com/schapman1974/tinymongo.git#egg=tinymongo`
 
 This
 is a pure python distribution and - thus - should require no external
 compilers or tools besides those contained within Python itself.
 
+# Notes for this fork
+
+- **Default storage:** this fork uses Parquet v2 files by default (via `pyarrow`) for improved I/O performance and reliability. If `pyarrow` is not available, it falls back to TinyDB's default JSON storage.
+- **Concurrency:** writes use atomic temp-file replace and optional advisory locks (`portalocker`) to reduce corruption risk under concurrent writers.
+- **Tests & CI:** a GitHub Actions workflow is included at `.github/workflows/ci.yml` to run unit tests and linters across Python versions. See `requirements-dev.txt` for dev dependencies.
+
+
 # Examples
 
 The quick start is shown below.  For a more detailed look at tinymongo,
@@ -50,7 +59,7 @@ take a look at demo.py within the repository.
     collection = db.users
 
     # insert data adds a new record returns _id
-    record_id = collection.insert_one({"username": "admin", "password": "admin", "module":"somemodule"})
+    record_id = collection.insert_one({"username": "admin", "password": "admin", "module":"somemodule"}).inserted_id
     user_info = collection.find_one({"_id": record_id})  # returns the record inserted
 
     # you can also use it directly
@@ -64,13 +73,13 @@ take a look at demo.py within the repository.
 
     # Sorting users by its username DESC
     # omitting `filter` returns all records
-    db.users.find(sort={'username': -1})
+    db.users.find(sort=[('username', -1)])
 
     # Pagination of the results
     # Getting the first 20 records
-    db.users.find(sort={'username': -1}, skip=0, limit=20)
+    db.users.find(sort=[('username', -1)], skip=0, limit=20)
     # Getting next 20 records
-    db.users.find(sort={'username': -1}, skip=20, limit=20)
+    db.users.find(sort=[('username', -1)], skip=20, limit=20)
 
     # Getting the total of records
     db.users.count()

tinymongo-1.0.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinymongo"
+version = "1.0.0"
+description = "A flat file drop in replacement for mongodb. Requires TinyDB"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [ { name = "Stephen Chapman", email = "schapman1974@gmail.com" } ]
+license = {file = "LICENSE.txt"}
+dependencies = [
+  "tinydb==3.2.1",
+  "tinydb-serialization==1.0.4",
+  "pymongo>=3.4.0",
+  "pyarrow>=10.0.0",
+  "portalocker>=2.7.0"
+]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Database",
+]
+
+[project.urls]
+Homepage = "https://github.com/schapman1974/tinymongo"
+Source = "https://github.com/schapman1974/tinymongo"
+
+[tool.black]
+line-length = 88
+
+[tool.ruff]
+line-length = 88
+
+[tool.mypy]
+python_version = 3.8
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-q"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tinymongo*"]
+
+[tool.setuptools]
+include-package-data = true
+
+[project.optional-dependencies]
+uv = ["uvicorn>=0.23.0"]
+

{tinymongo-0.1.9 → tinymongo-1.0.0}/setup.cfg

@@ -1,8 +1,7 @@
 [metadata]
-description-file = README.md
+description_file = README.md
 
 [egg_info]
 tag_build = 
 tag_date = 0
-tag_svn_revision = 0
 

tinymongo-1.0.0/tests/test_mongo_like.py

@@ -0,0 +1,86 @@
+import os
+import shutil
+
+import tinymongo as tm
+
+
+DB_DIR = os.path.abspath("./test_db_mongo_like")
+
+
+def setup_db():
+    if os.path.exists(DB_DIR):
+        shutil.rmtree(DB_DIR)
+    os.makedirs(DB_DIR, exist_ok=True)
+
+
+def test_upsert_and_find():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+
+    # insert doc
+    c.insert_one({"_id": "a", "count": 1})
+
+    # upsert behavior simulation: update if exists else insert
+    existing = c.find_one({"_id": "a"})
+    assert existing is not None
+
+    # update using $set
+    c.update_one({"_id": "a"}, {"$set": {"count": 5}})
+    doc = c.find_one({"_id": "a"})
+    assert doc["count"] == 5
+
+
+def test_update_operators():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+
+    c.insert_many([{"_id": i, "v": i} for i in range(5)])
+
+    # Simulate $inc by reading, modifying, writing
+    for i in range(5):
+        c.update_one({"_id": i}, {"$set": {"v": i + 10}})
+
+    vals = sorted([d["v"] for d in c.find()])
+    assert vals == [10, 11, 12, 13, 14]
+
+
+def test_projection_like():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+
+    c.insert_one({"_id": "p", "a": 1, "b": 2, "c": 3})
+    doc = c.find_one({"_id": "p"})
+    # projection not implemented; ensure full doc available
+    assert set(doc.keys()) >= {"_id", "a", "b", "c"}
+
+
+def test_find_and_modify_semantics():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+
+    c.insert_one({"_id": "fm", "counter": 0})
+
+    # Emulate findOneAndUpdate: read, update atomically via TinyDB API
+    c.update_one({"_id": "fm"}, {"$set": {"counter": 1}})
+    d = c.find_one({"_id": "fm"})
+    assert d["counter"] == 1
+
+
+def test_unique_index_simulation():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+
+    # TinyMongo insert_one enforces _id uniqueness
+    c.insert_one({"_id": "u1", "v": 1})
+    try:
+        c.insert_one({"_id": "u1", "v": 2})
+        inserted = True
+    except Exception:
+        inserted = False
+
+    assert not inserted

tinymongo-1.0.0/tests/test_multi_write.py

@@ -0,0 +1,52 @@
+import os
+import multiprocessing as mp
+import shutil
+
+import tinymongo as tm
+
+
+DB_DIR = os.path.abspath("./test_db_multi")
+
+
+def writer_process(proc_id, count, start_value=0):
+    client = tm.TinyMongoClient(DB_DIR)
+    db = client.multiDB
+    coll = db.multiCollection
+
+    items = []
+    for i in range(count):
+        items.append({"count": start_value + proc_id * count + i})
+
+    # insert many
+    coll.insert_many(items)
+
+
+def test_multi_writer_stress():
+    # ensure clean dir
+    if os.path.exists(DB_DIR):
+        try:
+            shutil.rmtree(DB_DIR)
+        except Exception:
+            pass
+
+    num_procs = 6
+    per_proc = 50
+
+    procs = []
+    for pid in range(num_procs):
+        p = mp.Process(target=writer_process, args=(pid, per_proc, 0))
+        p.start()
+        procs.append(p)
+
+    for p in procs:
+        p.join()
+
+    # validate
+    client = tm.TinyMongoClient(DB_DIR)
+    coll = client.multiDB.multiCollection
+    all_docs = list(coll.find())
+    assert len(all_docs) == num_procs * per_proc
+
+    # check uniqueness
+    counts = sorted(d["count"] for d in all_docs)
+    assert counts == list(range(0, num_procs * per_proc))

tinymongo-1.0.0/tests/test_query_more.py

@@ -0,0 +1,108 @@
+import os
+import shutil
+
+import tinymongo as tm
+
+DB_DIR = os.path.abspath("./test_db_query_more")
+
+
+def setup_db():
+    if os.path.exists(DB_DIR):
+        shutil.rmtree(DB_DIR)
+    os.makedirs(DB_DIR, exist_ok=True)
+
+
+def test_nin_query_operator():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_many([
+        {"_id": 1, "tag": "alpha"},
+        {"_id": 2, "tag": "beta"},
+        {"_id": 3, "tag": "gamma"},
+    ])
+
+    results = c.find({"tag": {"$nin": ["alpha", "beta"]}})
+    assert results.count() == 1
+    assert results[0]["tag"] == "gamma"
+
+
+def test_update_many_applies_to_all_matches():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_many([
+        {"_id": 1, "group": "a", "value": 1},
+        {"_id": 2, "group": "a", "value": 2},
+        {"_id": 3, "group": "b", "value": 3},
+    ])
+
+    result = c.update_many({"group": "a"}, {"$set": {"active": True}})
+    assert result.matched_count == 2
+    assert result.modified_count == 2
+    assert c.find({"active": True}).count() == 2
+
+
+def test_replace_one_replaces_single_document():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_one({"_id": "one", "count": 1, "tag": "keep"})
+    c.insert_one({"_id": "two", "count": 2, "tag": "keep"})
+
+    result = c.replace_one({"_id": "one"}, {"count": 42})
+    assert result.matched_count == 1
+    doc = c.find_one({"_id": "one"})
+    assert doc["count"] == 42
+    assert doc["_id"] == "one"
+    assert "tag" not in doc
+
+
+def test_find_one_and_update_returns_old_document():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_one({"_id": "item", "score": 10})
+
+    old_doc = c.find_one_and_update({"_id": "item"}, {"$set": {"score": 20}})
+    assert old_doc["score"] == 10
+    assert c.find_one({"_id": "item"})["score"] == 20
+
+
+def test_skip_limit_pagination_with_find():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_many([{"_id": i, "value": i} for i in range(20)])
+
+    page = c.find(sort=[("value", 1)], skip=5, limit=5)
+    assert page.count() == 5
+    assert page[0]["value"] == 5
+    assert page[-1]["value"] == 9
+
+
+def test_all_operator_matches_arrays():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_many([
+        {"_id": 1, "tags": ["a", "b", "c"]},
+        {"_id": 2, "tags": ["a", "c"]},
+        {"_id": 3, "tags": ["b", "a", "c"]},
+    ])
+
+    matches = c.find({"tags": {"$all": ["a", "c"]}})
+    assert matches.count() == 3
+
+
+def test_count_documents_uses_filter():
+    setup_db()
+    client = tm.TinyMongoClient(DB_DIR)
+    c = client.db.collection
+    c.insert_many([
+        {"_id": 1, "even": True},
+        {"_id": 2, "even": False},
+        {"_id": 3, "even": True},
+    ])
+
+    assert c.count_documents({"even": True}) == 2

tinymongo-1.0.0/tests/test_storage_backends.py

@@ -0,0 +1,55 @@
+import pytest
+import tinymongo as tm
+
+
+def test_tinydb_backend_default(tmp_path):
+    client = tm.TinyMongoClient(str(tmp_path / "db"), backend="tinydb")
+    db = client.testdb
+    coll = db.testcollection
+    coll.insert_one({"_id": 1, "value": "tinydb"})
+
+    assert coll.count() == 1
+    assert (tmp_path / "db" / "testdb.json").exists()
+
+
+def test_sqlite_backend(tmp_path):
+    client = tm.TinyMongoClient(str(tmp_path / "db"), backend="sqlite")
+    db = client.testdb
+    coll = db.testcollection
+    coll.insert_one({"_id": 1, "value": "sqlite"})
+
+    assert coll.count() == 1
+    assert (tmp_path / "db" / "testdb.sqlite").exists()
+
+
+def test_parquet_backend(tmp_path):
+    pytest.importorskip("pyarrow")
+    client = tm.TinyMongoClient(str(tmp_path / "db"), backend="parquet")
+    db = client.testdb
+    coll = db.testcollection
+    coll.insert_one({"_id": 1, "value": "parquet"})
+
+    assert coll.count() == 1
+    assert (tmp_path / "db" / "testdb.parquet").exists()
+
+
+def test_duckdb_backend(tmp_path):
+    pytest.importorskip("duckdb")
+    client = tm.TinyMongoClient(str(tmp_path / "db"), backend="duckdb")
+    db = client.testdb
+    coll = db.testcollection
+    coll.insert_one({"_id": 1, "value": "duckdb"})
+
+    assert coll.count() == 1
+    assert (tmp_path / "db" / "testdb.duckdb").exists()
+
+
+def test_internal_client_attrs_are_preserved(tmp_path):
+    client = tm.TinyMongoClient(str(tmp_path / "db"), backend="tinydb")
+
+    assert client._backend == "tinydb"
+    assert client._storage is not None
+
+    db = client.testdb
+    assert db._foldername == str(tmp_path / "db")
+    assert not (tmp_path / "db" / "_storage.json").exists()