@enbox/dwn-sdk-js 0.0.2 → 0.0.3

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

@@ -8,14 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ResumableTaskManager } from '../../src/core/resumable-task-manager.js';
-import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
-import anyoneCollaborateProtocolDefinition from '../vectors/protocol-definitions/anyone-collaborate.json' assert { type: 'json' };
-import authorCanProtocolDefinition from '../vectors/protocol-definitions/author-can.json' assert { type: 'json' };
-import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' assert { type: 'json' };
-import recipientCanProtocolDefinition from '../vectors/protocol-definitions/recipient-can.json' assert { type: 'json' };
-import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' assert { type: 'json' };
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import anyoneCollaborateProtocolDefinition from '../vectors/protocol-definitions/anyone-collaborate.json' with { type: 'json' };
+import authorCanProtocolDefinition from '../vectors/protocol-definitions/author-can.json' with { type: 'json' };
+import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' with { type: 'json' };
+import recipientCanProtocolDefinition from '../vectors/protocol-definitions/recipient-can.json' with { type: 'json' };
+import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
 import { ArrayUtility } from '../../src/utils/array.js';
 import { DwnErrorCode } from '../../src/core/dwn-error.js';
 import { DwnMethodName } from '../../src/enums/dwn-interface-method.js';
@@ -29,43 +28,42 @@ import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { Time } from '../../src/utils/time.js';
 import { DataStream, Dwn, Encoder, Jws, MessageStoreLevel, RecordsDelete, RecordsRead, RecordsWrite } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-chai.use(chaiAsPromised);
 export function testRecordsDeleteHandler() {
     describe('RecordsDeleteHandler.handle()', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         beforeEach(() => {
             sinon.restore();
         });
-        after(() => {
+        afterAll(() => {
             sinon.restore();
         });
         describe('functional tests', () => {
             // 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* () {
                 // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
                 yield messageStore.clear();
                 yield dataStore.clear();
                 yield resumableTaskStore.clear();
-                yield eventLog.clear();
+                yield stateIndex.clear();
             }));
-            after(() => __awaiter(this, void 0, void 0, function* () {
+            afterAll(() => __awaiter(this, void 0, void 0, function* () {
                 yield dwn.close();
             }));
             it('should handle RecordsDelete successfully and return 404 if deleting a deleted record', () => __awaiter(this, void 0, void 0, function* () {
@@ -74,33 +72,33 @@ export function testRecordsDeleteHandler() {
                 // insert data
                 const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // ensure data is inserted
                 const queryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: message.recordId }
                 });
                 const reply = yield dwn.processMessage(alice.did, queryData.message);
-                expect(reply.status.code).to.equal(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 // testing delete
                 const recordsDelete = yield RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(alice)
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 // ensure a query will no longer find the deleted record
                 const reply2 = yield dwn.processMessage(alice.did, queryData.message);
-                expect(reply2.status.code).to.equal(200);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(reply2.status.code).toBe(200);
+                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
                 // testing deleting a deleted record
                 const recordsDelete2 = yield RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(alice)
                 });
                 const recordsDelete2Reply = yield dwn.processMessage(alice.did, recordsDelete2.message);
-                expect(recordsDelete2Reply.status.code).to.equal(404);
+                expect(recordsDelete2Reply.status.code).toBe(404);
             }));
             it('should not affect other records or tenants with the same data', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -109,26 +107,26 @@ export function testRecordsDeleteHandler() {
                 // alice writes a records with data
                 const aliceWriteData = yield TestDataGenerator.generateRecordsWrite({ author: alice, data });
                 const aliceWriteReply = yield dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
-                expect(aliceWriteReply.status.code).to.equal(202);
+                expect(aliceWriteReply.status.code).toBe(202);
                 // alice writes another record with the same data
                 const aliceWrite2Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, data });
                 const aliceWrite2Reply = yield dwn.processMessage(alice.did, aliceWrite2Data.message, { dataStream: aliceWrite2Data.dataStream });
-                expect(aliceWrite2Reply.status.code).to.equal(202);
+                expect(aliceWrite2Reply.status.code).toBe(202);
                 // bob writes a records with same data
                 const bobWriteData = yield TestDataGenerator.generateRecordsWrite({ author: bob, data });
                 const bobWriteReply = yield dwn.processMessage(bob.did, bobWriteData.message, { dataStream: bobWriteData.dataStream });
-                expect(bobWriteReply.status.code).to.equal(202);
+                expect(bobWriteReply.status.code).toBe(202);
                 // bob writes another record with the same data
                 const bobWrite2Data = yield TestDataGenerator.generateRecordsWrite({ author: bob, data });
                 const bobWrite2Reply = yield dwn.processMessage(bob.did, bobWrite2Data.message, { dataStream: bobWrite2Data.dataStream });
-                expect(bobWrite2Reply.status.code).to.equal(202);
+                expect(bobWrite2Reply.status.code).toBe(202);
                 // alice deletes one of the two records
                 const aliceDeleteWriteData = yield TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: aliceWriteData.message.recordId
                 });
                 const aliceDeleteWriteReply = yield dwn.processMessage(alice.did, aliceDeleteWriteData.message);
-                expect(aliceDeleteWriteReply.status.code).to.equal(202);
+                expect(aliceDeleteWriteReply.status.code).toBe(202);
                 // verify the other record with the same data is unaffected
                 const aliceRead1 = yield RecordsRead.create({
                     filter: {
@@ -137,19 +135,19 @@ export function testRecordsDeleteHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const aliceRead1Reply = yield dwn.processMessage(alice.did, aliceRead1.message);
-                expect(aliceRead1Reply.status.code).to.equal(200);
+                expect(aliceRead1Reply.status.code).toBe(200);
                 const aliceDataFetched = yield DataStream.toBytes(aliceRead1Reply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(aliceDataFetched, data)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(aliceDataFetched, data)).toBe(true);
                 // alice deletes the other record
                 const aliceDeleteWrite2Data = yield TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: aliceWrite2Data.message.recordId
                 });
                 const aliceDeleteWrite2Reply = yield dwn.processMessage(alice.did, aliceDeleteWrite2Data.message);
-                expect(aliceDeleteWrite2Reply.status.code).to.equal(202);
+                expect(aliceDeleteWrite2Reply.status.code).toBe(202);
                 // verify that alice can no longer fetch the 2nd record
                 const aliceRead2Reply = yield dwn.processMessage(alice.did, aliceRead1.message);
-                expect(aliceRead2Reply.status.code).to.equal(404);
+                expect(aliceRead2Reply.status.code).toBe(404);
                 // verify that bob can still fetch record with the same data
                 const bobRead1 = yield RecordsRead.create({
                     filter: {
@@ -158,9 +156,9 @@ export function testRecordsDeleteHandler() {
                     signer: Jws.createSigner(bob)
                 });
                 const bobRead1Reply = yield dwn.processMessage(bob.did, bobRead1.message);
-                expect(bobRead1Reply.status.code).to.equal(200);
+                expect(bobRead1Reply.status.code).toBe(200);
                 const bobDataFetched = yield DataStream.toBytes(bobRead1Reply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(bobDataFetched, data)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(bobDataFetched, data)).toBe(true);
             }));
             it('should return 404 if deleting a non-existent record', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -170,7 +168,7 @@ export function testRecordsDeleteHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(404);
+                expect(deleteReply.status.code).toBe(404);
             }));
             it('should be disallowed if there is a newer RecordsWrite already in the DWN ', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -178,7 +176,7 @@ export function testRecordsDeleteHandler() {
                 // initial write
                 const initialWriteData = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const initialWriteReply = yield dwn.processMessage(alice.did, initialWriteData.message, { dataStream: initialWriteData.dataStream });
-                expect(initialWriteReply.status.code).to.equal(202);
+                expect(initialWriteReply.status.code).toBe(202);
                 // generate subsequent write and delete with the delete having an earlier timestamp
                 // NOTE: creating RecordsDelete first ensures it has an earlier `messageTimestamp` time
                 const recordsDelete = yield RecordsDelete.create({
@@ -192,10 +190,10 @@ export function testRecordsDeleteHandler() {
                 });
                 // subsequent write
                 const subsequentWriteReply = yield dwn.processMessage(alice.did, subsequentWriteData.message, { dataStream: subsequentWriteData.dataStream });
-                expect(subsequentWriteReply.status.code).to.equal(202);
+                expect(subsequentWriteReply.status.code).toBe(202);
                 // test that a delete with an earlier `messageTimestamp` results in a 409
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(409);
+                expect(deleteReply.status.code).toBe(409);
                 // ensure data still exists
                 const queryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -203,9 +201,9 @@ export function testRecordsDeleteHandler() {
                 });
                 const expectedEncodedData = Encoder.bytesToBase64Url(subsequentWriteData.dataBytes);
                 const reply = yield dwn.processMessage(alice.did, queryData.message);
-                expect(reply.status.code).to.equal(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(reply.entries[0].encodedData).to.equal(expectedEncodedData);
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries[0].encodedData).toBe(expectedEncodedData);
             }));
             it('should be able to delete then rewrite the same data', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
@@ -218,44 +216,44 @@ export function testRecordsDeleteHandler() {
                     data
                 });
                 const aliceWriteReply = yield dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
-                expect(aliceWriteReply.status.code).to.equal(202);
+                expect(aliceWriteReply.status.code).toBe(202);
                 const aliceQueryWriteAfterAliceWriteData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceWriteData.message.recordId }
                 });
                 const aliceQueryWriteAfterAliceWriteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceWriteData.message);
-                expect(aliceQueryWriteAfterAliceWriteReply.status.code).to.equal(200);
-                expect((_a = aliceQueryWriteAfterAliceWriteReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(aliceQueryWriteAfterAliceWriteReply.entries[0].encodedData).to.equal(encodedData);
+                expect(aliceQueryWriteAfterAliceWriteReply.status.code).toBe(200);
+                expect((_a = aliceQueryWriteAfterAliceWriteReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(aliceQueryWriteAfterAliceWriteReply.entries[0].encodedData).toBe(encodedData);
                 // alice deleting the record
                 const aliceDeleteWriteData = yield TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: aliceWriteData.message.recordId
                 });
                 const aliceDeleteWriteReply = yield dwn.processMessage(alice.did, aliceDeleteWriteData.message);
-                expect(aliceDeleteWriteReply.status.code).to.equal(202);
+                expect(aliceDeleteWriteReply.status.code).toBe(202);
                 const aliceQueryWriteAfterAliceDeleteData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceWriteData.message.recordId }
                 });
                 const aliceQueryWriteAfterAliceDeleteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceDeleteData.message);
-                expect(aliceQueryWriteAfterAliceDeleteReply.status.code).to.equal(200);
-                expect((_b = aliceQueryWriteAfterAliceDeleteReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(aliceQueryWriteAfterAliceDeleteReply.status.code).toBe(200);
+                expect((_b = aliceQueryWriteAfterAliceDeleteReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
                 // alice writes a new record with the same data
                 const aliceRewriteData = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data
                 });
                 const aliceRewriteReply = yield dwn.processMessage(alice.did, aliceRewriteData.message, { dataStream: aliceRewriteData.dataStream });
-                expect(aliceRewriteReply.status.code).to.equal(202);
+                expect(aliceRewriteReply.status.code).toBe(202);
                 const aliceQueryWriteAfterAliceRewriteData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceRewriteData.message.recordId }
                 });
                 const aliceQueryWriteAfterAliceRewriteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceRewriteData.message);
-                expect(aliceQueryWriteAfterAliceRewriteReply.status.code).to.equal(200);
-                expect((_c = aliceQueryWriteAfterAliceRewriteReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-                expect(aliceQueryWriteAfterAliceRewriteReply.entries[0].encodedData).to.equal(encodedData);
+                expect(aliceQueryWriteAfterAliceRewriteReply.status.code).toBe(200);
+                expect((_c = aliceQueryWriteAfterAliceRewriteReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(aliceQueryWriteAfterAliceRewriteReply.entries[0].encodedData).toBe(encodedData);
             }));
             describe('protocol based deletes', () => {
                 it('should allow delete with allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
@@ -270,7 +268,7 @@ export function testRecordsDeleteHandler() {
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a record
                     const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -278,14 +276,14 @@ export function testRecordsDeleteHandler() {
                         protocolPath: 'doc',
                     });
                     const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
-                    expect(recordsWriteReply.status.code).to.eq(202);
+                    expect(recordsWriteReply.status.code).toBe(202);
                     // Bob (anyone) is able to delete the record
                     const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
                         author: bob,
                         recordId: recordsWrite.message.recordId,
                     });
                     const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                    expect(recordsDeleteReply.status.code).to.eq(202);
+                    expect(recordsDeleteReply.status.code).toBe(202);
                 }));
                 describe('recipient rules', () => {
                     it('should allow delete with ancestor recipient rule', () => __awaiter(this, void 0, void 0, function* () {
@@ -302,7 +300,7 @@ export function testRecordsDeleteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice writes a chat
                         const chatRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -311,7 +309,7 @@ export function testRecordsDeleteHandler() {
                             protocolPath: 'post',
                         });
                         const chatRecordsWriteReply = yield dwn.processMessage(alice.did, chatRecordsWrite.message, { dataStream: chatRecordsWrite.dataStream });
-                        expect(chatRecordsWriteReply.status.code).to.eq(202);
+                        expect(chatRecordsWriteReply.status.code).toBe(202);
                         // Alice writes a 'chat/tag'
                         const tagRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -320,22 +318,22 @@ export function testRecordsDeleteHandler() {
                             parentContextId: chatRecordsWrite.message.contextId,
                         });
                         const tagRecordsWriteReply = yield dwn.processMessage(alice.did, tagRecordsWrite.message, { dataStream: tagRecordsWrite.dataStream });
-                        expect(tagRecordsWriteReply.status.code).to.eq(202);
+                        expect(tagRecordsWriteReply.status.code).toBe(202);
                         // Carol is unable to delete the 'chat/tag'
                         const recordsDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: tagRecordsWrite.message.recordId,
                         });
                         const recordsDeleteCarolReply = yield dwn.processMessage(alice.did, recordsDeleteCarol.message);
-                        expect(recordsDeleteCarolReply.status.code).to.eq(401);
-                        expect(recordsDeleteCarolReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(recordsDeleteCarolReply.status.code).toBe(401);
+                        expect(recordsDeleteCarolReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to delete the 'chat/tag'
                         const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: tagRecordsWrite.message.recordId,
                         });
                         const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                        expect(recordsDeleteReply.status.code).to.eq(202);
+                        expect(recordsDeleteReply.status.code).toBe(202);
                     }));
                     it('should allow delete with direct recipient rule', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice creates a 'post' with Bob as recipient. Bob is able to delete
@@ -351,7 +349,7 @@ export function testRecordsDeleteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a 'post' with Bob as recipient
                         const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -360,22 +358,22 @@ export function testRecordsDeleteHandler() {
                             protocolPath: 'post',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
-                        expect(recordsWriteReply.status.code).to.eq(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Carol is unable to delete the 'post'
                         const carolRecordsDelete = yield TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: recordsWrite.message.recordId,
                         });
                         const carolRecordsDeleteReply = yield dwn.processMessage(alice.did, carolRecordsDelete.message);
-                        expect(carolRecordsDeleteReply.status.code).to.eq(401);
-                        expect(carolRecordsDeleteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(carolRecordsDeleteReply.status.code).toBe(401);
+                        expect(carolRecordsDeleteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to delete the post
                         const bobRecordsDelete = yield TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: recordsWrite.message.recordId,
                         });
                         const bobRecordsDeleteReply = yield dwn.processMessage(alice.did, bobRecordsDelete.message);
-                        expect(bobRecordsDeleteReply.status.code).to.eq(202);
+                        expect(bobRecordsDeleteReply.status.code).toBe(202);
                     }));
                 });
                 describe('author action rules', () => {
@@ -393,7 +391,7 @@ export function testRecordsDeleteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Bob writes a post
                         const postRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -401,7 +399,7 @@ export function testRecordsDeleteHandler() {
                             protocolPath: 'post',
                         });
                         const postRecordsWriteReply = yield dwn.processMessage(alice.did, postRecordsWrite.message, { dataStream: postRecordsWrite.dataStream });
-                        expect(postRecordsWriteReply.status.code).to.eq(202);
+                        expect(postRecordsWriteReply.status.code).toBe(202);
                         // Alice writes a 'post/comment'
                         const commentRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -410,22 +408,22 @@ export function testRecordsDeleteHandler() {
                             parentContextId: postRecordsWrite.message.contextId,
                         });
                         const commentRecordsWriteReply = yield dwn.processMessage(alice.did, commentRecordsWrite.message, { dataStream: commentRecordsWrite.dataStream });
-                        expect(commentRecordsWriteReply.status.code).to.eq(202);
+                        expect(commentRecordsWriteReply.status.code).toBe(202);
                         // Carol is unable to delete Alice's 'post/comment'
                         const recordsDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: commentRecordsWrite.message.recordId,
                         });
                         const recordsDeleteCarolReply = yield dwn.processMessage(alice.did, recordsDeleteCarol.message);
-                        expect(recordsDeleteCarolReply.status.code).to.eq(401);
-                        expect(recordsDeleteCarolReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(recordsDeleteCarolReply.status.code).toBe(401);
+                        expect(recordsDeleteCarolReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to delete the Alice's 'post/comment'
                         const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: commentRecordsWrite.message.recordId,
                         });
                         const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                        expect(recordsDeleteReply.status.code).to.eq(202);
+                        expect(recordsDeleteReply.status.code).toBe(202);
                     }));
                 });
                 describe('role based deletes', () => {
@@ -442,7 +440,7 @@ export function testRecordsDeleteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a thread
                         const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -451,7 +449,7 @@ export function testRecordsDeleteHandler() {
                             protocolPath: 'thread'
                         });
                         const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                        expect(threadRecordReply.status.code).to.equal(202);
+                        expect(threadRecordReply.status.code).toBe(202);
                         // Alice adds Bob as a 'thread/admin' in that thread
                         const participantRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -461,7 +459,7 @@ export function testRecordsDeleteHandler() {
                             parentContextId: threadRecord.message.contextId,
                         });
                         const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
-                        expect(participantRecordReply.status.code).to.equal(202);
+                        expect(participantRecordReply.status.code).toBe(202);
                         // Alice writes a chat message in that thread
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -471,15 +469,15 @@ export function testRecordsDeleteHandler() {
                             parentContextId: threadRecord.message.contextId,
                         });
                         const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                        expect(chatRecordReply.status.code).to.equal(202);
+                        expect(chatRecordReply.status.code).toBe(202);
                         // Verifies that Carol cannot delete without appropriate role
                         const chatDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: chatRecord.message.recordId,
                         });
                         const chatDeleteReplyCarol = yield dwn.processMessage(alice.did, chatDeleteCarol.message);
-                        expect(chatDeleteReplyCarol.status.code).to.eq(401);
-                        expect(chatDeleteReplyCarol.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(chatDeleteReplyCarol.status.code).toBe(401);
+                        expect(chatDeleteReplyCarol.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob invokes the role to delete the chat message
                         const chatDelete = yield TestDataGenerator.generateRecordsDelete({
                             author: bob,
@@ -487,7 +485,7 @@ export function testRecordsDeleteHandler() {
                             protocolRole: 'thread/admin',
                         });
                         const chatDeleteReply = yield dwn.processMessage(alice.did, chatDelete.message);
-                        expect(chatDeleteReply.status.code).to.equal(202);
+                        expect(chatDeleteReply.status.code).toBe(202);
                     }));
                     it('should allow co-delete invoking a root-level role', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice adds Bob as a root-level 'admin' role. She writes a 'chat'.
@@ -501,7 +499,7 @@ export function testRecordsDeleteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice adds Bob as a 'thread/admin' in that thread
                         const participantRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -510,7 +508,7 @@ export function testRecordsDeleteHandler() {
                             protocolPath: 'admin',
                         });
                         const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
-                        expect(participantRecordReply.status.code).to.equal(202);
+                        expect(participantRecordReply.status.code).toBe(202);
                         // Alice writes a chat message in that thread
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -519,15 +517,15 @@ export function testRecordsDeleteHandler() {
                             protocolPath: 'chat',
                         });
                         const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                        expect(chatRecordReply.status.code).to.equal(202);
+                        expect(chatRecordReply.status.code).toBe(202);
                         // Carol is unable to delete the chat message
                         const chatDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: chatRecord.message.recordId,
                         });
                         const chatDeleteCarolReply = yield dwn.processMessage(alice.did, chatDeleteCarol.message);
-                        expect(chatDeleteCarolReply.status.code).to.equal(401);
-                        expect(chatDeleteCarolReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(chatDeleteCarolReply.status.code).toBe(401);
+                        expect(chatDeleteCarolReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob invokes the role to delete the chat message
                         const chatDelete = yield TestDataGenerator.generateRecordsDelete({
                             author: bob,
@@ -535,7 +533,7 @@ export function testRecordsDeleteHandler() {
                             protocolRole: 'admin',
                         });
                         const chatDeleteReply = yield dwn.processMessage(alice.did, chatDelete.message);
-                        expect(chatDeleteReply.status.code).to.equal(202);
+                        expect(chatDeleteReply.status.code).toBe(202);
                     }));
                 });
             });
@@ -547,21 +545,21 @@ export function testRecordsDeleteHandler() {
                     author: alice,
                 });
                 const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
-                expect(recordsWriteReply.status.code).to.equal(202);
+                expect(recordsWriteReply.status.code).toBe(202);
                 const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
                     author: bob,
                     recordId: recordsWrite.message.recordId,
                 });
                 const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(recordsDeleteReply.status.code).to.equal(401);
-                expect(recordsDeleteReply.status.detail).to.contain(DwnErrorCode.RecordsDeleteAuthorizationFailed);
+                expect(recordsDeleteReply.status.code).toBe(401);
+                expect(recordsDeleteReply.status.detail).toContain(DwnErrorCode.RecordsDeleteAuthorizationFailed);
             }));
             it('should index additional properties from the RecordsWrite being deleted', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // initial write
                 const initialWriteData = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'testSchema' });
                 const initialWriteReply = yield dwn.processMessage(alice.did, initialWriteData.message, { dataStream: initialWriteData.dataStream });
-                expect(initialWriteReply.status.code).to.equal(202);
+                expect(initialWriteReply.status.code).toBe(202);
                 // generate subsequent write and delete with the delete having an earlier timestamp
                 // NOTE: creating RecordsDelete first ensures it has an earlier `messageTimestamp` time
                 const recordsDelete = yield RecordsDelete.create({
@@ -570,62 +568,61 @@ export function testRecordsDeleteHandler() {
                 });
                 const deleteMessageCid = yield Message.getCid(recordsDelete.message);
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 // message store
                 const { messages } = yield messageStore.query(alice.did, [{ schema: normalizeSchemaUrl('testSchema'), method: DwnMethodName.Delete }]);
-                expect(messages.length).to.equal(1);
-                expect(yield Message.getCid(messages[0])).to.equal(deleteMessageCid);
-                // event log
-                const { events } = yield eventLog.queryEvents(alice.did, [{ schema: normalizeSchemaUrl('testSchema'), method: DwnMethodName.Delete }]);
-                expect(events.length).to.equal(1);
-                expect(events[0]).to.equal(deleteMessageCid);
+                expect(messages.length).toBe(1);
+                expect(yield Message.getCid(messages[0])).toBe(deleteMessageCid);
+                // state index
+                const events = yield stateIndex.getLeaves(alice.did, []);
+                expect(events).toContain(deleteMessageCid);
             }));
-            describe('event log', () => {
+            describe('state index', () => {
                 it('should include RecordsDelete event and keep initial RecordsWrite event', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
                     const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                     const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     const recordsDelete = yield RecordsDelete.create({
                         recordId: message.recordId,
                         signer: Jws.createSigner(alice)
                     });
                     const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                    expect(deleteReply.status.code).to.equal(202);
-                    const { events } = yield eventLog.getEvents(alice.did);
-                    expect(events.length).to.equal(2);
+                    expect(deleteReply.status.code).toBe(202);
+                    const events = yield stateIndex.getLeaves(alice.did, []);
+                    expect(events.length).toBe(2);
                     const writeMessageCid = yield Message.getCid(message);
                     const deleteMessageCid = yield Message.getCid(recordsDelete.message);
                     const expectedMessageCids = new Set([writeMessageCid, deleteMessageCid]);
                     for (const messageCid of events) {
                         expectedMessageCids.delete(messageCid);
                     }
-                    expect(expectedMessageCids.size).to.equal(0);
+                    expect(expectedMessageCids.size).toBe(0);
                 }));
                 it('should only keep first write and delete when subsequent writes happen', () => __awaiter(this, void 0, void 0, function* () {
                     const { message, author, dataStream, recordsWrite } = yield TestDataGenerator.generateRecordsWrite();
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const reply = yield dwn.processMessage(author.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     const newWrite = yield RecordsWrite.createFrom({
                         recordsWriteMessage: recordsWrite.message,
                         published: true,
                         signer: Jws.createSigner(author)
                     });
                     const newWriteReply = yield dwn.processMessage(author.did, newWrite.message);
-                    expect(newWriteReply.status.code).to.equal(202);
+                    expect(newWriteReply.status.code).toBe(202);
                     const recordsDelete = yield RecordsDelete.create({
                         recordId: message.recordId,
                         signer: Jws.createSigner(author)
                     });
                     const deleteReply = yield dwn.processMessage(author.did, recordsDelete.message);
-                    expect(deleteReply.status.code).to.equal(202);
-                    const { events } = yield eventLog.getEvents(author.did);
-                    expect(events.length).to.equal(2);
+                    expect(deleteReply.status.code).toBe(202);
+                    const events = yield stateIndex.getLeaves(author.did, []);
+                    expect(events.length).toBe(2);
                     const deletedMessageCid = yield Message.getCid(newWrite.message);
                     for (const messageCid of events) {
                         if (messageCid === deletedMessageCid) {
-                            expect.fail(`${messageCid} should not exist`);
+                            throw new Error(`${messageCid} should not exist`);
                         }
                     }
                 }));
@@ -643,7 +640,7 @@ export function testRecordsDeleteHandler() {
             const resumableTaskManagerStub = sinon.createStubInstance(ResumableTaskManager);
             const recordsDeleteHandler = new RecordsDeleteHandler(didResolver, messageStoreStub, resumableTaskManagerStub);
             const reply = yield recordsDeleteHandler.handle({ tenant, message });
-            expect(reply.status.code).to.equal(401);
+            expect(reply.status.code).toBe(401);
         }));
         it('should return 400 if fail parsing the message', () => __awaiter(this, void 0, void 0, function* () {
             const { author, message } = yield TestDataGenerator.generateRecordsDelete();
@@ -655,7 +652,7 @@ export function testRecordsDeleteHandler() {
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsDelete, 'parse').throws('anyError');
             const reply = yield recordsDeleteHandler.handle({ tenant, message });
-            expect(reply.status.code).to.equal(400);
+            expect(reply.status.code).toBe(400);
         }));
     });
 }