@enbox/dwn-sdk-js 0.0.2 → 0.0.4

package/dist/esm/tests/features/permissions.spec.js

@@ -7,9 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
 import { DataStream } from '../../src/utils/data-stream.js';
 import { Dwn } from '../../src/dwn.js';
 import { Jws } from '../../src/utils/jws.js';
@@ -20,29 +18,29 @@ import { RecordsWrite } from '../../src/interfaces/records-write.js';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 import { DwnErrorCode, DwnInterfaceName, DwnMethodName, Encoder, RecordsQuery, Time } from '../../src/index.js';
-chai.use(chaiAsPromised);
 export function testPermissions() {
-    describe('permissions', () => __awaiter(this, void 0, void 0, function* () {
+    describe('permissions', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
         // so that different test suites can reuse the same backend store for testing
-        before(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
             dataStore = stores.dataStore;
             resumableTaskStore = stores.resumableTaskStore;
-            eventLog = stores.eventLog;
+            stateIndex = stores.stateIndex;
             eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, eventStream, resumableTaskStore });
+            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
         }));
         beforeEach(() => __awaiter(this, void 0, void 0, function* () {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
@@ -50,9 +48,9 @@ export function testPermissions() {
             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* () {
             sinon.restore();
             yield dwn.close();
         }));
@@ -70,7 +68,7 @@ export function testPermissions() {
                     protocol: testProtocol,
                 }
             });
-            expect(requestWrite.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: testProtocol });
+            expect(requestWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: testProtocol });
             // createGrant with a protocol
             const grantWrite = yield PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
@@ -83,14 +81,14 @@ export function testPermissions() {
                     protocol: testProtocol,
                 }
             });
-            expect(grantWrite.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: testProtocol });
+            expect(grantWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: testProtocol });
             // createRevocation with a protocol derived from the grant
             const revokeWrite = yield PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
                 grant: yield PermissionGrant.parse(grantWrite.dataEncodedMessage),
                 dateRevoked: Time.getCurrentTimestamp()
             });
-            expect(revokeWrite.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: testProtocol });
+            expect(revokeWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: testProtocol });
         }));
         it('should normalize the protocol URL in the scope of a Request, Grant, and Revocation', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -106,7 +104,7 @@ export function testPermissions() {
                     protocol: 'any-protocol' // URL will normalize to `http://any-protocol`
                 }
             });
-            expect(requestWrite.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: 'http://any-protocol' });
+            expect(requestWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'http://any-protocol' });
             // createRequest with a protocol that is already normalized to `https://any-protocol`
             const requestWrite2 = yield PermissionsProtocol.createRequest({
                 signer: Jws.createSigner(bob),
@@ -118,7 +116,7 @@ export function testPermissions() {
                     protocol: 'https://any-protocol'
                 }
             });
-            expect(requestWrite2.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: 'https://any-protocol' });
+            expect(requestWrite2.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'https://any-protocol' });
             // createGrant with a protocol that will be normalized to `http://any-protocol`
             const grantWrite = yield PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
@@ -131,7 +129,7 @@ export function testPermissions() {
                     protocol: 'any-protocol' // URL will normalize to `http://any-protocol`
                 }
             });
-            expect(grantWrite.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: 'http://any-protocol' });
+            expect(grantWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'http://any-protocol' });
             // createGrant with a protocol that is already normalized to `https://any-protocol`
             const grantWrite2 = yield PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
@@ -144,7 +142,7 @@ export function testPermissions() {
                     protocol: 'https://any-protocol'
                 }
             });
-            expect(grantWrite2.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: 'https://any-protocol' });
+            expect(grantWrite2.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'https://any-protocol' });
         }));
         it('should derive the grantId and protocol from the grant record when creating a revocation', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -165,7 +163,7 @@ export function testPermissions() {
             const grantWriteReply = yield dwn.processMessage(alice.did, grantWrite.recordsWrite.message, {
                 dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes)
             });
-            expect(grantWriteReply.status.code).to.equal(202);
+            expect(grantWriteReply.status.code).toBe(202);
             // derive the grantId and protocol from the grant record
             const revokeWrite = yield PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
@@ -173,9 +171,9 @@ export function testPermissions() {
                 dateRevoked: Time.getCurrentTimestamp()
             });
             // check that the protocol is in the revocation record's tags
-            expect(revokeWrite.recordsWrite.message.descriptor.tags).to.deep.equal({ protocol: grantProtocol });
+            expect(revokeWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: grantProtocol });
             // check that the revocation's parentId is the grant's recordId
-            expect(revokeWrite.recordsWrite.message.descriptor.parentId).to.equal(grantWrite.recordsWrite.message.recordId);
+            expect(revokeWrite.recordsWrite.message.descriptor.parentId).toBe(grantWrite.recordsWrite.message.recordId);
         }));
         it('should support permission management through use of Request, Grants, and Revocations', () => __awaiter(this, void 0, void 0, function* () {
             // scenario:
@@ -204,7 +202,7 @@ export function testPermissions() {
                 scope: permissionScope
             });
             const requestWriteReply = yield dwn.processMessage(alice.did, requestToAlice.recordsWrite.message, { dataStream: DataStream.fromBytes(requestToAlice.permissionRequestBytes) });
-            expect(requestWriteReply.status.code).to.equal(202);
+            expect(requestWriteReply.status.code).toBe(202);
             // 2. Alice queries her DWN for new permission requests
             const requestQuery = yield RecordsQuery.create({
                 signer: Jws.createSigner(alice),
@@ -216,9 +214,9 @@ export function testPermissions() {
             });
             const requestQueryReply = yield dwn.processMessage(alice.did, requestQuery.message);
             const requestFromBob = (_a = requestQueryReply.entries) === null || _a === void 0 ? void 0 : _a[0];
-            expect(requestQueryReply.status.code).to.equal(200);
-            expect((_b = requestQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            expect(requestFromBob.recordId).to.equal(requestToAlice.recordsWrite.message.recordId);
+            expect(requestQueryReply.status.code).toBe(200);
+            expect((_b = requestQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+            expect(requestFromBob.recordId).toBe(requestToAlice.recordsWrite.message.recordId);
             // 3. Verify a non-owner cannot create a grant for Bob in Alice's DWN
             const decodedRequest = PermissionsProtocol.parseRequest(requestFromBob.encodedData);
             const unauthorizedGrantWrite = yield PermissionsProtocol.createGrant({
@@ -229,8 +227,8 @@ export function testPermissions() {
                 scope: decodedRequest.scope
             });
             const unauthorizedGrantWriteReply = yield dwn.processMessage(alice.did, unauthorizedGrantWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(unauthorizedGrantWrite.permissionGrantBytes) });
-            expect(unauthorizedGrantWriteReply.status.code).to.equal(401);
-            expect(unauthorizedGrantWriteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+            expect(unauthorizedGrantWriteReply.status.code).toBe(401);
+            expect(unauthorizedGrantWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
             // 4. Alice creates a permission grant for Bob in her DWN
             const grantWrite = yield PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
@@ -240,7 +238,7 @@ export function testPermissions() {
                 scope: decodedRequest.scope
             });
             const grantWriteReply = yield dwn.processMessage(alice.did, grantWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes) });
-            expect(grantWriteReply.status.code).to.equal(202);
+            expect(grantWriteReply.status.code).toBe(202);
             // 5. Verify that Bob can query the permission grant from Alice's DWN (even though Alice can also send it directly to Bob)
             const grantQuery = yield RecordsQuery.create({
                 signer: Jws.createSigner(bob),
@@ -252,9 +250,9 @@ export function testPermissions() {
             });
             const grantQueryReply = yield dwn.processMessage(alice.did, grantQuery.message);
             const grantFromBob = (_c = grantQueryReply.entries) === null || _c === void 0 ? void 0 : _c[0];
-            expect(grantQueryReply.status.code).to.equal(200);
-            expect((_d = grantQueryReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(1);
-            expect(grantFromBob.recordId).to.equal(grantWrite.recordsWrite.message.recordId);
+            expect(grantQueryReply.status.code).toBe(200);
+            expect((_d = grantQueryReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+            expect(grantFromBob.recordId).toBe(grantWrite.recordsWrite.message.recordId);
             // 6. Verify that any third-party can fetch revocation of the grant and find it is still active (not revoked)
             const revocationRead = yield RecordsRead.create({
                 signer: Jws.createSigner(bob),
@@ -264,7 +262,7 @@ export function testPermissions() {
                 }
             });
             const revocationReadReply = yield dwn.processMessage(alice.did, revocationRead.message);
-            expect(revocationReadReply.status.code).to.equal(404);
+            expect(revocationReadReply.status.code).toBe(404);
             // 7. Verify that non-owner cannot revoke the grant
             const unauthorizedRevokeWrite = yield PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(bob),
@@ -272,8 +270,8 @@ export function testPermissions() {
                 dateRevoked: Time.getCurrentTimestamp(),
             });
             const unauthorizedRevokeWriteReply = yield dwn.processMessage(alice.did, unauthorizedRevokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(unauthorizedRevokeWrite.permissionRevocationBytes) });
-            expect(unauthorizedRevokeWriteReply.status.code).to.equal(401);
-            expect(unauthorizedGrantWriteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+            expect(unauthorizedRevokeWriteReply.status.code).toBe(401);
+            expect(unauthorizedGrantWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
             // 8. Alice revokes the permission grant for Bob
             const revokeWrite = yield PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
@@ -281,11 +279,11 @@ export function testPermissions() {
                 dateRevoked: Time.getCurrentTimestamp(),
             });
             const revokeWriteReply = yield dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
-            expect(revokeWriteReply.status.code).to.equal(202);
+            expect(revokeWriteReply.status.code).toBe(202);
             // 9. Verify that any third-party can fetch the revocation status of the permission grant
             const revocationReadReply2 = yield dwn.processMessage(alice.did, revocationRead.message);
-            expect(revocationReadReply2.status.code).to.equal(200);
-            expect((_e = revocationReadReply2.entry.recordsWrite) === null || _e === void 0 ? void 0 : _e.recordId).to.equal(revokeWrite.recordsWrite.message.recordId);
+            expect(revocationReadReply2.status.code).toBe(200);
+            expect((_e = revocationReadReply2.entry.recordsWrite) === null || _e === void 0 ? void 0 : _e.recordId).toBe(revokeWrite.recordsWrite.message.recordId);
         }));
         it('should fail if a RecordsPermissionScope in a Request or Grant record is created without a protocol', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -300,7 +298,7 @@ export function testPermissions() {
                 delegated: false,
                 scope: permissionScope // explicity as any to test the validation
             });
-            yield expect(requestWrite).to.eventually.be.rejectedWith(DwnErrorCode.PermissionsProtocolCreateRequestRecordsScopeMissingProtocol);
+            yield expect(requestWrite).rejects.toThrow(DwnErrorCode.PermissionsProtocolCreateRequestRecordsScopeMissingProtocol);
             const grantWrite = PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -308,7 +306,7 @@ export function testPermissions() {
                 grantedTo: bob.did,
                 scope: permissionScope // explicity as any to test the validation
             });
-            yield expect(grantWrite).to.eventually.be.rejectedWith(DwnErrorCode.PermissionsProtocolCreateGrantRecordsScopeMissingProtocol);
+            yield expect(grantWrite).rejects.toThrow(DwnErrorCode.PermissionsProtocolCreateGrantRecordsScopeMissingProtocol);
         }));
         it('should fail if an invalid protocolPath is used during Permissions schema validation', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -318,7 +316,7 @@ export function testPermissions() {
                 protocolPath: 'invalid/path',
                 data: Encoder.stringToBytes(JSON.stringify({}))
             });
-            expect(() => PermissionsProtocol.validateSchema(message, dataBytes)).to.throw(DwnErrorCode.PermissionsProtocolValidateSchemaUnexpectedRecord);
+            expect(() => PermissionsProtocol.validateSchema(message, dataBytes)).toThrow(DwnErrorCode.PermissionsProtocolValidateSchemaUnexpectedRecord);
         }));
         it('performs additional validation to the tagged protocol in a Revocation message ensuring it matches the Grant it is revoking', () => __awaiter(this, void 0, void 0, function* () {
             // scenario:
@@ -345,7 +343,7 @@ export function testPermissions() {
             const grantWriteReply = yield dwn.processMessage(alice.did, grantWrite.recordsWrite.message, {
                 dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes)
             });
-            expect(grantWriteReply.status.code).to.equal(202);
+            expect(grantWriteReply.status.code).toBe(202);
             // attempt to revoke the grant without a protocol set
             const permissionRevocationBytes = Encoder.objectToBytes({ description: 'Revoking the grant' });
             const revokeWithoutProtocolRecordsWrite = yield RecordsWrite.create({
@@ -359,9 +357,9 @@ export function testPermissions() {
             const revokeWriteWithoutProtocolReply = yield dwn.processMessage(alice.did, revokeWithoutProtocolRecordsWrite.message, {
                 dataStream: DataStream.fromBytes(permissionRevocationBytes)
             });
-            expect(revokeWriteWithoutProtocolReply.status.code).to.equal(400);
-            expect(revokeWriteWithoutProtocolReply.status.detail).to.contain(DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch);
-            expect(revokeWriteWithoutProtocolReply.status.detail).to.contain(`Revocation protocol undefined does not match grant protocol ${grantProtocol}`);
+            expect(revokeWriteWithoutProtocolReply.status.code).toBe(400);
+            expect(revokeWriteWithoutProtocolReply.status.detail).toContain(DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch);
+            expect(revokeWriteWithoutProtocolReply.status.detail).toContain(`Revocation protocol undefined does not match grant protocol ${grantProtocol}`);
             // revoke the grant with an invalid protocol
             const revokeWriteWithMissMatchedProtocol = yield RecordsWrite.create({
                 signer: Jws.createSigner(alice),
@@ -375,9 +373,9 @@ export function testPermissions() {
             const revokeWriteWithMissMatchedProtocolReply = yield dwn.processMessage(alice.did, revokeWriteWithMissMatchedProtocol.message, {
                 dataStream: DataStream.fromBytes(permissionRevocationBytes)
             });
-            expect(revokeWriteWithMissMatchedProtocolReply.status.code).to.equal(400);
-            expect(revokeWriteWithMissMatchedProtocolReply.status.detail).to.contain(DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch);
-            expect(revokeWriteWithMissMatchedProtocolReply.status.detail).to.contain(`Revocation protocol ${invalidProtocol} does not match grant protocol ${grantProtocol}`);
+            expect(revokeWriteWithMissMatchedProtocolReply.status.code).toBe(400);
+            expect(revokeWriteWithMissMatchedProtocolReply.status.detail).toContain(DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch);
+            expect(revokeWriteWithMissMatchedProtocolReply.status.detail).toContain(`Revocation protocol ${invalidProtocol} does not match grant protocol ${grantProtocol}`);
             // revoke the grant with a valid protocol
             const revokeWrite = yield RecordsWrite.create({
                 signer: Jws.createSigner(alice),
@@ -391,30 +389,10 @@ export function testPermissions() {
             const revokeWriteReply = yield dwn.processMessage(alice.did, revokeWrite.message, {
                 dataStream: DataStream.fromBytes(permissionRevocationBytes)
             });
-            expect(revokeWriteReply.status.code).to.equal(202);
+            expect(revokeWriteReply.status.code).toBe(202);
         }));
         // These set of tets are primarily to ensure SchemaValidation passes for the various permission request and grant messages and their scopes
         describe('ensure loaded scope properties for permission requests are processed', () => {
-            it('MessagesQuery', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                // create a permission grant with protocol
-                const messagesQueryPermissions = yield PermissionsProtocol.createGrant({
-                    signer: Jws.createSigner(alice),
-                    grantedTo: bob.did,
-                    dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
-                    description: 'Requesting to query from Alice test-context',
-                    scope: {
-                        interface: DwnInterfaceName.Messages,
-                        method: DwnMethodName.Query,
-                        protocol: 'https://example.com/protocol/test',
-                    }
-                });
-                const messagesQueryPermissionsReply = yield dwn.processMessage(alice.did, messagesQueryPermissions.recordsWrite.message, {
-                    dataStream: DataStream.fromBytes(messagesQueryPermissions.permissionGrantBytes)
-                });
-                expect(messagesQueryPermissionsReply.status.code).to.equal(202);
-            }));
             it('MessagesRead', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
@@ -433,7 +411,7 @@ export function testPermissions() {
                 const messagesReadPermissionsReply = yield dwn.processMessage(alice.did, messagesReadPermissions.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(messagesReadPermissions.permissionGrantBytes)
                 });
-                expect(messagesReadPermissionsReply.status.code).to.equal(202);
+                expect(messagesReadPermissionsReply.status.code).toBe(202);
             }));
             it('MessagesSubscribe', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -453,7 +431,7 @@ export function testPermissions() {
                 const messagesSubscribePermissionsReply = yield dwn.processMessage(alice.did, messagesSubscribePermissions.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(messagesSubscribePermissions.permissionGrantBytes)
                 });
-                expect(messagesSubscribePermissionsReply.status.code).to.equal(202);
+                expect(messagesSubscribePermissionsReply.status.code).toBe(202);
             }));
             it('RecordsDelete', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -474,7 +452,7 @@ export function testPermissions() {
                 const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
-                expect(withContextIdReply.status.code).to.equal(202);
+                expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath
                 const withProtocolPath = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -491,7 +469,7 @@ export function testPermissions() {
                 const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
-                expect(withProtocolPathReply.status.code).to.equal(202);
+                expect(withProtocolPathReply.status.code).toBe(202);
             }));
             it('RecordsQuery', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -513,7 +491,7 @@ export function testPermissions() {
                 const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
-                expect(withContextIdReply.status.code).to.equal(202);
+                expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
                 const withProtocolPath = yield PermissionsProtocol.createRequest({
                     signer: Jws.createSigner(bob),
@@ -529,7 +507,7 @@ export function testPermissions() {
                 const withProtocolPathReply = yield dwn.processMessage(bob.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionRequestBytes)
                 });
-                expect(withProtocolPathReply.status.code).to.equal(202);
+                expect(withProtocolPathReply.status.code).toBe(202);
             }));
             it('RecordsRead', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -551,7 +529,7 @@ export function testPermissions() {
                 const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
-                expect(withContextIdReply.status.code).to.equal(202);
+                expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
                 const withProtocolPath = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -569,7 +547,7 @@ export function testPermissions() {
                 const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
-                expect(withProtocolPathReply.status.code).to.equal(202);
+                expect(withProtocolPathReply.status.code).toBe(202);
             }));
             it('RecordsSubscribe', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -591,7 +569,7 @@ export function testPermissions() {
                 const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
-                expect(withContextIdReply.status.code).to.equal(202);
+                expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
                 const withProtocolPath = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -609,7 +587,7 @@ export function testPermissions() {
                 const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
-                expect(withProtocolPathReply.status.code).to.equal(202);
+                expect(withProtocolPathReply.status.code).toBe(202);
             }));
             it('RecordsWrite', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -631,7 +609,7 @@ export function testPermissions() {
                 const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
-                expect(withContextIdReply.status.code).to.equal(202);
+                expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
                 const withProtocolPath = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -649,7 +627,7 @@ export function testPermissions() {
                 const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
-                expect(withProtocolPathReply.status.code).to.equal(202);
+                expect(withProtocolPathReply.status.code).toBe(202);
             }));
             it('ProtocolsQuery', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -668,10 +646,10 @@ export function testPermissions() {
                 const protocolQueryPermissionsReply = yield dwn.processMessage(alice.did, protocolQueryPermissions.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(protocolQueryPermissions.permissionGrantBytes)
                 });
-                expect(protocolQueryPermissionsReply.status.code).to.equal(202);
+                expect(protocolQueryPermissionsReply.status.code).toBe(202);
             }));
         });
-        describe('validateScopeAndTags', () => __awaiter(this, void 0, void 0, function* () {
+        describe('validateScopeAndTags', () => {
             it('should be called for a Request or Grant record', () => __awaiter(this, void 0, void 0, function* () {
                 // spy on `validateScope`
                 const validateScopeSpy = sinon.spy(PermissionsProtocol, 'validateScopeAndTags');
@@ -690,8 +668,8 @@ export function testPermissions() {
                     scope: permissionScope
                 });
                 const requestToAliceReply = yield dwn.processMessage(alice.did, requestToAlice.recordsWrite.message, { dataStream: DataStream.fromBytes(requestToAlice.permissionRequestBytes) });
-                expect(requestToAliceReply.status.code).to.equal(202);
-                expect(validateScopeSpy.calledOnce).to.be.true;
+                expect(requestToAliceReply.status.code).toBe(202);
+                expect(validateScopeSpy.calledOnce).toBe(true);
                 // create a grant
                 const grantedToBob = yield PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
@@ -701,8 +679,8 @@ export function testPermissions() {
                     scope: permissionScope
                 });
                 const grantWriteReply = yield dwn.processMessage(alice.did, grantedToBob.recordsWrite.message, { dataStream: DataStream.fromBytes(grantedToBob.permissionGrantBytes) });
-                expect(grantWriteReply.status.code).to.equal(202);
-                expect(validateScopeSpy.calledTwice).to.be.true; // called twice, once for the request and once for the grant
+                expect(grantWriteReply.status.code).toBe(202);
+                expect(validateScopeSpy.calledTwice).toBe(true); // called twice, once for the request and once for the grant
             }));
             it('should throw if the scope is a RecordsPermissionScope and a protocol tag is not defined on the Request and Grant record', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -719,7 +697,7 @@ export function testPermissions() {
                     data: Encoder.stringToBytes(JSON.stringify({})),
                     tags: { someTag: 'someValue' } // not a protocol tag
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
                 // create a permission grant without a protocol tag
                 const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -728,7 +706,7 @@ export function testPermissions() {
                     data: Encoder.stringToBytes(JSON.stringify({})),
                     tags: { someTag: 'someValue' } // not a protocol tag
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
             }));
             it('should throw if the scope is a RecordsPermissionScope and the Request and Grant record has no tags', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -744,7 +722,7 @@ export function testPermissions() {
                     protocolPath: PermissionsProtocol.requestPath,
                     data: Encoder.stringToBytes(JSON.stringify({}))
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
                 // create a permission grant without a protocol tag
                 const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -752,7 +730,7 @@ export function testPermissions() {
                     protocolPath: PermissionsProtocol.grantPath,
                     data: Encoder.stringToBytes(JSON.stringify({})),
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
             }));
             it('should throw if the protocol tag in the Request and Grant record does not match the protocol defined in the scope', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -770,7 +748,7 @@ export function testPermissions() {
                     data: Encoder.stringToBytes(JSON.stringify({})),
                     tags: { protocol: 'https://example.com/protocol/invalid' }
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch);
                 // create a permission grant with a protocol tag that does not match the scope
                 const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -779,7 +757,7 @@ export function testPermissions() {
                     data: Encoder.stringToBytes(JSON.stringify({})),
                     tags: { protocol: 'https://example.com/protocol/invalid' }
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch);
             }));
             it('should throw if protocolPath and contextId are both defined in the scope for a Request and Grant record', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -798,7 +776,7 @@ export function testPermissions() {
                     data: Encoder.stringToBytes(JSON.stringify({})),
                     tags: { protocol: 'https://example.com/protocol/test' }
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestRecordsWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeContextIdProhibitedProperties);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeContextIdProhibitedProperties);
                 // create a permission grant with a scope that has both protocolPath and contextId
                 const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -807,9 +785,9 @@ export function testPermissions() {
                     data: Encoder.stringToBytes(JSON.stringify({})),
                     tags: { protocol: 'https://example.com/protocol/test' }
                 });
-                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).to.throw(DwnErrorCode.PermissionsProtocolValidateScopeContextIdProhibitedProperties);
+                expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeContextIdProhibitedProperties);
             }));
-        }));
-    }));
+        });
+    });
 }
 //# sourceMappingURL=permissions.spec.js.map