@openstax/ts-utils 1.33.0 → 1.34.0

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

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