diff --git a/client/src/app/instance/store/effects/search-multiple.effects.spec.ts b/client/src/app/instance/store/effects/search-multiple.effects.spec.ts
index f09533cfcbcdb05c2fe22f05ecef33f76f9367b6..320dd80334fc75b2bd707cae5e25bf2f7b518b23 100644
--- a/client/src/app/instance/store/effects/search-multiple.effects.spec.ts
+++ b/client/src/app/instance/store/effects/search-multiple.effects.spec.ts
@@ -11,6 +11,8 @@ import { SearchMultipleEffects } from './search-multiple.effects';
import { SearchService } from '../services/search.service';
import * as searchActions from '../actions/search.actions';
import * as fromSearch from '../reducers/search.reducer';
+import * as fromSearchMultiple from '../reducers/search-multiple.reducer';
+import * as fromInstance from '../../../metamodel/reducers/instance.reducer';
import * as datasetSelector from '../../../metamodel/selectors/dataset.selector';
import * as searchSelector from '../selectors/search.selector';
import * as attributeActions from '../../../metamodel/actions/attribute.actions';
@@ -32,7 +34,13 @@ describe('SearchMultipleEffects', () => {
let searchService: SearchService;
let toastr: ToastrService;
let store: MockStore;
- const initialState = { search: { ...fromSearch.initialState } };
+ const initialState = {
+ metamodel: { instance: { ...fromInstance.initialState }},
+ instance: {
+ search: {...fromSearch.initialState},
+ searchMultiple: {...fromSearchMultiple.initialState}
+ }
+ };
let mockSearchMultipleSelectorSelectPristine;
let mockSearchMultipleSelectorSelectSelectedDatasetsByRoute;
let mockConeSearchSelectorSelectConeSearchByRoute;
@@ -43,10 +51,7 @@ describe('SearchMultipleEffects', () => {
TestBed.configureTestingModule({
providers: [
SearchMultipleEffects,
- { provide: SearchService, useValue: {
- // retrieveData: jest.fn(),
- retrieveDataLength: jest.fn()
- }},
+ { provide: SearchService, useValue: { retrieveDataLength: jest.fn() }},
{ provide: ToastrService, useValue: { error: jest.fn() }},
provideMockActions(() => actions),
provideMockStore({ initialState }),
@@ -66,43 +71,46 @@ describe('SearchMultipleEffects', () => {
mockConeSearchSelectorSelectConeSearchByRoute = store.overrideSelector(
coneSearchSelector.selectConeSearchByRoute,''
);
+ // mockInstanceSelectorSelectorSelectInstanceByRouteName = store.overrideSelector(
+ // instanceSelector.selectInstanceByRouteName,{
+ // name: 'myInstance',
+ // label: 'My Instance',
+ // data_path: 'data/path',
+ // config: {
+ // design: {
+ // design_color: 'green',
+ // design_background_color: 'darker green',
+ // design_logo: 'path/to/logo',
+ // design_favicon: 'path/to/favicon'
+ // },
+ // home: {
+ // home_component: 'HomeComponent',
+ // home_config: {
+ // home_component_text: 'Description',
+ // home_component_logo: 'path/to/logo'
+ // }
+ // },
+ // search: {
+ // search_by_criteria_allowed: true,
+ // search_by_criteria_label: 'Search',
+ // search_multiple_allowed: true,
+ // search_multiple_label: 'Search multiple',
+ // search_multiple_all_datasets_selected: true
+ // },
+ // documentation: {
+ // documentation_allowed: true,
+ // documentation_label: 'Documentation'
+ // }
+ // },
+ // nb_dataset_families: 1,
+ // nb_datasets: 2
+ // }
+ // );
mockInstanceSelectorSelectorSelectInstanceByRouteName = store.overrideSelector(
- instanceSelector.selectInstanceByRouteName,{
- name: 'myInstance',
- label: 'My Instance',
- data_path: 'data/path',
- config: {
- design: {
- design_color: 'green',
- design_background_color: 'darker green',
- design_logo: 'path/to/logo',
- design_favicon: 'path/to/favicon'
- },
- home: {
- home_component: 'HomeComponent',
- home_config: {
- home_component_text: 'Description',
- home_component_logo: 'path/to/logo'
- }
- },
- search: {
- search_by_criteria_allowed: true,
- search_by_criteria_label: 'Search',
- search_multiple_allowed: true,
- search_multiple_label: 'Search multiple',
- search_multiple_all_datasets_selected: true
- },
- documentation: {
- documentation_allowed: true,
- documentation_label: 'Documentation'
- }
- },
- nb_dataset_families: 1,
- nb_datasets: 2
- }
+ instanceSelector.selectInstanceByRouteName,undefined
);
mockDatasetSelectorSelectAllConeSearchDatasets = store.overrideSelector(
- searchSelector.selectOutputListByRoute,''
+ datasetSelector.selectAllConeSearchDatasets,[]
);
});
@@ -110,55 +118,14 @@ describe('SearchMultipleEffects', () => {
expect(effects).toBeTruthy();
});
- describe('initSearch$ effect', () => {
+ describe.only('initSearch$ effect', () => {
it('should dispatch the restartSearch action when dataset or cone search changed', () => {
mockSearchMultipleSelectorSelectPristine = store.overrideSelector(
- searchMultipleSelector.selectPristine,true
- );
- mockSearchMultipleSelectorSelectSelectedDatasetsByRoute = store.overrideSelector(
- searchMultipleSelector.selectSelectedDatasetsByRoute,''
+ searchMultipleSelector.selectPristine,false
);
mockConeSearchSelectorSelectConeSearchByRoute = store.overrideSelector(
coneSearchSelector.selectConeSearchByRoute,''
);
- mockInstanceSelectorSelectorSelectInstanceByRouteName = store.overrideSelector(
- instanceSelector.selectInstanceByRouteName,{
- name: 'myInstance',
- label: 'My Instance',
- data_path: 'data/path',
- config: {
- design: {
- design_color: 'green',
- design_background_color: 'darker green',
- design_logo: 'path/to/logo',
- design_favicon: 'path/to/favicon'
- },
- home: {
- home_component: 'HomeComponent',
- home_config: {
- home_component_text: 'Description',
- home_component_logo: 'path/to/logo'
- }
- },
- search: {
- search_by_criteria_allowed: true,
- search_by_criteria_label: 'Search',
- search_multiple_allowed: true,
- search_multiple_label: 'Search multiple',
- search_multiple_all_datasets_selected: true
- },
- documentation: {
- documentation_allowed: true,
- documentation_label: 'Documentation'
- }
- },
- nb_dataset_families: 1,
- nb_datasets: 2
- }
- );
- mockDatasetSelectorSelectAllConeSearchDatasets = store.overrideSelector(
- searchSelector.selectOutputListByRoute,''
- );
const action = searchMultipleActions.initSearch();
actions = hot('-a', { a: action });
@@ -170,6 +137,21 @@ describe('SearchMultipleEffects', () => {
expect(effects.initSearch$).toBeObservable(expected);
});
+ it('should not dispatch action when default form parameters already loaded or no dataset selected', () => {
+ mockSearchMultipleSelectorSelectPristine = store.overrideSelector(
+ searchMultipleSelector.selectPristine,false
+ );
+ mockConeSearchSelectorSelectConeSearchByRoute = store.overrideSelector(
+ coneSearchSelector.selectConeSearchByRoute,'1:2:3'
+ );
+
+ const action = searchMultipleActions.initSearch();
+ actions = hot('-a', { a: action });
+ const expected = cold('-b', { b: { type: '[No Action] Load Default Form Parameters' } });
+
+ expect(effects.initSearch$).toBeObservable(expected);
+ });
+
// it('should dispatch a bunch of actions when a dataset is selected or a page is reloaded', () => {
// mockDatasetSelectorSelectDatasetNameByRoute = store.overrideSelector(
// datasetSelector.selectDatasetNameByRoute, 'myDatasetName'
diff --git a/client/src/app/instance/store/effects/search-multiple.effects.ts b/client/src/app/instance/store/effects/search-multiple.effects.ts
index 8fd7a53c3b63b22bcd960f4016cb002cd33d69ad..2cd1eeab2499f9ad5e1ca91ba7d6dfda8768c8f1 100644
--- a/client/src/app/instance/store/effects/search-multiple.effects.ts
+++ b/client/src/app/instance/store/effects/search-multiple.effects.ts
@@ -41,16 +41,16 @@ export class SearchMultipleEffects {
this.store.select(datasetSelector.selectAllConeSearchDatasets)
]),
mergeMap(([action, pristine, coneSearchByRoute, selectedDatasetsByRoute, instance, datasetList]) => {
+ // Restart search
if (!pristine && !coneSearchByRoute) {
- // Restart search
return [
coneSearchActions.deleteConeSearch(),
searchMultipleActions.restartSearch()
];
}
+ // Default form parameters already loaded or no dataset selected
if (!pristine) {
- // Default form parameters already loaded or no dataset selected
return of({ type: '[No Action] Load Default Form Parameters' });
}
diff --git a/client/src/app/instance/store/models/criterion.model.ts b/client/src/app/instance/store/models/criterion.model.ts
index a6118e881162183a5c5bcbf1a4b63b5ad72ec2e9..95f9d974ce488501c9af3e0b868c91b3be1f2ac8 100644
--- a/client/src/app/instance/store/models/criterion.model.ts
+++ b/client/src/app/instance/store/models/criterion.model.ts
@@ -17,8 +17,9 @@ import {
import { Attribute } from 'src/app/metamodel/models';
/**
- * @class
- * @classdesc Criterion class.
+ * Interface for criterion.
+ *
+ * @interface Criterion
*/
export interface Criterion {
id: number;
diff --git a/client/src/app/instance/store/models/criterion/select-multiple-criterion.model.ts b/client/src/app/instance/store/models/criterion/select-multiple-criterion.model.ts
index 90fc0ae7499ea8d2f68ba3571503474e74a18532..e1da198fb35d9069df0126c9d1abb91439a8fae9 100644
--- a/client/src/app/instance/store/models/criterion/select-multiple-criterion.model.ts
+++ b/client/src/app/instance/store/models/criterion/select-multiple-criterion.model.ts
@@ -11,10 +11,9 @@ import { Criterion } from '../criterion.model';
import { Option } from 'src/app/metamodel/models/option.model';
/**
- * @class
- * @classdesc Select multiple criterion class.
+ * Interface for select multiple criterion.
*
- * @implements Criterion
+ * @interface SelectMultipleCriterion
*/
export interface SelectMultipleCriterion extends Criterion {
id: number;
diff --git a/client/src/app/instance/store/models/search-multiple-dataset-data.ts b/client/src/app/instance/store/models/search-multiple-dataset-data.ts
index fa25ed88176093d7840cdd984c476aed52b25ed3..0f3d0d86928cb33b5ca735f14aea4fc281b1d4da 100644
--- a/client/src/app/instance/store/models/search-multiple-dataset-data.ts
+++ b/client/src/app/instance/store/models/search-multiple-dataset-data.ts
@@ -7,6 +7,11 @@
* file that was distributed with this source code.
*/
+/**
+ * Interface for search multiple data.
+ *
+ * @interface SearchMultipleDatasetData
+ */
export interface SearchMultipleDatasetData {
datasetName: string;
data: any[];
diff --git a/client/src/app/instance/store/models/search-multiple-dataset-length.ts b/client/src/app/instance/store/models/search-multiple-dataset-length.ts
index 75961a0d5c68acd8878099d32715c9a4c9143242..73a3e0de377302eeefc85bbd15f42be7a7882c46 100644
--- a/client/src/app/instance/store/models/search-multiple-dataset-length.ts
+++ b/client/src/app/instance/store/models/search-multiple-dataset-length.ts
@@ -7,6 +7,11 @@
* file that was distributed with this source code.
*/
+/**
+ * Interface for search multiple data length.
+ *
+ * @interface SearchMultipleDatasetLength
+ */
export interface SearchMultipleDatasetLength {
datasetName: string;
length: number;
diff --git a/client/src/app/instance/store/reducers/search-multiple.reducer.spec.ts b/client/src/app/instance/store/reducers/search-multiple.reducer.spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e3ce85eec3702448d7061a4d49d6d11bc0254a9
--- /dev/null
+++ b/client/src/app/instance/store/reducers/search-multiple.reducer.spec.ts
@@ -0,0 +1,363 @@
+import { Action } from '@ngrx/store';
+
+import * as fromSearchMultiple from './search-multiple.reducer';
+import * as searchMultipleActions from '../actions/search-multiple.actions';
+import { SearchMultipleDatasetData, SearchMultipleDatasetLength } from '../models';
+
+describe('SearchMultiple reducer', () => {
+ it('unknown action should return the default state', () => {
+ const { initialState } = fromSearchMultiple;
+ const action = { type: 'Unknown' };
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state).toBe(initialState);
+ });
+
+ it('restartSearch action should set currentStep to \'position\'', () => {
+ const { initialState } = fromSearchMultiple;
+ const action = searchMultipleActions.restartSearch();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toEqual('position');
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('changeStep action should change the currentStep', () => {
+ const { initialState } = fromSearchMultiple;
+ const action = searchMultipleActions.changeStep({ step: 'myStep' });
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toEqual('myStep');
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('markAsDirty action should set pristine to false', () => {
+ const { initialState } = fromSearchMultiple;
+ const action = searchMultipleActions.markAsDirty();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeFalsy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('checkDatasets action should set datasetsStepChecked to true', () => {
+ const { initialState } = fromSearchMultiple;
+ const action = searchMultipleActions.checkDatasets();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeTruthy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('checkResult action should set resultStepChecked to true', () => {
+ const { initialState } = fromSearchMultiple;
+ const action = searchMultipleActions.checkResult();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeTruthy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('updateSelectedDatasets action should set selectedDatasets', () => {
+ const { initialState } = fromSearchMultiple;
+ const selectedDatasets: string[] = ['myDataset'];
+ const action = searchMultipleActions.updateSelectedDatasets({ selectedDatasets });
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(1);
+ expect(state.selectedDatasets).toEqual(selectedDatasets);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('retrieveDataLength action should set dataLengthIsLoading to true and dataLengthIsLoaded to false', () => {
+ const initialState = {
+ ...fromSearchMultiple.initialState,
+ dataLengthIsLoaded: true
+ };
+ const action = searchMultipleActions.retrieveDataLength();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeTruthy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('retrieveDataLengthSuccess action should set dataLength, set dataLengthIsLoading to true and dataLengthIsLoaded to false', () => {
+ const initialState = {
+ ...fromSearchMultiple.initialState,
+ dataLengthIsLoading: true
+ };
+ const dataLength: SearchMultipleDatasetLength[] = [{ datasetName: 'myDataset', length: 1 }];
+ const action = searchMultipleActions.retrieveDataLengthSuccess({ dataLength });
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeTruthy();
+ expect(state.dataLength.length).toEqual(1);
+ expect(state.dataLength).toEqual(dataLength);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('retrieveDataLengthFail action should set dataLengthIsLoading to false', () => {
+ const initialState = {
+ ...fromSearchMultiple.initialState,
+ dataLengthIsLoading: true
+ };
+ const action = searchMultipleActions.retrieveDataLengthFail();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('retrieveData action should set dataIsLoading to true and dataIsLoaded to false', () => {
+ const initialState = {
+ ...fromSearchMultiple.initialState,
+ dataIsLoaded: true
+ };
+ const action = searchMultipleActions.retrieveData();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeTruthy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('retrieveDataSuccess action should set data, set dataIsLoading to false and dataIsLoaded to true', () => {
+ const initialState = {
+ ...fromSearchMultiple.initialState,
+ dataIsLoading: true
+ };
+ const data: SearchMultipleDatasetData[] = [{ datasetName: 'myDataset', data: ['myData'] }];
+ const action = searchMultipleActions.retrieveDataSuccess({ data });
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeTruthy();
+ expect(state.data.length).toEqual(1);
+ expect(state.data).toEqual(data);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('retrieveDataFail action should set dataIsLoading to false', () => {
+ const initialState = {
+ ...fromSearchMultiple.initialState,
+ dataIsLoading: true
+ };
+ const action = searchMultipleActions.retrieveDataFail();
+ const state = fromSearchMultiple.searchMultipleReducer(initialState, action);
+
+ expect(state.pristine).toBeTruthy();
+ expect(state.currentStep).toBeNull();
+ expect(state.positionStepChecked).toBeFalsy();
+ expect(state.datasetsStepChecked).toBeFalsy();
+ expect(state.resultStepChecked).toBeFalsy();
+ expect(state.selectedDatasets.length).toEqual(0);
+ expect(state.dataLengthIsLoading).toBeFalsy();
+ expect(state.dataLengthIsLoaded).toBeFalsy();
+ expect(state.dataLength.length).toEqual(0);
+ expect(state.dataIsLoading).toBeFalsy();
+ expect(state.dataIsLoaded).toBeFalsy();
+ expect(state.data.length).toEqual(0);
+ expect(state).not.toBe(initialState);
+ });
+
+ it('should get pristine', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectPristine(state)).toBeTruthy();
+ });
+
+ it('should get currentStep', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectCurrentStep(state)).toBeNull();
+ });
+
+ it('should get positionStepChecked', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectPositionStepChecked(state)).toBeFalsy();
+ });
+
+ it('should get datasetsStepChecked', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectDatasetsStepChecked(state)).toBeFalsy();
+ });
+
+ it('should get resultStepChecked', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectResultStepChecked(state)).toBeFalsy();
+ });
+
+ it('should get selectedDatasets', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectSelectedDatasets(state).length).toEqual(0);
+ });
+
+ it('should get dataLengthIsLoading', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectDataLengthIsLoading(state)).toBeFalsy();
+ });
+
+ it('should get dataLengthIsLoaded', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectDataLengthIsLoaded(state)).toBeFalsy();
+ });
+
+ it('should get dataLength', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectDataLength(state).length).toEqual(0);
+ });
+
+ it('should get dataIsLoading', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectDataIsLoading(state)).toBeFalsy();
+ });
+
+ it('should get dataIsLoaded', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectDataIsLoaded(state)).toBeFalsy();
+ });
+
+ it('should get data', () => {
+ const action = {} as Action;
+ const state = fromSearchMultiple.searchMultipleReducer(undefined, action);
+
+ expect(fromSearchMultiple.selectData(state).length).toEqual(0);
+ });
+});
diff --git a/client/src/app/instance/store/reducers/search-multiple.reducer.ts b/client/src/app/instance/store/reducers/search-multiple.reducer.ts
index bd73fbba1df15c2853d55d21157e8a7f30fb1dbb..d5cf3af087b2055e2b0caa99b846102e2c363ba2 100644
--- a/client/src/app/instance/store/reducers/search-multiple.reducer.ts
+++ b/client/src/app/instance/store/reducers/search-multiple.reducer.ts
@@ -12,9 +12,15 @@ import { createReducer, on } from '@ngrx/store';
import { SearchMultipleDatasetLength, SearchMultipleDatasetData } from '../models';
import * as searchMultipleActions from '../actions/search-multiple.actions';
+/**
+ * Interface for search multiple state.
+ *
+ * @interface State
+ */
export interface State {
pristine: boolean;
currentStep: string;
+ // TODO: remove unused positionStepChecked variable
positionStepChecked: boolean;
datasetsStepChecked: boolean;
resultStepChecked: boolean;
diff --git a/client/src/app/instance/store/selectors/search-multiple.selector.spec.ts b/client/src/app/instance/store/selectors/search-multiple.selector.spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5b21c4ac104900ee2b3b3beef6ad151141cf8007
--- /dev/null
+++ b/client/src/app/instance/store/selectors/search-multiple.selector.spec.ts
@@ -0,0 +1,115 @@
+import * as searchMultipleSelector from './search-multiple.selector';
+import * as fromSearchMultiple from '../reducers/search-multiple.reducer';
+import * as fromConeSearch from '../reducers/cone-search.reducer';
+import { ConeSearch } from '../models';
+
+describe('Search multiple selector', () => {
+ it('should get selectPristine', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectPristine(state)).toBeTruthy();
+ });
+
+ it('should get currentStep', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectCurrentStep(state)).toBeNull();
+ });
+
+ it('should get positionStepChecked', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectPositionStepChecked(state)).toBeFalsy();
+ });
+
+ it('should get datasetsStepChecked', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectDatasetsStepChecked(state)).toBeFalsy();
+ });
+
+ it('should get resultStepChecked', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectResultStepChecked(state)).toBeFalsy();
+ });
+
+ it('should get selectedDatasets', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectSelectedDatasets(state).length).toEqual(0);
+ });
+
+ it('should get dataLengthIsLoading', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectDataLengthIsLoading(state)).toBeFalsy();
+ });
+
+ it('should get dataLengthIsLoaded', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectDataLengthIsLoaded(state)).toBeFalsy();
+ });
+
+ it('should get dataLength', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectDataLength(state).length).toEqual(0);
+ });
+
+ it('should get dataIsLoading', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectDataIsLoading(state)).toBeFalsy();
+ });
+
+ it('should get dataIsLoaded', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectDataIsLoaded(state)).toBeFalsy();
+ });
+
+ it('should get data', () => {
+ const state = { instance: { searchMultiple: { ...fromSearchMultiple.initialState }}};
+ expect(searchMultipleSelector.selectData(state).length).toEqual(0);
+ });
+
+ it('should get queryParams', () => {
+ const state = {
+ instance: {
+ searchMultiple: { ...fromSearchMultiple.initialState },
+ coneSearch: { ...fromConeSearch.initialState }
+ }
+ };
+ const expected = { };
+
+ expect(searchMultipleSelector.selectQueryParams(state)).toEqual(expected);
+ });
+
+ it('should get queryParams with cone search', () => {
+ const coneSearch: ConeSearch = { ra: 3, dec: 4, radius: 5 };
+ const state = {
+ instance: {
+ searchMultiple: { ...fromSearchMultiple.initialState },
+ coneSearch: {
+ ...fromConeSearch.initialState,
+ coneSearch
+ }
+ }
+ };
+ const expected = { cs: '3:4:5' };
+
+ expect(searchMultipleSelector.selectQueryParams(state)).toEqual(expected);
+ });
+
+ it('should get queryParams with datasets', () => {
+ const selectedDatasets: string[] = ['d1', 'd2'];
+ const state = {
+ instance: {
+ searchMultiple: {
+ ...fromSearchMultiple.initialState,
+ selectedDatasets
+ },
+ coneSearch: { ...fromConeSearch.initialState }
+ }
+ };
+ const expected = { d: 'd1;d2' };
+
+ expect(searchMultipleSelector.selectQueryParams(state)).toEqual(expected);
+ });
+
+ it('should get steps by route', () => {
+ const state = { router: { state: { queryParams: { d: 'd1;d2' }}}};
+ expect(searchMultipleSelector.selectSelectedDatasetsByRoute(state)).toEqual('d1;d2');
+ });
+});