@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -0,0 +1,926 @@
+// 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,
+      });
+    });
+  });
+
+});