test: unit and api tests for tags and referenceNot In operators

Author: harshithad0703

test/api/entry-queryables.spec.ts

@@ -116,6 +116,32 @@ describe('Query Operators API test cases', () => {
         expect(entryQuery.entries[0].title).toBe('test');
       }
     });
+    it('should return entry for referenceNotIn query', async () => {
+      const query = makeEntries('contenttype_uid').query().where('title', QueryOperation.EQUALS, 'value');
+      const entryQuery = await makeEntries('contenttype_uid').query().referenceNotIn('reference_uid', query).find<TEntry>();
+
+      if (entryQuery.entries) {
+        expect(entryQuery.entries[0]._version).toBeDefined();
+        expect(entryQuery.entries[0].locale).toBeDefined();
+        expect(entryQuery.entries[0].uid).toBeDefined();
+        expect(entryQuery.entries[0].title).not.toBe('test');
+        expect(entryQuery.entries[0].title).toBe('value2');
+        expect(entryQuery.entries[1]._version).toBeDefined();
+        expect(entryQuery.entries[1].locale).toBeDefined();
+        expect(entryQuery.entries[1].uid).toBeDefined();
+        expect(entryQuery.entries[1].title).toBe('value');
+      }
+    });
+
+    it('should return entry if tags are matching', async () => {
+      const query = await makeEntries('contenttype_uid').query().tags(['tag1']).find<TEntry>();
+      if (query.entries) {
+        expect(query.entries[0]._version).toBeDefined();
+        expect(query.entries[0].locale).toBeDefined();
+        expect(query.entries[0].uid).toBeDefined();
+        expect(query.entries[0].title).toBe('value');
+      }
+    });
 });
 
 function makeEntries(contentTypeUid = ''): Entries {

test/unit/entry-queryable.spec.ts

@@ -47,11 +47,24 @@ describe('Query Operators API test cases', () => {
       const query = contentType.Entry().query().equalTo('fieldUID', 'value');
       expect(query._parameters).toStrictEqual({ 'fieldUID': 'value' });
     });
-    it('should return entry for referencedIn query', async () => {
-      const query1 = contentType.Entry().query().containedIn('fieldUID', ['value']);
+    it('should return entry for referenceIn query', async () => {
+      const query1 = contentType.Entry().query().where('fieldUID', QueryOperation.EQUALS, 'value');
       const entryQuery = await contentType.Entry().query().referenceIn('reference_uid', query1);
       if (entryQuery) {
-        expect(entryQuery._parameters).toEqual({ reference_uid: { '$in_query': { fieldUID: { '$in': [ 'value' ] } } } });
+        expect(entryQuery._parameters).toEqual({ reference_uid: { '$in_query': { fieldUID: 'value' } } });
+      }
+    });
+    it('should return entry for referenceNotIn query', async () => {
+      const query1 = contentType.Entry().query().where('fieldUID', QueryOperation.EQUALS, 'value');
+      const entryQuery = await contentType.Entry().query().referenceNotIn('reference_uid', query1);
+      if (entryQuery) {
+        expect(entryQuery._parameters).toEqual({ reference_uid: { '$nin_query': { fieldUID: 'value' } } });
+      }
+    });
+    it('should return entry if tags are matching', async () => {
+      const query =  contentType.Entry().query().tags(['tag1']);
+      if (query) {
+        expect(query._parameters).toEqual({ tags: ['tag1'] });
       }
     });
 });