WIP: Tests on search multiple store

src/app/search-multiple/search-multiple-routing.module.ts

@@ -2,9 +2,9 @@ import { NgModule } from '@angular/core';
 import { Routes, RouterModule } from '@angular/router';
 
 import { SearchMultipleComponent } from './containers/search-multiple.component';
-import { PositionComponent } from "./containers/position.component";
-import { DatasetsComponent } from "./containers/datasets.component";
-import { ResultMultipleComponent } from "./containers/result-multiple.component";
+import { PositionComponent } from './containers/position.component';
+import { DatasetsComponent } from './containers/datasets.component';
+import { ResultMultipleComponent } from './containers/result-multiple.component';
 
 const routes: Routes = [
     {

src/app/search-multiple/store/search-multiple.action.ts

@@ -10,13 +10,11 @@ export const INIT_SELECTED_DATASETS = '[SearchMultiple] Init Selected Datasets';
 export const CHANGE_STEP = '[SearchMultiple] Change Step';
 export const POSITION_CHECKED = '[SearchMultiple] Position Checked';
 export const DATASETS_CHECKED = '[SearchMultiple] Datasets Checked';
+export const RESULTS_CHECKED = '[SearchMultiple] Results Checked';
 export const UPDATE_SELECTED_DATASETS = '[SearchMultiple] Update Selected Datasets';
 export const RETRIEVE_DATASETS_COUNT = '[SearchMultiple] Retrieve Datasets Count';
 export const RETRIEVE_DATASETS_COUNT_SUCCESS = '[SearchMultiple] Retrieve Datasets Count Success';
 export const RETRIEVE_DATASETS_COUNT_FAIL = '[SearchMultiple] Retrieve Datasets Count Fail';
-export const RETRIEVE_ATTRIBUTE_LIST = '[SearchMultiple] Retrieve Attribute List';
-export const RETRIEVE_ATTRIBUTE_LIST_SUCCESS = '[SearchMultiple] Retrieve Attribute List Success';
-export const RETRIEVE_ATTRIBUTE_LIST_FAIL = '[SearchMultiple] Retrieve Attribute List Fail';
 export const RETRIEVE_DATA = '[SearchMultiple] Retrieve Data';
 export const RETRIEVE_DATA_SUCCESS = '[SearchMultiple] Retrieve Data Success';
 export const RETRIEVE_DATA_FAIL = '[SearchMultiple] Retrieve Data Fail';
@@ -55,6 +53,12 @@ export class DatasetsCheckedAction implements Action {
     constructor(public payload: {} = null) { }
 }
 
+export class ResultsCheckedAction implements Action {
+    readonly type = RESULTS_CHECKED;
+
+    constructor(public payload: {} = null) { }
+}
+
 export class UpdateSelectedDatasetsAction implements Action {
     readonly type = UPDATE_SELECTED_DATASETS;
 
@@ -79,24 +83,6 @@ export class RetrieveDatasetsCountFailAction implements Action {
     constructor(public payload: {} = null) { }
 }
 
-export class RetrieveAttributeListAction implements Action {
-    readonly type = RETRIEVE_ATTRIBUTE_LIST;
-
-    constructor(public payload: string) { }
-}
-
-export class RetrieveAttributeListSuccessAction implements Action {
-    readonly type = RETRIEVE_ATTRIBUTE_LIST_SUCCESS;
-
-    constructor(public payload: { dname: string, attributeList: Attribute[] }) { }
-}
-
-export class RetrieveAttributeListFailAction implements Action {
-    readonly type = RETRIEVE_ATTRIBUTE_LIST_FAIL;
-
-    constructor(public payload: {} = null ) { }
-}
-
 export class RetrieveDataAction implements Action {
     readonly type = RETRIEVE_DATA;
 
@@ -139,13 +125,11 @@ export type Actions
     | ChangeStepAction
     | PositionCheckedAction
     | DatasetsCheckedAction
+    | ResultsCheckedAction
     | UpdateSelectedDatasetsAction
     | RetrieveDatasetsCountAction
     | RetrieveDatasetsCountSuccessAction
     | RetrieveDatasetsCountFailAction
-    | RetrieveAttributeListAction
-    | RetrieveAttributeListSuccessAction
-    | RetrieveAttributeListFailAction
     | RetrieveDataAction
     | RetrieveDataSuccessAction
     | RetrieveDataFailAction

src/app/search-multiple/store/search-multiple.reducer.ts

+import { createEntityAdapter, EntityAdapter, EntityState, Update } from '@ngrx/entity';
+
 import * as actions from './search-multiple.action';
-import { Attribute } from "../../metamodel/model";
-import { DataByDataset, DatasetCount, SearchMultipleQueryParams } from "./model";
-import {createEntityAdapter, EntityAdapter, EntityState, Update} from "@ngrx/entity";
+import { DataByDataset, DatasetCount } from './model';
 
 
 export interface State extends EntityState<DataByDataset> {
@@ -10,12 +10,10 @@ export interface State extends EntityState<DataByDataset> {
     positionStepChecked: boolean;
     datasetsStepChecked: boolean;
     resultStepChecked: boolean;
-    queryParams: SearchMultipleQueryParams;
     selectedDatasets: string[];
     datasetsCountIsLoading: boolean;
     datasetsCountIsLoaded: boolean;
     datasetsCount: DatasetCount[];
-    attributeList: { dname: string, attributeList: Attribute[] }[];
     selectedData: { dname: string, data: (string | number)[] }[];
 }
 
@@ -33,12 +31,10 @@ export const initialState: State = adapter.getInitialState({
     positionStepChecked: false,
     datasetsStepChecked: false,
     resultStepChecked: false,
-    queryParams: null,
     selectedDatasets: [],
     datasetsCountIsLoading: false,
     datasetsCountIsLoaded: false,
     datasetsCount: [],
-    attributeList: [],
     selectedData: []
 });
 
@@ -69,36 +65,36 @@ export function reducer(state: State = initialState, action: actions.Actions): S
                 datasetsStepChecked: true
             };
 
-        case actions.RETRIEVE_DATASETS_COUNT:
+        case actions.RESULTS_CHECKED:
             return {
                 ...state,
-                datasetsCountIsLoading: true
+                resultStepChecked: true
             };
 
-        case actions.RETRIEVE_DATASETS_COUNT_SUCCESS:
+        case actions.UPDATE_SELECTED_DATASETS:
             return {
                 ...state,
-                datasetsCountIsLoading: false,
-                datasetsCountIsLoaded: true,
-                datasetsCount: action.payload
+                selectedDatasets: action.payload
             };
 
-        case actions.RETRIEVE_DATASETS_COUNT_FAIL:
+        case actions.RETRIEVE_DATASETS_COUNT:
             return {
                 ...state,
-                datasetsCountIsLoading: false
+                datasetsCountIsLoading: true
             };
 
-        case actions.UPDATE_SELECTED_DATASETS:
+        case actions.RETRIEVE_DATASETS_COUNT_SUCCESS:
             return {
                 ...state,
-                selectedDatasets: action.payload
+                datasetsCountIsLoading: false,
+                datasetsCountIsLoaded: true,
+                datasetsCount: action.payload
             };
 
-        case actions.RETRIEVE_ATTRIBUTE_LIST_SUCCESS:
+        case actions.RETRIEVE_DATASETS_COUNT_FAIL:
             return {
                 ...state,
-                attributeList: [...state.attributeList, action.payload]
+                datasetsCountIsLoading: false
             };
 
         case actions.RETRIEVE_DATA:
@@ -158,10 +154,8 @@ export const getCurrentStep = (state: State) => state.currentStep;
 export const getPositionStepChecked = (state: State) => state.positionStepChecked;
 export const getDatasetsStepChecked = (state: State) => state.datasetsStepChecked;
 export const getResultStepChecked = (state: State) => state.resultStepChecked;
-export const getQueryParams = (state: State) => state.queryParams;
 export const getSelectedDatasets = (state: State) => state.selectedDatasets;
 export const getDatasetsCountIsLoading = (state: State) => state.datasetsCountIsLoading;
 export const getDatasetsCountIsLoaded = (state: State) => state.datasetsCountIsLoaded;
 export const getDatasetsCount = (state: State) => state.datasetsCount;
-export const getAttributeList = (state: State) => state.attributeList;
 export const getSelectedData = (state: State) => state.selectedData;

src/app/search-multiple/store/search-multiple.selector.spec.ts

-// import * as searchSelector from './search.selector';
-// import * as fromSearch from './search.reducer';
-// import * as fromConeSearch from '../../shared/cone-search/store/cone-search.reducer';
-// import { Criterion } from './model';
-// import { CRITERIA_LIST } from 'src/settings/test-data';
-// import { ConeSearch } from "../../shared/cone-search/store/model";
-//
-// describe('[Search] Selector', () => {
-//     it('should get pristine', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getPristine(state)).toBeTruthy();
-//     });
-//
-//     it('should get currentStep', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getCurrentStep(state)).toBeNull();
-//     });
-//
-//     it('should get datasetName', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getDatasetName(state)).toBeNull();
-//     });
-//
-//     it('should get criteriaStepChecked', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getCriteriaStepChecked(state)).toBeFalsy();
-//     });
-//
-//     it('should get outputStepChecked', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getOutputStepChecked(state)).toBeFalsy();
-//     });
-//
-//     it('should get resultStepChecked', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getResultStepChecked(state)).toBeFalsy();
-//     });
-//
-//     it('should get coneSearchAdded', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getIsConeSearchAdded(state)).toBeFalsy();
-//     });
-//
-//     it('should get criteriaList', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getCriteriaList(state).length).toEqual(0);
-//     });
-//
-//     it('should get outputList', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getOutputList(state).length).toEqual(0);
-//     });
-//
-//     it('should get searchData', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getSearchData(state)).toBeNull();
-//     });
-//
-//     it('should get dataLength', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getDataLength(state)).toBeNull();
-//     });
-//
-//     it('should get selectedData', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getSelectedData(state).length).toEqual(0);
-//     });
-//
-//     it('should get queryParams without criteria', () => {
-//         const outputList: number[] = [1, 2];
-//         const state = {
-//             search: {
-//                 ...fromSearch.initialState,
-//                 outputList
-//             },
-//             coneSearch: { ...fromConeSearch.initialState }
-//         };
-//         const expected = { s: '000', a: '1;2' };
-//
-//         expect(searchSelector.getQueryParams(state)).toEqual(expected);
-//     });
-//
-//     it('should get queryParams with criteria', () => {
-//         const outputList: number[] = [1, 2];
-//         const criteriaList: Criterion[] = CRITERIA_LIST;
-//         const state = {
-//             search: {
-//                 ...fromSearch.initialState,
-//                 outputList,
-//                 criteriaList
-//             },
-//             coneSearch: { ...fromConeSearch.initialState }
-//         };
-//         const expected = { s: '000', a: '1;2', c: '1::eq::fd_crit_1;2::eq::fd_crit_2' };
-//
-//         expect(searchSelector.getQueryParams(state)).toEqual(expected);
-//     });
-//
-//     it('should get queryParams with cone search', () => {
-//         const outputList: number[] = [1, 2];
-//         const coneSearchAdded: boolean = true;
-//         const coneSearch: ConeSearch = { ra: 3, dec: 4, radius: 5 };
-//         const state = {
-//             search: {
-//                 ...fromSearch.initialState,
+import * as searchMultipleSelector from './search-multiple.selector';
+import * as fromSearchMultiple from './search-multiple.reducer';
+import * as fromConeSearch from '../../shared/cone-search/store/cone-search.reducer';
+import { ConeSearch } from '../../shared/cone-search/store/model';
+import { SearchMultipleQueryParams } from './model';
+
+describe('[SearchMultiple] Selector', () => {
+    it('should get current step', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getCurrentStep(state)).toBeNull();
+    });
+
+    it('should get positionStepChecked', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getPositionStepChecked(state)).toBeFalsy();
+    });
+
+    it('should get datasetsStepChecked', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getDatasetsStepChecked(state)).toBeFalsy();
+    });
+
+    it('should get resultsStepChecked', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getResultStepChecked(state)).toBeFalsy();
+    });
+
+    it('should get selectedDatasets', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getSelectedDatasets(state).length).toEqual(0);
+    });
+
+    it('should get noSelectedDatasets', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getNoSelectedDatasets(state)).toBeTruthy();
+    });
+
+    it('should get queryParams without cone search and selected datasets', () => {
+        const state = {
+            searchMultiple: { ...fromSearchMultiple.initialState },
+            coneSearch: { ...fromConeSearch.initialState }
+        };
+
+        expect(searchMultipleSelector.getQueryParams(state)).toEqual({});
+    });
+
+    it('should get queryParams with cone search', () => {
+        const coneSearch: ConeSearch = { ra: 1, dec: 2, radius: 3 };
+        const state = {
+            searchMultiple: { ...fromSearchMultiple.initialState },
+            coneSearch: {
+                ...fromConeSearch.initialState,
+                coneSearch
+            }
+        };
+        const expectedQueryParams: SearchMultipleQueryParams = { cs: '1:2:3' };
+
+        expect(searchMultipleSelector.getQueryParams(state)).toEqual(expectedQueryParams);
+    });
+
+    it('should get queryParams with selected datasets', () => {
+        const selectedDatasets: string[] = ['toto', 'tutu'];
+        const state = {
+            searchMultiple: {
+                ...fromSearchMultiple.initialState,
+                selectedDatasets
+            },
+            coneSearch: { ...fromConeSearch.initialState }
+        };
+        const expectedQueryParams: SearchMultipleQueryParams = { d: 'toto;tutu' };
+
+        expect(searchMultipleSelector.getQueryParams(state)).toEqual(expectedQueryParams);
+    });
+
+    it('should get datasetsCountIsLoading', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getDatasetsCountIsLoading(state)).toBeFalsy();
+    });
+
+    it('should get datasetsCountIsLoaded', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getDatasetsCountIsLoaded(state)).toBeFalsy();
+    });
+
+    it('should get datasetsCount', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getDatasetsCount(state).length).toEqual(0);
+    });
+
+    it('should get datasetsWithData', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getDatasetsWithData(state).length).toEqual(0);
+    });
+
+    it('should get allData', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getAllData(state)).toEqual({});
+    });
+
+    it('should get sSelectedData', () => {
+        const state = { searchMultiple: { ...fromSearchMultiple.initialState }};
+        expect(searchMultipleSelector.getSelectedData(state).length).toEqual(0);
+    });
+});
\ No newline at end of file
-//                 outputList,
-//                 coneSearchAdded
-//             },
-//             coneSearch: {
-//                 ...fromConeSearch.initialState,
-//                 coneSearch
-//             }
-//         };
-//         const expected = { s: '000', a: '1;2', cs: '3:4:5' };
-//
-//         expect(searchSelector.getQueryParams(state)).toEqual(expected);
-//     });
-//
-//     it('should get queryParams with checked steps', () => {
-//         const criteriaStepChecked: boolean = true;
-//         const outputStepChecked: boolean = true;
-//         const resultStepChecked: boolean = true;
-//         const outputList: number[] = [1, 2];
-//         const state = {
-//             search: {
-//                 ...fromSearch.initialState,
-//                 criteriaStepChecked,
-//                 outputStepChecked,
-//                 resultStepChecked,
-//                 outputList
-//             },
-//             coneSearch: { ...fromConeSearch.initialState }
-//         };
-//         const expected = { s: '111', a: '1;2' };
-//
-//         expect(searchSelector.getQueryParams(state)).toEqual(expected);
-//     });
-//
-//     it('should get processWip', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getProcessWip(state)).toBeFalsy();
-//     });
-//
-//     it('should get processDone', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getProcessDone(state)).toBeFalsy();
-//     });
-//
-//     it('should get processId', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getProcessId(state)).toBeNull();
-//     });
-//
-//     it('should get outputListEmpty', () => {
-//         const state = { search: { ...fromSearch.initialState }};
-//         expect(searchSelector.getOutputListEmpty(state)).toBeNull();
-//     });
-// });
\ No newline at end of file

src/app/search-multiple/store/search-multiple.selector.ts

 import { createSelector, createFeatureSelector } from '@ngrx/store';
 
 import * as searchMultiple from './search-multiple.reducer';
-import { getConeSearch, getIsValidConeSearch } from "../../shared/cone-search/store/cone-search.selector";
-import { ConeSearch } from "../../shared/cone-search/store/model";
-import { SearchMultipleQueryParams } from "./model";
-import * as att from "../../metamodel/reducers/att.reducer";
-import {getAttState} from "../../metamodel/selectors";
+import { getConeSearch, getIsValidConeSearch } from '../../shared/cone-search/store/cone-search.selector';
+import { ConeSearch } from '../../shared/cone-search/store/model';
+import { SearchMultipleQueryParams } from './model';
+
 
 export const getSearchMultipleState = createFeatureSelector<searchMultiple.State>('searchMultiple');
 
@@ -83,11 +82,6 @@ export const getDatasetsCount = createSelector(
     searchMultiple.getDatasetsCount
 );
 
-export const getAttributeList = createSelector(
-    getSearchMultipleState,
-    searchMultiple.getAttributeList
-);
-
 export const getDatasetsWithData = createSelector(
     getSearchMultipleState,
     searchMultiple.selectIds
@@ -98,11 +92,6 @@ export const getAllData = createSelector(
     searchMultiple.selectEntities
 );
 
-// export const getData = createSelector(
-//     getSearchMultipleState,
-//     searchMultiple.getData
-// );
-
 export const getSelectedData = createSelector(
     getSearchMultipleState,
     searchMultiple.getSelectedData

src/app/search-multiple/store/search-multiple.service.ts

 import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
 import { environment } from '../../../environments/environment';
-import { Observable } from "rxjs";
-import { Attribute } from "../../metamodel/model";
-import { map, tap, switchMap, withLatestFrom, catchError, delay } from 'rxjs/operators';
-import { DatasetCount } from "./model";
+import { DatasetCount } from './model';
 
 
 @Injectable()
@@ -23,14 +23,6 @@ export class SearchMultipleService {
         );
     }
 
-    // retrieveAttributeList(dname: string): Observable<{ dname: string, attributeList: Attribute[] }> {
-    //     return this.http.get<Attribute[]>(this.API_PATH + '/dataset/' + dname + '/attribute').pipe(
-    //         map(res => {
-    //             return { dname: dname, attributeList: res };
-    //         })
-    //     );
-    // }
-
     retrieveData(dname: string, query: string): Observable<{ datasetName: string, data: any[] }> {
         return this.http.get<any[]>(this.API_PATH + '/search/' + query).pipe(
             map(res => {

src/app/shared/cone-search/store/cone-search.effects.ts

 import { Injectable } from '@angular/core';
 import { FormControl, Validators } from '@angular/forms';
 
+import * as fromRouter from '@ngrx/router-store';
 import { Effect, Actions, ofType } from '@ngrx/effects';
 import { Action, Store } from '@ngrx/store';
 import { of } from 'rxjs';
 import { map, tap, switchMap, withLatestFrom, catchError } from 'rxjs/operators';
-
 import { ToastrService } from 'ngx-toastr';
+
 import * as coneSearchActions from './cone-search.action';
-import * as fromRouter from '@ngrx/router-store';
 import * as fromConeSearch from './cone-search.reducer';
 import * as utils from '../../utils';
 import { ConeSearchService } from './cone-search.service';
 import { nanValidator, rangeValidator } from '../../validator';
-import {ConeSearch} from "./model";
+import { ConeSearch } from './model';
 
 
 @Injectable()
@@ -94,7 +94,6 @@ export class ConeSearchEffects {
             if (!raForm.errors && !decForm.errors && !radiusForm.errors) {
                 const actions: Action[] = [];
                 actions.push(new coneSearchActions.AddConeSearchAction(addConeSearchFromUrlAction.payload));
-                // actions.push(new coneSearchActions.IsValidConeSearchAction(true));
                 return actions;
             } else {
                 this.toastr.error('Cone search from URL is not valid', 'Not valid position!');