@enbox/dwn-sdk-js 0.0.2 → 0.0.4

package/dist/esm/tests/features/author-delegated-grant.spec.js

@@ -7,12 +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 emailProtocolDefinition from '../vectors/protocol-definitions/email.json' assert { type: 'json' };
-import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' assert { type: 'json' };
+import emailProtocolDefinition from '../vectors/protocol-definitions/email.json' with { type: 'json' };
+import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' with { type: 'json' };
 import sinon from 'sinon';
-import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' assert { type: 'json' };
-import chai, { expect } from 'chai';
+import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
 import { base64url } from 'multiformats/bases/base64';
 import { DataStream } from '../../src/utils/data-stream.js';
 import { Dwn } from '../../src/dwn.js';
@@ -25,29 +23,29 @@ import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { Time } from '../../src/utils/time.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 import { DwnInterfaceName, DwnMethodName, Encoder, Message, PermissionsProtocol, RecordsDelete, RecordsQuery, RecordsRead, RecordsSubscribe } from '../../src/index.js';
-chai.use(chaiAsPromised);
 export function testAuthorDelegatedGrant() {
-    describe('author delegated grant', () => __awaiter(this, void 0, void 0, function* () {
+    describe('author delegated grant', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
         // so that different test suites can reuse the same backend store for testing
-        before(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
             dataStore = stores.dataStore;
             resumableTaskStore = stores.resumableTaskStore;
-            eventLog = stores.eventLog;
+            stateIndex = stores.stateIndex;
             eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, eventStream, resumableTaskStore });
+            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
         }));
         beforeEach(() => __awaiter(this, void 0, void 0, function* () {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
@@ -55,9 +53,9 @@ export function testAuthorDelegatedGrant() {
             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('ProtocolsConfigure', () => {
@@ -85,22 +83,22 @@ export function testAuthorDelegatedGrant() {
                 });
                 // Bob should be able to configure a protocol on behalf of alice
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 // verify the protocol configure message was processed
                 const protocolsQuery = yield TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: emailProtocolDefinition.protocol }
                 });
                 const { status, entries } = yield dwn.processMessage(alice.did, protocolsQuery.message);
-                expect(status.code).to.equal(200);
-                expect(entries === null || entries === void 0 ? void 0 : entries.length).to.equal(1);
+                expect(status.code).toBe(200);
+                expect(entries === null || entries === void 0 ? void 0 : entries.length).toBe(1);
                 const fetchedProtocolConfigure = entries[0];
-                expect(fetchedProtocolConfigure.descriptor.definition).to.deep.equal(emailProtocolDefinition);
+                expect(fetchedProtocolConfigure.descriptor.definition).toEqual(emailProtocolDefinition);
                 // author should be alice
                 const author = Message.getAuthor(fetchedProtocolConfigure);
-                expect(author).to.equal(alice.did);
+                expect(author).toBe(alice.did);
                 const signer = Message.getSigner(fetchedProtocolConfigure);
-                expect(signer).to.equal(bob.did);
+                expect(signer).toBe(bob.did);
             }));
             it('should allow author-delegated grant to configure a specific protocol', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -127,22 +125,22 @@ export function testAuthorDelegatedGrant() {
                 });
                 // Bob should be able to configure a protocol on behalf of alice
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 // verify the protocol configure message was processed
                 const protocolsQuery = yield TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: emailProtocolDefinition.protocol }
                 });
                 const { status, entries } = yield dwn.processMessage(alice.did, protocolsQuery.message);
-                expect(status.code).to.equal(200);
-                expect(entries === null || entries === void 0 ? void 0 : entries.length).to.equal(1);
+                expect(status.code).toBe(200);
+                expect(entries === null || entries === void 0 ? void 0 : entries.length).toBe(1);
                 const fetchedProtocolConfigure = entries[0];
-                expect(fetchedProtocolConfigure.descriptor.definition).to.deep.equal(emailProtocolDefinition);
+                expect(fetchedProtocolConfigure.descriptor.definition).toEqual(emailProtocolDefinition);
                 // author should be alice
                 const author = Message.getAuthor(fetchedProtocolConfigure);
-                expect(author).to.equal(alice.did);
+                expect(author).toBe(alice.did);
                 const signer = Message.getSigner(fetchedProtocolConfigure);
-                expect(signer).to.equal(bob.did);
+                expect(signer).toBe(bob.did);
                 // verify that bob cannot configure a different protocol
                 const otherProtocolDefinition = Object.assign(Object.assign({}, emailProtocolDefinition), { protocol: 'https://example.com/protocol/otherProtocol' });
                 const otherProtocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
@@ -151,11 +149,11 @@ export function testAuthorDelegatedGrant() {
                     protocolDefinition: otherProtocolDefinition,
                 });
                 const otherProtocolConfigureReply = yield dwn.processMessage(alice.did, otherProtocolConfigure.message);
-                expect(otherProtocolConfigureReply.status.code).to.equal(401);
-                expect(otherProtocolConfigureReply.status.detail).to.contain(DwnErrorCode.ProtocolsGrantAuthorizationScopeProtocolMismatch);
+                expect(otherProtocolConfigureReply.status.code).toBe(401);
+                expect(otherProtocolConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsGrantAuthorizationScopeProtocolMismatch);
             }));
         });
-        describe('RecordsWrite.parse()', () => __awaiter(this, void 0, void 0, function* () {
+        describe('RecordsWrite.parse()', () => {
             it('should throw if a message invokes a author-delegated grant (ID) but the author-delegated grant is not given', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generatePersona();
                 const bob = yield TestDataGenerator.generatePersona();
@@ -182,7 +180,7 @@ export function testAuthorDelegatedGrant() {
                 });
                 delete recordsWrite.message.authorization.authorDelegatedGrant; // intentionally remove `authorDelegatedGrant`
                 const parsePromise = RecordsWrite.parse(recordsWrite.message);
-                yield expect(parsePromise).to.be.rejectedWith(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
+                yield expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
             }));
             it('should throw if a message includes an author-delegated grant but does not reference it in author signature', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generatePersona();
@@ -213,9 +211,9 @@ export function testAuthorDelegatedGrant() {
                 delete authorSignaturePayloadCopy.delegatedGrantId; // intentionally remove `delegatedGrantId` in author signature
                 recordsWrite.message.authorization.signature.payload = Encoder.stringToBase64Url(JSON.stringify(authorSignaturePayloadCopy));
                 const parsePromise = RecordsWrite.parse(recordsWrite.message);
-                yield expect(parsePromise).to.be.rejectedWith(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
+                yield expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
             }));
-        }));
+        });
         it('should only allow correct entity invoking an author-delegated grant to write', () => __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             // scenario:
@@ -236,7 +234,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // Alice creates a delegated grant for device X and device Y
             const scope = {
                 interface: DwnInterfaceName.Records,
@@ -270,19 +268,19 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(202);
+            expect(deviceXWriteReply.status.code).toBe(202);
             // verify the message by device X got written to Bob's DWN, AND Alice is the logical author
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
             const fetchedDeviceXWriteEntry = bobRecordsQueryReply.entries[0];
-            expect(fetchedDeviceXWriteEntry.encodedData).to.equal(base64url.baseEncode(deviceXData));
+            expect(fetchedDeviceXWriteEntry.encodedData).toBe(base64url.baseEncode(deviceXData));
             const fetchedDeviceXWrite = yield RecordsWrite.parse(fetchedDeviceXWriteEntry);
-            expect(fetchedDeviceXWrite.author).to.equal(alice.did);
+            expect(fetchedDeviceXWrite.author).toBe(alice.did);
             // generate a new message by device Y updating the existing record device X created, and write to Bob's DWN
             const deviceYData = new TextEncoder().encode('message from device Y');
             const deviceYDataStream = DataStream.fromBytes(deviceYData);
@@ -293,15 +291,15 @@ export function testAuthorDelegatedGrant() {
                 delegatedGrant: deviceYGrant.dataEncodedMessage,
             });
             const deviceYWriteReply = yield dwn.processMessage(bob.did, messageByDeviceY.message, { dataStream: deviceYDataStream });
-            expect(deviceYWriteReply.status.code).to.equal(202);
+            expect(deviceYWriteReply.status.code).toBe(202);
             // verify the message by device Y got written to Bob's DWN, AND Alice is the logical author
             const bobRecordsQueryReply2 = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply2.status.code).to.equal(200);
-            expect((_b = bobRecordsQueryReply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            expect(bobRecordsQueryReply2.status.code).toBe(200);
+            expect((_b = bobRecordsQueryReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
             const fetchedDeviceYWriteEntry = bobRecordsQueryReply2.entries[0];
-            expect(fetchedDeviceYWriteEntry.encodedData).to.equal(base64url.baseEncode(deviceYData));
+            expect(fetchedDeviceYWriteEntry.encodedData).toBe(base64url.baseEncode(deviceYData));
             const fetchedDeviceYWrite = yield RecordsWrite.parse(fetchedDeviceYWriteEntry);
-            expect(fetchedDeviceYWrite.author).to.equal(alice.did);
+            expect(fetchedDeviceYWrite.author).toBe(alice.did);
             // Verify that Carol cannot write a chat message as Alice by invoking the Device X's grant
             const messageByCarolAsAlice = new TextEncoder().encode('Message from Carol pretending to be Alice');
             const writeByCarolAsAlice = yield RecordsWrite.create({
@@ -314,8 +312,8 @@ export function testAuthorDelegatedGrant() {
                 data: messageByCarolAsAlice
             });
             const carolWriteReply = yield dwn.processMessage(carol.did, writeByCarolAsAlice.message, { dataStream: DataStream.fromBytes(messageByCarolAsAlice) });
-            expect(carolWriteReply.status.code).to.equal(400);
-            expect(carolWriteReply.status.detail).to.contain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
+            expect(carolWriteReply.status.code).toBe(400);
+            expect(carolWriteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
         }));
         it('should only allow correct entity invoking an author-delegated grant to read and query ', () => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
@@ -336,7 +334,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob starts a chat thread
             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -344,7 +342,7 @@ export function testAuthorDelegatedGrant() {
                 protocolPath: 'thread',
             });
             const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-            expect(threadRoleReply.status.code).to.equal(202);
+            expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Alice as a participant in the thread
             const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -355,7 +353,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('Alice is my friend'),
             });
             const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-            expect(participantRoleReply.status.code).to.equal(202);
+            expect(participantRoleReply.status.code).toBe(202);
             // Bob writes a chat message in the thread
             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -364,7 +362,7 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
             });
             const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-            expect(chatRecordReply.status.code).to.equal(202);
+            expect(chatRecordReply.status.code).toBe(202);
             // Alice creates a delegated query grant for device X to act as Alice.
             const queryGrantForDeviceX = yield PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
@@ -395,8 +393,8 @@ export function testAuthorDelegatedGrant() {
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(3);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
             // sanity verify Alice herself is able to query for the chat message from Bob's DWN
             const recordsQueryByAlice = yield RecordsQuery.create({
                 signer: Jws.createSigner(alice),
@@ -408,8 +406,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const aliceRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByAlice.message);
-            expect(aliceRecordsQueryReply.status.code).to.equal(200);
-            expect((_b = aliceRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            expect(aliceRecordsQueryReply.status.code).toBe(200);
+            expect((_b = aliceRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
             // verify device X is able to query for the chat message from Bob's DWN
             const recordsQueryByDeviceX = yield RecordsQuery.create({
                 signer: Jws.createSigner(deviceX),
@@ -422,8 +420,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const deviceXRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
-            expect(deviceXRecordsQueryReply.status.code).to.equal(200);
-            expect((_c = deviceXRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
+            expect(deviceXRecordsQueryReply.status.code).toBe(200);
+            expect((_c = deviceXRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
             // verify device X is able to read the chat message from Bob's DWN
             const recordsReadByDeviceX = yield RecordsRead.create({
                 signer: Jws.createSigner(deviceX),
@@ -434,8 +432,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const deviceXRecordsReadReply = yield dwn.processMessage(bob.did, recordsReadByDeviceX.message);
-            expect(deviceXRecordsReadReply.status.code).to.equal(200);
-            expect((_d = deviceXRecordsReadReply.entry.recordsWrite) === null || _d === void 0 ? void 0 : _d.recordId).to.equal(chatRecord.message.recordId);
+            expect(deviceXRecordsReadReply.status.code).toBe(200);
+            expect((_d = deviceXRecordsReadReply.entry.recordsWrite) === null || _d === void 0 ? void 0 : _d.recordId).toBe(chatRecord.message.recordId);
             // Verify that Carol cannot query as Alice by invoking the delegated grant granted to Device X
             const recordsQueryByCarol = yield RecordsQuery.create({
                 signer: Jws.createSigner(carol),
@@ -448,8 +446,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const recordsQueryByCarolReply = yield dwn.processMessage(bob.did, recordsQueryByCarol.message);
-            expect(recordsQueryByCarolReply.status.code).to.equal(400);
-            expect(recordsQueryByCarolReply.status.detail).to.contain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
+            expect(recordsQueryByCarolReply.status.code).toBe(400);
+            expect(recordsQueryByCarolReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
             // Verify that Carol cannot read as Alice by invoking the delegated grant granted to Device X
             const recordsReadByCarol = yield RecordsRead.create({
                 signer: Jws.createSigner(carol),
@@ -460,8 +458,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const recordsReadByCarolReply = yield dwn.processMessage(bob.did, recordsReadByCarol.message);
-            expect(recordsReadByCarolReply.status.code).to.equal(400);
-            expect(recordsQueryByCarolReply.status.detail).to.contain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
+            expect(recordsReadByCarolReply.status.code).toBe(400);
+            expect(recordsQueryByCarolReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
         }));
         it('should only allow correct entity invoking an author-delegated grant to subscribe', () => __awaiter(this, void 0, void 0, function* () {
             // scenario:
@@ -486,7 +484,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob starts a chat thread
             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -494,7 +492,7 @@ export function testAuthorDelegatedGrant() {
                 protocolPath: 'thread',
             });
             const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-            expect(threadRoleReply.status.code).to.equal(202);
+            expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Alice as a participant in the thread
             const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -505,7 +503,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('Alice is my friend'),
             });
             const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-            expect(participantRoleReply.status.code).to.equal(202);
+            expect(participantRoleReply.status.code).toBe(202);
             // Alice creates a delegated subscribe grant for device X to act as Alice.
             const subscribeGrantForDeviceX = yield PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
@@ -542,7 +540,7 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const recordsSubscribeByDeviceXWithoutGrantReply = yield dwn.processMessage(bob.did, recordsSubscribeByDeviceXWithoutGrant.message);
-            expect(recordsSubscribeByDeviceXWithoutGrantReply.status.code).to.equal(401, 'device X without grant subscribe');
+            expect(recordsSubscribeByDeviceXWithoutGrantReply.status.code).toBe(401, 'device X without grant subscribe');
             // control: verify that Carol cannot subscribe as Alice by invoking the delegated grant granted to Device X
             const recordsSubscribeByCarol = yield RecordsSubscribe.create({
                 signer: Jws.createSigner(carol),
@@ -555,8 +553,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const recordsSubscribeByCarolReply = yield dwn.processMessage(bob.did, recordsSubscribeByCarol.message);
-            expect(recordsSubscribeByCarolReply.status.code).to.equal(400, 'carol subscribe');
-            expect(recordsSubscribeByCarolReply.status.detail).to.contain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
+            expect(recordsSubscribeByCarolReply.status.code).toBe(400, 'carol subscribe');
+            expect(recordsSubscribeByCarolReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
             // verify device X is able to subscribe the chat message from Bob's DWN using the delegated grant
             const recordsSubscribeByDeviceX = yield RecordsSubscribe.create({
                 signer: Jws.createSigner(deviceX),
@@ -571,7 +569,7 @@ export function testAuthorDelegatedGrant() {
             const recordsSubscribeByDeviceXReply = yield dwn.processMessage(bob.did, recordsSubscribeByDeviceX.message, {
                 subscriptionHandler: captureChatRecords
             });
-            expect(recordsSubscribeByDeviceXReply.status.code).to.equal(200, 'subscribe');
+            expect(recordsSubscribeByDeviceXReply.status.code).toBe(200, 'subscribe');
             // Bob writes chat messages in the thread
             const chatRecord1 = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -580,7 +578,7 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
             });
             const chatRecord1Reply = yield dwn.processMessage(bob.did, chatRecord1.message, { dataStream: chatRecord1.dataStream });
-            expect(chatRecord1Reply.status.code).to.equal(202);
+            expect(chatRecord1Reply.status.code).toBe(202);
             const chatRecord2 = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
@@ -588,10 +586,10 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
             });
             const chatRecord2Reply = yield dwn.processMessage(bob.did, chatRecord2.message, { dataStream: chatRecord2.dataStream });
-            expect(chatRecord2Reply.status.code).to.equal(202);
+            expect(chatRecord2Reply.status.code).toBe(202);
             yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                expect(subscriptionChatRecords.size).to.equal(2);
-                expect([...subscriptionChatRecords]).to.have.members([chatRecord1.message.recordId, chatRecord2.message.recordId]);
+                expect(subscriptionChatRecords.size).toBe(2);
+                expect([...subscriptionChatRecords]).toEqual(expect.arrayContaining([chatRecord1.message.recordId, chatRecord2.message.recordId]));
             }));
             yield ((_a = recordsSubscribeByDeviceXReply.subscription) === null || _a === void 0 ? void 0 : _a.close());
         }));
@@ -615,7 +613,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob adds Alice as an admin
             const globalAdminRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -625,7 +623,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('I trust Alice to manage my chat thread'),
             });
             const globalAdminRecordReply = yield dwn.processMessage(bob.did, globalAdminRecord.message, { dataStream: globalAdminRecord.dataStream });
-            expect(globalAdminRecordReply.status.code).to.equal(202);
+            expect(globalAdminRecordReply.status.code).toBe(202);
             // Bob starts a chat thread
             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -633,7 +631,7 @@ export function testAuthorDelegatedGrant() {
                 protocolPath: 'thread',
             });
             const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-            expect(threadRoleReply.status.code).to.equal(202);
+            expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Carol as a participant in the thread
             const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -643,7 +641,7 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId
             });
             const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-            expect(participantRoleReply.status.code).to.equal(202);
+            expect(participantRoleReply.status.code).toBe(202);
             // Carol writes a chat message in the thread
             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: carol,
@@ -654,7 +652,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('A rude message'),
             });
             const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-            expect(chatRecordReply.status.code).to.equal(202);
+            expect(chatRecordReply.status.code).toBe(202);
             // Alice creates a delegated delete grant for device X to act as Alice.
             const deleteGrantForDeviceX = yield PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
@@ -675,15 +673,15 @@ export function testAuthorDelegatedGrant() {
                 recordId: chatRecord.message.recordId
             });
             const carolRecordsDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByCarol.message);
-            expect(carolRecordsDeleteReply.status.code).to.equal(400);
+            expect(carolRecordsDeleteReply.status.code).toBe(400);
             // sanity verify the chat message is still in Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocolPath: 'thread/chat' }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
             // verify device X is able to delete Carol's chat message from Bob's DWN
             const recordsDeleteByDeviceX = yield RecordsDelete.create({
                 signer: Jws.createSigner(deviceX),
@@ -692,11 +690,11 @@ export function testAuthorDelegatedGrant() {
                 recordId: chatRecord.message.recordId
             });
             const deviceXRecordsDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
-            expect(deviceXRecordsDeleteReply.status.code).to.equal(202);
+            expect(deviceXRecordsDeleteReply.status.code).toBe(202);
             // sanity verify the chat message is no longer queryable from Bob's DWN
             const bobRecordsQueryReply2 = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply2.status.code).to.equal(200);
-            expect((_b = bobRecordsQueryReply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+            expect(bobRecordsQueryReply2.status.code).toBe(200);
+            expect((_b = bobRecordsQueryReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
         }));
         it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke write', () => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -716,7 +714,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a non-delegated grant for device X
             const scope = {
                 interface: DwnInterfaceName.Records,
@@ -743,22 +741,170 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(400);
-            expect(deviceXWriteReply.status.detail).to.contain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
+            expect(deviceXWriteReply.status.code).toBe(400);
+            expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
         }));
-        xit('should not allow entity using a non-delegated grant as an author-delegated grant to invoke read', () => __awaiter(this, void 0, void 0, function* () {
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke read', () => __awaiter(this, void 0, void 0, function* () {
+            // scenario:
+            // 1. Bob has the message protocol installed
+            // 2. Alice writes a message to Bob's DWN
+            // 3. Alice creates a non-delegated read grant for device X
+            // 4. Verify that device X cannot read the message from Bob's DWN as Alice using the non-delegated grant
+            const alice = yield TestDataGenerator.generateDidKeyPersona();
+            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            // 1. Bob has the message protocol installed
+            const protocolDefinition = messageProtocolDefinition;
+            const protocol = protocolDefinition.protocol;
+            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                author: bob,
+                protocolDefinition
+            });
+            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            expect(protocolConfigureReply.status.code).toBe(202);
+            // 2. Alice writes a message to Bob's DWN
+            const messageByAlice = yield TestDataGenerator.generateRecordsWrite({
+                author: alice,
+                protocol,
+                protocolPath: 'message',
+                schema: protocolDefinition.types.message.schema,
+                dataFormat: protocolDefinition.types.message.dataFormats[0],
+            });
+            const aliceWriteReply = yield dwn.processMessage(bob.did, messageByAlice.message, { dataStream: messageByAlice.dataStream });
+            expect(aliceWriteReply.status.code).toBe(202);
+            // 3. Alice creates a non-delegated read grant for device X
+            const deviceXGrant = yield PermissionsProtocol.createGrant({
+                // delegated   : true, // intentionally commented out to show that this is not a delegated grant
+                dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
+                grantedTo: deviceX.did,
+                scope: {
+                    interface: DwnInterfaceName.Records,
+                    method: DwnMethodName.Read,
+                    protocol
+                },
+                signer: Jws.createSigner(alice)
+            });
+            // 4. Verify that device X cannot read the message from Bob's DWN as Alice using the non-delegated grant
+            const recordsReadByDeviceX = yield RecordsRead.create({
+                signer: Jws.createSigner(deviceX),
+                delegatedGrant: deviceXGrant.dataEncodedMessage,
+                filter: {
+                    recordId: messageByAlice.message.recordId
+                }
+            });
+            const deviceXReadReply = yield dwn.processMessage(bob.did, recordsReadByDeviceX.message);
+            expect(deviceXReadReply.status.code).toBe(400);
+            expect(deviceXReadReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
         }));
-        xit('should not allow entity using a non-delegated grant as an author-delegated grant to invoke query', () => __awaiter(this, void 0, void 0, function* () {
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke query', () => __awaiter(this, void 0, void 0, function* () {
+            // scenario:
+            // 1. Bob has the message protocol installed
+            // 2. Alice creates a non-delegated query grant for device X
+            // 3. Verify that device X cannot query Bob's DWN as Alice using the non-delegated grant
+            const alice = yield TestDataGenerator.generateDidKeyPersona();
+            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            // 1. Bob has the message protocol installed
+            const protocolDefinition = messageProtocolDefinition;
+            const protocol = protocolDefinition.protocol;
+            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                author: bob,
+                protocolDefinition
+            });
+            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            expect(protocolConfigureReply.status.code).toBe(202);
+            // 2. Alice creates a non-delegated query grant for device X
+            const deviceXGrant = yield PermissionsProtocol.createGrant({
+                // delegated   : true, // intentionally commented out to show that this is not a delegated grant
+                dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
+                grantedTo: deviceX.did,
+                scope: {
+                    interface: DwnInterfaceName.Records,
+                    method: DwnMethodName.Query,
+                    protocol
+                },
+                signer: Jws.createSigner(alice)
+            });
+            // 3. Verify that device X cannot query Bob's DWN as Alice using the non-delegated grant
+            const recordsQueryByDeviceX = yield RecordsQuery.create({
+                signer: Jws.createSigner(deviceX),
+                delegatedGrant: deviceXGrant.dataEncodedMessage,
+                filter: {
+                    protocol,
+                    protocolPath: 'message'
+                }
+            });
+            const deviceXQueryReply = yield dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
+            expect(deviceXQueryReply.status.code).toBe(400);
+            expect(deviceXQueryReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
         }));
-        xit('should not allow entity using a non-delegated grant as an author-delegated grant to invoke delete', () => __awaiter(this, void 0, void 0, function* () {
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke delete', () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // scenario:
+            // 1. Bob has the message protocol installed
+            // 2. Alice writes a message to Bob's DWN
+            // 3. Alice creates a non-delegated delete grant for device X
+            // 4. Verify that device X cannot delete the message from Bob's DWN as Alice using the non-delegated grant
+            // 5. Sanity verify the message still exists in Bob's DWN
+            const alice = yield TestDataGenerator.generateDidKeyPersona();
+            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            // 1. Bob has the message protocol installed
+            const protocolDefinition = messageProtocolDefinition;
+            const protocol = protocolDefinition.protocol;
+            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                author: bob,
+                protocolDefinition
+            });
+            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            expect(protocolConfigureReply.status.code).toBe(202);
+            // 2. Alice writes a message to Bob's DWN
+            const messageByAlice = yield TestDataGenerator.generateRecordsWrite({
+                author: alice,
+                protocol,
+                protocolPath: 'message',
+                schema: protocolDefinition.types.message.schema,
+                dataFormat: protocolDefinition.types.message.dataFormats[0],
+            });
+            const aliceWriteReply = yield dwn.processMessage(bob.did, messageByAlice.message, { dataStream: messageByAlice.dataStream });
+            expect(aliceWriteReply.status.code).toBe(202);
+            // 3. Alice creates a non-delegated delete grant for device X
+            const deviceXGrant = yield PermissionsProtocol.createGrant({
+                // delegated   : true, // intentionally commented out to show that this is not a delegated grant
+                dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
+                grantedTo: deviceX.did,
+                scope: {
+                    interface: DwnInterfaceName.Records,
+                    method: DwnMethodName.Delete,
+                    protocol
+                },
+                signer: Jws.createSigner(alice)
+            });
+            // 4. Verify that device X cannot delete the message from Bob's DWN as Alice using the non-delegated grant
+            const recordsDeleteByDeviceX = yield RecordsDelete.create({
+                signer: Jws.createSigner(deviceX),
+                delegatedGrant: deviceXGrant.dataEncodedMessage,
+                recordId: messageByAlice.message.recordId
+            });
+            const deviceXDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
+            expect(deviceXDeleteReply.status.code).toBe(400);
+            expect(deviceXDeleteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
+            // 5. Sanity verify the message still exists in Bob's DWN
+            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+                author: bob,
+                filter: { protocol }
+            });
+            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
         }));
         it('should fail if author-delegated grant has a mismatching protocol scope - write', () => __awaiter(this, void 0, void 0, function* () {
             // scenario:
@@ -790,7 +936,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // 3. Device X attempts to use the delegated grant to write an email to Bob as Alice
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
@@ -804,8 +950,8 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(401);
-            expect(deviceXWriteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
+            expect(deviceXWriteReply.status.code).toBe(401);
+            expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
         }));
         it('should fail if author-delegated grant has a mismatching protocol scope - query, subscribe & read', () => __awaiter(this, void 0, void 0, function* () {
             // scenario:
@@ -824,7 +970,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob starts a chat thread
             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -832,7 +978,7 @@ export function testAuthorDelegatedGrant() {
                 protocolPath: 'thread',
             });
             const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-            expect(threadRoleReply.status.code).to.equal(202);
+            expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Alice as a participant in the thread
             const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -843,7 +989,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('Alice is my friend'),
             });
             const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-            expect(participantRoleReply.status.code).to.equal(202);
+            expect(participantRoleReply.status.code).toBe(202);
             // Bob writes a chat message in the thread
             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -852,7 +998,7 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
             });
             const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-            expect(chatRecordReply.status.code).to.equal(202);
+            expect(chatRecordReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to act as her for a protocol that is NOT chat protocol
             // Alice creates a delegated query grant for device X to act as Alice but not for chat protocol
             const queryGrantForDeviceX = yield PermissionsProtocol.createGrant({
@@ -903,8 +1049,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const deviceXRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
-            expect(deviceXRecordsQueryReply.status.code).to.equal(401);
-            expect(deviceXRecordsQueryReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationQueryOrSubscribeProtocolScopeMismatch);
+            expect(deviceXRecordsQueryReply.status.code).toBe(401);
+            expect(deviceXRecordsQueryReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationQueryOrSubscribeProtocolScopeMismatch);
             // verify device X reading for the chat message from Bob's DWN fails
             const recordsReadByDeviceX = yield RecordsRead.create({
                 signer: Jws.createSigner(deviceX),
@@ -915,8 +1061,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const deviceXReadReply = yield dwn.processMessage(bob.did, recordsReadByDeviceX.message);
-            expect(deviceXReadReply.status.code).to.equal(401);
-            expect(deviceXReadReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
+            expect(deviceXReadReply.status.code).toBe(401);
+            expect(deviceXReadReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
             // verify device X subscribing to the chat message from Bob's DWN fails
             const recordsSubscribeByDeviceX = yield RecordsSubscribe.create({
                 signer: Jws.createSigner(deviceX),
@@ -929,8 +1075,8 @@ export function testAuthorDelegatedGrant() {
                 }
             });
             const deviceXRecordsSubscribeReply = yield dwn.processMessage(bob.did, recordsSubscribeByDeviceX.message);
-            expect(deviceXRecordsSubscribeReply.status.code).to.equal(401);
-            expect(deviceXRecordsSubscribeReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationQueryOrSubscribeProtocolScopeMismatch);
+            expect(deviceXRecordsSubscribeReply.status.code).toBe(401);
+            expect(deviceXRecordsSubscribeReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationQueryOrSubscribeProtocolScopeMismatch);
         }));
         it('should fail if author-delegated grant has a mismatching protocol scope - delete', () => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -950,7 +1096,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob adds Alice as an admin
             const globalAdminRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -960,7 +1106,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('I trust Alice to manage my chat thread'),
             });
             const globalAdminRecordReply = yield dwn.processMessage(bob.did, globalAdminRecord.message, { dataStream: globalAdminRecord.dataStream });
-            expect(globalAdminRecordReply.status.code).to.equal(202);
+            expect(globalAdminRecordReply.status.code).toBe(202);
             // Bob starts a chat thread
             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -968,7 +1114,7 @@ export function testAuthorDelegatedGrant() {
                 protocolPath: 'thread',
             });
             const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-            expect(threadRoleReply.status.code).to.equal(202);
+            expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Carol as a participant in the thread
             const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: bob,
@@ -978,7 +1124,7 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId
             });
             const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-            expect(participantRoleReply.status.code).to.equal(202);
+            expect(participantRoleReply.status.code).toBe(202);
             // Carol writes a chat message in the thread
             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                 author: carol,
@@ -989,7 +1135,7 @@ export function testAuthorDelegatedGrant() {
                 data: new TextEncoder().encode('A rude message'),
             });
             const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-            expect(chatRecordReply.status.code).to.equal(202);
+            expect(chatRecordReply.status.code).toBe(202);
             // Alice creates a delegated delete grant for Device X to act as her for a protocol that is NOT chat protocol
             const delegatedGrantForDeviceX = yield PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
@@ -1010,16 +1156,16 @@ export function testAuthorDelegatedGrant() {
                 recordId: chatRecord.message.recordId
             });
             const deviceXRecordsDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
-            expect(deviceXRecordsDeleteReply.status.code).to.equal(401);
-            expect(deviceXRecordsDeleteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationDeleteProtocolScopeMismatch);
+            expect(deviceXRecordsDeleteReply.status.code).toBe(401);
+            expect(deviceXRecordsDeleteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationDeleteProtocolScopeMismatch);
             // sanity verify the chat message is still in Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocolPath: 'thread/chat' }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
         }));
         it('should fail if presented with an author-delegated grant with invalid grantor signature - write', () => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -1039,7 +1185,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to write as Alice, but with invalid signature
             const scope = {
                 interface: DwnInterfaceName.Records,
@@ -1068,16 +1214,16 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(401);
-            expect(deviceXWriteReply.status.detail).to.contain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
+            expect(deviceXWriteReply.status.code).toBe(401);
+            expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
         }));
         it('should fail if the CID of the author-delegated grant and the grant ID in the payload of the message signature is mismatching - write', () => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -1097,7 +1243,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates two delegated grants for device X to write as Alice
             const scope = {
                 interface: DwnInterfaceName.Records,
@@ -1133,16 +1279,16 @@ export function testAuthorDelegatedGrant() {
             });
             messageByDeviceX.message.authorization.authorDelegatedGrant = deviceXGrant2.dataEncodedMessage; // intentionally have a mismatching grant
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(400);
-            expect(deviceXWriteReply.status.detail).to.contain(DwnErrorCode.RecordsAuthorDelegatedGrantCidMismatch);
+            expect(deviceXWriteReply.status.code).toBe(400);
+            expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantCidMismatch);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
         }));
         it('should fail if author-delegated grant is revoked - write', () => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -1163,7 +1309,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to write as Alice
             const scope = {
                 interface: DwnInterfaceName.Records,
@@ -1179,7 +1325,7 @@ export function testAuthorDelegatedGrant() {
             });
             const deviceXGrantDataStream = DataStream.fromBytes(deviceXGrant.permissionGrantBytes);
             const permissionGrantWriteReply = yield dwn.processMessage(alice.did, deviceXGrant.recordsWrite.message, { dataStream: deviceXGrantDataStream });
-            expect(permissionGrantWriteReply.status.code).to.equal(202);
+            expect(permissionGrantWriteReply.status.code).toBe(202);
             // 3. Alice revokes the grant
             const permissionRevoke = yield PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
@@ -1187,7 +1333,7 @@ export function testAuthorDelegatedGrant() {
             });
             const revocationDataStream = DataStream.fromBytes(permissionRevoke.permissionRevocationBytes);
             const permissionRevokeReply = yield dwn.processMessage(alice.did, permissionRevoke.recordsWrite.message, { dataStream: revocationDataStream });
-            expect(permissionRevokeReply.status.code).to.equal(202);
+            expect(permissionRevokeReply.status.code).toBe(202);
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using a mismatching delegated grant ID
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
@@ -1201,16 +1347,16 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(401);
-            expect(deviceXWriteReply.status.detail).to.contain(DwnErrorCode.GrantAuthorizationGrantRevoked);
+            expect(deviceXWriteReply.status.code).toBe(401);
+            expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantRevoked);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
         }));
         it('should fail if author-delegated grant is expired - write', () => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -1230,7 +1376,7 @@ export function testAuthorDelegatedGrant() {
                 protocolDefinition
             });
             const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-            expect(protocolConfigureReply.status.code).to.equal(202);
+            expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to write as Alice, but make it expired
             const scope = {
                 interface: DwnInterfaceName.Records,
@@ -1257,17 +1403,17 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
-            expect(deviceXWriteReply.status.code).to.equal(401);
-            expect(deviceXWriteReply.status.detail).to.contain(DwnErrorCode.GrantAuthorizationGrantExpired);
+            expect(deviceXWriteReply.status.code).toBe(401);
+            expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantExpired);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
             const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
             const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
-            expect(bobRecordsQueryReply.status.code).to.equal(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+            expect(bobRecordsQueryReply.status.code).toBe(200);
+            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
         }));
-    }));
+    });
 }
 //# sourceMappingURL=author-delegated-grant.spec.js.map