@sprucelabs/data-stores 19.3.3 → 20.0.1

package/build/tests/databaseAssertUtil.js

@@ -6,16 +6,109 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const schema_1 = require("@sprucelabs/schema");
 const test_utils_1 = require("@sprucelabs/test-utils");
 const test_utils_2 = require("@sprucelabs/test-utils");
-const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const generateId_1 = __importDefault(require("../utilities/generateId"));
-const pluckAssertionMethods_1 = __importDefault(require("./pluckAssertionMethods"));
 const databaseAssertUtil = {
     collectionName: 'test_collection',
-    async runSuite(connect) {
+    async runSuite(connect, tests) {
         (0, schema_1.assertOptions)({ connect }, ['connect']);
-        const methods = (0, pluckAssertionMethods_1.default)(this);
-        //@ts-ignore
-        await 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 = await connectToDabatase(connect);
+        await db.dropDatabase();
+        await this.shutdown(db);
+        const toRun = tests !== null && tests !== void 0 ? tests : methods;
+        for (const method of toRun) {
+            try {
+                //@ts-ignore
+                await this[method](connect);
+            }
+            catch (err) {
+                const prefix = `Error in ${method}:\n\n `;
+                err.message = `${prefix} ${err.message}`;
+                err.stack = `${prefix} ${err.stack}`;
+                throw err;
+            }
+        }
     },
     async _getFilteredIndexes(db) {
         return this._filterIdIndex(await db.getIndexes(this.collectionName));
@@ -25,15 +118,32 @@ const databaseAssertUtil = {
     },
     async _assertUpdateUpdatedRightNumberOfRecords(db, search, updates, expectedUpdateCount) {
         const updatedCount = await db.update(this.collectionName, search, updates);
-        test_utils_1.assert.isEqual(updatedCount, expectedUpdateCount);
+        test_utils_1.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 = await db.count(this.collectionName, updates);
         test_utils_1.assert.isEqual(count, expectedUpdateCount);
     },
+    async generateIdDifferentEachTime(connect) {
+        const db = await connectToDabatase(connect);
+        const id1 = db.generateId();
+        const id2 = db.generateId();
+        test_utils_1.assert.isNotEqual(id1, id2, 'generateId() must generate a different id each time');
+        await this.shutdown(db);
+    },
     async assertCanSortDesc(connect) {
-        const db = await connect();
-        await db.createOne(this.collectionName, { name: 'second', count: 1 });
-        await db.createOne(this.collectionName, { name: 'third', count: 5 });
-        await db.createOne(this.collectionName, { name: 'first', count: -1 });
+        const db = await connectToDabatase(connect);
+        const second = await db.createOne(this.collectionName, {
+            name: 'second',
+            count: 1,
+        });
+        const third = await db.createOne(this.collectionName, {
+            name: 'third',
+            count: 5,
+        });
+        const first = await db.createOne(this.collectionName, {
+            name: 'first',
+            count: -1,
+        });
+        test_utils_1.assert.isFunction(db.find, `db.find() must be a function.`);
         const results = await db.find(this.collectionName, {}, {
             sort: [
                 {
@@ -42,18 +152,23 @@ const databaseAssertUtil = {
                 },
             ],
         });
-        test_utils_1.assert.isEqual(results[0].name, 'third');
-        test_utils_1.assert.isEqual(results[1].name, 'second');
-        test_utils_1.assert.isEqual(results[2].name, 'first');
+        test_utils_1.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!`);
+        test_utils_1.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!`);
+        test_utils_1.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.`);
+        test_utils_1.assert.isEqual(results[1].name, 'second', `second record should be named "second" when sorting desc by name.`);
+        test_utils_1.assert.isEqual(results[2].name, 'first', `third record should be named "first" when sorting desc by name.`);
+        test_utils_1.assert.isEqualDeep(results[0], third, `createOne() is not returning the record that was created!`);
+        test_utils_1.assert.isEqualDeep(results[1], second, `createOne() is not returning the record that was created!`);
+        test_utils_1.assert.isEqualDeep(results[2], first, `createOne() is not returning the record that was created!`);
         const result = await db.findOne(this.collectionName, undefined, {
             sort: [{ field: 'count', direction: 'desc' }],
         });
-        test_utils_1.assert.isTruthy(result);
-        test_utils_1.assert.isEqual(result.name, 'third');
+        test_utils_1.assert.isTruthy(result, 'findOne() should return a record!');
+        test_utils_1.assert.isEqual(result.name, 'third', 'findOne() should honor sort!');
         await this.shutdown(db);
     },
     async assertCanSortAsc(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createOne(this.collectionName, { name: 'second', count: 1 });
         await db.createOne(this.collectionName, { name: 'third', count: 5 });
         await db.createOne(this.collectionName, { name: 'first', count: -1 });
@@ -65,9 +180,9 @@ const databaseAssertUtil = {
                 },
             ],
         });
-        test_utils_1.assert.isEqual(results[0].name, 'first');
-        test_utils_1.assert.isEqual(results[1].name, 'second');
-        test_utils_1.assert.isEqual(results[2].name, 'third');
+        test_utils_1.assert.isEqual(results[0].name, 'first', 'find is not sorting ascending');
+        test_utils_1.assert.isEqual(results[1].name, 'second', 'find is not sorting ascending');
+        test_utils_1.assert.isEqual(results[2].name, 'third', 'find is not sorting ascending');
         const result = await db.findOne(this.collectionName, undefined, {
             sort: [{ field: 'count', direction: 'asc' }],
         });
@@ -76,74 +191,84 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertInsertingGeneratesId(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
+        const name = (0, generateId_1.default)();
         const inserted = await db.createOne(this.collectionName, {
-            name: 'first',
+            name,
         });
-        test_utils_1.assert.isTruthy(inserted);
-        test_utils_1.assert.isString(inserted.id);
-        test_utils_1.assert.isEqual(inserted.name, 'first');
+        test_utils_1.assert.isTruthy(inserted, "createOne() didn't return anything!");
+        test_utils_1.assert.isTruthy(inserted.id, 'createOne() record id is missing!');
+        test_utils_1.assert.isEqual(inserted.name, name, 'createOne() record name field was not set to ' + name);
         await this.shutdown(db);
     },
     async assertThrowsWhenUpdatingRecordNotFound(connect) {
-        const db = await connect();
-        const err = (await test_utils_1.assert.doesThrowAsync(() => db.updateOne('unknown', { id: db.generateId() }, { foo: 'bar' })));
-        test_utils_2.errorAssert.assertError(err, 'RECORD_NOT_FOUND');
+        const db = await connectToDabatase(connect);
+        test_utils_1.assert.isFunction(db.generateId, `db.generateId() must be a function that returns a unique identifier.`);
+        test_utils_1.assert.isFunction(db.updateOne, 'You must implement updateOne() in your database adapter.');
+        await this._assertThrowsExpectedNotFoundOnUpdateOne(db, {
+            id: db.generateId(),
+        });
+        await this._assertThrowsExpectedNotFoundOnUpdateOne(db, { count: 10 });
         await this.shutdown(db);
     },
     async shutdown(db) {
-        await db.dropDatabase();
-        await db.close();
+        if (db.isConnected()) {
+            await db.dropDatabase();
+            await db.close();
+        }
     },
     async assertCanCreateUniqueIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['uniqueField']);
         let indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isLength(indexes[0], 1);
-        test_utils_1.assert.isEqual(indexes[0][0], 'uniqueField');
+        test_utils_1.assert.isLength(indexes, 1, 'getUniqueIndexes() did not return the unique index I tried to create!');
+        test_utils_1.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.');
+        test_utils_1.assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase(), 'getUniqueIndexes() did not add the expected field to the first unique index.');
         await db.createUniqueIndex(this.collectionName, ['uniqueField2']);
         indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 2);
-        test_utils_1.assert.isEqual(indexes[1][0], 'uniqueField2');
+        test_utils_1.assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
         await db.createUniqueIndex(this.collectionName, [
             'uniqueField3',
             'uniqueField4',
         ]);
         indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 3);
-        test_utils_1.assert.isEqual(indexes[2][0], 'uniqueField3');
-        test_utils_1.assert.isEqual(indexes[2][1], 'uniqueField4');
+        test_utils_1.assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
         await this.shutdown(db);
     },
     async assertHasNoUniqueIndexToStart(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 0);
+        test_utils_1.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.");
         await this.shutdown(db);
     },
-    async assertCanShutdown(connect) {
-        const db = await connect();
+    async assertCanUpsertOne(connect) {
+        const db = await connectToDabatase(connect);
         const id = db.generateId();
         const created = await db.upsertOne(this.collectionName, { id }, {
             id,
             name: 'first',
         });
-        test_utils_1.assert.isTruthy(created);
+        test_utils_1.assert.isTruthy(created, 'upsertOne() should return the record it created!');
         test_utils_1.assert.isEqual(created.name, 'first');
-        test_utils_1.assert.isEqual(created.id, id);
+        test_utils_1.assert.isEqual(`${created.id}`, `${id}`, 'ids do not match!');
         const upserted = await db.upsertOne(this.collectionName, { id }, { name: 'second' });
-        await db.upsertOne(this.collectionName, { id: db.generateId() }, { name: 'second' });
+        const id2 = db.generateId();
+        await db.upsertOne(this.collectionName, { id: id2 }, { name: 'second', id: id2 });
         test_utils_1.assert.isTruthy(upserted);
         test_utils_1.assert.isEqual(created.id, upserted.id);
         test_utils_1.assert.isEqual(upserted.name, 'second');
         const upserted2 = await db.upsertOne(this.collectionName, { id }, { name: 'third' });
         test_utils_1.assert.isTruthy(upserted2);
         test_utils_1.assert.isEqual(upserted2.name, 'third');
+        const match = await db.findOne(this.collectionName, { id });
+        test_utils_1.assert.isEqualDeep(match, upserted2, 'upsertOne() did not update the record!');
         await this.shutdown(db);
     },
     async assertCanDeleteOne(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.create(this.collectionName, [
             {
                 name: 'a record',
@@ -157,11 +282,11 @@ const databaseAssertUtil = {
         ]);
         await db.deleteOne(this.collectionName, { name: 'a record' });
         const count = await db.count(this.collectionName);
-        test_utils_1.assert.isEqual(count, 2);
+        test_utils_1.assert.isEqual(count, 2, 'deleteOne() did not delete a single record!');
         await this.shutdown(db);
     },
     async assertCanDeleteRecord(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const created = await db.createOne(this.collectionName, {
             id: db.generateId(),
             name: 'first',
@@ -178,7 +303,7 @@ const databaseAssertUtil = {
         const matchedAfterDelete = await db.findOne(this.collectionName, {
             id: created.id,
         });
-        test_utils_1.assert.isFalsy(matchedAfterDelete);
+        test_utils_1.assert.isFalsy(matchedAfterDelete, `Record with the id of ${created.id} was not deleted!`);
         await db.create(this.collectionName, [
             {
                 name: 'a record',
@@ -191,11 +316,11 @@ const databaseAssertUtil = {
             },
         ]);
         const manyDeleted = await db.delete(this.collectionName, {});
-        test_utils_1.assert.isEqual(manyDeleted, 3);
+        test_utils_1.assert.isEqual(manyDeleted, 3, `delete() did not return the total recrods deleted!`);
         await this.shutdown(db);
     },
     async assertCanLimitResultsToZero(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createOne(this.collectionName, {
             id: db.generateId(),
             name: 'first',
@@ -216,7 +341,7 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanLimitResults(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createOne(this.collectionName, {
             id: db.generateId(),
             name: 'first',
@@ -239,21 +364,22 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertFindOneOnEmptyDatabaseReturnsNull(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const results = await db.findOne(this.collectionName, { id: '111' });
         test_utils_1.assert.isFalsy(results);
         await this.shutdown(db);
     },
     async assertEmptyDatabaseReturnsEmptyArray(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const results = await db.find(this.collectionName, { id: '111' });
         test_utils_1.assert.isLength(results, 0);
         await this.shutdown(db);
     },
     async assertCanPushOntoArrayValue(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const inserted = await db.createOne(this.collectionName, {
             id: db.generateId(),
+            name: 'nope',
             names: ['first'],
         });
         const updated = await db.updateOne(this.collectionName, { id: inserted.id }, {
@@ -265,13 +391,72 @@ const databaseAssertUtil = {
         test_utils_1.assert.isEqualDeep(matched.names, ['first', 'second']);
         await this.shutdown(db);
     },
+    async assertCanCreateWithObjectField(connect) {
+        const db = await connectToDabatase(connect);
+        const values = {
+            name: 'first',
+            target: {
+                organizationId: (0, generateId_1.default)(),
+                locationId: (0, generateId_1.default)(),
+            },
+        };
+        let created;
+        try {
+            created = await db.createOne(this.collectionName, values);
+        }
+        catch (_a) {
+            test_utils_1.assert.fail('createOne() tried to create a record with an object field. Make sure the target field handles objects!');
+        }
+        const matched = await db.findOne(this.collectionName, { id: created.id });
+        test_utils_1.assert.isEqualDeep(matched, Object.assign(Object.assign({}, created), { id: matched.id }));
+        await this.shutdown(db);
+    },
+    async canUpdateWithObjectField(connect) {
+        const db = await connectToDabatase(connect);
+        const values = {
+            name: 'first',
+            target: {
+                organizationId: (0, generateId_1.default)(),
+                locationId: (0, generateId_1.default)(),
+            },
+        };
+        const created = await db.createOne(this.collectionName, values);
+        const target = {
+            organizationId: 'hey',
+            locationId: 'there',
+        };
+        await db.updateOne(this.collectionName, { id: created.id }, {
+            target,
+        });
+        const matched = await db.findOne(this.collectionName, { id: created.id });
+        test_utils_1.assert.isEqualDeep(matched.target, target);
+        await this.shutdown(db);
+    },
+    async canUpdateFieldInObjectFieldWithTargettedWhere(connect) {
+        const db = await connectToDabatase(connect);
+        const target = {
+            organizationId: (0, generateId_1.default)(),
+            locationId: (0, generateId_1.default)(),
+        };
+        const values = {
+            name: 'first',
+            target,
+        };
+        const created = await db.createOne(this.collectionName, values);
+        await db.updateOne(this.collectionName, { id: created.id }, {
+            'target.organizationId': 'oy oy',
+        });
+        const matched = await db.findOne(this.collectionName, { id: created.id });
+        test_utils_1.assert.isEqualDeep(matched.target, Object.assign(Object.assign({}, target), { organizationId: 'oy oy' }));
+        await this.shutdown(db);
+    },
     async assertCanCreateMany(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const values = [
-            { first: 'ry' },
-            { first: 'tay' },
-            { first: 'bill' },
-            { first: 'bob' },
+            { name: 'ry' },
+            { name: 'tay' },
+            { name: 'bill' },
+            { name: 'bob' },
         ];
         const results = await db.create(this.collectionName, values);
         test_utils_1.assert.isLength(results, values.length);
@@ -281,7 +466,7 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanUpdateMany(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.create(this.collectionName, [
             {
                 name: 'one',
@@ -301,41 +486,42 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanQueryWithOr(connect) {
-        const db = await connect();
-        const id1 = (0, generateId_1.default)();
-        const id2 = (0, generateId_1.default)();
+        const db = await connectToDabatase(connect);
+        const name1 = (0, generateId_1.default)();
+        const name2 = (0, generateId_1.default)();
+        test_utils_1.assert.isFunction(db.create, 'db.create() must be a function that creates records and returns it.');
         await db.create(this.collectionName, [
             {
                 isPublic: true,
-                id: id1,
+                name: name1,
             },
             {
-                id: id2,
+                name: name2,
             },
         ]);
-        const matches = await db.find(this.collectionName, {
-            $or: [{ isPublic: true }, { id: id2 }],
-        });
-        test_utils_1.assert.isLength(matches, 2);
+        await this._assert$orReturnsExpectedTotalRecords(db, [{ isPublic: true }, { name: name2 }], 2);
+        await this._assert$orReturnsExpectedTotalRecords(db, [{ isPublic: true }], 1);
         await this.shutdown(db);
     },
     async assertCanUpdate(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const inserted = await db.createOne(this.collectionName, {
             id: db.generateId(),
             name: 'first',
         });
-        test_utils_1.assert.isString(inserted.id);
-        test_utils_1.assert.isEqual(inserted.name, 'first');
+        test_utils_1.assert.isTruthy(inserted, 'createOne needs to return the record that was inserted!');
+        test_utils_1.assert.isTruthy(inserted.id, `an id must be return with the record from createOne!`);
+        test_utils_1.assert.isEqual(inserted.name, 'first', 'name did not set as expected on the inserted record');
         const updated = await db.updateOne(this.collectionName, { id: inserted.id }, {
             name: 'updated',
         });
+        test_utils_1.assert.isTruthy(updated, `updateOne needs to return the record that was updated!`);
         test_utils_1.assert.isEqual(updated.id, inserted.id);
         test_utils_1.assert.isEqual(updated.name, 'updated');
         await this.shutdown(db);
     },
     async assertCanSortById(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createOne(this.collectionName, {
             id: db.generateId(),
             name: 'first',
@@ -367,26 +553,33 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanCreateMultiFieldUniqueIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, [
             'uniqueField',
             'uniqueField2',
         ]);
         await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
             uniqueField: 'hello world',
             uniqueField2: 'hello again',
         });
         await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
             uniqueField: 'hello world',
             uniqueField2: 'unique',
         });
         let err = (await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
             uniqueField: 'hello world',
             uniqueField2: 'unique',
-        })));
+        }), undefined, `createOne() should throw a SpruceError with the code: DUPLICATE_RECORD`));
+        lowerCaseErrorDuplicateFields(err);
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['uniqueField', 'uniqueField2'],
+            duplicateFields: [
+                'uniqueField'.toLowerCase(),
+                'uniqueField2'.toLowerCase(),
+            ],
             duplicateValues: ['hello world', 'unique'],
             action: 'create',
         });
@@ -394,6 +587,7 @@ const databaseAssertUtil = {
             uniqueField: 'hello world',
             uniqueField2: 'unique',
         }, {
+            name: (0, generateId_1.default)(),
             uniqueField: 'hello world',
             uniqueField2: 'unique2',
         });
@@ -401,45 +595,60 @@ const databaseAssertUtil = {
             uniqueField: 'hello world',
             uniqueField2: 'unique2',
         }, {
+            name: (0, generateId_1.default)(),
             uniqueField: 'hello world',
             uniqueField2: 'hello again',
-        })));
+        }), undefined, 'upsertOne() should throw a SpruceError with the code: DUPLICATE_RECORD'));
+        lowerCaseErrorDuplicateFields(err);
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['uniqueField', 'uniqueField2'],
+            duplicateFields: [
+                'uniqueField'.toLowerCase(),
+                'uniqueField2'.toLowerCase(),
+            ],
             duplicateValues: ['hello world', 'hello again'],
             action: 'upsertOne',
         });
         await this.shutdown(db);
     },
     async assertSettingUniqueIndexViolationThrowsSpruceError(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['randomUniqueField']);
         await db.createOne(this.collectionName, {
             uniqueField: 'hello world',
             randomUniqueField: '1',
+            name: (0, generateId_1.default)(),
         });
         await db.createOne(this.collectionName, {
             uniqueField: 'hello world',
             randomUniqueField: '2',
+            name: (0, generateId_1.default)(),
         });
         let err = await test_utils_1.assert.doesThrowAsync(() => db.syncUniqueIndexes(this.collectionName, [['uniqueField']]));
-        test_utils_1.assert.isTrue(err instanceof SpruceError_1.default);
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_KEY');
         await this.shutdown(db);
     },
     async assertDuplicateKeyThrowsOnInsert(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['uniqueField']);
         await db.createOne(this.collectionName, {
             uniqueField: 'hello world',
+            name: (0, generateId_1.default)(),
+        });
+        let err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            name: (0, generateId_1.default)(),
+        }));
+        lowerCaseErrorDuplicateFields(err);
+        test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
+            duplicateFields: ['uniquefield'],
+            duplicateValues: ['hello world'],
+            collectionName: this.collectionName,
         });
-        let err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, { uniqueField: 'hello world' }));
-        test_utils_1.assert.isTrue(err instanceof SpruceError_1.default);
         await this.shutdown(db);
     },
     async assertSyncingIndexesDoesNotAddAndRemove(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['otherField']);
         await db.createUniqueIndex(this.collectionName, ['someField']);
         db.createUniqueIndex = () => {
@@ -455,22 +664,22 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertSyncingUniqueIndexesRemovesExtraIndexes(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.syncUniqueIndexes(this.collectionName, [
             ['uniqueField'],
             ['someField'],
             ['otherField', 'otherField2'],
         ]);
         let indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 3);
+        test_utils_1.assert.isLength(indexes, 3, 'syncUniqueIndexes() should have created 3 indexes.');
         await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
         indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isEqual(indexes[0][0], 'uniqueField');
+        test_utils_1.assert.isEqual(indexes[0][0].toLowerCase(), 'uniquefield');
         await this.shutdown(db);
     },
     async assertSyncingUniqueIndexsSkipsExistingIndexs(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
         let indexes = await db.getUniqueIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 1);
@@ -484,46 +693,58 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertSyncingUniqueIndexsAddsMissingIndexes(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.syncUniqueIndexes(this.collectionName, [['uniqueField']]);
         let indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isLength(indexes, 1, 'There should be 1 index after syncing.');
         await db.syncUniqueIndexes(this.collectionName, [['someField']]);
         indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 1);
+        test_utils_1.assert.isLength(indexes, 1, 'There should now be 2 indexes after syncing.');
         await db.syncUniqueIndexes(this.collectionName, [
             ['uniqueField'],
             ['someField'],
         ]);
         indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 2);
+        test_utils_1.assert.isLength(indexes, 2, 'There should still be 2 indexes after syncing.');
         await this.shutdown(db);
     },
     async assertCantDropCompoundUniqueIndexThatDoesntExist(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, [
             'someField',
             'someOtherField',
         ]);
         const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
-        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        lowerCaseMissingIndexValues(err);
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+            collectionName: this.collectionName,
+            missingIndex: ['uniquefield', 'someotherfield'],
+        });
         await this.shutdown(db);
     },
     async assertCantDropIndexWhenNoIndexExists(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField']));
-        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        lowerCaseMissingIndexValues(err);
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+            collectionName: this.collectionName,
+            missingIndex: ['someotherfield'],
+        });
         await this.shutdown(db);
     },
     async assertCantDropUniqueIndexThatDoesntExist(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['someField']);
         const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['someOtherField']));
-        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        lowerCaseMissingIndexValues(err);
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+            collectionName: this.collectionName,
+            missingIndex: ['someotherfield'],
+        });
         await this.shutdown(db);
     },
     async assertCanDropCompoundUniqueIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['someField', 'otherField']);
         await db.dropIndex(this.collectionName, ['someField', 'otherField']);
         let indexes = await db.getUniqueIndexes(this.collectionName);
@@ -536,11 +757,11 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanDropUniqueIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['someField']);
         await db.dropIndex(this.collectionName, ['someField']);
         let indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 0);
+        test_utils_1.assert.isLength(indexes, 0, 'getUniqueIndexes() still returned an index even though it should not have after dropIndex().');
         await db.createUniqueIndex(this.collectionName, ['someField2']);
         await db.createUniqueIndex(this.collectionName, ['someField3']);
         await db.dropIndex(this.collectionName, ['someField3']);
@@ -549,16 +770,12 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCantCreateUniqueIndexTwice(connect) {
-        const db = await connect();
-        await db.createUniqueIndex(this.collectionName, ['uniqueField']);
-        let indexes = await db.getUniqueIndexes(this.collectionName);
-        test_utils_1.assert.isLength(indexes, 1);
-        const err = await test_utils_1.assert.doesThrowAsync(() => db.createUniqueIndex(this.collectionName, ['uniqueField']));
-        test_utils_2.errorAssert.assertError(err, 'INDEX_EXISTS');
+        const db = await connectToDabatase(connect);
+        await assertCantCreateUniqueIndexTwice(db, this.collectionName, ['uniqueField'], 1);
         await this.shutdown(db);
     },
     async assertSyncingUniqueIndexesIsRaceProof(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const syncs = [
             db.syncUniqueIndexes(this.collectionName, [
                 ['otherField', 'otherField2'],
@@ -595,25 +812,32 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertUniqueIndexBlocksDuplicates(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, ['uniqueField']);
         await db.createOne(this.collectionName, {
             uniqueField: 'hello world',
+            name: 'hello world',
         });
-        let err = (await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, { uniqueField: 'hello world' })));
+        let err = (await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            uniqueField: 'hello world',
+            name: 'hello world',
+        })));
+        lowerCaseStringArray(err, 'duplicateFields');
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['uniqueField'],
+            duplicateFields: ['uniquefield'],
             duplicateValues: ['hello world'],
             action: 'create',
         });
         const created = await db.createOne(this.collectionName, {
             uniqueField: 'pass',
+            name: 'hello world',
         });
         err = (await test_utils_1.assert.doesThrowAsync(() => db.updateOne(this.collectionName, { id: created.id }, { uniqueField: 'hello world' })));
+        lowerCaseStringArray(err, 'duplicateFields');
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['uniqueField'],
+            duplicateFields: ['uniquefield'],
             duplicateValues: ['hello world'],
             action: 'updateOne',
         });
@@ -621,17 +845,20 @@ const databaseAssertUtil = {
         for (let c = 0; c <= 10; c++) {
             promises.push(db.createOne(this.collectionName, {
                 uniqueField: 'fast',
+                name: 'hello world',
             }));
         }
         err = (await test_utils_1.assert.doesThrowAsync(() => Promise.all(promises)));
+        lowerCaseStringArray(err, 'duplicateFields');
         test_utils_2.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 = (await test_utils_1.assert.doesThrowAsync(() => Promise.all(promises)));
@@ -639,12 +866,20 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanCreateUniqueIndexOnNestedField(connect) {
-        const db = await connect();
-        await db.createUniqueIndex(this.collectionName, [
-            'target.organizationId',
-            'slug',
-        ]);
+        var _a;
+        const db = await connectToDabatase(connect);
+        try {
+            await db.createUniqueIndex(this.collectionName, [
+                'target.organizationId',
+                'slug',
+            ]);
+        }
+        catch (err) {
+            test_utils_1.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);
+        }
         await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
             target: {
                 organizationId: 'go!',
                 locationId: null,
@@ -652,6 +887,7 @@ const databaseAssertUtil = {
             slug: 'a slug',
         });
         const err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
             target: {
                 organizationId: 'go!',
                 locationId: null,
@@ -669,6 +905,7 @@ const databaseAssertUtil = {
                 organizationId: 'go!',
             },
         }, {
+            name: 'test',
             target: {
                 organizationId: 'go 2!',
                 locationId: null,
@@ -678,8 +915,11 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanPushToArrayOnUpsert(connect) {
-        const db = await connect();
-        const record = await db.createOne(this.collectionName, { names: [] });
+        const db = await connectToDabatase(connect);
+        const record = await db.createOne(this.collectionName, {
+            name: 'test',
+            names: [],
+        });
         await db.updateOne(this.collectionName, {
             id: record.id,
         }, {
@@ -690,23 +930,23 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanSearchByRegex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.create(this.collectionName, [
             {
                 name: 'first',
-                subObject: {
+                target: {
                     score: 1,
                 },
             },
             {
                 name: 'second',
-                subObject: {
+                target: {
                     score: 2,
                 },
             },
             {
                 name: 'third',
-                subObject: {
+                target: {
                     score: 2,
                 },
             },
@@ -716,27 +956,27 @@ const databaseAssertUtil = {
             {
                 name: 'first',
             },
-        ]);
+        ], 'Searching by regex failed.!');
         await this.shutdown(db);
     },
     async assertCanReturnOnlySelectFields(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.create(this.collectionName, [
             {
                 name: 'first',
-                subObject: {
+                target: {
                     score: 1,
                 },
             },
             {
                 name: 'second',
-                subObject: {
+                target: {
                     score: 2,
                 },
             },
             {
                 name: 'third',
-                subObject: {
+                target: {
                     score: 2,
                 },
             },
@@ -753,22 +993,26 @@ const databaseAssertUtil = {
                 name: 'third',
             },
         ]);
-        const first = await db.findOne(this.collectionName, {}, { includeFields: ['subObject'] });
+        const first = await db.findOne(this.collectionName, {}, { includeFields: ['target'] });
         test_utils_1.assert.isEqualDeep(first, {
-            subObject: {
+            target: {
                 score: 1,
             },
         });
         await this.shutdown(db);
     },
-    async assertThrowsWithoutDatabaseName(connect) {
-        const err = await test_utils_1.assert.doesThrowAsync(() => connect(undefined, 'undefined'));
+    async assertThrowsWithBadDatabaseName(connect) {
+        const { db, connectionStringWithRandomBadDatabaseName: connectionStringWithRandomBadDatabaseeName, badDatabaseName, } = await connect();
+        await this.shutdown(db);
+        const err = await test_utils_1.assert.doesThrowAsync(() => connect(connectionStringWithRandomBadDatabaseeName));
         test_utils_2.errorAssert.assertError(err, 'INVALID_DATABASE_NAME', {
-            suppliedName: 'undefined',
+            suppliedName: badDatabaseName,
         });
     },
     async assertThrowsWhenCantConnect(connect) {
-        const err = await test_utils_1.assert.doesThrowAsync(() => connect('mongodb://localhost:9999'));
+        const { db, scheme } = await connect();
+        await this.shutdown(db);
+        const err = await test_utils_1.assert.doesThrowAsync(() => connect(`${scheme}localhost:9999`));
         test_utils_2.errorAssert.assertError(err, 'UNABLE_TO_CONNECT_TO_DB');
     },
     async assertThrowsWithInvalidConnectionString(connect) {
@@ -776,95 +1020,101 @@ const databaseAssertUtil = {
         test_utils_2.errorAssert.assertError(err, 'INVALID_DB_CONNECTION_STRING');
     },
     async assertKnowsIfConnectionClosed(connect) {
-        const db = await connect();
-        test_utils_1.assert.isTrue(db.isConnected());
+        const db = await connectToDabatase(connect);
+        test_utils_1.assert.isFunction(db.isConnected, `db.isConnected() needs to be a function!`);
+        test_utils_1.assert.isTrue(db.isConnected(), 'isConnected() should return true when connected');
         await db.close();
-        test_utils_1.assert.isFalse(db.isConnected());
+        test_utils_1.assert.isFalse(db.isConnected(), 'isConnected() should return false when disconnected (after calling db.close())');
+        await this.shutdown(db);
     },
     async assertCanQueryPathWithDotSyntax(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.create(this.collectionName, [
             {
                 name: 'first',
-                subObject: {
+                target: {
                     score: 1,
                 },
             },
             {
                 name: 'second',
-                subObject: {
+                target: {
                     score: 2,
                 },
             },
             {
                 name: 'third',
-                subObject: {
+                target: {
                     score: 2,
                 },
             },
         ]);
         const secondMatch = await db.findOne(this.collectionName, {
-            'subObject.score': 2,
+            'target.score': 2,
         });
-        test_utils_1.assert.isTruthy(secondMatch);
+        test_utils_1.assert.isTruthy(secondMatch, 'Could not match on path with dot syntax.');
         test_utils_1.assert.isEqual(secondMatch.name, 'second');
         await this.shutdown(db);
     },
     async assertCanQueryByGtLtGteLte(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const created = await db.create(this.collectionName, [
             {
-                position: 1,
+                number: 1,
+                name: (0, generateId_1.default)(),
             },
             {
-                position: 2,
+                number: 2,
+                name: (0, generateId_1.default)(),
             },
             {
-                position: 3,
+                number: 3,
+                name: (0, generateId_1.default)(),
             },
             {
-                position: 4,
+                number: 4,
+                name: (0, generateId_1.default)(),
             },
         ]);
         const gtMatches = await db.find(this.collectionName, {
-            id: { $gt: created[2].id },
+            number: { $gt: 3 },
         });
-        test_utils_1.assert.isLength(gtMatches, 1);
-        test_utils_1.assert.isEqual(gtMatches[0].position, 4);
+        test_utils_1.assert.isLength(gtMatches, 1, 'Expected 1 match for $gt: 3');
+        test_utils_1.assert.isEqual(gtMatches[0].number, 4, 'Did not match the expected result for $gt: 3');
         const gteMatches = await db.find(this.collectionName, {
-            id: { $gte: created[2].id },
+            number: { $gte: created[2].number },
         });
         test_utils_1.assert.isLength(gteMatches, 2);
-        test_utils_1.assert.isEqual(gteMatches[0].position, 3);
-        test_utils_1.assert.isEqual(gteMatches[1].position, 4);
+        test_utils_1.assert.isEqual(gteMatches[0].number, 3);
+        test_utils_1.assert.isEqual(gteMatches[1].number, 4);
         const ltMatches = await db.find(this.collectionName, {
-            id: { $lt: created[2].id },
+            number: { $lt: created[2].number },
         });
         test_utils_1.assert.isLength(ltMatches, 2);
-        test_utils_1.assert.isEqual(ltMatches[0].position, 1);
-        test_utils_1.assert.isEqual(ltMatches[1].position, 2);
+        test_utils_1.assert.isEqual(ltMatches[0].number, 1);
+        test_utils_1.assert.isEqual(ltMatches[1].number, 2);
         const lteMatches = await db.find(this.collectionName, {
-            id: { $lte: created[2].id },
+            number: { $lte: created[2].number },
         });
         test_utils_1.assert.isLength(lteMatches, 3);
-        test_utils_1.assert.isEqual(lteMatches[0].position, 1);
-        test_utils_1.assert.isEqual(lteMatches[1].position, 2);
-        test_utils_1.assert.isEqual(lteMatches[2].position, 3);
+        test_utils_1.assert.isEqual(lteMatches[0].number, 1);
+        test_utils_1.assert.isEqual(lteMatches[1].number, 2);
+        test_utils_1.assert.isEqual(lteMatches[2].number, 3);
         await this.shutdown(db);
     },
     async assertCanFindWithNe(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const record1 = await db.createOne(this.collectionName, {
-            foo: 'bar',
-            hello: 'world',
+            name: 'bar',
+            someField: 'world',
         });
         await db.createOne(this.collectionName, {
-            foo: 'bar2',
-            hello: 'world',
+            name: 'bar2',
+            someField: 'world',
         });
         await db.createOne(this.collectionName, {
-            foo: 'bar3',
-            hello: 'planet',
+            name: 'bar3',
+            someField: 'planet',
         });
         const query = { id: { $ne: record1.id } };
         const results = await db.find(this.collectionName, query);
@@ -872,37 +1122,57 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanFindWithIn(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const record1 = await db.createOne(this.collectionName, {
-            foo: 'bar',
-            hello: 'world',
+            name: 'bar',
+            otherField: 'world',
         });
         const record2 = await db.createOne(this.collectionName, {
-            foo: 'bar2',
-            hello: 'world',
+            name: 'bar2',
+            otherField: 'world',
         });
         const record3 = await db.createOne(this.collectionName, {
-            foo: 'bar3',
-            hello: 'planet',
+            name: 'bar3',
+            otherField: 'planet',
         });
         const query = { id: { $in: [record1.id, record2.id, record3.id] } };
         const results = await db.find(this.collectionName, query);
         test_utils_1.assert.isLength(results, 3);
         await this.shutdown(db);
     },
+    async assertCanFindWithBooleanField(connect) {
+        const db = await connectToDabatase(connect);
+        const first = await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
+            isPublic: true,
+        });
+        const second = await db.createOne(this.collectionName, {
+            name: (0, generateId_1.default)(),
+            isPublic: false,
+        });
+        const firstMatch = await db.findOne(this.collectionName, {
+            isPublic: true,
+        });
+        test_utils_1.assert.isEqualDeep(firstMatch, first, `Searching where boolean field is true failed.`);
+        const secondMatch = await db.findOne(this.collectionName, {
+            isPublic: false,
+        });
+        test_utils_1.assert.isEqualDeep(secondMatch, second, `Searching where boolean field is false failed.`);
+        await this.shutdown(db);
+    },
     async assertCanCountOnId(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const first = await db.createOne(this.collectionName, {
-            foo: 'bar',
-            hello: 'world',
+            name: 'bar',
+            otherField: 'world',
         });
         const second = await db.createOne(this.collectionName, {
-            foo: 'bar2',
-            hello: 'world',
+            name: 'bar2',
+            otherField: 'world',
         });
         const third = await db.createOne(this.collectionName, {
-            foo: 'bar3',
-            hello: 'planet',
+            name: 'bar3',
+            otherField: 'planet',
         });
         const countFirst = await db.count(this.collectionName, { id: first.id });
         const countSecond = await db.count(this.collectionName, {
@@ -917,76 +1187,93 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanCount(connect) {
-        const db = await connect();
-        await db.createOne(this.collectionName, { foo: 'bar', hello: 'world' });
-        await db.createOne(this.collectionName, { foo: 'bar2', hello: 'world' });
-        await db.createOne(this.collectionName, { foo: 'bar3', hello: 'planet' });
+        const db = await connectToDabatase(connect);
+        await db.createOne(this.collectionName, {
+            name: 'bar',
+            otherField: 'world',
+        });
+        await db.createOne(this.collectionName, {
+            name: 'bar2',
+            otherField: 'world',
+        });
+        await db.createOne(this.collectionName, {
+            name: 'bar3',
+            otherField: 'planet',
+        });
         const countAll = await db.count(this.collectionName);
         test_utils_1.assert.isEqual(countAll, 3);
         await this.shutdown(db);
     },
     async assertCanUpsertNull(connect) {
-        const db = await connect();
+        var _a, _b;
+        const db = await connectToDabatase(connect);
         const createdUndefined = await db.upsertOne(this.collectionName, {
             undefinedField: undefined,
         }, {
             undefinedField: undefined,
+            name: (0, generateId_1.default)(),
         });
         test_utils_1.assert.isTruthy(createdUndefined);
-        test_utils_1.assert.isNull(createdUndefined.undefinedField);
+        test_utils_1.assert.isTrue(createdUndefined.undefinedField === null ||
+            createdUndefined.undefinedfield === null);
         const createdNull = await db.upsertOne(this.collectionName, {
             nullField: null,
+            name: '234',
         }, {
             nullField: null,
+            name: (0, generateId_1.default)(),
         });
         test_utils_1.assert.isTruthy(createdNull);
         let all = await db.find(this.collectionName);
-        test_utils_1.assert.isLength(all, 2);
+        test_utils_1.assert.isLength(all, 2, 'I expected to find 2 records after 2 upserts.');
         const updatedUndefined = await db.upsertOne(this.collectionName, {
             undefinedField: undefined,
         }, { undefinedField: 'now defined' });
         test_utils_1.assert.isEqual(updatedUndefined.id, createdUndefined.id);
-        test_utils_1.assert.isEqual(updatedUndefined.undefinedField, 'now defined');
+        test_utils_1.assert.isEqual((_a = updatedUndefined.undefinedField) !== null && _a !== void 0 ? _a : updatedUndefined.undefinedfield, 'now defined');
         const updatedNull = await db.upsertOne(this.collectionName, {
             nullField: null,
         }, { nullField: 'now defined' });
         test_utils_1.assert.isEqual(updatedNull.id, createdNull.id);
-        test_utils_1.assert.isEqual(updatedNull.nullField, 'now defined');
+        test_utils_1.assert.isEqual((_b = updatedNull.nullField) !== null && _b !== void 0 ? _b : updatedNull.nullfield, 'now defined', 'nullField should have upserted to "now defined"');
         all = await db.find(this.collectionName);
         test_utils_1.assert.isLength(all, 2);
         await this.shutdown(db);
     },
     async assertCanSaveAndGetNullAndUndefined(connect) {
-        const db = await connect();
+        var _a, _b;
+        const db = await connectToDabatase(connect);
         const created = await db.createOne(this.collectionName, {
             undefinedField: undefined,
             nullField: null,
+            name: 'hey',
         });
-        test_utils_1.assert.isNull(created.undefinedField);
-        test_utils_1.assert.isNull(created.nullField);
+        test_utils_1.assert.isTrue(created.undefinedField === null || created.undefinedfield === null, 'undefinedField should be null');
+        test_utils_1.assert.isTrue(created.nullField === null || created.nullfield === null, 'nullField should be null');
         const matchedUndefined = await db.findOne(this.collectionName, {
             undefinedField: undefined,
         });
         test_utils_1.assert.isTruthy(matchedUndefined);
-        test_utils_1.assert.isNull(matchedUndefined.undefinedField);
+        test_utils_1.assert.isTrue(matchedUndefined.undefinedField === null ||
+            matchedUndefined.undefinedfield === null, 'findOne should return null for undefinedField');
         const matchedNull = await db.findOne(this.collectionName, {
             nullField: null,
         });
         test_utils_1.assert.isTruthy(matchedNull);
-        test_utils_1.assert.isNull(matchedNull.nullField);
+        test_utils_1.assert.isTrue(matchedNull.nullField === null || matchedNull.nullfield === null, 'findOne should return null for nullField');
         const updatedUndefined = await db.updateOne(this.collectionName, {
             undefinedField: undefined,
         }, { undefinedField: 'now defined' });
         test_utils_1.assert.isEqual(updatedUndefined.id, created.id);
-        test_utils_1.assert.isEqual(updatedUndefined.undefinedField, 'now defined');
+        test_utils_1.assert.isEqual((_a = updatedUndefined.undefinedField) !== null && _a !== void 0 ? _a : updatedUndefined.undefinedfield, 'now defined');
         const updatedNull = await db.updateOne(this.collectionName, {
             nullField: null,
         }, { nullField: 'now defined' });
-        test_utils_1.assert.isEqual(updatedNull.nullField, 'now defined');
+        test_utils_1.assert.isEqual((_b = updatedNull.nullField) !== null && _b !== void 0 ? _b : updatedNull.nullfield, 'now defined');
         await this.shutdown(db);
     },
     async assertSyncIndexesDoesNotRemoveExisting(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['otherField']);
         await db.createIndex(this.collectionName, ['someField']);
         db.createIndex = () => {
@@ -999,27 +1286,27 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertSyncIndexesRemovesExtraIndexes(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.syncIndexes(this.collectionName, [
-            ['field'],
+            ['name'],
             ['someField'],
             ['otherField', 'otherField2'],
         ]);
         let indexes = await this._getFilteredIndexes(db);
         test_utils_1.assert.isLength(indexes, 3);
-        await db.syncIndexes(this.collectionName, [['field']]);
+        await db.syncIndexes(this.collectionName, [['name']]);
         indexes = await this._getFilteredIndexes(db);
         test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isEqual(indexes[0][0], 'field');
+        test_utils_1.assert.isEqual(indexes[0][0], 'name');
         await this.shutdown(db);
     },
     async assertSyncIndexesSkipsExisting(connect) {
-        const db = await connect();
-        await db.syncIndexes(this.collectionName, [['field']]);
+        const db = await connectToDabatase(connect);
+        await db.syncIndexes(this.collectionName, [['name']]);
         let indexes = await this._getFilteredIndexes(db);
         test_utils_1.assert.isLength(indexes, 1);
         await db.syncIndexes(this.collectionName, [
-            ['field'],
+            ['name'],
             ['someField'],
             ['otherField', 'otherField2'],
         ]);
@@ -1028,14 +1315,17 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCantDropCompoundIndexThatDoesNotExist(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['someField', 'someOtherField']);
         const err = await test_utils_1.assert.doesThrowAsync(() => db.dropIndex(this.collectionName, ['uniqueField', 'someOtherField']));
-        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND');
+        test_utils_2.errorAssert.assertError(err, 'INDEX_NOT_FOUND', {
+            collectionName: this.collectionName,
+            missingIndex: ['uniqueField', 'someOtherField'],
+        });
         await this.shutdown(db);
     },
     async assertCanDropCompoundIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['someField', 'otherField']);
         await db.dropIndex(this.collectionName, ['someField', 'otherField']);
         let indexes = await this._getFilteredIndexes(db);
@@ -1048,7 +1338,7 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertCanDropIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.createIndex(this.collectionName, ['someField']);
         await db.dropIndex(this.collectionName, ['someField']);
         let indexes = await this._getFilteredIndexes(db);
@@ -1060,49 +1350,61 @@ const databaseAssertUtil = {
         test_utils_1.assert.isLength(indexes, 1);
         await this.shutdown(db);
     },
-    async assertCanCreateMultiFieldIndex(connect, fields) {
-        const db = await connect();
-        await db.createIndex(this.collectionName, fields);
-        let indexes = await this._getFilteredIndexes(db);
-        test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isEqualDeep(indexes, [fields]);
-        await this.shutdown(db);
+    async assertCanCreateMultiFieldIndex(connect) {
+        await this._assertCanCreateMultiFieldIndex(connect, [
+            'otherField',
+            'someField',
+        ]);
+        await this._assertCanCreateMultiFieldIndex(connect, [
+            'someField',
+            'otherField',
+        ]);
+        await this._assertCanCreateMultiFieldIndex(connect, [
+            'otherField',
+            'otherField2',
+        ]);
+        await this._assertCanCreateMultiFieldIndex(connect, [
+            'otherField2',
+            'otherField',
+        ]);
     },
     async assertCantCreateSameIndexTwice(connect) {
-        const db = await connect();
-        await db.createIndex(this.collectionName, ['field']);
+        const db = await connectToDabatase(connect);
+        await db.createIndex(this.collectionName, ['name']);
         let indexes = await this._getFilteredIndexes(db);
         test_utils_1.assert.isLength(indexes, 1);
-        const err = await test_utils_1.assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['field']));
+        const err = await test_utils_1.assert.doesThrowAsync(() => db.createIndex(this.collectionName, ['name']));
         test_utils_2.errorAssert.assertError(err, 'INDEX_EXISTS');
         await this.shutdown(db);
     },
     async assertCanCreateIndex(connect) {
-        const db = await connect();
-        await db.createIndex(this.collectionName, ['field']);
+        const db = await connectToDabatase(connect);
+        await db.createIndex(this.collectionName, ['uniqueField']);
         let indexes = await this._getFilteredIndexes(db);
-        test_utils_1.assert.isLength(indexes, 1);
-        test_utils_1.assert.isLength(indexes[0], 1);
-        test_utils_1.assert.isEqual(indexes[0][0], 'field');
-        await db.createIndex(this.collectionName, ['field2']);
+        test_utils_1.assert.isArray(indexes, 'getIndexes() should return an array!');
+        test_utils_1.assert.isLength(indexes, 1, 'getIndexes() should return the one index that was created!');
+        test_utils_1.assert.isLength(indexes[0], 1, 'getIndexes() should return an array of arrays! It should be returing the first index I created!');
+        test_utils_1.assert.isEqual(indexes[0][0].toLowerCase(), 'uniqueField'.toLowerCase());
+        await db.createIndex(this.collectionName, ['uniqueField2']);
         indexes = await this._getFilteredIndexes(db);
         test_utils_1.assert.isLength(indexes, 2);
-        test_utils_1.assert.isEqual(indexes[1][0], 'field2');
-        await db.createIndex(this.collectionName, ['field3', 'field4']);
+        test_utils_1.assert.isEqual(indexes[1][0].toLowerCase(), 'uniqueField2'.toLowerCase());
+        await db.createIndex(this.collectionName, ['uniqueField3', 'uniqueField4']);
         indexes = await this._getFilteredIndexes(db);
         test_utils_1.assert.isLength(indexes, 3);
-        test_utils_1.assert.isEqual(indexes[2][0], 'field3');
-        test_utils_1.assert.isEqual(indexes[2][1], 'field4');
+        test_utils_1.assert.isEqual(indexes[2][0].toLowerCase(), 'uniqueField3'.toLowerCase());
+        test_utils_1.assert.isEqual(indexes[2][1].toLowerCase(), 'uniqueField4'.toLowerCase());
         await this.shutdown(db);
     },
     async assertHasNoIndexToStart(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const indexes = await db.getIndexes(this.collectionName);
         test_utils_1.assert.isLength(indexes, 0);
         await this.shutdown(db);
     },
     async assertNestedFieldIndexUpdates(connect) {
-        const db = await connect();
+        var _a;
+        const db = await connectToDabatase(connect);
         await db.createUniqueIndex(this.collectionName, [
             'target.organizationId',
             'slug',
@@ -1112,6 +1414,7 @@ const databaseAssertUtil = {
                 organizationId: 'go!',
             },
             aNonIndexedField: true,
+            name: 'squirrel',
             slug: 'a slug',
         });
         const updated = await db.updateOne(this.collectionName, { id: results.id }, {
@@ -1121,11 +1424,11 @@ const databaseAssertUtil = {
             aNonIndexedField: false,
             slug: 'a slug',
         });
-        test_utils_1.assert.isEqual(updated.aNonIndexedField, false);
+        test_utils_1.assert.isEqual((_a = updated.aNonIndexedField) !== null && _a !== void 0 ? _a : updated.anonindexedfield, false);
         await this.shutdown(db);
     },
     async assertUpsertWithUniqueIndex(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         await db.syncUniqueIndexes(this.collectionName, [
             ['name', 'target.organizationId'],
             ['slug', 'target.organizationId'],
@@ -1149,7 +1452,7 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertSyncIndexesHandlesRaceConditions(connect) {
-        const db = await connect();
+        const db = await connectToDabatase(connect);
         const syncs = [
             db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
             db.syncIndexes(this.collectionName, [['otherField', 'otherField2']]),
@@ -1166,34 +1469,87 @@ const databaseAssertUtil = {
         await this.shutdown(db);
     },
     async assertDuplicateFieldsWithMultipleUniqueIndexesWorkAsExpected(connect) {
-        const db = await connect();
-        await db.createUniqueIndex(this.collectionName, ['uniqueField1']);
+        const db = await connectToDabatase(connect);
+        await db.createUniqueIndex(this.collectionName, ['uniqueField']);
         await db.createUniqueIndex(this.collectionName, ['uniqueField2']);
         await db.createOne(this.collectionName, {
-            uniqueField1: 'unique field 1',
+            name: (0, generateId_1.default)(),
+            uniqueField: 'unique field 1',
             uniqueField2: 'unique field 2',
         });
         let err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
-            uniqueField1: 'unique field 1',
+            name: (0, generateId_1.default)(),
+            uniqueField: 'unique field 1',
             uniqueField2: 'unique field 2',
         }));
+        lowerCaseStringArray(err, 'duplicateFields');
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['uniqueField1'],
+            duplicateFields: ['uniquefield'],
             duplicateValues: ['unique field 1'],
             action: 'create',
         });
         err = await test_utils_1.assert.doesThrowAsync(() => db.createOne(this.collectionName, {
-            uniqueField1: 'unique field 1.0',
+            name: (0, generateId_1.default)(),
+            uniqueField: 'unique field 1.0',
             uniqueField2: 'unique field 2',
         }));
+        lowerCaseStringArray(err, 'duplicateFields');
         test_utils_2.errorAssert.assertError(err, 'DUPLICATE_RECORD', {
             collectionName: this.collectionName,
-            duplicateFields: ['uniqueField2'],
+            duplicateFields: ['uniquefield2'],
             duplicateValues: ['unique field 2'],
             action: 'create',
         });
         await this.shutdown(db);
     },
+    async _assertThrowsExpectedNotFoundOnUpdateOne(db, query) {
+        const err = (await test_utils_1.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!`));
+        test_utils_2.errorAssert.assertError(err, 'RECORD_NOT_FOUND', {
+            query,
+        });
+    },
+    async _assert$orReturnsExpectedTotalRecords(db, $or, expected) {
+        const matches = await db.find(this.collectionName, {
+            $or,
+        });
+        test_utils_1.assert.isLength(matches, expected);
+    },
+    async _assertCanCreateMultiFieldIndex(connect, fields) {
+        const db = await connectToDabatase(connect);
+        await db.createIndex(this.collectionName, fields);
+        const indexes = await this._getFilteredIndexes(db);
+        test_utils_1.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!`);
+        test_utils_1.assert.isEqualDeep(indexes[0].map((i) => i.toLowerCase()), fields.map((f) => f.toLowerCase()));
+        await this.shutdown(db);
+    },
 };
 exports.default = databaseAssertUtil;
+async function assertCantCreateUniqueIndexTwice(db, collectionName, fields, expectedTotalUniqueIndexes) {
+    await db.createUniqueIndex(collectionName, fields);
+    let indexes = await db.getUniqueIndexes(collectionName);
+    test_utils_1.assert.isLength(indexes, expectedTotalUniqueIndexes, 'getUniqueIndexes() should return total unique indexs');
+    const err = await test_utils_1.assert.doesThrowAsync(() => db.createUniqueIndex(collectionName, ['uniqueField']), undefined, 'createUniqueIndex() should throw a DataStoreError({code: "INDEX_EXISTS"}) error.');
+    test_utils_2.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());
+    }
+}
+async function connectToDabatase(connect) {
+    const { db } = await connect();
+    return db;
+}