zydecodb 0.9.0__tar.gz

zydecodb-0.9.0/.gitignore

@@ -0,0 +1,77 @@
+# Node.js
+node_modules/
+dist/
+experiments/**/*.js
+
+# Compiled binaries
+experiments/write_heavy/write_heavy
+clients/go/user_backend
+
+# Rust
+/target
+**/*.rs.bk
+
+# Runtime data (dev)
+*.sock
+/.zydecodb-data/
+/.zydecodb-run/
+
+# Soak run artifacts (baselines in docs/soak-baselines/ are committed)
+/soak-runs/**/data/
+/soak-runs/**/wal/
+/soak-runs/**/*.log
+/soak-runs/**/*.jsonl
+
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+*.egg-info/
+.venv/
+
+# Fuzzing
+/fuzz/corpus/
+/fuzz/artifacts/
+/fuzz/target/
+
+# Coverage
+/coverage/
+*.profraw
+lcov.info
+
+# Secrets / credentials (never commit)
+.env
+.env.*
+!.env.example
+keys.toml
+**/keys.toml
+!config/zydecodb.keys.example.toml
+*.pem
+*.key
+*.p12
+*.pfx
+tls.crt
+tls.key
+
+# IDE
+/.idea/
+/.vscode/
+*.swp
+.DS_Store
+
+# Empty stub left over from an earlier packaging experiment
+/.github/workflows/publish-python.yml
+
+# Website / Marketing (deployed from this tree via scripts/deploy-website.sh;
+# keep the marketing site and ops scripts local unless explicitly force-added)
+/website/
+/scripts/*
+!/scripts/install.sh
+!/scripts/deploy-website.sh
+!/scripts/tenant-isolation-soak.sh
+
+# Internal / Archived Docs
+/ROADMAP.md
+/docs/archive/
+/docs/soak-baselines/
+.cargo-home/

zydecodb-0.9.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: zydecodb
+Version: 0.9.0
+Summary: Official Python driver for ZydecoDB.
+Project-URL: Homepage, https://github.com/dataparade/zydecodb
+Project-URL: Source, https://github.com/dataparade/zydecodb
+Author: Dataparade
+License: MIT
+Keywords: database,document-store,nosql,zydecodb
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ZydecoDB Python driver
+
+Official Python client for [ZydecoDB](../../README.md). Pure standard library,
+no runtime dependencies.
+
+**Wire reference:** this client is the hand-maintained reference codec. Go and
+TypeScript track the same bytes via [`../conformance/vectors.json`](../conformance/vectors.json)
+(CI job `wire-conformance`).
+
+## Install
+
+```bash
+pip install zydecodb
+```
+
+Requires Python 3.9+. (Working from a checkout of this repo:
+`pip install -e clients/python`.)
+
+## Quick start
+
+```python
+from zydecodb import Client
+
+# Plain TCP (localhost). For TLS: Client(..., api_key="YOUR_KEY", tls=True)
+with Client("127.0.0.1", 9470, api_key="YOUR_KEY") as db:
+    users = db.collection("users")
+    users.create_index(["email"], unique=True)
+
+    uid = users.insert_one({"email": "ada@example.com", "name": "Ada", "age": 30})
+
+    for u in users.find({"age": {"$gte": 18}}, sort=[("age", True)]):
+        print(u["name"], u["age"])
+
+    users.update_one({"_id": uid}, {"$inc": {"age": 1}})
+    print(users.count_documents())
+```
+
+## What you get
+
+- **Connection pooling.** `Client` owns a thread-safe pool (`pool_size`,
+  default 8) and is safe to share across threads.
+- **Automatic retries with backoff.** Transient transport failures and server
+  `EngineBusy` responses are retried (full-jitter exponential backoff) for
+  operations that are safe to repeat. Operator updates and deletes are never
+  retried automatically.
+- **Keepalive.** Idle pooled connections are validated with a `Ping` on
+  checkout and transparently replaced if dead.
+- **Typed error taxonomy.** Non-OK responses raise a specific subclass:
+  `ConflictError` (unique-index violation), `AuthError`, `ServerBusyError`,
+  `InvalidRequestError`, or the base `ServerError` — each carrying the wire
+  `status` byte. Transport problems raise `ConnectionError`.
+- **`Collection` API.** `insert_one/many`, `find`/`find_one`,
+  `update_one/many`, `delete_one/many`, `count_documents`, `distinct`,
+  `create_index`, with `$`-operators, sort, projection, and skip/limit.
+  Pagination is repeatable-read across pages.
+- **Raw KV with TTL.** Side-channel `put` (with `expires_at`), `get`, and `delete` methods on `Client` for session data that needs a time-to-live.
+- **TLS.** Pass `tls=True` for system CA defaults, or an `ssl.SSLContext` for custom roots / verification.
+
+## Optimistic concurrency
+
+```python
+got = users.get_with_revision(uid)
+doc, rev = got
+doc["age"] += 1
+try:
+    users.replace_one_if_match(uid, doc, if_match=rev)
+except ConflictError:
+    pass  # re-read and retry, or merge
+```
+
+Also: `find_with_revision`, `update_by_id_if_match`. Revisions are opaque
+integers. Stale/missing documents raise `ConflictError`. Against an older
+server these methods fail with a protocol error instead of silently becoming
+unconditional writes.
+
+## Durability
+
+Writes are durable (fsync-on-commit) by default. For latency-sensitive,
+loss-tolerant writes, pass `relaxed=True` to acknowledge before the fsync.
+It is available on every write: `insert_one`, `replace_one`, `update_one`,
+`update_many`, `delete_one`, and `delete_many`.
+
+```python
+users.insert_one(doc, relaxed=True)
+users.update_one({"_id": "ada"}, {"$inc": {"hits": 1}}, relaxed=True)
+users.delete_many({"stale": True}, relaxed=True)
+```
+
+## Running the tests
+
+Unit + wire conformance (no server):
+
+```bash
+cd clients/python
+pip install -e ".[dev]"
+pytest tests/test_protocol.py tests/test_conformance.py
+```
+
+Integration tests run against a live server selected by environment variables
+(skipped automatically if it is unreachable):
+
+```bash
+ZYDECODB_TEST_HOST=127.0.0.1 ZYDECODB_TEST_PORT=9470 pytest
+```

zydecodb-0.9.0/README.md

@@ -0,0 +1,104 @@
+# ZydecoDB Python driver
+
+Official Python client for [ZydecoDB](../../README.md). Pure standard library,
+no runtime dependencies.
+
+**Wire reference:** this client is the hand-maintained reference codec. Go and
+TypeScript track the same bytes via [`../conformance/vectors.json`](../conformance/vectors.json)
+(CI job `wire-conformance`).
+
+## Install
+
+```bash
+pip install zydecodb
+```
+
+Requires Python 3.9+. (Working from a checkout of this repo:
+`pip install -e clients/python`.)
+
+## Quick start
+
+```python
+from zydecodb import Client
+
+# Plain TCP (localhost). For TLS: Client(..., api_key="YOUR_KEY", tls=True)
+with Client("127.0.0.1", 9470, api_key="YOUR_KEY") as db:
+    users = db.collection("users")
+    users.create_index(["email"], unique=True)
+
+    uid = users.insert_one({"email": "ada@example.com", "name": "Ada", "age": 30})
+
+    for u in users.find({"age": {"$gte": 18}}, sort=[("age", True)]):
+        print(u["name"], u["age"])
+
+    users.update_one({"_id": uid}, {"$inc": {"age": 1}})
+    print(users.count_documents())
+```
+
+## What you get
+
+- **Connection pooling.** `Client` owns a thread-safe pool (`pool_size`,
+  default 8) and is safe to share across threads.
+- **Automatic retries with backoff.** Transient transport failures and server
+  `EngineBusy` responses are retried (full-jitter exponential backoff) for
+  operations that are safe to repeat. Operator updates and deletes are never
+  retried automatically.
+- **Keepalive.** Idle pooled connections are validated with a `Ping` on
+  checkout and transparently replaced if dead.
+- **Typed error taxonomy.** Non-OK responses raise a specific subclass:
+  `ConflictError` (unique-index violation), `AuthError`, `ServerBusyError`,
+  `InvalidRequestError`, or the base `ServerError` — each carrying the wire
+  `status` byte. Transport problems raise `ConnectionError`.
+- **`Collection` API.** `insert_one/many`, `find`/`find_one`,
+  `update_one/many`, `delete_one/many`, `count_documents`, `distinct`,
+  `create_index`, with `$`-operators, sort, projection, and skip/limit.
+  Pagination is repeatable-read across pages.
+- **Raw KV with TTL.** Side-channel `put` (with `expires_at`), `get`, and `delete` methods on `Client` for session data that needs a time-to-live.
+- **TLS.** Pass `tls=True` for system CA defaults, or an `ssl.SSLContext` for custom roots / verification.
+
+## Optimistic concurrency
+
+```python
+got = users.get_with_revision(uid)
+doc, rev = got
+doc["age"] += 1
+try:
+    users.replace_one_if_match(uid, doc, if_match=rev)
+except ConflictError:
+    pass  # re-read and retry, or merge
+```
+
+Also: `find_with_revision`, `update_by_id_if_match`. Revisions are opaque
+integers. Stale/missing documents raise `ConflictError`. Against an older
+server these methods fail with a protocol error instead of silently becoming
+unconditional writes.
+
+## Durability
+
+Writes are durable (fsync-on-commit) by default. For latency-sensitive,
+loss-tolerant writes, pass `relaxed=True` to acknowledge before the fsync.
+It is available on every write: `insert_one`, `replace_one`, `update_one`,
+`update_many`, `delete_one`, and `delete_many`.
+
+```python
+users.insert_one(doc, relaxed=True)
+users.update_one({"_id": "ada"}, {"$inc": {"hits": 1}}, relaxed=True)
+users.delete_many({"stale": True}, relaxed=True)
+```
+
+## Running the tests
+
+Unit + wire conformance (no server):
+
+```bash
+cd clients/python
+pip install -e ".[dev]"
+pytest tests/test_protocol.py tests/test_conformance.py
+```
+
+Integration tests run against a live server selected by environment variables
+(skipped automatically if it is unreachable):
+
+```bash
+ZYDECODB_TEST_HOST=127.0.0.1 ZYDECODB_TEST_PORT=9470 pytest
+```

zydecodb-0.9.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "zydecodb"
+version = "0.9.0"
+description = "Official Python driver for ZydecoDB."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Dataparade" }]
+keywords = ["zydecodb", "database", "document-store", "nosql"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Database :: Front-Ends",
+]
+# Pure stdlib: no runtime dependencies.
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/dataparade/zydecodb"
+Source = "https://github.com/dataparade/zydecodb"
+
+[tool.hatch.build.targets.wheel]
+packages = ["zydecodb"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

zydecodb-0.9.0/tests/test_conformance.py

@@ -0,0 +1,184 @@
+"""Conformance: the Python codec must match the shared wire vectors byte-for-byte.
+
+The vectors in `clients/conformance/vectors.json` are generated from the Rust
+server encoders (the protocol authority). Running the Python codec against them
+proves it cannot silently drift from the server. See `clients/conformance/README.md`.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from zydecodb import _protocol as proto
+
+VECTORS_PATH = Path(__file__).resolve().parents[2] / "conformance" / "vectors.json"
+
+
+def _load():
+    with VECTORS_PATH.open(encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+VECTORS = _load()
+
+
+def _json_field(s: str):
+    """An opaque pre-serialized JSON field -> the object Python re-serializes to
+    the same bytes (empty string means "absent")."""
+    return None if s == "" else json.loads(s)
+
+
+def _encode_request(kind: str, inp: dict) -> bytes:
+    if kind == "Put":
+        return proto.encode_put(
+            bytes.fromhex(inp["key_hex"]),
+            bytes.fromhex(inp["value_hex"]),
+            expires_at=inp["expires_at"],
+        )
+    if kind == "Get":
+        return proto.encode_key(bytes.fromhex(inp["key_hex"]))
+    if kind == "Del":
+        return proto.encode_key(bytes.fromhex(inp["key_hex"]))
+    if kind == "DocPut":
+        return proto.encode_doc_put(
+            inp["collection"], inp["doc_id"], _json_field(inp["body_json"]),
+            relaxed=inp["relaxed"],
+            expires_at=inp.get("expires_at", 0),
+        )
+    if kind == "DocDel":
+        return proto.encode_doc_del(inp["collection"], inp["doc_id"])
+    if kind == "IndexDef":
+        return proto.encode_index_def(
+            inp["collection"], inp["index_name"], inp["fields"], unique=inp["unique"],
+            expire_after_seconds=inp.get("expire_after_seconds", 0),
+        )
+    if kind == "QueryById":
+        return proto.encode_query_by_id(inp["collection"], inp["doc_id"])
+    if kind == "QueryIndexRange":
+        return proto.encode_query_index_range(
+            inp["collection"], inp["index_name"],
+            lo=_json_field(inp["lo_json"]), hi=_json_field(inp["hi_json"]),
+            page_size=inp["limit"], cursor=bytes.fromhex(inp["cursor_hex"]),
+        )
+    if kind in ("Find", "FindRev"):
+        proj = inp["projection"]
+        mode = {"none": None, "include": proto.PROJ_INCLUDE, "exclude": proto.PROJ_EXCLUDE}[proj["mode"]]
+        projection = None if mode is None else (mode, proj["fields"])
+        return proto.encode_find(
+            inp["collection"], _json_field(inp["filter_json"]),
+            [tuple(s) for s in inp["sort"]], projection,
+            inp["skip"], inp["limit"], bytes.fromhex(inp["cursor_hex"]),
+        )
+    if kind == "DocGetRev":
+        return proto.encode_query_by_id(inp["collection"], inp["doc_id"])
+    if kind == "DocPutIfMatch":
+        return proto.encode_doc_put_if_match(
+            inp["collection"],
+            inp["doc_id"],
+            _json_field(inp["body_json"]),
+            relaxed=inp["relaxed"],
+            if_match=inp["if_match"],
+            expires_at=inp.get("expires_at", 0),
+        )
+    if kind == "DocUpdateIfMatch":
+        return proto.encode_doc_update_if_match(
+            inp["collection"],
+            inp["doc_id"],
+            _json_field(inp["update_json"]),
+            relaxed=inp["relaxed"],
+            if_match=inp["if_match"],
+        )
+    if kind == "Update":
+        return proto.encode_update(
+            inp["collection"], _json_field(inp["filter_json"]),
+            _json_field(inp["update_json"]), multi=inp["multi"], relaxed=inp["relaxed"],
+            upsert=inp.get("upsert", False),
+        )
+    if kind == "Delete":
+        return proto.encode_delete(
+            inp["collection"], _json_field(inp["filter_json"]),
+            multi=inp["multi"], relaxed=inp["relaxed"],
+        )
+    if kind == "Count":
+        return proto.encode_count(inp["collection"], _json_field(inp["filter_json"]))
+    if kind == "Distinct":
+        return proto.encode_distinct(
+            inp["collection"], inp["field"], _json_field(inp["filter_json"])
+        )
+    if kind == "SessionInit":
+        return inp["api_key"].encode("utf-8")
+    if kind == "Ping":
+        return b""
+    raise AssertionError(f"unhandled request kind: {kind}")
+
+
+@pytest.mark.parametrize("vec", VECTORS["requests"], ids=lambda v: v["name"])
+def test_request_payload_matches(vec):
+    payload = _encode_request(vec["kind"], vec["input"])
+    assert payload.hex() == vec["payload_hex"], vec["name"]
+    envelope = proto.encode_header(vec["command"], len(payload)) + payload
+    assert envelope.hex() == vec["envelope_hex"], vec["name"]
+
+
+@pytest.mark.parametrize("vec", VECTORS["responses"], ids=lambda v: v["name"])
+def test_response_decode_matches(vec):
+    kind = vec["kind"]
+    if kind == "QueryPage":
+        rows, cursor = proto.decode_page(bytes.fromhex(vec["bytes_hex"]))
+        expected_rows = vec["decoded"]["rows"]
+        assert len(rows) == len(expected_rows), vec["name"]
+        for (doc_id, body), exp in zip(rows, expected_rows):
+            assert doc_id.decode("utf-8") == exp["doc_id"]
+            assert body.decode("utf-8") == exp["body_json"]
+        expected_cursor = vec["decoded"]["next_cursor_hex"]
+        if expected_cursor is None:
+            assert cursor == b""
+        else:
+            assert cursor.hex() == expected_cursor
+        return
+    if kind == "QueryPageRev":
+        rows, cursor = proto.decode_page_with_revision(
+            bytes.fromhex(vec["bytes_hex"]), with_revision=True
+        )
+        expected_rows = vec["decoded"]["rows"]
+        assert len(rows) == len(expected_rows), vec["name"]
+        for (doc_id, body, rev), exp in zip(rows, expected_rows):
+            assert doc_id.decode("utf-8") == exp["doc_id"]
+            assert body.decode("utf-8") == exp["body_json"]
+            assert rev == exp["revision"]
+        assert cursor == b""
+        return
+    if kind == "DocGetRevResponse":
+        body, rev = proto.decode_doc_get_rev_response(bytes.fromhex(vec["bytes_hex"]))
+        assert body.decode("utf-8") == vec["decoded"]["body_json"]
+        assert rev == vec["decoded"]["revision"]
+        return
+    raise AssertionError(f"unhandled response kind: {kind}")
+
+
+def test_command_codes_match_vectors():
+    cmds = VECTORS["commands"]
+    assert proto.CMD_DOC_PUT == cmds["DocPut"]
+    assert proto.CMD_FIND == cmds["Find"]
+    assert proto.CMD_UPDATE == cmds["Update"]
+    assert proto.CMD_DELETE == cmds["Delete"]
+    assert proto.CMD_COUNT == cmds["Count"]
+    assert proto.CMD_DOC_GET_REV == cmds["DocGetRev"]
+    assert proto.CMD_FIND_REV == cmds["FindRev"]
+    assert proto.CMD_DOC_PUT_IF_MATCH == cmds["DocPutIfMatch"]
+    assert proto.CMD_DOC_UPDATE_IF_MATCH == cmds["DocUpdateIfMatch"]
+    assert proto.CMD_INDEX_DEF == cmds["IndexDef"]
+    assert proto.CMD_SESSION_INIT == cmds["SessionInit"]
+
+
+def test_status_codes_match_vectors():
+    st = VECTORS["statuses"]
+    assert proto.STATUS_OK == st["Ok"]
+    assert proto.STATUS_ENGINE_BUSY == st["EngineBusy"]
+    assert proto.STATUS_POLICY_REJECTED == st["PolicyRejected"]
+    assert proto.STATUS_UNSUPPORTED_FORMAT == st["UnsupportedFormat"]
+    assert proto.STATUS_UNAUTHORIZED == st["Unauthorized"]
+    assert proto.STATUS_FORBIDDEN == st["Forbidden"]

zydecodb-0.9.0/tests/test_live.py

@@ -0,0 +1,140 @@
+"""Integration tests against a live ZydecoDB server.
+
+Set ZYDECODB_TEST_HOST / ZYDECODB_TEST_PORT (and optionally ZYDECODB_TEST_API_KEY)
+to point at a running server. The whole module is skipped when the server is not
+reachable, so a plain `pytest` run stays green offline; CI starts a server first.
+"""
+
+import os
+import socket
+import uuid
+
+import pytest
+
+from zydecodb import Client, ConflictError
+
+HOST = os.environ.get("ZYDECODB_TEST_HOST", "127.0.0.1")
+PORT = int(os.environ.get("ZYDECODB_TEST_PORT", "9470"))
+API_KEY = os.environ.get("ZYDECODB_TEST_API_KEY") or None
+
+
+def _server_up() -> bool:
+    try:
+        with socket.create_connection((HOST, PORT), timeout=1.0):
+            return True
+    except OSError:
+        return False
+
+
+pytestmark = pytest.mark.skipif(
+    not _server_up(), reason=f"no ZydecoDB server at {HOST}:{PORT}"
+)
+
+
+@pytest.fixture()
+def db():
+    client = Client(HOST, PORT, api_key=API_KEY)
+    yield client
+    client.close()
+
+
+@pytest.fixture()
+def coll(db):
+    # A unique collection per test keeps runs isolated.
+    return db.collection(f"pytest_{uuid.uuid4().hex[:12]}")
+
+
+def test_ping(db):
+    db.ping()
+
+
+def test_insert_find_update_delete(coll):
+    coll.create_index(["age"])
+    ids = coll.insert_many(
+        [
+            {"name": "Ada", "age": 30, "city": "London"},
+            {"name": "Bo", "age": 25, "city": "NOLA"},
+            {"name": "Cy", "age": 40, "city": "NOLA"},
+        ]
+    )
+    assert len(ids) == 3
+
+    got = list(coll.find({"age": {"$gte": 30}}, sort=[("age", True)]))
+    assert [d["name"] for d in got] == ["Ada", "Cy"]
+
+    res = coll.update_one({"name": "Bo"}, {"$inc": {"age": 10}})
+    assert res["matched"] == 1 and res["modified"] == 1
+    assert coll.find_one({"name": "Bo"})["age"] == 35
+
+    assert coll.count_documents() == 3
+    assert sorted(coll.distinct("city")) == ["London", "NOLA"]
+
+    assert coll.delete_many({"city": "NOLA"}) == 2
+    assert coll.count_documents() == 1
+
+
+def test_unique_index_conflict(coll):
+    coll.create_index(["email"], unique=True)
+    coll.insert_one({"email": "a@b.com"})
+    with pytest.raises(ConflictError):
+        coll.insert_one({"email": "a@b.com"})
+
+
+def test_pagination_is_stable(coll):
+    coll.create_index(["n"])
+    coll.insert_many([{"n": i} for i in range(25)])
+    seen = [d["n"] for d in coll.find({"n": {"$gte": 0}}, page_size=10)]
+    assert sorted(seen) == list(range(25))
+    assert len(seen) == 25  # no duplicates across pages
+
+
+def test_get_by_id(coll):
+    doc_id = coll.insert_one({"name": "Zee"})
+    fetched = coll.get(doc_id)
+    assert fetched["name"] == "Zee"
+    assert coll.get("does-not-exist") is None
+
+
+def test_upsert_set_on_insert(coll):
+    miss = coll.update_one(
+        {"email": "soi@example.com"},
+        {"$set": {"email": "soi@example.com", "n": 1}, "$setOnInsert": {"created": True}},
+        upsert=True,
+    )
+    assert miss["matched"] == 0 and miss["modified"] == 0
+    assert miss.get("upserted_id")
+    doc = coll.find_one({"email": "soi@example.com"})
+    assert doc["created"] is True
+    assert doc["n"] == 1
+
+    hit = coll.update_one(
+        {"email": "soi@example.com"},
+        {"$set": {"n": 2}, "$setOnInsert": {"created": False, "extra": 1}},
+        upsert=True,
+    )
+    assert hit["matched"] == 1 and hit["modified"] == 1
+    assert "upserted_id" not in hit
+    doc = coll.find_one({"email": "soi@example.com"})
+    assert doc["n"] == 2
+    assert doc["created"] is True
+    assert "extra" not in doc
+
+
+def test_optimistic_concurrency(coll):
+    from zydecodb.errors import ConflictError
+
+    doc_id = coll.insert_one({"n": 1})
+    got = coll.get_with_revision(doc_id)
+    assert got is not None
+    doc, rev = got
+    assert doc["n"] == 1
+    assert rev > 0
+    new_rev = coll.replace_one_if_match(doc_id, {"n": 2}, if_match=rev)
+    assert new_rev > rev
+    try:
+        coll.replace_one_if_match(doc_id, {"n": 3}, if_match=rev)
+        assert False, "expected ConflictError"
+    except ConflictError:
+        pass
+    after = coll.update_by_id_if_match(doc_id, {"$inc": {"n": 1}}, if_match=new_rev)
+    assert after > new_rev