@enbox/dwn-sdk-js 0.0.1 → 0.0.3

package/dist/esm/tests/handlers/records-subscribe.spec.js

@@ -7,11 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
-import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' assert { type: 'json' };
-import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' assert { type: 'json' };
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' with { type: 'json' };
+import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
 import { Jws } from '../../src/utils/jws.js';
 import { Message } from '../../src/core/message.js';
 import { Poller } from '../utils/poller.js';
@@ -23,7 +22,6 @@ import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 import { Dwn, DwnErrorCode, DwnMethodName, EventEmitterStream, MessageStoreLevel, Time } from '../../src/index.js';
-chai.use(chaiAsPromised);
 export function testRecordsSubscribeHandler() {
     describe('RecordsSubscribeHandler.handle()', () => {
         describe('EventStream disabled', () => {
@@ -31,23 +29,23 @@ export function testRecordsSubscribeHandler() {
             let messageStore;
             let resumableTaskStore;
             let dataStore;
-            let eventLog;
+            let stateIndex;
             let dwn;
             // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
             // so that different test suites can reuse the same backend store for testing
-            before(() => __awaiter(this, void 0, void 0, function* () {
+            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
                 didResolver = new UniversalResolver({ didResolvers: [DidKey] });
                 const stores = TestStores.get();
                 messageStore = stores.messageStore;
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
-                eventLog = stores.eventLog;
+                stateIndex = stores.stateIndex;
                 dwn = yield Dwn.create({
                     didResolver,
                     messageStore,
                     dataStore,
                     resumableTaskStore,
-                    eventLog,
+                    stateIndex,
                 });
             }));
             beforeEach(() => __awaiter(this, void 0, void 0, function* () {
@@ -56,22 +54,22 @@ export function testRecordsSubscribeHandler() {
                 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();
             }));
             it('should respond with a 501 if subscriptions are not supported', () => __awaiter(this, void 0, void 0, function* () {
                 yield dwn.close(); // close the original dwn instance
-                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, resumableTaskStore }); // leave out eventStream
+                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, resumableTaskStore }); // leave out eventStream
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // attempt to subscribe
                 const { message } = yield TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                 });
                 const subscriptionMessageReply = yield dwn.processMessage(alice.did, message, { subscriptionHandler: (_) => { } });
-                expect(subscriptionMessageReply.status.code).to.equal(501, subscriptionMessageReply.status.detail);
-                expect(subscriptionMessageReply.status.detail).to.include(DwnErrorCode.RecordsSubscribeEventStreamUnimplemented);
+                expect(subscriptionMessageReply.status.code).toBe(501, subscriptionMessageReply.status.detail);
+                expect(subscriptionMessageReply.status.detail).toContain(DwnErrorCode.RecordsSubscribeEventStreamUnimplemented);
             }));
         });
         describe('functional tests', () => {
@@ -79,20 +77,20 @@ export function testRecordsSubscribeHandler() {
             let messageStore;
             let dataStore;
             let resumableTaskStore;
-            let eventLog;
+            let stateIndex;
             let eventStream;
             let dwn;
             // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
             // so that different test suites can reuse the same backend store for testing
-            before(() => __awaiter(this, void 0, void 0, function* () {
+            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
                 didResolver = new UniversalResolver({ didResolvers: [DidKey] });
                 const stores = TestStores.get();
                 messageStore = stores.messageStore;
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
-                eventLog = stores.eventLog;
+                stateIndex = stores.stateIndex;
                 eventStream = TestEventStream.get();
-                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, eventStream, resumableTaskStore });
+                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
             }));
             beforeEach(() => __awaiter(this, void 0, void 0, function* () {
                 sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
@@ -100,9 +98,9 @@ export function testRecordsSubscribeHandler() {
                 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();
             }));
             it('should return a subscription object', () => __awaiter(this, void 0, void 0, function* () {
@@ -113,8 +111,8 @@ export function testRecordsSubscribeHandler() {
                 });
                 // Send records subscribe message
                 const reply = yield dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
-                expect(reply.status.code).to.equal(200);
-                expect(reply.subscription).to.exist;
+                expect(reply.status.code).toBe(200);
+                expect(reply.subscription).toBeDefined();
             }));
             it('should return 400 if protocol is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -132,8 +130,8 @@ export function testRecordsSubscribeHandler() {
                 });
                 // Send records subscribe message
                 const reply = yield dwn.processMessage(alice.did, recordsSubscribe.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.UrlProtocolNotNormalized);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.UrlProtocolNotNormalized);
             }));
             it('should return 400 if schema is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -151,8 +149,8 @@ export function testRecordsSubscribeHandler() {
                 });
                 // Send records subscribe message
                 const reply = yield dwn.processMessage(alice.did, recordsSubscribe.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.UrlSchemaNotNormalized);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.UrlSchemaNotNormalized);
             }));
             it('should return 400 if published is set to false and a datePublished range is provided', () => __awaiter(this, void 0, void 0, function* () {
                 const fromDatePublished = Time.getCurrentTimestamp();
@@ -165,26 +163,26 @@ export function testRecordsSubscribeHandler() {
                 // set to false
                 recordSubscribe.message.descriptor.filter.published = false;
                 const subscribeResponse = yield dwn.processMessage(alice.did, recordSubscribe.message);
-                expect(subscribeResponse.status.code).to.equal(400);
-                expect(subscribeResponse.status.detail).to.contain('descriptor/filter/published: must be equal to one of the allowed values');
+                expect(subscribeResponse.status.code).toBe(400);
+                expect(subscribeResponse.status.detail).toContain('descriptor/filter/published: must be equal to one of the allowed values');
             }));
             it('should return 401 for anonymous subscriptions that filter explicitly for unpublished records', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // create an unpublished record
                 const draftWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
                 const draftWriteReply = yield dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
-                expect(draftWriteReply.status.code).to.equal(202);
+                expect(draftWriteReply.status.code).toBe(202);
                 // validate that alice can subscribe
                 const unpublishedPostSubscribe = yield TestDataGenerator.generateRecordsSubscribe({ author: alice, filter: { schema: 'post', published: false } });
                 const unpublishedPostReply = yield dwn.processMessage(alice.did, unpublishedPostSubscribe.message, { subscriptionHandler: () => { } });
-                expect(unpublishedPostReply.status.code).to.equal(200);
-                expect(unpublishedPostReply.subscription).to.exist;
+                expect(unpublishedPostReply.status.code).toBe(200);
+                expect(unpublishedPostReply.subscription).toBeDefined();
                 // anonymous subscribe for unpublished records
                 const unpublishedAnonymous = yield RecordsSubscribe.create({ filter: { schema: 'post', published: false } });
                 const anonymousPostReply = yield dwn.processMessage(alice.did, unpublishedAnonymous.message);
-                expect(anonymousPostReply.status.code).to.equal(401);
-                expect(anonymousPostReply.status.detail).contains('Missing JWS');
-                expect(anonymousPostReply.subscription).to.not.exist;
+                expect(anonymousPostReply.status.code).toBe(401);
+                expect(anonymousPostReply.status.detail).toContain('Missing JWS');
+                expect(anonymousPostReply.subscription).toBeUndefined();
             }));
             it('should return 401 if signature check fails', () => __awaiter(this, void 0, void 0, function* () {
                 const { author, message } = yield TestDataGenerator.generateRecordsSubscribe();
@@ -197,7 +195,7 @@ export function testRecordsSubscribeHandler() {
                 const eventStreamStub = sinon.createStubInstance(EventEmitterStream);
                 const recordsSubscribeHandler = new RecordsSubscribeHandler(didResolver, messageStoreStub, eventStreamStub);
                 const reply = yield recordsSubscribeHandler.handle({ tenant, message, subscriptionHandler: () => { } });
-                expect(reply.status.code).to.equal(401);
+                expect(reply.status.code).toBe(401);
             }));
             it('should return 400 if fail parsing the message', () => __awaiter(this, void 0, void 0, function* () {
                 const { author, message } = yield TestDataGenerator.generateRecordsSubscribe();
@@ -210,7 +208,7 @@ export function testRecordsSubscribeHandler() {
                 // stub the `parse()` function to throw an error
                 sinon.stub(RecordsSubscribe, 'parse').throws('anyError');
                 const reply = yield recordsSubscribeHandler.handle({ tenant, message, subscriptionHandler: () => { } });
-                expect(reply.status.code).to.equal(400);
+                expect(reply.status.code).toBe(400);
             }));
             describe('protocol based subscriptions', () => {
                 it('does not try protocol authorization if protocolRole is not invoked', () => __awaiter(this, void 0, void 0, function* () {
@@ -228,7 +226,7 @@ export function testRecordsSubscribeHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     const bobMessages = [];
                     const handleForBob = (event) => __awaiter(this, void 0, void 0, function* () {
                         const { message } = event;
@@ -243,8 +241,8 @@ export function testRecordsSubscribeHandler() {
                         }
                     });
                     const subscriptionReply = yield dwn.processMessage(alice.did, bobSubscription.message, { subscriptionHandler: handleForBob });
-                    expect(subscriptionReply.status.code).to.equal(200);
-                    expect(subscriptionReply.subscription).to.exist;
+                    expect(subscriptionReply.status.code).toBe(200);
+                    expect(subscriptionReply.subscription).toBeDefined();
                     const carolMessages = [];
                     const handleForCarol = (event) => __awaiter(this, void 0, void 0, function* () {
                         const { message } = event;
@@ -259,8 +257,8 @@ export function testRecordsSubscribeHandler() {
                         }
                     });
                     const carolSubscriptionReply = yield dwn.processMessage(alice.did, carolSubscription.message, { subscriptionHandler: handleForCarol });
-                    expect(carolSubscriptionReply.status.code).to.equal(200);
-                    expect(carolSubscriptionReply.subscription).to.exist;
+                    expect(carolSubscriptionReply.status.code).toBe(200);
+                    expect(carolSubscriptionReply.subscription).toBeDefined();
                     // Alice writes a 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -268,7 +266,7 @@ export function testRecordsSubscribeHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes one 'chat' record addressed to Bob
                     const chatRecordForBob = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -280,7 +278,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob can read this cuz he is my friend'),
                     });
                     const chatRecordForBobReply = yield dwn.processMessage(alice.did, chatRecordForBob.message, { dataStream: chatRecordForBob.dataStream });
-                    expect(chatRecordForBobReply.status.code).to.equal(202);
+                    expect(chatRecordForBobReply.status.code).toBe(202);
                     const chatRecordForBobCid = yield Message.getCid(chatRecordForBob.message);
                     // Alice writes two 'chat' records addressed to Carol
                     const chatRecordForCarol1 = yield TestDataGenerator.generateRecordsWrite({
@@ -293,7 +291,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob cannot read this'),
                     });
                     const chatRecordForCarol1Reply = yield dwn.processMessage(alice.did, chatRecordForCarol1.message, { dataStream: chatRecordForCarol1.dataStream });
-                    expect(chatRecordForCarol1Reply.status.code).to.equal(202);
+                    expect(chatRecordForCarol1Reply.status.code).toBe(202);
                     const chatRecordForCarol1Cid = yield Message.getCid(chatRecordForCarol1.message);
                     const chatRecordForCarol2 = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -305,15 +303,15 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob cannot read this either'),
                     });
                     const chatRecordForCarol2Reply = yield dwn.processMessage(alice.did, chatRecordForCarol2.message, { dataStream: chatRecordForCarol2.dataStream });
-                    expect(chatRecordForCarol2Reply.status.code).to.equal(202);
+                    expect(chatRecordForCarol2Reply.status.code).toBe(202);
                     const chatRecordForCarol2Cid = yield Message.getCid(chatRecordForCarol2.message);
                     yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                        expect(bobMessages.length).to.equal(1);
-                        expect(bobMessages).to.have.members([chatRecordForBobCid]);
+                        expect(bobMessages.length).toBe(1);
+                        expect(bobMessages).toEqual(expect.arrayContaining([chatRecordForBobCid]));
                     }));
                     yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                        expect(carolMessages.length).to.equal(2);
-                        expect(carolMessages).to.have.members([chatRecordForCarol1Cid, chatRecordForCarol2Cid]);
+                        expect(carolMessages.length).toBe(2);
+                        expect(carolMessages).toEqual(expect.arrayContaining([chatRecordForCarol1Cid, chatRecordForCarol2Cid]));
                     }));
                 }));
                 it('allows root-level role authorized subscriptions', () => __awaiter(this, void 0, void 0, function* () {
@@ -328,7 +326,7 @@ export function testRecordsSubscribeHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     const filter = {
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'chat'
@@ -350,8 +348,8 @@ export function testRecordsSubscribeHandler() {
                         filter
                     });
                     const subscriptionReply = yield dwn.processMessage(alice.did, noRoleSubscription.message, { subscriptionHandler: addNoRole });
-                    expect(subscriptionReply.status.code).to.equal(200);
-                    expect(subscriptionReply.subscription).to.exist;
+                    expect(subscriptionReply.status.code).toBe(200);
+                    expect(subscriptionReply.subscription).toBeDefined();
                     // Alice writes a 'friend' root-level role record with Bob as recipient
                     const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -361,7 +359,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
                     const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                    expect(friendRoleReply.status.code).to.equal(202);
+                    expect(friendRoleReply.status.code).toBe(202);
                     const recordIds = new Set();
                     const addRecord = (event) => __awaiter(this, void 0, void 0, function* () {
                         const { message } = event;
@@ -380,8 +378,8 @@ export function testRecordsSubscribeHandler() {
                         protocolRole: 'friend',
                     });
                     const subscriptionWithRoleReply = yield dwn.processMessage(alice.did, bobSubscriptionWithRole.message, { subscriptionHandler: addRecord });
-                    expect(subscriptionWithRoleReply.status.code).to.equal(200);
-                    expect(subscriptionWithRoleReply.subscription).to.exist;
+                    expect(subscriptionWithRoleReply.status.code).toBe(200);
+                    expect(subscriptionWithRoleReply.subscription).toBeDefined();
                     // Create one chat message for Bob as a control to show up in the `noRoleRecords` array
                     const chatRecordForBob = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -392,7 +390,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob can read this cuz he is my friend'),
                     });
                     const chatRecordForBobReply = yield dwn.processMessage(alice.did, chatRecordForBob.message, { dataStream: chatRecordForBob.dataStream });
-                    expect(chatRecordForBobReply.status.code).to.equal(202);
+                    expect(chatRecordForBobReply.status.code).toBe(202);
                     // Alice writes three more 'chat' records for carol, Bob's friend role should allow him to see these messages.
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -405,20 +403,20 @@ export function testRecordsSubscribeHandler() {
                             data: new TextEncoder().encode('Bob can read this cuz he is my friend'),
                         });
                         const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                        expect(chatReply.status.code).to.equal(202);
+                        expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // there should only be the control message for bob in the subscription without a friend role.
                     yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                        expect(noRoleRecords.size).to.equal(1);
-                        expect([...noRoleRecords]).to.have.members([chatRecordForBob.message.recordId]);
+                        expect(noRoleRecords.size).toBe(1);
+                        expect([...noRoleRecords]).toEqual(expect.arrayContaining([chatRecordForBob.message.recordId]));
                     }));
                     // All chats should be in the subscription with the friend role.
                     yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                        expect(recordIds.size).to.equal(4);
-                        expect([...recordIds]).to.have.members([chatRecordForBob.message.recordId, ...chatRecordIds]);
+                        expect(recordIds.size).toBe(4);
+                        expect([...recordIds]).toEqual(expect.arrayContaining([chatRecordForBob.message.recordId, ...chatRecordIds]));
                     }));
-                    // TODO: https://github.com/TBD54566975/dwn-sdk-js/issues/759
+                    // TODO: https://github.com/enboxorg/enbox/issues/759
                     //      When `RecordsSubscribeHandler` builds up the matchFilters there are no matching filters for a delete within a context
                     //      so the delete event is not being captured by the subscription handler. This is likely due to some of the filters including
                     //      `published: false` which is a mutable property and not included with the delete event
@@ -430,18 +428,18 @@ export function testRecordsSubscribeHandler() {
                     //   recordId     : chatRecordForBob.message.recordId,
                     // });
                     // const chatForBobDeleteReply = await dwn.processMessage(alice.did, chatForBobDelete.message);
-                    // expect(chatForBobDeleteReply.status.code).to.equal(202);
+                    // expect(chatForBobDeleteReply.status.code).toBe(202);
                     // // Delete one of the other chat messages
                     // const chatForCarolDelete = await TestDataGenerator.generateRecordsDelete({
                     //   author       : alice,
                     //   recordId     : chatRecordIds[0],
                     // });
                     // const chatForCarolDeleteReply = await dwn.processMessage(alice.did, chatForCarolDelete.message);
-                    // expect(chatForCarolDeleteReply.status.code).to.equal(202);
+                    // expect(chatForCarolDeleteReply.status.code).toBe(202);
                     // await Poller.pollUntilSuccessOrTimeout(async () => {
-                    //   expect(noRoleRecords.size).to.equal(0); // chat record was removed from the set
-                    //   expect(recordIds.size).to.equal(2); // both chat records were removed from the set
-                    //   expect([ ...recordIds ]).to.have.members([ ...chatRecordIds.slice(1) ]); // only the last two chat records remain
+                    //   expect(noRoleRecords.size).toBe(0); // chat record was removed from the set
+                    //   expect(recordIds.size).toBe(2); // both chat records were removed from the set
+                    //   expect([ ...recordIds ]).toEqual(expect.arrayContaining([ ...chatRecordIds.slice(1) ])); // only the last two chat records remain
                     // });
                 }));
                 it('can authorize subscriptions using a context role', () => __awaiter(this, void 0, void 0, function* () {
@@ -455,7 +453,7 @@ export function testRecordsSubscribeHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -463,7 +461,7 @@ export function testRecordsSubscribeHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     const filter = {
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'thread/chat',
@@ -483,8 +481,8 @@ export function testRecordsSubscribeHandler() {
                         filter
                     });
                     const subscriptionReply = yield dwn.processMessage(alice.did, noRoleSubscription.message, { subscriptionHandler: addNoRole });
-                    expect(subscriptionReply.status.code).to.equal(200);
-                    expect(subscriptionReply.subscription).to.exist;
+                    expect(subscriptionReply.status.code).toBe(200);
+                    expect(subscriptionReply.subscription).toBeDefined();
                     // Alice writes a 'participant' role record with Bob as recipient
                     const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -495,7 +493,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
                     const participantRoleReply = yield dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-                    expect(participantRoleReply.status.code).to.equal(202);
+                    expect(participantRoleReply.status.code).toBe(202);
                     const recordIds = [];
                     const addRecord = (event) => __awaiter(this, void 0, void 0, function* () {
                         const { message } = event;
@@ -511,8 +509,8 @@ export function testRecordsSubscribeHandler() {
                         protocolRole: 'thread/participant',
                     });
                     const subscriptionWithRoleReply = yield dwn.processMessage(alice.did, bobSubscriptionWithRole.message, { subscriptionHandler: addRecord });
-                    expect(subscriptionWithRoleReply.status.code).to.equal(200);
-                    expect(subscriptionWithRoleReply.subscription).to.exist;
+                    expect(subscriptionWithRoleReply.status.code).toBe(200);
+                    expect(subscriptionWithRoleReply.subscription).toBeDefined();
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -526,14 +524,14 @@ export function testRecordsSubscribeHandler() {
                             data: new TextEncoder().encode('Bob can read this cuz he is my friend'),
                         });
                         const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                        expect(chatReply.status.code).to.equal(202);
+                        expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
                         // should have all chat messages.
-                        expect(recordIds).to.have.members(chatRecordIds);
+                        expect(recordIds).toEqual(expect.arrayContaining(chatRecordIds));
                         // there should not be any messages in the subscription without a participant role.
-                        expect(noRoleRecords.length).to.equal(0);
+                        expect(noRoleRecords.length).toBe(0);
                     }));
                 }));
                 it('does not execute protocol subscriptions where protocolPath is missing from the filter', () => __awaiter(this, void 0, void 0, function* () {
@@ -547,7 +545,7 @@ export function testRecordsSubscribeHandler() {
                         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 'friend' root-level role record with Bob as recipient
                     const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -557,7 +555,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
                     const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                    expect(friendRoleReply.status.code).to.equal(202);
+                    expect(friendRoleReply.status.code).toBe(202);
                     // Bob invokes his friendRole to subscribe but does not have `protocolPath` in the filter
                     const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
@@ -568,9 +566,9 @@ export function testRecordsSubscribeHandler() {
                         protocolRole: 'friend',
                     });
                     const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
-                    expect(chatSubscribeReply.status.code).to.equal(400);
-                    expect(chatSubscribeReply.status.detail).to.contain(DwnErrorCode.RecordsSubscribeFilterMissingRequiredProperties);
-                    expect(chatSubscribeReply.subscription).to.not.exist;
+                    expect(chatSubscribeReply.status.code).toBe(400);
+                    expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.RecordsSubscribeFilterMissingRequiredProperties);
+                    expect(chatSubscribeReply.subscription).toBeUndefined();
                 }));
                 it('does not execute context role authorized subscriptions where contextId is missing from the filter', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice gives Bob a role allowing him to access a particular chat thread.
@@ -583,7 +581,7 @@ export function testRecordsSubscribeHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -591,7 +589,7 @@ export function testRecordsSubscribeHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes a 'friend' root-level role record with Bob as recipient
                     const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -602,7 +600,7 @@ export function testRecordsSubscribeHandler() {
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
                     const participantRoleReply = yield dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-                    expect(participantRoleReply.status.code).to.equal(202);
+                    expect(participantRoleReply.status.code).toBe(202);
                     // Bob invokes his thread participant role to subscribe but omits the contextId
                     const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
@@ -614,9 +612,9 @@ export function testRecordsSubscribeHandler() {
                         protocolRole: 'thread/participant',
                     });
                     const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
-                    expect(chatSubscribeReply.status.code).to.eq(401);
-                    expect(chatSubscribeReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMissingContextId);
-                    expect(chatSubscribeReply.subscription).to.not.exist;
+                    expect(chatSubscribeReply.status.code).toBe(401);
+                    expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMissingContextId);
+                    expect(chatSubscribeReply.subscription).toBeUndefined();
                 }));
                 it('rejects role authorized subscriptions if the request author does not have a matching root-level role', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice installs a chat protocol.
@@ -629,7 +627,7 @@ export function testRecordsSubscribeHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Bob invokes a friendRole he does not have to subscribe to the records
                     const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
@@ -640,9 +638,9 @@ export function testRecordsSubscribeHandler() {
                         protocolRole: 'friend',
                     });
                     const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
-                    expect(chatSubscribeReply.status.code).to.eq(401);
-                    expect(chatSubscribeReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
-                    expect(chatSubscribeReply.subscription).to.not.exist;
+                    expect(chatSubscribeReply.status.code).toBe(401);
+                    expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                    expect(chatSubscribeReply.subscription).toBeUndefined();
                 }));
                 it('rejects role authorized subscriptions where the subscription author does not have a matching context role', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -653,7 +651,7 @@ export function testRecordsSubscribeHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -661,7 +659,7 @@ export function testRecordsSubscribeHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Bob invokes his a `thread/participant` role which he does not have to subscribe to the records
                     const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
@@ -673,10 +671,207 @@ export function testRecordsSubscribeHandler() {
                         protocolRole: 'thread/participant',
                     });
                     const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
-                    expect(chatSubscribeReply.status.code).to.eq(401);
-                    expect(chatSubscribeReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
-                    expect(chatSubscribeReply.subscription).to.not.exist;
+                    expect(chatSubscribeReply.status.code).toBe(401);
+                    expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                    expect(chatSubscribeReply.subscription).toBeUndefined();
                 }));
+                describe('who-based query/subscribe action rules', () => {
+                    const whoSubscribeProtocol = {
+                        published: true,
+                        protocol: 'http://who-subscribe-test.xyz',
+                        types: {
+                            message: {
+                                dataFormats: ['text/plain'],
+                            },
+                        },
+                        structure: {
+                            message: {
+                                $actions: [
+                                    { who: 'anyone', can: ['create'] },
+                                    { who: 'author', of: 'message', can: ['read'] },
+                                    { who: 'recipient', of: 'message', can: ['read'] },
+                                ],
+                            },
+                        },
+                    };
+                    it('recipient receives only events for records addressed to them', () => __awaiter(this, void 0, void 0, function* () {
+                        // scenario: Bob and Carol each subscribe to Alice's DWN. Alice writes messages
+                        //           to Bob and Carol. Each subscriber only receives their own messages.
+                        //           Dave subscribes and receives nothing.
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const carol = yield TestDataGenerator.generateDidKeyPersona();
+                        const dave = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition: whoSubscribeProtocol,
+                        });
+                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
+                        // Bob subscribes — no role
+                        const bobRecordIds = new Set();
+                        const bobHandler = (event) => __awaiter(this, void 0, void 0, function* () {
+                            const { message } = event;
+                            if (message.descriptor.method === DwnMethodName.Write) {
+                                bobRecordIds.add(message.recordId);
+                            }
+                        });
+                        const bobSub = yield TestDataGenerator.generateRecordsSubscribe({
+                            author: bob,
+                            filter: {
+                                published: false,
+                                protocol: whoSubscribeProtocol.protocol,
+                            },
+                        });
+                        const bobSubReply = yield dwn.processMessage(alice.did, bobSub.message, { subscriptionHandler: bobHandler });
+                        expect(bobSubReply.status.code).toBe(200);
+                        // Carol subscribes — no role
+                        const carolRecordIds = new Set();
+                        const carolHandler = (event) => __awaiter(this, void 0, void 0, function* () {
+                            const { message } = event;
+                            if (message.descriptor.method === DwnMethodName.Write) {
+                                carolRecordIds.add(message.recordId);
+                            }
+                        });
+                        const carolSub = yield TestDataGenerator.generateRecordsSubscribe({
+                            author: carol,
+                            filter: {
+                                published: false,
+                                protocol: whoSubscribeProtocol.protocol,
+                            },
+                        });
+                        const carolSubReply = yield dwn.processMessage(alice.did, carolSub.message, { subscriptionHandler: carolHandler });
+                        expect(carolSubReply.status.code).toBe(200);
+                        // Dave subscribes — no role, not a participant at all
+                        const daveRecordIds = new Set();
+                        const daveHandler = (event) => __awaiter(this, void 0, void 0, function* () {
+                            const { message } = event;
+                            if (message.descriptor.method === DwnMethodName.Write) {
+                                daveRecordIds.add(message.recordId);
+                            }
+                        });
+                        const daveSub = yield TestDataGenerator.generateRecordsSubscribe({
+                            author: dave,
+                            filter: {
+                                published: false,
+                                protocol: whoSubscribeProtocol.protocol,
+                            },
+                        });
+                        const daveSubReply = yield dwn.processMessage(alice.did, daveSub.message, { subscriptionHandler: daveHandler });
+                        expect(daveSubReply.status.code).toBe(200);
+                        // Alice writes 2 messages for Bob
+                        const expectedBobIds = [];
+                        for (let i = 0; i < 2; i++) {
+                            const msg = yield TestDataGenerator.generateRecordsWrite({
+                                author: alice,
+                                recipient: bob.did,
+                                protocol: whoSubscribeProtocol.protocol,
+                                protocolPath: 'message',
+                                published: false,
+                                dataFormat: 'text/plain',
+                                data: new TextEncoder().encode(`for bob ${i}`),
+                            });
+                            const reply = yield dwn.processMessage(alice.did, msg.message, { dataStream: msg.dataStream });
+                            expect(reply.status.code).toBe(202);
+                            expectedBobIds.push(msg.message.recordId);
+                        }
+                        // Alice writes 1 message for Carol
+                        const carolMsg = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            recipient: carol.did,
+                            protocol: whoSubscribeProtocol.protocol,
+                            protocolPath: 'message',
+                            published: false,
+                            dataFormat: 'text/plain',
+                            data: new TextEncoder().encode('for carol'),
+                        });
+                        const carolWriteReply = yield dwn.processMessage(alice.did, carolMsg.message, { dataStream: carolMsg.dataStream });
+                        expect(carolWriteReply.status.code).toBe(202);
+                        // Alice writes 1 message addressed to herself (nobody else should see it)
+                        const aliceMsg = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            recipient: alice.did,
+                            protocol: whoSubscribeProtocol.protocol,
+                            protocolPath: 'message',
+                            published: false,
+                            dataFormat: 'text/plain',
+                            data: new TextEncoder().encode('private'),
+                        });
+                        const aliceWriteReply = yield dwn.processMessage(alice.did, aliceMsg.message, { dataStream: aliceMsg.dataStream });
+                        expect(aliceWriteReply.status.code).toBe(202);
+                        // Bob should receive exactly 2 events
+                        yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                            expect(bobRecordIds.size).toBe(2);
+                            expect([...bobRecordIds]).toEqual(expect.arrayContaining(expectedBobIds));
+                        }));
+                        // Carol should receive exactly 1 event
+                        yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                            expect(carolRecordIds.size).toBe(1);
+                            expect([...carolRecordIds]).toEqual(expect.arrayContaining([carolMsg.message.recordId]));
+                        }));
+                        // Dave should receive zero events
+                        // Give a small window for any stray events to arrive, then assert empty
+                        yield Time.sleep(200);
+                        expect(daveRecordIds.size).toBe(0);
+                    }));
+                    it('who-based subscribe rules do not grant role-like broad access', () => __awaiter(this, void 0, void 0, function* () {
+                        // scenario: Dave tries to invoke a protocolRole on a protocol with who-based
+                        //           subscribe rules. Should be rejected because he has no role record.
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const dave = yield TestDataGenerator.generateDidKeyPersona();
+                        const mixedProtocol = {
+                            published: true,
+                            protocol: 'http://mixed-sub-test.xyz',
+                            types: {
+                                thread: {},
+                                participant: {},
+                                chat: { dataFormats: ['text/plain'] },
+                            },
+                            structure: {
+                                thread: {
+                                    participant: {
+                                        $role: true,
+                                    },
+                                    chat: {
+                                        $actions: [
+                                            { who: 'anyone', can: ['create'] },
+                                            { who: 'recipient', of: 'thread/chat', can: ['read'] },
+                                            { role: 'thread/participant', can: ['read'] },
+                                        ],
+                                    },
+                                },
+                            },
+                        };
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition: mixedProtocol,
+                        });
+                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
+                        // Alice creates a thread
+                        const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: mixedProtocol.protocol,
+                            protocolPath: 'thread',
+                        });
+                        const threadReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                        expect(threadReply.status.code).toBe(202);
+                        // Dave tries to subscribe with a role he doesn't have — should be rejected
+                        const daveRoleSub = yield TestDataGenerator.generateRecordsSubscribe({
+                            author: dave,
+                            filter: {
+                                protocol: mixedProtocol.protocol,
+                                protocolPath: 'thread/chat',
+                                contextId: threadRecord.message.contextId,
+                            },
+                            protocolRole: 'thread/participant',
+                        });
+                        const daveRoleSubReply = yield dwn.processMessage(alice.did, daveRoleSub.message);
+                        expect(daveRoleSubReply.status.code).toBe(401);
+                        expect(daveRoleSubReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                        expect(daveRoleSubReply.subscription).toBeUndefined();
+                    }));
+                });
             });
         });
     });