@enbox/dwn-sdk-js 0.4.8 → 0.4.10

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

@@ -150,7 +150,7 @@ export function testRecordsQueryHandler() {
                 expect(writeReply.status.code).toBe(202);
                 const query = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
                 const reply = await dwn.processMessage(alice.did, query.message);
-                expect(reply.entries?.length).toBe(1);
+                expect(reply.entries).toHaveLength(1);
                 const entry = reply.entries[0];
                 expect(entry.authorization).toEqual(write.message.authorization);
                 expect(entry.attestation).toEqual(write.message.attestation);
@@ -180,7 +180,7 @@ export function testRecordsQueryHandler() {
                 const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
                 const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect(reply.entries?.length).toBe(2); // only 2 entries should match the query on protocol
+                expect(reply.entries).toHaveLength(2); // only 2 entries should match the query on protocol
                 // testing multi-conditional query, reuse data generated above for bob
                 const messageData2 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -191,7 +191,7 @@ export function testRecordsQueryHandler() {
                 });
                 const reply2 = await dwn.processMessage(alice.did, messageData2.message);
                 expect(reply2.status.code).toBe(200);
-                expect(reply2.entries?.length).toBe(1); // only 1 entry should match the query
+                expect(reply2.entries).toHaveLength(1); // only 1 entry should match the query
             });
             it('should allow exact-tuple audience control queries without broad enumeration', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -700,7 +700,7 @@ export function testRecordsQueryHandler() {
                 const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
                 const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect(reply.entries?.length).toBe(1);
+                expect(reply.entries).toHaveLength(1);
                 expect(reply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(data));
             });
             it('should not return `encodedData` if data size is greater then spec threshold', async () => {
@@ -713,7 +713,7 @@ export function testRecordsQueryHandler() {
                 const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
                 const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect(reply.entries?.length).toBe(1);
+                expect(reply.entries).toHaveLength(1);
                 expect(reply.entries[0].encodedData).toBeUndefined();
             });
             it('should include `initialWrite` property if RecordsWrite is not initial write', async () => {
@@ -730,7 +730,7 @@ export function testRecordsQueryHandler() {
                 const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
                 const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect(reply.entries?.length).toBe(1);
+                expect(reply.entries).toHaveLength(1);
                 expect(reply.entries[0].initialWrite).toBeDefined();
                 expect(reply.entries[0].initialWrite?.recordId).toBe(write.message.recordId);
             });
@@ -749,7 +749,7 @@ export function testRecordsQueryHandler() {
                 // testing attester filter
                 const recordsQuery1 = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { attester: alice.did } });
                 const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
-                expect(reply1.entries?.length).toBe(1);
+                expect(reply1.entries).toHaveLength(1);
                 const reply1Attester = Jws.getSignerDid(reply1.entries[0].attestation.signatures[0]);
                 expect(reply1Attester).toBe(alice.did);
                 // testing attester + another filter
@@ -758,14 +758,14 @@ export function testRecordsQueryHandler() {
                     filter: { attester: bob.did, schema: recordsWrite2.message.descriptor.schema }
                 });
                 const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
-                expect(reply2.entries?.length).toBe(1);
+                expect(reply2.entries).toHaveLength(1);
                 const reply2Attester = Jws.getSignerDid(reply2.entries[0].attestation.signatures[0]);
                 expect(reply2Attester).toBe(bob.did);
                 // testing attester filter that yields no results
                 const carol = await TestDataGenerator.generateDidKeyPersona();
                 const recordsQuery3 = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { attester: carol.did } });
                 const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
-                expect(reply3.entries?.length).toBe(0);
+                expect(reply3.entries).toHaveLength(0);
             });
             it('should be able to query by author', async () => {
                 // scenario alice and bob both author records into alice's DWN.
@@ -809,7 +809,7 @@ export function testRecordsQueryHandler() {
                 });
                 let queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(2);
+                expect(queryReply.entries).toHaveLength(2);
                 // filter for bob as author
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -823,7 +823,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(1);
+                expect(queryReply.entries).toHaveLength(1);
                 expect(queryReply.entries[0].recordId).toBe(bobAuthorWrite.message.recordId);
                 // empty array for author should return all same as undefined author field
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
@@ -838,7 +838,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(2);
+                expect(queryReply.entries).toHaveLength(2);
                 // query for both authors explicitly
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -852,7 +852,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(2);
+                expect(queryReply.entries).toHaveLength(2);
             });
             it('should be able to query by recipient', async () => {
                 // scenario alice authors records for bob and carol into alice's DWN.
@@ -899,7 +899,7 @@ export function testRecordsQueryHandler() {
                 });
                 let queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(2);
+                expect(queryReply.entries).toHaveLength(2);
                 // filter for bob as recipient
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -913,7 +913,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(1);
+                expect(queryReply.entries).toHaveLength(1);
                 expect(queryReply.entries[0].recordId).toBe(aliceToBob.message.recordId);
                 // filter for carol as recipient
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
@@ -928,7 +928,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(1);
+                expect(queryReply.entries).toHaveLength(1);
                 expect(queryReply.entries[0].recordId).toBe(aliceToCarol.message.recordId);
                 // empty array for recipient should return all same as undefined recipient field
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
@@ -943,7 +943,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(2);
+                expect(queryReply.entries).toHaveLength(2);
                 // query for both recipients explicitly
                 recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -957,7 +957,7 @@ export function testRecordsQueryHandler() {
                 });
                 queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(2);
+                expect(queryReply.entries).toHaveLength(2);
             });
             it('should be able to query for published records', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -975,19 +975,19 @@ export function testRecordsQueryHandler() {
                 const publishedPostQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: true } });
                 let publishedPostReply = await dwn.processMessage(alice.did, publishedPostQuery.message);
                 expect(publishedPostReply.status.code).toBe(200);
-                expect(publishedPostReply.entries?.length).toBe(1);
+                expect(publishedPostReply.entries).toHaveLength(1);
                 expect(publishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // make an query for published records from non owner
                 const notOwnerPostQuery = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: true } });
                 let notOwnerPublishedPostReply = await dwn.processMessage(alice.did, notOwnerPostQuery.message);
                 expect(notOwnerPublishedPostReply.status.code).toBe(200);
-                expect(notOwnerPublishedPostReply.entries?.length).toBe(1);
+                expect(notOwnerPublishedPostReply.entries).toHaveLength(1);
                 expect(notOwnerPublishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // anonymous query for published records
                 const anonymousPostQuery = await RecordsQuery.create({ filter: { schema: 'post', published: true } });
                 let anonymousPublishedPostReply = await dwn.processMessage(alice.did, anonymousPostQuery.message);
                 expect(anonymousPublishedPostReply.status.code).toBe(200);
-                expect(anonymousPublishedPostReply.entries?.length).toBe(1);
+                expect(anonymousPublishedPostReply.entries).toHaveLength(1);
                 expect(anonymousPublishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // publish the unpublished record
                 const publishedDraftWrite = await RecordsWrite.createFrom({
@@ -1000,20 +1000,20 @@ export function testRecordsQueryHandler() {
                 // issue the same query for published records
                 publishedPostReply = await dwn.processMessage(alice.did, publishedPostQuery.message);
                 expect(publishedPostReply.status.code).toBe(200);
-                expect(publishedPostReply.entries?.length).toBe(2);
+                expect(publishedPostReply.entries).toHaveLength(2);
                 const returnedRecordIds = publishedPostReply.entries?.map(e => e.recordId);
                 // ensure that both records now exist in results
                 expect(returnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
                 // query after publishing from non owner
                 notOwnerPublishedPostReply = await dwn.processMessage(alice.did, anonymousPostQuery.message);
                 expect(notOwnerPublishedPostReply.status.code).toBe(200);
-                expect(notOwnerPublishedPostReply.entries?.length).toBe(2);
+                expect(notOwnerPublishedPostReply.entries).toHaveLength(2);
                 const nonOwnerReturnedRecordIds = notOwnerPublishedPostReply.entries?.map(e => e.recordId);
                 expect(nonOwnerReturnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
                 // anonymous query after publishing
                 anonymousPublishedPostReply = await dwn.processMessage(alice.did, anonymousPostQuery.message);
                 expect(anonymousPublishedPostReply.status.code).toBe(200);
-                expect(anonymousPublishedPostReply.entries?.length).toBe(2);
+                expect(anonymousPublishedPostReply.entries).toHaveLength(2);
                 const anonymousReturnedRecordIds = anonymousPublishedPostReply.entries?.map(e => e.recordId);
                 expect(anonymousReturnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
             });
@@ -1032,7 +1032,7 @@ export function testRecordsQueryHandler() {
                 const unpublishedPostQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: false } });
                 let unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostQuery.message);
                 expect(unpublishedPostReply.status.code).toBe(200);
-                expect(unpublishedPostReply.entries?.length).toBe(1);
+                expect(unpublishedPostReply.entries).toHaveLength(1);
                 expect(unpublishedPostReply.entries[0].recordId).toBe(draftWrite.message.recordId);
                 // publish the unpublished record
                 const publishedDraftWrite = await RecordsWrite.createFrom({
@@ -1045,7 +1045,7 @@ export function testRecordsQueryHandler() {
                 // issue the same query for unpublished records
                 unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostQuery.message);
                 expect(unpublishedPostReply.status.code).toBe(200);
-                expect(unpublishedPostReply.entries?.length).toBe(0);
+                expect(unpublishedPostReply.entries).toHaveLength(0);
             });
             it('should not be able to query for unpublished records if unauthorized', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -1063,7 +1063,7 @@ export function testRecordsQueryHandler() {
                 const unpublishedNotOwner = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: false } });
                 let notOwnerPostReply = await dwn.processMessage(alice.did, unpublishedNotOwner.message);
                 expect(notOwnerPostReply.status.code).toBe(200);
-                expect(notOwnerPostReply.entries?.length).toBe(0);
+                expect(notOwnerPostReply.entries).toHaveLength(0);
                 // publish the unpublished record
                 const publishedDraftWrite = await RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
@@ -1076,16 +1076,16 @@ export function testRecordsQueryHandler() {
                 let publishedNotOwner = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post' } });
                 let publishedNotOwnerReply = await dwn.processMessage(alice.did, publishedNotOwner.message);
                 expect(publishedNotOwnerReply.status.code).toBe(200);
-                expect(publishedNotOwnerReply.entries?.length).toBe(2);
+                expect(publishedNotOwnerReply.entries).toHaveLength(2);
                 // with explicit published true
                 publishedNotOwner = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: true } });
                 publishedNotOwnerReply = await dwn.processMessage(alice.did, publishedNotOwner.message);
                 expect(publishedNotOwnerReply.status.code).toBe(200);
-                expect(publishedNotOwnerReply.entries?.length).toBe(2);
+                expect(publishedNotOwnerReply.entries).toHaveLength(2);
                 // with explicit published false after publishing should still return nothing
                 notOwnerPostReply = await dwn.processMessage(alice.did, unpublishedNotOwner.message);
                 expect(notOwnerPostReply.status.code).toBe(200);
-                expect(notOwnerPostReply.entries?.length).toBe(0);
+                expect(notOwnerPostReply.entries).toHaveLength(0);
             });
             it('should query unpublished records authorized by permissionGrantId', async () => {
                 const alice = await TestDataGenerator.generatePersona();
@@ -1169,7 +1169,7 @@ export function testRecordsQueryHandler() {
                 const dataCidQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataCid: recordDataCid } });
                 const dataCidQueryReply = await dwn.processMessage(alice.did, dataCidQuery.message);
                 expect(dataCidQueryReply.status.code).toBe(200);
-                expect(dataCidQueryReply.entries?.length).toBe(1);
+                expect(dataCidQueryReply.entries).toHaveLength(1);
                 expect(dataCidQueryReply.entries[0].recordId).toBe(writeRecord.message.recordId);
             });
             it('should be able to query with `dataSize` filter (half-open range)', async () => {
@@ -1191,7 +1191,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { gt: 10 } },
                 });
                 const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
-                expect(reply1.entries?.length).toBe(2);
+                expect(reply1.entries).toHaveLength(2);
                 expect(reply1.entries?.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write2.dataBytes),
                     Encoder.bytesToBase64Url(write3.dataBytes)
@@ -1202,7 +1202,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { lt: 100 } },
                 });
                 const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
-                expect(reply2.entries?.length).toBe(2);
+                expect(reply2.entries).toHaveLength(2);
                 expect(reply2.entries?.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes)
@@ -1213,7 +1213,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { gte: 10 } },
                 });
                 const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
-                expect(reply3.entries?.length).toBe(3);
+                expect(reply3.entries).toHaveLength(3);
                 expect(reply3.entries?.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes),
@@ -1225,7 +1225,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { lte: 100 } },
                 });
                 const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
-                expect(reply4.entries?.length).toBe(3);
+                expect(reply4.entries).toHaveLength(3);
                 expect(reply4.entries?.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes),
@@ -1251,7 +1251,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { gt: 10, lt: 60 } },
                 });
                 const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
-                expect(reply1.entries?.length).toBe(1);
+                expect(reply1.entries).toHaveLength(1);
                 expect(reply1.entries[0].recordId).toBe(write2.message.recordId);
                 // testing range using gte & lt
                 const recordsQuery2 = await TestDataGenerator.generateRecordsQuery({
@@ -1259,7 +1259,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { gte: 10, lt: 60 } },
                 });
                 const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
-                expect(reply2.entries?.length).toBe(2);
+                expect(reply2.entries).toHaveLength(2);
                 const reply2RecordIds = reply2.entries?.map(e => e.recordId);
                 expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing range using gt & lte
@@ -1268,7 +1268,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { gt: 50, lte: 100 } },
                 });
                 const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
-                expect(reply3.entries?.length).toBe(1);
+                expect(reply3.entries).toHaveLength(1);
                 expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing range using gte & lte
                 const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
@@ -1276,7 +1276,7 @@ export function testRecordsQueryHandler() {
                     filter: { dataSize: { gte: 10, lte: 100 } },
                 });
                 const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
-                expect(reply4.entries?.length).toBe(3);
+                expect(reply4.entries).toHaveLength(3);
                 const reply4RecordIds = reply4.entries?.map(e => e.recordId);
                 expect(reply4RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
             });
@@ -1306,7 +1306,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
-                expect(reply1.entries?.length).toBe(2);
+                expect(reply1.entries).toHaveLength(2);
                 expect(reply1.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
                 expect(reply1.entries[1].encodedData).toBe(Encoder.bytesToBase64Url(write3.dataBytes));
                 // testing `to` range
@@ -1317,7 +1317,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
-                expect(reply2.entries?.length).toBe(2);
+                expect(reply2.entries).toHaveLength(2);
                 expect(reply2.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write1.dataBytes));
                 expect(reply2.entries[1].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
                 // testing `from` and `to` range
@@ -1328,7 +1328,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
-                expect(reply3.entries?.length).toBe(1);
+                expect(reply3.entries).toHaveLength(1);
                 expect(reply3.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write3.dataBytes));
                 // testing edge case where value equals `from` and `to`
                 const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
@@ -1337,7 +1337,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
-                expect(reply4.entries?.length).toBe(1);
+                expect(reply4.entries).toHaveLength(1);
                 expect(reply4.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
             });
             it('should not return records that were published and then unpublished ', async () => {
@@ -1380,7 +1380,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = await dwn.processMessage(alice.did, ownerRangeQuery.message);
-                expect(reply1.entries?.length).toBe(2);
+                expect(reply1.entries).toHaveLength(2);
                 const reply1RecordIds = reply1.entries?.map(e => e.recordId);
                 expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // confirm published true filter before un-publishing
@@ -1391,7 +1391,7 @@ export function testRecordsQueryHandler() {
                 });
                 let ownerPublishedReply = await dwn.processMessage(alice.did, ownerPublishedQuery.message);
                 expect(ownerPublishedReply.status.code).toBe(200);
-                expect(ownerPublishedReply.entries?.length).toBe(3);
+                expect(ownerPublishedReply.entries).toHaveLength(3);
                 const ownerPublishedIds = ownerPublishedReply.entries?.map(e => e.recordId);
                 expect(ownerPublishedIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
                 // confirm for anonymous query before un-publishing
@@ -1401,7 +1401,7 @@ export function testRecordsQueryHandler() {
                 });
                 let anonymousRangeReply = await dwn.processMessage(alice.did, anonymousRangeQuery.message);
                 expect(anonymousRangeReply.status.code).toBe(200);
-                expect(anonymousRangeReply.entries?.length).toBe(2);
+                expect(anonymousRangeReply.entries).toHaveLength(2);
                 const anonymousReplyIds = anonymousRangeReply.entries?.map(e => e.recordId);
                 expect(anonymousReplyIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // confirm anonymous published true filter before un-publishing
@@ -1411,7 +1411,7 @@ export function testRecordsQueryHandler() {
                 });
                 let anonymousPublishedReply = await dwn.processMessage(alice.did, anonymousPublishedQuery.message);
                 expect(anonymousPublishedReply.status.code).toBe(200);
-                expect(anonymousPublishedReply.entries?.length).toBe(3);
+                expect(anonymousPublishedReply.entries).toHaveLength(3);
                 const anonymousPublishedIds = anonymousPublishedReply.entries?.map(e => e.recordId);
                 expect(anonymousPublishedIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
                 //unpublish records
@@ -1439,19 +1439,19 @@ export function testRecordsQueryHandler() {
                 // try datePublished range query as an anonymous user after unpublish
                 anonymousRangeReply = await dwn.processMessage(alice.did, anonymousRangeQuery.message);
                 expect(anonymousRangeReply.status.code).toBe(200);
-                expect(anonymousRangeReply.entries?.length).toBe(0);
+                expect(anonymousRangeReply.entries).toHaveLength(0);
                 // try published:true filter as an anonymous user after unpublish
                 anonymousPublishedReply = await dwn.processMessage(alice.did, anonymousPublishedQuery.message);
                 expect(anonymousPublishedReply.status.code).toBe(200);
-                expect(anonymousPublishedReply.entries?.length).toBe(0);
+                expect(anonymousPublishedReply.entries).toHaveLength(0);
                 // try datePublished range query as owner after unpublish
                 const ownerRangeReply = await dwn.processMessage(alice.did, ownerRangeQuery.message);
                 expect(ownerRangeReply.status.code).toBe(200);
-                expect(ownerRangeReply.entries?.length).toBe(0);
+                expect(ownerRangeReply.entries).toHaveLength(0);
                 // try published:true filter as owner after unpublish
                 ownerPublishedReply = await dwn.processMessage(alice.did, ownerPublishedQuery.message);
                 expect(ownerPublishedReply.status.code).toBe(200);
-                expect(ownerPublishedReply.entries?.length).toBe(0);
+                expect(ownerPublishedReply.entries).toHaveLength(0);
             });
             it('should be able to range query by `datePublished`', async () => {
                 // scenario: 3 records authored by alice, published on first of 2021, 2022, and 2023 respectively
@@ -1486,7 +1486,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
-                expect(reply1.entries?.length).toBe(2);
+                expect(reply1.entries).toHaveLength(2);
                 const reply1RecordIds = reply1.entries?.map(e => e.recordId);
                 expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // testing `to` range
@@ -1497,7 +1497,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
-                expect(reply2.entries?.length).toBe(2);
+                expect(reply2.entries).toHaveLength(2);
                 const reply2RecordIds = reply2.entries?.map(e => e.recordId);
                 expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing `from` and `to` range
@@ -1508,7 +1508,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
-                expect(reply3.entries?.length).toBe(1);
+                expect(reply3.entries).toHaveLength(1);
                 expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing edge case where value equals `from` and `to`
                 const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
@@ -1517,7 +1517,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
-                expect(reply4.entries?.length).toBe(1);
+                expect(reply4.entries).toHaveLength(1);
                 expect(reply4.entries[0].recordId).toBe(write2.message.recordId);
                 // check for anonymous range query
                 const anonymousRecordQuery = await RecordsQuery.create({
@@ -1526,7 +1526,7 @@ export function testRecordsQueryHandler() {
                 });
                 const anonymousReply = await dwn.processMessage(alice.did, anonymousRecordQuery.message);
                 expect(anonymousReply.status.code).toBe(200);
-                expect(anonymousReply.entries?.length).toBe(2);
+                expect(anonymousReply.entries).toHaveLength(2);
                 const anonymousReplyIds = anonymousReply.entries?.map(e => e.recordId);
                 expect(anonymousReplyIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // check for non owner range query
@@ -1538,7 +1538,7 @@ export function testRecordsQueryHandler() {
                 });
                 const nonOwnerReply = await dwn.processMessage(alice.did, nonOwnerRange.message);
                 expect(nonOwnerReply.status.code).toBe(200);
-                expect(nonOwnerReply.entries?.length).toBe(2);
+                expect(nonOwnerReply.entries).toHaveLength(2);
                 const nonOwnerReplyIds = nonOwnerReply.entries?.map(e => e.recordId);
                 expect(nonOwnerReplyIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
             });
@@ -1611,7 +1611,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
-                expect(reply1.entries?.length).toBe(2);
+                expect(reply1.entries).toHaveLength(2);
                 const reply1RecordIds = reply1.entries?.map(e => e.recordId);
                 expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // testing `to` range
@@ -1622,7 +1622,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
-                expect(reply2.entries?.length).toBe(2);
+                expect(reply2.entries).toHaveLength(2);
                 const reply2RecordIds = reply2.entries?.map(e => e.recordId);
                 expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing `from` and `to` range
@@ -1633,7 +1633,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
-                expect(reply3.entries?.length).toBe(1);
+                expect(reply3.entries).toHaveLength(1);
                 expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing edge case where value equals `from` and `to`
                 const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
@@ -1642,7 +1642,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
-                expect(reply4.entries?.length).toBe(1);
+                expect(reply4.entries).toHaveLength(1);
                 expect(reply4.entries[0].recordId).toBe(write2.message.recordId);
             });
             it('should be able use range and exact match queries at the same time', async () => {
@@ -1682,7 +1682,7 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply = await dwn.processMessage(alice.did, recordsQuery5.message);
-                expect(reply.entries?.length).toBe(1);
+                expect(reply.entries).toHaveLength(1);
                 expect(reply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
             });
             it('should include `authorization` in returned records', async () => {
@@ -1700,7 +1700,7 @@ export function testRecordsQueryHandler() {
                 });
                 const queryReply = await dwn.processMessage(alice.did, queryData.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(1);
+                expect(queryReply.entries).toHaveLength(1);
                 expect(queryReply.entries[0].authorization).toEqual(message.authorization);
             });
             it('should include `attestation` in returned records', async () => {
@@ -1716,9 +1716,9 @@ export function testRecordsQueryHandler() {
                 });
                 const queryReply = await dwn.processMessage(alice.did, queryData.message);
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(1);
+                expect(queryReply.entries).toHaveLength(1);
                 const recordsWriteMessage = queryReply.entries[0];
-                expect(recordsWriteMessage.attestation?.signatures?.length).toBe(1);
+                expect(recordsWriteMessage.attestation?.signatures).toHaveLength(1);
             });
             it('should omit records that are not published if `dateSort` sorts on `datePublished`', async () => {
                 // setup: 2 records in DWN: 1 published and 1 unpublished
@@ -1747,7 +1747,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries?.length).toBe(1);
+                expect(publishedAscendingQueryReply.entries).toHaveLength(1);
                 expect(publishedAscendingQueryReply.entries[0].recordId).toBe(publishedWriteData.message.recordId);
                 // test published date scending sort does not include any records that are not published
                 const publishedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
@@ -1756,7 +1756,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries?.length).toBe(1);
+                expect(publishedDescendingQueryReply.entries).toHaveLength(1);
                 expect(publishedDescendingQueryReply.entries[0].recordId).toBe(publishedWriteData.message.recordId);
             });
             it('should sort records if `dateSort` is specified with and without a cursor', async () => {
@@ -1788,7 +1788,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let createdAscendingQueryReply = await dwn.processMessage(alice.did, createdAscendingQueryData.message);
-                expect(createdAscendingQueryReply.entries.length).toBe(3);
+                expect(createdAscendingQueryReply.entries).toHaveLength(3);
                 expect(createdAscendingQueryReply.entries?.[0].recordId).toBe(write1Data.message.recordId);
                 expect(createdAscendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
                 expect(createdAscendingQueryReply.entries?.[2].recordId).toBe(write3Data.message.recordId);
@@ -1800,7 +1800,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 createdAscendingQueryReply = await dwn.processMessage(alice.did, createdAscendingQueryData.message);
-                expect(createdAscendingQueryReply.entries.length).toBe(1);
+                expect(createdAscendingQueryReply.entries).toHaveLength(1);
                 // we then use the single record query's cursor to get the rest of the records
                 createdAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1809,7 +1809,7 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: createdAscendingQueryReply.cursor }
                 });
                 createdAscendingQueryReply = await dwn.processMessage(alice.did, createdAscendingQueryData.message);
-                expect(createdAscendingQueryReply.entries.length).toBe(2);
+                expect(createdAscendingQueryReply.entries).toHaveLength(2);
                 expect(createdAscendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
                 expect(createdAscendingQueryReply.entries[1].recordId).toBe(write3Data.message.recordId);
                 // createdDescending test
@@ -1819,7 +1819,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let createdDescendingQueryReply = await dwn.processMessage(alice.did, createdDescendingQueryData.message);
-                expect(createdDescendingQueryReply.entries.length).toBe(3);
+                expect(createdDescendingQueryReply.entries).toHaveLength(3);
                 expect(createdDescendingQueryReply.entries?.[0].recordId).toBe(write3Data.message.recordId);
                 expect(createdDescendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
                 expect(createdDescendingQueryReply.entries?.[2].recordId).toBe(write1Data.message.recordId);
@@ -1831,7 +1831,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 createdDescendingQueryReply = await dwn.processMessage(alice.did, createdDescendingQueryData.message);
-                expect(createdDescendingQueryReply.entries.length).toBe(1);
+                expect(createdDescendingQueryReply.entries).toHaveLength(1);
                 // we then use the single record query's cursor to get the rest of the records
                 createdDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1840,7 +1840,7 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: createdDescendingQueryReply.cursor }
                 });
                 createdDescendingQueryReply = await dwn.processMessage(alice.did, createdDescendingQueryData.message);
-                expect(createdDescendingQueryReply.entries.length).toBe(2);
+                expect(createdDescendingQueryReply.entries).toHaveLength(2);
                 expect(createdDescendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
                 expect(createdDescendingQueryReply.entries[1].recordId).toBe(write1Data.message.recordId);
                 // publishedAscending test
@@ -1850,7 +1850,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries.length).toBe(3);
+                expect(publishedAscendingQueryReply.entries).toHaveLength(3);
                 expect(publishedAscendingQueryReply.entries?.[0].recordId).toBe(write1Data.message.recordId);
                 expect(publishedAscendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
                 expect(publishedAscendingQueryReply.entries?.[2].recordId).toBe(write3Data.message.recordId);
@@ -1862,7 +1862,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries.length).toBe(1);
+                expect(publishedAscendingQueryReply.entries).toHaveLength(1);
                 publishedAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedAscending,
@@ -1870,7 +1870,7 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: publishedAscendingQueryReply.cursor }
                 });
                 publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries.length).toBe(2);
+                expect(publishedAscendingQueryReply.entries).toHaveLength(2);
                 expect(publishedAscendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
                 expect(publishedAscendingQueryReply.entries[1].recordId).toBe(write3Data.message.recordId);
                 // publishedDescending test
@@ -1880,7 +1880,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries.length).toBe(3);
+                expect(publishedDescendingQueryReply.entries).toHaveLength(3);
                 expect(publishedDescendingQueryReply.entries?.[0].recordId).toBe(write3Data.message.recordId);
                 expect(publishedDescendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
                 expect(publishedDescendingQueryReply.entries?.[2].recordId).toBe(write1Data.message.recordId);
@@ -1891,7 +1891,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries.length).toBe(1);
+                expect(publishedDescendingQueryReply.entries).toHaveLength(1);
                 publishedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
@@ -1899,7 +1899,7 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: publishedDescendingQueryReply.cursor }
                 });
                 publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries.length).toBe(2);
+                expect(publishedDescendingQueryReply.entries).toHaveLength(2);
                 expect(publishedDescendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
                 expect(publishedDescendingQueryReply.entries[1].recordId).toBe(write1Data.message.recordId);
             });
@@ -1927,7 +1927,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const updatedAscendingQueryReply = await dwn.processMessage(alice.did, updatedAscendingQueryData.message);
-                expect(updatedAscendingQueryReply.entries.length).toBe(3);
+                expect(updatedAscendingQueryReply.entries).toHaveLength(3);
                 expect(updatedAscendingQueryReply.entries?.[0].recordId).toBe(write1Data.message.recordId);
                 expect(updatedAscendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
                 expect(updatedAscendingQueryReply.entries?.[2].recordId).toBe(write3Data.message.recordId);
@@ -1938,7 +1938,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const updatedDescendingQueryReply = await dwn.processMessage(alice.did, updatedDescendingQueryData.message);
-                expect(updatedDescendingQueryReply.entries.length).toBe(3);
+                expect(updatedDescendingQueryReply.entries).toHaveLength(3);
                 expect(updatedDescendingQueryReply.entries?.[0].recordId).toBe(write3Data.message.recordId);
                 expect(updatedDescendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
                 expect(updatedDescendingQueryReply.entries?.[2].recordId).toBe(write1Data.message.recordId);
@@ -2001,7 +2001,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const updatedAscReply = await dwn.processMessage(alice.did, updatedAscQuery.message);
-                expect(updatedAscReply.entries.length).toBe(3);
+                expect(updatedAscReply.entries).toHaveLength(3);
                 expect(updatedAscReply.entries[0].recordId).toBe(write3.message.recordId);
                 expect(updatedAscReply.entries[1].recordId).toBe(write2.message.recordId);
                 expect(updatedAscReply.entries[2].recordId).toBe(write1.message.recordId);
@@ -2012,7 +2012,7 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const updatedDescReply = await dwn.processMessage(alice.did, updatedDescQuery.message);
-                expect(updatedDescReply.entries.length).toBe(3);
+                expect(updatedDescReply.entries).toHaveLength(3);
                 expect(updatedDescReply.entries[0].recordId).toBe(write1.message.recordId);
                 expect(updatedDescReply.entries[1].recordId).toBe(write2.message.recordId);
                 expect(updatedDescReply.entries[2].recordId).toBe(write3.message.recordId);
@@ -2045,7 +2045,7 @@ export function testRecordsQueryHandler() {
                 const queryReply = await dwn.processMessage(alice.did, queryMessageData.message);
                 // verify that messages returned are sorted/tiebreak by `messageCid`
                 expect(queryReply.status.code).toBe(200);
-                expect(queryReply.entries?.length).toBe(3);
+                expect(queryReply.entries).toHaveLength(3);
                 expect((queryReply.entries[0]).recordId).toBe(oldestWrite.message.recordId);
                 expect((queryReply.entries[1]).recordId).toBe(middleWrite.message.recordId);
                 expect((queryReply.entries[2]).recordId).toBe(newestWrite.message.recordId);
@@ -2095,8 +2095,8 @@ export function testRecordsQueryHandler() {
                         break;
                     }
                 }
-                expect(results.length).toBe(messages.length);
-                expect(messages.every(({ message }) => results.map(e => e.recordId).includes(message.recordId)));
+                expect(results).toHaveLength(messages.length);
+                expect(messages.every(({ message }) => results.map(e => e.recordId).includes(message.recordId))).toBe(true);
             });
             it('should paginate all records in descending order', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2133,8 +2133,8 @@ export function testRecordsQueryHandler() {
                         break;
                     }
                 }
-                expect(results.length).toBe(messages.length);
-                expect(messages.every(({ message }) => results.map(e => e.recordId).includes(message.recordId)));
+                expect(results).toHaveLength(messages.length);
+                expect(messages.every(({ message }) => results.map(e => e.recordId).includes(message.recordId))).toBe(true);
             });
             it('should allow an anonymous unauthenticated query to return published records', async () => {
                 // write 2 records into Alice's DB:
@@ -2157,7 +2157,7 @@ export function testRecordsQueryHandler() {
                 expect(anonymousQueryMessageData.message.authorization).toBeUndefined();
                 const replyToQuery = await dwn.processMessage(alice.did, anonymousQueryMessageData.message);
                 expect(replyToQuery.status.code).toBe(200);
-                expect(replyToQuery.entries?.length).toBe(1);
+                expect(replyToQuery.entries).toHaveLength(1);
                 expect(replyToQuery.entries[0].descriptor.schema).toBe('https://schema2');
                 // explicitly for published records
                 const anonymousQueryPublished = await TestDataGenerator.generateRecordsQuery({
@@ -2169,7 +2169,7 @@ export function testRecordsQueryHandler() {
                 // should return the published records
                 const publishedReply = await dwn.processMessage(alice.did, anonymousQueryPublished.message);
                 expect(publishedReply.status.code).toBe(200);
-                expect(publishedReply.entries?.length).toBe(1);
+                expect(publishedReply.entries).toHaveLength(1);
                 expect(publishedReply.entries[0].descriptor.schema).toBe('https://schema2');
             });
             it('should only return published records and unpublished records that are meant for specific recipient(s)', async () => {
@@ -2348,7 +2348,7 @@ export function testRecordsQueryHandler() {
                 });
                 const bobQueryMessagesForBobAliceReply = await dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
                 expect(bobQueryMessagesForBobAliceReply.status.code).toBe(200);
-                expect(bobQueryMessagesForBobAliceReply.entries?.length).toBe(7);
+                expect(bobQueryMessagesForBobAliceReply.entries).toHaveLength(7);
                 // Since Bob is the author if the query, we expect for him to be able to see:
                 // Private Messages THAT ANYONE sent to Bob
                 // Private Messages THAT ONLY HE sent to Alice
@@ -2370,7 +2370,7 @@ export function testRecordsQueryHandler() {
                 });
                 const carolQueryMessagesForCarolAliceReply = await dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
                 expect(carolQueryMessagesForCarolAliceReply.status.code).toBe(200);
-                expect(carolQueryMessagesForCarolAliceReply.entries?.length).toBe(4);
+                expect(carolQueryMessagesForCarolAliceReply.entries).toHaveLength(4);
                 // Since Carol is the author if the query, we expect for her to be able to see:
                 // Private Messages THAT ANYONE sent to Carol
                 // Private Messages THAT ONLY SHE sent to Alice
@@ -2389,7 +2389,7 @@ export function testRecordsQueryHandler() {
                 });
                 const aliceQueryPublishedReply = await dwn.processMessage(alice.did, aliceQueryPublished.message);
                 expect(aliceQueryPublishedReply.status.code).toBe(200);
-                expect(aliceQueryPublishedReply.entries?.length).toBe(4);
+                expect(aliceQueryPublishedReply.entries).toHaveLength(4);
                 expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePublicToBob.message.recordId,
                     carolPublicToBob.message.recordId,
@@ -2403,7 +2403,7 @@ export function testRecordsQueryHandler() {
                 });
                 const carolQueryPrivateReply = await dwn.processMessage(alice.did, carolQueryPrivate.message);
                 expect(carolQueryPrivateReply.status.code).toBe(200);
-                expect(carolQueryPrivateReply.entries?.length).toBe(3);
+                expect(carolQueryPrivateReply.entries).toHaveLength(3);
                 // Carol can query for private messages she authored to alice, and her own private messages with herself as the recipient
                 expect(carolQueryPrivateReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToCarol.message.recordId,
@@ -2587,7 +2587,7 @@ export function testRecordsQueryHandler() {
                 });
                 const bobQueryMessagesForBobAliceReply = await dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
                 expect(bobQueryMessagesForBobAliceReply.status.code).toBe(200);
-                expect(bobQueryMessagesForBobAliceReply.entries?.length).toBe(7);
+                expect(bobQueryMessagesForBobAliceReply.entries).toHaveLength(7);
                 // Since Bob is the author if the query, we expect for him to be able to see:
                 // Private Messages Bob authored TO ANYONE
                 // Private Messages Alice authored To Bob
@@ -2609,7 +2609,7 @@ export function testRecordsQueryHandler() {
                 });
                 const carolQueryMessagesForCarolAliceReply = await dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
                 expect(carolQueryMessagesForCarolAliceReply.status.code).toBe(200);
-                expect(carolQueryMessagesForCarolAliceReply.entries?.length).toBe(4);
+                expect(carolQueryMessagesForCarolAliceReply.entries).toHaveLength(4);
                 // Since Carol is the author if the query, we expect for her to be able to see:
                 // All messages that Carol sent to anyone, private or public
                 expect(carolQueryMessagesForCarolAliceReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
@@ -2625,7 +2625,7 @@ export function testRecordsQueryHandler() {
                 });
                 const aliceQueryPublishedReply = await dwn.processMessage(alice.did, aliceQueryPublished.message);
                 expect(aliceQueryPublishedReply.status.code).toBe(200);
-                expect(aliceQueryPublishedReply.entries?.length).toBe(4);
+                expect(aliceQueryPublishedReply.entries).toHaveLength(4);
                 expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePublicToBob.message.recordId,
                     alicePublicToCarol.message.recordId,
@@ -2639,7 +2639,7 @@ export function testRecordsQueryHandler() {
                 });
                 const carolQueryPrivateReply = await dwn.processMessage(alice.did, carolQueryPrivate.message);
                 expect(carolQueryPrivateReply.status.code).toBe(200);
-                expect(carolQueryPrivateReply.entries?.length).toBe(3);
+                expect(carolQueryPrivateReply.entries).toHaveLength(3);
                 expect(carolQueryPrivateReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToCarol.message.recordId,
                     carolPrivateToAlice.message.recordId,
@@ -2730,7 +2730,7 @@ export function testRecordsQueryHandler() {
                 const compareRecordId = (a, b) => {
                     return a.recordId === b.recordId;
                 };
-                expect(sortedMessages.every((m, i) => compareRecordId(aliceRetrieved.at(i), m)));
+                expect(sortedMessages.every((m, i) => compareRecordId(aliceRetrieved.at(i), m))).toBe(true);
                 const bobs = (m) => {
                     return m.descriptor.recipient === bob.did || m.descriptor.published === true || Message.getSigner(m) === bob.did;
                 };
@@ -2760,7 +2760,7 @@ export function testRecordsQueryHandler() {
                 expect(results.entries?.length).toBe(10, 'bob page 2');
                 expect(results.cursor, 'bob page 2 cursor').toBeUndefined();
                 bobRetrieved.push(...results.entries);
-                expect(bobSorted.every((m, i) => compareRecordId(bobRetrieved.at(i), m)));
+                expect(bobSorted.every((m, i) => compareRecordId(bobRetrieved.at(i), m))).toBe(true);
             });
             // https://github.com/enboxorg/enbox/issues/170
             it('#170 - should treat records with `published` explicitly set to `false` as unpublished', async () => {
@@ -2779,7 +2779,7 @@ export function testRecordsQueryHandler() {
                 });
                 const replyToAliceQuery = await dwn.processMessage(alice.did, queryByAlice.message);
                 expect(replyToAliceQuery.status.code).toBe(200);
-                expect(replyToAliceQuery.entries?.length).toBe(1);
+                expect(replyToAliceQuery.entries).toHaveLength(1);
                 // actual test: bob should not be able to see unpublished record
                 const queryByBob = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
@@ -2787,7 +2787,7 @@ export function testRecordsQueryHandler() {
                 });
                 const replyToBobQuery = await dwn.processMessage(alice.did, queryByBob.message);
                 expect(replyToBobQuery.status.code).toBe(200);
-                expect(replyToBobQuery.entries?.length).toBe(0);
+                expect(replyToBobQuery.entries).toHaveLength(0);
             });
             it('should allow DWN owner to use `recipient` as a filter in queries', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2817,7 +2817,7 @@ export function testRecordsQueryHandler() {
                 await dwn.processMessage(bob.did, recordsWriteMessage2Data.message, { dataStream: recordsWriteMessage2Data.dataStream });
                 const reply = await dwn.processMessage(alice.did, aliceQueryMessageData.message);
                 expect(reply.status.code).toBe(200);
-                expect(reply.entries?.length).toBe(1);
+                expect(reply.entries).toHaveLength(1);
             });
             it('should return 400 if protocol is not normalized', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2882,7 +2882,7 @@ export function testRecordsQueryHandler() {
                 const unpublishedPostQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: false } });
                 const unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostQuery.message);
                 expect(unpublishedPostReply.status.code).toBe(200);
-                expect(unpublishedPostReply.entries?.length).toBe(1);
+                expect(unpublishedPostReply.entries).toHaveLength(1);
                 expect(unpublishedPostReply.entries[0].recordId).toBe(draftWrite.message.recordId);
                 // anonymous query for unpublished records
                 const unpublishedAnonymous = await RecordsQuery.create({ filter: { schema: 'post', published: false } });
@@ -2959,7 +2959,7 @@ export function testRecordsQueryHandler() {
                     });
                     const foo1ContextIdQueryReply = await dwn.processMessage(alice.did, foo1ContextIdQuery.message);
                     expect(foo1ContextIdQueryReply.status.code).toBe(200);
-                    expect(foo1ContextIdQueryReply.entries?.length).toBe(5);
+                    expect(foo1ContextIdQueryReply.entries).toHaveLength(5);
                     expect(foo1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([
                         foo1.message.recordId,
                         bar1.message.recordId,
@@ -2974,7 +2974,7 @@ export function testRecordsQueryHandler() {
                     });
                     const bar1ContextIdQueryReply = await dwn.processMessage(alice.did, bar1ContextIdQuery.message);
                     expect(bar1ContextIdQueryReply.status.code).toBe(200);
-                    expect(bar1ContextIdQueryReply.entries?.length).toBe(3);
+                    expect(bar1ContextIdQueryReply.entries).toHaveLength(3);
                     expect(bar1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([
                         bar1.message.recordId,
                         baz1.message.recordId,
@@ -2987,7 +2987,7 @@ export function testRecordsQueryHandler() {
                     });
                     const baz1ContextIdQueryReply = await dwn.processMessage(alice.did, baz1ContextIdQuery.message);
                     expect(baz1ContextIdQueryReply.status.code).toBe(200);
-                    expect(baz1ContextIdQueryReply.entries?.length).toBe(1);
+                    expect(baz1ContextIdQueryReply.entries).toHaveLength(1);
                     expect(baz1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([baz1.message.recordId]));
                 });
                 it('does not try protocol authorization if protocolRole is not invoked', async () => {
@@ -3046,7 +3046,7 @@ export function testRecordsQueryHandler() {
                     });
                     const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     expect(chatQueryReply.status.code).toBe(200);
-                    expect(chatQueryReply.entries?.length).toBe(1);
+                    expect(chatQueryReply.entries).toHaveLength(1);
                     expect(chatQueryReply.entries[0].recordId).toBe(chatRecordForBob.message.recordId);
                     // bob queries without invoking any protocolRole and filters for unpublished records
                     const unpublishedChatQuery = await TestDataGenerator.generateRecordsQuery({
@@ -3058,7 +3058,7 @@ export function testRecordsQueryHandler() {
                     });
                     const unpublishedChatReply = await dwn.processMessage(alice.did, unpublishedChatQuery.message);
                     expect(unpublishedChatReply.status.code).toBe(200);
-                    expect(unpublishedChatReply.entries?.length).toBe(1);
+                    expect(unpublishedChatReply.entries).toHaveLength(1);
                     expect(unpublishedChatReply.entries[0].recordId).toBe(chatRecordForBob.message.recordId);
                 });
                 it('allows root-level role authorized queries', async () => {
@@ -3109,7 +3109,7 @@ export function testRecordsQueryHandler() {
                     });
                     const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     expect(chatQueryReply.status.code).toBe(200);
-                    expect(chatQueryReply.entries?.length).toBe(3);
+                    expect(chatQueryReply.entries).toHaveLength(3);
                     expect(chatQueryReply.entries.map((record) => record.recordId)).toEqual(expect.arrayContaining(chatRecordIds));
                     // Bob invokes his friendRole along with an explicit filter for unpublished records
                     const unpublishedChatQuery = await TestDataGenerator.generateRecordsQuery({
@@ -3123,7 +3123,7 @@ export function testRecordsQueryHandler() {
                     });
                     const unpublishedChatReply = await dwn.processMessage(alice.did, unpublishedChatQuery.message);
                     expect(unpublishedChatReply.status.code).toBe(200);
-                    expect(unpublishedChatReply.entries?.length).toBe(3);
+                    expect(unpublishedChatReply.entries).toHaveLength(3);
                     expect(unpublishedChatReply.entries.map((record) => record.recordId)).toEqual(expect.arrayContaining(chatRecordIds));
                 });
                 it('can authorize queries using a context role.', async () => {
@@ -3184,7 +3184,7 @@ export function testRecordsQueryHandler() {
                     });
                     const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     expect(chatQueryReply.status.code).toBe(200);
-                    expect(chatQueryReply.entries?.length).toBe(3);
+                    expect(chatQueryReply.entries).toHaveLength(3);
                     expect(chatQueryReply.entries.map((record) => record.recordId)).toEqual(expect.arrayContaining(chatRecordIds));
                 });
                 it('does not execute protocol queries where protocolPath is missing from the filter', async () => {
@@ -3478,7 +3478,7 @@ export function testRecordsQueryHandler() {
                         });
                         const bobQueryReply = await dwn.processMessage(alice.did, bobQuery.message);
                         expect(bobQueryReply.status.code).toBe(200);
-                        expect(bobQueryReply.entries?.length).toBe(2);
+                        expect(bobQueryReply.entries).toHaveLength(2);
                         expect(bobQueryReply.entries.map((e) => e.recordId)).toEqual(expect.arrayContaining(bobRecordIds));
                         // Carol queries — should see exactly her 1 message
                         const carolQuery = await TestDataGenerator.generateRecordsQuery({
@@ -3490,7 +3490,7 @@ export function testRecordsQueryHandler() {
                         });
                         const carolQueryReply = await dwn.processMessage(alice.did, carolQuery.message);
                         expect(carolQueryReply.status.code).toBe(200);
-                        expect(carolQueryReply.entries?.length).toBe(1);
+                        expect(carolQueryReply.entries).toHaveLength(1);
                         expect(carolQueryReply.entries[0].recordId).toBe(carolMsg.message.recordId);
                     });
                     it('author can query their own records via who-based rule', async () => {
@@ -3527,7 +3527,7 @@ export function testRecordsQueryHandler() {
                         });
                         const bobQueryReply = await dwn.processMessage(alice.did, bobQuery.message);
                         expect(bobQueryReply.status.code).toBe(200);
-                        expect(bobQueryReply.entries?.length).toBe(1);
+                        expect(bobQueryReply.entries).toHaveLength(1);
                         expect(bobQueryReply.entries[0].recordId).toBe(bobMsg.message.recordId);
                         // Carol queries — should see nothing (she is neither author nor recipient)
                         const carolQuery = await TestDataGenerator.generateRecordsQuery({
@@ -3539,7 +3539,7 @@ export function testRecordsQueryHandler() {
                         });
                         const carolQueryReply = await dwn.processMessage(alice.did, carolQuery.message);
                         expect(carolQueryReply.status.code).toBe(200);
-                        expect(carolQueryReply.entries?.length).toBe(0);
+                        expect(carolQueryReply.entries).toHaveLength(0);
                     });
                     it('unauthorized party cannot see any unpublished records via query', async () => {
                         // scenario: Alice writes unpublished messages. Dave (not author, not recipient)
@@ -3577,7 +3577,7 @@ export function testRecordsQueryHandler() {
                         });
                         const daveQueryReply = await dwn.processMessage(alice.did, daveQuery.message);
                         expect(daveQueryReply.status.code).toBe(200);
-                        expect(daveQueryReply.entries?.length).toBe(0);
+                        expect(daveQueryReply.entries).toHaveLength(0);
                         // Dave queries with explicit unpublished filter — still sees nothing
                         const daveUnpubQuery = await TestDataGenerator.generateRecordsQuery({
                             author: dave,
@@ -3589,7 +3589,7 @@ export function testRecordsQueryHandler() {
                         });
                         const daveUnpubReply = await dwn.processMessage(alice.did, daveUnpubQuery.message);
                         expect(daveUnpubReply.status.code).toBe(200);
-                        expect(daveUnpubReply.entries?.length).toBe(0);
+                        expect(daveUnpubReply.entries).toHaveLength(0);
                     });
                     it('who-based query rules do not grant role-like broad access', async () => {
                         // scenario: Protocol has who-based query rules. A non-participant tries to invoke
@@ -3673,7 +3673,7 @@ export function testRecordsQueryHandler() {
                         });
                         const bobRoleQueryReply = await dwn.processMessage(alice.did, bobRoleQuery.message);
                         expect(bobRoleQueryReply.status.code).toBe(200);
-                        expect(bobRoleQueryReply.entries?.length).toBe(3);
+                        expect(bobRoleQueryReply.entries).toHaveLength(3);
                         // Dave (who is NOT a participant) tries to invoke the role — should be rejected
                         const daveRoleQuery = await TestDataGenerator.generateRecordsQuery({
                             author: dave,
@@ -3698,7 +3698,7 @@ export function testRecordsQueryHandler() {
                         });
                         const daveNoRoleQueryReply = await dwn.processMessage(alice.did, daveNoRoleQuery.message);
                         expect(daveNoRoleQueryReply.status.code).toBe(200);
-                        expect(daveNoRoleQueryReply.entries?.length).toBe(0);
+                        expect(daveNoRoleQueryReply.entries).toHaveLength(0);
                     });
                 });
             });