@enbox/dwn-sdk-js 0.0.2 → 0.0.3

package/dist/esm/tests/features/records-tags.spec.js

@@ -7,9 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
 import { DidKey } from '@enbox/dids';
 import { Dwn } from '../../src/dwn.js';
 import { DwnErrorCode } from '../../src/core/dwn-error.js';
@@ -21,28 +19,28 @@ import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { UniversalResolver } from '@enbox/dids';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DwnInterfaceName, DwnMethodName, Message, Time } from '../../src/index.js';
-chai.use(chaiAsPromised);
 export function testRecordsTags() {
     describe('Records Tags', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
         // so that different test suites can reuse the same backend store for testing
-        before(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
             dataStore = stores.dataStore;
             resumableTaskStore = stores.resumableTaskStore;
-            eventLog = stores.eventLog;
+            stateIndex = stores.stateIndex;
             eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, eventStream, resumableTaskStore });
+            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
         }));
         beforeEach(() => __awaiter(this, void 0, void 0, function* () {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
@@ -50,9 +48,9 @@ export function testRecordsTags() {
             yield messageStore.clear();
             yield dataStore.clear();
             yield resumableTaskStore.clear();
-            yield eventLog.clear();
+            yield stateIndex.clear();
         }));
-        after(() => __awaiter(this, void 0, void 0, function* () {
+        afterAll(() => __awaiter(this, void 0, void 0, function* () {
             yield dwn.close();
         }));
         describe('RecordsWrite with tags', () => {
@@ -109,7 +107,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                     }));
                     it('should reject tags that have invalid schema definitions during create', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -141,7 +139,7 @@ export function testRecordsTags() {
                             author: alice,
                             protocolDefinition: invalidSchemaProtocol,
                         });
-                        yield expect(protocolConfigure).to.eventually.be.rejectedWith(DwnErrorCode.ProtocolsConfigureInvalidTagSchema);
+                        yield expect(protocolConfigure).rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidTagSchema);
                     }));
                     it('should reject tags that have invalid schema definitions during process', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -182,9 +180,9 @@ export function testRecordsTags() {
                         });
                         const protocolsConfigureMessage = { descriptor, authorization };
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                        expect(protocolsConfigureReply.status.code).to.equal(400);
-                        expect(protocolsConfigureReply.status.detail).to.contain(DwnErrorCode.ProtocolsConfigureInvalidTagSchema);
-                        expect(protocolsConfigureReply.status.detail).to.contain(`foo/$tags/invalidTag/contains/minimum must be number`);
+                        expect(protocolsConfigureReply.status.code).toBe(400);
+                        expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidTagSchema);
+                        expect(protocolsConfigureReply.status.detail).toContain(`foo/$tags/invalidTag/contains/minimum must be number`);
                     }));
                     describe('should reject invalid tag types', () => {
                         it('object', () => __awaiter(this, void 0, void 0, function* () {
@@ -219,7 +217,7 @@ export function testRecordsTags() {
                             });
                             const protocolsConfigureMessage = { descriptor, authorization };
                             const objectTagsTypeConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                            expect(objectTagsTypeConfigureReply.status.code).to.equal(400);
+                            expect(objectTagsTypeConfigureReply.status.code).toBe(400);
                         }));
                         it('array of objects', () => __awaiter(this, void 0, void 0, function* () {
                             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -256,7 +254,7 @@ export function testRecordsTags() {
                             });
                             const protocolsConfigureMessage = { descriptor, authorization };
                             const objectArrayTagsTypeConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                            expect(objectArrayTagsTypeConfigureReply.status.code).to.equal(400);
+                            expect(objectArrayTagsTypeConfigureReply.status.code).toBe(400);
                         }));
                         it('array of booleans', () => __awaiter(this, void 0, void 0, function* () {
                             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -292,7 +290,7 @@ export function testRecordsTags() {
                             });
                             const protocolsConfigureMessage = { descriptor, authorization };
                             const booleanArrayTagsTypeConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                            expect(booleanArrayTagsTypeConfigureReply.status.code).to.equal(400);
+                            expect(booleanArrayTagsTypeConfigureReply.status.code).toBe(400);
                         }));
                     });
                 });
@@ -321,7 +319,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with an `unknownTag` tag.
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -333,10 +331,10 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     // ensure the correct tag descriptor is in the error message
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags must NOT have additional properties`);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags must NOT have additional properties`);
                     // write a foo record with a `knownTag` tag.
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -349,7 +347,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject a tag value that does not match the boolean type', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -376,7 +374,7 @@ export function testRecordsTags() {
                         protocolDefinition
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // `draft` should be a boolean type, but we are passing a string
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -388,9 +386,9 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/draft must be boolean`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/draft must be boolean`);
                     // positive test with a boolean
                     const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -402,7 +400,7 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
-                    expect(fooRecord2Reply.status.code).to.equal(202);
+                    expect(fooRecord2Reply.status.code).toBe(202);
                 }));
                 it('should reject a tag value that does not match the number type', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -429,7 +427,7 @@ export function testRecordsTags() {
                         protocolDefinition
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // `numberType` should be a number type, but we are passing a string
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -441,9 +439,9 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/numberType must be number`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberType must be number`);
                     // positive tests with an integer number
                     const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -455,7 +453,7 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
-                    expect(fooRecord2Reply.status.code).to.equal(202);
+                    expect(fooRecord2Reply.status.code).toBe(202);
                     // positive tests with a decimal number
                     const fooRecord3 = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -467,7 +465,7 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecord3Reply = yield dwn.processMessage(alice.did, fooRecord3.message, { dataStream: fooRecord3.dataStream });
-                    expect(fooRecord3Reply.status.code).to.equal(202);
+                    expect(fooRecord3Reply.status.code).toBe(202);
                 }));
                 it('should reject a tag value that does not match the integer type', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -494,7 +492,7 @@ export function testRecordsTags() {
                         protocolDefinition
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // `count` should be an integer type, but we are passing decimal number
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -506,9 +504,9 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/count must be integer`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/count must be integer`);
                     // positive test with an integer
                     const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -520,7 +518,7 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
-                    expect(fooRecord2Reply.status.code).to.equal(202);
+                    expect(fooRecord2Reply.status.code).toBe(202);
                 }));
                 it('should reject a record with a tag value that does not match a given enum in the protocol definition', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -548,7 +546,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with an `unknown_status` tag value.
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -560,12 +558,12 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to
-                        .contain(`${protocolDefinition.protocol}/foo/$tags/status must be equal to one of the allowed values`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    const expectedStatusMsg = `${protocolDefinition.protocol}/foo/$tags/status must be equal to one of the allowed values`;
+                    expect(fooRecordReply.status.detail).toContain(expectedStatusMsg);
                     // ensure the correct tag descriptor path is in the error message
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/status`);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/status`);
                     // write a foo record with a valid `status` tag value.
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -578,7 +576,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject a record with a tag value that is not within the `minimum` and `maximum` range', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -607,7 +605,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with an `score` value less than 0.
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -620,9 +618,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/score must be >= 0`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/score must be >= 0`);
                     // write a foo record with an `score` value greater than 100.
                     const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -635,9 +633,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
-                    expect(fooRecord2Reply.status.code).to.equal(400);
-                    expect(fooRecord2Reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecord2Reply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/score must be <= 100`);
+                    expect(fooRecord2Reply.status.code).toBe(400);
+                    expect(fooRecord2Reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecord2Reply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/score must be <= 100`);
                     // write a foo record with a maximum `score` of 100.
                     const validFooMaxRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -650,7 +648,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooMaxRecordReply = yield dwn.processMessage(alice.did, validFooMaxRecord.message, { dataStream: validFooMaxRecord.dataStream });
-                    expect(validFooMaxRecordReply.status.code).to.equal(202);
+                    expect(validFooMaxRecordReply.status.code).toBe(202);
                     // write a foo record with a maximum `score` of 0.
                     const validFooMinRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -663,7 +661,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooMinRecordReply = yield dwn.processMessage(alice.did, validFooMinRecord.message, { dataStream: validFooMinRecord.dataStream });
-                    expect(validFooMinRecordReply.status.code).to.equal(202);
+                    expect(validFooMinRecordReply.status.code).toBe(202);
                     // write a foo record within the range
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -676,7 +674,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject a record with a tag value that is not within the `exclusiveMinimum` and `exclusiveMaximum` range', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -705,7 +703,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with an hour at the exclusiveMaximum
                     const exclusiveMaxRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -718,9 +716,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const exclusiveMaxReply = yield dwn.processMessage(alice.did, exclusiveMaxRecord.message, { dataStream: exclusiveMaxRecord.dataStream });
-                    expect(exclusiveMaxReply.status.code).to.equal(400);
-                    expect(exclusiveMaxReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(exclusiveMaxReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/hours must be < 24`);
+                    expect(exclusiveMaxReply.status.code).toBe(400);
+                    expect(exclusiveMaxReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(exclusiveMaxReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/hours must be < 24`);
                     // write a foo record with an hour at the exclusiveMinimum
                     const exclusiveMinRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -733,9 +731,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const exclusiveMinReply = yield dwn.processMessage(alice.did, exclusiveMinRecord.message, { dataStream: exclusiveMinRecord.dataStream });
-                    expect(exclusiveMinReply.status.code).to.equal(400);
-                    expect(exclusiveMinReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(exclusiveMinReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/hours must be > 0`);
+                    expect(exclusiveMinReply.status.code).toBe(400);
+                    expect(exclusiveMinReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(exclusiveMinReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/hours must be > 0`);
                     // write a foo record with an `hour` value within the range.
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -748,7 +746,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject tag values that are not within the `minLength` and `maxLength` values', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -777,7 +775,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `stringWithLimit` value less than the minimum length
                     const minLengthRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -790,10 +788,10 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const minLengthReply = yield dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
-                    expect(minLengthReply.status.code).to.equal(400);
-                    expect(minLengthReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(minLengthReply.status.detail).to
-                        .contain(`${protocolDefinition.protocol}/foo/$tags/stringWithLimit must NOT have fewer than 5 characters`);
+                    expect(minLengthReply.status.code).toBe(400);
+                    expect(minLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    const expectedMinMsg = `${protocolDefinition.protocol}/foo/$tags/stringWithLimit must NOT have fewer than 5 characters`;
+                    expect(minLengthReply.status.detail).toContain(expectedMinMsg);
                     // write a foo record with a `stringWithLimit` value greater than the maximum length
                     const maxLengthRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -806,10 +804,10 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const maxLengthReply = yield dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
-                    expect(maxLengthReply.status.code).to.equal(400);
-                    expect(maxLengthReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(maxLengthReply.status.detail).to
-                        .contain(`${protocolDefinition.protocol}/foo/$tags/stringWithLimit must NOT have more than 10 characters`);
+                    expect(maxLengthReply.status.code).toBe(400);
+                    expect(maxLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    const expectedMaxMsg = `${protocolDefinition.protocol}/foo/$tags/stringWithLimit must NOT have more than 10 characters`;
+                    expect(maxLengthReply.status.detail).toContain(expectedMaxMsg);
                     // write a foo record with a `stringWithLimit` value within the range
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -822,7 +820,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject tag values that do not contain the number of items within the `minItems` and `maxItems` values', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -854,7 +852,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with only 1 item, less than the `minItems` specified of 2
                     const minLengthRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -867,9 +865,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const minLengthReply = yield dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
-                    expect(minLengthReply.status.code).to.equal(400);
-                    expect(minLengthReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(minLengthReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/numberArray must NOT have fewer than 2 items`);
+                    expect(minLengthReply.status.code).toBe(400);
+                    expect(minLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(minLengthReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must NOT have fewer than 2 items`);
                     // write a foo record with a `numberArray` value with 4 items, more than the `maxItems` specified of 3
                     const maxLengthRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -882,9 +880,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const maxLengthReply = yield dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
-                    expect(maxLengthReply.status.code).to.equal(400);
-                    expect(maxLengthReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(maxLengthReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/numberArray must NOT have more than 3 items`);
+                    expect(maxLengthReply.status.code).toBe(400);
+                    expect(maxLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(maxLengthReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must NOT have more than 3 items`);
                     // write a foo record with a `numberArray` value with 3 items, within the range
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -897,7 +895,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject a value within an array that should only include numbers', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -927,7 +925,7 @@ export function testRecordsTags() {
                         protocolDefinition
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with a string
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -940,9 +938,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/numberArray/0 must be number`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray/0 must be number`);
                     // write a foo record with a `numberArray` value with a number (both integer and decimal)
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -955,7 +953,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject a value within an array that should only include integers', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -985,7 +983,7 @@ export function testRecordsTags() {
                         protocolDefinition
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with a decimal
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -998,9 +996,9 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags/numberArray/1 must be integer`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray/1 must be integer`);
                     // write a foo record with a `numberArray` value with values of integers
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1013,7 +1011,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject tag values that do not contain the number of items within the `minContains` and `maxContains` values', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1050,7 +1048,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with only 1 item that matches contains contraint, less than the `minContains` of 2
                     // but additional items that would equal more than 2 items
                     const minLengthRecord = yield TestDataGenerator.generateRecordsWrite({
@@ -1064,10 +1062,10 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const minLengthReply = yield dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
-                    expect(minLengthReply.status.code).to.equal(400);
-                    expect(minLengthReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(minLengthReply.status.code).toBe(400);
+                    expect(minLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(minLengthReply.status.detail)
-                        .to.contain(`${protocolDefinition.protocol}/foo/$tags/numberArray must contain at least 2 and no more than 4 valid item(s)`);
+                        .toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must contain at least 2 and no more than 4 valid item(s)`);
                     // write a foo record with a `numberArray` value with 4 items, more than the `maxItems` specified of 3
                     const maxLengthRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1080,10 +1078,10 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const maxLengthReply = yield dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
-                    expect(maxLengthReply.status.code).to.equal(400);
-                    expect(maxLengthReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(maxLengthReply.status.code).toBe(400);
+                    expect(maxLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(maxLengthReply.status.detail)
-                        .to.contain(`${protocolDefinition.protocol}/foo/$tags/numberArray must contain at least 2 and no more than 4 valid item(s)`);
+                        .toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must contain at least 2 and no more than 4 valid item(s)`);
                     // write a foo record with a `numberArray` value with 3 items, within the range
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1096,7 +1094,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should reject tag values that do not follow the constraints of the `uniqueItems` value', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1127,7 +1125,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `uniqueStrings` value with duplicate items
                     const duplicateItemsRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1140,7 +1138,7 @@ export function testRecordsTags() {
                     });
                     // should fail
                     const duplicateItemsReply = yield dwn.processMessage(alice.did, duplicateItemsRecord.message, { dataStream: duplicateItemsRecord.dataStream });
-                    expect(duplicateItemsReply.status.code).to.equal(400);
+                    expect(duplicateItemsReply.status.code).toBe(400);
                     // write a foo record with a `uniqueStrings` value with unique items
                     const uniqueItemsRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1153,7 +1151,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const uniqueItemsReply = yield dwn.processMessage(alice.did, uniqueItemsRecord.message, { dataStream: uniqueItemsRecord.dataStream });
-                    expect(uniqueItemsReply.status.code).to.equal(202);
+                    expect(uniqueItemsReply.status.code).toBe(202);
                 }));
                 it('should only accept a record containing tags required by $requiredTags', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1181,7 +1179,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record without the required tag
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1190,9 +1188,9 @@ export function testRecordsTags() {
                         protocolPath: 'foo',
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(400);
-                    expect(fooRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                    expect(fooRecordReply.status.detail).to.contain(`${protocolDefinition.protocol}/foo/$tags must have required property 'someRequiredTag'`);
+                    expect(fooRecordReply.status.code).toBe(400);
+                    expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                    expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags must have required property 'someRequiredTag'`);
                     // write a foo record with the required tag
                     const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1205,7 +1203,7 @@ export function testRecordsTags() {
                     });
                     // should pass
                     const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                    expect(validFooRecordReply.status.code).to.equal(202);
+                    expect(validFooRecordReply.status.code).toBe(202);
                 }));
                 it('should accept any tag if $allowUndefinedTags is set to true', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1233,7 +1231,7 @@ export function testRecordsTags() {
                         protocolDefinition,
                     });
                     const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                    expect(configureReply.status.code).to.equal(202);
+                    expect(configureReply.status.code).toBe(202);
                     // write a foo record without the required tag
                     const fooRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1245,7 +1243,7 @@ export function testRecordsTags() {
                         }
                     });
                     const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
-                    expect(fooRecordReply.status.code).to.equal(202);
+                    expect(fooRecordReply.status.code).toBe(202);
                 }));
                 describe('contains', () => {
                     it('should reject a record tag that does not contain a value specified within the `enum` definition', () => __awaiter(this, void 0, void 0, function* () {
@@ -1280,7 +1278,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `status` value that is not represented in the `enum`
                         const invalidEnumRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1293,10 +1291,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const invalidEnumReply = yield dwn.processMessage(alice.did, invalidEnumRecord.message, { dataStream: invalidEnumRecord.dataStream });
-                        expect(invalidEnumReply.status.code).to.equal(400);
-                        expect(invalidEnumReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(invalidEnumReply.status.code).toBe(400);
+                        expect(invalidEnumReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(invalidEnumReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/status must contain at least 1 valid item(s)`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/status must contain at least 1 valid item(s)`);
                         // write a foo record that now adds a valid `status` value to the array
                         const validEnumRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1309,7 +1307,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validEnumReply = yield dwn.processMessage(alice.did, validEnumRecord.message, { dataStream: validEnumRecord.dataStream });
-                        expect(validEnumReply.status.code).to.equal(202);
+                        expect(validEnumReply.status.code).toBe(202);
                     }));
                     it('should reject a record tag that does not contain a value within the `minimum` and `maximum` range ', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1344,7 +1342,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `containsNumbers` value that does not have a number within the range
                         const minContainsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1357,10 +1355,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const minContainsReply = yield dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
-                        expect(minContainsReply.status.code).to.equal(400);
-                        expect(minContainsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(minContainsReply.status.code).toBe(400);
+                        expect(minContainsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minContainsReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/containsNumbers must contain at least 1 valid item(s)`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/containsNumbers must contain at least 1 valid item(s)`);
                         // write a foo record with a `containsNumbers` value that has a number within the range
                         const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1373,7 +1371,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                        expect(validFooRecordReply.status.code).to.equal(202);
+                        expect(validFooRecordReply.status.code).toBe(202);
                     }));
                     it('should reject a record tag that does not contain a value within the `exclusiveMinimum` and `exclusiveMaximum` range ', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1408,7 +1406,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `containsNumbers` value that does not have a number within the range
                         const minContainsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1421,10 +1419,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const minContainsReply = yield dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
-                        expect(minContainsReply.status.code).to.equal(400);
-                        expect(minContainsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(minContainsReply.status.code).toBe(400);
+                        expect(minContainsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minContainsReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/containsNumbers must contain at least 1 valid item(s)`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/containsNumbers must contain at least 1 valid item(s)`);
                         // write a foo record with a `containsNumbers` value that has a number within the range
                         const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1437,7 +1435,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                        expect(validFooRecordReply.status.code).to.equal(202);
+                        expect(validFooRecordReply.status.code).toBe(202);
                     }));
                     it('should reject a record tag that does not contain a value within the `minLength` and `maxLength` range ', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1472,7 +1470,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `firstName` value that does not have a string within the range
                         const minContainsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1485,10 +1483,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const minContainsReply = yield dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
-                        expect(minContainsReply.status.code).to.equal(400);
-                        expect(minContainsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                        expect(minContainsReply.status.detail).to
-                            .contain(`${protocolDefinition.protocol}/foo/$tags/nickNames must contain at least 1 valid item(s)`);
+                        expect(minContainsReply.status.code).toBe(400);
+                        expect(minContainsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        const expectedContainsMsg = `${protocolDefinition.protocol}/foo/$tags/nickNames must contain at least 1 valid item(s)`;
+                        expect(minContainsReply.status.detail).toContain(expectedContainsMsg);
                         // write a foo record with a `nickNames` value that has a string within the range
                         const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1501,7 +1499,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                        expect(validFooRecordReply.status.code).to.equal(202);
+                        expect(validFooRecordReply.status.code).toBe(202);
                     }));
                 });
                 describe('items', () => {
@@ -1534,7 +1532,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `status` value that is not represented in the `enum`
                         const invalidEnumRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1547,10 +1545,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const invalidEnumReply = yield dwn.processMessage(alice.did, invalidEnumRecord.message, { dataStream: invalidEnumRecord.dataStream });
-                        expect(invalidEnumReply.status.code).to.equal(400);
-                        expect(invalidEnumReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(invalidEnumReply.status.code).toBe(400);
+                        expect(invalidEnumReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(invalidEnumReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/status/1 must be equal to one of the allowed values`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/status/1 must be equal to one of the allowed values`);
                         // write a foo record that now includes only valid `status` values
                         const validEnumRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1563,7 +1561,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validEnumReply = yield dwn.processMessage(alice.did, validEnumRecord.message, { dataStream: validEnumRecord.dataStream });
-                        expect(validEnumReply.status.code).to.equal(202);
+                        expect(validEnumReply.status.code).toBe(202);
                     }));
                     it('should reject a record tag which all items do not have a value within the `minimum` and `maximum` range ', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1595,7 +1593,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `numbers` value that is less than the minimum
                         const minItemssRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1608,10 +1606,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const minItemsReply = yield dwn.processMessage(alice.did, minItemssRecord.message, { dataStream: minItemssRecord.dataStream });
-                        expect(minItemsReply.status.code).to.equal(400);
-                        expect(minItemsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(minItemsReply.status.code).toBe(400);
+                        expect(minItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minItemsReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/numbers/0 must be >= 80`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/0 must be >= 80`);
                         // write a foo record with a `numbers` value that is more than the maximum
                         const maxItemssRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1624,10 +1622,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const maxItemsReply = yield dwn.processMessage(alice.did, maxItemssRecord.message, { dataStream: maxItemssRecord.dataStream });
-                        expect(maxItemsReply.status.code).to.equal(400);
-                        expect(maxItemsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(maxItemsReply.status.code).toBe(400);
+                        expect(maxItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(maxItemsReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/numbers/1 must be <= 100`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/1 must be <= 100`);
                         // write a foo record with a `numbers` value that are within the range
                         const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1640,7 +1638,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                        expect(validFooRecordReply.status.code).to.equal(202);
+                        expect(validFooRecordReply.status.code).toBe(202);
                     }));
                     it('should reject a record tag which all items do not have a value within the `exclusiveMinimum` and `exclusiveMaximum` range ', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1672,7 +1670,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `numbers` value that is equal to than the exclusive minimum
                         const minItemsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1685,10 +1683,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const minItemsReply = yield dwn.processMessage(alice.did, minItemsRecord.message, { dataStream: minItemsRecord.dataStream });
-                        expect(minItemsReply.status.code).to.equal(400);
-                        expect(minItemsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(minItemsReply.status.code).toBe(400);
+                        expect(minItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minItemsReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/numbers/0 must be > 80`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/0 must be > 80`);
                         // write a foo record with a `numbers` value that is equal to than the exclusive maximum
                         const maxContainsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1701,10 +1699,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const maxItemsReply = yield dwn.processMessage(alice.did, maxContainsRecord.message, { dataStream: maxContainsRecord.dataStream });
-                        expect(maxItemsReply.status.code).to.equal(400);
-                        expect(maxItemsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        expect(maxItemsReply.status.code).toBe(400);
+                        expect(maxItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(maxItemsReply.status.detail)
-                            .to.contain(`${protocolDefinition.protocol}/foo/$tags/numbers/1 must be < 100`);
+                            .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/1 must be < 100`);
                         // write a foo record with a `numbers` value that are within the range
                         const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1717,7 +1715,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                        expect(validFooRecordReply.status.code).to.equal(202);
+                        expect(validFooRecordReply.status.code).toBe(202);
                     }));
                     it('should reject a record tag that does not contain a value within the `minLength` and `maxLength` range ', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1749,7 +1747,7 @@ export function testRecordsTags() {
                             protocolDefinition,
                         });
                         const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                        expect(configureReply.status.code).to.equal(202);
+                        expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `firstName` value that does not have a string within the range
                         const minItemsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1762,10 +1760,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const minItemsReply = yield dwn.processMessage(alice.did, minItemsRecord.message, { dataStream: minItemsRecord.dataStream });
-                        expect(minItemsReply.status.code).to.equal(400);
-                        expect(minItemsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                        expect(minItemsReply.status.detail).to
-                            .contain(`${protocolDefinition.protocol}/foo/$tags/nickNames/1 must NOT have fewer than 2 characters`);
+                        expect(minItemsReply.status.code).toBe(400);
+                        expect(minItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        const expectedMinItemsMsg = `${protocolDefinition.protocol}/foo/$tags/nickNames/1 must NOT have fewer than 2 characters`;
+                        expect(minItemsReply.status.detail).toContain(expectedMinItemsMsg);
                         // write a foo record with a `nickname` value this is too long
                         const maxItemsRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1778,10 +1776,10 @@ export function testRecordsTags() {
                         });
                         // should fail
                         const maxItemsReply = yield dwn.processMessage(alice.did, maxItemsRecord.message, { dataStream: maxItemsRecord.dataStream });
-                        expect(maxItemsReply.status.code).to.equal(400);
-                        expect(maxItemsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
-                        expect(maxItemsReply.status.detail).to
-                            .contain(`${protocolDefinition.protocol}/foo/$tags/nickNames/1 must NOT have more than 10 characters`);
+                        expect(maxItemsReply.status.code).toBe(400);
+                        expect(maxItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
+                        const expectedMaxItemsMsg = `${protocolDefinition.protocol}/foo/$tags/nickNames/1 must NOT have more than 10 characters`;
+                        expect(maxItemsReply.status.detail).toContain(expectedMaxItemsMsg);
                         // write a foo record with a `nickNames` value that has a string within the range
                         const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1794,7 +1792,7 @@ export function testRecordsTags() {
                         });
                         // should pass
                         const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
-                        expect(validFooRecordReply.status.code).to.equal(202);
+                        expect(validFooRecordReply.status.code).toBe(202);
                     }));
                 });
             });
@@ -1819,7 +1817,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 // verify the record was written
                 const tagsRecord1Read = yield RecordsRead.create({
                     filter: {
@@ -1828,10 +1826,10 @@ export function testRecordsTags() {
                     signer: Jws.createSigner(alice)
                 });
                 const tagsRecord1ReadReply = yield dwn.processMessage(alice.did, tagsRecord1Read.message);
-                expect(tagsRecord1ReadReply.status.code).to.equal(200);
-                expect(tagsRecord1ReadReply.entry.recordsWrite).to.not.be.undefined;
+                expect(tagsRecord1ReadReply.status.code).toBe(200);
+                expect(tagsRecord1ReadReply.entry.recordsWrite).toBeDefined();
                 expect(tagsRecord1ReadReply.entry.recordsWrite.descriptor.tags)
-                    .to.deep.equal({ stringTag, numberTag, booleanTag, stringArrayTag, numberArrayTag });
+                    .toEqual({ stringTag, numberTag, booleanTag, stringArrayTag, numberArrayTag });
             }));
             it('should overwrite tags when updating a Record', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -1850,7 +1848,7 @@ export function testRecordsTags() {
                 });
                 // write the record
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 // verify the record was written
                 const tagsRecord1Read = yield RecordsRead.create({
                     filter: {
@@ -1859,9 +1857,9 @@ export function testRecordsTags() {
                     signer: Jws.createSigner(alice)
                 });
                 const tagsRecord1ReadReply = yield dwn.processMessage(alice.did, tagsRecord1Read.message);
-                expect(tagsRecord1ReadReply.status.code).to.equal(200);
-                expect(tagsRecord1ReadReply.entry.recordsWrite).to.not.be.undefined;
-                expect(tagsRecord1ReadReply.entry.recordsWrite.descriptor.tags).to.deep.equal({
+                expect(tagsRecord1ReadReply.status.code).toBe(200);
+                expect(tagsRecord1ReadReply.entry.recordsWrite).toBeDefined();
+                expect(tagsRecord1ReadReply.entry.recordsWrite.descriptor.tags).toEqual({
                     stringTag: 'string-value',
                     numberTag: 54566975,
                     booleanTag: false,
@@ -1878,9 +1876,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchReply.entries[0].recordId).to.equal(tagsRecord1.message.recordId);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record with new tags
                 const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
@@ -1888,15 +1886,15 @@ export function testRecordsTags() {
                     tags: { newTag: 'new-value' }
                 });
                 const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
-                expect(updatedRecordReply.status.code).to.equal(202, updatedRecordReply.status.detail);
+                expect(updatedRecordReply.status.code).toBe(202, updatedRecordReply.status.detail);
                 const updatedRecordReadReply = yield dwn.processMessage(alice.did, tagsRecord1Read.message);
-                expect(updatedRecordReadReply.status.code).to.equal(200);
-                expect(updatedRecordReadReply.entry.recordsWrite).to.exist;
-                expect(updatedRecordReadReply.entry.recordsWrite.descriptor.tags).to.deep.equal({ newTag: 'new-value' });
+                expect(updatedRecordReadReply.status.code).toBe(200);
+                expect(updatedRecordReadReply.entry.recordsWrite).toBeDefined();
+                expect(updatedRecordReadReply.entry.recordsWrite.descriptor.tags).toEqual({ newTag: 'new-value' });
                 // Sanity: Query for the old tag value should return no results
                 const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply2.status.code).to.equal(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(tagsQueryMatchReply2.status.code).toBe(200);
+                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
             }));
             it('should not index tags when the record is not `latestBaseState`', () => __awaiter(this, void 0, void 0, function* () {
                 const buildTagIndexSpy = sinon.spy(Records, 'buildTagIndexes');
@@ -1917,11 +1915,11 @@ export function testRecordsTags() {
                 });
                 // write the record
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 // verify that construct Indexes was called
-                expect(constructIndexesSpy.callCount).to.equal(1);
+                expect(constructIndexesSpy.callCount).toBe(1);
                 // verify that buildTagIndexes was called
-                expect(buildTagIndexSpy.callCount).to.equal(1);
+                expect(buildTagIndexSpy.callCount).toBe(1);
                 // reset counters
                 constructIndexesSpy.resetHistory();
                 buildTagIndexSpy.resetHistory();
@@ -1931,11 +1929,11 @@ export function testRecordsTags() {
                     existingWrite: tagsRecord1.recordsWrite,
                 });
                 const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
-                expect(updatedRecordReply.status.code).to.equal(202);
+                expect(updatedRecordReply.status.code).toBe(202);
                 // construct Indexes should be called once for the `initialWrite` and once for the updated write
-                expect(constructIndexesSpy.callCount).to.equal(2);
+                expect(constructIndexesSpy.callCount).toBe(2);
                 // verify that buildTagIndexes was not called at all
-                expect(buildTagIndexSpy.callCount).to.equal(0);
+                expect(buildTagIndexSpy.callCount).toBe(0);
             }));
         });
         describe('RecordsQuery filter for tags', () => {
@@ -1952,7 +1950,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
@@ -1962,9 +1960,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchReply.entries[0].recordId).to.equal(tagsRecord1.message.recordId);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // negative result same tag different value
                 let tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1975,8 +1973,8 @@ export function testRecordsTags() {
                     }
                 });
                 let tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
-                expect(tagsQueryNegativeReply.status.code).to.equal(200);
-                expect((_b = tagsQueryNegativeReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(tagsQueryNegativeReply.status.code).toBe(200);
+                expect((_b = tagsQueryNegativeReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
                 // negative result different tag same value
                 tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1987,8 +1985,8 @@ export function testRecordsTags() {
                     }
                 });
                 tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
-                expect(tagsQueryNegativeReply.status.code).to.equal(200);
-                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                expect(tagsQueryNegativeReply.status.code).toBe(200);
+                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
             }));
             it('should be able to filter by number match', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
@@ -2004,7 +2002,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 // do an exact match for the tag value
                 const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2015,9 +2013,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchReply.entries[0].recordId).to.equal(tagsRecord1.message.recordId);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // negative result same tag different value
                 let tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2028,8 +2026,8 @@ export function testRecordsTags() {
                     }
                 });
                 let tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
-                expect(tagsQueryNegativeReply.status.code).to.equal(200);
-                expect((_b = tagsQueryNegativeReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(tagsQueryNegativeReply.status.code).toBe(200);
+                expect((_b = tagsQueryNegativeReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
                 // negative result different tag same value
                 tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2040,8 +2038,8 @@ export function testRecordsTags() {
                     }
                 });
                 tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
-                expect(tagsQueryNegativeReply.status.code).to.equal(200);
-                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                expect(tagsQueryNegativeReply.status.code).toBe(200);
+                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
             }));
             it('should be able to filter by boolean match', () => __awaiter(this, void 0, void 0, function* () {
                 // 1. Write a record with a boolean tag `booleanTag` set to true
@@ -2061,7 +2059,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecordTrueReply = yield dwn.processMessage(alice.did, tagsRecordTrue.message, { dataStream: tagsRecordTrue.dataStream });
-                expect(tagsRecordTrueReply.status.code).to.equal(202);
+                expect(tagsRecordTrueReply.status.code).toBe(202);
                 // write a record with a false boolean value tag
                 const tagsRecordFalse = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -2072,7 +2070,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecordFalseReply = yield dwn.processMessage(alice.did, tagsRecordFalse.message, { dataStream: tagsRecordFalse.dataStream });
-                expect(tagsRecordFalseReply.status.code).to.equal(202);
+                expect(tagsRecordFalseReply.status.code).toBe(202);
                 // query for records with a `booleanTag` set to true, should return the record with the true tag
                 const tagsQueryMatchTrue = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2083,9 +2081,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchTrueReply = yield dwn.processMessage(alice.did, tagsQueryMatchTrue.message);
-                expect(tagsQueryMatchTrueReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchTrueReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchTrueReply.entries[0].recordId).to.equal(tagsRecordTrue.message.recordId);
+                expect(tagsQueryMatchTrueReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchTrueReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchTrueReply.entries[0].recordId).toBe(tagsRecordTrue.message.recordId);
                 // query for records with a `booleanTag` set to false, should return the record with the false tag
                 const tagsQueryMatchFalse = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2096,9 +2094,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchFalseReply = yield dwn.processMessage(alice.did, tagsQueryMatchFalse.message);
-                expect(tagsQueryMatchFalseReply.status.code).to.equal(200);
-                expect((_b = tagsQueryMatchFalseReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(tagsQueryMatchFalseReply.entries[0].recordId).to.equal(tagsRecordFalse.message.recordId);
+                expect(tagsQueryMatchFalseReply.status.code).toBe(200);
+                expect((_b = tagsQueryMatchFalseReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(tagsQueryMatchFalseReply.entries[0].recordId).toBe(tagsRecordFalse.message.recordId);
                 // negative result for a non existent boolean tag.
                 const tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2109,8 +2107,8 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
-                expect(tagsQueryNegativeReply.status.code).to.equal(200);
-                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                expect(tagsQueryNegativeReply.status.code).toBe(200);
+                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
             }));
             it('should be able to range filter by string value', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d;
@@ -2149,13 +2147,13 @@ export function testRecordsTags() {
                     }
                 });
                 const aliceReply = yield dwn.processMessage(alice.did, aliceRecord.message, { dataStream: aliceRecord.dataStream });
-                expect(aliceReply.status.code).to.equal(202);
+                expect(aliceReply.status.code).toBe(202);
                 const bobReply = yield dwn.processMessage(alice.did, bobRecord.message, { dataStream: bobRecord.dataStream });
-                expect(bobReply.status.code).to.equal(202);
+                expect(bobReply.status.code).toBe(202);
                 const carolReply = yield dwn.processMessage(alice.did, carolRecord.message, { dataStream: carolRecord.dataStream });
-                expect(carolReply.status.code).to.equal(202);
+                expect(carolReply.status.code).toBe(202);
                 const danielReply = yield dwn.processMessage(alice.did, danielRecord.message, { dataStream: danielRecord.dataStream });
-                expect(danielReply.status.code).to.equal(202);
+                expect(danielReply.status.code).toBe(202);
                 // sanity query for all
                 const queryForAll = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2164,8 +2162,8 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForAllReply = yield dwn.processMessage(alice.did, queryForAll.message);
-                expect(queryForAllReply.status.code).to.equal(200);
-                expect((_a = queryForAllReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(4); // all 4 records
+                expect(queryForAllReply.status.code).toBe(200);
+                expect((_a = queryForAllReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(4); // all 4 records
                 // query for first names that begin with 'a' and 'b'
                 const queryForAtoB = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2177,10 +2175,10 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForAtoBReply = yield dwn.processMessage(alice.did, queryForAtoB.message);
-                expect(queryForAtoBReply.status.code).to.equal(200);
-                expect((_b = queryForAtoBReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
+                expect(queryForAtoBReply.status.code).toBe(200);
+                expect((_b = queryForAtoBReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
                 const atobRecordIds = queryForAtoBReply.entries.map(entry => entry.recordId);
-                expect(atobRecordIds).to.have.members([aliceRecord.message.recordId, bobRecord.message.recordId]);
+                expect(atobRecordIds).toEqual(expect.arrayContaining([aliceRecord.message.recordId, bobRecord.message.recordId]));
                 // query for first names greater than 'bob'(exclusive of), and less than but inclusive of 'daniel'
                 const queryForBtoD = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2192,10 +2190,10 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForBtoDReply = yield dwn.processMessage(alice.did, queryForBtoD.message);
-                expect(queryForBtoDReply.status.code).to.equal(200);
-                expect((_c = queryForBtoDReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
+                expect(queryForBtoDReply.status.code).toBe(200);
+                expect((_c = queryForBtoDReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
                 const btodRecordIds = queryForBtoDReply.entries.map(entry => entry.recordId);
-                expect(btodRecordIds).to.have.members([carolRecord.message.recordId, danielRecord.message.recordId]);
+                expect(btodRecordIds).toEqual(expect.arrayContaining([carolRecord.message.recordId, danielRecord.message.recordId]));
                 // query for first names that begin with 'carol' onward (inclusive).
                 const queryForCarolOnward = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2207,10 +2205,10 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForCarolOnwardReply = yield dwn.processMessage(alice.did, queryForCarolOnward.message);
-                expect(queryForCarolOnwardReply.status.code).to.equal(200);
-                expect((_d = queryForCarolOnwardReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(2);
+                expect(queryForCarolOnwardReply.status.code).toBe(200);
+                expect((_d = queryForCarolOnwardReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(2);
                 const onwardResults = queryForCarolOnwardReply.entries.map(entry => entry.recordId);
-                expect(onwardResults).to.have.members([carolRecord.message.recordId, danielRecord.message.recordId]);
+                expect(onwardResults).toEqual(expect.arrayContaining([carolRecord.message.recordId, danielRecord.message.recordId]));
             }));
             it('should be able to filter by string prefix', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -2233,9 +2231,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 const tagsRecord2Reply = yield dwn.processMessage(alice.did, tagsRecord2.message, { dataStream: tagsRecord2.dataStream });
-                expect(tagsRecord2Reply.status.code).to.equal(202);
+                expect(tagsRecord2Reply.status.code).toBe(202);
                 // control record that has a different prefix
                 const tagsRecord3 = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -2246,7 +2244,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord3Reply = yield dwn.processMessage(alice.did, tagsRecord3.message, { dataStream: tagsRecord3.dataStream });
-                expect(tagsRecord3Reply.status.code).to.equal(202);
+                expect(tagsRecord3Reply.status.code).toBe(202);
                 // a prefix search will return only the records matching the prefix
                 const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2257,10 +2255,10 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 const matchedRecords = tagsQueryMatchReply.entries.map(entry => entry.recordId);
-                expect(matchedRecords).to.have.members([tagsRecord1.message.recordId, tagsRecord2.message.recordId]);
+                expect(matchedRecords).toEqual(expect.arrayContaining([tagsRecord1.message.recordId, tagsRecord2.message.recordId]));
                 // sanity/control: a regular range query will return all
                 // since `zaz-string` comes lexicographically after `string-` it will appear in the result set
                 const tagsQueryRange = yield TestDataGenerator.generateRecordsQuery({
@@ -2272,8 +2270,8 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryRangeReply = yield dwn.processMessage(alice.did, tagsQueryRange.message);
-                expect(tagsQueryRangeReply.status.code).to.equal(200);
-                expect((_b = tagsQueryRangeReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(3); // returned all 3 records
+                expect(tagsQueryRangeReply.status.code).toBe(200);
+                expect((_b = tagsQueryRangeReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(3); // returned all 3 records
             }));
             it('should be able to range filter by number value', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e;
@@ -2316,13 +2314,13 @@ export function testRecordsTags() {
                     }
                 });
                 const aliceReply = yield dwn.processMessage(alice.did, aliceRecord.message, { dataStream: aliceRecord.dataStream });
-                expect(aliceReply.status.code).to.equal(202);
+                expect(aliceReply.status.code).toBe(202);
                 const bobReply = yield dwn.processMessage(alice.did, bobRecord.message, { dataStream: bobRecord.dataStream });
-                expect(bobReply.status.code).to.equal(202);
+                expect(bobReply.status.code).toBe(202);
                 const carolReply = yield dwn.processMessage(alice.did, carolRecord.message, { dataStream: carolRecord.dataStream });
-                expect(carolReply.status.code).to.equal(202);
+                expect(carolReply.status.code).toBe(202);
                 const danielReply = yield dwn.processMessage(alice.did, danielRecord.message, { dataStream: danielRecord.dataStream });
-                expect(danielReply.status.code).to.equal(202);
+                expect(danielReply.status.code).toBe(202);
                 // sanity query for all
                 const queryForAll = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2331,8 +2329,8 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForAllReply = yield dwn.processMessage(alice.did, queryForAll.message);
-                expect(queryForAllReply.status.code).to.equal(200);
-                expect((_a = queryForAllReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(4); // all 4 records
+                expect(queryForAllReply.status.code).toBe(200);
+                expect((_a = queryForAllReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(4); // all 4 records
                 // query for all records that received higher than(not including) an 80
                 // only one record should match
                 const queryForHighGrade = yield TestDataGenerator.generateRecordsQuery({
@@ -2345,9 +2343,9 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForHighReply = yield dwn.processMessage(alice.did, queryForHighGrade.message);
-                expect(queryForHighReply.status.code).to.equal(200);
-                expect((_b = queryForHighReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(queryForHighReply.entries[0].recordId).to.equal(danielRecord.message.recordId);
+                expect(queryForHighReply.status.code).toBe(200);
+                expect((_b = queryForHighReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(queryForHighReply.entries[0].recordId).toBe(danielRecord.message.recordId);
                 // query for all records that received higher (and including) a 75
                 // three records should match
                 const queryForPassingGrade = yield TestDataGenerator.generateRecordsQuery({
@@ -2360,10 +2358,12 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForPassingGradeReply = yield dwn.processMessage(alice.did, queryForPassingGrade.message);
-                expect(queryForPassingGradeReply.status.code).to.equal(200);
-                expect((_c = queryForPassingGradeReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(3);
+                expect(queryForPassingGradeReply.status.code).toBe(200);
+                expect((_c = queryForPassingGradeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(3);
                 const passingRecords = queryForPassingGradeReply.entries.map(entry => entry.recordId);
-                expect(passingRecords).to.have.members([danielRecord.message.recordId, bobRecord.message.recordId, aliceRecord.message.recordId]);
+                expect(passingRecords).toEqual(expect.arrayContaining([
+                    danielRecord.message.recordId, bobRecord.message.recordId, aliceRecord.message.recordId
+                ]));
                 // query for poorly performing grades (65 and below, inclusive)
                 const queryForPoorGrades = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2375,9 +2375,9 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForPoorGradesReply = yield dwn.processMessage(alice.did, queryForPoorGrades.message);
-                expect(queryForPoorGradesReply.status.code).to.equal(200);
-                expect((_d = queryForPoorGradesReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(1);
-                expect(queryForPoorGradesReply.entries[0].recordId).to.equal(carolRecord.message.recordId);
+                expect(queryForPoorGradesReply.status.code).toBe(200);
+                expect((_d = queryForPoorGradesReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+                expect(queryForPoorGradesReply.entries[0].recordId).toBe(carolRecord.message.recordId);
                 // query for passing grades that were not perfect scores
                 const queryForRange = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2389,10 +2389,10 @@ export function testRecordsTags() {
                     }
                 });
                 const queryForRangeReply = yield dwn.processMessage(alice.did, queryForRange.message);
-                expect(queryForRangeReply.status.code).to.equal(200);
-                expect((_e = queryForRangeReply.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(2);
+                expect(queryForRangeReply.status.code).toBe(200);
+                expect((_e = queryForRangeReply.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(2);
                 const rangeRecords = queryForRangeReply.entries.map(entry => entry.recordId);
-                expect(rangeRecords).to.have.members([bobRecord.message.recordId, aliceRecord.message.recordId]);
+                expect(rangeRecords).toEqual(expect.arrayContaining([bobRecord.message.recordId, aliceRecord.message.recordId]));
             }));
             it('should return results based on the latest tag values', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -2406,7 +2406,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
@@ -2416,9 +2416,9 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchReply.entries[0].recordId).to.equal(tagsRecord1.message.recordId);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record with new tags
                 const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
@@ -2426,11 +2426,11 @@ export function testRecordsTags() {
                     tags: { otherTag: 'other-value' } // new tags
                 });
                 const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
-                expect(updatedRecordReply.status.code).to.equal(202);
+                expect(updatedRecordReply.status.code).toBe(202);
                 // issuing the same query should return no results
                 const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply2.status.code).to.equal(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(tagsQueryMatchReply2.status.code).toBe(200);
+                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
             }));
             it('should not return results if the record was updated with empty tags', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -2444,7 +2444,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
@@ -2454,20 +2454,20 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchReply.entries[0].recordId).to.equal(tagsRecord1.message.recordId);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record without any tags
                 const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
                     existingWrite: tagsRecord1.recordsWrite,
                 });
                 const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
-                expect(updatedRecordReply.status.code).to.equal(202);
+                expect(updatedRecordReply.status.code).toBe(202);
                 // issuing the same query should return no results
                 const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply2.status.code).to.equal(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(tagsQueryMatchReply2.status.code).toBe(200);
+                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
             }));
         });
         describe('RecordsDelete with tags', () => {
@@ -2484,7 +2484,7 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
-                expect(tagsRecord1Reply.status.code).to.equal(202);
+                expect(tagsRecord1Reply.status.code).toBe(202);
                 //sanity: query for the record
                 const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2495,20 +2495,20 @@ export function testRecordsTags() {
                     }
                 });
                 const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply.status.code).to.equal(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(tagsQueryMatchReply.entries[0].recordId).to.equal(tagsRecord1.message.recordId);
+                expect(tagsQueryMatchReply.status.code).toBe(200);
+                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // delete the record
                 const recordDelete = yield TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: tagsRecord1.message.recordId,
                 });
                 const recordDeleteReply = yield dwn.processMessage(alice.did, recordDelete.message);
-                expect(recordDeleteReply.status.code).to.equal(202);
+                expect(recordDeleteReply.status.code).toBe(202);
                 // issue the the same query should return no results
                 const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
-                expect(tagsQueryMatchReply2.status.code).to.equal(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(tagsQueryMatchReply2.status.code).toBe(200);
+                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
             }));
         });
     });