@sprucelabs/data-stores 19.3.3 → 20.0.1

package/build/esm/tests/databaseAssertUtil.js

@@ -10,17 +10,110 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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) {
+    runSuite(connect, tests) {
         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)));
+            const methods = [
+                //connecting
+                'assertThrowsWithInvalidConnectionString',
+                'assertThrowsWhenCantConnect',
+                'assertThrowsWithBadDatabaseName',
+                //inserting
+                'assertEmptyDatabaseReturnsEmptyArray',
+                'assertKnowsIfConnectionClosed',
+                'assertFindOneOnEmptyDatabaseReturnsNull',
+                'assertCanSortDesc',
+                'assertCanSortAsc',
+                'assertCanSortById',
+                'assertCanQueryWithOr',
+                'generateIdDifferentEachTime',
+                'assertInsertingGeneratesId',
+                'assertCanCreateMany',
+                'assertCanLimitResults',
+                'assertCanCreateWithObjectField',
+                //counting
+                'assertCanCountOnId',
+                'assertCanCount',
+                //updating
+                'assertThrowsWhenUpdatingRecordNotFound',
+                'assertCanUpdate',
+                'assertCanUpdateMany',
+                'assertCanPushOntoArrayValue',
+                'canUpdateWithObjectField',
+                'canUpdateFieldInObjectFieldWithTargettedWhere',
+                'assertCanSaveAndGetNullAndUndefined',
+                //upserting
+                'assertCanUpsertOne',
+                'assertCanUpsertNull',
+                'assertCanPushToArrayOnUpsert',
+                //finding
+                'assertEmptyDatabaseReturnsEmptyArray',
+                'assertFindOneOnEmptyDatabaseReturnsNull',
+                'assertCanLimitResults',
+                'assertCanLimitResultsToZero',
+                'assertCanFindWithBooleanField',
+                'assertCanQueryByGtLtGteLte',
+                'assertCanQueryPathWithDotSyntax',
+                'assertCanReturnOnlySelectFields',
+                'assertCanSearchByRegex',
+                'assertCanFindWithNe',
+                'assertCanFindWithIn',
+                //deleting
+                'assertCanDeleteRecord',
+                'assertCanDeleteOne',
+                //indexing
+                'assertHasNoUniqueIndexToStart',
+                'assertCanCreateUniqueIndex',
+                'assertCanCreateMultiFieldUniqueIndex',
+                'assertCantCreateUniqueIndexTwice',
+                'assertCanDropUniqueIndex',
+                'assertCanDropCompoundUniqueIndex',
+                'assertCantDropUniqueIndexThatDoesntExist',
+                'assertCantDropIndexWhenNoIndexExists',
+                'assertCantDropCompoundUniqueIndexThatDoesntExist',
+                'assertSyncingUniqueIndexsAddsMissingIndexes',
+                'assertSyncingUniqueIndexsSkipsExistingIndexs',
+                'assertSyncingUniqueIndexesRemovesExtraIndexes',
+                'assertSyncingUniqueIndexesIsRaceProof',
+                'assertSyncingIndexesDoesNotAddAndRemove',
+                'assertUniqueIndexBlocksDuplicates',
+                'assertDuplicateKeyThrowsOnInsert',
+                'assertSettingUniqueIndexViolationThrowsSpruceError',
+                'assertCanCreateUniqueIndexOnNestedField',
+                'assertUpsertWithUniqueIndex',
+                'assertNestedFieldIndexUpdates',
+                'assertHasNoIndexToStart',
+                'assertCanCreateIndex',
+                'assertCantCreateSameIndexTwice',
+                'assertCanCreateMultiFieldIndex',
+                'assertCanDropIndex',
+                'assertCanDropCompoundIndex',
+                'assertCantDropCompoundIndexThatDoesNotExist',
+                'assertSyncIndexesSkipsExisting',
+                'assertSyncIndexesRemovesExtraIndexes',
+                'assertSyncIndexesHandlesRaceConditions',
+                'assertSyncIndexesDoesNotRemoveExisting',
+                'assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected',
+            ];
+            const db = yield connectToDabatase(connect);
+            yield db.dropDatabase();
+            yield this.shutdown(db);
+            const toRun = tests !== null && tests !== void 0 ? tests : methods;
+            for (const method of toRun) {
+                try {
+                    //@ts-ignore
+                    yield this[method](connect);
+                }
+                catch (err) {
+                    const prefix = `Error in ${method}:\n\n `;
+                    err.message = `${prefix} ${err.message}`;
+                    err.stack = `${prefix} ${err.stack}`;
+                    throw err;
+                }
+            }
         });
     },
     _getFilteredIndexes(db) {
@@ -34,17 +127,36 @@ const databaseAssertUtil = {
     _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);
+            assert.isEqual(updatedCount, expectedUpdateCount, 'db.update() did not update the expected amount of records! Make sure it returns an integer of the number of records updated.');
             const count = yield db.count(this.collectionName, updates);
             assert.isEqual(count, expectedUpdateCount);
         });
     },
+    generateIdDifferentEachTime(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            const id1 = db.generateId();
+            const id2 = db.generateId();
+            assert.isNotEqual(id1, id2, 'generateId() must generate a different id each time');
+            yield this.shutdown(db);
+        });
+    },
     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 db = yield connectToDabatase(connect);
+            const second = yield db.createOne(this.collectionName, {
+                name: 'second',
+                count: 1,
+            });
+            const third = yield db.createOne(this.collectionName, {
+                name: 'third',
+                count: 5,
+            });
+            const first = yield db.createOne(this.collectionName, {
+                name: 'first',
+                count: -1,
+            });
+            assert.isFunction(db.find, `db.find() must be a function.`);
             const results = yield db.find(this.collectionName, {}, {
                 sort: [
                     {
@@ -53,20 +165,25 @@ const databaseAssertUtil = {
                     },
                 ],
             });
-            assert.isEqual(results[0].name, 'third');
-            assert.isEqual(results[1].name, 'second');
-            assert.isEqual(results[2].name, 'first');
+            assert.isBelow(results.length, 4, `You are not resetting data when .dropDatabase() is called. If you can't drop the database in your env, then you need to clear at all rows in all tables! Got back ${results.length} records!`);
+            assert.isLength(results, 3, `Should have 3 records back from find() after 3 createOne()s. Make sure your createOne() is inserting records! I only got back ${results.length} records!`);
+            assert.isEqual(results[0].name, 'third', `first record should be named "third" when sorting desc by name. Make sure you are sorting using the "sort" option.`);
+            assert.isEqual(results[1].name, 'second', `second record should be named "second" when sorting desc by name.`);
+            assert.isEqual(results[2].name, 'first', `third record should be named "first" when sorting desc by name.`);
+            assert.isEqualDeep(results[0], third, `createOne() is not returning the record that was created!`);
+            assert.isEqualDeep(results[1], second, `createOne() is not returning the record that was created!`);
+            assert.isEqualDeep(results[2], first, `createOne() is not returning the record that was created!`);
             const result = yield db.findOne(this.collectionName, undefined, {
                 sort: [{ field: 'count', direction: 'desc' }],
             });
-            assert.isTruthy(result);
-            assert.isEqual(result.name, 'third');
+            assert.isTruthy(result, 'findOne() should return a record!');
+            assert.isEqual(result.name, 'third', 'findOne() should honor sort!');
             yield this.shutdown(db);
         });
     },
     assertCanSortAsc(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(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 });
@@ -78,9 +195,9 @@ const databaseAssertUtil = {
                     },
                 ],
             });
-            assert.isEqual(results[0].name, 'first');
-            assert.isEqual(results[1].name, 'second');
-            assert.isEqual(results[2].name, 'third');
+            assert.isEqual(results[0].name, 'first', 'find is not sorting ascending');
+            assert.isEqual(results[1].name, 'second', 'find is not sorting ascending');
+            assert.isEqual(results[2].name, 'third', 'find is not sorting ascending');
             const result = yield db.findOne(this.collectionName, undefined, {
                 sort: [{ field: 'count', direction: 'asc' }],
             });
@@ -91,86 +208,96 @@ const databaseAssertUtil = {
     },
     assertInsertingGeneratesId(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
+            const name = generateId();
             const inserted = yield db.createOne(this.collectionName, {
-                name: 'first',
+                name,
             });
-            assert.isTruthy(inserted);
-            assert.isString(inserted.id);
-            assert.isEqual(inserted.name, 'first');
+            assert.isTruthy(inserted, "createOne() didn't return anything!");
+            assert.isTruthy(inserted.id, 'createOne() record id is missing!');
+            assert.isEqual(inserted.name, name, 'createOne() record name field was not set to ' + name);
             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');
+            const db = yield connectToDabatase(connect);
+            assert.isFunction(db.generateId, `db.generateId() must be a function that returns a unique identifier.`);
+            assert.isFunction(db.updateOne, 'You must implement updateOne() in your database adapter.');
+            yield this._assertThrowsExpectedNotFoundOnUpdateOne(db, {
+                id: db.generateId(),
+            });
+            yield this._assertThrowsExpectedNotFoundOnUpdateOne(db, { count: 10 });
             yield this.shutdown(db);
         });
     },
     shutdown(db) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield db.dropDatabase();
-            yield db.close();
+            if (db.isConnected()) {
+                yield db.dropDatabase();
+                yield db.close();
+            }
         });
     },
     assertCanCreateUniqueIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(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');
+            assert.isLength(indexes, 1, 'getUniqueIndexes() did not return the unique index I tried to create!');
+            assert.isLength(indexes[0], 1, 'getUniqueIndexes() needs to return an array of arrays. Each item in the array should be an array of fields that make up the unique index.');
+            assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase(), 'getUniqueIndexes() did not add the expected field to the first unique index.');
             yield db.createUniqueIndex(this.collectionName, ['uniqueField2']);
             indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 2);
-            assert.isEqual(indexes[1][0], 'uniqueField2');
+            assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
             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');
+            assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
+            assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
             yield this.shutdown(db);
         });
     },
     assertHasNoUniqueIndexToStart(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 0);
+            assert.isLength(indexes, 0, "getUniqueIndexes() should return an empty array when there are no unique indexes (primary key indexes don't count!). Also, make sure that dropDatabase() in your adapter clears out any unique indexes you've created.");
             yield this.shutdown(db);
         });
     },
-    assertCanShutdown(connect) {
+    assertCanUpsertOne(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const id = db.generateId();
             const created = yield db.upsertOne(this.collectionName, { id }, {
                 id,
                 name: 'first',
             });
-            assert.isTruthy(created);
+            assert.isTruthy(created, 'upsertOne() should return the record it created!');
             assert.isEqual(created.name, 'first');
-            assert.isEqual(created.id, id);
+            assert.isEqual(`${created.id}`, `${id}`, 'ids do not match!');
             const upserted = yield db.upsertOne(this.collectionName, { id }, { name: 'second' });
-            yield db.upsertOne(this.collectionName, { id: db.generateId() }, { name: 'second' });
+            const id2 = db.generateId();
+            yield db.upsertOne(this.collectionName, { id: id2 }, { name: 'second', id: id2 });
             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');
+            const match = yield db.findOne(this.collectionName, { id });
+            assert.isEqualDeep(match, upserted2, 'upsertOne() did not update the record!');
             yield this.shutdown(db);
         });
     },
     assertCanDeleteOne(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.create(this.collectionName, [
                 {
                     name: 'a record',
@@ -184,13 +311,13 @@ const databaseAssertUtil = {
             ]);
             yield db.deleteOne(this.collectionName, { name: 'a record' });
             const count = yield db.count(this.collectionName);
-            assert.isEqual(count, 2);
+            assert.isEqual(count, 2, 'deleteOne() did not delete a single record!');
             yield this.shutdown(db);
         });
     },
     assertCanDeleteRecord(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const created = yield db.createOne(this.collectionName, {
                 id: db.generateId(),
                 name: 'first',
@@ -207,7 +334,7 @@ const databaseAssertUtil = {
             const matchedAfterDelete = yield db.findOne(this.collectionName, {
                 id: created.id,
             });
-            assert.isFalsy(matchedAfterDelete);
+            assert.isFalsy(matchedAfterDelete, `Record with the id of ${created.id} was not deleted!`);
             yield db.create(this.collectionName, [
                 {
                     name: 'a record',
@@ -220,13 +347,13 @@ const databaseAssertUtil = {
                 },
             ]);
             const manyDeleted = yield db.delete(this.collectionName, {});
-            assert.isEqual(manyDeleted, 3);
+            assert.isEqual(manyDeleted, 3, `delete() did not return the total recrods deleted!`);
             yield this.shutdown(db);
         });
     },
     assertCanLimitResultsToZero(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createOne(this.collectionName, {
                 id: db.generateId(),
                 name: 'first',
@@ -249,7 +376,7 @@ const databaseAssertUtil = {
     },
     assertCanLimitResults(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createOne(this.collectionName, {
                 id: db.generateId(),
                 name: 'first',
@@ -274,7 +401,7 @@ const databaseAssertUtil = {
     },
     assertFindOneOnEmptyDatabaseReturnsNull(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const results = yield db.findOne(this.collectionName, { id: '111' });
             assert.isFalsy(results);
             yield this.shutdown(db);
@@ -282,7 +409,7 @@ const databaseAssertUtil = {
     },
     assertEmptyDatabaseReturnsEmptyArray(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const results = yield db.find(this.collectionName, { id: '111' });
             assert.isLength(results, 0);
             yield this.shutdown(db);
@@ -290,9 +417,10 @@ const databaseAssertUtil = {
     },
     assertCanPushOntoArrayValue(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const inserted = yield db.createOne(this.collectionName, {
                 id: db.generateId(),
+                name: 'nope',
                 names: ['first'],
             });
             const updated = yield db.updateOne(this.collectionName, { id: inserted.id }, {
@@ -305,14 +433,79 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
+    assertCanCreateWithObjectField(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            const values = {
+                name: 'first',
+                target: {
+                    organizationId: generateId(),
+                    locationId: generateId(),
+                },
+            };
+            let created;
+            try {
+                created = yield db.createOne(this.collectionName, values);
+            }
+            catch (_a) {
+                assert.fail('createOne() tried to create a record with an object field. Make sure the target field handles objects!');
+            }
+            const matched = yield db.findOne(this.collectionName, { id: created.id });
+            assert.isEqualDeep(matched, Object.assign(Object.assign({}, created), { id: matched.id }));
+            yield this.shutdown(db);
+        });
+    },
+    canUpdateWithObjectField(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            const values = {
+                name: 'first',
+                target: {
+                    organizationId: generateId(),
+                    locationId: generateId(),
+                },
+            };
+            const created = yield db.createOne(this.collectionName, values);
+            const target = {
+                organizationId: 'hey',
+                locationId: 'there',
+            };
+            yield db.updateOne(this.collectionName, { id: created.id }, {
+                target,
+            });
+            const matched = yield db.findOne(this.collectionName, { id: created.id });
+            assert.isEqualDeep(matched.target, target);
+            yield this.shutdown(db);
+        });
+    },
+    canUpdateFieldInObjectFieldWithTargettedWhere(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            const target = {
+                organizationId: generateId(),
+                locationId: generateId(),
+            };
+            const values = {
+                name: 'first',
+                target,
+            };
+            const created = yield db.createOne(this.collectionName, values);
+            yield db.updateOne(this.collectionName, { id: created.id }, {
+                'target.organizationId': 'oy oy',
+            });
+            const matched = yield db.findOne(this.collectionName, { id: created.id });
+            assert.isEqualDeep(matched.target, Object.assign(Object.assign({}, target), { organizationId: 'oy oy' }));
+            yield this.shutdown(db);
+        });
+    },
     assertCanCreateMany(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const values = [
-                { first: 'ry' },
-                { first: 'tay' },
-                { first: 'bill' },
-                { first: 'bob' },
+                { name: 'ry' },
+                { name: 'tay' },
+                { name: 'bill' },
+                { name: 'bob' },
             ];
             const results = yield db.create(this.collectionName, values);
             assert.isLength(results, values.length);
@@ -324,7 +517,7 @@ const databaseAssertUtil = {
     },
     assertCanUpdateMany(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.create(this.collectionName, [
                 {
                     name: 'one',
@@ -346,37 +539,38 @@ const databaseAssertUtil = {
     },
     assertCanQueryWithOr(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            const id1 = generateId();
-            const id2 = generateId();
+            const db = yield connectToDabatase(connect);
+            const name1 = generateId();
+            const name2 = generateId();
+            assert.isFunction(db.create, 'db.create() must be a function that creates records and returns it.');
             yield db.create(this.collectionName, [
                 {
                     isPublic: true,
-                    id: id1,
+                    name: name1,
                 },
                 {
-                    id: id2,
+                    name: name2,
                 },
             ]);
-            const matches = yield db.find(this.collectionName, {
-                $or: [{ isPublic: true }, { id: id2 }],
-            });
-            assert.isLength(matches, 2);
+            yield this._assert$orReturnsExpectedTotalRecords(db, [{ isPublic: true }, { name: name2 }], 2);
+            yield this._assert$orReturnsExpectedTotalRecords(db, [{ isPublic: true }], 1);
             yield this.shutdown(db);
         });
     },
     assertCanUpdate(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const inserted = yield db.createOne(this.collectionName, {
                 id: db.generateId(),
                 name: 'first',
             });
-            assert.isString(inserted.id);
-            assert.isEqual(inserted.name, 'first');
+            assert.isTruthy(inserted, 'createOne needs to return the record that was inserted!');
+            assert.isTruthy(inserted.id, `an id must be return with the record from createOne!`);
+            assert.isEqual(inserted.name, 'first', 'name did not set as expected on the inserted record');
             const updated = yield db.updateOne(this.collectionName, { id: inserted.id }, {
                 name: 'updated',
             });
+            assert.isTruthy(updated, `updateOne needs to return the record that was updated!`);
             assert.isEqual(updated.id, inserted.id);
             assert.isEqual(updated.name, 'updated');
             yield this.shutdown(db);
@@ -384,7 +578,7 @@ const databaseAssertUtil = {
     },
     assertCanSortById(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createOne(this.collectionName, {
                 id: db.generateId(),
                 name: 'first',
@@ -418,26 +612,33 @@ const databaseAssertUtil = {
     },
     assertCanCreateMultiFieldUniqueIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, [
                 'uniqueField',
                 'uniqueField2',
             ]);
             yield db.createOne(this.collectionName, {
+                name: generateId(),
                 uniqueField: 'hello world',
                 uniqueField2: 'hello again',
             });
             yield db.createOne(this.collectionName, {
+                name: generateId(),
                 uniqueField: 'hello world',
                 uniqueField2: 'unique',
             });
             let err = (yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+                name: generateId(),
                 uniqueField: 'hello world',
                 uniqueField2: 'unique',
-            })));
+            }), undefined, `createOne() should throw a SpruceError with the code: DUPLICATE_RECORD`));
+            lowerCaseErrorDuplicateFields(err);
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['uniqueField', 'uniqueField2'],
+                duplicateFields: [
+                    'uniqueField'.toLowerCase(),
+                    'uniqueField2'.toLowerCase(),
+                ],
                 duplicateValues: ['hello world', 'unique'],
                 action: 'create',
             });
@@ -445,6 +646,7 @@ const databaseAssertUtil = {
                 uniqueField: 'hello world',
                 uniqueField2: 'unique',
             }, {
+                name: generateId(),
                 uniqueField: 'hello world',
                 uniqueField2: 'unique2',
             });
@@ -452,12 +654,17 @@ const databaseAssertUtil = {
                 uniqueField: 'hello world',
                 uniqueField2: 'unique2',
             }, {
+                name: generateId(),
                 uniqueField: 'hello world',
                 uniqueField2: 'hello again',
-            })));
+            }), undefined, 'upsertOne() should throw a SpruceError with the code: DUPLICATE_RECORD'));
+            lowerCaseErrorDuplicateFields(err);
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['uniqueField', 'uniqueField2'],
+                duplicateFields: [
+                    'uniqueField'.toLowerCase(),
+                    'uniqueField2'.toLowerCase(),
+                ],
                 duplicateValues: ['hello world', 'hello again'],
                 action: 'upsertOne',
             });
@@ -466,37 +673,47 @@ const databaseAssertUtil = {
     },
     assertSettingUniqueIndexViolationThrowsSpruceError(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['randomUniqueField']);
             yield db.createOne(this.collectionName, {
                 uniqueField: 'hello world',
                 randomUniqueField: '1',
+                name: generateId(),
             });
             yield db.createOne(this.collectionName, {
                 uniqueField: 'hello world',
                 randomUniqueField: '2',
+                name: generateId(),
             });
             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();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['uniqueField']);
             yield db.createOne(this.collectionName, {
                 uniqueField: 'hello world',
+                name: generateId(),
+            });
+            let err = yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+                uniqueField: 'hello world',
+                name: generateId(),
+            }));
+            lowerCaseErrorDuplicateFields(err);
+            errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+                duplicateFields: ['uniquefield'],
+                duplicateValues: ['hello world'],
+                collectionName: this.collectionName,
             });
-            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();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['otherField']);
             yield db.createUniqueIndex(this.collectionName, ['someField']);
             db.createUniqueIndex = () => {
@@ -514,24 +731,24 @@ const databaseAssertUtil = {
     },
     assertSyncingUniqueIndexesRemovesExtraIndexes(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.syncUniqueIndexes(this.collectionName, [
                 ['uniqueField'],
                 ['someField'],
                 ['otherField', 'otherField2'],
             ]);
             let indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 3);
+            assert.isLength(indexes, 3, 'syncUniqueIndexes() should have created 3 indexes.');
             yield db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
             indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 1);
-            assert.isEqual(indexes[0][0], 'uniqueField');
+            assert.isEqual(indexes[0][0].toLowerCase(), 'uniquefield');
             yield this.shutdown(db);
         });
     },
     assertSyncingUniqueIndexsSkipsExistingIndexs(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
             let indexes = yield db.getUniqueIndexes(this.collectionName);
             assert.isLength(indexes, 1);
@@ -547,54 +764,66 @@ const databaseAssertUtil = {
     },
     assertSyncingUniqueIndexsAddsMissingIndexes(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
             let indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 1);
+            assert.isLength(indexes, 1, 'There should be 1 index after syncing.');
             yield db.syncUniqueIndexes(this.collectionName, [['someField']]);
             indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 1);
+            assert.isLength(indexes, 1, 'There should now be 2 indexes after syncing.');
             yield db.syncUniqueIndexes(this.collectionName, [
                 ['uniqueField'],
                 ['someField'],
             ]);
             indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 2);
+            assert.isLength(indexes, 2, 'There should still be 2 indexes after syncing.');
             yield this.shutdown(db);
         });
     },
     assertCantDropCompoundUniqueIndexThatDoesntExist(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(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');
+            lowerCaseMissingIndexValues(err);
+            errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+                collectionName: this.collectionName,
+                missingIndex: ['uniquefield', 'someotherfield'],
+            });
             yield this.shutdown(db);
         });
     },
     assertCantDropIndexWhenNoIndexExists(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const err = yield assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField']));
-            errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+            lowerCaseMissingIndexValues(err);
+            errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+                collectionName: this.collectionName,
+                missingIndex: ['someotherfield'],
+            });
             yield this.shutdown(db);
         });
     },
     assertCantDropUniqueIndexThatDoesntExist(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['someField']);
             const err = yield assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField']));
-            errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+            lowerCaseMissingIndexValues(err);
+            errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+                collectionName: this.collectionName,
+                missingIndex: ['someotherfield'],
+            });
             yield this.shutdown(db);
         });
     },
     assertCanDropCompoundUniqueIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['someField', 'otherField']);
             yield db.dropIndex(this.collectionName, ['someField', 'otherField']);
             let indexes = yield db.getUniqueIndexes(this.collectionName);
@@ -609,11 +838,11 @@ const databaseAssertUtil = {
     },
     assertCanDropUniqueIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['someField']);
             yield db.dropIndex(this.collectionName, ['someField']);
             let indexes = yield db.getUniqueIndexes(this.collectionName);
-            assert.isLength(indexes, 0);
+            assert.isLength(indexes, 0, 'getUniqueIndexes() still returned an index even though it should not have after dropIndex().');
             yield db.createUniqueIndex(this.collectionName, ['someField2']);
             yield db.createUniqueIndex(this.collectionName, ['someField3']);
             yield db.dropIndex(this.collectionName, ['someField3']);
@@ -624,18 +853,14 @@ const databaseAssertUtil = {
     },
     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');
+            const db = yield connectToDabatase(connect);
+            yield assertCantCreateUniqueIndexTwice(db, this.collectionName, ['uniqueField'], 1);
             yield this.shutdown(db);
         });
     },
     assertSyncingUniqueIndexesIsRaceProof(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const syncs = [
                 db.syncUniqueIndexes(this.collectionName, [
                     ['otherField', 'otherField2'],
@@ -674,25 +899,32 @@ const databaseAssertUtil = {
     },
     assertUniqueIndexBlocksDuplicates(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, ['uniqueField']);
             yield db.createOne(this.collectionName, {
                 uniqueField: 'hello world',
+                name: 'hello world',
             });
-            let err = (yield assert.doesThrowAsync(() => db.createOne(this.collectionName, { uniqueField: 'hello world' })));
+            let err = (yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+                uniqueField: 'hello world',
+                name: 'hello world',
+            })));
+            lowerCaseStringArray(err, 'duplicateFields');
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['uniqueField'],
+                duplicateFields: ['uniquefield'],
                 duplicateValues: ['hello world'],
                 action: 'create',
             });
             const created = yield db.createOne(this.collectionName, {
                 uniqueField: 'pass',
+                name: 'hello world',
             });
             err = (yield assert.doesThrowAsync(() => db.updateOne(this.collectionName, { id: created.id }, { uniqueField: 'hello world' })));
+            lowerCaseStringArray(err, 'duplicateFields');
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['uniqueField'],
+                duplicateFields: ['uniquefield'],
                 duplicateValues: ['hello world'],
                 action: 'updateOne',
             });
@@ -700,17 +932,20 @@ const databaseAssertUtil = {
             for (let c = 0; c <= 10; c++) {
                 promises.push(db.createOne(this.collectionName, {
                     uniqueField: 'fast',
+                    name: 'hello world',
                 }));
             }
             err = (yield assert.doesThrowAsync(() => Promise.all(promises)));
+            lowerCaseStringArray(err, 'duplicateFields');
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
-                duplicateFields: ['uniqueField'],
+                duplicateFields: ['uniquefield'],
                 duplicateValues: ['fast'],
             });
             promises = [];
             for (let c = 0; c <= 10; c++) {
                 promises.push(db.upsertOne(this.collectionName, { uniqueField: `${c}` }, {
                     uniqueField: 'upsertFast',
+                    name: 'hello world',
                 }));
             }
             err = (yield assert.doesThrowAsync(() => Promise.all(promises)));
@@ -719,13 +954,21 @@ const databaseAssertUtil = {
         });
     },
     assertCanCreateUniqueIndexOnNestedField(connect) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            yield db.createUniqueIndex(this.collectionName, [
-                'target.organizationId',
-                'slug',
-            ]);
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            try {
+                yield db.createUniqueIndex(this.collectionName, [
+                    'target.organizationId',
+                    'slug',
+                ]);
+            }
+            catch (err) {
+                assert.fail((_a = `Trying to create a unique index on target.organizationId and slug failed.\n\n` +
+                    err.stack) !== null && _a !== void 0 ? _a : err.message);
+            }
             yield db.createOne(this.collectionName, {
+                name: generateId(),
                 target: {
                     organizationId: 'go!',
                     locationId: null,
@@ -733,6 +976,7 @@ const databaseAssertUtil = {
                 slug: 'a slug',
             });
             const err = yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+                name: generateId(),
                 target: {
                     organizationId: 'go!',
                     locationId: null,
@@ -750,6 +994,7 @@ const databaseAssertUtil = {
                     organizationId: 'go!',
                 },
             }, {
+                name: 'test',
                 target: {
                     organizationId: 'go 2!',
                     locationId: null,
@@ -761,8 +1006,11 @@ const databaseAssertUtil = {
     },
     assertCanPushToArrayOnUpsert(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            const record = yield db.createOne(this.collectionName, { names: [] });
+            const db = yield connectToDabatase(connect);
+            const record = yield db.createOne(this.collectionName, {
+                name: 'test',
+                names: [],
+            });
             yield db.updateOne(this.collectionName, {
                 id: record.id,
             }, {
@@ -775,23 +1023,23 @@ const databaseAssertUtil = {
     },
     assertCanSearchByRegex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.create(this.collectionName, [
                 {
                     name: 'first',
-                    subObject: {
+                    target: {
                         score: 1,
                     },
                 },
                 {
                     name: 'second',
-                    subObject: {
+                    target: {
                         score: 2,
                     },
                 },
                 {
                     name: 'third',
-                    subObject: {
+                    target: {
                         score: 2,
                     },
                 },
@@ -801,29 +1049,29 @@ const databaseAssertUtil = {
                 {
                     name: 'first',
                 },
-            ]);
+            ], 'Searching by regex failed.!');
             yield this.shutdown(db);
         });
     },
     assertCanReturnOnlySelectFields(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.create(this.collectionName, [
                 {
                     name: 'first',
-                    subObject: {
+                    target: {
                         score: 1,
                     },
                 },
                 {
                     name: 'second',
-                    subObject: {
+                    target: {
                         score: 2,
                     },
                 },
                 {
                     name: 'third',
-                    subObject: {
+                    target: {
                         score: 2,
                     },
                 },
@@ -840,26 +1088,30 @@ const databaseAssertUtil = {
                     name: 'third',
                 },
             ]);
-            const first = yield db.findOne(this.collectionName, {}, { includeFields: ['subObject'] });
+            const first = yield db.findOne(this.collectionName, {}, { includeFields: ['target'] });
             assert.isEqualDeep(first, {
-                subObject: {
+                target: {
                     score: 1,
                 },
             });
             yield this.shutdown(db);
         });
     },
-    assertThrowsWithoutDatabaseName(connect) {
+    assertThrowsWithBadDatabaseName(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const err = yield assert.doesThrowAsync(() => connect(undefined, 'undefined'));
+            const { db, connectionStringWithRandomBadDatabaseName: connectionStringWithRandomBadDatabaseeName, badDatabaseName, } = yield connect();
+            yield this.shutdown(db);
+            const err = yield assert.doesThrowAsync(() => connect(connectionStringWithRandomBadDatabaseeName));
             errorAssert.assertError(err, 'INVALID_DATABASE_NAME', {
-                suppliedName: 'undefined',
+                suppliedName: badDatabaseName,
             });
         });
     },
     assertThrowsWhenCantConnect(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const err = yield assert.doesThrowAsync(() => connect('mongodb://localhost:9999'));
+            const { db, scheme } = yield connect();
+            yield this.shutdown(db);
+            const err = yield assert.doesThrowAsync(() => connect(`${scheme}localhost:9999`));
             errorAssert.assertError(err, 'UNABLE_TO_CONNECT_TO_DB');
         });
     },
@@ -871,101 +1123,107 @@ const databaseAssertUtil = {
     },
     assertKnowsIfConnectionClosed(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            assert.isTrue(db.isConnected());
+            const db = yield connectToDabatase(connect);
+            assert.isFunction(db.isConnected, `db.isConnected() needs to be a function!`);
+            assert.isTrue(db.isConnected(), 'isConnected() should return true when connected');
             yield db.close();
-            assert.isFalse(db.isConnected());
+            assert.isFalse(db.isConnected(), 'isConnected() should return false when disconnected (after calling db.close())');
+            yield this.shutdown(db);
         });
     },
     assertCanQueryPathWithDotSyntax(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.create(this.collectionName, [
                 {
                     name: 'first',
-                    subObject: {
+                    target: {
                         score: 1,
                     },
                 },
                 {
                     name: 'second',
-                    subObject: {
+                    target: {
                         score: 2,
                     },
                 },
                 {
                     name: 'third',
-                    subObject: {
+                    target: {
                         score: 2,
                     },
                 },
             ]);
             const secondMatch = yield db.findOne(this.collectionName, {
-                'subObject.score': 2,
+                'target.score': 2,
             });
-            assert.isTruthy(secondMatch);
+            assert.isTruthy(secondMatch, 'Could not match on path with dot syntax.');
             assert.isEqual(secondMatch.name, 'second');
             yield this.shutdown(db);
         });
     },
     assertCanQueryByGtLtGteLte(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const created = yield db.create(this.collectionName, [
                 {
-                    position: 1,
+                    number: 1,
+                    name: generateId(),
                 },
                 {
-                    position: 2,
+                    number: 2,
+                    name: generateId(),
                 },
                 {
-                    position: 3,
+                    number: 3,
+                    name: generateId(),
                 },
                 {
-                    position: 4,
+                    number: 4,
+                    name: generateId(),
                 },
             ]);
             const gtMatches = yield db.find(this.collectionName, {
-                id: { $gt: created[2].id },
+                number: { $gt: 3 },
             });
-            assert.isLength(gtMatches, 1);
-            assert.isEqual(gtMatches[0].position, 4);
+            assert.isLength(gtMatches, 1, 'Expected 1 match for $gt: 3');
+            assert.isEqual(gtMatches[0].number, 4, 'Did not match the expected result for $gt: 3');
             const gteMatches = yield db.find(this.collectionName, {
-                id: { $gte: created[2].id },
+                number: { $gte: created[2].number },
             });
             assert.isLength(gteMatches, 2);
-            assert.isEqual(gteMatches[0].position, 3);
-            assert.isEqual(gteMatches[1].position, 4);
+            assert.isEqual(gteMatches[0].number, 3);
+            assert.isEqual(gteMatches[1].number, 4);
             const ltMatches = yield db.find(this.collectionName, {
-                id: { $lt: created[2].id },
+                number: { $lt: created[2].number },
             });
             assert.isLength(ltMatches, 2);
-            assert.isEqual(ltMatches[0].position, 1);
-            assert.isEqual(ltMatches[1].position, 2);
+            assert.isEqual(ltMatches[0].number, 1);
+            assert.isEqual(ltMatches[1].number, 2);
             const lteMatches = yield db.find(this.collectionName, {
-                id: { $lte: created[2].id },
+                number: { $lte: created[2].number },
             });
             assert.isLength(lteMatches, 3);
-            assert.isEqual(lteMatches[0].position, 1);
-            assert.isEqual(lteMatches[1].position, 2);
-            assert.isEqual(lteMatches[2].position, 3);
+            assert.isEqual(lteMatches[0].number, 1);
+            assert.isEqual(lteMatches[1].number, 2);
+            assert.isEqual(lteMatches[2].number, 3);
             yield this.shutdown(db);
         });
     },
     assertCanFindWithNe(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const record1 = yield db.createOne(this.collectionName, {
-                foo: 'bar',
-                hello: 'world',
+                name: 'bar',
+                someField: 'world',
             });
             yield db.createOne(this.collectionName, {
-                foo: 'bar2',
-                hello: 'world',
+                name: 'bar2',
+                someField: 'world',
             });
             yield db.createOne(this.collectionName, {
-                foo: 'bar3',
-                hello: 'planet',
+                name: 'bar3',
+                someField: 'planet',
             });
             const query = { id: { $ne: record1.id } };
             const results = yield db.find(this.collectionName, query);
@@ -975,18 +1233,18 @@ const databaseAssertUtil = {
     },
     assertCanFindWithIn(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const record1 = yield db.createOne(this.collectionName, {
-                foo: 'bar',
-                hello: 'world',
+                name: 'bar',
+                otherField: 'world',
             });
             const record2 = yield db.createOne(this.collectionName, {
-                foo: 'bar2',
-                hello: 'world',
+                name: 'bar2',
+                otherField: 'world',
             });
             const record3 = yield db.createOne(this.collectionName, {
-                foo: 'bar3',
-                hello: 'planet',
+                name: 'bar3',
+                otherField: 'planet',
             });
             const query = { id: { $in: [record1.id, record2.id, record3.id] } };
             const results = yield db.find(this.collectionName, query);
@@ -994,20 +1252,42 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
+    assertCanFindWithBooleanField(connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            const first = yield db.createOne(this.collectionName, {
+                name: generateId(),
+                isPublic: true,
+            });
+            const second = yield db.createOne(this.collectionName, {
+                name: generateId(),
+                isPublic: false,
+            });
+            const firstMatch = yield db.findOne(this.collectionName, {
+                isPublic: true,
+            });
+            assert.isEqualDeep(firstMatch, first, `Searching where boolean field is true failed.`);
+            const secondMatch = yield db.findOne(this.collectionName, {
+                isPublic: false,
+            });
+            assert.isEqualDeep(secondMatch, second, `Searching where boolean field is false failed.`);
+            yield this.shutdown(db);
+        });
+    },
     assertCanCountOnId(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const first = yield db.createOne(this.collectionName, {
-                foo: 'bar',
-                hello: 'world',
+                name: 'bar',
+                otherField: 'world',
             });
             const second = yield db.createOne(this.collectionName, {
-                foo: 'bar2',
-                hello: 'world',
+                name: 'bar2',
+                otherField: 'world',
             });
             const third = yield db.createOne(this.collectionName, {
-                foo: 'bar3',
-                hello: 'planet',
+                name: 'bar3',
+                otherField: 'planet',
             });
             const countFirst = yield db.count(this.collectionName, { id: first.id });
             const countSecond = yield db.count(this.collectionName, {
@@ -1024,82 +1304,99 @@ const databaseAssertUtil = {
     },
     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 db = yield connectToDabatase(connect);
+            yield db.createOne(this.collectionName, {
+                name: 'bar',
+                otherField: 'world',
+            });
+            yield db.createOne(this.collectionName, {
+                name: 'bar2',
+                otherField: 'world',
+            });
+            yield db.createOne(this.collectionName, {
+                name: 'bar3',
+                otherField: 'planet',
+            });
             const countAll = yield db.count(this.collectionName);
             assert.isEqual(countAll, 3);
             yield this.shutdown(db);
         });
     },
     assertCanUpsertNull(connect) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const createdUndefined = yield db.upsertOne(this.collectionName, {
                 undefinedField: undefined,
             }, {
                 undefinedField: undefined,
+                name: generateId(),
             });
             assert.isTruthy(createdUndefined);
-            assert.isNull(createdUndefined.undefinedField);
+            assert.isTrue(createdUndefined.undefinedField === null ||
+                createdUndefined.undefinedfield === null);
             const createdNull = yield db.upsertOne(this.collectionName, {
                 nullField: null,
+                name: '234',
             }, {
                 nullField: null,
+                name: generateId(),
             });
             assert.isTruthy(createdNull);
             let all = yield db.find(this.collectionName);
-            assert.isLength(all, 2);
+            assert.isLength(all, 2, 'I expected to find 2 records after 2 upserts.');
             const updatedUndefined = yield db.upsertOne(this.collectionName, {
                 undefinedField: undefined,
             }, { undefinedField: 'now defined' });
             assert.isEqual(updatedUndefined.id, createdUndefined.id);
-            assert.isEqual(updatedUndefined.undefinedField, 'now defined');
+            assert.isEqual((_a = updatedUndefined.undefinedField) !== null && _a !== void 0 ? _a : 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');
+            assert.isEqual((_b = updatedNull.nullField) !== null && _b !== void 0 ? _b : updatedNull.nullfield, 'now defined', 'nullField should have upserted to "now defined"');
             all = yield db.find(this.collectionName);
             assert.isLength(all, 2);
             yield this.shutdown(db);
         });
     },
     assertCanSaveAndGetNullAndUndefined(connect) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const created = yield db.createOne(this.collectionName, {
                 undefinedField: undefined,
                 nullField: null,
+                name: 'hey',
             });
-            assert.isNull(created.undefinedField);
-            assert.isNull(created.nullField);
+            assert.isTrue(created.undefinedField === null || created.undefinedfield === null, 'undefinedField should be null');
+            assert.isTrue(created.nullField === null || created.nullfield === null, 'nullField should be null');
             const matchedUndefined = yield db.findOne(this.collectionName, {
                 undefinedField: undefined,
             });
             assert.isTruthy(matchedUndefined);
-            assert.isNull(matchedUndefined.undefinedField);
+            assert.isTrue(matchedUndefined.undefinedField === null ||
+                matchedUndefined.undefinedfield === null, 'findOne should return null for undefinedField');
             const matchedNull = yield db.findOne(this.collectionName, {
                 nullField: null,
             });
             assert.isTruthy(matchedNull);
-            assert.isNull(matchedNull.nullField);
+            assert.isTrue(matchedNull.nullField === null || matchedNull.nullfield === null, 'findOne should return null for 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');
+            assert.isEqual((_a = updatedUndefined.undefinedField) !== null && _a !== void 0 ? _a : updatedUndefined.undefinedfield, 'now defined');
             const updatedNull = yield db.updateOne(this.collectionName, {
                 nullField: null,
             }, { nullField: 'now defined' });
-            assert.isEqual(updatedNull.nullField, 'now defined');
+            assert.isEqual((_b = updatedNull.nullField) !== null && _b !== void 0 ? _b : updatedNull.nullfield, 'now defined');
             yield this.shutdown(db);
         });
     },
     assertSyncIndexesDoesNotRemoveExisting(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['otherField']);
             yield db.createIndex(this.collectionName, ['someField']);
             db.createIndex = () => {
@@ -1114,29 +1411,29 @@ const databaseAssertUtil = {
     },
     assertSyncIndexesRemovesExtraIndexes(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.syncIndexes(this.collectionName, [
-                ['field'],
+                ['name'],
                 ['someField'],
                 ['otherField', 'otherField2'],
             ]);
             let indexes = yield this._getFilteredIndexes(db);
             assert.isLength(indexes, 3);
-            yield db.syncIndexes(this.collectionName, [['field']]);
+            yield db.syncIndexes(this.collectionName, [['name']]);
             indexes = yield this._getFilteredIndexes(db);
             assert.isLength(indexes, 1);
-            assert.isEqual(indexes[0][0], 'field');
+            assert.isEqual(indexes[0][0], 'name');
             yield this.shutdown(db);
         });
     },
     assertSyncIndexesSkipsExisting(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            yield db.syncIndexes(this.collectionName, [['field']]);
+            const db = yield connectToDabatase(connect);
+            yield db.syncIndexes(this.collectionName, [['name']]);
             let indexes = yield this._getFilteredIndexes(db);
             assert.isLength(indexes, 1);
             yield db.syncIndexes(this.collectionName, [
-                ['field'],
+                ['name'],
                 ['someField'],
                 ['otherField', 'otherField2'],
             ]);
@@ -1147,16 +1444,19 @@ const databaseAssertUtil = {
     },
     assertCantDropCompoundIndexThatDoesNotExist(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(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');
+            errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+                collectionName: this.collectionName,
+                missingIndex: ['uniqueField', 'someOtherField'],
+            });
             yield this.shutdown(db);
         });
     },
     assertCanDropCompoundIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['someField', 'otherField']);
             yield db.dropIndex(this.collectionName, ['someField', 'otherField']);
             let indexes = yield this._getFilteredIndexes(db);
@@ -1171,7 +1471,7 @@ const databaseAssertUtil = {
     },
     assertCanDropIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createIndex(this.collectionName, ['someField']);
             yield db.dropIndex(this.collectionName, ['someField']);
             let indexes = yield this._getFilteredIndexes(db);
@@ -1184,58 +1484,70 @@ const databaseAssertUtil = {
             yield this.shutdown(db);
         });
     },
-    assertCanCreateMultiFieldIndex(connect, fields) {
+    assertCanCreateMultiFieldIndex(connect) {
         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);
+            yield this._assertCanCreateMultiFieldIndex(connect, [
+                'otherField',
+                'someField',
+            ]);
+            yield this._assertCanCreateMultiFieldIndex(connect, [
+                'someField',
+                'otherField',
+            ]);
+            yield this._assertCanCreateMultiFieldIndex(connect, [
+                'otherField',
+                'otherField2',
+            ]);
+            yield this._assertCanCreateMultiFieldIndex(connect, [
+                'otherField2',
+                'otherField',
+            ]);
         });
     },
     assertCantCreateSameIndexTwice(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            yield db.createIndex(this.collectionName, ['field']);
+            const db = yield connectToDabatase(connect);
+            yield db.createIndex(this.collectionName, ['name']);
             let indexes = yield this._getFilteredIndexes(db);
             assert.isLength(indexes, 1);
-            const err = yield assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['field']));
+            const err = yield assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['name']));
             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']);
+            const db = yield connectToDabatase(connect);
+            yield db.createIndex(this.collectionName, ['uniqueField']);
             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']);
+            assert.isArray(indexes, 'getIndexes() should return an array!');
+            assert.isLength(indexes, 1, 'getIndexes() should return the one index that was created!');
+            assert.isLength(indexes[0], 1, 'getIndexes() should return an array of arrays! It should be returing the first index I created!');
+            assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase());
+            yield db.createIndex(this.collectionName, ['uniqueField2']);
             indexes = yield this._getFilteredIndexes(db);
             assert.isLength(indexes, 2);
-            assert.isEqual(indexes[1][0], 'field2');
-            yield db.createIndex(this.collectionName, ['field3', 'field4']);
+            assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
+            yield db.createIndex(this.collectionName, ['uniqueField3', 'uniqueField4']);
             indexes = yield this._getFilteredIndexes(db);
             assert.isLength(indexes, 3);
-            assert.isEqual(indexes[2][0], 'field3');
-            assert.isEqual(indexes[2][1], 'field4');
+            assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
+            assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
             yield this.shutdown(db);
         });
     },
     assertHasNoIndexToStart(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const indexes = yield db.getIndexes(this.collectionName);
             assert.isLength(indexes, 0);
             yield this.shutdown(db);
         });
     },
     assertNestedFieldIndexUpdates(connect) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.createUniqueIndex(this.collectionName, [
                 'target.organizationId',
                 'slug',
@@ -1245,6 +1557,7 @@ const databaseAssertUtil = {
                     organizationId: 'go!',
                 },
                 aNonIndexedField: true,
+                name: 'squirrel',
                 slug: 'a slug',
             });
             const updated = yield db.updateOne(this.collectionName, { id: results.id }, {
@@ -1254,13 +1567,13 @@ const databaseAssertUtil = {
                 aNonIndexedField: false,
                 slug: 'a slug',
             });
-            assert.isEqual(updated.aNonIndexedField, false);
+            assert.isEqual((_a = updated.aNonIndexedField) !== null && _a !== void 0 ? _a : updated.anonindexedfield, false);
             yield this.shutdown(db);
         });
     },
     assertUpsertWithUniqueIndex(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             yield db.syncUniqueIndexes(this.collectionName, [
                 ['name', 'target.organizationId'],
                 ['slug', 'target.organizationId'],
@@ -1286,7 +1599,7 @@ const databaseAssertUtil = {
     },
     assertSyncIndexesHandlesRaceConditions(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
+            const db = yield connectToDabatase(connect);
             const syncs = [
                 db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
                 db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
@@ -1305,35 +1618,98 @@ const databaseAssertUtil = {
     },
     assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected(connect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield connect();
-            yield db.createUniqueIndex(this.collectionName, ['uniqueField1']);
+            const db = yield connectToDabatase(connect);
+            yield db.createUniqueIndex(this.collectionName, ['uniqueField']);
             yield db.createUniqueIndex(this.collectionName, ['uniqueField2']);
             yield db.createOne(this.collectionName, {
-                uniqueField1: 'unique field 1',
+                name: generateId(),
+                uniqueField: 'unique field 1',
                 uniqueField2: 'unique field 2',
             });
             let err = yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
-                uniqueField1: 'unique field 1',
+                name: generateId(),
+                uniqueField: 'unique field 1',
                 uniqueField2: 'unique field 2',
             }));
+            lowerCaseStringArray(err, 'duplicateFields');
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['uniqueField1'],
+                duplicateFields: ['uniquefield'],
                 duplicateValues: ['unique field 1'],
                 action: 'create',
             });
             err = yield assert.doesThrowAsync(() => db.createOne(this.collectionName, {
-                uniqueField1: 'unique field 1.0',
+                name: generateId(),
+                uniqueField: 'unique field 1.0',
                 uniqueField2: 'unique field 2',
             }));
+            lowerCaseStringArray(err, 'duplicateFields');
             errorAssert.assertError(err, 'DUPLICATE_RECORD', {
                 collectionName: this.collectionName,
-                duplicateFields: ['uniqueField2'],
+                duplicateFields: ['uniquefield2'],
                 duplicateValues: ['unique field 2'],
                 action: 'create',
             });
             yield this.shutdown(db);
         });
     },
+    _assertThrowsExpectedNotFoundOnUpdateOne(db, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const err = (yield assert.doesThrowAsync(() => db.updateOne(this.collectionName, query, { name: 'bar' }), undefined, `updateOne should throw a RECORD_NOT_FOUND when updating a record that cannot be found!`));
+            errorAssert.assertError(err, 'RECORD_NOT_FOUND', {
+                query,
+            });
+        });
+    },
+    _assert$orReturnsExpectedTotalRecords(db, $or, expected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matches = yield db.find(this.collectionName, {
+                $or,
+            });
+            assert.isLength(matches, expected);
+        });
+    },
+    _assertCanCreateMultiFieldIndex(connect, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield connectToDabatase(connect);
+            yield db.createIndex(this.collectionName, fields);
+            const indexes = yield this._getFilteredIndexes(db);
+            assert.isLength(indexes, 1, `getIndexes() should return the index it created. I expected 1 but got ${indexes.length}. Also, make sure you clear the indexes when resetting the database!`);
+            assert.isEqualDeep(indexes[0].map((i) => i.toLowerCase()), fields.map((f) => f.toLowerCase()));
+            yield this.shutdown(db);
+        });
+    },
 };
 export default databaseAssertUtil;
+function assertCantCreateUniqueIndexTwice(db, collectionName, fields, expectedTotalUniqueIndexes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield db.createUniqueIndex(collectionName, fields);
+        let indexes = yield db.getUniqueIndexes(collectionName);
+        assert.isLength(indexes, expectedTotalUniqueIndexes, 'getUniqueIndexes() should return total unique indexs');
+        const err = yield assert.doesThrowAsync(() => db.createUniqueIndex(collectionName, ['uniqueField']), undefined, 'createUniqueIndex() should throw a DataStoreError({code: "INDEX_EXISTS"}) error.');
+        errorAssert.assertError(err, 'INDEX_EXISTS', {
+            collectionName,
+            index: ['uniqueField'],
+        });
+    });
+}
+function lowerCaseErrorDuplicateFields(err) {
+    lowerCaseStringArray(err, 'duplicateFields');
+}
+function lowerCaseMissingIndexValues(err) {
+    lowerCaseStringArray(err, 'missingIndex');
+}
+function lowerCaseStringArray(err, key) {
+    var _a, _b;
+    //@ts-ignore
+    if ((_b = (_a = err.options) === null || _a === void 0 ? void 0 : _a[key]) === null || _b === void 0 ? void 0 : _b.map) {
+        //@ts-ignore
+        err.options[key] = err.options[key].map((i) => i.toLowerCase());
+    }
+}
+function connectToDabatase(connect) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { db } = yield connect();
+        return db;
+    });
+}