@eeacms/volto-globalsearch 2.1.2 → 4.0.0

package/src/config/clusters.test.js

@@ -0,0 +1,221 @@
+import '@testing-library/jest-dom';
+
+import config, {
+  clusters,
+  clusterIcons,
+  typesForClustersOptionsFilter,
+} from './clusters';
+
+// Mock static image imports
+jest.mock('../static/website-logo.png', () => 'website-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/eea-logo.svg', () => 'eea-logo.svg', { virtual: true });
+jest.mock('../static/ias-logo.png', () => 'ias-logo.png', { virtual: true });
+jest.mock('../static/bise-logo.png', () => 'bise-logo.png', { virtual: true });
+jest.mock('../static/wise-logo.png', () => 'wise-logo.png', { virtual: true });
+jest.mock('../static/energy-logo.png', () => 'energy-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/water-logo.png', () => 'water-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/forest-logo.png', () => 'forest-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/industry-logo.png', () => 'industry-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/climate-adapt-logo.png', () => 'climate-adapt-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/eionet-logo.png', () => 'eionet-logo.png', {
+  virtual: true,
+});
+jest.mock('../static/etc-atni.png', () => 'etc-atni.png', { virtual: true });
+jest.mock('../static/etc-bd.jpg', () => 'etc-bd.jpg', { virtual: true });
+jest.mock('../static/etc-cca.jpeg', () => 'etc-cca.jpeg', { virtual: true });
+jest.mock('../static/etc-cme.png', () => 'etc-cme.png', { virtual: true });
+jest.mock('../static/etc-icm.jpg', () => 'etc-icm.jpg', { virtual: true });
+jest.mock('../static/etc-uls.png', () => 'etc-uls.png', { virtual: true });
+jest.mock('../static/etc-wmge.png', () => 'etc-wmge.png', { virtual: true });
+jest.mock('../static/cab-logo.png', () => 'cab-logo.png', { virtual: true });
+jest.mock(
+  '../static/copernicus_insitu_logo.svg',
+  () => 'copernicus_insitu_logo.svg',
+  { virtual: true },
+);
+
+describe('clusters configuration', () => {
+  describe('clusters object', () => {
+    it('should export clusters object', () => {
+      expect(clusters).toBeDefined();
+    });
+
+    it('should have name property', () => {
+      expect(clusters.name).toBe('op_cluster');
+    });
+
+    it('should have field property', () => {
+      expect(clusters.field).toBe('objectProvides');
+    });
+
+    it('should have clusters array', () => {
+      expect(clusters.clusters).toBeDefined();
+      expect(Array.isArray(clusters.clusters)).toBe(true);
+    });
+
+    it('should have News cluster', () => {
+      const newsCluster = clusters.clusters.find((c) => c.name === 'News');
+      expect(newsCluster).toBeDefined();
+      expect(newsCluster.values).toContain('News');
+      expect(newsCluster.values).toContain('Article');
+    });
+
+    it('should have Publications cluster', () => {
+      const pubCluster = clusters.clusters.find(
+        (c) => c.name === 'Publications',
+      );
+      expect(pubCluster).toBeDefined();
+      expect(pubCluster.values).toContain('Report');
+      expect(pubCluster.values).toContain('Indicator');
+    });
+
+    it('should have Maps and charts cluster', () => {
+      const mapsCluster = clusters.clusters.find(
+        (c) => c.name === 'Maps and charts',
+      );
+      expect(mapsCluster).toBeDefined();
+      expect(mapsCluster.values).toContain('Dashboard');
+    });
+
+    it('should have Data cluster', () => {
+      const dataCluster = clusters.clusters.find((c) => c.name === 'Data');
+      expect(dataCluster).toBeDefined();
+      expect(dataCluster.values).toContain('Data set');
+    });
+
+    it('should have Others cluster', () => {
+      const othersCluster = clusters.clusters.find((c) => c.name === 'Others');
+      expect(othersCluster).toBeDefined();
+      expect(othersCluster.values).toContain('Webpage');
+    });
+
+    it('each cluster should have defaultResultView', () => {
+      clusters.clusters.forEach((cluster) => {
+        expect(cluster.defaultResultView).toBeDefined();
+      });
+    });
+  });
+
+  describe('clusterIcons', () => {
+    it('should export clusterIcons', () => {
+      expect(clusterIcons).toBeDefined();
+    });
+
+    it('should have fallback icon', () => {
+      expect(clusterIcons.fallback).toBeDefined();
+    });
+
+    it('should have News icon mapping', () => {
+      expect(clusterIcons.News).toBeDefined();
+    });
+  });
+
+  describe('config', () => {
+    it('should export default config', () => {
+      expect(config).toBeDefined();
+    });
+
+    it('should have icons configuration', () => {
+      expect(config.icons).toBeDefined();
+    });
+
+    it('should have Content types icons', () => {
+      expect(config.icons['Content types']).toBeDefined();
+    });
+
+    it('should have Sources icons', () => {
+      expect(config.icons.Sources).toBeDefined();
+    });
+
+    it('should have contentSectionsParams', () => {
+      expect(config.contentSectionsParams).toBeDefined();
+    });
+
+    it('should have contentSectionsParams.enable set to true', () => {
+      expect(config.contentSectionsParams.enable).toBe(true);
+    });
+
+    it('should have contentSectionsParams.sectionFacetsField', () => {
+      expect(config.contentSectionsParams.sectionFacetsField).toBe(
+        'op_cluster',
+      );
+    });
+
+    it('should have clusterMapping in contentSectionsParams', () => {
+      expect(config.contentSectionsParams.clusterMapping).toBeDefined();
+    });
+  });
+
+  describe('typesForClustersOptionsFilter', () => {
+    const mockOptions = [
+      { value: 'News' },
+      { value: 'Article' },
+      { value: 'Report' },
+      { value: 'Dashboard' },
+      { value: 'Data set' },
+    ];
+
+    it('should return all options when no cluster filter is active', () => {
+      const filters = [];
+      const result = typesForClustersOptionsFilter(mockOptions, filters);
+      expect(result).toEqual(mockOptions);
+    });
+
+    it('should return all options when filters is undefined', () => {
+      const result = typesForClustersOptionsFilter(mockOptions, undefined);
+      expect(result).toEqual(mockOptions);
+    });
+
+    it('should filter options for News cluster', () => {
+      const filters = [{ field: 'op_cluster', values: ['News'] }];
+      const result = typesForClustersOptionsFilter(mockOptions, filters);
+
+      expect(result).toContainEqual({ value: 'News' });
+      expect(result).toContainEqual({ value: 'Article' });
+      expect(result).not.toContainEqual({ value: 'Report' });
+    });
+
+    it('should filter options for Publications cluster', () => {
+      const filters = [{ field: 'op_cluster', values: ['Publications'] }];
+      const result = typesForClustersOptionsFilter(mockOptions, filters);
+
+      expect(result).toContainEqual({ value: 'Report' });
+      expect(result).not.toContainEqual({ value: 'News' });
+    });
+
+    it('should filter options for Data cluster', () => {
+      const filters = [{ field: 'op_cluster', values: ['Data'] }];
+      const result = typesForClustersOptionsFilter(mockOptions, filters);
+
+      expect(result).toContainEqual({ value: 'Data set' });
+      expect(result).not.toContainEqual({ value: 'News' });
+    });
+
+    it('should filter options for Maps and charts cluster', () => {
+      const filters = [{ field: 'op_cluster', values: ['Maps and charts'] }];
+      const result = typesForClustersOptionsFilter(mockOptions, filters);
+
+      expect(result).toContainEqual({ value: 'Dashboard' });
+      expect(result).not.toContainEqual({ value: 'News' });
+    });
+
+    it('should return empty array when no options match the cluster', () => {
+      const filters = [{ field: 'op_cluster', values: ['NonExistent'] }];
+      const result = typesForClustersOptionsFilter(mockOptions, filters);
+
+      expect(result).toEqual([]);
+    });
+  });
+});

package/src/config/filters.test.js

@@ -0,0 +1,67 @@
+import filters from './filters';
+import '@testing-library/jest-dom';
+
+describe('filters configuration', () => {
+  it('should export filters object', () => {
+    expect(filters).toBeDefined();
+  });
+
+  it('should have permanentFilters array', () => {
+    expect(filters.permanentFilters).toBeDefined();
+    expect(Array.isArray(filters.permanentFilters)).toBe(true);
+  });
+
+  it('should have published workflow state filter', () => {
+    const workflowFilter = filters.permanentFilters.find(
+      (f) => f.term && f.term.hasWorkflowState === 'published',
+    );
+    expect(workflowFilter).toBeDefined();
+  });
+
+  it('should have constantScore filter function', () => {
+    const constantScoreFilter = filters.permanentFilters.find(
+      (f) => typeof f === 'function' && f.id === 'constantScore',
+    );
+    expect(constantScoreFilter).toBeDefined();
+  });
+
+  it('constantScore filter should return correct structure', () => {
+    const constantScoreFilter = filters.permanentFilters.find(
+      (f) => typeof f === 'function' && f.id === 'constantScore',
+    );
+    const result = constantScoreFilter();
+
+    expect(result.constant_score).toBeDefined();
+    expect(result.constant_score.filter).toBeDefined();
+    expect(result.constant_score.filter.bool).toBeDefined();
+    expect(result.constant_score.filter.bool.should).toBeDefined();
+    expect(Array.isArray(result.constant_score.filter.bool.should)).toBe(true);
+  });
+
+  it('constantScore filter should have must_not exists condition', () => {
+    const constantScoreFilter = filters.permanentFilters.find(
+      (f) => typeof f === 'function' && f.id === 'constantScore',
+    );
+    const result = constantScoreFilter();
+
+    const mustNotExistsCondition =
+      result.constant_score.filter.bool.should.find(
+        (s) => s.bool && s.bool.must_not && s.bool.must_not.exists,
+      );
+    expect(mustNotExistsCondition).toBeDefined();
+    expect(mustNotExistsCondition.bool.must_not.exists.field).toBe('issued');
+  });
+
+  it('constantScore filter should have range condition for issued.date', () => {
+    const constantScoreFilter = filters.permanentFilters.find(
+      (f) => typeof f === 'function' && f.id === 'constantScore',
+    );
+    const result = constantScoreFilter();
+
+    const rangeCondition = result.constant_score.filter.bool.should.find(
+      (s) => s.range && s.range['issued.date'],
+    );
+    expect(rangeCondition).toBeDefined();
+    expect(rangeCondition.range['issued.date'].lte).toBeDefined();
+  });
+});

package/src/config/healthcheck.js

@@ -10,8 +10,6 @@ import latest_tasks_for_site from './healthcheck_queries/latest_tasks_for_site.j
 import started_or_finished_site_since_last_started from './healthcheck_queries/started_or_finished_site_since_last_started.json';
 
 const default_documentCountThreshold = 60000;
-const default_queryTimeSecondsThreshold_OK = 2;
-const default_queryTimeSecondsThreshold_WARNING = 5;
 const default_failedSyncThreshold_WARNING = 5;
 const default_failedSyncThreshold_OK = 2;
 
@@ -24,11 +22,11 @@ export function buildQuery(query, values) {
 }
 
 async function executeQuery(q, appConfig, params = {}, callback) {
-  params['index_name'] = 'status_' + appConfig['index_name'];
+  const { id, host } = appConfig;
+  const url = new URL(host);
+  url.pathname = `/_es/{status_}${id}/_search`;
   const query = buildQuery(q, params);
-  //console.log(JSON.stringify(query));
-  const resp = await runRequest(query, appConfig);
-  // console.log(JSON.stringify(resp.body));
+  const resp = await runRequest(query, appConfig, url);
   return Promise.resolve(callback(resp.body, params));
 }
 
@@ -101,8 +99,7 @@ export function getlatesttasks_for_site(body, params = {}) {
 export async function getStatus(appConfig, params) {
   let resp = 'OK';
   let error = null;
-  // console.log('=======================================');
-  // console.log('STEP 1');
+  // console.log('==== STEP 1 ====');
   const step1 = await executeQuery(
     last_scheduled_started_indexing,
     appConfig,
@@ -110,16 +107,13 @@ export async function getStatus(appConfig, params) {
     getlastandnext_started_execution,
   );
 
-  // console.log(step1);
-
   // const last_successful_schedule = step1.last_started;
   let next_schedule = step1.next_execution_date;
 
   const now = params.now || Date.now() - 60 * 1000;
   if (now >= next_schedule) {
     try {
-      // console.log('=======================================');
-      // console.log('STEP 2');
+      // console.log('==== STEP 2 ====');
       const step2 = await executeQuery(
         failed_scheduled_atempts_since_last_started,
         appConfig,
@@ -127,7 +121,6 @@ export async function getStatus(appConfig, params) {
         getlastfailed_execution,
       );
       next_schedule = step2.next_execution_date;
-      // console.log(step2);
     } catch {
       resp = 'CRITICAL';
       error = 'Failed to get status info from elasticsearch';
@@ -139,19 +132,17 @@ export async function getStatus(appConfig, params) {
       error = 'Airflow stopped indexing, no new schedules in the queue';
     } else {
       try {
+        // console.log('==== STEP 3 ====');
         const step3 = await executeQuery(
           last_sync_task_since_last_start,
           appConfig,
           step1,
           getlastsynctaskssincestarted,
         );
-        // console.log(step3.sites);
         const all_sites_status = {};
         for (let i = 0; i < step3.sites.length; i++) {
           try {
-            // console.log('=======================================');
-            // console.log('STEP 4');
-            // const step4 =
+            // console.log('==== STEP 4 ====');
             await executeQuery(
               started_or_finished_site_since_last_started,
               appConfig,
@@ -162,10 +153,8 @@ export async function getStatus(appConfig, params) {
               getlastsuccessfultasks_for_site,
             );
             all_sites_status[step3.sites[i]] = 'OK';
-            // console.log(step4);
           } catch {
-            // console.log('=======================================');
-            // console.log('STEP 5');
+            // console.log('==== STEP 5 ====');
             const step5 = await executeQuery(
               latest_tasks_for_site,
               appConfig,
@@ -182,7 +171,6 @@ export async function getStatus(appConfig, params) {
             all_sites_status[step3.sites[i]] = step5;
           }
         }
-        // console.log(all_sites_status);
         const oks = [];
         const warnings = [];
         const criticals = [];
@@ -232,19 +220,12 @@ export default async function healthcheck(appConfig, params) {
   try {
     let {
       documentCountThreshold,
-      queryTimeSecondsThreshold_OK,
-      queryTimeSecondsThreshold_WARNING,
       failedSyncThreshold_OK,
       failedSyncThreshold_WARNING,
       now,
     } = params;
     documentCountThreshold =
       documentCountThreshold || default_documentCountThreshold;
-    queryTimeSecondsThreshold_OK =
-      queryTimeSecondsThreshold_OK || default_queryTimeSecondsThreshold_OK;
-    queryTimeSecondsThreshold_WARNING =
-      queryTimeSecondsThreshold_WARNING ||
-      default_queryTimeSecondsThreshold_WARNING;
     failedSyncThreshold_OK =
       failedSyncThreshold_OK || default_failedSyncThreshold_OK;
     failedSyncThreshold_WARNING =
@@ -256,9 +237,7 @@ export default async function healthcheck(appConfig, params) {
       now: now,
     };
 
-    ///////////////////
     const body_total = buildRequest({ filters: [] }, appConfig);
-    //console.log(body_total);
     const resp_total = await runRequest(body_total, appConfig);
     const total = resp_total.body.hits.total.value;
     const total_status =
@@ -269,41 +248,15 @@ export default async function healthcheck(appConfig, params) {
             error:
               'The number of documents in elasticsearch dropped drastically',
           };
-    const body_nlp = buildRequest(
-      { filters: [], searchTerm: 'what is bise?' },
-      appConfig,
-    );
-    const resp_nlp = await runRequest(body_nlp, appConfig);
-    const elapsed = resp_nlp.body.elapsed;
-
-    let total_elapsed = 0;
-    Object.keys(elapsed).forEach((key) => {
-      elapsed[key].forEach((nlp_step) => {
-        Object.keys(nlp_step).forEach((step_name) => {
-          total_elapsed += nlp_step[step_name].delta;
-        });
-      });
-    });
-
-    const elapsed_status =
-      total_elapsed < queryTimeSecondsThreshold_OK
-        ? { status: 'OK' }
-        : total_elapsed < queryTimeSecondsThreshold_WARNING
-        ? { status: 'WARNING', error: 'Slow response from NLP' }
-        : { status: 'CRITICAL', error: 'Slow response from NLP' };
 
     const airflow_status = await getStatus(appConfig, airflow_params);
 
     let status = { status: 'OK' };
-    if (
-      elapsed_status.status === 'WARNING' ||
-      airflow_status.status === 'WARNING'
-    ) {
+    if (airflow_status.status === 'WARNING') {
       status = { status: 'WARNING' };
     }
     if (
       total_status.status === 'CRITICAL' ||
-      elapsed_status.status === 'CRITICAL' ||
       airflow_status.status === 'CRITICAL'
     ) {
       status = { status: 'CRITICAL' };
@@ -313,9 +266,6 @@ export default async function healthcheck(appConfig, params) {
     if (total_status.error) {
       errors_list.push(total_status.error);
     }
-    if (elapsed_status.error) {
-      errors_list.push(elapsed_status.error);
-    }
     if (airflow_status.error) {
       errors_list.push(airflow_status.error);
     }

package/src/config/healthcheck.test.js

@@ -29,6 +29,15 @@ jest.mock('@eeacms/search', () => ({
   buildRequest: jest.fn(),
 }));
 
+beforeEach(() => {
+  runRequest.mockClear();
+});
+
+const mockAppConfig = {
+  id: 'test_index',
+  host: 'http://localhost:9200',
+};
+
 const query1 = {
   query: {
     bool: {
@@ -253,7 +262,7 @@ describe('test the status of the index', () => {
         //   }),
       );
     const params = { index_name: 'test_index', now: 1695732000000 };
-    const status = await getStatus({}, params);
+    const status = await getStatus(mockAppConfig, params);
     expect(status).toEqual({ status: 'OK' });
   });
 });
@@ -261,20 +270,11 @@ describe('test the status of the index', () => {
 describe('test the healthcheck', () => {
   it('test', async () => {
     runRequest
+      // First call: total document count check
       .mockReturnValueOnce(
         Promise.resolve({ body: { hits: { total: { value: 60001 } } } }),
       )
-      .mockReturnValueOnce(
-        Promise.resolve({
-          body: {
-            elapsed: {
-              step1: [{ query: { delta: 0.5 } }],
-              step2: [{ query: { delta: 0.6 } }],
-            },
-          },
-        }),
-      )
-
+      // getStatus calls:
       .mockReturnValueOnce(
         Promise.resolve({ body: last_scheduled_started_indexing_resp }),
       )
@@ -288,13 +288,18 @@ describe('test the healthcheck', () => {
           body: last_sync_task_since_last_start_resp,
         }),
       )
+      .mockReturnValueOnce(
+        Promise.resolve({
+          body: started_or_finished_site_since_last_started_resp,
+        }),
+      )
       .mockReturnValueOnce(
         Promise.resolve({
           body: started_or_finished_site_since_last_started_resp,
         }),
       );
     const params = { index_name: 'test_index', now: 1695732000000 };
-    const status = await healthcheck({}, params);
+    const status = await healthcheck(mockAppConfig, params);
     expect(status).toEqual({ status: 'OK' });
   });
 });

package/src/config/healthcheck_queries/failed_scheduled_atempts_since_last_started.json

@@ -31,6 +31,5 @@
       "start_time_ts": "desc"
     }
   ],
-  "aggs": {},
-  "index": "<index_name>"
+  "aggs": {}
 }

package/src/config/healthcheck_queries/last_scheduled_started_indexing.json

@@ -24,6 +24,5 @@
       "start_time_ts": "desc"
     }
   ],
-  "aggs": {},
-  "index": "<index_name>"
+  "aggs": {}
 }

package/src/config/healthcheck_queries/last_sync_task_since_last_start.json

@@ -31,6 +31,5 @@
       "start_time_ts": "desc"
     }
   ],
-  "aggs": {},
-  "index": "<index_name>"
+  "aggs": {}
 }

package/src/config/healthcheck_queries/latest_tasks_for_site.json

@@ -18,6 +18,5 @@
     {
       "start_time_ts": "desc"
     }
-  ],
-  "index": "<index_name>"
+  ]
 }

package/src/config/healthcheck_queries/started_or_finished_site_since_last_started.json

@@ -30,6 +30,5 @@
     {
       "start_time_ts": "desc"
     }
-  ],
-  "index": "<index_name>"
+  ]
 }

package/src/config/index.test.js

@@ -1,7 +1,7 @@
 import install from './index';
 import globalSearchConfig from './global-search-config.js';
 
-import '@testing-library/jest-dom/extend-expect';
+import '@testing-library/jest-dom';
 
 const SLOTS = [
   'aboveSearchInput',

package/src/config/query.test.js

@@ -0,0 +1,64 @@
+import query from './query';
+import '@testing-library/jest-dom';
+
+describe('query configuration', () => {
+  it('should export query object', () => {
+    expect(query).toBeDefined();
+  });
+
+  it('should have debugQuery set to false', () => {
+    expect(query.debugQuery).toBe(false);
+  });
+
+  it('should have extraQueryParams', () => {
+    expect(query.extraQueryParams).toBeDefined();
+  });
+
+  it('should have text_fields in extraQueryParams', () => {
+    expect(query.extraQueryParams.text_fields).toBeDefined();
+    expect(Array.isArray(query.extraQueryParams.text_fields)).toBe(true);
+  });
+
+  it('should have title with boost in text_fields', () => {
+    expect(query.extraQueryParams.text_fields).toContain('title^2');
+  });
+
+  it('should have subject with boost in text_fields', () => {
+    expect(query.extraQueryParams.text_fields).toContain('subject^1.5');
+  });
+
+  it('should have description with boost in text_fields', () => {
+    expect(query.extraQueryParams.text_fields).toContain('description^1.5');
+  });
+
+  it('should have all_fields_for_freetext in text_fields', () => {
+    expect(query.extraQueryParams.text_fields).toContain(
+      'all_fields_for_freetext',
+    );
+  });
+
+  it('should have functions in extraQueryParams', () => {
+    expect(query.extraQueryParams.functions).toBeDefined();
+    expect(Array.isArray(query.extraQueryParams.functions)).toBe(true);
+  });
+
+  it('should have exp function for issued.date', () => {
+    const expFunction = query.extraQueryParams.functions.find((f) => f.exp);
+    expect(expFunction).toBeDefined();
+    expect(expFunction.exp['issued.date']).toBeDefined();
+  });
+
+  it('should have correct offset for issued.date function', () => {
+    const expFunction = query.extraQueryParams.functions.find((f) => f.exp);
+    expect(expFunction.exp['issued.date'].offset).toBe('30d');
+  });
+
+  it('should have correct scale for issued.date function', () => {
+    const expFunction = query.extraQueryParams.functions.find((f) => f.exp);
+    expect(expFunction.exp['issued.date'].scale).toBe('1800d');
+  });
+
+  it('should have score_mode set to sum', () => {
+    expect(query.extraQueryParams.score_mode).toBe('sum');
+  });
+});