@enbox/dwn-sdk-js 0.0.1 → 0.0.3

package/dist/esm/tests/handlers/messages-read.spec.js

@@ -7,16 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { expect } from 'chai';
 import { GeneralJwsVerifier } from '../../src/jose/jws/general/verifier.js';
 import { Message } from '../../src/core/message.js';
-import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' assert { type: 'json' };
+import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
+import sinon from 'sinon';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DataStream, Dwn, DwnConstant, DwnErrorCode, DwnInterfaceName, DwnMethodName, Jws, PermissionGrant, PermissionsProtocol, Time } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-import sinon from 'sinon';
 export function testMessagesReadHandler() {
     describe('MessagesReadHandler.handle()', () => {
         let dwn;
@@ -24,29 +24,29 @@ export function testMessagesReadHandler() {
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         // 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* () {
             // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
             yield messageStore.clear();
             yield dataStore.clear();
             yield resumableTaskStore.clear();
-            yield eventLog.clear();
+            yield stateIndex.clear();
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
         }));
-        after(() => __awaiter(this, void 0, void 0, function* () {
+        afterAll(() => __awaiter(this, void 0, void 0, function* () {
             sinon.restore();
             yield dwn.close();
         }));
@@ -60,8 +60,8 @@ export function testMessagesReadHandler() {
             });
             // alice is not the author of the message
             const reply = yield dwn.processMessage(alice.did, message);
-            expect(reply.status.code).to.equal(401);
-            expect(reply.status.detail).to.include('Invalid signature');
+            expect(reply.status.code).toBe(401);
+            expect(reply.status.detail).toContain('Invalid signature');
         }));
         it('returns a 400 if message is invalid', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -72,7 +72,7 @@ export function testMessagesReadHandler() {
             });
             message['descriptor']['troll'] = 'hehe';
             const reply = yield dwn.processMessage(alice.did, message);
-            expect(reply.status.code).to.equal(400);
+            expect(reply.status.code).toBe(400);
         }));
         it('returns a 400 if message contains an invalid message cid', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -83,9 +83,9 @@ export function testMessagesReadHandler() {
             });
             message.descriptor.messageCid = 'hehetroll';
             const reply = yield dwn.processMessage(alice.did, message);
-            expect(reply.status.code).to.equal(400);
-            expect(reply.status.detail).to.include('is not a valid CID');
-            expect(reply.entry).to.be.undefined;
+            expect(reply.status.code).toBe(400);
+            expect(reply.status.detail).toContain('is not a valid CID');
+            expect(reply.entry).toBeUndefined();
         }));
         it('returns a 404 and the entry as undefined in reply entry when a messageCid is not found', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -97,8 +97,8 @@ export function testMessagesReadHandler() {
             });
             // returns a 404 because the RecordsWrite created above was never stored
             const reply = yield dwn.processMessage(alice.did, message);
-            expect(reply.status.code).to.equal(404);
-            expect(reply.entry).to.be.undefined;
+            expect(reply.status.code).toBe(404);
+            expect(reply.entry).toBeUndefined();
         }));
         describe('without a grant', () => {
             describe('records interface messages', () => {
@@ -108,15 +108,15 @@ export function testMessagesReadHandler() {
                     // bob creates a record that alice will try and get
                     const { message: recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: bob });
                     const { status } = yield dwn.processMessage(bob.did, recordsWrite, { dataStream });
-                    expect(status.code).to.equal(202);
+                    expect(status.code).toBe(202);
                     // alice tries to read the message
                     const { message } = yield TestDataGenerator.generateMessagesRead({
                         author: alice,
                         messageCid: yield Message.getCid(recordsWrite)
                     });
                     const reply = yield dwn.processMessage(bob.did, message);
-                    expect(reply.status.code).to.equal(401);
-                    expect(reply.status.detail).to.include(DwnErrorCode.MessagesReadAuthorizationFailed);
+                    expect(reply.status.code).toBe(401);
+                    expect(reply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
                 }));
                 describe('gets record data in the reply entry', () => {
                     it('data is less than threshold', () => __awaiter(this, void 0, void 0, function* () {
@@ -126,22 +126,22 @@ export function testMessagesReadHandler() {
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded),
                         });
                         const reply = yield dwn.processMessage(alice.did, recordsWrite, { dataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         const recordsWriteMessageCid = yield Message.getCid(recordsWrite);
                         const { message } = yield TestDataGenerator.generateMessagesRead({
                             author: alice,
                             messageCid: recordsWriteMessageCid
                         });
                         const messagesReadReply = yield dwn.processMessage(alice.did, message);
-                        expect(messagesReadReply.status.code).to.equal(200);
-                        expect(messagesReadReply.entry).to.exist;
+                        expect(messagesReadReply.status.code).toBe(200);
+                        expect(messagesReadReply.entry).toBeDefined();
                         const messageReply = messagesReadReply.entry;
-                        expect(messageReply.messageCid).to.exist;
-                        expect(messageReply.messageCid).to.equal(recordsWriteMessageCid);
-                        expect(messageReply.message).to.exist.and.not.be.undefined;
-                        expect(messageReply.data).to.exist.and.not.be.undefined;
+                        expect(messageReply.messageCid).toBeDefined();
+                        expect(messageReply.messageCid).toBe(recordsWriteMessageCid);
+                        expect(messageReply.message).toBeDefined();
+                        expect(messageReply.data).toBeDefined();
                         const messageData = yield DataStream.toBytes(messageReply.data);
-                        expect(messageData).to.eql(dataBytes);
+                        expect(messageData).toEqual(dataBytes);
                     }));
                     it('data is greater than threshold', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -150,22 +150,22 @@ export function testMessagesReadHandler() {
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 10),
                         });
                         const reply = yield dwn.processMessage(alice.did, recordsWrite, { dataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         const recordsWriteMessageCid = yield Message.getCid(recordsWrite);
                         const { message } = yield TestDataGenerator.generateMessagesRead({
                             author: alice,
                             messageCid: recordsWriteMessageCid
                         });
                         const messagesReadReply = yield dwn.processMessage(alice.did, message);
-                        expect(messagesReadReply.status.code).to.equal(200);
-                        expect(messagesReadReply.entry).to.exist;
+                        expect(messagesReadReply.status.code).toBe(200);
+                        expect(messagesReadReply.entry).toBeDefined();
                         const messageReply = messagesReadReply.entry;
-                        expect(messageReply.messageCid).to.exist;
-                        expect(messageReply.messageCid).to.equal(recordsWriteMessageCid);
-                        expect(messageReply.message).to.exist.and.not.be.undefined;
-                        expect(messageReply.data).to.exist.and.not.be.undefined;
+                        expect(messageReply.messageCid).toBeDefined();
+                        expect(messageReply.messageCid).toBe(recordsWriteMessageCid);
+                        expect(messageReply.message).toBeDefined();
+                        expect(messageReply.data).toBeDefined();
                         const messageData = yield DataStream.toBytes(messageReply.data);
-                        expect(messageData).to.eql(dataBytes);
+                        expect(messageData).toEqual(dataBytes);
                     }));
                     it('data is not available', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -176,26 +176,26 @@ export function testMessagesReadHandler() {
                         });
                         const initialMessageCid = yield Message.getCid(recordsWriteMessage);
                         let reply = yield dwn.processMessage(alice.did, recordsWriteMessage, { dataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         const { recordsWrite: updateMessage, dataStream: updateDataStream } = yield TestDataGenerator.generateFromRecordsWrite({
                             author: alice,
                             existingWrite: recordsWrite,
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 10),
                         });
                         reply = yield dwn.processMessage(alice.did, updateMessage.toJSON(), { dataStream: updateDataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         const { message } = yield TestDataGenerator.generateMessagesRead({
                             author: alice,
                             messageCid: initialMessageCid
                         });
                         const messagesReadReply = yield dwn.processMessage(alice.did, message);
-                        expect(messagesReadReply.status.code).to.equal(200);
-                        expect(messagesReadReply.entry).to.exist;
+                        expect(messagesReadReply.status.code).toBe(200);
+                        expect(messagesReadReply.entry).toBeDefined();
                         const messageReply = messagesReadReply.entry;
-                        expect(messageReply.messageCid).to.exist;
-                        expect(messageReply.messageCid).to.equal(initialMessageCid);
-                        expect(messageReply.message).to.exist.and.not.be.undefined;
-                        expect(messageReply.data).to.be.undefined;
+                        expect(messageReply.messageCid).toBeDefined();
+                        expect(messageReply.messageCid).toBe(initialMessageCid);
+                        expect(messageReply.message).toBeDefined();
+                        expect(messageReply.data).toBeUndefined();
                     }));
                 });
             });
@@ -212,7 +212,7 @@ export function testMessagesReadHandler() {
                         protocolDefinition: unpublishedProtocolDefinition
                     });
                     const unpublishedProtocolsConfigureReply = yield dwn.processMessage(alice.did, unpublishedProtocolsConfigure);
-                    expect(unpublishedProtocolsConfigureReply.status.code).to.equal(202);
+                    expect(unpublishedProtocolsConfigureReply.status.code).toBe(202);
                     // published protocol configuration
                     const publishedProtocolDefinition = Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'http://example.com/protocol/published', published: true });
                     const { message: publishedProtocolsConfigure } = yield TestDataGenerator.generateProtocolsConfigure({
@@ -220,7 +220,7 @@ export function testMessagesReadHandler() {
                         protocolDefinition: publishedProtocolDefinition
                     });
                     const publishedProtocolsConfigureReply = yield dwn.processMessage(alice.did, publishedProtocolsConfigure);
-                    expect(publishedProtocolsConfigureReply.status.code).to.equal(202);
+                    expect(publishedProtocolsConfigureReply.status.code).toBe(202);
                     // get the message CIDs
                     const unpublishedProtocolMessageCid = yield Message.getCid(unpublishedProtocolsConfigure);
                     const publishedProtocolMessageCid = yield Message.getCid(publishedProtocolsConfigure);
@@ -230,37 +230,37 @@ export function testMessagesReadHandler() {
                         messageCid: unpublishedProtocolMessageCid,
                     });
                     const getUnpublishedProtocolConfigureReply = yield dwn.processMessage(alice.did, getUnpublishedProtocolConfigure);
-                    expect(getUnpublishedProtocolConfigureReply.status.code).to.equal(401);
-                    expect(getUnpublishedProtocolConfigureReply.status.detail).to.include(DwnErrorCode.MessagesReadAuthorizationFailed);
-                    expect(getUnpublishedProtocolConfigureReply.entry).to.be.undefined;
+                    expect(getUnpublishedProtocolConfigureReply.status.code).toBe(401);
+                    expect(getUnpublishedProtocolConfigureReply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
+                    expect(getUnpublishedProtocolConfigureReply.entry).toBeUndefined();
                     // bob attempts to read the published protocol configuration
                     const { message: getPublishedProtocolConfigure } = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: publishedProtocolMessageCid,
                     });
                     const getPublishedProtocolConfigureReply = yield dwn.processMessage(alice.did, getPublishedProtocolConfigure);
-                    expect(getPublishedProtocolConfigureReply.status.code).to.equal(401);
-                    expect(getPublishedProtocolConfigureReply.status.detail).to.include(DwnErrorCode.MessagesReadAuthorizationFailed);
-                    expect(getPublishedProtocolConfigureReply.entry).to.be.undefined;
+                    expect(getPublishedProtocolConfigureReply.status.code).toBe(401);
+                    expect(getPublishedProtocolConfigureReply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
+                    expect(getPublishedProtocolConfigureReply.entry).toBeUndefined();
                     // control: alice is able to read both the published and unpublished protocol configurations
                     const { message: getUnpublishedProtocolConfigureAlice } = yield TestDataGenerator.generateMessagesRead({
                         author: alice,
                         messageCid: unpublishedProtocolMessageCid,
                     });
                     const getUnpublishedProtocolConfigureAliceReply = yield dwn.processMessage(alice.did, getUnpublishedProtocolConfigureAlice);
-                    expect(getUnpublishedProtocolConfigureAliceReply.status.code).to.equal(200);
-                    expect(getUnpublishedProtocolConfigureAliceReply.entry).to.exist;
-                    expect(getUnpublishedProtocolConfigureAliceReply.entry.messageCid).to.equal(unpublishedProtocolMessageCid);
-                    expect(getUnpublishedProtocolConfigureAliceReply.entry.message).to.deep.equal(unpublishedProtocolsConfigure);
+                    expect(getUnpublishedProtocolConfigureAliceReply.status.code).toBe(200);
+                    expect(getUnpublishedProtocolConfigureAliceReply.entry).toBeDefined();
+                    expect(getUnpublishedProtocolConfigureAliceReply.entry.messageCid).toBe(unpublishedProtocolMessageCid);
+                    expect(getUnpublishedProtocolConfigureAliceReply.entry.message).toEqual(unpublishedProtocolsConfigure);
                     const { message: getPublishedProtocolConfigureAlice } = yield TestDataGenerator.generateMessagesRead({
                         author: alice,
                         messageCid: publishedProtocolMessageCid,
                     });
                     const getPublishedProtocolConfigureAliceReply = yield dwn.processMessage(alice.did, getPublishedProtocolConfigureAlice);
-                    expect(getPublishedProtocolConfigureAliceReply.status.code).to.equal(200);
-                    expect(getPublishedProtocolConfigureAliceReply.entry).to.exist;
-                    expect(getPublishedProtocolConfigureAliceReply.entry.messageCid).to.equal(publishedProtocolMessageCid);
-                    expect(getPublishedProtocolConfigureAliceReply.entry.message).to.deep.equal(publishedProtocolsConfigure);
+                    expect(getPublishedProtocolConfigureAliceReply.status.code).toBe(200);
+                    expect(getPublishedProtocolConfigureAliceReply.entry).toBeDefined();
+                    expect(getPublishedProtocolConfigureAliceReply.entry.messageCid).toBe(publishedProtocolMessageCid);
+                    expect(getPublishedProtocolConfigureAliceReply.entry.message).toEqual(publishedProtocolsConfigure);
                 }));
             });
         });
@@ -275,7 +275,7 @@ export function testMessagesReadHandler() {
                     protocolDefinition: minimalProtocolDefinition
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 // Alice writes a record which Bob will later try to read
                 const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -283,7 +283,7 @@ export function testMessagesReadHandler() {
                     protocolPath: 'foo',
                 });
                 const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                expect(recordsWriteReply.status.code).to.equal(202);
+                expect(recordsWriteReply.status.code).toBe(202);
                 // Alice gives Bob a permission grant scoped to a RecordsWrite and the protocol
                 const permissionGrant = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -297,7 +297,7 @@ export function testMessagesReadHandler() {
                 });
                 const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                 const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                expect(permissionGrantWriteReply.status.code).to.equal(202);
+                expect(permissionGrantWriteReply.status.code).toBe(202);
                 // Bob tries to MessagesRead using the RecordsWrite grant
                 const messagesRead = yield TestDataGenerator.generateMessagesRead({
                     author: bob,
@@ -305,8 +305,8 @@ export function testMessagesReadHandler() {
                     permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                 });
                 const messagesReadReply = yield dwn.processMessage(alice.did, messagesRead.message);
-                expect(messagesReadReply.status.code).to.equal(401);
-                expect(messagesReadReply.status.detail).to.contain(DwnErrorCode.GrantAuthorizationInterfaceMismatch);
+                expect(messagesReadReply.status.code).toBe(401);
+                expect(messagesReadReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationInterfaceMismatch);
             }));
             it('allows external parties to read a message using a grant with unrestricted scope', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: Alice gives Bob a grant allowing him to read any message in her DWN.
@@ -318,7 +318,7 @@ export function testMessagesReadHandler() {
                     author: alice,
                 });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 const messageCid = yield Message.getCid(message);
                 // Alice issues a permission grant allowing Bob to read any record in her DWN
                 const permissionGrant = yield PermissionsProtocol.createGrant({
@@ -332,7 +332,7 @@ export function testMessagesReadHandler() {
                 });
                 const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                 const grantReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                expect(grantReply.status.code).to.equal(202);
+                expect(grantReply.status.code).toBe(202);
                 // Bob invokes that grant to read a record from Alice's DWN
                 const messagesRead = yield TestDataGenerator.generateMessagesRead({
                     author: bob,
@@ -340,9 +340,9 @@ export function testMessagesReadHandler() {
                     messageCid,
                 });
                 const readReply = yield dwn.processMessage(alice.did, messagesRead.message);
-                expect(readReply.status.code).to.equal(200);
-                expect(readReply.entry).to.not.be.undefined;
-                expect(readReply.entry.messageCid).to.equal(messageCid);
+                expect(readReply.status.code).toBe(200);
+                expect(readReply.entry).toBeDefined();
+                expect(readReply.entry.messageCid).toBe(messageCid);
             }));
             describe('protocol scoped messages', () => {
                 it('allows reads of protocol messages with a protocol restricted grant scope', () => __awaiter(this, void 0, void 0, function* () {
@@ -368,7 +368,7 @@ export function testMessagesReadHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     const protocolConfigureMessageCid = yield Message.getCid(protocolsConfig.message);
                     // Carol requests a grant to write records to the protocol
                     const permissionRequestCarol = yield PermissionsProtocol.createRequest({
@@ -382,7 +382,7 @@ export function testMessagesReadHandler() {
                     });
                     const requestDataStreamCarol = DataStream.fromBytes(permissionRequestCarol.permissionRequestBytes);
                     const permissionRequestWriteReplyCarol = yield dwn.processMessage(alice.did, permissionRequestCarol.recordsWrite.message, { dataStream: requestDataStreamCarol });
-                    expect(permissionRequestWriteReplyCarol.status.code).to.equal(202);
+                    expect(permissionRequestWriteReplyCarol.status.code).toBe(202);
                     // Alice gives Carol a grant to write records to the protocol
                     const permissionGrantCarol = yield PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
@@ -393,7 +393,7 @@ export function testMessagesReadHandler() {
                     });
                     const grantDataStreamCarol = DataStream.fromBytes(permissionGrantCarol.permissionGrantBytes);
                     const permissionGrantWriteReplyCarol = yield dwn.processMessage(alice.did, permissionGrantCarol.recordsWrite.message, { dataStream: grantDataStreamCarol });
-                    expect(permissionGrantWriteReplyCarol.status.code).to.equal(202);
+                    expect(permissionGrantWriteReplyCarol.status.code).toBe(202);
                     const carolGrantMessageCiD = yield Message.getCid(permissionGrantCarol.recordsWrite.message);
                     // Alice writes a record associated with the protocol
                     const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
@@ -402,7 +402,7 @@ export function testMessagesReadHandler() {
                         protocolPath: 'foo',
                     });
                     const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                    expect(recordsWriteReply.status.code).to.equal(202);
+                    expect(recordsWriteReply.status.code).toBe(202);
                     const aliceRecordMessageCid = yield Message.getCid(recordsWrite.message);
                     // Alice deletes a record associated with the protocol
                     const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
@@ -410,7 +410,7 @@ export function testMessagesReadHandler() {
                         recordId: recordsWrite.message.recordId,
                     });
                     const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                    expect(recordsDeleteReply.status.code).to.equal(202);
+                    expect(recordsDeleteReply.status.code).toBe(202);
                     // Carol writes a record associated with the protocol
                     const { recordsWrite: recordsWriteCarol, dataStream: dataStreamCarol } = yield TestDataGenerator.generateRecordsWrite({
                         author: carol,
@@ -419,7 +419,7 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrantCarol.recordsWrite.message.recordId,
                     });
                     const recordsWriteReplyCarol = yield dwn.processMessage(alice.did, recordsWriteCarol.message, { dataStream: dataStreamCarol });
-                    expect(recordsWriteReplyCarol.status.code).to.equal(202);
+                    expect(recordsWriteReplyCarol.status.code).toBe(202);
                     const carolRecordMessageCid = yield Message.getCid(recordsWriteCarol.message);
                     // Alice revokes Carol's grant
                     const permissionRevocationCarol = yield PermissionsProtocol.createRevocation({
@@ -428,7 +428,7 @@ export function testMessagesReadHandler() {
                     });
                     const permissionRevocationCarolDataStream = DataStream.fromBytes(permissionRevocationCarol.permissionRevocationBytes);
                     const permissionRevocationCarolReply = yield dwn.processMessage(alice.did, permissionRevocationCarol.recordsWrite.message, { dataStream: permissionRevocationCarolDataStream });
-                    expect(permissionRevocationCarolReply.status.code).to.equal(202);
+                    expect(permissionRevocationCarolReply.status.code).toBe(202);
                     // Alice gives Bob a permission grant with scope MessagesRead
                     const permissionGrant = yield PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
@@ -442,15 +442,15 @@ export function testMessagesReadHandler() {
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                     const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                    expect(permissionGrantWriteReply.status.code).to.equal(202);
+                    expect(permissionGrantWriteReply.status.code).toBe(202);
                     // Bob is unable to read the message without using the permission grant
                     const messagesReadWithoutGrant = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: aliceRecordMessageCid,
                     });
                     const messagesReadWithoutGrantReply = yield dwn.processMessage(alice.did, messagesReadWithoutGrant.message);
-                    expect(messagesReadWithoutGrantReply.status.code).to.equal(401);
-                    expect(messagesReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.MessagesReadAuthorizationFailed);
+                    expect(messagesReadWithoutGrantReply.status.code).toBe(401);
+                    expect(messagesReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
                     // Bob is able to read all the associated messages when using the permission grant
                     // Expected Messages:
                     // - Protocol Configuration
@@ -467,9 +467,9 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadProtocolConfigureReply = yield dwn.processMessage(alice.did, messagesReadProtocolConfigure.message);
-                    expect(messagesReadProtocolConfigureReply.status.code).to.equal(200);
-                    expect(messagesReadProtocolConfigureReply.entry).to.exist;
-                    expect(messagesReadProtocolConfigureReply.entry.message).to.deep.equal(protocolsConfig.message);
+                    expect(messagesReadProtocolConfigureReply.status.code).toBe(200);
+                    expect(messagesReadProtocolConfigureReply.entry).toBeDefined();
+                    expect(messagesReadProtocolConfigureReply.entry.message).toEqual(protocolsConfig.message);
                     // alice RecordsWrite
                     const messagesReadWithGrant = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -477,9 +477,9 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadWithGrantReply = yield dwn.processMessage(alice.did, messagesReadWithGrant.message);
-                    expect(messagesReadWithGrantReply.status.code).to.equal(200);
-                    expect(messagesReadWithGrantReply.entry).to.exist;
-                    expect(messagesReadWithGrantReply.entry.message).to.deep.equal(recordsWrite.message);
+                    expect(messagesReadWithGrantReply.status.code).toBe(200);
+                    expect(messagesReadWithGrantReply.entry).toBeDefined();
+                    expect(messagesReadWithGrantReply.entry.message).toEqual(recordsWrite.message);
                     // alice RecordsDelete
                     const messagesReadDelete = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -487,9 +487,9 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadDeleteReply = yield dwn.processMessage(alice.did, messagesReadDelete.message);
-                    expect(messagesReadDeleteReply.status.code).to.equal(200);
-                    expect(messagesReadDeleteReply.entry).to.exist;
-                    expect(messagesReadDeleteReply.entry.message).to.deep.equal(recordsDelete.message);
+                    expect(messagesReadDeleteReply.status.code).toBe(200);
+                    expect(messagesReadDeleteReply.entry).toBeDefined();
+                    expect(messagesReadDeleteReply.entry.message).toEqual(recordsDelete.message);
                     // carol's Permission Request
                     const messagesReadCarolRequest = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -497,9 +497,9 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadCarolRequestReply = yield dwn.processMessage(alice.did, messagesReadCarolRequest.message);
-                    expect(messagesReadCarolRequestReply.status.code).to.equal(200);
-                    expect(messagesReadCarolRequestReply.entry).to.exist;
-                    expect(messagesReadCarolRequestReply.entry.message).to.deep.equal(permissionRequestCarol.recordsWrite.message);
+                    expect(messagesReadCarolRequestReply.status.code).toBe(200);
+                    expect(messagesReadCarolRequestReply.entry).toBeDefined();
+                    expect(messagesReadCarolRequestReply.entry.message).toEqual(permissionRequestCarol.recordsWrite.message);
                     // carol's Permission Grant
                     const messagesReadCarolGrant = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -507,9 +507,9 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadCarolGrantReply = yield dwn.processMessage(alice.did, messagesReadCarolGrant.message);
-                    expect(messagesReadCarolGrantReply.status.code).to.equal(200);
-                    expect(messagesReadCarolGrantReply.entry).to.exist;
-                    expect(messagesReadCarolGrantReply.entry.message).to.deep.equal(permissionGrantCarol.recordsWrite.message);
+                    expect(messagesReadCarolGrantReply.status.code).toBe(200);
+                    expect(messagesReadCarolGrantReply.entry).toBeDefined();
+                    expect(messagesReadCarolGrantReply.entry.message).toEqual(permissionGrantCarol.recordsWrite.message);
                     // carol's RecordsWrite
                     const messagesReadCarolRecord = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -517,9 +517,9 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadCarolRecordReply = yield dwn.processMessage(alice.did, messagesReadCarolRecord.message);
-                    expect(messagesReadCarolRecordReply.status.code).to.equal(200);
-                    expect(messagesReadCarolRecordReply.entry).to.exist;
-                    expect(messagesReadCarolRecordReply.entry.message).to.deep.equal(recordsWriteCarol.message);
+                    expect(messagesReadCarolRecordReply.status.code).toBe(200);
+                    expect(messagesReadCarolRecordReply.entry).toBeDefined();
+                    expect(messagesReadCarolRecordReply.entry.message).toEqual(recordsWriteCarol.message);
                     // carol's Grant Revocation
                     const messagesReadCarolGrantRevocation = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -527,15 +527,15 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadCarolGrantRevocationReply = yield dwn.processMessage(alice.did, messagesReadCarolGrantRevocation.message);
-                    expect(messagesReadCarolGrantRevocationReply.status.code).to.equal(200);
-                    expect(messagesReadCarolGrantRevocationReply.entry).to.exist;
-                    expect(messagesReadCarolGrantRevocationReply.entry.message).to.deep.equal(permissionRevocationCarol.recordsWrite.message);
+                    expect(messagesReadCarolGrantRevocationReply.status.code).toBe(200);
+                    expect(messagesReadCarolGrantRevocationReply.entry).toBeDefined();
+                    expect(messagesReadCarolGrantRevocationReply.entry.message).toEqual(permissionRevocationCarol.recordsWrite.message);
                     // CONTROL: Alice writes a record not associated with the protocol
                     const { recordsWrite: recordsWriteControl, dataStream: dataStreamControl } = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
                     });
                     const recordsWriteControlReply = yield dwn.processMessage(alice.did, recordsWriteControl.message, { dataStream: dataStreamControl });
-                    expect(recordsWriteControlReply.status.code).to.equal(202);
+                    expect(recordsWriteControlReply.status.code).toBe(202);
                     // Bob is unable to read the control message
                     const messagesReadControl = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -543,7 +543,7 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadControlReply = yield dwn.processMessage(alice.did, messagesReadControl.message);
-                    expect(messagesReadControlReply.status.code).to.equal(401);
+                    expect(messagesReadControlReply.status.code).toBe(401);
                 }));
                 it('rejects message read of protocol messages with mismatching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice writes a protocol record. Alice gives Bob a grant to read messages from a different protocol
@@ -557,7 +557,7 @@ export function testMessagesReadHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a record which Bob will later try to read
                     const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -565,7 +565,7 @@ export function testMessagesReadHandler() {
                         protocolPath: 'foo',
                     });
                     const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                    expect(recordsWriteReply.status.code).to.equal(202);
+                    expect(recordsWriteReply.status.code).toBe(202);
                     // Alice gives Bob a permission grant with scope MessagesRead
                     const permissionGrant = yield PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
@@ -579,7 +579,7 @@ export function testMessagesReadHandler() {
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                     const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                    expect(permissionGrantWriteReply.status.code).to.equal(202);
+                    expect(permissionGrantWriteReply.status.code).toBe(202);
                     // Bob is unable to read the record using the mismatched permission grant
                     const messagesReadWithoutGrant = yield TestDataGenerator.generateMessagesRead({
                         author: bob,
@@ -587,8 +587,8 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadWithoutGrantReply = yield dwn.processMessage(alice.did, messagesReadWithoutGrant.message);
-                    expect(messagesReadWithoutGrantReply.status.code).to.equal(401);
-                    expect(messagesReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.MessagesReadVerifyScopeFailed);
+                    expect(messagesReadWithoutGrantReply.status.code).toBe(401);
+                    expect(messagesReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.MessagesReadVerifyScopeFailed);
                 }));
                 it('rejects message if the RecordsWrite message is not found for a RecordsDelete being retrieved', () => __awaiter(this, void 0, void 0, function* () {
                     // NOTE: This is a corner case that is unlikely to happen in practice, but is tested for completeness
@@ -601,7 +601,7 @@ export function testMessagesReadHandler() {
                         protocolDefinition,
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice gives bob a grant to read messages in the protocol
                     const permissionGrant = yield PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
@@ -615,7 +615,7 @@ export function testMessagesReadHandler() {
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                     const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                    expect(permissionGrantWriteReply.status.code).to.equal(202);
+                    expect(permissionGrantWriteReply.status.code).toBe(202);
                     // Alice creates the records write and records delete messages
                     const { recordsWrite } = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -637,8 +637,8 @@ export function testMessagesReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const messagesReadReply = yield dwn.processMessage(alice.did, messagesRead.message);
-                    expect(messagesReadReply.status.code).to.equal(401);
-                    expect(messagesReadReply.status.detail).to.contain(DwnErrorCode.RecordsWriteGetNewestWriteRecordNotFound);
+                    expect(messagesReadReply.status.code).toBe(401);
+                    expect(messagesReadReply.status.detail).toContain(DwnErrorCode.RecordsWriteGetNewestWriteRecordNotFound);
                 }));
             });
         });