mirror of
https://github.com/nextapps-de/flexsearch.git
synced 2025-08-24 14:42:55 +02:00
521 lines
14 KiB
JavaScript
521 lines
14 KiB
JavaScript
global.self = global;
|
|
const env = process.argv[process.argv.length - 1] === "--exit" ? "" : process.argv[process.argv.length - 1];
|
|
import { expect } from "chai";
|
|
let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
|
|
if(FlexSearch.default) FlexSearch = FlexSearch.default;
|
|
if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
|
|
const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver } = FlexSearch;
|
|
const build_light = env && env.includes("light");
|
|
const build_compact = env && env.includes("compact");
|
|
const build_esm = !env || env.startsWith("module");
|
|
const Charset = _Charset || (await import("../src/charset.js")).default;
|
|
|
|
if(!build_light) describe("Document (Multi-Field Search)", function(){
|
|
|
|
const data = [{
|
|
id: 2,
|
|
data: { title: "Title 3", body: "Body 3", cat: "A" }
|
|
},{
|
|
id: 1,
|
|
data: { title: "Title 2", body: "Body 2", cat: "B" }
|
|
},{
|
|
id: 0,
|
|
data: { title: "Title 1", body: "Body 1", cat: "A" }
|
|
}];
|
|
|
|
const update = [{
|
|
id: 0,
|
|
data: { title: "Foo 1", body: "Bar 1" }
|
|
},{
|
|
id: 1,
|
|
data: { title: "Foo 2", body: "Bar 2" }
|
|
},{
|
|
id: 2,
|
|
data: { title: "Foo 3", body: "Bar 3" }
|
|
}];
|
|
|
|
it("Should have been indexed properly", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
id: "id",
|
|
field: [
|
|
"data:title",
|
|
"data:body"
|
|
]
|
|
}
|
|
});
|
|
|
|
const document_with_store = new Document({
|
|
keystore: 2,
|
|
fastupdate: true,
|
|
document: {
|
|
store: true,
|
|
id: "id",
|
|
field: [
|
|
"data:title",
|
|
"data:body"
|
|
]
|
|
}
|
|
});
|
|
|
|
for(let i = 0; i < data.length; i++){
|
|
document.add(data[i]);
|
|
document_with_store.add(data[i]);
|
|
}
|
|
|
|
expect(document.index.size).to.equal(2);
|
|
expect(document.reg.size).to.equal(3);
|
|
// Registry Sharing
|
|
expect(document.index.get("data:title").reg).to.equal(document.reg);
|
|
expect(document.index.get("data:title").reg).to.not.equal(document_with_store.reg);
|
|
|
|
expect(document.search({
|
|
query: "title"
|
|
})).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
field: "data:title"
|
|
})).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document_with_store.search({
|
|
query: "title",
|
|
pluck: "data:title",
|
|
enrich: true
|
|
}).map(res => res.doc)).to.eql(data);
|
|
|
|
expect(document.search({
|
|
field: "data:body",
|
|
query: "title"
|
|
})).to.have.lengthOf(0)
|
|
|
|
expect(document.search({
|
|
field: "data:title",
|
|
query: "body"
|
|
})).to.have.lengthOf(0);
|
|
|
|
expect(document.search({
|
|
field: "data:body",
|
|
query: "body"
|
|
})).to.eql([{
|
|
field: "data:body",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
field: ["data:title"],
|
|
query: "title"
|
|
})).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
field: ["data:title", "data:body"],
|
|
query: "body"
|
|
})).to.eql([{
|
|
field: "data:body",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
field: ["data:body", "data:title"],
|
|
query: "title"
|
|
})).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
field: ["data:title", "data:body"],
|
|
query: "body"
|
|
})).to.eql([{
|
|
field: "data:body",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
field: ["data:body", "data:title"],
|
|
query: "title"
|
|
})).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search("body", {
|
|
field: "data:body"
|
|
})).to.eql([{
|
|
field: "data:body",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search("title", {
|
|
field: ["data:title"]
|
|
})).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search({
|
|
query: "body"
|
|
})).to.eql([{
|
|
field: "data:body",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search("title")).to.eql([{
|
|
field: "data:title",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
expect(document.search([{
|
|
field: "data:title",
|
|
query: "body"
|
|
},{
|
|
field: "data:body",
|
|
query: "body"
|
|
}])).to.eql([{
|
|
field: "data:body",
|
|
result: [2, 1, 0]
|
|
}]);
|
|
|
|
// ---------------------------------------
|
|
|
|
for(let i = 0; i < update.length; i++){
|
|
document.add(update[i]);
|
|
document_with_store.add(update[i]);
|
|
}
|
|
|
|
expect(document.search("foo")).to.eql([{
|
|
field: "data:title",
|
|
result: [0, 1, 2]
|
|
}]);
|
|
|
|
expect(document.search("bar")).to.eql([{
|
|
field: "data:body",
|
|
result: [0, 1, 2]
|
|
}]);
|
|
|
|
expect(document.search("foo bar", { suggest: true })).to.eql([{
|
|
field: "data:title",
|
|
result: [0, 1, 2]
|
|
},{
|
|
field: "data:body",
|
|
result: [0, 1, 2]
|
|
}]);
|
|
|
|
expect(document.search("foo bar", { suggest: true, merge: true })).to.eql([
|
|
{ id: 0, field: [ 'data:title', 'data:body' ] },
|
|
{ id: 1, field: [ 'data:title', 'data:body' ] },
|
|
{ id: 2, field: [ 'data:title', 'data:body' ] }
|
|
]);
|
|
|
|
expect(document_with_store.search({
|
|
query: "foo",
|
|
pluck: "data:title",
|
|
enrich: true
|
|
}).map(res => res.doc)).to.eql(update);
|
|
|
|
expect(document_with_store.search({
|
|
query: "bar",
|
|
pluck: "data:body",
|
|
enrich: true
|
|
}).map(res => res.doc)).to.eql(update);
|
|
|
|
// ---------------------------------------
|
|
|
|
for(let i = 0; i < update.length; i++){
|
|
document.remove(update[i]);
|
|
document_with_store.remove(update[i]);
|
|
}
|
|
|
|
expect(document.reg.size).to.equal(0);
|
|
expect(document.index.get("data:title").reg.size).to.equal(0);
|
|
expect(document.index.get("data:body").reg.size).to.equal(0);
|
|
expect(document.index.get("data:title").map.size).to.equal(0);
|
|
expect(document.index.get("data:body").map.size).to.equal(0);
|
|
expect(document_with_store.store.size).to.equal(0);
|
|
|
|
expect(document_with_store.search({
|
|
query: "foo",
|
|
})).to.eql([]);
|
|
|
|
expect(document_with_store.search({
|
|
query: "bar"
|
|
})).to.eql([]);
|
|
});
|
|
|
|
|
|
it("Should have been unique results", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
id: "id",
|
|
field: ["field1", "field2"]
|
|
}
|
|
});
|
|
|
|
const data = [{
|
|
id: 1,
|
|
field1: "phrase",
|
|
field2: "phrase next"
|
|
},{
|
|
id: 2,
|
|
field1: "phrase next",
|
|
field2: "phrase"
|
|
}];
|
|
|
|
for(let i = 0; i < data.length; i++){
|
|
document.add(data[i]);
|
|
}
|
|
|
|
expect(document.search("phrase")).to.eql([{
|
|
field: "field1",
|
|
result: [1, 2]
|
|
},{
|
|
field: "field2",
|
|
result: [1, 2]
|
|
}]);
|
|
|
|
expect(document.search("phrase", { suggest: true })).to.eql([{
|
|
field: "field1",
|
|
result: [1, 2]
|
|
},{
|
|
field: "field2",
|
|
result: [1, 2]
|
|
}]);
|
|
});
|
|
|
|
it("Should have been sorted properly by number of field count matches", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
id: "id",
|
|
field: ["field1", "field2"]
|
|
}
|
|
});
|
|
|
|
const data = [{
|
|
id: 1,
|
|
field1: "phrase",
|
|
field2: "phrase next"
|
|
},{
|
|
id: 2,
|
|
field1: "phrase next",
|
|
field2: "phrase"
|
|
}];
|
|
|
|
for(let i = 0; i < data.length; i++){
|
|
document.add(data[i]);
|
|
}
|
|
|
|
expect(document.search("phrase", { suggest: true, merge: true })).to.eql([
|
|
{ id: 1, field: [ 'field1', 'field2' ] },
|
|
{ id: 2, field: [ 'field1', 'field2' ] }
|
|
]);
|
|
|
|
expect(document.search("phrase next", { suggest: true, merge: true })).to.eql([
|
|
{ id: 2, field: [ 'field1', 'field2' ] },
|
|
{ id: 1, field: [ 'field1', 'field2' ] }
|
|
]);
|
|
});
|
|
|
|
it("Should not have been shared the Encoder", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
id: "id",
|
|
field: ["field1", "field2"]
|
|
}
|
|
});
|
|
|
|
expect(document.index.get("field1").encoder).not.to.equal(
|
|
document.index.get("field2").encoder
|
|
);
|
|
});
|
|
|
|
it("Should have been shared the Encoder", function(){
|
|
|
|
const document = new Document({
|
|
encoder: new Encoder(),
|
|
document: {
|
|
id: "id",
|
|
field: ["field1", "field2"]
|
|
}
|
|
});
|
|
|
|
expect(document.index.get("field1").encoder).to.equal(
|
|
document.index.get("field2").encoder
|
|
);
|
|
});
|
|
|
|
it("Should have been applied limit/offset properly", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
store: true,
|
|
id: "id",
|
|
field: [
|
|
"data:title",
|
|
"data:body"
|
|
]
|
|
}
|
|
});
|
|
|
|
for(let i = 0; i < data.length; i++){
|
|
document.add(data[i]);
|
|
}
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
pluck: "data:title",
|
|
enrich: true,
|
|
suggest: true,
|
|
limit: 2
|
|
}).map(res => res.doc)).to.eql([data[0], data[1]]);
|
|
|
|
expect(document.search({
|
|
query: "body",
|
|
pluck: "data:body",
|
|
enrich: true,
|
|
suggest: true,
|
|
limit: 1,
|
|
offset: 1
|
|
}).map(res => res.doc)).to.eql([data[1]]);
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
suggest: true,
|
|
limit: 1,
|
|
offset: 3
|
|
})).to.eql([]);
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
suggest: true,
|
|
offset: 3
|
|
})).to.eql([]);
|
|
});
|
|
|
|
it("Merge Results", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
store: [
|
|
"data:title"
|
|
],
|
|
id: "id",
|
|
field: [
|
|
"data:title",
|
|
"data:body"
|
|
],
|
|
tag: "data:cat"
|
|
}
|
|
});
|
|
|
|
for(let i = 0; i < data.length; i++){
|
|
document.add(data[i]);
|
|
}
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
enrich: false,
|
|
suggest: true,
|
|
merge: true
|
|
})).to.eql([
|
|
{ id: 2, field: [ 'data:title' ] },
|
|
{ id: 1, field: [ 'data:title' ] },
|
|
{ id: 0, field: [ 'data:title' ] }
|
|
]);
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
enrich: true,
|
|
suggest: true,
|
|
merge: true
|
|
}).map(res => res.doc)).to.eql([
|
|
{ data: { title: data[0].data.title }},
|
|
{ data: { title: data[1].data.title }},
|
|
{ data: { title: data[2].data.title }}
|
|
]);
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
tag: { "data:cat": "A" },
|
|
enrich: true,
|
|
suggest: true,
|
|
merge: true
|
|
}).map(res => res.doc)).to.eql([
|
|
{ data: { title: data[0].data.title }},
|
|
{ data: { title: data[2].data.title }}
|
|
]);
|
|
});
|
|
|
|
it("Using BigInt", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
store: "data:title",
|
|
id: "id",
|
|
field: [
|
|
"data:title",
|
|
"data:body"
|
|
],
|
|
tag: "data:cat"
|
|
}
|
|
});
|
|
|
|
for(let i = 0, tmp; i < data.length; i++){
|
|
tmp = Object.assign({}, data[i], { id: BigInt(i + 1) });
|
|
document.add(tmp);
|
|
}
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
tag: { "data:cat": "A" },
|
|
merge: true
|
|
})).to.eql([
|
|
{ id: BigInt(1), field: [ "data:title" ] },
|
|
{ id: BigInt(3), field: [ "data:title" ] }
|
|
]);
|
|
});
|
|
|
|
it("Custom Document Store", function(){
|
|
|
|
const document = new Document({
|
|
document: {
|
|
store: [
|
|
"data:title"
|
|
],
|
|
id: "id",
|
|
field: [
|
|
"data:title",
|
|
"data:body"
|
|
]
|
|
}
|
|
});
|
|
|
|
for(let i = 0; i < data.length; i++){
|
|
document.add(data[i]);
|
|
}
|
|
|
|
expect(document.search({
|
|
query: "title",
|
|
enrich: true,
|
|
suggest: true,
|
|
merge: true
|
|
}).map(res => res.doc)).to.eql([
|
|
{ data: { title: data[0].data.title }},
|
|
{ data: { title: data[1].data.title }},
|
|
{ data: { title: data[2].data.title }}
|
|
]);
|
|
});
|
|
});
|