@enbox/dwn-sdk-js 0.4.8 → 0.4.9

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

@@ -1866,7 +1866,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record with new tags
                 const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
@@ -1883,7 +1883,7 @@ export function testRecordsTags() {
                 // Sanity: Query for the old tag value should return no results
                 const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+                expect(tagsQueryMatchReply2.entries).toHaveLength(0);
             });
             it('should not index tags when the record is not `latestBaseState`', async () => {
                 const buildTagIndexSpy = sinon.spy(Records, 'buildTagIndexes');
@@ -1951,7 +1951,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // negative result same tag different value
                 let tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
@@ -1964,7 +1964,7 @@ export function testRecordsTags() {
                 });
                 let tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries).toHaveLength(0);
                 // negative result different tag same value
                 tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1976,7 +1976,7 @@ export function testRecordsTags() {
                 });
                 tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries).toHaveLength(0);
             });
             it('should be able to filter by number match', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2004,7 +2004,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // negative result same tag different value
                 let tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
@@ -2017,7 +2017,7 @@ export function testRecordsTags() {
                 });
                 let tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries).toHaveLength(0);
                 // negative result different tag same value
                 tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2029,7 +2029,7 @@ export function testRecordsTags() {
                 });
                 tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries).toHaveLength(0);
             });
             it('should be able to filter by boolean match', async () => {
                 // 1. Write a record with a boolean tag `booleanTag` set to true
@@ -2072,7 +2072,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchTrueReply = await dwn.processMessage(alice.did, tagsQueryMatchTrue.message);
                 expect(tagsQueryMatchTrueReply.status.code).toBe(200);
-                expect(tagsQueryMatchTrueReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchTrueReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchTrueReply.entries[0].recordId).toBe(tagsRecordTrue.message.recordId);
                 // query for records with a `booleanTag` set to false, should return the record with the false tag
                 const tagsQueryMatchFalse = await TestDataGenerator.generateRecordsQuery({
@@ -2085,7 +2085,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchFalseReply = await dwn.processMessage(alice.did, tagsQueryMatchFalse.message);
                 expect(tagsQueryMatchFalseReply.status.code).toBe(200);
-                expect(tagsQueryMatchFalseReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchFalseReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchFalseReply.entries[0].recordId).toBe(tagsRecordFalse.message.recordId);
                 // negative result for a non existent boolean tag.
                 const tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
@@ -2098,7 +2098,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries).toHaveLength(0);
             });
             it('should be able to range filter by string value', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2153,7 +2153,7 @@ export function testRecordsTags() {
                 });
                 const queryForAllReply = await dwn.processMessage(alice.did, queryForAll.message);
                 expect(queryForAllReply.status.code).toBe(200);
-                expect(queryForAllReply.entries?.length).toBe(4); // all 4 records
+                expect(queryForAllReply.entries).toHaveLength(4); // all 4 records
                 // query for first names that begin with 'a' and 'b'
                 const queryForAtoB = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -2166,7 +2166,7 @@ export function testRecordsTags() {
                 });
                 const queryForAtoBReply = await dwn.processMessage(alice.did, queryForAtoB.message);
                 expect(queryForAtoBReply.status.code).toBe(200);
-                expect(queryForAtoBReply.entries?.length).toBe(2);
+                expect(queryForAtoBReply.entries).toHaveLength(2);
                 const atobRecordIds = queryForAtoBReply.entries.map(entry => entry.recordId);
                 expect(atobRecordIds).toEqual(expect.arrayContaining([aliceRecord.message.recordId, bobRecord.message.recordId]));
                 // query for first names greater than 'bob'(exclusive of), and less than but inclusive of 'daniel'
@@ -2181,7 +2181,7 @@ export function testRecordsTags() {
                 });
                 const queryForBtoDReply = await dwn.processMessage(alice.did, queryForBtoD.message);
                 expect(queryForBtoDReply.status.code).toBe(200);
-                expect(queryForBtoDReply.entries?.length).toBe(2);
+                expect(queryForBtoDReply.entries).toHaveLength(2);
                 const btodRecordIds = queryForBtoDReply.entries.map(entry => entry.recordId);
                 expect(btodRecordIds).toEqual(expect.arrayContaining([carolRecord.message.recordId, danielRecord.message.recordId]));
                 // query for first names that begin with 'carol' onward (inclusive).
@@ -2196,7 +2196,7 @@ export function testRecordsTags() {
                 });
                 const queryForCarolOnwardReply = await dwn.processMessage(alice.did, queryForCarolOnward.message);
                 expect(queryForCarolOnwardReply.status.code).toBe(200);
-                expect(queryForCarolOnwardReply.entries?.length).toBe(2);
+                expect(queryForCarolOnwardReply.entries).toHaveLength(2);
                 const onwardResults = queryForCarolOnwardReply.entries.map(entry => entry.recordId);
                 expect(onwardResults).toEqual(expect.arrayContaining([carolRecord.message.recordId, danielRecord.message.recordId]));
             });
@@ -2246,7 +2246,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(2);
+                expect(tagsQueryMatchReply.entries).toHaveLength(2);
                 const matchedRecords = tagsQueryMatchReply.entries.map(entry => entry.recordId);
                 expect(matchedRecords).toEqual(expect.arrayContaining([tagsRecord1.message.recordId, tagsRecord2.message.recordId]));
                 // sanity/control: a regular range query will return all
@@ -2261,7 +2261,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryRangeReply = await dwn.processMessage(alice.did, tagsQueryRange.message);
                 expect(tagsQueryRangeReply.status.code).toBe(200);
-                expect(tagsQueryRangeReply.entries?.length).toBe(3); // returned all 3 records
+                expect(tagsQueryRangeReply.entries).toHaveLength(3); // returned all 3 records
             });
             it('should be able to range filter by number value', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2320,7 +2320,7 @@ export function testRecordsTags() {
                 });
                 const queryForAllReply = await dwn.processMessage(alice.did, queryForAll.message);
                 expect(queryForAllReply.status.code).toBe(200);
-                expect(queryForAllReply.entries?.length).toBe(4); // all 4 records
+                expect(queryForAllReply.entries).toHaveLength(4); // all 4 records
                 // query for all records that received higher than(not including) an 80
                 // only one record should match
                 const queryForHighGrade = await TestDataGenerator.generateRecordsQuery({
@@ -2334,7 +2334,7 @@ export function testRecordsTags() {
                 });
                 const queryForHighReply = await dwn.processMessage(alice.did, queryForHighGrade.message);
                 expect(queryForHighReply.status.code).toBe(200);
-                expect(queryForHighReply.entries?.length).toBe(1);
+                expect(queryForHighReply.entries).toHaveLength(1);
                 expect(queryForHighReply.entries[0].recordId).toBe(danielRecord.message.recordId);
                 // query for all records that received higher (and including) a 75
                 // three records should match
@@ -2349,7 +2349,7 @@ export function testRecordsTags() {
                 });
                 const queryForPassingGradeReply = await dwn.processMessage(alice.did, queryForPassingGrade.message);
                 expect(queryForPassingGradeReply.status.code).toBe(200);
-                expect(queryForPassingGradeReply.entries?.length).toBe(3);
+                expect(queryForPassingGradeReply.entries).toHaveLength(3);
                 const passingRecords = queryForPassingGradeReply.entries.map(entry => entry.recordId);
                 expect(passingRecords).toEqual(expect.arrayContaining([
                     danielRecord.message.recordId, bobRecord.message.recordId, aliceRecord.message.recordId
@@ -2366,7 +2366,7 @@ export function testRecordsTags() {
                 });
                 const queryForPoorGradesReply = await dwn.processMessage(alice.did, queryForPoorGrades.message);
                 expect(queryForPoorGradesReply.status.code).toBe(200);
-                expect(queryForPoorGradesReply.entries?.length).toBe(1);
+                expect(queryForPoorGradesReply.entries).toHaveLength(1);
                 expect(queryForPoorGradesReply.entries[0].recordId).toBe(carolRecord.message.recordId);
                 // query for passing grades that were not perfect scores
                 const queryForRange = await TestDataGenerator.generateRecordsQuery({
@@ -2380,7 +2380,7 @@ export function testRecordsTags() {
                 });
                 const queryForRangeReply = await dwn.processMessage(alice.did, queryForRange.message);
                 expect(queryForRangeReply.status.code).toBe(200);
-                expect(queryForRangeReply.entries?.length).toBe(2);
+                expect(queryForRangeReply.entries).toHaveLength(2);
                 const rangeRecords = queryForRangeReply.entries.map(entry => entry.recordId);
                 expect(rangeRecords).toEqual(expect.arrayContaining([bobRecord.message.recordId, aliceRecord.message.recordId]));
             });
@@ -2407,7 +2407,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record with new tags
                 const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
@@ -2420,7 +2420,7 @@ export function testRecordsTags() {
                 // issuing the same query should return no results
                 const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+                expect(tagsQueryMatchReply2.entries).toHaveLength(0);
             });
             it('should not return results if the record was updated with empty tags', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -2445,7 +2445,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record without any tags
                 const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
@@ -2457,7 +2457,7 @@ export function testRecordsTags() {
                 // issuing the same query should return no results
                 const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+                expect(tagsQueryMatchReply2.entries).toHaveLength(0);
             });
         });
         describe('RecordsDelete with tags', () => {
@@ -2486,7 +2486,7 @@ export function testRecordsTags() {
                 });
                 const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect(tagsQueryMatchReply.entries?.length).toBe(1);
+                expect(tagsQueryMatchReply.entries).toHaveLength(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // delete the record
                 const recordDelete = await TestDataGenerator.generateRecordsDelete({
@@ -2498,7 +2498,7 @@ export function testRecordsTags() {
                 // issue the the same query should return no results
                 const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+                expect(tagsQueryMatchReply2.entries).toHaveLength(0);
             });
         });
     });