docs: unit test formation with Jest

src/app/applications/index.component.ts

@@ -62,11 +62,13 @@ import { ApplicationRaw, ApplicationRawColumnKey, ApplicationRawFieldKey, Applic
       [columnsLabels]="columnsLabels()"
       [displayedColumns]="displayedColumns"
       [availableColumns]="availableColumns"
+      [lockColumns]="lockColumns"
       (refresh)="onRefresh()"
       (intervalValueChange)="onIntervalValueChange($event)"
       (displayedColumnsChange)="onColumnsChange($event)"
       (resetColumns)="onColumnsReset()"
       (resetFilters)="onFiltersReset()"
+      (lockColumnsChange)="onLockColumnsChange()"
     >
       <ng-container extra-menu-items>
         <button mat-menu-item (click)="personalizeTasksByStatus()">
@@ -85,7 +87,7 @@ import { ApplicationRaw, ApplicationRawColumnKey, ApplicationRawFieldKey, Applic
 </mat-toolbar>
 
 <app-table-container>
-  <table mat-table matSort [matSortActive]="options.sort.active" matSortDisableClear [matSortDirection]="options.sort.direction" [dataSource]="data" cdkDropList cdkDropListOrientation="horizontal" (cdkDropListDropped)="onDrop($event)">
+  <table mat-table matSort [matSortActive]="options.sort.active" matSortDisableClear [matSortDirection]="options.sort.direction" [dataSource]="data" cdkDropList cdkDropListOrientation="horizontal" [cdkDropListDisabled]="lockColumns" (cdkDropListDropped)="onDrop($event)">
 
     <ng-container *ngFor="let column of displayedColumns" [matColumnDef]="column">
       <!-- Header -->
@@ -210,6 +212,7 @@ export class IndexComponent implements OnInit, AfterViewInit, OnDestroy {
 
   displayedColumns: ApplicationRawColumnKey[] = [];
   availableColumns: ApplicationRawColumnKey[] = [];
+  lockColumns: boolean = false;
 
   isLoading = true;
   data: ApplicationRaw[] = [];
@@ -243,6 +246,7 @@ export class IndexComponent implements OnInit, AfterViewInit, OnDestroy {
   ngOnInit(): void {
     this.displayedColumns = this._applicationsIndexService.restoreColumns();
     this.availableColumns = this._applicationsIndexService.availableColumns;
+    this.lockColumns = this._applicationsIndexService.restoreLockColumns();
 
     this.options = this._applicationsIndexService.restoreOptions();
 
@@ -357,7 +361,7 @@ export class IndexComponent implements OnInit, AfterViewInit, OnDestroy {
   }
 
   onColumnsChange(data: ApplicationRawColumnKey[]) {
-    this.displayedColumns = [...data];
+    this.displayedColumns = data;
 
     this._applicationsIndexService.saveColumns(data);
   }
@@ -380,6 +384,11 @@ export class IndexComponent implements OnInit, AfterViewInit, OnDestroy {
     this.refresh.next();
   }
 
+  onLockColumnsChange() {
+    this.lockColumns = !this.lockColumns;
+    this._applicationsIndexService.saveLockColumns(this.lockColumns);
+  }
+
   autoRefreshTooltip() {
     return this._autoRefreshService.autoRefreshTooltip(this.intervalValue);
   }

src/app/applications/services/applications-grpc.service.spec.ts

@@ -0,0 +1,129 @@
+import { ApplicationRawEnumField, ApplicationsClient, FilterStringOperator, ListApplicationsRequest } from '@aneoconsultingfr/armonik.api.angular';
+import { TestBed } from '@angular/core/testing';
+import { FilterDefinitionRootString } from '@app/types/filter-definition';
+import { UtilsService } from '@services/utils.service';
+import { ApplicationsFiltersService } from './applications-filters.service';
+import { ApplicationsGrpcService } from './applications-grpc.service';
+import { ApplicationRawFilter, ApplicationRawListOptions } from '../types';
+
+describe('ApplicationsGrpcService', () => {
+  let service: ApplicationsGrpcService;
+
+  const mockApplicationFiltersService = {
+    retrieveFiltersDefinitions: jest.fn().mockImplementation(() => {
+      const definitions: FilterDefinitionRootString<ApplicationRawEnumField>[] = [
+        {
+          for: 'root',
+          field: 1,
+          type: 'string'
+        },
+        {
+          for: 'root',
+          field: 2,
+          type: 'number'
+        } as unknown as FilterDefinitionRootString<ApplicationRawEnumField>
+      ];
+      return definitions;
+    })
+  };
+
+  const mockApplicationsClient = {
+    listApplications: jest.fn().mockImplementation((data) => data)
+  };
+
+  const options: ApplicationRawListOptions = {
+    pageIndex: 0,
+    pageSize: 10,
+    sort: {
+      active: 'name',
+      direction: 'asc'
+    }
+  };
+
+  const correctfilters: ApplicationRawFilter = [[
+    {
+      field: 1,
+      for: 'root',
+      operator: 0,
+      value: 'someValue'
+    }
+  ]];
+
+  const uncorrectfilters: ApplicationRawFilter = [[
+    {
+      field: 2,
+      for: 'root',
+      operator: 0,
+      value: 123
+    }
+  ]];
+
+  beforeEach(() => {
+    service = TestBed.configureTestingModule({
+      providers: [
+        ApplicationsGrpcService,
+        UtilsService<ApplicationRawEnumField>,
+        { provide: ApplicationsClient, useValue: mockApplicationsClient },
+        { provide: ApplicationsFiltersService, useValue: mockApplicationFiltersService }
+      ]
+    }).inject(ApplicationsGrpcService);
+  });
+
+  it('should create', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should not get', () => {
+    expect(() => {service.get$();}).toThrowError('This method must never be called');
+  });
+
+  it('should create a request without filters', () => {
+    const listResult = new ListApplicationsRequest({
+      page: 0,
+      pageSize: 10,
+      sort: {
+        direction: 1,
+        fields: [{
+          applicationField: {
+            field: 1
+          }
+        }]
+      },
+      filters: {or: []}
+    });
+    expect(service.list$(options, [])).toEqual(listResult);
+  });
+
+  it('should create a request with filters', () => {
+    const listResult = new ListApplicationsRequest({
+      page: 0,
+      pageSize: 10,
+      sort: {
+        direction: 1,
+        fields: [{
+          applicationField: {
+            field: 1
+          }
+        }]
+      },
+      filters: { or: [{
+        and: [{
+          field: {
+            applicationField: {
+              field: 1
+            }
+          },
+          filterString: {
+            value: 'someValue',
+            operator: 0 as FilterStringOperator
+          }
+        }]
+      }]}
+    });
+    expect(service.list$(options, correctfilters)).toEqual(listResult);
+  });
+
+  it('should throw error in case on unexpected type', () => {
+    expect(() => {service.list$(options, uncorrectfilters);}).toThrowError('Type number not supported');
+  });
+});

src/app/applications/services/applications-index.service.spec.ts

@@ -0,0 +1,149 @@
+import { TestBed } from '@angular/core/testing';
+import { DefaultConfigService } from '@services/default-config.service';
+import { TableService } from '@services/table.service';
+import { ApplicationsIndexService } from './applications-index.service';
+import { ApplicationRawColumnKey, ApplicationRawListOptions } from '../types';
+
+
+describe('TasksIndexService', () => {
+  let service: ApplicationsIndexService; 
+
+  const expectedColumnLabels: Record<ApplicationRawColumnKey, string> = {
+    name: $localize`Name`,
+    namespace: $localize`Namespace`,
+    service: $localize`Service`,
+    version: $localize`Version`,
+    count: $localize`Tasks by Status`,
+    actions: $localize`Actions`,
+  };
+
+  const expectDefaultOptions :ApplicationRawListOptions = {
+    pageIndex: 0,
+    pageSize: 10,
+    sort: {
+      active: 'name',
+      direction: 'asc'
+    },
+  };  
+  const expectedDefaultColumns = new DefaultConfigService().defaultApplications.columns;
+
+  const expectedDefaultIntervalValue = new DefaultConfigService().defaultApplications.interval;
+  const mockTableService = {
+    saveIntervalValue: jest.fn(),
+    restoreIntervalValue: jest.fn(),
+    saveOptions: jest.fn(),
+    restoreOptions: jest.fn(),
+    saveColumns: jest.fn(),
+    restoreColumns: jest.fn(),
+    resetColumns: jest.fn(),
+    saveViewInLogs: jest.fn(),
+    restoreViewInLogs: jest.fn()
+  };
+
+
+  beforeEach(() => {
+    service = TestBed.configureTestingModule({
+      providers: [
+        ApplicationsIndexService,
+        DefaultConfigService,
+        {provide: TableService, useValue: mockTableService}
+      ]
+    }).inject(ApplicationsIndexService);
+  }); 
+
+  test('Create ApplicationsIndexService', ()=> {
+    expect(service).toBeTruthy();
+  });
+
+
+  describe('Columns', ()=> {
+    test('the service should label the right column among available columns labels',() => { 
+      for(const [key] of Object.entries(expectedColumnLabels)) {
+        expect(service.columnToLabel(key as ApplicationRawColumnKey)).toEqual(service.columnsLabels[`${key}` as ApplicationRawColumnKey]);
+      }
+    });
+  });
+
+  describe('Table', () => {
+    it('should return true if the column is actions', () =>{
+      expect(service.isActionsColumn('actions')).toEqual(true);
+    });
+    it('should return false if the column is not actions', () =>{
+      expect(service.isActionsColumn('name')).toEqual(false);
+    }); 
+
+    it('should return true if the column is id', () =>{
+      expect(service.isCountColumn('count')).toEqual(true);
+    });
+    it('should return false if the column is not id', () =>{
+      expect(service.isCountColumn('name')).toEqual(false);
+    });
+
+    it('should return true if the column is a simple column', () =>{
+      expect(service.isSimpleColumn('name')).toEqual(true);
+    });
+    it('should return false if the column is not a simple column', () =>{
+      expect(service.isSimpleColumn('actions')).toEqual(false);
+    });
+
+    it('should return true if the column is not sortable', () =>{
+      expect(service.isNotSortableColumn('count')).toEqual(true);
+    });
+    it('should return false if the column is sortable', () =>{
+      expect(service.isNotSortableColumn('name')).toEqual(false);
+    });
+  });
+
+  describe('Interval', ()=>{
+    it('should call saveIntervalValue from TableService', ()=>{
+      service.saveIntervalValue(9);
+      expect(mockTableService.saveIntervalValue).toBeCalledWith('applications-interval', 9);
+    });
+
+    it('should call restoreIntervalValue from TableService', ()=>{
+      service.restoreIntervalValue();
+      expect(mockTableService.restoreIntervalValue).toHaveBeenCalledWith('applications-interval');
+    });
+
+    it('should return defaultIntervalValue when restoreIntervalValue from TableService returns null', () => {
+      mockTableService.restoreIntervalValue.mockImplementationOnce(() => null);
+      expect(service.restoreIntervalValue()).toEqual(expectedDefaultIntervalValue);
+    });  
+
+  });
+
+  describe('Options', ()=>{
+    it('should call saveOptions from TableService', ()=>{
+      service.saveOptions(expectDefaultOptions);
+      expect(mockTableService.saveOptions).toBeCalledWith('applications-options',expectDefaultOptions);
+    });
+
+    it('should call restoreOptions from TableService', ()=>{
+      service.restoreOptions(); 
+      expect(mockTableService.restoreOptions).toBeCalledWith('applications-options',expectDefaultOptions);
+    });
+  });
+
+  describe('Columns', ()=>{
+    it('should call saveColumns from TableService', ()=>{
+      service.saveColumns(['namespace', 'actions', 'version']); 
+      expect(mockTableService.saveColumns).toBeCalledWith('applications-columns', ['namespace', 'actions', 'version']);
+    });
+
+    it('should call restoreColumns from TableService', ()=>{
+      service.restoreColumns(); 
+      expect(mockTableService.restoreColumns).toBeCalledWith('applications-columns');
+    });
+
+    it('should return defaultColums when restoreColumns from TableService returns null', ()=>{
+      mockTableService.restoreColumns.mockImplementationOnce(() => null);
+      expect(service.restoreColumns()).toEqual(expectedDefaultColumns);
+    });
+
+    it('should call resetColumns from TableService', ()=>{
+      service.resetColumns(); 
+      expect(mockTableService.resetColumns).toBeCalledWith('applications-columns');
+      expect(service.resetColumns()).toEqual(expectedDefaultColumns);
+    });
+  });
+});

src/app/applications/services/applications-index.service.ts

@@ -24,6 +24,7 @@ export class ApplicationsIndexService {
   readonly defaultOptions: ApplicationRawListOptions = this.#defaultConfigService.defaultApplications.options;
 
   readonly defaultIntervalValue = this.#defaultConfigService.defaultApplications.interval;
+  readonly defaultLockColumnValue = this.#defaultConfigService.defaultApplications.lockColumns;
 
   #tableService = inject(TableService);
 
@@ -62,6 +63,18 @@ export class ApplicationsIndexService {
     return this.#tableService.restoreIntervalValue('applications-interval') ?? this.defaultIntervalValue;
   }
 
+  /**
+   * Lock columns
+   */
+
+  saveLockColumns(value: boolean): void {
+    this.#tableService.saveLockColumns('applications-lock-columns', value);
+  }
+
+  restoreLockColumns(): boolean {
+    return this.#tableService.restoreLockColumns('applications-lock-columns') ?? this.defaultLockColumnValue;
+  }
+
   /**
    * Options
    */

src/app/components/columns-button.component.ts

@@ -10,7 +10,7 @@ import { ColumnsModifyDialogComponent } from './columns-modify-dialog.component'
 @Component({
   selector: 'app-columns-button',
   template: `
-<button mat-stroked-button (click)="openModifyColumnsDialog()">
+<button [disabled]="disabled" mat-stroked-button (click)="openModifyColumnsDialog()">
   <mat-icon aria-hidden="true" [fontIcon]="getIcon('modify-columns')"></mat-icon>
   <span i18n="Open a dialog on click">Modify Columns</span>
 </button>
@@ -31,6 +31,7 @@ export class ColumnsButtonComponent<T extends object, O extends object> {
   @Input({ required: true }) columnsLabels: Record<ColumnKey<T, O>, string>;
   @Input({ required: true }) displayedColumns: ColumnKey<T, O>[] = [];
   @Input({ required: true }) availableColumns: ColumnKey<T, O>[];
+  @Input({ required: true}) disabled: boolean = false;
 
   @Output() displayedColumnsChange: EventEmitter<ColumnKey<T, O>[]> = new EventEmitter<ColumnKey<T, O>[]>();