| /******************************************************************************** |
| * Copyright (c) 2015-2020 Contributors to the Eclipse Foundation |
| * |
| * See the NOTICE file(s) distributed with this work for additional |
| * information regarding copyright ownership. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| ********************************************************************************/ |
| |
| |
| import { BaseRequestOptions, Http, HttpModule, Response, ResponseOptions } from '@angular/http'; |
| import { async, TestBed, inject } from '@angular/core/testing'; |
| import { MockBackend } from '@angular/http/testing'; |
| import { of as observableOf, Observable } from 'rxjs'; |
| |
| import { SearchService, SearchAttribute, SearchLayout } from './search.service'; |
| import { PreferenceService, Preference, Scope } from '../core/preference.service'; |
| import { PropertyService } from '../core/property.service'; |
| import { LocalizationService } from '../localization/localization.service'; |
| import { NodeService } from '../navigator/node.service'; |
| import { QueryService } from '../tableview/query.service'; |
| import { MDMNotificationService } from '../core/mdm-notification.service'; |
| import { HttpErrorHandler } from '../core/http-error-handler'; |
| |
| import { Condition, Operator } from './filter.service'; |
| import { TranslateModule } from '@ngx-translate/core'; |
| |
| class TestPreferenceService { |
| getPreference(key?: string): Observable<Preference[]> { |
| return observableOf([ |
| { |
| id: 1, |
| key: 'ignoredAttributes', |
| scope: Scope.USER, |
| source: null, |
| user: 'testUser', |
| value: '[\"*.Name\", \"TestStep.Id\", \"Measurement.*\"]' |
| // value: '[\"*.MimeType\", \"TestStep.Sortindex\"]' |
| } |
| ]); |
| } |
| } |
| |
| describe ( 'SearchService', () => { |
| |
| beforeEach(() => { |
| TestBed.configureTestingModule({ |
| imports: [ |
| HttpModule, |
| TranslateModule.forRoot(), |
| ], |
| providers: [ |
| LocalizationService, |
| PropertyService, |
| { |
| provide: PreferenceService, |
| useClass: TestPreferenceService |
| }, |
| SearchService, |
| MDMNotificationService, |
| NodeService, |
| QueryService, |
| MockBackend, |
| BaseRequestOptions, |
| HttpErrorHandler, |
| { |
| provide: Http, |
| useFactory: (backend, options) => new Http(backend, options), |
| deps: [MockBackend, BaseRequestOptions] |
| }] |
| }); |
| }); |
| |
| describe('groupByEnv()', () => { |
| it('should group attributes by environment', () => { |
| let attributes = [ |
| new SearchAttribute('env1', 'Test', 'Name'), |
| new SearchAttribute('env1', 'Vehicle', 'Name'), |
| new SearchAttribute('env2', 'Test', 'Name'), |
| new SearchAttribute('env2', 'Uut', 'Name'), |
| ]; |
| |
| let conditionsPerEnv = SearchLayout.groupByEnv(attributes); |
| |
| expect(Object.getOwnPropertyNames(conditionsPerEnv)) |
| .toContain('env1', 'env2'); |
| |
| expect(conditionsPerEnv['env1']) |
| .toContain(attributes[0], attributes[1]); |
| |
| expect(conditionsPerEnv['env2']) |
| .toContain(attributes[2], attributes[3]); |
| }); |
| }); |
| |
| describe('createSearchLayout()', () => { |
| it('should create a searchLayout object from conditions', () => { |
| let cond1 = new Condition('Test', 'Name', Operator.EQUALS, []); |
| let cond2 = new Condition('Vehicle', 'Name', Operator.EQUALS, []); |
| |
| let attributes = { |
| 'env1': [ |
| new SearchAttribute('env1', 'Test', 'Name'), |
| new SearchAttribute('env1', 'Vehicle', 'Name'), |
| ], |
| 'env2': [ |
| new SearchAttribute('env2', 'Test', 'Name'), |
| new SearchAttribute('env2', 'Uut', 'Name'), |
| ] |
| }; |
| |
| let searchLayout = SearchLayout.createSearchLayout(['env1', 'env2'], attributes, [cond1, cond2]); |
| |
| expect(searchLayout.getSourceNames()) |
| .toEqual(['Global', 'env1']); |
| |
| expect(searchLayout.getConditions('Global')) |
| .toEqual([cond1]); |
| |
| expect(searchLayout.getConditions('env1')) |
| .toEqual([cond2]); |
| |
| }); |
| }); |
| |
| describe('convert()', () => { |
| it('should convert conditions to filter string', async(inject([SearchService, MockBackend], (service, mockBackend) => { |
| let cond1 = new Condition('Test', 'Name', Operator.LIKE, ['PBN*']); |
| let cond2 = new Condition('Vehicle', 'Number', Operator.EQUALS, ['12']); |
| let cond3 = new Condition('Vehicle', 'Created', Operator.EQUALS, ['2017-07-17T12:13:14']); |
| |
| let attributes = [ |
| new SearchAttribute('env1', 'Test', 'Name'), |
| new SearchAttribute('env1', 'Vehicle', 'Number', 'LONG'), |
| new SearchAttribute('env2', 'Test', 'Name'), |
| new SearchAttribute('env2', 'Uut', 'Name'), |
| new SearchAttribute('env2', 'Vehicle', 'Created', 'DATE'), |
| ]; |
| |
| let filter = service.convertEnv('env1', [cond1, cond2, cond3], attributes, 'test'); |
| |
| expect(filter.sourceName).toEqual('env1'); |
| expect(filter.filter).toEqual('Test.Name ci_lk "PBN*" and Vehicle.Number eq 12 and Vehicle.Created eq "2017-07-17T12:13:14"'); |
| expect(filter.searchString).toEqual('test'); |
| |
| }))); |
| }); |
| |
| describe('loadSearchAttributes()', () => { |
| it('should return filtered search attributes for env', |
| async(inject([SearchService, MockBackend], |
| (searchService, mockBackend) => { |
| mockBackend.connections.subscribe(conn => { |
| let mockResponse = { |
| data: [ |
| { |
| boType: 'Test', |
| attrName: 'Name', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'Test', |
| attrName: 'Id', |
| valueType: 'LONG', |
| criteria: '*' |
| }, |
| { |
| boType: 'TestStep', |
| attrName: 'Name', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'TestStep', |
| attrName: 'MimeType', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'TestStep', |
| attrName: 'Id', |
| valueType: 'LONG', |
| criteria: '*' |
| }, |
| { |
| boType: 'Measurement', |
| attrName: 'Name', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'Measurement', |
| attrName: 'Id', |
| valueType: 'LONG', |
| criteria: '*' |
| } |
| ]}; |
| if (conn.request.url === searchService._prop.getUrl() + '/mdm/environments/TestEnv//searchattributes') { |
| conn.mockRespond(new Response(new ResponseOptions({ body: mockResponse }))); |
| } else if (conn.request.url === searchService._prop.getUrl() + '/mdm/environments/' + 'TestEnv2' + '/' + '/searchattributes') { |
| conn.mockRespond(new Response(new ResponseOptions({ body: mockResponse }))); |
| } |
| }); |
| let ans = [ |
| new SearchAttribute('TestEnv', 'Test', 'Id', 'LONG', '*'), |
| new SearchAttribute('TestEnv', 'TestStep', 'MimeType', 'STRING', '*'), |
| ]; |
| searchService.loadSearchAttributes('', 'TestEnv').subscribe(sas => { |
| expect(sas).toEqual(ans); |
| }); |
| }))); |
| }); |
| |
| describe('getFilters()', () => { |
| it('should retrun ignoredAttributes in a string array', |
| async(inject([SearchService], |
| (searchService) => { |
| expect(searchService.getFilters(undefined)).toEqual(['*.Name', 'TestStep.Id', 'Measurement.*']); |
| }))); |
| }); |
| |
| describe('filterIgnoredAttributes', () => { |
| it('should return searchAttributes without the ignored ones', |
| async(inject([SearchService], (searchService) => { |
| |
| let input = [ |
| new SearchAttribute('TestEnv', 'Test', 'Name', 'STRING'), |
| new SearchAttribute('TestEnv', 'Test', 'MimeType', 'STRING'), |
| new SearchAttribute('TestEnv', 'Test', 'Id', 'LONG'), |
| new SearchAttribute('TestEnv', 'TestStep', 'Name', 'STRING'), |
| new SearchAttribute('TestEnv', 'TestStep', 'MimeType', 'STRING'), |
| new SearchAttribute('TestEnv', 'TestStep', 'Id', 'LONG'), |
| new SearchAttribute('TestEnv', 'Measurement', 'Name', 'STRING'), |
| new SearchAttribute('TestEnv', 'Measurement', 'MimeType', 'STRING'), |
| new SearchAttribute('TestEnv', 'Measurement', 'Id', 'LONG') |
| ]; |
| |
| let ans = [ |
| new SearchAttribute('TestEnv', 'Test', 'MimeType', 'STRING'), |
| new SearchAttribute('TestEnv', 'Test', 'Id', 'LONG'), |
| new SearchAttribute('TestEnv', 'TestStep', 'MimeType', 'STRING') |
| ]; |
| |
| expect(searchService.filterIgnoredAttributes(undefined, input)).toEqual(ans); |
| }))); |
| }); |
| |
| describe('getSearchAttributes()', () => { |
| it('should return filtered search attributes for env', |
| async(inject([SearchService, MockBackend], |
| (searchService, mockBackend) => { |
| mockBackend.connections.subscribe(conn => { |
| let mockResponse = { |
| data: [ |
| { |
| boType: 'Test', |
| attrName: 'Name', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'Test', |
| attrName: 'Id', |
| valueType: 'LONG', |
| criteria: '*' |
| }, |
| { |
| boType: 'TestStep', |
| attrName: 'Name', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'TestStep', |
| attrName: 'MimeType', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'TestStep', |
| attrName: 'Id', |
| valueType: 'LONG', |
| criteria: '*' |
| }, |
| { |
| boType: 'Measurement', |
| attrName: 'Name', |
| valueType: 'STRING', |
| criteria: '*' |
| }, |
| { |
| boType: 'Measurement', |
| attrName: 'Id', |
| valueType: 'LONG', |
| criteria: '*' |
| } |
| ]}; |
| if (conn.request.url === searchService._prop.getUrl() + '/mdm/environments/TestEnv//searchattributes') { |
| conn.mockRespond(new Response(new ResponseOptions({ body: mockResponse }))); |
| } else if (conn.request.url === searchService._prop.getUrl() + '/mdm/environments/TestEnv2//searchattributes') { |
| conn.mockRespond(new Response(new ResponseOptions({ body: mockResponse }))); |
| } |
| }); |
| let ans = [ |
| new SearchAttribute('TestEnv', 'Test', 'Id', 'LONG', '*'), |
| new SearchAttribute('TestEnv', 'TestStep', 'MimeType', 'STRING', '*'), |
| new SearchAttribute('TestEnv2', 'Test', 'Id', 'LONG', '*'), |
| new SearchAttribute('TestEnv2', 'TestStep', 'MimeType', 'STRING', '*'), |
| ]; |
| |
| searchService.getSearchAttributesPerEnvs(['TestEnv', 'TestEnv2'], '').subscribe(sas => expect(sas).toEqual(ans)); |
| }))); |
| }); |
| }); |