@seniorsistemas/exclusion-process-component 0.0.1-c049d10c-e93a-4d63-9c2a-b17bca40c324 → 0.6.0-44030ff3-2eeb-49f7-8927-0920cc01a805

package/lib/src/exclusions-list/exclusions-list.component.spec.ts

@@ -0,0 +1,526 @@
+import { ChangeDetectorRef } from "@angular/core";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { RouterTestingModule } from "@angular/router/testing";
+import { FormBuilder, FormsModule, ReactiveFormsModule} from "@angular/forms";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
+import { ActivatedRoute, RouterModule } from "@angular/router";
+import { TranslateModule, TranslateService } from "@ngx-translate/core";
+import {
+    AngularComponentsModule,
+    ButtonModule,
+    ControlErrorsModule,
+    CustomFieldsModule,
+    DynamicFormModule,
+    EmptyStateModule,
+    InfoSignModule,
+    LoadingStateModule,
+    TokenListModule,
+    NumberInputModule,
+    TableModule as SeniorTableModule
+} from "@seniorsistemas/angular-components";
+import { MessageService } from "primeng/api";
+import { HttpClientTestingModule } from "@angular/common/http/testing";
+import { Observable } from "rxjs";
+import { CommonModule } from "@angular/common";
+import { CurrencyMaskModule } from "@seniorsistemas/ng2-currency-mask";
+import { CyclicJsonInterceptorModule } from "@seniorsistemas/platform-components";
+import { PanelModule } from "primeng/panel";
+import { InputTextModule } from "primeng/inputtext";
+import { HotkeyModule } from "angular2-hotkeys";
+import { TabViewModule } from "primeng/tabview";
+import { DropdownModule } from "primeng/dropdown";
+import { CalendarModule } from "primeng/calendar";
+import { KeyFilterModule } from "primeng/keyfilter";
+import { MultiSelectModule } from "primeng/multiselect";
+import { ConfirmDialogModule } from "primeng/confirmdialog";
+import { TableModule } from "primeng/table";
+import { DialogModule } from "primeng/dialog";
+import { InputTextareaModule } from "primeng/inputtextarea";
+import { CheckboxModule } from "primeng/checkbox";
+import { ExclusionDetailsModule } from "../exclusion-details";
+import { FilterService } from "../services/filter.service";
+import { LogicalDeleteConfigService } from "../services/logical-delete-config.service";
+import { RadioButtonModule } from "primeng/radiobutton";
+import { ExclusionsListComponent } from "./exclusions-list.component";
+import { ProjectConfigs, ProjectConfigsInjectionToken } from "../models/project-config";
+import { LogicalDeleteService } from "../services";
+import { EnumExclusionProcessStatus } from "../enums/enum-exclusion-process-status";
+import { ExclusionProcess } from "../models";
+
+describe("ExclusionsListComponent", () => {
+    let fixture: ComponentFixture<ExclusionsListComponent> = null;
+    let component: ExclusionsListComponent = null;
+    let logicalDeleteService: LogicalDeleteService = null;
+
+    let fakeActivatedRoute: any = {};
+
+    const defaultProjectConfigs: ProjectConfigs = {
+        domain: "domain",
+        service: "service"
+    };
+
+    beforeEach(async () => {
+        fakeActivatedRoute = {
+            data: new Observable(subscriber => {
+                subscriber.next({
+                    localeConfig: {
+                        calendar: {},
+                        number: {
+                            scale: 1,
+                            decimalSeparator: ","
+                        }
+                    }
+                });
+                subscriber.complete();
+            }),
+            params: new Observable(subscriber => {
+                subscriber.next({entityName: "entityName"});
+                subscriber.complete();
+            }),
+            queryParams: new Observable(subscriber => {
+                subscriber.next({entityDescription: "entityDescription"});
+                subscriber.complete();
+            })
+        };
+
+        await TestBed.configureTestingModule({
+            imports: [
+                AngularComponentsModule.forRoot({
+                    domain: "domain",
+                    service: "service"
+                }),
+                ButtonModule,
+                TranslateModule.forRoot(),
+                RouterModule,
+                RouterTestingModule,
+                HttpClientTestingModule,
+                ExclusionDetailsModule,
+                BrowserAnimationsModule,
+
+                FormsModule,
+                ReactiveFormsModule,
+                CommonModule,
+                CurrencyMaskModule,
+                TranslateModule,
+                CustomFieldsModule,
+                ControlErrorsModule,
+                EmptyStateModule,
+                DynamicFormModule,
+                TokenListModule,
+                PanelModule,
+                InputTextModule,
+                InputTextareaModule,
+                ButtonModule,
+                InfoSignModule,
+                CheckboxModule,
+                TableModule,
+                ConfirmDialogModule,
+                CalendarModule,
+                DropdownModule,
+                TabViewModule,
+                HotkeyModule,
+                LoadingStateModule,
+                NumberInputModule,
+                CyclicJsonInterceptorModule,
+                DialogModule,
+                KeyFilterModule,
+                RadioButtonModule,
+                SeniorTableModule,
+                MultiSelectModule,
+            ],
+            providers: [
+                TranslateService,
+                MessageService,
+                FormBuilder,
+                ChangeDetectorRef,
+                FilterService,
+                LogicalDeleteConfigService,
+                LogicalDeleteService,
+                {
+                    provide: ActivatedRoute,
+                    useValue: fakeActivatedRoute
+                },
+                {
+                    provide: ProjectConfigsInjectionToken,
+                    useValue: defaultProjectConfigs
+                }
+            ],
+            declarations: [ExclusionsListComponent]
+        }).compileComponents();
+
+        logicalDeleteService = TestBed.inject(LogicalDeleteService);
+
+        fixture = TestBed.createComponent(ExclusionsListComponent);
+        component = fixture.componentInstance;
+    });
+
+    const mockDefaultListExclusionsCall = (contents: ExclusionProcess[] = [], totalElements: number = 0) => {
+        const spy = spyOn(logicalDeleteService, "listExclusions")
+            .and.returnValue(new Observable(subscriber => {
+                subscriber.next({
+                    totalElements,
+                    contents,
+                    totalPages: 0
+                });
+                return subscriber.complete();
+            }));
+        return spy;
+    };
+
+    describe("Component constructor", () => {
+        it("should create component", () => {
+            mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+            expect(component).toBeTruthy();
+        });
+
+        it("should read locale from route data", () => {
+            fakeActivatedRoute.data = new Observable(subscriber => {
+                subscriber.next({
+                    localeConfig: {
+                        calendar: {},
+                        number: {
+                            scale: 1,
+                            decimalSeparator: ","
+                        }
+                    }
+                });
+                subscriber.complete();
+            });
+
+            mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+            expect(component.locale.number.scale).toBe(1);
+            expect(component.locale.number.decimalSeparator).toBe(",");
+        });
+
+        it("should read entityName from params", () => {
+            fakeActivatedRoute.params = new Observable(subscriber => {
+                subscriber.next({
+                    entityName: "valid entity name"
+                });
+                subscriber.complete();
+            });
+
+            mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+            expect(component.entityName).toBe("valid entity name");
+        });
+
+        it("should read entityDescription from queryParams", () => {
+            fakeActivatedRoute.queryParams = new Observable(subscriber => {
+                subscriber.next({
+                    entityDescription: "valid entity description"
+                });
+                subscriber.complete();
+            });
+
+            mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+            expect(component.entityDescription).toBe("valid entity description");
+        });
+    });
+
+    describe("Filters", () => {
+        it("should filter by description", () => {
+            const listExclusionsSpy = mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+
+            component.filterFormGroup.controls["description"].setValue("Teste");
+            const filterButton = fixture.nativeElement.querySelector("#filter-button");
+            filterButton.dispatchEvent(new Event("click"));
+            expect(listExclusionsSpy).toHaveBeenCalledWith(
+                "entityName",
+                {
+                    page: 0,
+                    size: 10,
+                    sort: [],
+                    filterQuery: "containing(upper(description), upper('Teste'))",
+                    displayFields: ["recordId", "description", "status", "startDate", "finishDate"]
+                }
+            );
+        });
+
+        it("should filter by single state enum", () => {
+            const listExclusionsSpy = mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+
+            component.filterFormGroup.controls["state"].setValue([EnumExclusionProcessStatus.PENDING]);
+            const filterButton = fixture.nativeElement.querySelector("#filter-button");
+            filterButton.dispatchEvent(new Event("click"));
+            expect(listExclusionsSpy).toHaveBeenCalledWith(
+                "entityName",
+                {
+                    page: 0,
+                    size: 10,
+                    sort: [],
+                    filterQuery: `(state eq '${EnumExclusionProcessStatus.PENDING}')`,
+                    displayFields: ["recordId", "description", "status", "startDate", "finishDate"]
+                }
+            );
+        });
+
+        it("should filter by multiple state enum", () => {
+            const listExclusionsSpy = mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+
+            component.filterFormGroup.controls["state"].setValue([
+                EnumExclusionProcessStatus.PENDING, EnumExclusionProcessStatus.PROCESSING
+            ]);
+            const filterButton = fixture.nativeElement.querySelector("#filter-button");
+            filterButton.dispatchEvent(new Event("click"));
+
+            const filter = `(state eq '${EnumExclusionProcessStatus.PENDING}' or state eq '${EnumExclusionProcessStatus.PROCESSING}')`;
+
+            expect(listExclusionsSpy).toHaveBeenCalledWith(
+                "entityName",
+                {
+                    page: 0,
+                    size: 10,
+                    sort: [],
+                    filterQuery: filter,
+                    displayFields: ["recordId", "description", "status", "startDate", "finishDate"]
+                }
+            );
+        });
+
+        it("should filter by start date and finish date", () => {
+            const listExclusionsSpy = mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+
+            const startDate = new Date(2023, 2, 10);
+            const endDate = new Date(2023, 2, 15);
+            component.filterFormGroup.controls["startDate"].setValue(startDate);
+            component.filterFormGroup.controls["endDate"].setValue(endDate);
+            const filterButton = fixture.nativeElement.querySelector("#filter-button");
+            filterButton.dispatchEvent(new Event("click"));
+            expect(listExclusionsSpy).toHaveBeenCalledWith(
+                "entityName",
+                {
+                    page: 0,
+                    size: 10,
+                    sort: [],
+                    filterQuery: "startDate between '2023-03-10' and '2023-03-15'",
+                    displayFields: ["recordId", "description", "status", "startDate", "finishDate"]
+                }
+            );
+        });
+
+        it("should clean all filters by pressing the Clear button", () => {
+            const listExclusionsSpy = mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+
+            const testDate = new Date(2023, 2, 10);
+            component.filterFormGroup.controls["description"].setValue("test description");
+            component.filterFormGroup.controls["state"].setValue([EnumExclusionProcessStatus.PROCESSING]);
+            component.filterFormGroup.controls["startDate"].setValue(testDate);
+            component.filterFormGroup.controls["endDate"].setValue(testDate);
+
+            const clearFilterButton = fixture.nativeElement.querySelector("#clear-button");
+            clearFilterButton.dispatchEvent(new Event("click"));
+            expect(listExclusionsSpy).toHaveBeenCalledWith(
+                "entityName",
+                {
+                    page: 0,
+                    size: 10,
+                    sort: [],
+                    filterQuery: "",
+                    displayFields: ["recordId", "description", "status", "startDate", "finishDate"]
+                }
+            );
+
+            for (const controlKey of Object.keys(component.filterFormGroup.controls)) {
+                expect(component.filterFormGroup.controls[controlKey].value).toBeFalsy();
+            }
+        });
+    });
+
+    describe("Table", () => {
+        it("should have all columns in the column confing with translation", () => {
+            mockDefaultListExclusionsCall();
+            fixture.detectChanges(false);
+
+            const columns = component.gridColumns;
+            const tableThs = Array.from(fixture.nativeElement.querySelectorAll("#exclusionsTable th") as any[]);
+            expect(tableThs.length).toBe(columns.length + 1); // Action column
+
+            for (const column of columns) {
+                const th = tableThs.find(p => p.id === column.field);
+                expect(th).toBeTruthy();
+                expect(th.textContent.trim()).toBe(column.header);
+            }
+
+            const actionColumn = tableThs[tableThs.length - 1];
+            expect(actionColumn.textContent.trim()).toBe("Ações");
+        });
+
+        it("should render the description column data", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.SUCCESS,
+                startDate: new Date(),
+                finishDate: new Date(),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const decriptionColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[0];
+            expect(decriptionColumn.textContent).toBe("Test description");
+        });
+
+        it("should render the status column for success", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.SUCCESS,
+                startDate: new Date(),
+                finishDate: new Date(),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const statusColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[1];
+            expect(statusColumn.textContent).toBe("domain.service.logical_delete_enum_exclusion_process_status_success");
+            const span = statusColumn.querySelectorAll("span")[0];
+            expect(span.className).toContain("sds-badge sds-semantic-green");
+        });
+
+        it("should render the status column for error", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.ERROR,
+                startDate: new Date(),
+                finishDate: new Date(),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const statusColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[1];
+            expect(statusColumn.textContent).toBe("domain.service.logical_delete_enum_exclusion_process_status_error");
+            const span = statusColumn.querySelectorAll("span")[0];
+            expect(span.className).toContain("sds-badge sds-semantic-red");
+        });
+
+        it("should render the status column for pending", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.PENDING,
+                startDate: new Date(),
+                finishDate: new Date(),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const statusColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[1];
+            expect(statusColumn.textContent).toBe("domain.service.logical_delete_enum_exclusion_process_status_pending");
+            const span = statusColumn.querySelectorAll("span")[0];
+            expect(span.className).toContain("sds-badge sds-semantic-yellow");
+        });
+
+        it("should render the status column for processing", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.PROCESSING,
+                startDate: new Date(),
+                finishDate: new Date(),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const statusColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[1];
+            expect(statusColumn.textContent).toBe("domain.service.logical_delete_enum_exclusion_process_status_processing");
+            const span = statusColumn.querySelectorAll("span")[0];
+            expect(span.className).toContain("sds-badge sds-semantic-blue");
+        });
+
+        it("should render the start date column with date format", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.PROCESSING,
+                startDate: new Date(2023, 2, 13, 15, 30),
+                finishDate: new Date(2023, 2, 14, 15, 30),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const statusColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[2];
+            expect(statusColumn.textContent).toBe("13/03/2023 15:30");
+        });
+
+        it("should render the end date column with date format", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.PROCESSING,
+                startDate: new Date(2023, 2, 13, 15, 30),
+                finishDate: new Date(2023, 2, 14, 8, 5),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const statusColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[3];
+            expect(statusColumn.textContent).toBe("14/03/2023 08:05");
+        });
+
+        it("should render the actions column", () => {
+            mockDefaultListExclusionsCall();
+
+            component.gridData = [{
+                id: "valid id",
+                recordId: "record id",
+                description: "Test description",
+                status: EnumExclusionProcessStatus.PROCESSING,
+                startDate: new Date(2023, 2, 13, 15, 30),
+                finishDate: new Date(2023, 2, 14, 8, 5),
+                entityName: "",
+                groups: []
+            }];
+
+            fixture.detectChanges(false);
+
+            const actionColumn = fixture.nativeElement.querySelectorAll("#exclusionsTable td")[4];
+            const button = actionColumn.querySelector("button");
+            expect(button.textContent).toBe(" domain.service.logical_delete_details ");
+        });
+    });
+});