@k-int/stripes-kint-components 5.36.0 → 5.37.0

package/src/lib/utils/generateKiwtQueryParams/generateKiwtQueryParams.test.js

@@ -1,27 +1,258 @@
 import generateKiwtQuery from '../generateKiwtQuery';
 
-// FIXME we need to test more than this
 describe('generateKiwtQueryParams', () => {
-  describe('generateKiwtQueryParams nested group filters', () => {
-    test('EXAMPLE nested AND shape', () => {
-      expect(generateKiwtQuery({
-        filters: [{
-          groupValues: {
-            AND: [
-              { path: 'wobble', value: 'test' },
-              {
+  describe('generateKiwtQueryParams', () => {
+    describe.each([
+      {
+        label: 'Recursive Filter Groups',
+        cases: [
+          {
+            label: 'Simple AND group',
+            options: {
+              filters: [
+                {
+                  groupValues: {
+                    AND: [
+                      { path: 'a', value: '1' },
+                      { path: 'b', value: '2' }
+                    ]
+                  }
+                }
+              ]
+            },
+            ns: {},
+            expected: '?filters=a==1&&b==2&stats=true'
+          },
+          {
+            label: 'Nested AND/OR with NOT',
+            options: {
+              filters: [
+                {
+                  groupValues: {
+                    NOT: true,
+                    OR: [
+                      { path: 'a', value: '1' },
+                      {
+                        groupValues: {
+                          AND: [
+                            { path: 'b', value: '2' },
+                            { path: 'c', value: '3' }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            ns: {},
+            expected: '?filters=!(a==1||(b==2&&c==3))&stats=true'
+          },
+          {
+            label: 'Nested AND/OR with complex values',
+            options: {
+              filters: [{
                 groupValues: {
-                  OR: [
-                    { value: 'test2' },
-                    { path: 'sup', value: 'test3' },
-                    { groupValues: { AND: [{ value: 'test4' }, { path: 'help', comparator: '!=', value: 'false' }] } },
+                  AND: [
+                    { path: 'wobble', value: 'test' },
+                    {
+                      groupValues: {
+                        OR: [
+                          { value: 'test2' },
+                          { path: 'sup', value: 'test3' },
+                          { groupValues: { AND: [{ value: 'test4' }, { path: 'help', comparator: '!=', value: 'false' }] } },
+                        ]
+                      }
+                    },
                   ]
                 }
-              },
-            ]
+              }]
+            },
+            ns: {},
+            expected: '?filters=wobble==test&&(test2||sup==test3||(test4&&help!=false))&stats=true'
+          },
+          {
+            label: 'Path-less values (standalone)',
+            options: { filters: [{ values: ['foo', 'bar'], comparator: '==' }] },
+            ns: {},
+            expected: '?filters=foo||bar&stats=true'
+          },
+          {
+            label: 'Complex comparator override',
+            options: { filters: [{ path: 'status', value: 'active', comparator: '!=' }] },
+            ns: {},
+            expected: '?filters=status!=active&stats=true'
+          },
+          {
+            label: 'Option filters with multiple values (plural array)',
+            options: {
+              filters: [
+                { path: 'status', values: ['active', 'deleted'], comparator: '==' },
+                { values: ['standalone1', 'standalone2'] }
+              ]
+            },
+            ns: {},
+            expected: '?filters=status==active||status==deleted&filters=standalone1||standalone2&stats=true'
+          },
+          {
+            label: 'Trigger default comparator (==) and empty filter object',
+            options: {
+              filters: [
+                { path: 'noComp', value: 'foo' },
+                {}
+              ]
+            },
+            ns: {},
+            expected: '?filters=noComp==foo&stats=true'
+          },
+        ]
+      },
+      {
+        label: 'Namespace Filter Mapping (nsValues)',
+        cases: [
+          {
+            label: 'Basic dot notation (no filterKeys)',
+            options: {},
+            ns: { filters: 'status.active,type.local' },
+            expected: '?filters=active&filters=local&stats=true'
+          },
+          {
+            label: 'Config with custom prefix',
+            options: { filterConfig: [{ name: 'status', filterPrefix: 'custom=' }] },
+            ns: { filters: 'status.active' },
+            expected: '?custom=status==active&stats=true'
+          },
+          {
+            label: 'Config with value mapping override',
+            options: { filterConfig: [{ name: 'range', valuesMapping: (v) => `min==${v[0]}&&max==${v[1]}` }] },
+            ns: { filters: 'range.10,range.20' },
+            expected: '?filters=min==10&&max==20&stats=true'
+          },
+          {
+            label: 'Key mapping (filterKeys)',
+            options: { filterKeys: { status: 'st' } },
+            ns: { filters: 'status.active' },
+            expected: '?filters=st==active&stats=true'
+          },
+          {
+            label: 'Namespace filters with complex config value/comparator overrides',
+            options: {
+              filterKeys: { status: 'st' },
+              filterConfig: [{
+                name: 'status',
+                values: [
+                  { name: 'active', value: 'is-active', comparator: '==' },
+                  { name: 'void', value: 'is-null', comparator: 'isSet' }
+                ]
+              }]
+            },
+            ns: { filters: 'status.active,status.void' },
+            expected: '?filters=st==is-active||stisSetis-null&stats=true'
+          },
+          {
+            label: 'Search using qindex instead of searchKey',
+            options: { searchKey: undefined },
+            ns: { qindex: 'title,name', query: 'test' },
+            expected: '?match=title&match=name&term=test&stats=true'
+          },
+        ]
+      },
+      {
+        label: 'Sorting Logic & Precedence',
+        cases: [
+          {
+            label: 'Options sort (manual path)',
+            options: { sort: [{ path: 'name', direction: 'desc' }] },
+            ns: {},
+            expected: '?sort=name;desc&stats=true'
+          },
+          {
+            label: 'Options sort (value override)',
+            options: { sort: [{ value: 'special_sort_logic' }] },
+            ns: {},
+            expected: '?sort=special_sort_logic&stats=true'
+          },
+          {
+            label: 'NS Sort with hyphen negation',
+            options: {},
+            ns: { sort: '-name' },
+            expected: '?sort=name;desc&stats=true'
+          },
+          {
+            label: 'NS Sort with mapped sortKeys',
+            options: { sortKeys: { creator: 'user.name' } },
+            ns: { sort: 'creator' },
+            expected: '?sort=user.name;asc&stats=true'
+          },
+          {
+            label: 'Mixed NS Sort (mapped and hyphenated)',
+            options: { sortKeys: { creator: 'user.name' } },
+            ns: { sort: '-creator' },
+            expected: '?sort=user.name;desc&stats=true'
+          },
+          {
+            label: 'NS Sort with multiple comma-separated fields',
+            options: {},
+            ns: { sort: 'name,-date,size' },
+            expected: '?sort=name;asc&sort=date;desc&sort=size;asc&stats=true'
+          },
+          {
+            label: 'NS Sort complex XOR logic (Hyphen in key AND hyphen in mapping)',
+            options: {
+              sortKeys: { legacy: '-oldField' }
+            },
+            ns: { sort: '-legacy' },
+            // reverse = true, descending = true -> should result in 'asc'
+            expected: '?sort=oldField;asc&stats=true'
+          },
+        ]
+      },
+      {
+        label: 'Edge Cases & Param Cleaning',
+        cases: [
+          {
+            label: 'Ignored keys (totalRecords)',
+            options: { totalRecords: 999, other: 'keep' },
+            ns: {},
+            expected: '?stats=true&other=keep'
+          },
+          {
+            label: 'Search match/term splitting',
+            options: { searchKey: 'name,code' },
+            ns: { query: 'test' },
+            expected: '?match=name&match=code&term=test&stats=true'
+          },
+          {
+            label: 'Stats turned off',
+            options: { stats: false },
+            ns: {},
+            expected: '' // paramsArray will be empty if no other options passed
+          },
+          {
+            label: 'Empty nsValues / defaults',
+            options: {},
+            ns: {},
+            expected: '?stats=true'
           }
-        }]
-      }, {}, false)).toEqual('?filters=wobble==test&&(test2||sup==test3||(test4&&help!=false))&stats=true');
+        ]
+      }
+    ])('$label', ({ cases }) => {
+      test.each(cases)('$label', ({ options, ns, expected }) => {
+        // Running with encode = false to make reading your manual verification easier
+        const result = generateKiwtQuery(options, ns, false);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe('Encoding Toggles', () => {
+      test.each([
+        ['Encoded', true, '?filters=a%20b%3D%3Dc%20d&stats=true'],
+        ['Plain', false, '?filters=a b==c d&stats=true']
+      ])('Handles %s mode', (_label, encode, expected) => {
+        const options = { filters: [{ path: 'a b', value: 'c d' }] };
+        const result = generateKiwtQuery(options, {}, encode);
+        expect(result).toEqual(expected);
+      });
     });
   });
 });