Tests on selectors => DONE

src/app/detail/store/detail.selector.spec.ts

+import * as detailSelector from './detail.selector';
+import * as fromDetail from './detail.reducer';
+
+describe('[Detail] Selector', () => {
+    it('should get attributeList', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getAttributeList(state)).toBeNull();
+    });
+   
+    it('should get objectIsLoading', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getObjectIsLoading(state)).toBeFalsy();
+    });
+   
+    it('should get objectIsLoaded', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getObjectIsLoaded(state)).toBeFalsy();
+    });
+   
+    it('should get object', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getObject(state)).toBeNull();
+    });
+   
+    it('should get spectraIsLoading', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getSpectraIsLoading(state)).toBeFalsy();
+    });
+   
+    it('should get spectraIsLoaded', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getSpectraIsLoaded(state)).toBeFalsy();
+    });
+   
+    it('should get spectraCSV', () => {
+        const state = { detail: { ...fromDetail.initialState }};
+        expect(detailSelector.getSpectraCSV(state)).toBeNull();
+    });
+});
\ No newline at end of file

src/app/login/store/login.selector.spec.ts

+import * as loginSelector from './login.selector';
+import * as fromLogin from './login.reducer';
+
+describe('[Login] Selector', () => {
+    it('should get isAuthenticated', () => {
+        const state = { login: { ...fromLogin.initialState }};
+        expect(loginSelector.isAuthenticated(state)).toBeFalsy();
+    });
+    
+    it('should get loginToken', () => {
+        const state = { login: { ...fromLogin.initialState }};
+        expect(loginSelector.getLoginToken(state)).toBeNull();
+    });
+});

src/app/metamodel/selectors/attribute.selector.spec.ts

+import * as attributeSelector from './attribute.selector';
+import * as fromAttribute from '../reducers/attribute.reducer';
+
+describe('[Metamodel] Attribute selector', () => {
+    it('should get attributeSearchMetaIsLoading', () => {
+        const state = { metamodel: { attribute: { ...fromAttribute.initialState }}};
+        expect(attributeSelector.getAttributeSearchMetaIsLoading(state)).toBeFalsy();
+    });
+
+    it('should get attributeSearchMetaIsLoaded', () => {
+        const state = { metamodel: { attribute: { ...fromAttribute.initialState }}};
+        expect(attributeSelector.getAttributeSearchMetaIsLoaded(state)).toBeFalsy();
+    });
+
+    it('should get datasetAttributeList', () => {
+        const state = { metamodel: { attribute: { ...fromAttribute.initialState }}};
+        expect(attributeSelector.getDatasetAttributeList(state).length).toEqual(0);
+    });
+});
\ No newline at end of file

src/app/metamodel/selectors/criteria.selector.spec.ts

+import * as criteriaSelector from './criteria.selector';
+import * as fromCriteria from '../reducers/criteria.reducer';
+
+describe('[Metamodel] Criteria selector', () => {
+    it('should get criteriaSearchMetaIsLoading', () => {
+        const state = { metamodel: { criteria: { ...fromCriteria.initialState }}};
+        expect(criteriaSelector.getCriteriaSearchMetaIsLoading(state)).toBeFalsy();
+    });
+   
+    it('should get criteriaSearchMetaIsLoaded', () => {
+        const state = { metamodel: { criteria: { ...fromCriteria.initialState }}};
+        expect(criteriaSelector.getCriteriaSearchMetaIsLoaded(state)).toBeFalsy();
+    });
+   
+    it('should get criteriaFamilyList', () => {
+        const state = { metamodel: { criteria: { ...fromCriteria.initialState }}};
+        expect(criteriaSelector.getCriteriaFamilyList(state).length).toEqual(0);
+    });
+});
\ No newline at end of file

src/app/metamodel/selectors/dataset.selector.spec.ts

+import * as datasetSelector from './dataset.selector';
+import * as fromDataset from '../reducers/dataset.reducer';
+
+describe('[Metamodel] Dataset selector', () => {
+    it('should get datasetSearchMetaIsLoading', () => {
+        const state = { metamodel: { dataset: { ...fromDataset.initialState }}};
+        expect(datasetSelector.getDatasetSearchMetaIsLoading(state)).toBeFalsy();
+    });
+
+    it('should get datasetSearchMetaIsLoaded', () => {
+        const state = { metamodel: { dataset: { ...fromDataset.initialState }}};
+        expect(datasetSelector.getDatasetSearchMetaIsLoaded(state)).toBeFalsy();
+    });
+
+    it('should get projectList', () => {
+        const state = { metamodel: { dataset: { ...fromDataset.initialState }}};
+        expect(datasetSelector.getProjectList(state).length).toEqual(0);
+    });
+
+    it('should get datasetList', () => {
+        const state = { metamodel: { dataset: { ...fromDataset.initialState }}};
+        expect(datasetSelector.getDatasetList(state).length).toEqual(0);
+    });
+   
+    it('should get datasetFamilyList', () => {
+        const state = { metamodel: { dataset: { ...fromDataset.initialState }}};
+        expect(datasetSelector.getDatasetFamilyList(state).length).toEqual(0);
+    });
+});
\ No newline at end of file

src/app/metamodel/selectors/output.selector.spec.ts

+import * as outputSelector from './output.selector';
+import * as fromOutput from '../reducers/output.reducer';
+
+describe('[Metamodel] Output selector', () => {
+    it('should get outputSearchMetaIsLoading', () => {
+        const state = { metamodel: { output: { ...fromOutput.initialState }}};
+        expect(outputSelector.getOutputSearchMetaIsLoading(state)).toBeFalsy();
+    });
+   
+    it('should get outputSearchMetaIsLoaded', () => {
+        const state = { metamodel: { output: { ...fromOutput.initialState }}};
+        expect(outputSelector.getOutputSearchMetaIsLoaded(state)).toBeFalsy();
+    });
+   
+    it('should get outputFamilyList', () => {
+        const state = { metamodel: { output: { ...fromOutput.initialState }}};
+        expect(outputSelector.getOutputFamilyList(state).length).toEqual(0);
+    });
+   
+    it('should get categoryList', () => {
+        const state = { metamodel: { output: { ...fromOutput.initialState }}};
+        expect(outputSelector.getCategoryList(state).length).toEqual(0);
+    });
+});
\ No newline at end of file

src/app/search/containers/result.component.ts

@@ -29,7 +29,6 @@ export class ResultComponent implements OnInit, OnDestroy {
     public attributeSearchMetaIsLoading: Observable<boolean>;
     public attributeSearchMetaIsLoaded: Observable<boolean>;
     public apiPath: string = environment.apiUrl;
-    public instanceName: string = environment.instanceName;
     public datasetName: Observable<string>;
     public currentStep: Observable<string>;
     public datasetList: Observable<Dataset[]>;

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

+import * as searchSelector from './search.selector';
+import * as fromSearch from './search.reducer';
+import { Criterion } from './model';
+import { CRITERIA_LIST } from 'src/settings/test-data';
+
+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 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 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();
+    });
+    
+    it('should get queryParams without criteria', () => {
+        const outputList: number[] = [1, 2];
+        const state = {
+            search: {
+                ...fromSearch.initialState,
+                outputList
+            }
+        };
+        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
+            }
+        };
+        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 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
+            }
+        };
+        const expected = { s: '111', a: '1;2' };
+
+        expect(searchSelector.getQueryParams(state)).toEqual(expected);
+    });
+});
\ No newline at end of file