@sprucelabs/data-stores 19.1.67 → 19.2.0

package/build/esm/tests/databaseAssertUtil.js

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