@sprucelabs/data-stores 19.1.67 → 19.2.0

package/build/tests/databaseAssertUtil.js

@@ -0,0 +1,1199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const test_utils_2 = require("@sprucelabs/test-utils");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const generateId_1 = __importDefault(require("../utilities/generateId"));
+const pluckAssertionMethods_1 = __importDefault(require("./pluckAssertionMethods"));
+const databaseAssertUtil = {
+    collectionName: 'test_collection',
+    async runSuite(connect) {
+        (0, schema_1.assertOptions)({ connect }, ['connect']);
+        const methods = (0, pluckAssertionMethods_1.default)(this);
+        //@ts-ignore
+        await Promise.all(methods.map((method) => this[method](connect)));
+    },
+    async _getFilteredIndexes(db) {
+        return this._filterIdIndex(await db.getIndexes(this.collectionName));
+    },
+    _filterIdIndex(allIndexes) {
+        return allIndexes.filter((i) => i[0] !== '_id');
+    },
+    async _assertUpdateUpdatedRightNumberOfRecords(db, search, updates, expectedUpdateCount) {
+        const updatedCount = await db.update(this.collectionName, search, updates);
+        test_utils_1.assert.isEqual(updatedCount, expectedUpdateCount);
+        const count = await db.count(this.collectionName, updates);
+        test_utils_1.assert.isEqual(count, expectedUpdateCount);
+    },
+    async assertCanSortDesc(connect) {
+        const db = await connect();
+        await db.createOne(this.collectionName, { name: 'second', count: 1 });
+        await db.createOne(this.collectionName, { name: 'third', count: 5 });
+        await db.createOne(this.collectionName, { name: 'first', count: -1 });
+        const results = await db.find(this.collectionName, {}, {
+            sort: [
+                {
+                    field: 'count',
+                    direction: 'desc',
+                },
+            ],
+        });
+        test_utils_1.assert.isEqual(results[0].name, 'third');
+        test_utils_1.assert.isEqual(results[1].name, 'second');
+        test_utils_1.assert.isEqual(results[2].name, 'first');
+        const result = await db.findOne(this.collectionName, undefined, {
+            sort: [{ field: 'count', direction: 'desc' }],
+        });
+        test_utils_1.assert.isTruthy(result);
+        test_utils_1.assert.isEqual(result.name, 'third');
+        await this.shutdown(db);
+    },
+    async assertCanSortAsc(connect) {
+        const db = await connect();
+        await db.createOne(this.collectionName, { name: 'second', count: 1 });
+        await db.createOne(this.collectionName, { name: 'third', count: 5 });
+        await db.createOne(this.collectionName, { name: 'first', count: -1 });
+        const results = await db.find(this.collectionName, {}, {
+            sort: [
+                {
+                    field: 'count',
+                    direction: 'asc',
+                },
+            ],
+        });
+        test_utils_1.assert.isEqual(results[0].name, 'first');
+        test_utils_1.assert.isEqual(results[1].name, 'second');
+        test_utils_1.assert.isEqual(results[2].name, 'third');
+        const result = await db.findOne(this.collectionName, undefined, {
+            sort: [{ field: 'count', direction: 'asc' }],
+        });
+        test_utils_1.assert.isTruthy(result);
+        test_utils_1.assert.isEqual(result.name, 'first');
+        await this.shutdown(db);
+    },
+    async assertInsertingGeneratesId(connect) {
+        const db = await connect();
+        const inserted = await db.createOne(this.collectionName, {
+            name: 'first',
+        });
+        test_utils_1.assert.isTruthy(inserted);
+        test_utils_1.assert.isString(inserted.id);
+        test_utils_1.assert.isEqual(inserted.name, 'first');
+        await this.shutdown(db);
+    },
+    async assertThrowsWhenUpdatingRecordNotFound(connect) {
+        const db = await connect();
+        const err = (await test_utils_1.assert.doesThrowAsync(() => db.updateOne('unknown', { id: db.generateId() }, { foo: 'bar' })));
+        test_utils_2.errorAssert.assertError(err, 'RECORD_NOT_FOUND');
+        await this.shutdown(db);
+    },
+    async shutdown(db) {
+        await db.dropDatabase();
+        await db.close();
+    },
+    async assertCanCreateUniqueIndex(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['uniqueField']);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isLength(indexes[0], 1);
+        test_utils_1.assert.isEqual(indexes[0][0], 'uniqueField');
+        await db.createUniqueIndex(this.collectionName, ['uniqueField2']);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 2);
+        test_utils_1.assert.isEqual(indexes[1][0], 'uniqueField2');
+        await db.createUniqueIndex(this.collectionName, [
+            'uniqueField3',
+            'uniqueField4',
+        ]);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 3);
+        test_utils_1.assert.isEqual(indexes[2][0], 'uniqueField3');
+        test_utils_1.assert.isEqual(indexes[2][1], 'uniqueField4');
+        await this.shutdown(db);
+    },
+    async assertHasNoUniqueIndexToStart(connect) {
+        const db = await connect();
+        const indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 0);
+        await this.shutdown(db);
+    },
+    async assertCanShutdown(connect) {
+        const db = await connect();
+        const id = db.generateId();
+        const created = await db.upsertOne(this.collectionName, { id }, {
+            id,
+            name: 'first',
+        });
+        test_utils_1.assert.isTruthy(created);
+        test_utils_1.assert.isEqual(created.name, 'first');
+        test_utils_1.assert.isEqual(created.id, id);
+        const upserted = await db.upsertOne(this.collectionName, { id }, { name: 'second' });
+        await db.upsertOne(this.collectionName, { id: db.generateId() }, { name: 'second' });
+        test_utils_1.assert.isTruthy(upserted);
+        test_utils_1.assert.isEqual(created.id, upserted.id);
+        test_utils_1.assert.isEqual(upserted.name, 'second');
+        const upserted2 = await db.upsertOne(this.collectionName, { id }, { name: 'third' });
+        test_utils_1.assert.isTruthy(upserted2);
+        test_utils_1.assert.isEqual(upserted2.name, 'third');
+        await this.shutdown(db);
+    },
+    async assertCanDeleteOne(connect) {
+        const db = await connect();
+        await db.create(this.collectionName, [
+            {
+                name: 'a record',
+            },
+            {
+                name: 'a record',
+            },
+            {
+                name: 'a record',
+            },
+        ]);
+        await db.deleteOne(this.collectionName, { name: 'a record' });
+        const count = await db.count(this.collectionName);
+        test_utils_1.assert.isEqual(count, 2);
+        await this.shutdown(db);
+    },
+    async assertCanDeleteRecord(connect) {
+        const db = await connect();
+        const created = await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'first',
+        });
+        const matchedBeforeDelete = await db.findOne(this.collectionName, {
+            id: created.id,
+        });
+        test_utils_1.assert.isTruthy(matchedBeforeDelete);
+        test_utils_1.assert.isEqual(matchedBeforeDelete.id, created.id);
+        const numDeleted = await db.delete(this.collectionName, {
+            id: matchedBeforeDelete.id,
+        });
+        test_utils_1.assert.isEqual(numDeleted, 1);
+        const matchedAfterDelete = await db.findOne(this.collectionName, {
+            id: created.id,
+        });
+        test_utils_1.assert.isFalsy(matchedAfterDelete);
+        await db.create(this.collectionName, [
+            {
+                name: 'a record',
+            },
+            {
+                name: 'a record',
+            },
+            {
+                name: 'a record',
+            },
+        ]);
+        const manyDeleted = await db.delete(this.collectionName, {});
+        test_utils_1.assert.isEqual(manyDeleted, 3);
+        await this.shutdown(db);
+    },
+    async assertCanLimitResultsToZero(connect) {
+        const db = await connect();
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'first',
+        });
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'second',
+        });
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'third',
+        });
+        const results = await db.find(this.collectionName, undefined, {
+            limit: 0,
+            sort: [{ field: 'name', direction: 'asc' }],
+        });
+        test_utils_1.assert.isLength(results, 0);
+        await this.shutdown(db);
+    },
+    async assertCanLimitResults(connect) {
+        const db = await connect();
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'first',
+        });
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'second',
+        });
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'third',
+        });
+        const results = await db.find(this.collectionName, undefined, {
+            limit: 2,
+            sort: [{ field: 'name', direction: 'asc' }],
+        });
+        test_utils_1.assert.isLength(results, 2);
+        test_utils_1.assert.isEqual(results[0].name, 'first');
+        test_utils_1.assert.isEqual(results[1].name, 'second');
+        await this.shutdown(db);
+    },
+    async assertFindOneOnEmptyDatabaseReturnsNull(connect) {
+        const db = await connect();
+        const results = await db.findOne(this.collectionName, { id: '111' });
+        test_utils_1.assert.isFalsy(results);
+        await this.shutdown(db);
+    },
+    async assertEmptyDatabaseReturnsEmptyArray(connect) {
+        const db = await connect();
+        const results = await db.find(this.collectionName, { id: '111' });
+        test_utils_1.assert.isLength(results, 0);
+        await this.shutdown(db);
+    },
+    async assertCanPushOntoArrayValue(connect) {
+        const db = await connect();
+        const inserted = await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            names: ['first'],
+        });
+        const updated = await db.updateOne(this.collectionName, { id: inserted.id }, {
+            $push: { names: 'second' },
+        });
+        test_utils_1.assert.isEqualDeep(updated.names, ['first', 'second']);
+        const matched = await db.findOne(this.collectionName, { id: updated.id });
+        test_utils_1.assert.isTruthy(matched);
+        test_utils_1.assert.isEqualDeep(matched.names, ['first', 'second']);
+        await this.shutdown(db);
+    },
+    async assertCanCreateMany(connect) {
+        const db = await connect();
+        const values = [
+            { first: 'ry' },
+            { first: 'tay' },
+            { first: 'bill' },
+            { first: 'bob' },
+        ];
+        const results = await db.create(this.collectionName, values);
+        test_utils_1.assert.isLength(results, values.length);
+        for (const val of values) {
+            test_utils_1.assert.doesInclude(results, val);
+        }
+        await this.shutdown(db);
+    },
+    async assertCanUpdateMany(connect) {
+        const db = await connect();
+        await db.create(this.collectionName, [
+            {
+                name: 'one',
+                number: 1,
+            },
+            {
+                name: 'two',
+                number: 1,
+            },
+            {
+                name: 'three',
+                number: 1,
+            },
+        ]);
+        await this._assertUpdateUpdatedRightNumberOfRecords(db, { name: 'one' }, { name: 'one-updated' }, 1);
+        await this._assertUpdateUpdatedRightNumberOfRecords(db, { number: 1 }, { number: 2 }, 3);
+        await this.shutdown(db);
+    },
+    async assertCanQueryWithOr(connect) {
+        const db = await connect();
+        const id1 = (0, generateId_1.default)();
+        const id2 = (0, generateId_1.default)();
+        await db.create(this.collectionName, [
+            {
+                isPublic: true,
+                id: id1,
+            },
+            {
+                id: id2,
+            },
+        ]);
+        const matches = await db.find(this.collectionName, {
+            $or: [{ isPublic: true }, { id: id2 }],
+        });
+        test_utils_1.assert.isLength(matches, 2);
+        await this.shutdown(db);
+    },
+    async assertCanUpdate(connect) {
+        const db = await connect();
+        const inserted = await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'first',
+        });
+        test_utils_1.assert.isString(inserted.id);
+        test_utils_1.assert.isEqual(inserted.name, 'first');
+        const updated = await db.updateOne(this.collectionName, { id: inserted.id }, {
+            name: 'updated',
+        });
+        test_utils_1.assert.isEqual(updated.id, inserted.id);
+        test_utils_1.assert.isEqual(updated.name, 'updated');
+        await this.shutdown(db);
+    },
+    async assertCanSortById(connect) {
+        const db = await connect();
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'first',
+        });
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'second',
+        });
+        await db.createOne(this.collectionName, {
+            id: db.generateId(),
+            name: 'third',
+        });
+        const results = await db.find(this.collectionName, {}, {
+            sort: [
+                {
+                    field: 'id',
+                    direction: 'desc',
+                },
+            ],
+        });
+        test_utils_1.assert.isEqual(results[0].name, 'third');
+        test_utils_1.assert.isEqual(results[1].name, 'second');
+        test_utils_1.assert.isEqual(results[2].name, 'first');
+        const result = await db.findOne(this.collectionName, undefined, {
+            sort: [{ field: 'id', direction: 'desc' }],
+        });
+        test_utils_1.assert.isTruthy(result);
+        test_utils_1.assert.isEqual(result.name, 'third');
+        await this.shutdown(db);
+    },
+    async assertCanCreateMultiFieldUniqueIndex(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, [
+            'uniqueField',
+            'uniqueField2',
+        ]);
+        await db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            uniqueField2: 'hello again',
+        });
+        await db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            uniqueField2: 'unique',
+        });
+        let err = (await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            uniqueField2: 'unique',
+        })));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['uniqueField', 'uniqueField2'],
+            duplicateValues: ['hello world', 'unique'],
+            action: 'create',
+        });
+        await db.upsertOne(this.collectionName, {
+            uniqueField: 'hello world',
+            uniqueField2: 'unique',
+        }, {
+            uniqueField: 'hello world',
+            uniqueField2: 'unique2',
+        });
+        err = (await test_utils_1.assert.doesThrowAsync(() => db.upsertOne(this.collectionName, {
+            uniqueField: 'hello world',
+            uniqueField2: 'unique2',
+        }, {
+            uniqueField: 'hello world',
+            uniqueField2: 'hello again',
+        })));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['uniqueField', 'uniqueField2'],
+            duplicateValues: ['hello world', 'hello again'],
+            action: 'upsertOne',
+        });
+        await this.shutdown(db);
+    },
+    async assertSettingUniqueIndexViolationThrowsSpruceError(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['randomUniqueField']);
+        await db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            randomUniqueField: '1',
+        });
+        await db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            randomUniqueField: '2',
+        });
+        let err = await test_utils_1.assert.doesThrowAsync(() => db.syncUniqueIndexes(this.collectionName, [['uniqueField']]));
+        test_utils_1.assert.isTrue(err instanceof SpruceError_1.default);
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_KEY');
+        await this.shutdown(db);
+    },
+    async assertDuplicateKeyThrowsOnInsert(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['uniqueField']);
+        await db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+        });
+        let err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, { uniqueField: 'hello world' }));
+        test_utils_1.assert.isTrue(err instanceof SpruceError_1.default);
+        await this.shutdown(db);
+    },
+    async assertSyncingIndexesDoesNotAddAndRemove(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['otherField']);
+        await db.createUniqueIndex(this.collectionName, ['someField']);
+        db.createUniqueIndex = () => {
+            throw new Error('Should not have been called');
+        };
+        db.dropIndex = () => {
+            throw new Error('Should not have been called');
+        };
+        await db.syncUniqueIndexes(this.collectionName, [
+            ['someField'],
+            ['otherField'],
+        ]);
+        await this.shutdown(db);
+    },
+    async assertSyncingUniqueIndexesRemovesExtraIndexes(connect) {
+        const db = await connect();
+        await db.syncUniqueIndexes(this.collectionName, [
+            ['uniqueField'],
+            ['someField'],
+            ['otherField', 'otherField2'],
+        ]);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 3);
+        await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isEqual(indexes[0][0], 'uniqueField');
+        await this.shutdown(db);
+    },
+    async assertSyncingUniqueIndexsSkipsExistingIndexs(connect) {
+        const db = await connect();
+        await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        await db.syncUniqueIndexes(this.collectionName, [
+            ['uniqueField'],
+            ['someField'],
+            ['otherField', 'otherField2'],
+        ]);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 3);
+        await this.shutdown(db);
+    },
+    async assertSyncingUniqueIndexsAddsMissingIndexes(connect) {
+        const db = await connect();
+        await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        await db.syncUniqueIndexes(this.collectionName, [['someField']]);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        await db.syncUniqueIndexes(this.collectionName, [
+            ['uniqueField'],
+            ['someField'],
+        ]);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 2);
+        await this.shutdown(db);
+    },
+    async assertCantDropCompoundUniqueIndexThatDoesntExist(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, [
+            'someField',
+            'someOtherField',
+        ]);
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        await this.shutdown(db);
+    },
+    async assertCantDropIndexWhenNoIndexExists(connect) {
+        const db = await connect();
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField']));
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        await this.shutdown(db);
+    },
+    async assertCantDropUniqueIndexThatDoesntExist(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['someField']);
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField']));
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        await this.shutdown(db);
+    },
+    async assertCanDropCompoundUniqueIndex(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['someField', 'otherField']);
+        await db.dropIndex(this.collectionName, ['someField', 'otherField']);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 0);
+        await db.createUniqueIndex(this.collectionName, ['someField', 'someField2']);
+        await db.createUniqueIndex(this.collectionName, ['someField', 'someField3']);
+        await db.dropIndex(this.collectionName, ['someField', 'someField3']);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        await this.shutdown(db);
+    },
+    async assertCanDropUniqueIndex(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['someField']);
+        await db.dropIndex(this.collectionName, ['someField']);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 0);
+        await db.createUniqueIndex(this.collectionName, ['someField2']);
+        await db.createUniqueIndex(this.collectionName, ['someField3']);
+        await db.dropIndex(this.collectionName, ['someField3']);
+        indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        await this.shutdown(db);
+    },
+    async assertCantCreateUniqueIndexTwice(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['uniqueField']);
+        let indexes = await db.getUniqueIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 1);
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.createUniqueIndex(this.collectionName, ['uniqueField']));
+        test_utils_2.errorAssert.assertError(err, 'INDEX_EXISTS');
+        await this.shutdown(db);
+    },
+    async assertSyncingUniqueIndexesIsRaceProof(connect) {
+        const db = await connect();
+        const syncs = [
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+            db.syncUniqueIndexes(this.collectionName, [
+                ['otherField', 'otherField2'],
+            ]),
+        ];
+        await Promise.all(syncs);
+        await this.shutdown(db);
+    },
+    async assertUniqueIndexBlocksDuplicates(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['uniqueField']);
+        await db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+        });
+        let err = (await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, { uniqueField: 'hello world' })));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['uniqueField'],
+            duplicateValues: ['hello world'],
+            action: 'create',
+        });
+        const created = await db.createOne(this.collectionName, {
+            uniqueField: 'pass',
+        });
+        err = (await test_utils_1.assert.doesThrowAsync(() => db.updateOne(this.collectionName, { id: created.id }, { uniqueField: 'hello world' })));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['uniqueField'],
+            duplicateValues: ['hello world'],
+            action: 'updateOne',
+        });
+        let promises = [];
+        for (let c = 0; c <= 10; c++) {
+            promises.push(db.createOne(this.collectionName, {
+                uniqueField: 'fast',
+            }));
+        }
+        err = (await test_utils_1.assert.doesThrowAsync(() => Promise.all(promises)));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            duplicateFields: ['uniqueField'],
+            duplicateValues: ['fast'],
+        });
+        promises = [];
+        for (let c = 0; c <= 10; c++) {
+            promises.push(db.upsertOne(this.collectionName, { uniqueField: `${c}` }, {
+                uniqueField: 'upsertFast',
+            }));
+        }
+        err = (await test_utils_1.assert.doesThrowAsync(() => Promise.all(promises)));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD');
+        await this.shutdown(db);
+    },
+    async assertCanCreateUniqueIndexOnNestedField(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, [
+            'target.organizationId',
+            'slug',
+        ]);
+        await db.createOne(this.collectionName, {
+            target: {
+                organizationId: 'go!',
+                locationId: null,
+            },
+            slug: 'a slug',
+        });
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            target: {
+                organizationId: 'go!',
+                locationId: null,
+            },
+            slug: 'a slug',
+        }));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['target.organizationId', 'slug'],
+            duplicateValues: ['go!', 'a slug'],
+            action: 'create',
+        });
+        await db.upsertOne(this.collectionName, {
+            target: {
+                organizationId: 'go!',
+            },
+        }, {
+            target: {
+                organizationId: 'go 2!',
+                locationId: null,
+            },
+            slug: 'a slug',
+        });
+        await this.shutdown(db);
+    },
+    async assertCanPushToArrayOnUpsert(connect) {
+        const db = await connect();
+        const record = await db.createOne(this.collectionName, { names: [] });
+        await db.updateOne(this.collectionName, {
+            id: record.id,
+        }, {
+            $push: { names: 'test' },
+        });
+        const match = await db.findOne(this.collectionName);
+        test_utils_1.assert.isEqualDeep(match === null || match === void 0 ? void 0 : match.names, ['test']);
+        await this.shutdown(db);
+    },
+    async assertCanSearchByRegex(connect) {
+        const db = await connect();
+        await db.create(this.collectionName, [
+            {
+                name: 'first',
+                subObject: {
+                    score: 1,
+                },
+            },
+            {
+                name: 'second',
+                subObject: {
+                    score: 2,
+                },
+            },
+            {
+                name: 'third',
+                subObject: {
+                    score: 2,
+                },
+            },
+        ]);
+        const all = await db.find(this.collectionName, { name: { $regex: /fi/ } }, { includeFields: ['name'] });
+        test_utils_1.assert.isEqualDeep(all, [
+            {
+                name: 'first',
+            },
+        ]);
+        await this.shutdown(db);
+    },
+    async assertCanReturnOnlySelectFields(connect) {
+        const db = await connect();
+        await db.create(this.collectionName, [
+            {
+                name: 'first',
+                subObject: {
+                    score: 1,
+                },
+            },
+            {
+                name: 'second',
+                subObject: {
+                    score: 2,
+                },
+            },
+            {
+                name: 'third',
+                subObject: {
+                    score: 2,
+                },
+            },
+        ]);
+        const all = await db.find(this.collectionName, {}, { includeFields: ['name'] });
+        test_utils_1.assert.isEqualDeep(all, [
+            {
+                name: 'first',
+            },
+            {
+                name: 'second',
+            },
+            {
+                name: 'third',
+            },
+        ]);
+        const first = await db.findOne(this.collectionName, {}, { includeFields: ['subObject'] });
+        test_utils_1.assert.isEqualDeep(first, {
+            subObject: {
+                score: 1,
+            },
+        });
+        await this.shutdown(db);
+    },
+    async assertThrowsWithoutDatabaseName(connect) {
+        const err = await test_utils_1.assert.doesThrowAsync(() => connect(undefined, 'undefined'));
+        test_utils_2.errorAssert.assertError(err, 'INVALID_DATABASE_NAME', {
+            suppliedName: 'undefined',
+        });
+    },
+    async assertThrowsWhenCantConnect(connect) {
+        const err = await test_utils_1.assert.doesThrowAsync(() => connect('mongodb://localhost:9999'));
+        test_utils_2.errorAssert.assertError(err, 'UNABLE_TO_CONNECT_TO_DB');
+    },
+    async assertThrowsWithInvalidConnectionString(connect) {
+        const err = await test_utils_1.assert.doesThrowAsync(() => connect('astnoehusantoheun'));
+        test_utils_2.errorAssert.assertError(err, 'INVALID_DB_CONNECTION_STRING');
+    },
+    async assertKnowsIfConnectionClosed(connect) {
+        const db = await connect();
+        test_utils_1.assert.isTrue(db.isConnected());
+        await db.close();
+        test_utils_1.assert.isFalse(db.isConnected());
+    },
+    async assertCanQueryPathWithDotSyntax(connect) {
+        const db = await connect();
+        await db.create(this.collectionName, [
+            {
+                name: 'first',
+                subObject: {
+                    score: 1,
+                },
+            },
+            {
+                name: 'second',
+                subObject: {
+                    score: 2,
+                },
+            },
+            {
+                name: 'third',
+                subObject: {
+                    score: 2,
+                },
+            },
+        ]);
+        const secondMatch = await db.findOne(this.collectionName, {
+            'subObject.score': 2,
+        });
+        test_utils_1.assert.isTruthy(secondMatch);
+        test_utils_1.assert.isEqual(secondMatch.name, 'second');
+        await this.shutdown(db);
+    },
+    async assertCanQueryByGtLtGteLte(connect) {
+        const db = await connect();
+        const created = await db.create(this.collectionName, [
+            {
+                position: 1,
+            },
+            {
+                position: 2,
+            },
+            {
+                position: 3,
+            },
+            {
+                position: 4,
+            },
+        ]);
+        const gtMatches = await db.find(this.collectionName, {
+            id: { $gt: created[2].id },
+        });
+        test_utils_1.assert.isLength(gtMatches, 1);
+        test_utils_1.assert.isEqual(gtMatches[0].position, 4);
+        const gteMatches = await db.find(this.collectionName, {
+            id: { $gte: created[2].id },
+        });
+        test_utils_1.assert.isLength(gteMatches, 2);
+        test_utils_1.assert.isEqual(gteMatches[0].position, 3);
+        test_utils_1.assert.isEqual(gteMatches[1].position, 4);
+        const ltMatches = await db.find(this.collectionName, {
+            id: { $lt: created[2].id },
+        });
+        test_utils_1.assert.isLength(ltMatches, 2);
+        test_utils_1.assert.isEqual(ltMatches[0].position, 1);
+        test_utils_1.assert.isEqual(ltMatches[1].position, 2);
+        const lteMatches = await db.find(this.collectionName, {
+            id: { $lte: created[2].id },
+        });
+        test_utils_1.assert.isLength(lteMatches, 3);
+        test_utils_1.assert.isEqual(lteMatches[0].position, 1);
+        test_utils_1.assert.isEqual(lteMatches[1].position, 2);
+        test_utils_1.assert.isEqual(lteMatches[2].position, 3);
+        await this.shutdown(db);
+    },
+    async assertCanFindWithNe(connect) {
+        const db = await connect();
+        const record1 = await db.createOne(this.collectionName, {
+            foo: 'bar',
+            hello: 'world',
+        });
+        await db.createOne(this.collectionName, {
+            foo: 'bar2',
+            hello: 'world',
+        });
+        await db.createOne(this.collectionName, {
+            foo: 'bar3',
+            hello: 'planet',
+        });
+        const query = { id: { $ne: record1.id } };
+        const results = await db.find(this.collectionName, query);
+        test_utils_1.assert.isLength(results, 2);
+        await this.shutdown(db);
+    },
+    async assertCanFindWithIn(connect) {
+        const db = await connect();
+        const record1 = await db.createOne(this.collectionName, {
+            foo: 'bar',
+            hello: 'world',
+        });
+        const record2 = await db.createOne(this.collectionName, {
+            foo: 'bar2',
+            hello: 'world',
+        });
+        const record3 = await db.createOne(this.collectionName, {
+            foo: 'bar3',
+            hello: 'planet',
+        });
+        const query = { id: { $in: [record1.id, record2.id, record3.id] } };
+        const results = await db.find(this.collectionName, query);
+        test_utils_1.assert.isLength(results, 3);
+        await this.shutdown(db);
+    },
+    async assertCanCountOnId(connect) {
+        const db = await connect();
+        const first = await db.createOne(this.collectionName, {
+            foo: 'bar',
+            hello: 'world',
+        });
+        const second = await db.createOne(this.collectionName, {
+            foo: 'bar2',
+            hello: 'world',
+        });
+        const third = await db.createOne(this.collectionName, {
+            foo: 'bar3',
+            hello: 'planet',
+        });
+        const countFirst = await db.count(this.collectionName, { id: first.id });
+        const countSecond = await db.count(this.collectionName, {
+            id: { $in: [first.id, second.id] },
+        });
+        const countThird = await db.count(this.collectionName, {
+            id: { $in: [first.id, second.id, third.id] },
+        });
+        test_utils_1.assert.isEqual(countFirst, 1);
+        test_utils_1.assert.isEqual(countSecond, 2);
+        test_utils_1.assert.isEqual(countThird, 3);
+        await this.shutdown(db);
+    },
+    async assertCanCount(connect) {
+        const db = await connect();
+        await db.createOne(this.collectionName, { foo: 'bar', hello: 'world' });
+        await db.createOne(this.collectionName, { foo: 'bar2', hello: 'world' });
+        await db.createOne(this.collectionName, { foo: 'bar3', hello: 'planet' });
+        const countAll = await db.count(this.collectionName);
+        test_utils_1.assert.isEqual(countAll, 3);
+        await this.shutdown(db);
+    },
+    async assertCanUpsertNull(connect) {
+        const db = await connect();
+        const createdUndefined = await db.upsertOne(this.collectionName, {
+            undefinedField: undefined,
+        }, {
+            undefinedField: undefined,
+        });
+        test_utils_1.assert.isTruthy(createdUndefined);
+        test_utils_1.assert.isNull(createdUndefined.undefinedField);
+        const createdNull = await db.upsertOne(this.collectionName, {
+            nullField: null,
+        }, {
+            nullField: null,
+        });
+        test_utils_1.assert.isTruthy(createdNull);
+        let all = await db.find(this.collectionName);
+        test_utils_1.assert.isLength(all, 2);
+        const updatedUndefined = await db.upsertOne(this.collectionName, {
+            undefinedField: undefined,
+        }, { undefinedField: 'now defined' });
+        test_utils_1.assert.isEqual(updatedUndefined.id, createdUndefined.id);
+        test_utils_1.assert.isEqual(updatedUndefined.undefinedField, 'now defined');
+        const updatedNull = await db.upsertOne(this.collectionName, {
+            nullField: null,
+        }, { nullField: 'now defined' });
+        test_utils_1.assert.isEqual(updatedNull.id, createdNull.id);
+        test_utils_1.assert.isEqual(updatedNull.nullField, 'now defined');
+        all = await db.find(this.collectionName);
+        test_utils_1.assert.isLength(all, 2);
+        await this.shutdown(db);
+    },
+    async assertCanSaveAndGetNullAndUndefined(connect) {
+        const db = await connect();
+        const created = await db.createOne(this.collectionName, {
+            undefinedField: undefined,
+            nullField: null,
+        });
+        test_utils_1.assert.isNull(created.undefinedField);
+        test_utils_1.assert.isNull(created.nullField);
+        const matchedUndefined = await db.findOne(this.collectionName, {
+            undefinedField: undefined,
+        });
+        test_utils_1.assert.isTruthy(matchedUndefined);
+        test_utils_1.assert.isNull(matchedUndefined.undefinedField);
+        const matchedNull = await db.findOne(this.collectionName, {
+            nullField: null,
+        });
+        test_utils_1.assert.isTruthy(matchedNull);
+        test_utils_1.assert.isNull(matchedNull.nullField);
+        const updatedUndefined = await db.updateOne(this.collectionName, {
+            undefinedField: undefined,
+        }, { undefinedField: 'now defined' });
+        test_utils_1.assert.isEqual(updatedUndefined.id, created.id);
+        test_utils_1.assert.isEqual(updatedUndefined.undefinedField, 'now defined');
+        const updatedNull = await db.updateOne(this.collectionName, {
+            nullField: null,
+        }, { nullField: 'now defined' });
+        test_utils_1.assert.isEqual(updatedNull.nullField, 'now defined');
+        await this.shutdown(db);
+    },
+    async assertSyncIndexesDoesNotRemoveExisting(connect) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, ['otherField']);
+        await db.createIndex(this.collectionName, ['someField']);
+        db.createIndex = () => {
+            throw new Error('Should not have been called');
+        };
+        db.dropIndex = () => {
+            throw new Error('Should not have been called');
+        };
+        await db.syncIndexes(this.collectionName, [['someField'], ['otherField']]);
+        await this.shutdown(db);
+    },
+    async assertSyncIndexesRemovesExtraIndexes(connect) {
+        const db = await connect();
+        await db.syncIndexes(this.collectionName, [
+            ['field'],
+            ['someField'],
+            ['otherField', 'otherField2'],
+        ]);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 3);
+        await db.syncIndexes(this.collectionName, [['field']]);
+        indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isEqual(indexes[0][0], 'field');
+        await this.shutdown(db);
+    },
+    async assertSyncIndexesSkipsExisting(connect) {
+        const db = await connect();
+        await db.syncIndexes(this.collectionName, [['field']]);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        await db.syncIndexes(this.collectionName, [
+            ['field'],
+            ['someField'],
+            ['otherField', 'otherField2'],
+        ]);
+        indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 3);
+        await this.shutdown(db);
+    },
+    async assertCantDropCompoundIndexThatDoesNotExist(connect) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, ['someField', 'someOtherField']);
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        await this.shutdown(db);
+    },
+    async assertCanDropCompoundIndex(connect) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, ['someField', 'otherField']);
+        await db.dropIndex(this.collectionName, ['someField', 'otherField']);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 0);
+        await db.createIndex(this.collectionName, ['someField', 'someField2']);
+        await db.createIndex(this.collectionName, ['someField', 'someField3']);
+        await db.dropIndex(this.collectionName, ['someField', 'someField3']);
+        indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        await this.shutdown(db);
+    },
+    async assertCanDropIndex(connect) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, ['someField']);
+        await db.dropIndex(this.collectionName, ['someField']);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 0);
+        await db.createIndex(this.collectionName, ['someField2']);
+        await db.createIndex(this.collectionName, ['someField3']);
+        await db.dropIndex(this.collectionName, ['someField3']);
+        indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        await this.shutdown(db);
+    },
+    async assertCanCreateMultiFieldIndex(connect, fields) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, fields);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isEqualDeep(indexes, [fields]);
+        await this.shutdown(db);
+    },
+    async assertCantCreateSameIndexTwice(connect) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, ['field']);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['field']));
+        test_utils_2.errorAssert.assertError(err, 'INDEX_EXISTS');
+        await this.shutdown(db);
+    },
+    async assertCanCreateIndex(connect) {
+        const db = await connect();
+        await db.createIndex(this.collectionName, ['field']);
+        let indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isLength(indexes[0], 1);
+        test_utils_1.assert.isEqual(indexes[0][0], 'field');
+        await db.createIndex(this.collectionName, ['field2']);
+        indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 2);
+        test_utils_1.assert.isEqual(indexes[1][0], 'field2');
+        await db.createIndex(this.collectionName, ['field3', 'field4']);
+        indexes = await this._getFilteredIndexes(db);
+        test_utils_1.assert.isLength(indexes, 3);
+        test_utils_1.assert.isEqual(indexes[2][0], 'field3');
+        test_utils_1.assert.isEqual(indexes[2][1], 'field4');
+        await this.shutdown(db);
+    },
+    async assertHasNoIndexToStart(connect) {
+        const db = await connect();
+        const indexes = await db.getIndexes(this.collectionName);
+        test_utils_1.assert.isLength(indexes, 0);
+        await this.shutdown(db);
+    },
+    async assertNestedFieldIndexUpdates(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, [
+            'target.organizationId',
+            'slug',
+        ]);
+        const results = await db.createOne(this.collectionName, {
+            target: {
+                organizationId: 'go!',
+            },
+            aNonIndexedField: true,
+            slug: 'a slug',
+        });
+        const updated = await db.updateOne(this.collectionName, { id: results.id }, {
+            target: {
+                organizationId: 'go!',
+            },
+            aNonIndexedField: false,
+            slug: 'a slug',
+        });
+        test_utils_1.assert.isEqual(updated.aNonIndexedField, false);
+        await this.shutdown(db);
+    },
+    async assertUpsertWithUniqueIndex(connect) {
+        const db = await connect();
+        await db.syncUniqueIndexes(this.collectionName, [
+            ['name', 'target.organizationId'],
+            ['slug', 'target.organizationId'],
+        ]);
+        const results = await db.createOne(this.collectionName, {
+            target: {
+                organizationId: 'go!',
+            },
+            name: 'squirrel',
+            slug: 'a slug',
+        });
+        const updated = await db.upsertOne(this.collectionName, { target: { organizationId: 'go!' }, slug: 'a slug' }, {
+            target: {
+                organizationId: 'go!',
+            },
+            name: 'notsquirrel',
+            slug: 'a slug',
+        });
+        test_utils_1.assert.isEqual(results.id, updated.id);
+        test_utils_1.assert.isEqual(updated.name, 'notsquirrel');
+        await this.shutdown(db);
+    },
+    async assertSyncIndexesHandlesRaceConditions(connect) {
+        const db = await connect();
+        const syncs = [
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+            db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
+        ];
+        await Promise.all(syncs);
+        await this.shutdown(db);
+    },
+    async assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected(connect) {
+        const db = await connect();
+        await db.createUniqueIndex(this.collectionName, ['uniqueField1']);
+        await db.createUniqueIndex(this.collectionName, ['uniqueField2']);
+        await db.createOne(this.collectionName, {
+            uniqueField1: 'unique field 1',
+            uniqueField2: 'unique field 2',
+        });
+        let err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            uniqueField1: 'unique field 1',
+            uniqueField2: 'unique field 2',
+        }));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['uniqueField1'],
+            duplicateValues: ['unique field 1'],
+            action: 'create',
+        });
+        err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            uniqueField1: 'unique field 1.0',
+            uniqueField2: 'unique field 2',
+        }));
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            collectionName: this.collectionName,
+            duplicateFields: ['uniqueField2'],
+            duplicateValues: ['unique field 2'],
+            action: 'create',
+        });
+        await this.shutdown(db);
+    },
+};
+exports.default = databaseAssertUtil;