@enbox/dwn-sdk-js 0.0.2 → 0.0.3

package/dist/esm/tests/features/records-prune.spec.js

@@ -7,39 +7,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import chaiAsPromised from 'chai-as-promised';
+import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' with { type: 'json' };
+import nestedProtocolDefinition from '../vectors/protocol-definitions/nested.json' with { type: 'json' };
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
-import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' assert { type: 'json' };
-import nestedProtocolDefinition from '../vectors/protocol-definitions/nested.json' assert { type: 'json' };
 import { DwnInterfaceName } from '../../src/enums/dwn-interface-method.js';
 import { Message } from '../../src/core/message.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 { DataStream, Dwn, DwnConstant, DwnErrorCode, Jws, ProtocolsConfigure, RecordsDelete, RecordsQuery, RecordsWrite, SortDirection } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-chai.use(chaiAsPromised);
 export function testRecordsPrune() {
     describe('records pruning', () => {
         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
@@ -47,9 +45,9 @@ export function testRecordsPrune() {
             yield messageStore.clear();
             yield dataStore.clear();
             yield resumableTaskStore.clear();
-            yield eventLog.clear();
+            yield stateIndex.clear();
         }));
-        after(() => __awaiter(this, void 0, void 0, function* () {
+        afterAll(() => __awaiter(this, void 0, void 0, function* () {
             yield dwn.close();
         }));
         it('should prune all descendants when given RecordsDelete with `prune` set to `true`', () => __awaiter(this, void 0, void 0, function* () {
@@ -62,7 +60,7 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // writes 2 foos, 2 bars under foo1, and 2 bazes under bar1
             // write 2 foos
             const fooData = TestDataGenerator.randomBytes(100);
@@ -76,10 +74,10 @@ export function testRecordsPrune() {
             };
             const foo1 = yield RecordsWrite.create(fooOptions);
             const foo1WriteResponse = yield dwn.processMessage(alice.did, foo1.message, { dataStream: DataStream.fromBytes(fooData) });
-            expect(foo1WriteResponse.status.code).equals(202);
+            expect(foo1WriteResponse.status.code).toBe(202);
             const foo2 = yield RecordsWrite.create(fooOptions);
             const foo2WriteResponse = yield dwn.processMessage(alice.did, foo2.message, { dataStream: DataStream.fromBytes(fooData) });
-            expect(foo2WriteResponse.status.code).equals(202);
+            expect(foo2WriteResponse.status.code).toBe(202);
             // write 2 bars under foo1 with data large enough to be required to be stored in the data store so we can test purge in data store
             const barData = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
             const barOptions = {
@@ -93,10 +91,10 @@ export function testRecordsPrune() {
             };
             const bar1 = yield RecordsWrite.create(Object.assign({}, barOptions));
             const bar1WriteResponse = yield dwn.processMessage(alice.did, bar1.message, { dataStream: DataStream.fromBytes(barData) });
-            expect(bar1WriteResponse.status.code).equals(202);
+            expect(bar1WriteResponse.status.code).toBe(202);
             const bar2 = yield RecordsWrite.create(Object.assign({}, barOptions));
             const bar2WriteResponse = yield dwn.processMessage(alice.did, bar2.message, { dataStream: DataStream.fromBytes(barData) });
-            expect(bar2WriteResponse.status.code).equals(202);
+            expect(bar2WriteResponse.status.code).toBe(202);
             // write 2 bazes under bar1, each has more than 1 message associated with the record so we can test multi-message purge
             const bazData = TestDataGenerator.randomBytes(100);
             const bazOptions = {
@@ -110,10 +108,10 @@ export function testRecordsPrune() {
             };
             const baz1 = yield RecordsWrite.create(Object.assign({}, bazOptions));
             const baz1WriteResponse = yield dwn.processMessage(alice.did, baz1.message, { dataStream: DataStream.fromBytes(bazData) });
-            expect(baz1WriteResponse.status.code).equals(202);
+            expect(baz1WriteResponse.status.code).toBe(202);
             const baz2 = yield RecordsWrite.create(Object.assign({}, bazOptions));
             const baz2WriteResponse = yield dwn.processMessage(alice.did, baz2.message, { dataStream: DataStream.fromBytes(bazData) });
-            expect(baz2WriteResponse.status.code).equals(202);
+            expect(baz2WriteResponse.status.code).toBe(202);
             // make latest state of baz1 a `RecordsWrite`
             const newBaz1Data = TestDataGenerator.randomBytes(100);
             const baz1Update = yield RecordsWrite.createFrom({
@@ -122,29 +120,30 @@ export function testRecordsPrune() {
                 data: newBaz1Data
             });
             const baz1UpdateResponse = yield dwn.processMessage(alice.did, baz1Update.message, { dataStream: DataStream.fromBytes(newBaz1Data) });
-            expect(baz1UpdateResponse.status.code).equals(202);
+            expect(baz1UpdateResponse.status.code).toBe(202);
             // make latest state of baz2 a `RecordsDelete`
             const baz2Delete = yield RecordsDelete.create({
                 signer: Jws.createSigner(alice),
                 recordId: baz2.message.recordId
             });
             const baz2DeleteResponse = yield dwn.processMessage(alice.did, baz2Delete.message);
-            expect(baz2DeleteResponse.status.code).equals(202);
+            expect(baz2DeleteResponse.status.code).toBe(202);
             // sanity test messages are inserted in message store
             const queryFilter = [{
                     interface: DwnInterfaceName.Records,
                     protocol: nestedProtocol.protocol
                 }];
             const queryResult = yield messageStore.query(alice.did, queryFilter);
-            expect(queryResult.messages.length).to.equal(8); // 2 foos, 2 bars, 2 bazes x 2 messages each
-            // sanity test events are inserted in event log
-            const { events } = yield eventLog.queryEvents(alice.did, queryFilter);
-            expect(events.length).to.equal(8);
+            expect(queryResult.messages.length).toBe(8); // 2 foos, 2 bars, 2 bazes x 2 messages each
+            // sanity test events are inserted in state index
+            // NOTE: getLeaves returns ALL messageCids (including ProtocolsConfigure), so count is 9 not 8
+            const events = yield stateIndex.getLeaves(alice.did, []);
+            expect(events.length).toBe(9);
             // sanity test data is inserted in data store
             const bar1DataGetResult = yield dataStore.get(alice.did, bar1.message.recordId, bar1.message.descriptor.dataCid);
             const bar2DataGetResult = yield dataStore.get(alice.did, bar2.message.recordId, bar2.message.descriptor.dataCid);
-            expect(bar1DataGetResult).to.not.be.undefined;
-            expect(bar2DataGetResult).to.not.be.undefined;
+            expect(bar1DataGetResult).toBeDefined();
+            expect(bar2DataGetResult).toBeDefined();
             // Delete foo1 with prune enabled
             const foo1Delete = yield RecordsDelete.create({
                 recordId: foo1.message.recordId,
@@ -152,34 +151,35 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const deleteReply = yield dwn.processMessage(alice.did, foo1Delete.message);
-            expect(deleteReply.status.code).to.equal(202);
+            expect(deleteReply.status.code).toBe(202);
             // verify all bar and baz message are permanently deleted
             const queryResult2 = yield messageStore.query(alice.did, queryFilter, { messageTimestamp: SortDirection.Ascending });
-            expect(queryResult2.messages.length).to.equal(3); // foo2 RecordsWrite, foo1 RecordsWrite and RecordsDelete
-            expect(queryResult2.messages[0]).to.deep.include(foo1.message);
-            expect(queryResult2.messages[1]).to.deep.include(foo2.message);
-            expect(queryResult2.messages[2]).to.deep.include(foo1Delete.message);
+            expect(queryResult2.messages.length).toBe(3); // foo2 RecordsWrite, foo1 RecordsWrite and RecordsDelete
+            expect(queryResult2.messages[0]).toEqual(expect.objectContaining(foo1.message));
+            expect(queryResult2.messages[1]).toEqual(expect.objectContaining(foo2.message));
+            expect(queryResult2.messages[2]).toEqual(expect.objectContaining(foo1Delete.message));
             // verify all bar and baz events are permanently deleted
-            const { events: events2 } = yield eventLog.queryEvents(alice.did, queryFilter);
-            expect(events2.length).to.equal(3);
+            // NOTE: getLeaves returns ALL messageCids (including ProtocolsConfigure), so count is 4 not 3
+            const events2 = yield stateIndex.getLeaves(alice.did, []);
+            expect(events2.length).toBe(4);
             const foo1RecordsWriteCid = yield Message.getCid(foo1.message);
             const foo2RecordsWriteCid = yield Message.getCid(foo2.message);
             const foo2RecordsDeleteCid = yield Message.getCid(foo1Delete.message);
-            expect(events2).to.contain.members([foo1RecordsWriteCid, foo2RecordsWriteCid, foo2RecordsDeleteCid]);
+            expect(events2).toEqual(expect.arrayContaining([foo1RecordsWriteCid, foo2RecordsWriteCid, foo2RecordsDeleteCid]));
             // verify all bar data are permanently deleted
             const bar1DataGetResult2 = yield dataStore.get(alice.did, bar1.message.recordId, bar1.message.descriptor.dataCid);
             const bar2DataGetResult2 = yield dataStore.get(alice.did, bar2.message.recordId, bar2.message.descriptor.dataCid);
-            expect(bar1DataGetResult2).to.be.undefined;
-            expect(bar2DataGetResult2).to.be.undefined;
+            expect(bar1DataGetResult2).toBeUndefined();
+            expect(bar2DataGetResult2).toBeUndefined();
             // sanity test an external query will no longer return the deleted records
             const queryData = yield RecordsQuery.create({
                 signer: Jws.createSigner(alice),
                 filter: { protocol: nestedProtocol.protocol }
             });
             const reply2 = yield dwn.processMessage(alice.did, queryData.message);
-            expect(reply2.status.code).to.equal(200);
-            expect((_a = reply2.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1); // only foo2 is left
-            expect(reply2.entries[0]).to.deep.include(foo2.message);
+            expect(reply2.status.code).toBe(200);
+            expect((_a = reply2.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1); // only foo2 is left
+            expect(reply2.entries[0]).toEqual(expect.objectContaining(foo2.message));
         }));
         it('should allow pruning against a deleted record that is not already pruned', () => __awaiter(this, void 0, void 0, function* () {
             // Scenario:
@@ -195,7 +195,7 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // 1. Alice has a record `foo` with a descendent chain
             // write foo <- bar <- baz records
             const fooData = TestDataGenerator.randomBytes(100);
@@ -209,7 +209,7 @@ export function testRecordsPrune() {
             };
             const foo = yield RecordsWrite.create(fooOptions);
             const fooWriteResponse = yield dwn.processMessage(alice.did, foo.message, { dataStream: DataStream.fromBytes(fooData) });
-            expect(fooWriteResponse.status.code).equals(202);
+            expect(fooWriteResponse.status.code).toBe(202);
             const barData = TestDataGenerator.randomBytes(100);
             const barOptions = {
                 signer: Jws.createSigner(alice),
@@ -222,7 +222,7 @@ export function testRecordsPrune() {
             };
             const bar = yield RecordsWrite.create(Object.assign({}, barOptions));
             const barWriteResponse = yield dwn.processMessage(alice.did, bar.message, { dataStream: DataStream.fromBytes(barData) });
-            expect(barWriteResponse.status.code).equals(202);
+            expect(barWriteResponse.status.code).toBe(202);
             const bazData = TestDataGenerator.randomBytes(100);
             const bazOptions = {
                 signer: Jws.createSigner(alice),
@@ -235,22 +235,22 @@ export function testRecordsPrune() {
             };
             const baz = yield RecordsWrite.create(Object.assign({}, bazOptions));
             const bazWriteResponse = yield dwn.processMessage(alice.did, baz.message, { dataStream: DataStream.fromBytes(bazData) });
-            expect(bazWriteResponse.status.code).equals(202);
+            expect(bazWriteResponse.status.code).toBe(202);
             // sanity records are inserted in message store
             const queryFilter = [{
                     interface: DwnInterfaceName.Records,
                     protocol: nestedProtocol.protocol
                 }];
             const messagesBeforeDelete = yield messageStore.query(alice.did, queryFilter);
-            expect(messagesBeforeDelete.messages.length).to.equal(3);
+            expect(messagesBeforeDelete.messages.length).toBe(3);
             // sanity verify RecordsQuery returns no records
             const recordsQuery = yield RecordsQuery.create({
                 signer: Jws.createSigner(alice),
                 filter: { protocol: nestedProtocol.protocol }
             });
             const recordsQueryBeforeDeleteReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-            expect(recordsQueryBeforeDeleteReply.status.code).to.equal(200);
-            expect((_a = recordsQueryBeforeDeleteReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(3);
+            expect(recordsQueryBeforeDeleteReply.status.code).toBe(200);
+            expect((_a = recordsQueryBeforeDeleteReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
             // 2. Alice deletes the record `foo` WITHOUT prune, leaving the descendants intact
             const fooDelete = yield RecordsDelete.create({
                 recordId: foo.message.recordId,
@@ -258,14 +258,14 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const deleteReply = yield dwn.processMessage(alice.did, fooDelete.message);
-            expect(deleteReply.status.code).to.equal(202);
+            expect(deleteReply.status.code).toBe(202);
             // verify bar and baz messages still exists
             const messagesAfterDelete = yield messageStore.query(alice.did, queryFilter, { messageTimestamp: SortDirection.Ascending });
-            expect(messagesAfterDelete.messages.length).to.equal(4); // RecordsWrite for foo, bar, baz, and RecordsDelete for foo
+            expect(messagesAfterDelete.messages.length).toBe(4); // RecordsWrite for foo, bar, baz, and RecordsDelete for foo
             // sanity verify RecordsQuery returns the descendants
             const recordsQueryAfterDeleteReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-            expect(recordsQueryAfterDeleteReply.status.code).to.equal(200);
-            expect((_b = recordsQueryAfterDeleteReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
+            expect(recordsQueryAfterDeleteReply.status.code).toBe(200);
+            expect((_b = recordsQueryAfterDeleteReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
             // 3. Verify that Alice is able to perform a prune on `foo` to delete all its descendants
             const fooPrune = yield RecordsDelete.create({
                 recordId: foo.message.recordId,
@@ -273,16 +273,16 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const pruneReply = yield dwn.processMessage(alice.did, fooPrune.message);
-            expect(pruneReply.status.code).to.equal(202);
+            expect(pruneReply.status.code).toBe(202);
             // verify bar and baz messages are permanently deleted
             const messagesAfterPrune = yield messageStore.query(alice.did, queryFilter, { messageTimestamp: SortDirection.Ascending });
-            expect(messagesAfterPrune.messages.length).to.equal(2); // just RecordsWrite and RecordsDelete for foo
-            expect(messagesAfterPrune.messages[0]).to.deep.include(foo.message);
-            expect(messagesAfterPrune.messages[1]).to.deep.include(fooPrune.message);
+            expect(messagesAfterPrune.messages.length).toBe(2); // just RecordsWrite and RecordsDelete for foo
+            expect(messagesAfterPrune.messages[0]).toEqual(expect.objectContaining(foo.message));
+            expect(messagesAfterPrune.messages[1]).toEqual(expect.objectContaining(fooPrune.message));
             // sanity verify RecordsQuery returns no records
             const recordsQueryAfterPruneReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-            expect(recordsQueryAfterPruneReply.status.code).to.equal(200);
-            expect((_c = recordsQueryAfterPruneReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+            expect(recordsQueryAfterPruneReply.status.code).toBe(200);
+            expect((_c = recordsQueryAfterPruneReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
         }));
         it('should return 404 when attempting to prune against a record that is already pruned', () => __awaiter(this, void 0, void 0, function* () {
             // Scenario:
@@ -298,7 +298,7 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-            expect(protocolsConfigureReply.status.code).to.equal(202);
+            expect(protocolsConfigureReply.status.code).toBe(202);
             // 1. Alice has a record `foo` with a descendent chain
             // write foo <- bar <- baz records
             const fooData = TestDataGenerator.randomBytes(100);
@@ -312,7 +312,7 @@ export function testRecordsPrune() {
             };
             const foo = yield RecordsWrite.create(fooOptions);
             const fooWriteResponse = yield dwn.processMessage(alice.did, foo.message, { dataStream: DataStream.fromBytes(fooData) });
-            expect(fooWriteResponse.status.code).equals(202);
+            expect(fooWriteResponse.status.code).toBe(202);
             const barData = TestDataGenerator.randomBytes(100);
             const barOptions = {
                 signer: Jws.createSigner(alice),
@@ -325,7 +325,7 @@ export function testRecordsPrune() {
             };
             const bar = yield RecordsWrite.create(Object.assign({}, barOptions));
             const barWriteResponse = yield dwn.processMessage(alice.did, bar.message, { dataStream: DataStream.fromBytes(barData) });
-            expect(barWriteResponse.status.code).equals(202);
+            expect(barWriteResponse.status.code).toBe(202);
             const bazData = TestDataGenerator.randomBytes(100);
             const bazOptions = {
                 signer: Jws.createSigner(alice),
@@ -338,22 +338,22 @@ export function testRecordsPrune() {
             };
             const baz = yield RecordsWrite.create(Object.assign({}, bazOptions));
             const bazWriteResponse = yield dwn.processMessage(alice.did, baz.message, { dataStream: DataStream.fromBytes(bazData) });
-            expect(bazWriteResponse.status.code).equals(202);
+            expect(bazWriteResponse.status.code).toBe(202);
             // sanity records are inserted in message store
             const queryFilter = [{
                     interface: DwnInterfaceName.Records,
                     protocol: nestedProtocol.protocol
                 }];
             const queryResult = yield messageStore.query(alice.did, queryFilter);
-            expect(queryResult.messages.length).to.equal(3);
+            expect(queryResult.messages.length).toBe(3);
             // sanity verify RecordsQuery returns no records
             const recordsQuery = yield RecordsQuery.create({
                 signer: Jws.createSigner(alice),
                 filter: { protocol: nestedProtocol.protocol }
             });
             const recordsQueryBeforeDeleteReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-            expect(recordsQueryBeforeDeleteReply.status.code).to.equal(200);
-            expect((_a = recordsQueryBeforeDeleteReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(3);
+            expect(recordsQueryBeforeDeleteReply.status.code).toBe(200);
+            expect((_a = recordsQueryBeforeDeleteReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
             // 2. Alice prunes the record `foo`
             const fooPrune1 = yield RecordsDelete.create({
                 recordId: foo.message.recordId,
@@ -361,7 +361,7 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const prune1Reply = yield dwn.processMessage(alice.did, fooPrune1.message);
-            expect(prune1Reply.status.code).to.equal(202);
+            expect(prune1Reply.status.code).toBe(202);
             // 3. Verify that Alice is unable to perform a prune on `foo` again
             const fooPrune2 = yield RecordsDelete.create({
                 recordId: foo.message.recordId,
@@ -369,7 +369,7 @@ export function testRecordsPrune() {
                 signer: Jws.createSigner(alice)
             });
             const prune2Reply = yield dwn.processMessage(alice.did, fooPrune2.message);
-            expect(prune2Reply.status.code).to.equal(404);
+            expect(prune2Reply.status.code).toBe(404);
         }));
         describe('prune and co-prune protocol action', () => {
             it('should only allow a non-owner author to prune if `prune` is allowed and set to `true` in RecordsDelete', () => __awaiter(this, void 0, void 0, function* () {
@@ -422,7 +422,7 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 // 2. Bob writes a record + a descendant in Alice's DWN.
                 const postData = TestDataGenerator.randomBytes(100);
                 const postOptions = {
@@ -434,7 +434,7 @@ export function testRecordsPrune() {
                 };
                 const post = yield RecordsWrite.create(postOptions);
                 const postWriteResponse = yield dwn.processMessage(alice.did, post.message, { dataStream: DataStream.fromBytes(postData) });
-                expect(postWriteResponse.status.code).equals(202);
+                expect(postWriteResponse.status.code).toBe(202);
                 const attachmentData = TestDataGenerator.randomBytes(100);
                 const attachmentOptions = {
                     signer: Jws.createSigner(bob),
@@ -446,7 +446,7 @@ export function testRecordsPrune() {
                 };
                 const attachment = yield RecordsWrite.create(attachmentOptions);
                 const attachmentWriteResponse = yield dwn.processMessage(alice.did, attachment.message, { dataStream: DataStream.fromBytes(attachmentData) });
-                expect(attachmentWriteResponse.status.code).equals(202);
+                expect(attachmentWriteResponse.status.code).toBe(202);
                 // 3. Verify Bob cannot prune the records if `prune` is not set to `true` in RecordsDelete.
                 const unauthorizedPostPrune = yield RecordsDelete.create({
                     recordId: post.message.recordId,
@@ -454,8 +454,8 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(bob)
                 });
                 const unauthorizedPostPruneReply = yield dwn.processMessage(alice.did, unauthorizedPostPrune.message);
-                expect(unauthorizedPostPruneReply.status.code).to.equal(401);
-                expect(unauthorizedPostPruneReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                expect(unauthorizedPostPruneReply.status.code).toBe(401);
+                expect(unauthorizedPostPruneReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 // 4. Verify Bob can prune the records by setting `prune` to `true` in RecordsDelete.
                 const postPrune = yield RecordsDelete.create({
                     recordId: post.message.recordId,
@@ -463,15 +463,15 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(bob)
                 });
                 const pruneReply = yield dwn.processMessage(alice.did, postPrune.message);
-                expect(pruneReply.status.code).to.equal(202);
+                expect(pruneReply.status.code).toBe(202);
                 // sanity test `RecordsQuery` no longer returns the deleted record
                 const recordsQuery = yield RecordsQuery.create({
                     signer: Jws.createSigner(bob),
                     filter: { protocol: protocolDefinition.protocol }
                 });
                 const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
             }));
             it('should not allow a non-owner author to prune if `prune` is not an authorized action', () => __awaiter(this, void 0, void 0, function* () {
                 // Scenario:
@@ -488,7 +488,7 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 // 2. Bob writes a record + a descendant in Alice's DWN.
                 const messageData = TestDataGenerator.randomBytes(100);
                 const messageOptions = {
@@ -501,7 +501,7 @@ export function testRecordsPrune() {
                 };
                 const message = yield RecordsWrite.create(messageOptions);
                 const messageWriteResponse = yield dwn.processMessage(alice.did, message.message, { dataStream: DataStream.fromBytes(messageData) });
-                expect(messageWriteResponse.status.code).equals(202);
+                expect(messageWriteResponse.status.code).toBe(202);
                 const attachmentData = TestDataGenerator.randomBytes(100);
                 const attachmentOptions = {
                     signer: Jws.createSigner(bob),
@@ -513,7 +513,7 @@ export function testRecordsPrune() {
                 };
                 const attachment = yield RecordsWrite.create(attachmentOptions);
                 const attachmentWriteResponse = yield dwn.processMessage(alice.did, attachment.message, { dataStream: DataStream.fromBytes(attachmentData) });
-                expect(attachmentWriteResponse.status.code).equals(202);
+                expect(attachmentWriteResponse.status.code).toBe(202);
                 // 3. Verify Bob cannot prune the records.
                 const messagePrune = yield RecordsDelete.create({
                     recordId: message.message.recordId,
@@ -521,16 +521,16 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(bob)
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, messagePrune.message);
-                expect(deleteReply.status.code).to.equal(401);
-                expect(deleteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                expect(deleteReply.status.code).toBe(401);
+                expect(deleteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 // sanity test `RecordsQuery` still returns the records
                 const recordsQuery = yield RecordsQuery.create({
                     signer: Jws.createSigner(alice),
                     filter: { protocol: protocolDefinition.protocol }
                 });
                 const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
             }));
             it('should allow a non-author to prune if `co-prune` is allowed and `prune` is set to `true` in RecordsDelete', () => __awaiter(this, void 0, void 0, function* () {
                 // Scenario:
@@ -581,7 +581,7 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 // 2. Bob writes a record + a descendant in Alice's DWN.
                 const postData = TestDataGenerator.randomBytes(100);
                 const postOptions = {
@@ -593,7 +593,7 @@ export function testRecordsPrune() {
                 };
                 const post = yield RecordsWrite.create(postOptions);
                 const postWriteResponse = yield dwn.processMessage(alice.did, post.message, { dataStream: DataStream.fromBytes(postData) });
-                expect(postWriteResponse.status.code).equals(202);
+                expect(postWriteResponse.status.code).toBe(202);
                 const attachmentData = TestDataGenerator.randomBytes(100);
                 const attachmentOptions = {
                     signer: Jws.createSigner(bob),
@@ -605,7 +605,7 @@ export function testRecordsPrune() {
                 };
                 const attachment = yield RecordsWrite.create(attachmentOptions);
                 const attachmentWriteResponse = yield dwn.processMessage(alice.did, attachment.message, { dataStream: DataStream.fromBytes(attachmentData) });
-                expect(attachmentWriteResponse.status.code).equals(202);
+                expect(attachmentWriteResponse.status.code).toBe(202);
                 // 3. Verify Carol cannot prune the records if `prune` is not set to `true` in RecordsDelete.
                 const unauthorizedPostPrune = yield RecordsDelete.create({
                     recordId: post.message.recordId,
@@ -613,8 +613,8 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(carol)
                 });
                 const unauthorizedPostPruneReply = yield dwn.processMessage(alice.did, unauthorizedPostPrune.message);
-                expect(unauthorizedPostPruneReply.status.code).to.equal(401);
-                expect(unauthorizedPostPruneReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                expect(unauthorizedPostPruneReply.status.code).toBe(401);
+                expect(unauthorizedPostPruneReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 // 4. Verify Carol can prune the records by setting `prune` to `true` in RecordsDelete.
                 const postPrune = yield RecordsDelete.create({
                     recordId: post.message.recordId,
@@ -622,15 +622,15 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(carol)
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, postPrune.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 // sanity test `RecordsQuery` no longer returns the deleted record
                 const recordsQuery = yield RecordsQuery.create({
                     signer: Jws.createSigner(bob),
                     filter: { protocol: protocolDefinition.protocol }
                 });
                 const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
             }));
             it('should not allow a non-author to prune if `prune` is allowed but `co-prune` is not allowed', () => __awaiter(this, void 0, void 0, function* () {
                 // Scenario:
@@ -682,7 +682,7 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 // 2. Bob writes a record + a descendant in Alice's DWN.
                 const postData = TestDataGenerator.randomBytes(100);
                 const postOptions = {
@@ -694,7 +694,7 @@ export function testRecordsPrune() {
                 };
                 const post = yield RecordsWrite.create(postOptions);
                 const postWriteResponse = yield dwn.processMessage(alice.did, post.message, { dataStream: DataStream.fromBytes(postData) });
-                expect(postWriteResponse.status.code).equals(202);
+                expect(postWriteResponse.status.code).toBe(202);
                 const attachmentData = TestDataGenerator.randomBytes(100);
                 const attachmentOptions = {
                     signer: Jws.createSigner(bob),
@@ -706,7 +706,7 @@ export function testRecordsPrune() {
                 };
                 const attachment = yield RecordsWrite.create(attachmentOptions);
                 const attachmentWriteResponse = yield dwn.processMessage(alice.did, attachment.message, { dataStream: DataStream.fromBytes(attachmentData) });
-                expect(attachmentWriteResponse.status.code).equals(202);
+                expect(attachmentWriteResponse.status.code).toBe(202);
                 // 3. Verify Carol cannot prune the records.
                 const postPrune = yield RecordsDelete.create({
                     recordId: post.message.recordId,
@@ -714,16 +714,16 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(carol)
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, postPrune.message);
-                expect(deleteReply.status.code).to.equal(401);
-                expect(deleteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                expect(deleteReply.status.code).toBe(401);
+                expect(deleteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 // sanity test `RecordsQuery` still returns the records
                 const recordsQuery = yield RecordsQuery.create({
                     signer: Jws.createSigner(bob),
                     filter: { protocol: protocolDefinition.protocol }
                 });
                 const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
             }));
             it('should throw if only `delete` is allowed but received a RecordsDelete with `prune` set to `true`', () => __awaiter(this, void 0, void 0, function* () {
                 // Scenario:
@@ -771,7 +771,7 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 // 2. Bob writes a record + a descendant in Alice's DWN.
                 const postData = TestDataGenerator.randomBytes(100);
                 const postOptions = {
@@ -783,7 +783,7 @@ export function testRecordsPrune() {
                 };
                 const post = yield RecordsWrite.create(postOptions);
                 const postWriteResponse = yield dwn.processMessage(alice.did, post.message, { dataStream: DataStream.fromBytes(postData) });
-                expect(postWriteResponse.status.code).equals(202);
+                expect(postWriteResponse.status.code).toBe(202);
                 const attachmentData = TestDataGenerator.randomBytes(100);
                 const attachmentOptions = {
                     signer: Jws.createSigner(bob),
@@ -795,7 +795,7 @@ export function testRecordsPrune() {
                 };
                 const attachment = yield RecordsWrite.create(attachmentOptions);
                 const attachmentWriteResponse = yield dwn.processMessage(alice.did, attachment.message, { dataStream: DataStream.fromBytes(attachmentData) });
-                expect(attachmentWriteResponse.status.code).equals(202);
+                expect(attachmentWriteResponse.status.code).toBe(202);
                 // 3. Verify Bob cannot prune the records.
                 const unauthorizedPostPrune = yield RecordsDelete.create({
                     recordId: post.message.recordId,
@@ -803,8 +803,34 @@ export function testRecordsPrune() {
                     signer: Jws.createSigner(bob)
                 });
                 const unauthorizedPostPruneReply = yield dwn.processMessage(alice.did, unauthorizedPostPrune.message);
-                expect(unauthorizedPostPruneReply.status.code).to.equal(401);
-                expect(unauthorizedPostPruneReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                expect(unauthorizedPostPruneReply.status.code).toBe(401);
+                expect(unauthorizedPostPruneReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+            }));
+            it('should not allow creation of a protocol definition with action rule containing `prune` without `create`', () => __awaiter(this, void 0, void 0, function* () {
+                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const protocolDefinition = {
+                    protocol: 'http://prune-without-create.xyz',
+                    published: true,
+                    types: {
+                        post: {},
+                    },
+                    structure: {
+                        post: {
+                            $actions: [
+                                {
+                                    who: 'anyone',
+                                    can: ['prune'] // intentionally missing `create` action
+                                }
+                            ]
+                        }
+                    }
+                };
+                const protocolsConfigureCreatePromise = ProtocolsConfigure.create({
+                    definition: protocolDefinition,
+                    signer: Jws.createSigner(alice)
+                });
+                yield expect(protocolsConfigureCreatePromise)
+                    .rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidActionPruneWithoutCreate);
             }));
         });
     });