Merge branch 'tests-integration' into 'develop'

Tests integration

See merge request !71

angular.json

@@ -81,7 +81,7 @@
                 },
                 "test": {
                     "builder": "@angular-devkit/build-angular:karma",
-                    "codeCoverageExclude": ["node_modules/**", ""],
+                    "codeCoverageExclude": ["node_modules/**", "src/settings/test-data/**"],
                     "options": {
                         "main": "src/test.ts",
                         "polyfills": "src/polyfills.ts",

src/app/search/components/criteria/criteria-tabs.component.html

@@ -5,8 +5,8 @@
             <app-criteria-by-family 
                 [attributeList]="getAttributeByFamily(criteriaFamilyList[0].id)"
                 [criteriaList]="criteriaList" 
-                (addCriterion)="add($event)" 
-                (deleteCriterion)="delCriterion($event)">
+                (addCriterion)="emitAdd($event)" 
+                (deleteCriterion)="emitDelete($event)">
             </app-criteria-by-family>
         </div>
     </div>
@@ -31,8 +31,8 @@
             <app-criteria-by-family 
                 [attributeList]="getAttributeByFamily(family.id)" 
                 [criteriaList]="criteriaList"
-                (addCriterion)="add($event)" 
-                (deleteCriterion)="delCriterion($event)">
+                (addCriterion)="emitAdd($event)" 
+                (deleteCriterion)="emitDelete($event)">
             </app-criteria-by-family>
         </accordion-group>
     </ng-container>

src/app/search/components/criteria/criteria-tabs.component.spec.ts

+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+
+import { AccordionModule } from 'ngx-bootstrap';
+import { CriteriaTabsComponent } from './criteria-tabs.component';
+import { Attribute, Family } from '../../../metamodel/model';
+import { Criterion, FieldCriterion } from '../../store/model';
+import { CRITERIA_FAMILY_LIST, ATTRIBUTE_LIST, CRITERIA_LIST } from '../../../../settings/test-data';
+
+describe('[Search][Criteria] Component: CriteriaTabsComponent', () => {
+    @Component({
+        selector: `app-host`,
+        template: `
+            <app-criteria-tabs
+                [criteriaFamilyList]="criteriaFamilyList"
+                [datasetAttributeList]="datasetAttributeList"
+                [criteriaList]="criteriaList">
+            </app-criteria-tabs>
+        `
+    })
+    class TestHostComponent {
+        @ViewChild(CriteriaTabsComponent, { static: false })
+        public testedComponent: CriteriaTabsComponent;
+        private criteriaFamilyList: Family[] = CRITERIA_FAMILY_LIST;
+        private datasetAttributeList: Attribute[] = ATTRIBUTE_LIST;
+        private criteriaList: Criterion[] = CRITERIA_LIST;
+    }
+
+    @Component({ selector: 'app-criteria-by-family', template: '' })
+    class CriteriaByFamilyStubComponent {
+        @Input() attributeList: Attribute[];
+        @Input() criteriaList: Criterion[];
+        @Output() addCriterion: EventEmitter<Criterion> = new EventEmitter();
+        @Output() deleteCriterion: EventEmitter<number> = new EventEmitter();
+    }
+
+    let testHostComponent: TestHostComponent;
+    let testHostFixture: ComponentFixture<TestHostComponent>;
+    let testedComponent: CriteriaTabsComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            declarations: [
+                CriteriaTabsComponent,
+                TestHostComponent,
+                CriteriaByFamilyStubComponent
+            ],
+            imports: [AccordionModule.forRoot(), BrowserAnimationsModule]
+        });
+        testHostFixture = TestBed.createComponent(TestHostComponent);
+        testHostComponent = testHostFixture.componentInstance;
+        testHostFixture.detectChanges();
+        testedComponent = testHostComponent.testedComponent;
+    }));
+
+    it('should create the component', () => {
+        expect(testedComponent).toBeTruthy();
+    });
+
+    it('#getAttributeByFamily(idFamily) should filter attibutes by idFamily', () => {
+        const filteredAttributeList: Attribute[] = testedComponent.getAttributeByFamily(1);
+        expect(filteredAttributeList.length).toBe(1);
+        expect(filteredAttributeList[0].id).toBe(1);
+    });
+
+    it('#getCriteriaFamilyListSortedByDisplay() should sort criteria family by display', () => {
+        const sortedcriteriaFamily = testedComponent.getCriteriaFamilyListSortedByDisplay();
+        expect(sortedcriteriaFamily.length).toBe(3);
+        expect(sortedcriteriaFamily[0].id).toBe(1);
+        expect(sortedcriteriaFamily[2].id).toBe(3);
+    });
+
+    it('raises the add criterion event when clicked', () => {
+        const criterion = new FieldCriterion(1, 'eq', 'test');
+        testedComponent.addCriterion.subscribe((event: FieldCriterion) => expect(event).toEqual(criterion));
+        testedComponent.emitAdd(criterion);
+    });
+
+    it('raises the delete criterion event when clicked', () => {
+        const criterionId = 1;
+        testedComponent.deleteCriterion.subscribe((event: number) => expect(event).toEqual(1));
+        testedComponent.emitDelete(criterionId);
+    });
+});
+

src/app/search/components/criteria/criteria-tabs.component.ts

@@ -25,11 +25,11 @@ export class CriteriaTabsComponent {
             .sort((a, b) => a.display - b.display);
     }
 
-    add(criterion: Criterion): void {
+    emitAdd(criterion: Criterion): void {
         this.addCriterion.emit(criterion);
     }
 
-    delCriterion(id: number): void {
+    emitDelete(id: number): void {
         this.deleteCriterion.emit(id);
     }
 }

src/app/search/components/dataset/dataset-card.component.html

@@ -11,9 +11,15 @@
                     <p class="my-3">{{ dataset.description }}</p>
                 </div>
                 <div class="row">
-                    <button class="btn btn-link p-0" popover="{{project.description}}" popoverTitle="{{project.label}}"
-                        placement="bottom" [outsideClick]="true" triggers="mouseenter:mouseleave">
-                        <small>More about {{project.label}} project <span class="fas fa-question-circle"></span></small>
+                    <button class="btn btn-link p-0" 
+                        popover="{{ project.description }}" 
+                        popoverTitle="{{ project.label }}"
+                        placement="bottom" 
+                        [outsideClick]="true" 
+                        triggers="mouseenter:mouseleave">
+                        <small>
+                            More about {{ project.label }} project <span class="fas fa-question-circle"></span>
+                            </small>
                     </button>
                 </div>
             </div>

src/app/search/components/dataset/dataset-card.component.spec.ts

+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { Component, ViewChild } from '@angular/core';
+
+import { PopoverModule } from 'ngx-bootstrap';
+import { DatasetCardComponent } from './dataset-card.component';
+import { Dataset, Project } from '../../../metamodel/model';
+import { DATASET, PROJECT } from '../../../../settings/test-data';
+
+describe('[Search][Dataset] Component: DatasetCardComponent', () => {
+    @Component({
+        selector: `app-host`,
+        template: `
+            <app-dataset-card
+                [project]="project"
+                [dataset]="dataset"
+                [datasetSelected]="datasetSelected">
+            </app-dataset-card>
+        `
+    })
+    class TestHostComponent {
+        @ViewChild(DatasetCardComponent, { static: false })
+        public testedComponent: DatasetCardComponent;
+        private project: Project = PROJECT;
+        private dataset: Dataset = DATASET;
+        private datasetSelected = 'cat_1';
+    }
+
+    let testHostComponent: TestHostComponent;
+    let testHostFixture: ComponentFixture<TestHostComponent>;
+    let testedComponent: DatasetCardComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            declarations: [
+                DatasetCardComponent,
+                TestHostComponent
+            ],
+            imports: [PopoverModule.forRoot()]
+        });
+        testHostFixture = TestBed.createComponent(TestHostComponent);
+        testHostComponent = testHostFixture.componentInstance;
+        testHostFixture.detectChanges();
+        testedComponent = testHostComponent.testedComponent;
+    }));
+
+    it('should create the component', () => {
+        expect(testedComponent).toBeTruthy();
+    });
+});

src/app/search/components/dataset/dataset-tabs.component.spec.ts

+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
+
+import { TabsModule } from 'ngx-bootstrap';
+import { DatasetTabsComponent } from './dataset-tabs.component';
+import { Project, Dataset, Family } from '../../../metamodel/model';
+import { PROJECT_LIST, DATASET_LIST, DATASET_FAMILY_LIST, DATASET } from '../../../../settings/test-data';
+
+describe('[Search][Dataset] Component: DatasetTabsComponent', () => {
+    @Component({
+        selector: `app-host`,
+        template: `
+            <app-dataset-tabs
+                [projectList]="projectList"
+                [datasetList]="datasetList"
+                [datasetFamilyList]="datasetFamilyList"
+                [datasetSelected]="datasetSelected">
+            </app-dataset-tabs>
+        `
+    })
+    class TestHostComponent {
+        @ViewChild(DatasetTabsComponent, { static: false })
+        public testedComponent: DatasetTabsComponent;
+        private projectList: Project[] = PROJECT_LIST;
+        private datasetList: Dataset[] = DATASET_LIST;
+        private datasetFamilyList: Family[] = DATASET_FAMILY_LIST;
+        private datasetSelected = 'cat_1';
+    }
+
+    @Component({ selector: 'app-dataset-card', template: '' })
+    class DatasetCardStubComponent {
+        @Input() project: Project;
+        @Input() dataset: Dataset;
+        @Input() datasetSelected: string;
+        @Output() select: EventEmitter<string> = new EventEmitter();
+    }
+
+    let testHostComponent: TestHostComponent;
+    let testHostFixture: ComponentFixture<TestHostComponent>;
+    let testedComponent: DatasetTabsComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            declarations: [
+                DatasetTabsComponent,
+                TestHostComponent,
+                DatasetCardStubComponent
+            ],
+            imports: [TabsModule.forRoot()]
+        });
+        testHostFixture = TestBed.createComponent(TestHostComponent);
+        testHostComponent = testHostFixture.componentInstance;
+        testHostFixture.detectChanges();
+        testedComponent = testHostComponent.testedComponent;
+    }));
+
+    it('should create the component', () => {
+        expect(testedComponent).toBeTruthy();
+    });
+
+    it('#getDatasetListByFamily(idFamily) should filter datasets by idFamily', () => {
+        const filteredDatasetList: Dataset[] = testedComponent.getDatasetListByFamily(1);
+        expect(filteredDatasetList.length).toBe(1);
+        expect(filteredDatasetList[0].name).toBe('cat_1');
+    });
+
+    it('#getDatasetFamilyListSortedByDisplay() should sort dataset family by display', () => {
+        const sortedDatasetFamily = testedComponent.getDatasetFamilyListSortedByDisplay();
+        expect(sortedDatasetFamily.length).toBe(3);
+        expect(sortedDatasetFamily[0].id).toBe(1);
+        expect(sortedDatasetFamily[2].id).toBe(3);
+    });
+
+    it('#getProject(dataset) should return the dataset project', () => {
+        const project = testedComponent.getProject(DATASET);
+        expect(project.name).toBe('project_1');
+    });
+});
+

src/app/search/components/output/output-by-category.component.spec.ts

+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { Component, ViewChild } from '@angular/core';
+
+import { OutputByCategoryComponent } from './output-by-category.component';
+import { Attribute } from '../../../metamodel/model';
+import { ATTRIBUTE_LIST } from '../../../../settings/test-data';
+
+describe('[Search][Output] Component: OutputByCategoryComponent', () => {
+    @Component({
+        selector: `app-host`,
+        template: `
+            <app-output-by-category
+                [categoryLabel]="categoryLabel"
+                [attributeList]="attributeList"
+                [outputList]="outputList"
+                [isAllSelected]="isAllSelected"
+                [isAllUnselected]="isAllUnselected">
+            </app-output-by-category>`
+    })
+    class TestHostComponent {
+        @ViewChild(OutputByCategoryComponent, { static: false })
+        public testedComponent: OutputByCategoryComponent;
+        private categoryLabel = 'Default output category';
+        private attributeList: Attribute[] = ATTRIBUTE_LIST;
+        private outputList: number[] = [1];
+        private isAllSelected = true;
+        private isAllUnselected: false;
+    }
+
+    let testHostComponent: TestHostComponent;
+    let testHostFixture: ComponentFixture<TestHostComponent>;
+    let testedComponent: OutputByCategoryComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            declarations: [
+                OutputByCategoryComponent,
+                TestHostComponent
+            ]
+        });
+        testHostFixture = TestBed.createComponent(TestHostComponent);
+        testHostComponent = testHostFixture.componentInstance;
+        testHostFixture.detectChanges();
+        testedComponent = testHostComponent.testedComponent;
+    }));
+
+    it('should create the component', () => {
+        expect(testedComponent).toBeTruthy();
+    });
+
+    it('#getAttributeListSortedByDisplay() should sort attributeList by output_display', () => {
+        const sortedAttributeList: Attribute[] = testedComponent.getAttributeListSortedByDisplay();
+        expect(sortedAttributeList[0].id).toBe(2);
+        expect(sortedAttributeList[1].id).toBe(1);
+    });
+
+    it('#isSelected(idOutput) should return true if output is selected', () => {
+        expect(testedComponent.isSelected(1)).toBeTruthy();
+    });
+
+    it('#isSelected(idOutput) should return false if output is not selected', () => {
+        expect(testedComponent.isSelected(2)).toBeFalsy();
+    });
+
+    it('#toggleSelection(idOutput) should remove idOutput from outputList and raise change event', () => {
+        const idOutput = 1;
+        const expectedOutputList = [];
+        testedComponent.change.subscribe((event: number[]) => expect(event).toEqual(expectedOutputList));
+        testedComponent.toggleSelection(idOutput);
+    });
+
+    it('#toggleSelection(idOutput) should add idOutput to outputList and raise change event', () => {
+        const idOutput = 2;
+        const expectedOutputList = [1, 2];
+        testedComponent.change.subscribe((event: number[]) => expect(event).toEqual(expectedOutputList));
+        testedComponent.toggleSelection(idOutput);
+    });
+
+    it('#selectAll() should add all outputs to outputList and raise change event', () => {
+        const expectedOutputList = [1, 2];
+        testedComponent.change.subscribe((event: number[]) => expect(event).toEqual(expectedOutputList));
+        testedComponent.selectAll();
+    });
+
+    it('#unselectAll() should remove all outputs to outputList and raise change event', () => {
+        const expectedOutputList = [];
+        testedComponent.change.subscribe((event: number[]) => expect(event).toEqual(expectedOutputList));
+        testedComponent.unselectAll();
+    });
+});
+

src/app/search/components/output/output-by-family.component.html

@@ -7,7 +7,7 @@
             [outputList]="outputList" 
             [isAllSelected]="getIsAllSelected(category.id)"
             [isAllUnselected]="getIsAllUnselected(category.id)" 
-            (change)="change($event)">
+            (change)="emitChange($event)">
         </app-output-by-category>
     </div>
 </div>
\ No newline at end of file

src/app/search/components/output/output-by-family.component.spec.ts

+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
+
+import { OutputByFamilyComponent } from './output-by-family.component';
+import { Attribute, Family, Category } from '../../../metamodel/model';
+import { ATTRIBUTE_LIST, OUTPUT_FAMILY, CATEGORY_LIST } from '../../../../settings/test-data';
+
+describe('[Search][Output] Component: OutputByFamilyComponent', () => {
+    @Component({
+        selector: `app-host`,
+        template: `
+            <app-output-by-family
+                [outputFamily]="outputFamily"
+                [datasetAttributeList]="datasetAttributeList"
+                [categoryList]="categoryList"
+                [outputList]="outputList">
+            </app-output-by-family>`
+    })
+    class TestHostComponent {
+        @ViewChild(OutputByFamilyComponent, { static: false })
+        public testedComponent: OutputByFamilyComponent;
+        private outputFamily: Family = OUTPUT_FAMILY;
+        private datasetAttributeList: Attribute[] = ATTRIBUTE_LIST;
+        private categoryList: Category[] = CATEGORY_LIST;
+        private outputList: number[] = [1];
+    }
+
+    @Component({ selector: 'app-output-by-category', template: '' })
+    class OutputByCategoryStubComponent {
+        @Input() categoryLabel: string;
+        @Input() attributeList: Attribute[];
+        @Input() outputList: number[];
+        @Input() isAllSelected: boolean;
+        @Input() isAllUnselected: boolean;
+        @Output() change: EventEmitter<number[]> = new EventEmitter();
+    }
+
+    let testHostComponent: TestHostComponent;
+    let testHostFixture: ComponentFixture<TestHostComponent>;
+    let testedComponent: OutputByFamilyComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            declarations: [
+                OutputByFamilyComponent,
+                TestHostComponent,
+                OutputByCategoryStubComponent
+            ]
+        });
+        testHostFixture = TestBed.createComponent(TestHostComponent);
+        testHostComponent = testHostFixture.componentInstance;
+        testHostFixture.detectChanges();
+        testedComponent = testHostComponent.testedComponent;
+    }));
+
+    it('should create the component', () => {
+        expect(testedComponent).toBeTruthy();
+    });
+
+    it('#getCategoryByFamilySortedByDisplay(idFamily) should sort by display categories belonging to idFamily', () => {
+        const sortedCategoryList: Category[] = testedComponent.getCategoryByFamilySortedByDisplay(1);
+        expect(sortedCategoryList.length).toBe(2);
+        expect(sortedCategoryList[0].id).toBe(2);
+        expect(sortedCategoryList[1].id).toBe(1);
+    });
+
+    it('#getAttributeByCategory(idCategory) should return attributes belonging to idCategory', () => {
+        expect(testedComponent.getAttributeByCategory(1).length).toBe(1);
+        expect(testedComponent.getAttributeByCategory(1)[0].id).toBe(1);
+    });
+
+    it('#getIsAllSelected(idCategory) should return true if all outputs of idCategory are selected', () => {
+        expect(testedComponent.getIsAllSelected(1)).toBeTruthy();
+    });
+
+    it('#getIsAllSelected(idCategory) should return false if not all outputs of idCategory are selected', () => {
+        testedComponent.outputList = [];
+        expect(testedComponent.getIsAllSelected(1)).toBeFalsy();
+    });
+
+    it('#getIsAllUnselected(idCategory) should return true if all outputs of idCategory are not selected', () => {
+        testedComponent.outputList = [];
+        expect(testedComponent.getIsAllUnselected(1)).toBeTruthy();
+    });
+
+    it('#getIsAllUnselected(idCategory) should return false if not all outputs of idCategory are not selected', () => {
+        expect(testedComponent.getIsAllUnselected(1)).toBeFalsy();
+    });
+
+    it('#emitChange(outputList) should raise change event', () => {
+        const expectedOutputList = [1];
+        testedComponent.change.subscribe((event: number[]) => expect(event).toEqual(expectedOutputList));
+        testedComponent.emitChange([1]);
+    });
+});
+

src/app/search/components/output/output-by-family.component.ts

@@ -12,7 +12,7 @@ export class OutputByFamilyComponent {
     @Input() categoryList: Category[];
     @Input() datasetAttributeList: Attribute[];
     @Input() outputList: number[];
-    @Output() changed: EventEmitter<number[]> = new EventEmitter();
+    @Output() change: EventEmitter<number[]> = new EventEmitter();
 
     getCategoryByFamilySortedByDisplay(idFamily: number): Category[] {
         return this.categoryList
@@ -37,8 +37,8 @@ export class OutputByFamilyComponent {
         return filteredOutputList.length === 0;
     }
 
-    change(clonedOutputList: number[]): void {
-        this.changed.emit(
+    emitChange(clonedOutputList: number[]): void {
+        this.change.emit(
             this.datasetAttributeList
                 .filter(a => clonedOutputList.indexOf(a.id) > -1)
                 .sort((a, b) => a.output_display - b.output_display)

src/app/search/components/output/output-tabs.component.html

@@ -2,8 +2,12 @@
     <div class="border rounded my-2">
         <p class="border-bottom bg-light text-primary py-4 pl-4 mb-0">{{ outputFamilyList[0].label }}</p>
         <div class="px-3 pb-3 pt-0">
-            <app-output-by-family [outputFamily]="outputFamilyList[0]" [datasetAttributeList]="datasetAttributeList"
-                [categoryList]="categoryList" [outputList]="outputList" (changed)="change($event)">
+            <app-output-by-family
+                [outputFamily]="outputFamilyList[0]" 
+                [datasetAttributeList]="datasetAttributeList"
+                [categoryList]="categoryList" 
+                [outputList]="outputList" 
+                (change)="emitChange($event)">
             </app-output-by-family>
         </div>
     </div>
@@ -20,8 +24,12 @@
                 <span *ngIf="!ag.isOpen"><span class="fas fa-chevron-down"></span></span>
             </div>
         </button>
-        <app-output-by-family [outputFamily]="family" [datasetAttributeList]="datasetAttributeList"
-            [categoryList]="categoryList" [outputList]="outputList" (changed)="change($event)">
+        <app-output-by-family 
+            [outputFamily]="family" 
+            [datasetAttributeList]="datasetAttributeList"
+            [categoryList]="categoryList" 
+            [outputList]="outputList" 
+            (change)="emitChange($event)">
         </app-output-by-family>
     </accordion-group>
 </accordion>
\ No newline at end of file

src/app/search/components/output/output-tabs.component.spec.ts

+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+
+import { AccordionModule } from 'ngx-bootstrap';
+import { OutputTabsComponent } from './output-tabs.component';
+import { Attribute, Family, Category } from '../../../metamodel/model';
+import { ATTRIBUTE_LIST, OUTPUT_FAMILY_LIST , CATEGORY_LIST } from '../../../../settings/test-data';
+
+describe('[Search][Output] Component: OutputTabsComponent', () => {
+    @Component({
+        selector: `app-host`,
+        template: `
+            <app-output-tabs
+                [outputFamilyList]="outputFamilyList"
+                [categoryList]="categoryList"
+                [datasetAttributeList]="datasetAttributeList"
+                [outputList]="outputList">
+            </app-output-tabs>`
+    })
+    class TestHostComponent {
+        @ViewChild(OutputTabsComponent, { static: false })
+        public testedComponent: OutputTabsComponent;
+        private outputFamilyList: Family[] = OUTPUT_FAMILY_LIST;
+        private datasetAttributeList: Attribute[] = ATTRIBUTE_LIST;
+        private categoryList: Category[] = CATEGORY_LIST;
+        private outputList: number[] = [1];
+    }
+
+    @Component({ selector: 'app-output-by-family', template: '' })
+    class OutputByFamilyStubComponent {
+        @Input() outputFamily: Family;
+        @Input() categoryList: Category[];
+        @Input() datasetAttributeList: Attribute[];
+        @Input() outputList: number[];
+        @Output() change: EventEmitter<number[]> = new EventEmitter();
+    }
+
+    let testHostComponent: TestHostComponent;
+    let testHostFixture: ComponentFixture<TestHostComponent>;
+    let testedComponent: OutputTabsComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            declarations: [
+                OutputTabsComponent,
+                TestHostComponent,
+                OutputByFamilyStubComponent
+            ],
+            imports: [AccordionModule.forRoot(), BrowserAnimationsModule]
+        });
+        testHostFixture = TestBed.createComponent(TestHostComponent);
+        testHostComponent = testHostFixture.componentInstance;
+        testHostFixture.detectChanges();
+        testedComponent = testHostComponent.testedComponent;
+    }));
+
+    it('should create the component', () => {
+        expect(testedComponent).toBeTruthy();
+    });
+
+    it('#getOutputFamilyListSortedByDisplay() should sort output families by display', () => {
+        const sortedOutputFamilyList: Family[] = testedComponent.getOutputFamilyListSortedByDisplay();
+        expect(sortedOutputFamilyList.length).toBe(2);
+        expect(sortedOutputFamilyList[0].id).toBe(2);
+        expect(sortedOutputFamilyList[1].id).toBe(1);
+    });
+
+    it('#emitChange(outputList) should raise change event', () => {
+        const expectedOutputList = [1];
+        testedComponent.change.subscribe((event: number[]) => expect(event).toEqual(expectedOutputList));
+        testedComponent.emitChange([1]);
+    });
+});
+

src/app/search/components/output/output-tabs.component.ts

@@ -12,14 +12,14 @@ export class OutputTabsComponent {
     @Input() categoryList: Category[];
     @Input() datasetAttributeList: Attribute[];
     @Input() outputList: number[];
-    @Output() changed: EventEmitter<number[]> = new EventEmitter();
+    @Output() change: EventEmitter<number[]> = new EventEmitter();
 
     getOutputFamilyListSortedByDisplay(): Family[] {
         return this.outputFamilyList
             .sort((a, b) => a.display - b.display);
     }
 
-    change(clonedOutpuList: number[]): void {
-        this.changed.emit(clonedOutpuList);
+    emitChange(clonedOutpuList: number[]): void {
+        this.change.emit(clonedOutpuList);
     }
 }

src/app/search/containers/output.component.html

@@ -11,7 +11,7 @@
             [categoryList]="categoryList | async"
             [datasetAttributeList]="datasetAttributeList | async" 
             [outputList]="outputList | async"
-            (changed)="updateOutputList($event)">
+            (change)="updateOutputList($event)">
         </app-output-tabs>
     </div>
     <div class="col-12 col-md-4 col-lg-3 pt-2">

src/settings/test-data/attribute-list.ts

@@ -72,7 +72,7 @@ export const ATTRIBUTE_LIST: Attribute[] = [
         vo_description: '',
         vo_datatype: '',
         vo_size: 1,
-        id_criteria_family: 1,
-        id_output_category: 1
+        id_criteria_family: 2,
+        id_output_category: 2
     }
 ];

src/settings/test-data/criteria-family-list.ts

+import { Family } from 'src/app/metamodel/model';
+
+export const CRITERIA_FAMILY_LIST: Family[] = [
+    {
+        id: 3,
+        type: 'criteria',
+        label: 'The last criteria family',
+        display: 30
+    },
+    {
+        id: 1,
+        type: 'criteria',
+        label: 'Default criteria family',
+        display: 10
+    },
+    {
+        id: 2,
+        type: 'criteria',
+        label: 'Another criteria family',
+        display: 20
+    }
+];

src/settings/test-data/dataset-family-list.ts

+import { Family } from 'src/app/metamodel/model';
+
+export const DATASET_FAMILY_LIST: Family[] = [
+    {
+        id: 3,
+        type: 'dataset',
+        label: 'The last dataset family',
+        display: 30
+    },
+    {
+        id: 1,
+        type: 'dataset',
+        label: 'Default dataset family',
+        display: 10
+    },
+    {
+        id: 2,
+        type: 'dataset',
+        label: 'Another dataset family',
+        display: 20
+    }
+];

src/settings/test-data/dataset-list.ts

+import { Dataset } from 'src/app/metamodel/model';
+
+export const DATASET_LIST: Dataset[] = [
+    {
+        name: 'cat_1',
+        table_ref: '',
+        label: 'Cat 1',
+        description: 'Description of cat 1',
+        display: 10,
+        count: 10000,
+        vo: false,
+        selectable_row: false,
+        project_name: 'project_1',
+        id_dataset_family: 1
+    },
+    {
+        name: 'cat_3',
+        table_ref: '',
+        label: 'Cat 3',
+        description: 'Description of cat 3',
+        display: 30,
+        count: 30000,
+        vo: false,
+        selectable_row: false,
+        project_name: 'project_2',
+        id_dataset_family: 2
+    },
+    {
+        name: 'cat_2',
+        table_ref: '',
+        label: 'Cat 2',
+        description: 'Description of cat 2',
+        display: 20,
+        count: 20000,
+        vo: false,
+        selectable_row: false,
+        project_name: 'project_1',
+        id_dataset_family: 2
+    }
+];

src/settings/test-data/dataset.ts

+import { Dataset } from 'src/app/metamodel/model';
+
+export const DATASET: Dataset = {
+    name: 'cat_1',
+    table_ref: '',
+    label: 'Cat 1',
+    description: 'Description of cat 1',
+    display: 10,
+    count: 10000,
+    vo: false,
+    selectable_row: false,
+    project_name: 'project_1',
+    id_dataset_family: 1
+};