@entifix/testing-unit 0.1.0-0

package/dist/drivers/fake-mongo.js

@@ -0,0 +1,603 @@
+/**
+ * A fake of the mongodb driver, not of the repository port.
+ *
+ * It sits one level *below* `makeMongoRepository`, so the adapter's own code —
+ * the filter translation, the projection, the upsert rule, the error mapping —
+ * actually runs and is measured by coverage. A fake at the port level would
+ * skip all of it.
+ *
+ * Only the surface the adapter uses is implemented; anything else is a
+ * deliberate `TypeError` rather than a silent no-op.
+ */ /** The subset of a Mongo query document the adapter produces. */ import { _ as _extends } from "@swc/helpers/_/_extends";
+const isPlainObject = (value)=>typeof value === 'object' && value !== null && !Array.isArray(value);
+const compare = (left, right)=>{
+    if (left == null && right == null) return 0;
+    if (left == null) return -1;
+    if (right == null) return 1;
+    if (typeof left === 'number' && typeof right === 'number') return left - right;
+    if (left instanceof Date && right instanceof Date) {
+        return left.getTime() - right.getTime();
+    }
+    return String(left).localeCompare(String(right));
+};
+/** Evaluates one `{ $op: value }` condition against a document field. */ const matchesCondition = (actual, condition)=>{
+    if (!isPlainObject(condition)) {
+        return actual === condition;
+    }
+    return Object.entries(condition).every(([operator, operand])=>{
+        switch(operator){
+            case '$eq':
+                return actual === operand;
+            case '$ne':
+                return actual !== operand;
+            case '$gt':
+                return compare(actual, operand) > 0;
+            case '$gte':
+                return compare(actual, operand) >= 0;
+            case '$lt':
+                return compare(actual, operand) < 0;
+            case '$lte':
+                return compare(actual, operand) <= 0;
+            case '$in':
+                return operand.includes(actual);
+            // Absence, not falsiness. A settlement ledger keys "unpaid" on a `runId`
+            // that is not there at all, and `undefined` is what a document without
+            // the field reads as — so `{ $exists: false }` must be a different test
+            // from `{ $eq: undefined }` would be if the serializer ever wrote one.
+            case '$exists':
+                return actual !== undefined === operand;
+            case '$nin':
+                return !operand.includes(actual);
+            case '$not':
+                return !matchesCondition(actual, operand);
+            case '$regex':
+                var _condition_$options;
+                return new RegExp(operand, (_condition_$options = condition['$options']) != null ? _condition_$options : '').test(String(actual));
+            case '$options':
+                // Handled together with `$regex`.
+                return true;
+            default:
+                throw new TypeError(`fake mongo: unsupported operator "${operator}"`);
+        }
+    });
+};
+/**
+ * Evaluates one node of an aggregation expression — the `$expr` half of a
+ * query, which is a different language from the operators above: it compares
+ * two *fields of the same document* rather than a field against a constant.
+ *
+ * Only the shape a conditional stock write sends is implemented — a
+ * `$subtract` of two field paths compared with `$gte` — and anything else is a
+ * `TypeError`. That is the same rule the rest of this file follows: a fake that
+ * quietly evaluated an expression it does not understand would answer `true`
+ * for a document the real server would have refused, which turns an
+ * oversell-prevention test into a test that asserts nothing.
+ */ const evaluateExpression = (doc, node)=>{
+    if (typeof node === 'string' && node.startsWith('$')) {
+        return doc[node.slice(1)];
+    }
+    if (!isPlainObject(node)) {
+        return node;
+    }
+    const entries = Object.entries(node);
+    if (entries.length !== 1) {
+        throw new TypeError(`fake mongo: $expr node must have exactly one operator, got ${entries.length}`);
+    }
+    const [operator, operand] = entries[0];
+    const operands = operand.map((child)=>evaluateExpression(doc, child));
+    switch(operator){
+        case '$subtract':
+            return operands[0] - operands[1];
+        case '$add':
+            return operands[0] + operands[1];
+        case '$gte':
+            return compare(operands[0], operands[1]) >= 0;
+        case '$gt':
+            return compare(operands[0], operands[1]) > 0;
+        case '$lte':
+            return compare(operands[0], operands[1]) <= 0;
+        case '$lt':
+            return compare(operands[0], operands[1]) < 0;
+        case '$eq':
+            return operands[0] === operands[1];
+        default:
+            throw new TypeError(`fake mongo: unsupported $expr operator "${operator}"`);
+    }
+};
+/**
+ * Every value a field path names, the way the server reads one.
+ *
+ * A dotted path descends, and **an array on the way down is walked
+ * element-wise** — which is what makes `{'items.vendorId': x}` match an order
+ * with a line for that vendor rather than nothing at all. Without it a query
+ * into an embedded collection silently answers empty here while working against
+ * a real server, which is worse than an unsupported-operator throw: the spec
+ * passes and asserts the opposite of what it claims.
+ *
+ * The array itself is kept as a candidate beside its elements, because the
+ * server matches both — `{ tags: 'a' }` matches `{ tags: ['a'] }` and
+ * `{ tags: 'a' }` alike.
+ */ const valuesAt = (doc, field)=>{
+    let current = [
+        doc
+    ];
+    for (const segment of field.split('.')){
+        const next = [];
+        for (const value of current){
+            const container = Array.isArray(value) ? value : [
+                value
+            ];
+            for (const element of container){
+                if (isPlainObject(element)) {
+                    next.push(element[segment]);
+                }
+            }
+        }
+        current = next;
+    }
+    return current.flatMap((value)=>Array.isArray(value) ? [
+            value,
+            ...value
+        ] : [
+            value
+        ]);
+};
+/** Operators that exclude a document when a single value matches them. */ const NEGATIVE_OPERATORS = new Set([
+    '$ne',
+    '$nin',
+    '$not'
+]);
+const isNegativeCondition = (condition)=>isPlainObject(condition) && Object.keys(condition).some((operator)=>NEGATIVE_OPERATORS.has(operator));
+const matches = (doc, query)=>Object.entries(query).every(([field, condition])=>{
+        if (field === '$and') {
+            return condition.every((child)=>matches(doc, child));
+        }
+        if (field === '$or') {
+            return condition.some((child)=>matches(doc, child));
+        }
+        if (field === '$expr') {
+            return evaluateExpression(doc, condition) === true;
+        }
+        const candidates = valuesAt(doc, field);
+        if (candidates.length === 0) {
+            return matchesCondition(undefined, condition);
+        }
+        // A positive condition matches when **any** value at the path satisfies it;
+        // a negative one only when **every** value does. That asymmetry is the
+        // server's: `{ 'items.vendorId': { $ne: 'a' } }` must exclude an order that
+        // has a line for `a`, not include it because some other line differs.
+        return isNegativeCondition(condition) ? candidates.every((value)=>matchesCondition(value, condition)) : candidates.some((value)=>matchesCondition(value, condition));
+    });
+/**
+ * The error a real server raises when a write violates a unique index.
+ *
+ * The `code` matters and the message does not: callers recognise a duplicate
+ * key by `error.code === 11000` (or the same code inside `writeErrors`), and a
+ * fake that threw a plain `Error` would send a retry path that exists precisely
+ * for this case down the "unexpected failure" branch instead.
+ */ let FakeDuplicateKeyError = class FakeDuplicateKeyError extends Error {
+    constructor(collection, key){
+        super(`fake mongo: E11000 duplicate key error collection: ${collection} dup key: ${JSON.stringify(key)}`), this.code = 11000;
+        this.name = 'MongoServerError';
+    }
+};
+/**
+ * Builds an in-memory stand-in for a mongodb `Db`.
+ *
+ * `db` is typed `unknown` on purpose: casting it at the call site keeps this
+ * package free of a hard dependency on the `mongodb` types while remaining
+ * honest that it is not a real driver.
+ */ export const makeFakeMongoDb = (seed = {})=>{
+    const collections = new Map(Object.entries(seed).map(([name, docs])=>[
+            name,
+            docs.map((d)=>_extends({}, d))
+        ]));
+    const operations = [];
+    let failure;
+    const failuresByOperation = new Map();
+    const documentsOf = (name)=>{
+        if (!collections.has(name)) collections.set(name, []);
+        return collections.get(name);
+    };
+    /**
+   * The unique indexes `createIndex` has been asked for, per collection, as the
+   * field lists they key on.
+   *
+   * Recording them is not bookkeeping: `updateOne` with `upsert` is atomic per
+   * *document*, so two concurrent upserts for the same key each fail to see the
+   * other's uncommitted insert and each create a row. The index is what makes
+   * the fold singular, and a fake that accepted `createIndex` as a no-op would
+   * report a service as covered while the property the index exists for went
+   * untested (ADR 0010).
+   */ const uniqueIndexes = new Map();
+    const uniqueIndexesOf = (name)=>{
+        var _uniqueIndexes_get;
+        return (_uniqueIndexes_get = uniqueIndexes.get(name)) != null ? _uniqueIndexes_get : [];
+    };
+    /**
+   * Refuses `candidate` if it would duplicate an existing document under one of
+   * the collection's unique indexes.
+   *
+   * `ignored` is the document being replaced by an update, which must not count
+   * as its own duplicate. A key whose value is `undefined` on the candidate is
+   * skipped: a real index treats a missing field as `null` and would collide,
+   * but nothing in this repo indexes an optional member, and guessing wrong
+   * here would fail writes the server accepts.
+   */ const assertUnique = (name, candidate, ignored)=>{
+        for (const fields of uniqueIndexesOf(name)){
+            if (fields.some((field)=>candidate[field] === undefined)) continue;
+            const clash = documentsOf(name).find((doc)=>doc !== ignored && fields.every((field)=>doc[field] === candidate[field]));
+            if (clash !== undefined) {
+                throw new FakeDuplicateKeyError(name, Object.fromEntries(fields.map((field)=>[
+                        field,
+                        candidate[field]
+                    ])));
+            }
+        }
+    };
+    const record = (name, op, produce)=>{
+        operations.push({
+            collection: name,
+            op
+        });
+        const scoped = failuresByOperation.get(op);
+        if (scoped !== undefined) return Promise.reject(scoped);
+        if (failure !== undefined) return Promise.reject(failure);
+        // `try`/`catch` rather than `Promise.resolve(produce())`: a real driver
+        // returns a promise and *rejects*, so a fake that threw synchronously would
+        // need different handling at every call site than the thing it stands in for.
+        try {
+            return Promise.resolve(produce());
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    };
+    /** Applies `{ projection: { _id: 0 } }`, the only projection the adapter uses. */ const project = (doc, options)=>{
+        const copy = _extends({}, doc);
+        if ((options == null ? void 0 : options.projection) && options.projection['_id'] === 0) {
+            delete copy['_id'];
+        }
+        return copy;
+    };
+    const collection = (name)=>({
+            find: (query = {}, options)=>{
+                let sortSpec = {};
+                let skipCount = 0;
+                let limitCount = Infinity;
+                const cursor = {
+                    sort (spec) {
+                        sortSpec = spec;
+                        return cursor;
+                    },
+                    skip (count) {
+                        skipCount = count;
+                        return cursor;
+                    },
+                    limit (count) {
+                        limitCount = count;
+                        return cursor;
+                    },
+                    toArray: ()=>record(name, 'find', ()=>{
+                            const matched = documentsOf(name).filter((doc)=>matches(doc, query));
+                            const sorted = Object.entries(sortSpec).reduceRight((items, [field, direction])=>[
+                                    ...items
+                                ].sort((left, right)=>compare(left[field], right[field]) * direction), matched);
+                            return sorted.slice(skipCount, skipCount + limitCount).map((doc)=>project(doc, options));
+                        })
+                };
+                return cursor;
+            },
+            findOne: (query, options)=>record(name, 'findOne', ()=>{
+                    const found = documentsOf(name).find((doc)=>matches(doc, query));
+                    return found === undefined ? null : project(found, options);
+                }),
+            countDocuments: (query = {})=>record(name, 'countDocuments', ()=>documentsOf(name).filter((doc)=>matches(doc, query)).length),
+            // Used by the services' own seeding, which the e2e `mock` profile runs for
+            // real so both profiles serve the same catalog.
+            insertMany: (documents)=>record(name, 'insertMany', ()=>{
+                    const stored = documentsOf(name);
+                    for (const document of documents){
+                        assertUnique(name, document);
+                        stored.push(_extends({}, document));
+                    }
+                    return {
+                        insertedCount: documents.length
+                    };
+                }),
+            /**
+     * A single insert — how an append-only ledger grows, and how a hold is
+     * written beside the counter it moved.
+     *
+     * The options argument is accepted and ignored except for its `session`,
+     * which the transaction wrapper already handles: a caller that passes one
+     * is inside `withTransaction`, and this fake's rollback is a snapshot of
+     * the whole store rather than anything per-operation.
+     */ insertOne: (document)=>record(name, 'insertOne', ()=>{
+                    var _document_id;
+                    assertUnique(name, document);
+                    documentsOf(name).push(_extends({}, document));
+                    return {
+                        acknowledged: true,
+                        insertedId: (_document_id = document['id']) != null ? _document_id : null
+                    };
+                }),
+            replaceOne: (query, replacement, options)=>record(name, 'replaceOne', ()=>{
+                    const documents = documentsOf(name);
+                    const index = documents.findIndex((doc)=>matches(doc, query));
+                    if (index === -1) {
+                        if (!(options == null ? void 0 : options.upsert)) return {
+                            matchedCount: 0,
+                            upsertedCount: 0
+                        };
+                        documents.push(_extends({}, replacement));
+                        return {
+                            matchedCount: 0,
+                            upsertedCount: 1
+                        };
+                    }
+                    documents[index] = _extends({}, replacement);
+                    return {
+                        matchedCount: 1,
+                        upsertedCount: 0
+                    };
+                }),
+            /**
+     * Partial update. `$set`, `$addToSet`, `$inc` and `$setOnInsert` are
+     * implemented — the operators the adapters and the stock ledger use — and
+     * **anything else throws**, because a fake that silently accepted `$unset`
+     * without applying it would let a spec pass on an update that never
+     * happened.
+     *
+     * `$addToSet` is what links an identifier onto `user-identity.identifiers`
+     * without duplicating it on a repair run; supporting it here rather than
+     * ignoring it is the difference between the e2e proving the link and merely
+     * not noticing its absence.
+     *
+     * `$inc` with `upsert` is how a quantity moves. It matters that it is a
+     * real increment and not a read-modify-write even here: the whole rule it
+     * implements is that an absolute-value write loses updates, so a fake that
+     * computed the new total from a value it had already read would model the
+     * bug rather than the fix.
+     */ updateOne: (query, update, options)=>record(name, 'updateOne', ()=>{
+                    var _update_$setOnInsert;
+                    const supported = [
+                        '$set',
+                        '$addToSet',
+                        '$inc',
+                        '$setOnInsert'
+                    ];
+                    const unsupported = Object.keys(update).filter((operator)=>!supported.includes(operator));
+                    if (unsupported.length > 0) {
+                        throw new Error(`fake-mongo: updateOne does not implement ${unsupported.join(', ')}`);
+                    }
+                    // A real server rejects an update whose operators both name one field,
+                    // and the message is the one this repro'd against: `$setOnInsert` that
+                    // also named a field `$inc` touches. Reproducing the refusal is what
+                    // keeps the fake from blessing an update Mongo would refuse.
+                    const conflicting = Object.keys((_update_$setOnInsert = update.$setOnInsert) != null ? _update_$setOnInsert : {}).filter((field)=>{
+                        var _update_$inc, _update_$set;
+                        return field in ((_update_$inc = update.$inc) != null ? _update_$inc : {}) || field in ((_update_$set = update.$set) != null ? _update_$set : {});
+                    });
+                    if (conflicting.length > 0) {
+                        throw new Error(`fake-mongo: updateOne has conflicting paths in $setOnInsert and $inc/$set: ${conflicting.join(', ')}`);
+                    }
+                    /** `$set`, `$addToSet` and `$inc`, which apply on both branches. */ const applyOperators = (base)=>{
+                        var _update_$set, _update_$addToSet, _update_$inc;
+                        const updated = _extends({}, base, (_update_$set = update.$set) != null ? _update_$set : {});
+                        for (const [field, value] of Object.entries((_update_$addToSet = update.$addToSet) != null ? _update_$addToSet : {})){
+                            const current = updated[field];
+                            const array = Array.isArray(current) ? current : [];
+                            if (!array.includes(value)) {
+                                updated[field] = [
+                                    ...array,
+                                    value
+                                ];
+                            }
+                        }
+                        for (const [field, delta] of Object.entries((_update_$inc = update.$inc) != null ? _update_$inc : {})){
+                            // An absent field is created at the increment's value, which is
+                            // exactly why `$setOnInsert` must not also name it.
+                            const current = updated[field];
+                            updated[field] = (typeof current === 'number' ? current : 0) + delta;
+                        }
+                        return updated;
+                    };
+                    const documents = documentsOf(name);
+                    const index = documents.findIndex((doc)=>matches(doc, query));
+                    if (index === -1) {
+                        var _update_$setOnInsert1;
+                        if ((options == null ? void 0 : options.upsert) !== true) {
+                            return {
+                                matchedCount: 0,
+                                modifiedCount: 0,
+                                upsertedCount: 0
+                            };
+                        }
+                        // The upserted document starts from the query's *equality* fields,
+                        // the way a real server seeds one — an operator condition contributes
+                        // nothing, which is why a `$expr`-guarded upsert would insert a row
+                        // missing the very field it filtered on.
+                        const seedFields = Object.fromEntries(Object.entries(query).filter(([field, condition])=>!field.startsWith('$') && !isPlainObject(condition)));
+                        const inserted = applyOperators(_extends({}, seedFields, (_update_$setOnInsert1 = update.$setOnInsert) != null ? _update_$setOnInsert1 : {}));
+                        assertUnique(name, inserted);
+                        documents.push(inserted);
+                        return {
+                            matchedCount: 0,
+                            modifiedCount: 0,
+                            upsertedCount: 1
+                        };
+                    }
+                    const updated = applyOperators(documents[index]);
+                    assertUnique(name, updated, documents[index]);
+                    documents[index] = updated;
+                    return {
+                        matchedCount: 1,
+                        modifiedCount: 1,
+                        upsertedCount: 0
+                    };
+                }),
+            /**
+     * `$set` across every matching document, and the count of what changed.
+     *
+     * ⚠️ **The count is what a caller branches on.** A settlement run claims its
+     * ledger lines with this and reads `modifiedCount === 0` as "another replica
+     * took them all" — so a fake returning a fixed `1`, or the match count
+     * rather than the modified count, would make the losing replica behave like
+     * the winning one and the conditional claim would test nothing.
+     *
+     * `$set` only. Anything else throws, for the reason `updateOne` gives:
+     * silently accepting an operator it does not apply lets a spec pass on an
+     * update that never happened.
+     */ updateMany: (query, update)=>record(name, 'updateMany', ()=>{
+                    const unsupported = Object.keys(update).filter((operator)=>operator !== '$set');
+                    if (unsupported.length > 0) {
+                        throw new Error(`fake-mongo: updateMany does not implement ${unsupported.join(', ')}`);
+                    }
+                    const documents = documentsOf(name);
+                    let modifiedCount = 0;
+                    documents.forEach((doc, index)=>{
+                        var _update_$set;
+                        if (!matches(doc, query)) return;
+                        const updated = _extends({}, doc, (_update_$set = update.$set) != null ? _update_$set : {});
+                        assertUnique(name, updated, doc);
+                        documents[index] = updated;
+                        modifiedCount += 1;
+                    });
+                    return {
+                        matchedCount: modifiedCount,
+                        modifiedCount
+                    };
+                }),
+            /**
+     * Update one document and hand back the result, upserting when asked.
+     *
+     * ⚠️ **`returnDocument: 'after'` is the only mode implemented, and the
+     * default here is `'after'` rather than the driver's `'before'`** — because
+     * the callers that need this primitive at all need the merged document. A
+     * two-message join upserts its own half and then asks "is the pair complete
+     * now?", which is a question only the *after* state answers. `'before'`
+     * throws rather than quietly returning the wrong half.
+     *
+     * Implemented over {@link updateOne} so the upsert seeding rule, the
+     * conflicting-path refusal and the unique-index enforcement are the same
+     * ones, rather than a second copy that could drift from them.
+     */ findOneAndUpdate: (query, update, options)=>record(name, 'findOneAndUpdate', async ()=>{
+                    if ((options == null ? void 0 : options.returnDocument) === 'before') {
+                        throw new Error('fake-mongo: findOneAndUpdate only implements returnDocument: "after"');
+                    }
+                    // Where the document is *before* the write, because afterwards the
+                    // query may no longer find it: an upsert's operator conditions need not
+                    // hold of the row it just inserted — `{ folded: { $exists: false } }`
+                    // matches nothing once `folded` has been set. `documentsOf` hands back
+                    // the live array, which `updateOne` mutates in place or pushes onto, so
+                    // the position is enough to identify it either way.
+                    const documents = documentsOf(name);
+                    const index = documents.findIndex((doc)=>matches(doc, query));
+                    const result = await collection(name).updateOne(query, update, {
+                        upsert: (options == null ? void 0 : options.upsert) === true
+                    });
+                    if (result.matchedCount === 0 && result.upsertedCount === 0) {
+                        return null;
+                    }
+                    return index === -1 ? documents[documents.length - 1] : documents[index];
+                }),
+            deleteOne: (query)=>record(name, 'deleteOne', ()=>{
+                    const documents = documentsOf(name);
+                    const index = documents.findIndex((doc)=>matches(doc, query));
+                    if (index === -1) return {
+                        deletedCount: 0
+                    };
+                    documents.splice(index, 1);
+                    return {
+                        deletedCount: 1
+                    };
+                }),
+            /**
+     * Declares an index, and **enforces it when it is unique**.
+     *
+     * Idempotent, like the real one: a service that ensures its index per
+     * request rather than at boot — because a tenant database only appears on
+     * first write — calls this on every write.
+     */ createIndex: (spec, options)=>record(name, 'createIndex', ()=>{
+                    if ((options == null ? void 0 : options['unique']) === true) {
+                        var _uniqueIndexes_get;
+                        const fields = Object.keys(spec);
+                        const existing = (_uniqueIndexes_get = uniqueIndexes.get(name)) != null ? _uniqueIndexes_get : [];
+                        const already = existing.some((candidate)=>candidate.length === fields.length && candidate.every((field, at)=>field === fields[at]));
+                        if (!already) {
+                            uniqueIndexes.set(name, [
+                                ...existing,
+                                fields
+                            ]);
+                        }
+                    }
+                    return {
+                        spec,
+                        options
+                    };
+                })
+        });
+    /**
+   * A session whose `withTransaction` really rolls back.
+   *
+   * ⚠️ **It is atomicity, not isolation, and the difference decides where a
+   * test may live.** The store is a single-threaded object graph, so nothing
+   * runs concurrently with the body and a "race" here resolves in the order it
+   * was written: a concurrency property — two writers contending for the last
+   * unit — is green under this fake no matter what the code does, and belongs
+   * in a `*.live.spec.ts` against real Mongo (ADR 0010).
+   *
+   * What it *does* model is the abort path, which is worth having: a body that
+   * throws leaves the store exactly as it found it, so a conditional write that
+   * moves a counter and then fails to write its row cannot leave the counter
+   * moved. That is a real bug shape, and one a fake without rollback would hide
+   * by committing half of it.
+   */ const startSession = ()=>{
+        let open = true;
+        return {
+            withTransaction: async (body)=>{
+                const snapshot = new Map([
+                    ...collections
+                ].map(([name, docs])=>[
+                        name,
+                        docs.map((doc)=>_extends({}, doc))
+                    ]));
+                try {
+                    return await body();
+                } catch (error) {
+                    collections.clear();
+                    for (const [name, docs] of snapshot)collections.set(name, docs);
+                    throw error;
+                }
+            },
+            endSession: ()=>{
+                open = false;
+                return Promise.resolve();
+            },
+            get hasEnded () {
+                return !open;
+            }
+        };
+    };
+    return {
+        seed: (name, documents)=>{
+            collections.set(name, documents.map((doc)=>_extends({}, doc)));
+        },
+        read: (name)=>documentsOf(name).map((doc)=>_extends({}, doc)),
+        failWith: (error)=>{
+            failure = error;
+        },
+        failOn: (operation, error)=>{
+            failuresByOperation.set(operation, error);
+        },
+        get operations () {
+            return operations;
+        },
+        startSession,
+        db: {
+            collection
+        }
+    };
+};
+
+//# sourceMappingURL=fake-mongo.js.map