@enbox/dwn-sdk-js 0.0.1 → 0.0.3

package/dist/esm/tests/scenarios/subscriptions.spec.js

@@ -7,15 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import freeForAll from '../vectors/protocol-definitions/free-for-all.json' assert { type: 'json' };
-import threadProtocol from '../vectors/protocol-definitions/thread-role.json' assert { type: 'json' };
+import freeForAll from '../vectors/protocol-definitions/free-for-all.json' with { type: 'json' };
+import threadProtocol from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { Poller } from '../utils/poller.js';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { DataStream, Dwn, DwnInterfaceName, DwnMethodName, Jws, Message, PermissionGrant, PermissionsProtocol, Time } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-import { expect } from 'chai';
 // NOTE: We use `Poller.pollUntilSuccessOrTimeout` to poll for the expected results.
 // In some cases, the EventStream is a coordinated pub/sub system and the message events are emitted over the network
 // this means that the messages are not processed immediately and we need to wait for the messages to be processed
@@ -29,29 +29,29 @@ export function testSubscriptionScenarios() {
         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
+        // important to follow the `beforeAll` and `afterAll` 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();
         }));
-        after(() => __awaiter(this, void 0, void 0, function* () {
+        afterAll(() => __awaiter(this, void 0, void 0, function* () {
             yield dwn.close();
         }));
         describe('messages subscribe', () => {
@@ -69,25 +69,25 @@ export function testSubscriptionScenarios() {
                 // subscribe to all messages
                 const messagesSubscription = yield TestDataGenerator.generateMessagesSubscribe({ author: alice });
                 const messagesSubscriptionReply = yield dwn.processMessage(alice.did, messagesSubscription.message, { subscriptionHandler: handler });
-                expect(messagesSubscriptionReply.status.code).to.equal(200);
-                expect((_a = messagesSubscriptionReply.subscription) === null || _a === void 0 ? void 0 : _a.id).to.equal(yield Message.getCid(messagesSubscription.message));
+                expect(messagesSubscriptionReply.status.code).toBe(200);
+                expect((_a = messagesSubscriptionReply.subscription) === null || _a === void 0 ? void 0 : _a.id).toBe(yield Message.getCid(messagesSubscription.message));
                 // generate various messages
                 const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const write1MessageCid = yield Message.getCid(write1.message);
                 const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
-                expect(write1Reply.status.code).to.equal(202);
+                expect(write1Reply.status.code).toBe(202);
                 const protocol1 = yield TestDataGenerator.generateProtocolsConfigure({ author: alice });
                 const protocol1MessageCid = yield Message.getCid(protocol1.message);
                 const protocol1Reply = yield dwn.processMessage(alice.did, protocol1.message);
-                expect(protocol1Reply.status.code).to.equal(202);
+                expect(protocol1Reply.status.code).toBe(202);
                 const deleteWrite1 = yield TestDataGenerator.generateRecordsDelete({ author: alice, recordId: write1.message.recordId });
                 const delete1MessageCid = yield Message.getCid(deleteWrite1.message);
                 const deleteWrite1Reply = yield dwn.processMessage(alice.did, deleteWrite1.message);
-                expect(deleteWrite1Reply.status.code).to.equal(202);
+                expect(deleteWrite1Reply.status.code).toBe(202);
                 // poll until the messages are received by the handler
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    expect(messageCids.length).to.equal(3);
-                    expect(messageCids).to.eql([write1MessageCid, protocol1MessageCid, delete1MessageCid]);
+                    expect(messageCids.length).toBe(3);
+                    expect(messageCids).toEqual([write1MessageCid, protocol1MessageCid, delete1MessageCid]);
                 }));
                 // clean up the subscription handler
                 yield ((_b = messagesSubscriptionReply.subscription) === null || _b === void 0 ? void 0 : _b.close());
@@ -113,8 +113,8 @@ export function testSubscriptionScenarios() {
                     recordsMessageCids.push(messageCid);
                 });
                 const recordsInterfaceSubscriptionReply = yield dwn.processMessage(alice.did, recordsInterfaceSubscription.message, { subscriptionHandler: recordsSubscribeHandler });
-                expect(recordsInterfaceSubscriptionReply.status.code).to.equal(200);
-                expect(recordsInterfaceSubscriptionReply.subscription).to.exist;
+                expect(recordsInterfaceSubscriptionReply.status.code).toBe(200);
+                expect(recordsInterfaceSubscriptionReply.subscription).toBeDefined();
                 // subscribe to the Protocols interface
                 const protocolsInterfaceSubscription = yield TestDataGenerator.generateMessagesSubscribe({
                     author: alice,
@@ -127,35 +127,35 @@ export function testSubscriptionScenarios() {
                     protocolsMessageCids.push(messageCid);
                 });
                 const protocolsInterfaceSubscriptionReply = yield dwn.processMessage(alice.did, protocolsInterfaceSubscription.message, { subscriptionHandler: protocolsSubscribeHandler });
-                expect(protocolsInterfaceSubscriptionReply.status.code).to.equal(200);
-                expect(protocolsInterfaceSubscriptionReply.subscription).to.exist;
+                expect(protocolsInterfaceSubscriptionReply.status.code).toBe(200);
+                expect(protocolsInterfaceSubscriptionReply.subscription).toBeDefined();
                 // create one of each message types a RecordsWrite and a ProtocolsConfigure
                 const record = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const recordReply = yield dwn.processMessage(alice.did, record.message, { dataStream: record.dataStream });
-                expect(recordReply.status.code).to.equal(202, 'RecordsWrite');
+                expect(recordReply.status.code).toBe(202, 'RecordsWrite');
                 const protocol = yield TestDataGenerator.generateProtocolsConfigure({ author: alice });
                 const protocolReply = yield dwn.processMessage(alice.did, protocol.message);
-                expect(protocolReply.status.code).to.equal(202, 'ProtocolConfigure');
+                expect(protocolReply.status.code).toBe(202, 'ProtocolConfigure');
                 // Poll until the messages are received by the handler
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // check record message
-                    expect(recordsMessageCids.length).to.equal(1);
-                    expect(recordsMessageCids).to.have.members([yield Message.getCid(record.message)]);
+                    expect(recordsMessageCids.length).toBe(1);
+                    expect(recordsMessageCids).toEqual(expect.arrayContaining([yield Message.getCid(record.message)]));
                     // check protocols message
-                    expect(protocolsMessageCids.length).to.equal(1);
-                    expect(protocolsMessageCids).to.have.members([yield Message.getCid(protocol.message)]);
+                    expect(protocolsMessageCids.length).toBe(1);
+                    expect(protocolsMessageCids).toEqual(expect.arrayContaining([yield Message.getCid(protocol.message)]));
                 }));
                 // delete the record
                 const recordDelete = yield TestDataGenerator.generateRecordsDelete({ author: alice, recordId: record.message.recordId });
                 const recordDeleteReply = yield dwn.processMessage(alice.did, recordDelete.message);
-                expect(recordDeleteReply.status.code).to.equal(202, 'RecordsDelete');
+                expect(recordDeleteReply.status.code).toBe(202, 'RecordsDelete');
                 // poll until the delete message is received by the handler
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // check record messages to include the delete message
-                    expect(recordsMessageCids.length).to.equal(2);
-                    expect(recordsMessageCids).to.include.members([yield Message.getCid(recordDelete.message)]);
+                    expect(recordsMessageCids.length).toBe(2);
+                    expect(recordsMessageCids).toEqual(expect.arrayContaining([yield Message.getCid(recordDelete.message)]));
                     // check that the protocols message array does not include the delete message
-                    expect(protocolsMessageCids.length).to.equal(1); // unchanged
+                    expect(protocolsMessageCids.length).toBe(1); // unchanged
                 }));
                 // clean up the subscriptions
                 yield ((_a = recordsInterfaceSubscriptionReply.subscription) === null || _a === void 0 ? void 0 : _a.close());
@@ -185,8 +185,8 @@ export function testSubscriptionScenarios() {
                     recordsWriteMessageCids.push(messageCid);
                 });
                 const recordsWriteSubscriptionReply = yield dwn.processMessage(alice.did, recordsWriteSubscription.message, { subscriptionHandler: recordsSubscribeHandler });
-                expect(recordsWriteSubscriptionReply.status.code).to.equal(200);
-                expect(recordsWriteSubscriptionReply.subscription).to.exist;
+                expect(recordsWriteSubscriptionReply.status.code).toBe(200);
+                expect(recordsWriteSubscriptionReply.subscription).toBeDefined();
                 // subscribe to records delete
                 const recordsDeleteSubscription = yield TestDataGenerator.generateMessagesSubscribe({
                     author: alice,
@@ -199,51 +199,51 @@ export function testSubscriptionScenarios() {
                     recordsDeleteMessageCids.push(messageCid);
                 });
                 const recordsDeleteSubscriptionReply = yield dwn.processMessage(alice.did, recordsDeleteSubscription.message, { subscriptionHandler: recordsDeleteSubscribeHandler });
-                expect(recordsDeleteSubscriptionReply.status.code).to.equal(200);
-                expect(recordsDeleteSubscriptionReply.subscription).to.exist;
+                expect(recordsDeleteSubscriptionReply.status.code).toBe(200);
+                expect(recordsDeleteSubscriptionReply.subscription).toBeDefined();
                 // create and updates the record, this creates two RecordsWrite messages
                 const record = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const recordReply = yield dwn.processMessage(alice.did, record.message, { dataStream: record.dataStream });
-                expect(recordReply.status.code).to.equal(202, 'RecordsWrite');
+                expect(recordReply.status.code).toBe(202, 'RecordsWrite');
                 const record1MessageCid = yield Message.getCid(record.message);
                 const recordUpdate = yield TestDataGenerator.generateFromRecordsWrite({ author: alice, existingWrite: record.recordsWrite });
                 const recordUpdateReply = yield dwn.processMessage(alice.did, recordUpdate.message, { dataStream: recordUpdate.dataStream });
-                expect(recordUpdateReply.status.code).to.equal(202, 'RecordsUpdate');
+                expect(recordUpdateReply.status.code).toBe(202, 'RecordsUpdate');
                 const recordUpdateMessageCid = yield Message.getCid(recordUpdate.message);
                 // Poll until the messages are received by the handler
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // check the array for both the RecordsWrite messages
-                    expect(recordsWriteMessageCids.length).to.equal(2);
-                    expect(recordsWriteMessageCids).to.have.members([
+                    expect(recordsWriteMessageCids.length).toBe(2);
+                    expect(recordsWriteMessageCids).toEqual(expect.arrayContaining([
                         record1MessageCid,
                         recordUpdateMessageCid,
-                    ]);
+                    ]));
                 }));
                 // confirm that the delete array is empty
-                expect(recordsDeleteMessageCids.length).to.equal(0);
+                expect(recordsDeleteMessageCids.length).toBe(0);
                 // delete the record
                 const recordDelete = yield TestDataGenerator.generateRecordsDelete({ author: alice, recordId: record.message.recordId });
                 const recordDeleteReply = yield dwn.processMessage(alice.did, recordDelete.message);
-                expect(recordDeleteReply.status.code).to.equal(202, 'RecordsDelete');
+                expect(recordDeleteReply.status.code).toBe(202, 'RecordsDelete');
                 const recordDeleteMessageCid = yield Message.getCid(recordDelete.message);
                 // write a second record
                 const record2 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const record2Reply = yield dwn.processMessage(alice.did, record2.message, { dataStream: record2.dataStream });
-                expect(record2Reply.status.code).to.equal(202, 'RecordsWrite');
+                expect(record2Reply.status.code).toBe(202, 'RecordsWrite');
                 const record2MessageCid = yield Message.getCid(record2.message);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // ensure the new record is in the recordsWrite array, but not the delete
-                    expect(recordsWriteMessageCids.length).to.equal(3);
-                    expect(recordsWriteMessageCids).to.include.members([
+                    expect(recordsWriteMessageCids.length).toBe(3);
+                    expect(recordsWriteMessageCids).toEqual(expect.arrayContaining([
                         record1MessageCid,
                         recordUpdateMessageCid,
                         record2MessageCid,
-                    ]);
+                    ]));
                     // ensure the delete message is in the recordsDelete array
-                    expect(recordsDeleteMessageCids.length).to.equal(1);
-                    expect(recordsDeleteMessageCids).to.include.members([
+                    expect(recordsDeleteMessageCids.length).toBe(1);
+                    expect(recordsDeleteMessageCids).toEqual(expect.arrayContaining([
                         recordDeleteMessageCid,
-                    ]);
+                    ]));
                 }));
             }));
             it('filters by a protocol across different message types', () => __awaiter(this, void 0, void 0, function* () {
@@ -274,8 +274,8 @@ export function testSubscriptionScenarios() {
                 const proto1SubscriptionReply = yield dwn.processMessage(alice.did, proto1Subscription.message, {
                     subscriptionHandler: proto1Handler
                 });
-                expect(proto1SubscriptionReply.status.code).to.equal(200);
-                expect(proto1SubscriptionReply.subscription).to.exist;
+                expect(proto1SubscriptionReply.status.code).toBe(200);
+                expect(proto1SubscriptionReply.subscription).toBeDefined();
                 const proto2Messages = [];
                 const proto2Handler = (event) => __awaiter(this, void 0, void 0, function* () {
                     const { message } = event;
@@ -288,8 +288,8 @@ export function testSubscriptionScenarios() {
                 const proto2SubscriptionReply = yield dwn.processMessage(alice.did, proto2Subscription.message, {
                     subscriptionHandler: proto2Handler
                 });
-                expect(proto2SubscriptionReply.status.code).to.equal(200);
-                expect(proto2SubscriptionReply.subscription).to.exist;
+                expect(proto2SubscriptionReply.status.code).toBe(200);
+                expect(proto2SubscriptionReply.subscription).toBeDefined();
                 // configure proto1
                 const protoConf1 = yield TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
@@ -297,7 +297,7 @@ export function testSubscriptionScenarios() {
                 });
                 const proto1 = protoConf1.message.descriptor.definition.protocol;
                 const protoConf1Response = yield dwn.processMessage(alice.did, protoConf1.message);
-                expect(protoConf1Response.status.code).equals(202);
+                expect(protoConf1Response.status.code).toBe(202);
                 // configure proto2
                 const protoConf2 = yield TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
@@ -305,7 +305,7 @@ export function testSubscriptionScenarios() {
                 });
                 const proto2 = protoConf2.message.descriptor.definition.protocol;
                 const protoConf2Response = yield dwn.processMessage(alice.did, protoConf2.message);
-                expect(protoConf2Response.status.code).equals(202);
+                expect(protoConf2Response.status.code).toBe(202);
                 const postProperties = {
                     protocolPath: 'post',
                     schema: freeForAll.types.post.schema,
@@ -314,11 +314,11 @@ export function testSubscriptionScenarios() {
                 // create a record for proto1
                 const write1proto1 = yield TestDataGenerator.generateRecordsWrite(Object.assign({ author: alice, protocol: proto1 }, postProperties));
                 const write1Response = yield dwn.processMessage(alice.did, write1proto1.message, { dataStream: write1proto1.dataStream });
-                expect(write1Response.status.code).equals(202);
+                expect(write1Response.status.code).toBe(202);
                 // create a record for proto2
                 const write1proto2 = yield TestDataGenerator.generateRecordsWrite(Object.assign({ author: alice, protocol: proto2 }, postProperties));
                 const write1Proto2Response = yield dwn.processMessage(alice.did, write1proto2.message, { dataStream: write1proto2.dataStream });
-                expect(write1Proto2Response.status.code).equals(202);
+                expect(write1Proto2Response.status.code).toBe(202);
                 // bob requests permissions for proto1
                 const requestProto1 = yield PermissionsProtocol.createRequest({
                     signer: Jws.createSigner(bob),
@@ -326,7 +326,7 @@ export function testSubscriptionScenarios() {
                     delegated: false,
                 });
                 const requestProto1Response = yield dwn.processMessage(alice.did, requestProto1.recordsWrite.message, { dataStream: DataStream.fromBytes(requestProto1.permissionRequestBytes) });
-                expect(requestProto1Response.status.code).equals(202);
+                expect(requestProto1Response.status.code).toBe(202);
                 // bob requests permissions for proto2
                 const requestProto2 = yield PermissionsProtocol.createRequest({
                     signer: Jws.createSigner(bob),
@@ -334,7 +334,7 @@ export function testSubscriptionScenarios() {
                     delegated: false,
                 });
                 const requestProto2Response = yield dwn.processMessage(alice.did, requestProto2.recordsWrite.message, { dataStream: DataStream.fromBytes(requestProto2.permissionRequestBytes) });
-                expect(requestProto2Response.status.code).equals(202);
+                expect(requestProto2Response.status.code).toBe(202);
                 // alice grants permissions for proto1
                 const grantProto1 = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -343,7 +343,7 @@ export function testSubscriptionScenarios() {
                     grantedTo: bob.did,
                 });
                 const grantProto1Response = yield dwn.processMessage(alice.did, grantProto1.recordsWrite.message, { dataStream: DataStream.fromBytes(grantProto1.permissionGrantBytes) });
-                expect(grantProto1Response.status.code).equals(202);
+                expect(grantProto1Response.status.code).toBe(202);
                 // alice grants permissions for proto2
                 const grantProto2 = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -352,62 +352,62 @@ export function testSubscriptionScenarios() {
                     grantedTo: bob.did,
                 });
                 const grantProto2Response = yield dwn.processMessage(alice.did, grantProto2.recordsWrite.message, { dataStream: DataStream.fromBytes(grantProto2.permissionGrantBytes) });
-                expect(grantProto2Response.status.code).equals(202);
+                expect(grantProto2Response.status.code).toBe(202);
                 // poll until the messages are received by the handlers
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // check for proto1 messages
-                    expect(proto1Messages.length).to.equal(4);
-                    expect(proto1Messages).to.have.members([
+                    expect(proto1Messages.length).toBe(4);
+                    expect(proto1Messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(protoConf1.message),
                         yield Message.getCid(write1proto1.message),
                         yield Message.getCid(requestProto1.recordsWrite.message),
                         yield Message.getCid(grantProto1.recordsWrite.message),
-                    ]);
+                    ]));
                     // check for proto2 messages
-                    expect(proto2Messages.length).to.equal(4);
-                    expect(proto2Messages).to.have.members([
+                    expect(proto2Messages.length).toBe(4);
+                    expect(proto2Messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(protoConf2.message),
                         yield Message.getCid(write1proto2.message),
                         yield Message.getCid(requestProto2.recordsWrite.message),
                         yield Message.getCid(grantProto2.recordsWrite.message),
-                    ]);
+                    ]));
                 }));
                 // delete proto1 message
                 const deleteProto1Message = yield TestDataGenerator.generateRecordsDelete({ author: alice, recordId: write1proto1.message.recordId });
                 const deleteProto1MessageReply = yield dwn.processMessage(alice.did, deleteProto1Message.message);
-                expect(deleteProto1MessageReply.status.code).to.equal(202);
+                expect(deleteProto1MessageReply.status.code).toBe(202);
                 // delete proto2 message
                 const deleteProto2Message = yield TestDataGenerator.generateRecordsDelete({ author: alice, recordId: write1proto2.message.recordId });
                 const deleteProto2MessageReply = yield dwn.processMessage(alice.did, deleteProto2Message.message);
-                expect(deleteProto2MessageReply.status.code).to.equal(202);
+                expect(deleteProto2MessageReply.status.code).toBe(202);
                 // revoke permissions for proto1
                 const revokeProto1 = yield PermissionsProtocol.createRevocation({
                     signer: Jws.createSigner(alice),
                     grant: yield PermissionGrant.parse(grantProto1.dataEncodedMessage),
                 });
                 const revokeProto1Response = yield dwn.processMessage(alice.did, revokeProto1.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeProto1.permissionRevocationBytes) });
-                expect(revokeProto1Response.status.code).equals(202);
+                expect(revokeProto1Response.status.code).toBe(202);
                 // revoke permissions for proto2
                 const revokeProto2 = yield PermissionsProtocol.createRevocation({
                     signer: Jws.createSigner(alice),
                     grant: yield PermissionGrant.parse(grantProto2.dataEncodedMessage),
                 });
                 const revokeProto2Response = yield dwn.processMessage(alice.did, revokeProto2.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeProto2.permissionRevocationBytes) });
-                expect(revokeProto2Response.status.code).equals(202);
+                expect(revokeProto2Response.status.code).toBe(202);
                 // poll until the messages are received by the handlers
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // check for the delete and revocation in proto1 messages
-                    expect(proto1Messages.length).to.equal(6); // 2 additional messages
-                    expect(proto1Messages).to.include.members([
+                    expect(proto1Messages.length).toBe(6); // 2 additional messages
+                    expect(proto1Messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(deleteProto1Message.message),
                         yield Message.getCid(revokeProto1.recordsWrite.message),
-                    ]);
+                    ]));
                     // check for the delete and revocation in proto2 messages
-                    expect(proto2Messages.length).to.equal(6); // 2 additional messages
-                    expect(proto2Messages).to.include.members([
+                    expect(proto2Messages.length).toBe(6); // 2 additional messages
+                    expect(proto2Messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(deleteProto2Message.message),
                         yield Message.getCid(revokeProto2.recordsWrite.message),
-                    ]);
+                    ]));
                 }));
             }));
             it('does not emit events after subscription is closed', () => __awaiter(this, void 0, void 0, function* () {
@@ -433,45 +433,45 @@ export function testSubscriptionScenarios() {
                 // subscribe to all messages
                 const messagesSubscription1 = yield TestDataGenerator.generateMessagesSubscribe({ author: alice });
                 const messagesSubscription1Reply = yield dwn.processMessage(alice.did, messagesSubscription1.message, { subscriptionHandler: handler1 });
-                expect(messagesSubscription1Reply.status.code).to.equal(200);
+                expect(messagesSubscription1Reply.status.code).toBe(200);
                 const messagesSubscription2 = yield TestDataGenerator.generateMessagesSubscribe({ author: alice });
                 const messagesSubscription2Reply = yield dwn.processMessage(alice.did, messagesSubscription2.message, { subscriptionHandler: handler2 });
-                expect(messagesSubscription2Reply.status.code).to.equal(200);
+                expect(messagesSubscription2Reply.status.code).toBe(200);
                 // no event message exist yet
-                expect(sub1MessageCids.length).to.equal(0);
-                expect(sub2MessageCids.length).to.equal(0);
+                expect(sub1MessageCids.length).toBe(0);
+                expect(sub2MessageCids.length).toBe(0);
                 // write a record
                 const record1 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const record1Reply = yield dwn.processMessage(alice.did, record1.message, { dataStream: record1.dataStream });
-                expect(record1Reply.status.code).to.equal(202);
+                expect(record1Reply.status.code).toBe(202);
                 const record1MessageCid = yield Message.getCid(record1.message);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // both subscriptions should have received the message
-                    expect(sub1MessageCids.length).to.equal(1); // message exists
-                    expect(sub1MessageCids).to.eql([record1MessageCid]);
-                    expect(sub2MessageCids.length).to.equal(1); // message exists
-                    expect(sub2MessageCids).to.eql([record1MessageCid]);
+                    expect(sub1MessageCids.length).toBe(1); // message exists
+                    expect(sub1MessageCids).toEqual([record1MessageCid]);
+                    expect(sub2MessageCids.length).toBe(1); // message exists
+                    expect(sub2MessageCids).toEqual([record1MessageCid]);
                 }));
                 // unsubscribe from subscription 2
                 yield messagesSubscription2Reply.subscription.close();
                 // write two more message.
                 const record2 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const record2Reply = yield dwn.processMessage(alice.did, record2.message, { dataStream: record2.dataStream });
-                expect(record2Reply.status.code).to.equal(202);
+                expect(record2Reply.status.code).toBe(202);
                 const record2MessageCid = yield Message.getCid(record2.message);
                 const record3 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const record3Reply = yield dwn.processMessage(alice.did, record3.message, { dataStream: record3.dataStream });
-                expect(record3Reply.status.code).to.equal(202);
+                expect(record3Reply.status.code).toBe(202);
                 const record3MessageCid = yield Message.getCid(record3.message);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    expect(sub1MessageCids.length).to.equal(3); // all three messages exist
-                    expect(sub1MessageCids).to.eql([
+                    expect(sub1MessageCids.length).toBe(3); // all three messages exist
+                    expect(sub1MessageCids).toEqual([
                         record1MessageCid,
                         record2MessageCid,
                         record3MessageCid
                     ]);
-                    expect(sub2MessageCids.length).to.equal(1); // only the first message exists
-                    expect(sub2MessageCids).to.eql([record1MessageCid]);
+                    expect(sub2MessageCids.length).toBe(1); // only the first message exists
+                    expect(sub2MessageCids).toEqual([record1MessageCid]);
                 }));
             }));
         });
@@ -494,7 +494,7 @@ export function testSubscriptionScenarios() {
                     author: alice,
                 });
                 const allSubscriptionReply = yield dwn.processMessage(alice.did, allSubscription.message, { subscriptionHandler: allHandler });
-                expect(allSubscriptionReply.status.code).to.equal(200);
+                expect(allSubscriptionReply.status.code).toBe(200);
                 // we create an anonymous subscription to capture only published messages
                 const publishedMessages = [];
                 const anonymousSubscriptionHandler = (event) => __awaiter(this, void 0, void 0, function* () {
@@ -508,34 +508,34 @@ export function testSubscriptionScenarios() {
                 const anonymousSubscriptionReply = yield dwn.processMessage(alice.did, anonymousSubscription.message, {
                     subscriptionHandler: anonymousSubscriptionHandler
                 });
-                expect(anonymousSubscriptionReply.status.code).to.equal(200);
-                expect(anonymousSubscriptionReply.subscription).to.exist;
+                expect(anonymousSubscriptionReply.status.code).toBe(200);
+                expect(anonymousSubscriptionReply.subscription).toBeDefined();
                 // we create a non published record, this will only show up in the control subscription
                 const writeNotPublished = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://schema1' });
                 const writeNotPublishedReply = yield dwn.processMessage(alice.did, writeNotPublished.message, { dataStream: writeNotPublished.dataStream });
-                expect(writeNotPublishedReply.status.code).to.equal(202);
+                expect(writeNotPublishedReply.status.code).toBe(202);
                 // we create a published record, this will show up in both the control and anonymous subscription
                 const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://schema1', published: true });
                 const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
-                expect(write1Reply.status.code).to.equal(202);
+                expect(write1Reply.status.code).toBe(202);
                 // we create another published record, this will show up in both the control and anonymous subscription
                 const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://schema1', published: true });
                 const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
-                expect(write2Reply.status.code).to.equal(202);
+                expect(write2Reply.status.code).toBe(202);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // publishedMessages array should only contain the two published messages
-                    expect(publishedMessages.length).to.equal(2);
-                    expect(publishedMessages).to.have.members([
+                    expect(publishedMessages.length).toBe(2);
+                    expect(publishedMessages).toEqual(expect.arrayContaining([
                         yield Message.getCid(write1.message),
                         yield Message.getCid(write2.message),
-                    ]);
+                    ]));
                     // allMessages array should contain all three messages
-                    expect(allMessages.length).to.equal(3);
-                    expect(allMessages).to.have.members([
+                    expect(allMessages.length).toBe(3);
+                    expect(allMessages).toEqual(expect.arrayContaining([
                         yield Message.getCid(writeNotPublished.message),
                         yield Message.getCid(write1.message),
                         yield Message.getCid(write2.message),
-                    ]);
+                    ]));
                 }));
             }));
             it('allows authorized subscriptions to records intended for a recipient', () => __awaiter(this, void 0, void 0, function* () {
@@ -546,7 +546,7 @@ export function testSubscriptionScenarios() {
                     protocolDefinition: Object.assign({}, freeForAll)
                 });
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
                 const carol = yield TestDataGenerator.generateDidKeyPersona();
                 // bob subscribes to all records he's authorized to see, with alice as the recipient
@@ -562,8 +562,8 @@ export function testSubscriptionScenarios() {
                 const bobSubscribeReply = yield dwn.processMessage(alice.did, bobSubscribeToAlice.message, {
                     subscriptionHandler: bobSubscribeHandler
                 });
-                expect(bobSubscribeReply.status.code).to.equal(200);
-                expect(bobSubscribeReply.subscription).to.exist;
+                expect(bobSubscribeReply.status.code).toBe(200);
+                expect(bobSubscribeReply.subscription).toBeDefined();
                 // carol subscribes to any messages that she or alice are the recipients of
                 const carolSubscribeCarolAndAlice = [];
                 const carolSubscribeHandler = (event) => __awaiter(this, void 0, void 0, function* () {
@@ -577,8 +577,8 @@ export function testSubscriptionScenarios() {
                 const carolSubscribeReply = yield dwn.processMessage(alice.did, carolSubscribeToCarolAndAlice.message, {
                     subscriptionHandler: carolSubscribeHandler
                 });
-                expect(carolSubscribeReply.status.code).to.equal(200);
-                expect(carolSubscribeReply.subscription).to.exist;
+                expect(carolSubscribeReply.status.code).toBe(200);
+                expect(carolSubscribeReply.subscription).toBeDefined();
                 const recordParams = {
                     protocol: freeForAll.protocol,
                     protocolPath: 'post',
@@ -588,42 +588,42 @@ export function testSubscriptionScenarios() {
                 // write a private and public message for alice from bob
                 const publicBobToAlice = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: bob, recipient: alice.did, published: true }));
                 const publicBobToAliceReply = yield dwn.processMessage(alice.did, publicBobToAlice.message, { dataStream: publicBobToAlice.dataStream });
-                expect(publicBobToAliceReply.status.code).to.equal(202);
+                expect(publicBobToAliceReply.status.code).toBe(202);
                 const privateBobToAlice = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: bob, recipient: alice.did, published: false }));
                 const privateBobToAliceReply = yield dwn.processMessage(alice.did, privateBobToAlice.message, { dataStream: privateBobToAlice.dataStream });
-                expect(privateBobToAliceReply.status.code).to.equal(202);
+                expect(privateBobToAliceReply.status.code).toBe(202);
                 // write a private message for alice from carol
                 const privateCarolToAlice = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: carol, recipient: alice.did, published: false }));
                 const privateCarolToAliceReply = yield dwn.processMessage(alice.did, privateCarolToAlice.message, {
                     dataStream: privateCarolToAlice.dataStream
                 });
-                expect(privateCarolToAliceReply.status.code).to.equal(202);
+                expect(privateCarolToAliceReply.status.code).toBe(202);
                 // write a public and private message from bob to carol
                 const publicBobToCarol = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: bob, recipient: carol.did, published: true }));
                 const publicBobToCarolReply = yield dwn.processMessage(alice.did, publicBobToCarol.message, {
                     dataStream: publicBobToCarol.dataStream
                 });
-                expect(publicBobToCarolReply.status.code).to.equal(202);
+                expect(publicBobToCarolReply.status.code).toBe(202);
                 const privateBobToCarol = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: bob, recipient: carol.did, published: false }));
                 const privateBobToCarolReply = yield dwn.processMessage(alice.did, privateBobToCarol.message, {
                     dataStream: privateBobToCarol.dataStream
                 });
-                expect(privateBobToCarolReply.status.code).to.equal(202);
+                expect(privateBobToCarolReply.status.code).toBe(202);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // carol should have received the message intended for her
-                    expect(carolSubscribeCarolAndAlice.length).to.equal(4);
-                    expect(carolSubscribeCarolAndAlice).to.have.members([
+                    expect(carolSubscribeCarolAndAlice.length).toBe(4);
+                    expect(carolSubscribeCarolAndAlice).toEqual(expect.arrayContaining([
                         yield Message.getCid(publicBobToAlice.message),
                         yield Message.getCid(privateCarolToAlice.message),
                         yield Message.getCid(publicBobToCarol.message),
                         yield Message.getCid(privateBobToCarol.message),
-                    ]);
+                    ]));
                     // bob should have received the two messages intended for him
-                    expect(bobSubscribeAlice.length).to.equal(2);
-                    expect(bobSubscribeAlice).to.have.members([
+                    expect(bobSubscribeAlice.length).toBe(2);
+                    expect(bobSubscribeAlice).toEqual(expect.arrayContaining([
                         yield Message.getCid(privateBobToAlice.message),
                         yield Message.getCid(publicBobToAlice.message),
-                    ]);
+                    ]));
                 }));
             }));
             it('allows for authorized subscriptions to records authored by an author(s)', () => __awaiter(this, void 0, void 0, function* () {
@@ -634,7 +634,7 @@ export function testSubscriptionScenarios() {
                     protocolDefinition: Object.assign({}, freeForAll)
                 });
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
                 const carol = yield TestDataGenerator.generateDidKeyPersona();
                 // bob subscribes to all records he's authorized to see, with alice as the author
@@ -650,8 +650,8 @@ export function testSubscriptionScenarios() {
                 const bobSubscribeReply = yield dwn.processMessage(alice.did, bobSubscribeToAlice.message, {
                     subscriptionHandler: bobSubscribeHandler
                 });
-                expect(bobSubscribeReply.status.code).to.equal(200);
-                expect(bobSubscribeReply.subscription).to.exist;
+                expect(bobSubscribeReply.status.code).toBe(200);
+                expect(bobSubscribeReply.subscription).toBeDefined();
                 // carol subscribes to any messages that she or alice are the authors of
                 const carolSubscribeCarolAndAlice = [];
                 const carolSubscribeHandler = (event) => __awaiter(this, void 0, void 0, function* () {
@@ -665,8 +665,8 @@ export function testSubscriptionScenarios() {
                 const carolSubscribeReply = yield dwn.processMessage(alice.did, carolSubscribeToCarolAndAlice.message, {
                     subscriptionHandler: carolSubscribeHandler
                 });
-                expect(carolSubscribeReply.status.code).to.equal(200);
-                expect(carolSubscribeReply.subscription).to.exist;
+                expect(carolSubscribeReply.status.code).toBe(200);
+                expect(carolSubscribeReply.subscription).toBeDefined();
                 const recordParams = {
                     protocol: freeForAll.protocol,
                     protocolPath: 'post',
@@ -678,50 +678,50 @@ export function testSubscriptionScenarios() {
                 const publicAliceToBobReply = yield dwn.processMessage(alice.did, publicAliceToBob.message, {
                     dataStream: publicAliceToBob.dataStream
                 });
-                expect(publicAliceToBobReply.status.code).to.equal(202);
+                expect(publicAliceToBobReply.status.code).toBe(202);
                 // write a private and public message from alice to carol
                 const publicAliceToCarol = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: alice, recipient: carol.did, published: true }));
                 const publicAliceToCarolReply = yield dwn.processMessage(alice.did, publicAliceToCarol.message, {
                     dataStream: publicAliceToCarol.dataStream
                 });
-                expect(publicAliceToCarolReply.status.code).to.equal(202);
+                expect(publicAliceToCarolReply.status.code).toBe(202);
                 const privateAliceToCarol = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: alice, recipient: carol.did, published: false }));
                 const privateAliceToCarolReply = yield dwn.processMessage(alice.did, privateAliceToCarol.message, {
                     dataStream: privateAliceToCarol.dataStream
                 });
-                expect(privateAliceToCarolReply.status.code).to.equal(202);
+                expect(privateAliceToCarolReply.status.code).toBe(202);
                 // write a private message for alice from carol
                 const privateCarolToAlice = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: carol, recipient: alice.did, published: false }));
                 const privateCarolToAliceReply = yield dwn.processMessage(alice.did, privateCarolToAlice.message, {
                     dataStream: privateCarolToAlice.dataStream
                 });
-                expect(privateCarolToAliceReply.status.code).to.equal(202);
+                expect(privateCarolToAliceReply.status.code).toBe(202);
                 // write a public and private message from bob to carol
                 const publicBobToCarol = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: bob, recipient: carol.did, published: true }));
                 const publicBobToCarolReply = yield dwn.processMessage(alice.did, publicBobToCarol.message, {
                     dataStream: publicBobToCarol.dataStream
                 });
-                expect(publicBobToCarolReply.status.code).to.equal(202);
+                expect(publicBobToCarolReply.status.code).toBe(202);
                 const privateBobToCarol = yield TestDataGenerator.generateRecordsWrite(Object.assign(Object.assign({}, recordParams), { author: bob, recipient: carol.did, published: false }));
                 const privateBobToCarolReply = yield dwn.processMessage(alice.did, privateBobToCarol.message, {
                     dataStream: privateBobToCarol.dataStream
                 });
-                expect(privateBobToCarolReply.status.code).to.equal(202);
+                expect(privateBobToCarolReply.status.code).toBe(202);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     // carol should have received the message intended for her
-                    expect(carolSubscribeCarolAndAlice.length).to.equal(4);
-                    expect(carolSubscribeCarolAndAlice).to.have.members([
+                    expect(carolSubscribeCarolAndAlice.length).toBe(4);
+                    expect(carolSubscribeCarolAndAlice).toEqual(expect.arrayContaining([
                         yield Message.getCid(publicAliceToCarol.message),
                         yield Message.getCid(privateAliceToCarol.message),
                         yield Message.getCid(publicAliceToBob.message),
                         yield Message.getCid(privateCarolToAlice.message),
-                    ]);
+                    ]));
                     // bob should have received the two messages intended for him
-                    expect(bobSubscribeAlice.length).to.equal(2);
-                    expect(bobSubscribeAlice).to.have.members([
+                    expect(bobSubscribeAlice.length).toBe(2);
+                    expect(bobSubscribeAlice).toEqual(expect.arrayContaining([
                         yield Message.getCid(publicAliceToBob.message),
                         yield Message.getCid(publicAliceToCarol.message)
-                    ]);
+                    ]));
                 }));
             }));
             it('filters by protocol & contextId across multiple protocolPaths', () => __awaiter(this, void 0, void 0, function* () {
@@ -741,7 +741,7 @@ export function testSubscriptionScenarios() {
                     protocolDefinition: Object.assign({}, threadProtocol)
                 });
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 const protocol = protocolConfigure.message.descriptor.definition.protocol;
                 // alice creates thread
                 const thread = yield TestDataGenerator.generateRecordsWrite({
@@ -750,7 +750,7 @@ export function testSubscriptionScenarios() {
                     protocolPath: 'thread'
                 });
                 const threadReply = yield dwn.processMessage(alice.did, thread.message, { dataStream: thread.dataStream });
-                expect(threadReply.status.code).to.equal(202);
+                expect(threadReply.status.code).toBe(202);
                 // subscribe to this thread's messages
                 const messages = [];
                 const initialWrites = [];
@@ -768,8 +768,8 @@ export function testSubscriptionScenarios() {
                 const threadSubscriptionReply = yield dwn.processMessage(alice.did, threadSubscription.message, {
                     subscriptionHandler
                 });
-                expect(threadSubscriptionReply.status.code).to.equal(200);
-                expect(threadSubscriptionReply.subscription).to.exist;
+                expect(threadSubscriptionReply.status.code).toBe(200);
+                expect(threadSubscriptionReply.subscription).toBeDefined();
                 const participantSubscription = yield TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { protocol: protocol, protocolPath: 'thread/participant', contextId: thread.message.contextId }, // participant updates
@@ -777,8 +777,8 @@ export function testSubscriptionScenarios() {
                 const participantSubscriptionReply = yield dwn.processMessage(alice.did, participantSubscription.message, {
                     subscriptionHandler
                 });
-                expect(participantSubscriptionReply.status.code).to.equal(200);
-                expect(participantSubscriptionReply.subscription).to.exist;
+                expect(participantSubscriptionReply.status.code).toBe(200);
+                expect(participantSubscriptionReply.subscription).toBeDefined();
                 const chatSubscription = yield TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { protocol: protocol, protocolPath: 'thread/chat', contextId: thread.message.contextId } // chat updates
@@ -786,8 +786,8 @@ export function testSubscriptionScenarios() {
                 const chatSubscriptionReply = yield dwn.processMessage(alice.did, chatSubscription.message, {
                     subscriptionHandler
                 });
-                expect(chatSubscriptionReply.status.code).to.equal(200);
-                expect(chatSubscriptionReply.subscription).to.exist;
+                expect(chatSubscriptionReply.status.code).toBe(200);
+                expect(chatSubscriptionReply.subscription).toBeDefined();
                 // add bob as participant
                 const bobParticipant = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -797,7 +797,7 @@ export function testSubscriptionScenarios() {
                     protocolPath: 'thread/participant'
                 });
                 const bobParticipantReply = yield dwn.processMessage(alice.did, bobParticipant.message, { dataStream: bobParticipant.dataStream });
-                expect(bobParticipantReply.status.code).to.equal(202);
+                expect(bobParticipantReply.status.code).toBe(202);
                 // add carol as participant
                 const carolParticipant = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -807,7 +807,7 @@ export function testSubscriptionScenarios() {
                     protocolPath: 'thread/participant'
                 });
                 const carolParticipantReply = yield dwn.processMessage(alice.did, carolParticipant.message, { dataStream: carolParticipant.dataStream });
-                expect(carolParticipantReply.status.code).to.equal(202);
+                expect(carolParticipantReply.status.code).toBe(202);
                 // add another thread as a control, will not show up in handled message events
                 const additionalThread = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -815,13 +815,13 @@ export function testSubscriptionScenarios() {
                     protocolPath: 'thread'
                 });
                 const additionalThreadReply = yield dwn.processMessage(alice.did, additionalThread.message, { dataStream: additionalThread.dataStream });
-                expect(additionalThreadReply.status.code).to.equal(202);
+                expect(additionalThreadReply.status.code).toBe(202);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    expect(messages.length).to.equal(2);
-                    expect(messages).to.have.members([
+                    expect(messages.length).toBe(2);
+                    expect(messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(bobParticipant.message),
                         yield Message.getCid(carolParticipant.message),
-                    ]);
+                    ]));
                 }));
                 // add a message to protocol1
                 const message1 = yield TestDataGenerator.generateRecordsWrite({
@@ -833,7 +833,7 @@ export function testSubscriptionScenarios() {
                     protocolRole: 'thread/participant',
                 });
                 const message1Reply = yield dwn.processMessage(alice.did, message1.message, { dataStream: message1.dataStream });
-                expect(message1Reply.status.code).to.equal(202);
+                expect(message1Reply.status.code).toBe(202);
                 const message2 = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: alice.did,
@@ -843,7 +843,7 @@ export function testSubscriptionScenarios() {
                     protocolRole: 'thread/participant',
                 });
                 const message2Reply = yield dwn.processMessage(alice.did, message2.message, { dataStream: message2.dataStream });
-                expect(message2Reply.status.code).to.equal(202);
+                expect(message2Reply.status.code).toBe(202);
                 const message3 = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: alice.did,
@@ -853,14 +853,14 @@ export function testSubscriptionScenarios() {
                     protocolRole: 'thread/participant',
                 });
                 const message3Reply = yield dwn.processMessage(alice.did, message3.message, { dataStream: message3.dataStream });
-                expect(message3Reply.status.code).to.equal(202);
+                expect(message3Reply.status.code).toBe(202);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    expect(messages.length).to.equal(5);
-                    expect(messages).to.include.members([
+                    expect(messages.length).toBe(5);
+                    expect(messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(message1.message),
                         yield Message.getCid(message2.message),
                         yield Message.getCid(message3.message),
-                    ]);
+                    ]));
                 }));
                 // delete carol participant
                 const deleteCarol = yield TestDataGenerator.generateRecordsDelete({
@@ -868,16 +868,16 @@ export function testSubscriptionScenarios() {
                     recordId: carolParticipant.message.recordId
                 });
                 const deleteCarolReply = yield dwn.processMessage(alice.did, deleteCarol.message);
-                expect(deleteCarolReply.status.code).to.equal(202);
+                expect(deleteCarolReply.status.code).toBe(202);
                 yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    expect(messages.length).to.equal(6);
-                    expect(messages).to.include.members([
+                    expect(messages.length).toBe(6);
+                    expect(messages).toEqual(expect.arrayContaining([
                         yield Message.getCid(deleteCarol.message)
-                    ]);
+                    ]));
                     // check the initial write was included with the delete
-                    expect(initialWrites).to.include.members([
+                    expect(initialWrites).toEqual(expect.arrayContaining([
                         yield Message.getCid(carolParticipant.message)
-                    ]);
+                    ]));
                 }));
             }));
         });