mirror of
https://github.com/Alfresco/alfresco-ng2-components.git
synced 2025-05-12 17:04:57 +00:00
b28a53afe7
* remove xit test and ban xit and xdescribe use in the future * remove xit test and ban xit and xdescribe use in the future * remove test excluded * remove consecutive blank line
624 lines
22 KiB
TypeScript
624 lines
22 KiB
TypeScript
/*!
|
|
* @license
|
|
* Copyright 2019 Alfresco Software, Ltd.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import { SearchQueryBuilderService } from './search-query-builder.service';
|
|
import { SearchConfiguration } from './search-configuration.interface';
|
|
import { AppConfigService } from '@alfresco/adf-core';
|
|
import { FacetField } from './facet-field.interface';
|
|
|
|
describe('SearchQueryBuilder', () => {
|
|
|
|
const buildConfig = (searchSettings): AppConfigService => {
|
|
const config = new AppConfigService(null);
|
|
config.config.search = searchSettings;
|
|
return config;
|
|
};
|
|
|
|
it('should reset to defaults', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true },
|
|
<any> { id: 'cat2', enabled: true }
|
|
],
|
|
filterQueries: [
|
|
{ query: 'query1' },
|
|
{ query: 'query2' }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
builder.categories = [];
|
|
builder.filterQueries = [];
|
|
|
|
expect(builder.categories.length).toBe(0);
|
|
expect(builder.filterQueries.length).toBe(0);
|
|
|
|
builder.resetToDefaults();
|
|
|
|
expect(builder.categories.length).toBe(2);
|
|
expect(builder.filterQueries.length).toBe(2);
|
|
});
|
|
|
|
it('should have empty user query by default', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
expect(builder.userQuery).toBe('');
|
|
});
|
|
|
|
it('should wrap user query with brackets', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
builder.userQuery = 'my query';
|
|
expect(builder.userQuery).toEqual('(my query)');
|
|
});
|
|
|
|
it('should trim user query value', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
builder.userQuery = ' something ';
|
|
expect(builder.userQuery).toEqual('(something)');
|
|
});
|
|
|
|
it('should use only enabled categories', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true },
|
|
<any> { id: 'cat2', enabled: false },
|
|
<any> { id: 'cat3', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
expect(builder.categories.length).toBe(2);
|
|
expect(builder.categories[0].id).toBe('cat1');
|
|
expect(builder.categories[1].id).toBe('cat3');
|
|
});
|
|
|
|
it('should fetch filter queries from config', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [],
|
|
filterQueries: [
|
|
{ query: 'query1' },
|
|
{ query: 'query2' }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
expect(builder.filterQueries.length).toBe(2);
|
|
expect(builder.filterQueries[0].query).toBe('query1');
|
|
expect(builder.filterQueries[1].query).toBe('query2');
|
|
});
|
|
|
|
it('should add new filter query', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
|
|
builder.addFilterQuery('q1');
|
|
|
|
expect(builder.filterQueries.length).toBe(1);
|
|
expect(builder.filterQueries[0].query).toBe('q1');
|
|
});
|
|
|
|
it('should not add empty filter query', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
|
|
builder.addFilterQuery(null);
|
|
builder.addFilterQuery('');
|
|
|
|
expect(builder.filterQueries.length).toBe(0);
|
|
});
|
|
|
|
it('should not add duplicate filter query', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
|
|
builder.addFilterQuery('q1');
|
|
builder.addFilterQuery('q1');
|
|
builder.addFilterQuery('q1');
|
|
|
|
expect(builder.filterQueries.length).toBe(1);
|
|
expect(builder.filterQueries[0].query).toBe('q1');
|
|
});
|
|
|
|
it('should remove filter query', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
|
|
builder.addFilterQuery('q1');
|
|
builder.addFilterQuery('q2');
|
|
expect(builder.filterQueries.length).toBe(2);
|
|
|
|
builder.removeFilterQuery('q1');
|
|
expect(builder.filterQueries.length).toBe(1);
|
|
expect(builder.filterQueries[0].query).toBe('q2');
|
|
});
|
|
|
|
it('should not remove empty query', () => {
|
|
const builder = new SearchQueryBuilderService(buildConfig({}), null);
|
|
builder.addFilterQuery('q1');
|
|
builder.addFilterQuery('q2');
|
|
expect(builder.filterQueries.length).toBe(2);
|
|
|
|
builder.removeFilterQuery(null);
|
|
builder.removeFilterQuery('');
|
|
expect(builder.filterQueries.length).toBe(2);
|
|
});
|
|
|
|
it('should fetch facet query from config', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [],
|
|
facetQueries: {
|
|
queries: [
|
|
{ query: 'q1', label: 'query1' },
|
|
{ query: 'q2', label: 'query2' }
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
const query = builder.getFacetQuery('query2');
|
|
|
|
expect(query.query).toBe('q2');
|
|
expect(query.label).toBe('query2');
|
|
});
|
|
|
|
it('should not fetch empty facet query from the config', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [],
|
|
facetQueries: {
|
|
queries: [
|
|
{ query: 'q1', label: 'query1' }
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
const query1 = builder.getFacetQuery('');
|
|
expect(query1).toBeNull();
|
|
|
|
const query2 = builder.getFacetQuery(null);
|
|
expect(query2).toBeNull();
|
|
});
|
|
|
|
it('should fetch facet from the config by label', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [],
|
|
facetFields: {
|
|
'fields': [
|
|
{ 'field': 'content.mimetype', 'mincount': 1, 'label': 'Type' },
|
|
{ 'field': 'content.size', 'mincount': 1, 'label': 'Size' }
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
const field = builder.getFacetField('Size');
|
|
|
|
expect(field.label).toBe('Size');
|
|
expect(field.field).toBe('content.size');
|
|
});
|
|
|
|
it('should not fetch facet from the config by label', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [],
|
|
facetFields: {
|
|
'fields': [
|
|
{ 'field': 'content.mimetype', 'mincount': 1, 'label': 'Type' },
|
|
{ 'field': 'content.size', 'mincount': 1, 'label': 'Size' }
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
const field = builder.getFacetField('Missing');
|
|
|
|
expect(field).toBeFalsy();
|
|
});
|
|
|
|
it('should fetch facets from the config by label with spaces and return field with request compatible label (escaped)', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [],
|
|
facetFields: { 'fields': [
|
|
{ 'field': 'content.size', 'mincount': 1, 'label': 'Label with spaces' }
|
|
]}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
const field = builder.getFacetField('Label with spaces');
|
|
|
|
expect(field.label).toBe('"Label with spaces"');
|
|
expect(field.field).toBe('content.size');
|
|
});
|
|
|
|
it('should require a query fragment to build query', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = null;
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled).toBeNull();
|
|
});
|
|
|
|
it('should build query with single fragment', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.query.query).toBe('(cm:name:test)');
|
|
});
|
|
|
|
it('should build query with multiple fragments', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true },
|
|
<any> { id: 'cat2', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
builder.queryFragments['cat2'] = 'NOT cm:creator:System';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.query.query).toBe(
|
|
'(cm:name:test) AND (NOT cm:creator:System)'
|
|
);
|
|
});
|
|
|
|
it('should build query with custom fields', () => {
|
|
const config: SearchConfiguration = {
|
|
fields: ['field1', 'field2'],
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true },
|
|
<any> { id: 'cat2', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.fields).toEqual(['field1', 'field2']);
|
|
});
|
|
|
|
it('should build query with empty custom fields', () => {
|
|
const config: SearchConfiguration = {
|
|
fields: [],
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true },
|
|
<any> { id: 'cat2', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.fields).toEqual([]);
|
|
});
|
|
|
|
it('should build query with custom filter queries', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
builder.addFilterQuery('query1');
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.filterQueries).toEqual(
|
|
[{ query: 'query1' }]
|
|
);
|
|
});
|
|
|
|
it('should build query with custom facet queries', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
],
|
|
facetQueries: {
|
|
queries: [
|
|
{ query: 'q1', label: 'q2', group: 'group-name' }
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.facetQueries).toEqual(config.facetQueries.queries);
|
|
});
|
|
|
|
it('should build query with custom facet fields', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
],
|
|
facetFields: {
|
|
fields: [
|
|
{ field: 'field1', label: 'field1', mincount: 1, limit: null, offset: 0, prefix: null },
|
|
{ field: 'field2', label: 'field2', mincount: 1, limit: null, offset: 0, prefix: null }
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.facetFields.facets).toEqual(jasmine.objectContaining(config.facetFields.fields));
|
|
});
|
|
|
|
it('should build query with custom facet fields automatically getting their request compatible labels', () => {
|
|
const spacesLabel = {
|
|
configValue: 'label with spaces',
|
|
requestCompatibleValue: '"label with spaces"'
|
|
};
|
|
const noSpacesLabel = {
|
|
configValue: 'label',
|
|
requestCompatibleValue: 'label'
|
|
};
|
|
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
],
|
|
facetFields: { fields: [
|
|
{ field: 'field1', label: spacesLabel.configValue, mincount: 1, limit: null, offset: 0, prefix: null },
|
|
{ field: 'field2', label: noSpacesLabel.configValue, mincount: 1, limit: null, offset: 0, prefix: null }
|
|
]}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.facetFields.facets[0].label).toEqual(spacesLabel.requestCompatibleValue);
|
|
expect(compiled.facetFields.facets[0].label).not.toEqual(spacesLabel.configValue);
|
|
expect(compiled.facetFields.facets[1].label).toEqual(noSpacesLabel.requestCompatibleValue);
|
|
expect(compiled.facetFields.facets[1].label).toEqual(noSpacesLabel.configValue);
|
|
});
|
|
|
|
it('should build query with custom facet intervals', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
],
|
|
facetIntervals: {
|
|
intervals: [
|
|
{
|
|
label: 'test_intervals1',
|
|
field: 'f1',
|
|
sets: [
|
|
{ label: 'interval1', start: 's1', end: 'e1', startInclusive: true, endInclusive: true },
|
|
{ label: 'interval2', start: 's2', end: 'e2', startInclusive: false, endInclusive: true }
|
|
]
|
|
},
|
|
{
|
|
label: 'test_intervals2',
|
|
field: 'f2',
|
|
sets: [
|
|
{ label: 'interval3', start: 's3', end: 'e3', startInclusive: true, endInclusive: false },
|
|
{ label: 'interval4', start: 's4', end: 'e4', startInclusive: false, endInclusive: false }
|
|
]
|
|
}
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.facetIntervals).toEqual(jasmine.objectContaining(config.facetIntervals));
|
|
});
|
|
|
|
it('should build query with custom facet intervals automatically getting their request compatible labels', () => {
|
|
const spacesLabel = {
|
|
configValue: 'label with spaces',
|
|
requestCompatibleValue: '"label with spaces"'
|
|
};
|
|
const noSpacesLabel = {
|
|
configValue: 'label',
|
|
requestCompatibleValue: 'label'
|
|
};
|
|
const spacesLabelForSet = {
|
|
configValue: 'label for set',
|
|
requestCompatibleValue: '"label for set"'
|
|
};
|
|
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
],
|
|
facetIntervals: {
|
|
intervals: [
|
|
{
|
|
label: spacesLabel.configValue,
|
|
field: 'f1',
|
|
sets: [
|
|
{ label: spacesLabelForSet.configValue, start: 's1', end: 'e1' },
|
|
{ label: 'interval2', start: 's2', end: 'e2' }
|
|
]
|
|
},
|
|
{
|
|
label: noSpacesLabel.configValue,
|
|
field: 'f2',
|
|
sets: [
|
|
{ label: 'interval3', start: 's3', end: 'e3' },
|
|
{ label: 'interval4', start: 's4', end: 'e4' }
|
|
]
|
|
}
|
|
]
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.facetIntervals.intervals[0].label).toEqual(spacesLabel.requestCompatibleValue);
|
|
expect(compiled.facetIntervals.intervals[0].label).not.toEqual(spacesLabel.configValue);
|
|
expect(compiled.facetIntervals.intervals[1].label).toEqual(noSpacesLabel.requestCompatibleValue);
|
|
expect(compiled.facetIntervals.intervals[1].label).toEqual(noSpacesLabel.configValue);
|
|
|
|
expect(compiled.facetIntervals.intervals[0].sets[0].label).toEqual(spacesLabelForSet.requestCompatibleValue);
|
|
|
|
});
|
|
|
|
it('should build query with sorting', () => {
|
|
const config: SearchConfiguration = {
|
|
fields: [],
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true },
|
|
<any> { id: 'cat2', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
const sorting: any = { type: 'FIELD', field: 'cm:name', ascending: true };
|
|
builder.sorting = [sorting];
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.sort[0]).toEqual(jasmine.objectContaining(sorting));
|
|
});
|
|
|
|
it('should use pagination settings', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
builder.paging = { maxItems: 5, skipCount: 5 };
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.paging).toEqual({
|
|
maxItems: 5,
|
|
skipCount: 5
|
|
});
|
|
});
|
|
|
|
it('should build final request with user and custom queries', () => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.userQuery = 'my query';
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.query.query).toBe('(my query) AND (cm:name:test)');
|
|
});
|
|
|
|
it('should group facet buckets by field', () => {
|
|
const field1: FacetField = {
|
|
field: 'f1',
|
|
label: 'f1'
|
|
};
|
|
|
|
const field1buckets = [
|
|
{ checked: true, filterQuery: 'f1-q1', label: 'f1-q1', count: 1 },
|
|
{ checked: true, filterQuery: 'f1-q2', label: 'f1-q2', count: 1 }
|
|
];
|
|
|
|
const field2: FacetField = {
|
|
field: 'f2',
|
|
label: 'f2'
|
|
};
|
|
|
|
const field2buckets = [
|
|
{ checked: true, filterQuery: 'f2-q1', label: 'f2-q1', count: 1 },
|
|
{ checked: true, filterQuery: 'f2-q2', label: 'f2-q2', count: 1 }
|
|
];
|
|
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
|
|
builder.addUserFacetBucket(field1, field1buckets[0]);
|
|
builder.addUserFacetBucket(field1, field1buckets[1]);
|
|
builder.addUserFacetBucket(field2, field2buckets[0]);
|
|
builder.addUserFacetBucket(field2, field2buckets[1]);
|
|
|
|
const compiledQuery = builder.buildQuery();
|
|
const expectedResult = '(f1-q1 OR f1-q2) AND (f2-q1 OR f2-q2)';
|
|
|
|
expect(compiledQuery.query.query).toBe(expectedResult);
|
|
});
|
|
|
|
it('should use highlight in the queries', () => {
|
|
const config: SearchConfiguration = {
|
|
highlight: {
|
|
'prefix': 'my-prefix',
|
|
'postfix': 'my-postfix',
|
|
'mergeContiguous': true
|
|
}
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
builder.userQuery = 'my query';
|
|
|
|
builder.queryFragments['cat1'] = 'cm:name:test';
|
|
|
|
const compiled = builder.buildQuery();
|
|
expect(compiled.highlight.prefix).toBe('my-prefix');
|
|
expect(compiled.highlight.postfix).toBe('my-postfix');
|
|
expect(compiled.highlight.mergeContiguous).toBe(true);
|
|
});
|
|
|
|
it('should emit error event', (done) => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
spyOn(builder, 'buildQuery').and.throwError('some error');
|
|
|
|
builder.error.subscribe(() => {
|
|
done();
|
|
});
|
|
|
|
builder.execute();
|
|
});
|
|
|
|
it('should emit empty results on error', (done) => {
|
|
const config: SearchConfiguration = {
|
|
categories: [
|
|
<any> { id: 'cat1', enabled: true }
|
|
]
|
|
};
|
|
const builder = new SearchQueryBuilderService(buildConfig(config), null);
|
|
spyOn(builder, 'buildQuery').and.throwError('some error');
|
|
|
|
builder.executed.subscribe((data) => {
|
|
expect(data.list.entries).toEqual([]);
|
|
expect(data.list.pagination.totalItems).toBe(0);
|
|
done();
|
|
});
|
|
|
|
builder.execute();
|
|
});
|
|
|
|
});
|