@openstax/ts-utils 1.34.0 → 1.34.1

package/packages/utils/src/services/searchProvider/openSearch.spec.ts

@@ -1,926 +0,0 @@
-// cspell:ignore opensearch, Sigv
-import { Client } from '@opensearch-project/opensearch';
-import { SearchResponse } from '@opensearch-project/opensearch/api/types';
-import { IndexConfig, openSearchService } from './openSearch';
-import { SearchOptions } from '.';
-
-jest.mock('@aws-sdk/credential-provider-node', () => ({
-  defaultProvider: jest.fn(() => () => Promise.resolve({
-    accessKeyId: 'test',
-    secretAccessKey: 'test',
-    sessionToken: 'test'
-  }))
-}));
-
-jest.mock('@opensearch-project/opensearch');
-jest.mock('@opensearch-project/opensearch/aws', () => ({
-  AwsSigv4Signer: jest.fn(() => ({}))
-}));
-
-describe('openSearchService', () => {
-  type TestDoc = {
-    id: string;
-    title: string;
-    description: string;
-    tags: string[];
-  };
-
-  const indexConfig: IndexConfig = {
-    name: 'test-index',
-    mappings: {
-      title: { type: 'text' },
-      description: { type: 'text' },
-      tags: { type: 'keyword' }
-    },
-    pageSize: 15
-  };
-
-  const mockConfigProvider = {
-    deployed: {
-      node: jest.fn(() => Promise.resolve('https://opensearch.openstax.org')),
-      region: jest.fn(() => Promise.resolve('us-east-1'))
-    }
-  };
-
-  const mockClient = {
-    indices: {
-      exists: jest.fn(),
-      create: jest.fn(),
-      delete: jest.fn(),
-      putMapping: jest.fn(),
-    },
-    index: jest.fn(),
-    bulk: jest.fn(),
-    search: jest.fn(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    (Client as jest.Mock).mockImplementation(() => mockClient);
-  });
-
-  describe('initialization', () => {
-    it('should set up AwsSigv4Signer with correct parameters and getCredentials', async () => {
-      const mockAwsSigv4Signer = require('@opensearch-project/opensearch/aws').AwsSigv4Signer;
-      const mockDefaultProvider = require('@aws-sdk/credential-provider-node').defaultProvider;
-
-      mockAwsSigv4Signer.mockClear();
-
-      const mockCredentialProvider = jest.fn(() => Promise.resolve({
-        accessKeyId: 'test-key',
-        secretAccessKey: 'test-secret'
-      }));
-      mockDefaultProvider.mockReturnValue(mockCredentialProvider);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      try {
-        await service.ensureIndexCreated();
-      } catch (e) {
-        // ignore error, we just want the signer to be called
-      }
-
-      expect(mockAwsSigv4Signer).toHaveBeenCalled();
-      expect(mockAwsSigv4Signer.mock.calls[0][0].service).toBe('es');
-
-      const getCredentials = mockAwsSigv4Signer.mock.calls[0][0].getCredentials;
-      await getCredentials();
-
-      expect(mockDefaultProvider).toHaveBeenCalled();
-      expect(mockCredentialProvider).toHaveBeenCalled();
-    });
-  });
-
-  describe('pagination configuration', () => {
-    it('should use default pageSize', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>({...indexConfig, pageSize: undefined });
-
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        fields: [{ key: 'title', type: 'text', weight: 1 }],
-        page: 2
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 25 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            size: 10,
-            from: 10
-          })
-        })
-      );
-    });
-
-    it('should use custom pageSize', async () => {
-      const customIndexConfig = { ...indexConfig, pageSize: 25 };
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(customIndexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        fields: [{ key: 'title', type: 'text', weight: 1 }],
-        page: 2
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 100 },
-            hits: []
-          }
-        }
-      });
-
-      const result = await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            size: 25,
-            from: 25
-          })
-        })
-      );
-
-      expect(result.pageSize).toBe(25);
-      expect(result.totalPages).toBe(4);
-    });
-  });
-
-  describe('ensureIndexCreated', () => {
-    it('should create index if it does not exist', async () => {
-      mockClient.indices.exists.mockResolvedValueOnce({ body: false });
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.ensureIndexCreated();
-
-      expect(mockClient.indices.exists).toHaveBeenCalledWith({ index: 'test-index' });
-      expect(mockClient.indices.create).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: {
-          mappings: {
-            dynamic: false,
-            properties: indexConfig.mappings
-          }
-        }
-      });
-    });
-
-    it('should not create index if it already exists', async () => {
-      mockClient.indices.exists.mockResolvedValueOnce({ body: true });
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.ensureIndexCreated();
-
-      expect(mockClient.indices.exists).toHaveBeenCalledWith({ index: 'test-index' });
-      expect(mockClient.indices.create).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('deleteIndexIfExists', () => {
-    it('should delete index if it exists', async () => {
-      mockClient.indices.exists.mockResolvedValueOnce({ body: true });
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.deleteIndexIfExists();
-
-      expect(mockClient.indices.exists).toHaveBeenCalledWith({ index: 'test-index' });
-      expect(mockClient.indices.delete).toHaveBeenCalledWith({ index: 'test-index' });
-    });
-
-    it('should not delete index if it does not exist', async () => {
-      mockClient.indices.exists.mockResolvedValueOnce({ body: false });
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.deleteIndexIfExists();
-
-      expect(mockClient.indices.exists).toHaveBeenCalledWith({ index: 'test-index' });
-      expect(mockClient.indices.delete).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('index', () => {
-    it('should index a document', async () => {
-      const doc: TestDoc = {
-        id: '123',
-        title: 'Test Document',
-        description: 'This is a test document',
-        tags: ['test', 'document']
-      };
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.index({ id: '123', body: doc });
-
-      expect(mockClient.index).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: doc,
-        id: '123',
-        refresh: true
-      }, expect.anything());
-    });
-  });
-
-  describe('bulkIndex', () => {
-    it('should index a document', async () => {
-      const doc: TestDoc = {
-        id: '123',
-        title: 'Test Document',
-        description: 'This is a test document',
-        tags: ['test', 'document']
-      };
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.bulkIndex([{ id: '123', body: doc }]);
-
-      expect(mockClient.bulk).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: [
-          { index: { _id: '123' } },
-          doc
-        ],
-        refresh: true
-      }, expect.anything());
-    });
-  });
-
-  describe('search', () => {
-    it('should search with query and return results', async () => {
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        fields: [
-          { key: 'title', weight: 2 },
-          { key: 'description', type: 'text', weight: 1 }
-        ],
-        page: 2
-      };
-
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 30 },
-            hits: [
-              { _source: { id: '1', title: 'Doc 1', description: 'Desc 1', tags: ['a'] } },
-              { _source: { id: '2', title: 'Doc 2', description: 'Desc 2', tags: ['b'] } },
-            ]
-          }
-        }
-      } as unknown as SearchResponse<TestDoc>;
-
-      mockClient.search.mockResolvedValueOnce(mockResponse);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      const result = await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: expect.objectContaining({
-          query: {
-            bool: {
-              must: [{
-                multi_match: {
-                  fields: ['title^2', 'description^1'],
-                  query: 'test'
-                }
-              }]
-            }
-          },
-          size: 15,
-          from: 15
-        })
-      });
-
-      expect(result).toEqual({
-        items: [
-          { id: '1', title: 'Doc 1', description: 'Desc 1', tags: ['a'] },
-          { id: '2', title: 'Doc 2', description: 'Desc 2', tags: ['b'] }
-        ],
-        pageSize: 15,
-        currentPage: 2,
-        totalItems: 30,
-        totalPages: 2
-      });
-    });
-
-    it('should handle filter conditions', async () => {
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        filter: [
-          { key: 'tags', value: ['test'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 2 }]
-      };
-
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          hits: {
-            total: 5,
-            hits: [
-              { _source: { id: '1', title: 'Test Doc', description: 'Test', tags: ['test'] } }
-            ]
-          }
-        }
-      } as unknown as SearchResponse<TestDoc>;
-
-      mockClient.search.mockResolvedValueOnce(mockResponse);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      const result = await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: expect.objectContaining({
-          query: {
-            bool: {
-              filter: [
-                { terms: { tags: ['test'] } }
-              ],
-              must: [{
-                multi_match: {
-                  fields: ['title^2'],
-                  query: 'test'
-                },
-              }]
-            }
-          }
-        })
-      });
-
-      expect(result.totalItems).toBe(5);
-      expect(result.items).toHaveLength(1);
-    });
-
-    it('should handle must conditions', async () => {
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        must: [
-          { key: 'tags', value: ['test'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 2 }]
-      };
-
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          hits: {
-            total: 5,
-            hits: [
-              { _source: { id: '1', title: 'Test Doc', description: 'Test', tags: ['test'] } }
-            ]
-          }
-        }
-      } as unknown as SearchResponse<TestDoc>;
-
-      mockClient.search.mockResolvedValueOnce(mockResponse);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      const result = await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: expect.objectContaining({
-          query: {
-            bool: {
-              must: [
-                {multi_match: {
-                  fields: ['title^2'],
-                  query: 'test'
-                }},
-                { terms: { tags: ['test'] } }
-              ],
-            }
-          }
-        })
-      });
-
-      expect(result.totalItems).toBe(5);
-      expect(result.items).toHaveLength(1);
-    });
-
-    it('should handle must conditions with no query', async () => {
-      const searchOptions: SearchOptions = {
-        query: '',
-        must: [
-          { key: 'tags', value: ['test'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 2 }]
-      };
-
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          hits: {
-            total: 5,
-            hits: [
-              { _source: { id: '1', title: 'Test Doc', description: 'Test', tags: ['test'] } }
-            ]
-          }
-        }
-      } as unknown as SearchResponse<TestDoc>;
-
-      mockClient.search.mockResolvedValueOnce(mockResponse);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      const result = await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: expect.objectContaining({
-          query: {
-            bool: {
-              must: [
-                { terms: { tags: ['test'] } }
-              ],
-            }
-          }
-        })
-      });
-
-      expect(result.totalItems).toBe(5);
-      expect(result.items).toHaveLength(1);
-    });
-
-    it('should handle must_not conditions', async () => {
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        must_not: [
-          { key: 'tags', value: ['hidden'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 2 }]
-      };
-
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 10 },
-            hits: [
-              { _source: { id: '1', title: 'Visible Doc', description: 'Test', tags: ['visible'] } }
-            ]
-          }
-        }
-      } as unknown as SearchResponse<TestDoc>;
-
-      mockClient.search.mockResolvedValueOnce(mockResponse);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      const result = await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: expect.objectContaining({
-          query: {
-            bool: {
-              must: [{
-                multi_match: {
-                  fields: ['title^2'],
-                  query: 'test'
-                },
-              }],
-              must_not: [
-                { terms: { tags: ['hidden'] } }
-              ]
-            }
-          }
-        })
-      });
-
-      expect(result.totalItems).toBe(10);
-    });
-
-    it('should handle sorting', async () => {
-      const searchOptions: SearchOptions = {
-        query: 'test',
-        fields: [{ key: 'title', type: 'text', weight: 2 }],
-        sort: [{ key: 'title', order: 'asc' }]
-      };
-
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 20 },
-            hits: []
-          }
-        }
-      } as unknown as SearchResponse<TestDoc>;
-
-      mockClient.search.mockResolvedValueOnce(mockResponse);
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            sort: [{ title: { order: 'asc' } }]
-          })
-        })
-      );
-    });
-
-    it('should throw error on non-200 response', async () => {
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 500,
-        body: { error: 'Internal server error' }
-      });
-
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await expect(
-        service.search({
-          query: 'text',
-          fields: [{ key: 'title', type: 'text', weight: 1 }]
-        })
-      ).rejects
-        .toThrow('Unexpected status code: 500 from OpenSearch');
-    });
-
-    it('should correctly map field keys with weights in multi_match query', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        fields: [
-          { key: 'title', weight: 3 },
-          { key: 'description', weight: 2 },
-          { key: 'tags', type: 'keyword' }
-        ]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                must: [expect.objectContaining({
-                  multi_match: expect.objectContaining({
-                    fields: ['title^3', 'description^2', 'tags'],
-                    query: 'search term'
-                  })
-                })]
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should work with exists filter', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        filter: [
-          { exists: {field: 'tags'} }
-        ],
-        fields: [
-          { key: 'title', type: 'text', weight: 1 },
-          { key: 'tags', type: 'keyword' }
-        ]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                filter: [
-                  { exists: { field: 'tags' } }
-                ]
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle single value in filter', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        filter: [
-          { key: 'tags', value: 'single-tag' }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                filter: [
-                  { terms: { tags: ['single-tag'] } }
-                ]
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle array values in filter', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        filter: [
-          { key: 'tags', value: ['tag1', 'tag2', 'tag3'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                filter: [
-                  { terms: { tags: ['tag1', 'tag2', 'tag3'] } }
-                ]
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle single value in must_not', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        must_not: [
-          { key: 'tags', value: 'exclude-tag' }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                must_not: [
-                  { terms: { tags: ['exclude-tag'] } }
-                ]
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle array values in must_not', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        must_not: [
-          { key: 'tags', value: ['exclude1', 'exclude2'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                must_not: [
-                  { terms: { tags: ['exclude1', 'exclude2'] } },
-                ]
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle should conditions with array values', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        should: [
-          { key: 'tags', value: ['tag1', 'tag2', 'tag3'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                should: [
-                  { terms: { tags: ['tag1', 'tag2', 'tag3'] } }
-                ],
-                minimum_should_match: 1
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle should conditions with single values', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        should: [
-          { key: 'tags', value: 'single-tag' }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                should: [
-                  { terms: { tags: ['single-tag'] } }
-                ],
-                minimum_should_match: 1
-              })
-            })
-          })
-        })
-      );
-    });
-
-    it('should handle multiple should conditions', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-
-      const searchOptions: SearchOptions = {
-        query: 'search term',
-        should: [
-          { key: 'tags', value: 'tag1' },
-          { key: 'title', value: 'specific-title' },
-          { key: 'categories', value: ['cat1', 'cat2'] }
-        ],
-        fields: [{ key: 'title', type: 'text', weight: 1 }]
-      };
-
-      mockClient.search.mockResolvedValueOnce({
-        statusCode: 200,
-        body: {
-          hits: {
-            total: { value: 0 },
-            hits: []
-          }
-        }
-      });
-
-      await service.search(searchOptions);
-
-      expect(mockClient.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          body: expect.objectContaining({
-            query: expect.objectContaining({
-              bool: expect.objectContaining({
-                should: [
-                  { terms: { tags: ['tag1'] } },
-                  { terms: { title: ['specific-title'] } },
-                  { terms: { categories: ['cat1', 'cat2'] } }
-                ],
-                minimum_should_match: 1
-              })
-            })
-          })
-        })
-      );
-    });
-
-  });
-
-  describe('updateMappings', () => {
-    it('works', async () => {
-      const service = openSearchService()(mockConfigProvider)<TestDoc>(indexConfig);
-      await service.updateMappings();
-
-      expect(mockClient.indices.putMapping).toHaveBeenCalledWith({
-        index: 'test-index',
-        body: {
-          properties: indexConfig.mappings
-        }
-      }, {
-        requestTimeout: 10000,
-        maxRetries: 1,
-      });
-    });
-  });
-
-});