@openstax/ts-utils 1.34.0 → 1.34.1

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

@@ -1,526 +0,0 @@
-import { memorySearchTheBadWay } from './memorySearchTheBadWay';
-
-describe('memorySearchTheBadWay', () => {
-  it('stubs out the ensureIndexCreated method', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).ensureIndexCreated();
-    expect(result).toBeUndefined();
-  });
-
-  it('stubs out the index method', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).index({
-      id: '123', body: { text: '456' }
-    });
-    expect(result).toBeUndefined();
-  });
-
-  it('stubs out the bulkIndex method', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).bulkIndex([
-      { id: '123', body: { text: '456' } }
-    ]);
-    expect(result).toBeUndefined();
-  });
-
-  it('stubs out the deleteIndexIfExists method', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).deleteIndexIfExists();
-    expect(result).toBeUndefined();
-  });
-
-  it('matches documents', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({
-      query: 'foo', fields: [
-        {key: 'text', type: 'text', weight: 1}
-      ]
-    });
-    expect(result.items).toContainEqual({text: 'foo'});
-  });
-
-  it('gets no matches', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({query: 'no match', fields: [{key: 'text', weight: 1}]});
-    expect(result.items).toEqual([]);
-  });
-
-  it('omits documents', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({query: 'foo', fields: [{key: 'text', weight: 1}]});
-    expect(result.items).not.toContainEqual({text: 'bar'});
-  });
-
-  it('throws on invalid field type', async() => {
-    const documents: {text: string; num?: number}[] = [{text: 'foo'},{text: 'bar', num: 5}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    // @ts-ignore
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({query: 'foo', fields: [{key: 'num', weight: 1}, {key: 'text', weight: 1}]})).rejects.toThrow();
-  });
-
-  it('throws on invalid field name', async() => {
-    const documents: {text: string; num?: number}[] = [{text: 'foo'},{text: 'bar', num: 5}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    // @ts-ignore
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({
-      query: '',
-      fields: [],
-      filter: [{key: 'invalidField', value: 'foo'}]
-    })).rejects.toThrow();
-  });
-
-  it('throws on invalid nested field name', async() => {
-    const documents: {text: string; num?: number}[] = [{text: 'foo'},{text: 'bar', num: 5}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    // @ts-ignore
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({
-      query: '',
-      fields: [],
-      filter: [{key: 'nested.invalidField', value: 'foo'}]
-    })).rejects.toThrow();
-  });
-
-  it('throws on unmapped invalid nested field name', async() => {
-    const documents: {text: string; num?: number; nested?: {}}[] = [{text: 'foo', nested: {}},{text: 'bar', num: 5}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    // @ts-ignore
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({
-      query: '',
-      fields: [],
-      filter: [{key: 'nested.invalidField', value: 'foo'}]
-    })).rejects.toThrow();
-  });
-
-  it('throws on invalid nested field value', async() => {
-    const documents: {text: string}[] = [{text: 'foo'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    // @ts-ignore
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'nested', properties: {invalidField: {type: 'text'}}}}
-    }).search({
-      query: '',
-      fields: [],
-      filter: [{nested: {path: 'nested', query: {terms: {'nested.invalidField': 'foo'}}}}]
-    })).rejects.toThrow();
-  });
-
-  it('sorts by match strength', async() => {
-    const documents: {text: string; text2?: string}[] = [{text: 'foo', text2: 'bar'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}}
-    }).search({query: 'bar', fields: [{key: 'text', weight: 1}, {key: 'text2', weight: 0.5}]});
-    expect(result.items[0]).toEqual({text: 'bar'});
-    expect(result.items[1]).toEqual({text: 'foo', text2: 'bar'});
-  });
-
-  it('sorts by given sort', async() => {
-    const documents: {text: string; text2?: string; num: number}[] = [
-      {text: 'foo', text2: 'bar', num: 2},
-      {text: 'foo', text2: 'bar', num: 1},
-      {text: 'bar', num: 1},
-      {text: 'bar', num: 2}
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    let result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, num: {type: 'keyword'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'text', weight: 1},
-        {key: 'text2', weight: 0.5}
-      ],
-      sort: [{key: 'num', order: 'asc'}]
-    });
-    expect(result.items[0]).toEqual({text: 'bar', num: 1});
-    expect(result.items[1]).toEqual({text: 'foo', text2: 'bar', num: 1});
-    expect(result.items[2]).toEqual({text: 'bar', num: 2});
-    expect(result.items[3]).toEqual({text: 'foo', text2: 'bar', num: 2});
-    result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, num: {type: 'keyword'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'text', weight: 1},
-        {key: 'text2', weight: 0.5}
-      ],
-      sort: [{key: 'num', order: 'desc'}]
-    });
-    expect(result.items[0]).toEqual({text: 'bar', num: 2});
-    expect(result.items[1]).toEqual({text: 'foo', text2: 'bar', num: 2});
-    expect(result.items[2]).toEqual({text: 'bar', num: 1});
-    expect(result.items[3]).toEqual({text: 'foo', text2: 'bar', num: 1});
-  });
-
-  it('filters', async() => {
-    const documents: {text: string; text2?: string}[] = [{text: 'foo', text2: 'bar'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'text', type: 'keyword'},
-        {key: 'text2', type: 'text', weight: 0.5}
-      ],
-      filter: [{key: 'text', value: 'foo'}]
-    });
-    expect(result.items).toEqual([{text: 'foo', text2: 'bar'}]);
-  });
-
-  it('throws on invalid filter', async() => {
-    const documents: {text: string; text2?: string}[] = [{text: 'foo', text2: 'bar'},{text: 'bar'}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'text', type: 'keyword'},
-        {key: 'text2', type: 'text', weight: 0.5}
-      ],
-      filter: [{invalid: 'filter'} as any]
-    })).rejects.toThrow();
-  });
-
-  it('filters for exists', async() => {
-    const documents: {text: string; tag?: string; text2?: string}[] = [
-      {text: 'foo', tag: '1', text2: 'bar'},
-      {text: 'bar'}
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, tag: {type: 'keyword'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'text', type: 'keyword'},
-        {key: 'tag', type: 'keyword'},
-        {key: 'text2', type: 'text', weight: 0.5}
-      ],
-      filter: [{exists: {field: 'tag'}}]
-    });
-    expect(result.items).toEqual([{text: 'foo', tag: '1', text2: 'bar'}]);
-  });
-
-  it('filters with booleans', async() => {
-    const documents: {text: string; text2?: string; bool?: boolean}[] = [{text: 'foo', text2: 'bar', bool: true},{text: 'bar', bool: false}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, bool: {type: 'boolean'}}
-    }).search({
-      query: '',
-      fields: [
-        {key: 'bool', type: 'boolean'},
-      ],
-      must: [{key: 'bool', value: 'true'}]
-    });
-    expect(result.items).toEqual([{text: 'foo', text2: 'bar', bool: true}]);
-
-    const result2 = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, bool: {type: 'boolean'}}
-    }).search({
-      query: '',
-      fields: [
-        {key: 'bool', type: 'boolean'},
-      ],
-      must: [{key: 'bool', value: 'false'}]
-    });
-    expect(result2.items).toEqual([{text: 'bar', bool: false}]);
-
-    const result3 = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, bool: {type: 'boolean'}}
-    }).search({
-      query: '',
-      fields: [
-        {key: 'bool', type: 'boolean'},
-      ],
-      must_not: [{key: 'bool', value: 'false'}]
-    });
-    expect(result3.items).toEqual([{text: 'foo', text2: 'bar', bool: true}]);
-  });
-
-  it('throws on invalid boolean filter', async() => {
-    const documents: {text: string; text2?: string; bool?: boolean}[] = [{text: 'foo', text2: 'bar', bool: true},{text: 'bar', bool: false}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    await expect(memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},text2: {type: 'text'}, bool: {type: 'boolean'}}
-    }).search({
-      query: '',
-      fields: [
-        { key: 'bool', type: 'boolean' }
-      ],
-      filter: [{ key: 'bool', value: 'foo' }] })
-    ).rejects.toThrow();
-  });
-
-  it('filters array values', async() => {
-    const documents: {array: string[]; text?: string}[] = [{array: ['foo'], text: 'bar'},{array: ['bar']}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},array: {type: 'keyword'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'array', type: 'keyword'},
-        {key: 'text', type: 'text', weight: 0.5}
-      ],
-      filter: [{key: 'array', value: 'foo'}]
-    });
-    expect(result.items).toEqual([{array: ['foo'], text: 'bar'}]);
-  });
-
-  it('filters array values with multiple filters', async() => {
-    const documents: {array: string[]; text?: string}[] = [{array: ['foo'], text: 'bar'},{array: ['bar']}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'},array: {type: 'keyword'}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'array', type: 'keyword'},
-        {key: 'text', type: 'text', weight: 0.5}
-      ],
-      filter: [{key: 'array', value: ['foo', 'baz']}]
-    });
-    expect(result.items).toEqual([{array: ['foo'], text: 'bar'}]);
-  });
-
-  it('filters with nested objects', async() => {
-    const documents: {obj: {id: string}; text?: string}[] = [{obj: {id: 'foo'}, text: 'bar'},{obj: {id: 'bar'}}];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, obj: {type: 'object', properties: {id: {type: 'keyword'}}}}
-    }).search({
-      query: 'bar',
-      fields: [
-        {key: 'text', type: 'text', weight: 0.5}
-      ],
-      filter: [{key: 'obj.id', value: ['foo', 'baz']}]
-    });
-    expect(result.items).toEqual([{obj: {id: 'foo'}, text: 'bar'}]);
-  });
-
-  it('applies should filters', async () => {
-    const documents = [
-      { text: 'foo', category: 'A' },
-      { text: 'bar', category: 'B' },
-      { text: 'baz', category: 'C' }
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, category: {type: 'keyword'}}
-    }).search({
-      query: '',
-      fields: [{ key: 'text', type: 'text', weight: 1 }],
-      should: [{ key: 'category', value: 'A' }]
-    });
-    expect(result.items).toEqual([{ text: 'foo', category: 'A' }]);
-  });
-
-  it('requires at least one should match', async () => {
-    const documents = [
-      { text: 'foo', category: 'A' },
-      { text: 'bar', category: 'B' },
-      { text: 'baz', category: 'C' }
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, category: {type: 'keyword'}}
-    }).search({
-      query: '',
-      fields: [{ key: 'text', type: 'text', weight: 1 }],
-      should: [{ key: 'category', value: 'D' }]
-    });
-    expect(result.items).toEqual([]);
-  });
-
-  it('matches multiple should values', async () => {
-    const documents = [
-      { text: 'foo', category: 'A' },
-      { text: 'bar', category: 'B' },
-      { text: 'baz', category: 'C' }
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, category: {type: 'keyword'}}
-    }).search({
-      query: '',
-      fields: [{ key: 'text', type: 'text', weight: 1 }],
-      should: [{ key: 'category', value: ['A', 'B'] }]
-    });
-    expect(result.items).toHaveLength(2);
-    expect(result.items).toContainEqual({ text: 'foo', category: 'A' });
-    expect(result.items).toContainEqual({ text: 'bar', category: 'B' });
-  });
-
-  it('combines should with must filters', async () => {
-    const documents = [
-      { text: 'foo', category: 'A', status: 'active' },
-      { text: 'bar', category: 'B', status: 'active' },
-      { text: 'baz', category: 'C', status: 'inactive' }
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, category: {type: 'keyword'}, status: {type: 'keyword'}}
-    }).search({
-      query: '',
-      fields: [{ key: 'text', type: 'text', weight: 1 }],
-      must: [{ key: 'status', value: 'active' }],
-      should: [{ key: 'category', value: ['A', 'C'] }]
-    });
-    expect(result.items).toHaveLength(1);
-    expect(result.items).toEqual([{ text: 'foo', category: 'A', status: 'active' }]);
-  });
-
-  it('applies should filter with nested fields', async () => {
-    const documents = [
-      { text: 'foo', metadata: { importance: 'high' } },
-      { text: 'bar', metadata: { importance: 'low' } }
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, metadata: {type: 'object', properties: {importance: {type: 'keyword'}}}}
-    }).search({
-      query: '',
-      fields: [{ key: 'text', type: 'text', weight: 1 }],
-      should: [{ key: 'metadata.importance', value: 'high' }]
-    });
-    expect(result.items).toEqual([{ text: 'foo', metadata: { importance: 'high' } }]);
-  });
-
-  it('applies complex nested query', async () => {
-    const documents = [
-      { text: 'foo', categories: [{ name: 'one', enabled: true }] },
-      { text: 'foo', categories: [{ name: 'three', enabled: true }] },
-      { text: 'bar', categories: [{ name: 'two', enabled: true }, {name: 'three', enabled: false}] },
-      { text: 'bar', categories: [{ name: 'two', enabled: false }, {name: 'three', enabled: true}] }
-    ];
-    const loadAllDocumentsTheBadWay = () => Promise.resolve(documents);
-    const result = await memorySearchTheBadWay()({
-      store:{loadAllDocumentsTheBadWay},
-      mappings: {text: {type: 'text'}, categories: {type: 'nested', properties: {
-        name: {type: 'keyword'},
-        enabled: {type: 'boolean'}
-      }}}
-    }).search({
-      query: '',
-      must: [
-        {
-          bool: {
-            should: [
-              {
-                nested: {
-                  path: 'categories',
-                  query: {
-                    terms: {
-                      'categories.name': 'one'
-                    }
-                  }
-                }
-              },
-              {
-                nested: {
-                  path: 'categories',
-                  query: {
-                    terms: {
-                      'categories.name': 'two'
-                    }
-                  }
-                }
-              }
-            ],
-            minimum_should_match: 1
-          }
-        }
-      ],
-      must_not: [
-        {
-          nested: {
-            path: 'categories',
-            query: {
-              bool: {
-                must: [
-                  {
-                    terms: {
-                      'categories.name': ['one', 'two']
-                    }
-                  },
-                  {
-                    term: {
-                      'categories.enabled': false
-                    }
-                  }
-                ]
-              }
-            }
-          }
-        }
-      ],
-      fields: []
-    });
-    expect(result.items).toEqual([
-      { text: 'foo', categories: [{ name: 'one', enabled: true }] },
-      { text: 'bar', categories: [{ name: 'two', enabled: true }, {name: 'three', enabled: false}] }
-    ]);
-  });
-});