@enbox/dwn-sdk-js 0.4.8 → 0.4.10

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

@@ -75,7 +75,7 @@ export function testRecordsWriteHandler() {
                 await dwn.close();
             });
             async function installEncryptedProtocol(author, protocolDefinition) {
-                const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, author.keyId, author.encryptionKeyPair.privateJwk);
+                const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(author.keyId, author.encryptionKeyPair.privateJwk));
                 const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author,
                     protocolDefinition: encryptedProtocolDefinition,
@@ -405,7 +405,7 @@ export function testRecordsWriteHandler() {
                         message: {},
                     },
                 };
-                const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                 const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: encryptedProtocolDefinition,
@@ -922,7 +922,7 @@ export function testRecordsWriteHandler() {
                 // verify the message written can be queried
                 const recordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                 expect(recordsQueryReply.status.code).toBe(200);
-                expect(recordsQueryReply.entries?.length).toBe(1);
+                expect(recordsQueryReply.entries).toHaveLength(1);
                 expect(recordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(data1));
                 // generate and write a new RecordsWrite to overwrite the existing record
                 // a new RecordsWrite by default will have a later `messageTimestamp`
@@ -940,7 +940,7 @@ export function testRecordsWriteHandler() {
                 // verify new record has overwritten the existing record
                 const newRecordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                 expect(newRecordsQueryReply.status.code).toBe(200);
-                expect(newRecordsQueryReply.entries?.length).toBe(1);
+                expect(newRecordsQueryReply.entries).toHaveLength(1);
                 expect(newRecordsQueryReply.entries[0].encodedData).toBe(newDataEncoded);
                 // try to write the older message to store again and verify that it is not accepted
                 const thirdRecordsWriteReply = await dwn.processMessage(tenant, recordsWriteMessageData.message, { dataStream: recordsWriteMessageData.dataStream });
@@ -948,7 +948,7 @@ export function testRecordsWriteHandler() {
                 // expecting unchanged
                 const thirdRecordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                 expect(thirdRecordsQueryReply.status.code).toBe(200);
-                expect(thirdRecordsQueryReply.entries?.length).toBe(1);
+                expect(thirdRecordsQueryReply.entries).toHaveLength(1);
                 expect(thirdRecordsQueryReply.entries[0].encodedData).toBe(newDataEncoded);
             });
             it('should return 409 for an exact duplicate initial RecordsWrite with large data', async () => {
@@ -1054,7 +1054,7 @@ export function testRecordsWriteHandler() {
                 // verify the data is written
                 const recordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                 expect(recordsQueryReply.status.code).toBe(200);
-                expect(recordsQueryReply.entries?.length).toBe(1);
+                expect(recordsQueryReply.entries).toHaveLength(1);
                 expect(recordsQueryReply.entries[0].descriptor.dataCid)
                     .toBe(olderWrite.message.descriptor.dataCid);
                 // attempt to write the message with larger lexicographical message CID
@@ -1063,7 +1063,7 @@ export function testRecordsWriteHandler() {
                 // verify new record has overwritten the existing record
                 const newRecordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                 expect(newRecordsQueryReply.status.code).toBe(200);
-                expect(newRecordsQueryReply.entries?.length).toBe(1);
+                expect(newRecordsQueryReply.entries).toHaveLength(1);
                 expect(newRecordsQueryReply.entries[0].descriptor.dataCid)
                     .toBe(newerWrite.message.descriptor.dataCid);
                 // try to write the message with smaller lexicographical message CID again
@@ -1073,7 +1073,7 @@ export function testRecordsWriteHandler() {
                 // verify the message in store is still the one with larger lexicographical message CID
                 const thirdRecordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                 expect(thirdRecordsQueryReply.status.code).toBe(200);
-                expect(thirdRecordsQueryReply.entries?.length).toBe(1);
+                expect(thirdRecordsQueryReply.entries).toHaveLength(1);
                 expect(thirdRecordsQueryReply.entries[0].descriptor.dataCid)
                     .toBe(newerWrite.message.descriptor.dataCid); // expecting unchanged
             });
@@ -1211,7 +1211,7 @@ export function testRecordsWriteHandler() {
                 });
                 const recordsQueryReply = await dwn.processMessage(alice.did, recordsQueryMessageData.message);
                 expect(recordsQueryReply.status.code).toBe(200);
-                expect(recordsQueryReply.entries?.length).toBe(0);
+                expect(recordsQueryReply.entries).toHaveLength(0);
                 // generate and write a new `RecordsWrite` to overwrite the existing record
                 const newDataBytes = Encoder.stringToBytes('new data');
                 const newDataEncoded = Encoder.bytesToBase64Url(newDataBytes);
@@ -1225,7 +1225,7 @@ export function testRecordsWriteHandler() {
                 // verify new `RecordsWrite` has overwritten the existing record with new data
                 const newRecordsQueryReply = await dwn.processMessage(alice.did, recordsQueryMessageData.message);
                 expect(newRecordsQueryReply.status.code).toBe(200);
-                expect(newRecordsQueryReply.entries?.length).toBe(1);
+                expect(newRecordsQueryReply.entries).toHaveLength(1);
                 expect(newRecordsQueryReply.entries[0].encodedData).toBe(newDataEncoded);
             });
             it('should not allow non-initial writes to be written without supplying data', async () => {
@@ -1244,7 +1244,7 @@ export function testRecordsWriteHandler() {
                 });
                 const recordsQueryReply = await dwn.processMessage(alice.did, recordsQueryMessageData.message);
                 expect(recordsQueryReply.status.code).toBe(200);
-                expect(recordsQueryReply.entries?.length).toBe(1);
+                expect(recordsQueryReply.entries).toHaveLength(1);
                 // generate and write a new `RecordsWrite` to overwrite the existing record
                 const newDataBytes = Encoder.stringToBytes('new data');
                 const newRecordsWrite = await TestDataGenerator.generateFromRecordsWrite({
@@ -1259,7 +1259,7 @@ export function testRecordsWriteHandler() {
                 // verify the original `RecordsWrite` and data are still available
                 const newRecordsQueryReply = await dwn.processMessage(alice.did, recordsQueryMessageData.message);
                 expect(newRecordsQueryReply.status.code).toBe(200);
-                expect(newRecordsQueryReply.entries?.length).toBe(1);
+                expect(newRecordsQueryReply.entries).toHaveLength(1);
                 const originalEncodedData = Encoder.bytesToBase64Url(dataBytes);
                 expect(newRecordsQueryReply.entries[0].encodedData).toBe(originalEncodedData);
             });
@@ -1611,7 +1611,7 @@ export function testRecordsWriteHandler() {
                         });
                         const recordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                         expect(recordsQueryReply.status.code).toBe(200);
-                        expect(recordsQueryReply.entries?.length).toBe(1);
+                        expect(recordsQueryReply.entries).toHaveLength(1);
                         expect(recordsQueryReply.entries[0].descriptor.published).toBe(true);
                         // very importantly verify the original data is still returned
                         expect(recordsQueryReply.entries[0].encodedData).toBe(encodedData);
@@ -1643,7 +1643,7 @@ export function testRecordsWriteHandler() {
                         });
                         const recordsQueryReply = await dwn.processMessage(tenant, recordsQueryMessageData.message);
                         expect(recordsQueryReply.status.code).toBe(200);
-                        expect(recordsQueryReply.entries?.length).toBe(1);
+                        expect(recordsQueryReply.entries).toHaveLength(1);
                         const recordsWriteReturned = recordsQueryReply.entries[0];
                         expect(recordsWriteReturned.encodedData).toBe(Encoder.bytesToBase64Url(newData));
                         expect(recordsWriteReturned.descriptor.published).toBe(true);
@@ -1718,7 +1718,7 @@ export function testRecordsWriteHandler() {
                         expect(newestWriteReply.status.code).toBe(202);
                         const deletedMessageCid = await Message.getCid(newWrite.message);
                         const { messages } = await messageStore.query(author.did, [{ recordId: message.recordId }]);
-                        expect(messages.length).toBe(2); // first write + latest write
+                        expect(messages).toHaveLength(2); // first write + latest write
                         const retainedCids = await Promise.all(messages.map((storedMessage) => Message.getCid(storedMessage)));
                         expect(retainedCids).not.toContain(deletedMessageCid);
                     });
@@ -1758,7 +1758,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryReply = await dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
                     expect(bobRecordsQueryReply.status.code).toBe(200);
-                    expect(bobRecordsQueryReply.entries?.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries).toHaveLength(1);
                     expect(bobRecordsQueryReply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(bobData));
                 });
                 it('should allow co-update with allow-anyone rule', async () => {
@@ -1854,7 +1854,7 @@ export function testRecordsWriteHandler() {
                         });
                         const applicationResponseQueryReply = await dwn.processMessage(alice.did, messageDataForQueryingCredentialResponse.message);
                         expect(applicationResponseQueryReply.status.code).toBe(200);
-                        expect(applicationResponseQueryReply.entries?.length).toBe(1);
+                        expect(applicationResponseQueryReply.entries).toHaveLength(1);
                         expect(applicationResponseQueryReply.entries[0].encodedData)
                             .toBe(base64url.baseEncode(encodedCredentialResponse));
                     });
@@ -2016,7 +2016,7 @@ export function testRecordsWriteHandler() {
                         });
                         const applicationResponseQueryReply = await dwn.processMessage(bob.did, messageDataForQueryingCaptionResponse.message);
                         expect(applicationResponseQueryReply.status.code).toBe(200);
-                        expect(applicationResponseQueryReply.entries?.length).toBe(1);
+                        expect(applicationResponseQueryReply.entries).toHaveLength(1);
                         expect(applicationResponseQueryReply.entries[0].encodedData)
                             .toBe(base64url.baseEncode(encodedCaption));
                     });
@@ -2680,7 +2680,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryReply = await dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
                     expect(bobRecordsQueryReply.status.code).toBe(200);
-                    expect(bobRecordsQueryReply.entries?.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries).toHaveLength(1);
                     expect(bobRecordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(bobData));
                     // generate a new message from bob updating the existing message
                     const updatedMessageBytes = Encoder.stringToBytes('updated message from bob');
@@ -2694,7 +2694,7 @@ export function testRecordsWriteHandler() {
                     // verify bob's message got written to the DB
                     const newRecordQueryReply = await dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
                     expect(newRecordQueryReply.status.code).toBe(200);
-                    expect(newRecordQueryReply.entries?.length).toBe(1);
+                    expect(newRecordQueryReply.entries).toHaveLength(1);
                     expect(newRecordQueryReply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(updatedMessageBytes));
                 });
                 it('should disallow overwriting existing records by a different author if author is not authorized to `co-update`', async () => {
@@ -2732,7 +2732,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryReply = await dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
                     expect(bobRecordsQueryReply.status.code).toBe(200);
-                    expect(bobRecordsQueryReply.entries?.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries).toHaveLength(1);
                     expect(bobRecordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(bobData));
                     // generate a well-formed update from Carol, which should not be allowed/accepted
                     const modifiedMessageData = new TextEncoder().encode('modified message by carol');
@@ -2781,7 +2781,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryReply = await dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
                     expect(bobRecordsQueryReply.status.code).toBe(200);
-                    expect(bobRecordsQueryReply.entries?.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries).toHaveLength(1);
                     expect(bobRecordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(bobData));
                     // generate a new message from bob changing immutable recipient
                     const updatedMessageFromBob = await TestDataGenerator.generateRecordsWrite({
@@ -3043,7 +3043,7 @@ export function testRecordsWriteHandler() {
                             secret: {}
                         }
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     // Alice installs the protocol
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
@@ -3079,7 +3079,7 @@ export function testRecordsWriteHandler() {
                             secret: {}
                         }
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     // Alice installs the protocol
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
@@ -3134,7 +3134,7 @@ export function testRecordsWriteHandler() {
                             },
                         },
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: encryptedProtocolDefinition,
@@ -3201,7 +3201,7 @@ export function testRecordsWriteHandler() {
                             },
                         },
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: encryptedProtocolDefinition,
@@ -3279,7 +3279,7 @@ export function testRecordsWriteHandler() {
                             },
                         },
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: encryptedProtocolDefinition,
@@ -3478,7 +3478,7 @@ export function testRecordsWriteHandler() {
                             },
                         },
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: encryptedProtocolDefinition,
@@ -3564,7 +3564,7 @@ export function testRecordsWriteHandler() {
                             },
                         },
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: encryptedProtocolDefinition,
@@ -3643,7 +3643,7 @@ export function testRecordsWriteHandler() {
                             secret: {},
                         }
                     };
-                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, TestDataGenerator.createProtocolPathKeyDeriver(alice.keyId, alice.encryptionKeyPair.privateJwk));
                     // Alice installs the protocol
                     const protocolConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
@@ -3836,7 +3836,7 @@ export function testRecordsWriteHandler() {
                     // verify the data is written
                     const recordsQueryReply = await dwn.processMessage(pfi.did, recordsQueryMessageData.message);
                     expect(recordsQueryReply.status.code).toBe(200);
-                    expect(recordsQueryReply.entries?.length).toBe(1);
+                    expect(recordsQueryReply.entries).toHaveLength(1);
                     expect(recordsQueryReply.entries[0].descriptor.dataCid).toBe(fulfillmentMessageData.message.descriptor.dataCid);
                 });
                 it('should fail authorization if incoming message contains `parentId` that leads to no record', async () => {
@@ -4110,7 +4110,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryReply = await dwn.processMessage(alice.did, bobRecordsQuery.message);
                     expect(bobRecordsQueryReply.status.code).toBe(200);
-                    expect(bobRecordsQueryReply.entries?.length).toBe(0);
+                    expect(bobRecordsQueryReply.entries).toHaveLength(0);
                     //further sanity query for specific recordId
                     const bobRecordsQueryRecordId = await RecordsQuery.create({
                         filter: {
@@ -4120,7 +4120,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryRecordIdReply = await dwn.processMessage(alice.did, bobRecordsQueryRecordId.message);
                     expect(bobRecordsQueryRecordIdReply.status.code).toBe(200);
-                    expect(bobRecordsQueryRecordIdReply.entries?.length).toBe(0);
+                    expect(bobRecordsQueryRecordIdReply.entries).toHaveLength(0);
                     // attempt update recordsWrite without data, this will reject
                     const updateRecord = await RecordsWrite.createFrom({
                         recordsWriteMessage: imageRecordsWrite.message,
@@ -4133,7 +4133,7 @@ export function testRecordsWriteHandler() {
                     // sanity still can't query
                     const bobRecordsQueryReply2 = await dwn.processMessage(alice.did, bobRecordsQuery.message);
                     expect(bobRecordsQueryReply2.status.code).toBe(200);
-                    expect(bobRecordsQueryReply2.entries?.length).toBe(0);
+                    expect(bobRecordsQueryReply2.entries).toHaveLength(0);
                 });
                 it('#359 - should not allow access of data by referencing `dataCid` in protocol authorized `RecordsWrite` with large data', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -4192,7 +4192,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryReply = await dwn.processMessage(alice.did, bobRecordsQuery.message);
                     expect(bobRecordsQueryReply.status.code).toBe(200);
-                    expect(bobRecordsQueryReply.entries?.length).toBe(0);
+                    expect(bobRecordsQueryReply.entries).toHaveLength(0);
                     //further sanity query for specific recordId
                     const bobRecordsQueryRecordId = await RecordsQuery.create({
                         filter: {
@@ -4202,7 +4202,7 @@ export function testRecordsWriteHandler() {
                     });
                     const bobRecordsQueryRecordIdReply = await dwn.processMessage(alice.did, bobRecordsQueryRecordId.message);
                     expect(bobRecordsQueryRecordIdReply.status.code).toBe(200);
-                    expect(bobRecordsQueryRecordIdReply.entries?.length).toBe(0);
+                    expect(bobRecordsQueryRecordIdReply.entries).toHaveLength(0);
                     // attempt update recordsWrite without data, this will reject
                     const updateRecord = await RecordsWrite.createFrom({
                         recordsWriteMessage: imageRecordsWrite.message,
@@ -4215,7 +4215,7 @@ export function testRecordsWriteHandler() {
                     // sanity still can't query
                     const bobRecordsQueryReply2 = await dwn.processMessage(alice.did, bobRecordsQuery.message);
                     expect(bobRecordsQueryReply2.status.code).toBe(200);
-                    expect(bobRecordsQueryReply2.entries?.length).toBe(0);
+                    expect(bobRecordsQueryReply2.entries).toHaveLength(0);
                 });
                 it('should allow record with or without schema if protocol does not require schema for a record type', async () => {
                     // scenario: Alice's DWN has a protocol that allows anyone to write a record without schema
@@ -4260,7 +4260,7 @@ export function testRecordsWriteHandler() {
                     });
                     const recordsReadReply = await dwn.processMessage(alice.did, recordsQuery.message);
                     expect(recordsReadReply.status.code).toBe(200);
-                    expect(recordsReadReply.entries?.length).toBe(2);
+                    expect(recordsReadReply.entries).toHaveLength(2);
                 });
                 it('should allow authorization if protocol message size is within min and max size', async () => {
                     const alice = await TestDataGenerator.generatePersona();
@@ -5042,7 +5042,7 @@ export function testRecordsWriteHandler() {
                 });
                 const aliceQueryWriteAfterAliceWriteReply = await dwn.processMessage(alice.did, aliceQueryWriteAfterAliceWriteData.message);
                 expect(aliceQueryWriteAfterAliceWriteReply.status.code).toBe(200);
-                expect(aliceQueryWriteAfterAliceWriteReply.entries?.length).toBe(1);
+                expect(aliceQueryWriteAfterAliceWriteReply.entries).toHaveLength(1);
                 expect(aliceQueryWriteAfterAliceWriteReply.entries[0].encodedData).toBe(encodedData);
                 // bob learns of the CID of data of alice and tries to gain unauthorized access by referencing it in his own DWN
                 const bobWriteData = await TestDataGenerator.generateRecordsWrite({
@@ -5058,7 +5058,7 @@ export function testRecordsWriteHandler() {
                 });
                 const aliceQueryWriteAfterBobWriteReply = await dwn.processMessage(alice.did, aliceQueryWriteAfterBobWriteData.message);
                 expect(aliceQueryWriteAfterBobWriteReply.status.code).toBe(200);
-                expect(aliceQueryWriteAfterBobWriteReply.entries?.length).toBe(1);
+                expect(aliceQueryWriteAfterBobWriteReply.entries).toHaveLength(1);
                 expect(aliceQueryWriteAfterBobWriteReply.entries[0].encodedData).toBe(encodedData);
                 // verify that bob has not gained access to alice's data
                 const bobQueryAfterBobWriteData = await TestDataGenerator.generateRecordsQuery({
@@ -5067,7 +5067,7 @@ export function testRecordsWriteHandler() {
                 });
                 const bobQueryAfterBobWriteReply = await dwn.processMessage(bob.did, bobQueryAfterBobWriteData.message);
                 expect(bobQueryAfterBobWriteReply.status.code).toBe(200);
-                expect(bobQueryAfterBobWriteReply.entries?.length).toBe(0);
+                expect(bobQueryAfterBobWriteReply.entries).toHaveLength(0);
             });
             describe('encodedData threshold', () => {
                 it('should call cloneAndAddEncodedData if dataSize is less than or equal to the threshold', async () => {