Update package.json to modify script paths and adjust TypeScript configuration

Author: tacxou

package.json

@@ -8,13 +8,13 @@
   "scripts": {
     "prebuild": "cpr README.md dist/README.md && cpr LICENSE dist/LICENSE && cpr package.json dist/package.json",
     "build": "nest build",
-    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
     "start": "NODE_ENV=production nest start",
     "start:dev": "nest start --watch",
     "start:debug": "nest start --debug 0.0.0.0 --watch",
     "start:prod": "NODE_ENV=production node dist/main",
-    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\"",
-    "lint:fix": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "lint": "eslint \"{src,apps,libs,test,tests}/**/*.ts\"",
+    "lint:fix": "eslint \"{src,apps,libs,test,tests}/**/*.ts\" --fix",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
@@ -71,7 +71,11 @@
       "json",
       "ts"
     ],
-    "rootDir": "src",
+    "rootDir": ".",
+    "moduleNameMapper": {
+      "^~/(.*)$": "<rootDir>/src/$1",
+      "^@/(.*)$": "<rootDir>/$1"
+    },
     "testRegex": ".*\\.spec\\.ts$",
     "transform": {
       "^.+\\.(t|j)s$": "ts-jest"

tests/_common/functions/get-log-level.spec.ts

@@ -0,0 +1,29 @@
+import { LogLevel } from '@nestjs/common';
+import { getLogLevel } from '~/_common/functions/get-log-level';
+
+describe('getLogLevel', () => {
+  it('par defaut retourne les niveaux de info', () => {
+    expect(getLogLevel()).toEqual(['error', 'fatal', 'warn', 'log'] as LogLevel[]);
+  });
+
+  it('mappe "error"', () => {
+    expect(getLogLevel('error')).toEqual(['error', 'fatal'] as LogLevel[]);
+  });
+
+  it('mappe "warn"', () => {
+    expect(getLogLevel('warn')).toEqual(['error', 'fatal', 'warn'] as LogLevel[]);
+  });
+
+  it('mappe "debug"', () => {
+    expect(getLogLevel('debug')).toEqual(['error', 'fatal', 'warn', 'log', 'debug'] as LogLevel[]);
+  });
+
+  it('mappe "verbose"', () => {
+    expect(getLogLevel('verbose')).toEqual(['error', 'fatal', 'warn', 'log', 'debug', 'verbose'] as LogLevel[]);
+  });
+
+  it('unknown => info par defaut', () => {
+    expect(getLogLevel('unknown')).toEqual(getLogLevel('info'));
+  });
+});
+

tests/backend-runner/_executors/catch-all.executor.spec.ts

@@ -0,0 +1,85 @@
+import { BackendCodesEnumError } from '~/backend-runner/_interfaces/backend-codes.enum';
+import { CatchAllExecutor } from '~/backend-runner/_executors/catch-all.executor';
+
+describe('CatchAllExecutor helpers', () => {
+  const executor = new CatchAllExecutor({} as any);
+
+  describe('extractLastJsonImproved', () => {
+    it('retourne une erreur "No output" si stdout est vide', () => {
+      const res = (executor as any).extractLastJsonImproved('');
+      expect(res).toEqual({
+        status: BackendCodesEnumError.INVALID_JSON_RESPONSE,
+        message: 'No output',
+      });
+    });
+
+    it('retourne une erreur "No JSON output" s il n y a aucun JSON valide', () => {
+      const res = (executor as any).extractLastJsonImproved('hello world');
+      expect(res).toEqual({
+        status: BackendCodesEnumError.INVALID_JSON_RESPONSE,
+        message: 'No JSON output',
+      });
+    });
+
+    it('retourne le dernier JSON extrait de stdout', () => {
+      const res = (executor as any).extractLastJsonImproved('prefix {"a":1} middle {"b":2}');
+      expect(res).toEqual({ b: 2 });
+    });
+
+    it('ignore les accolades dans les strings', () => {
+      const res = (executor as any).extractLastJsonImproved('{"a":"{not json}", "b":1}');
+      expect(res).toEqual({ a: '{not json}', b: 1 });
+    });
+  });
+
+  describe('validationRecursive', () => {
+    it('produit un mapping des contraintes recursif (en profondeur 1)', () => {
+      const error = {
+        property: 'root',
+        constraints: { isDefined: 'Root required' },
+        children: [
+          {
+            property: 'child',
+            constraints: { isString: 'Child must be a string' },
+            children: [],
+          },
+        ],
+      } as any;
+
+      const validations = (executor as any).validationRecursive(error);
+      expect(validations).toEqual({
+        root: 'Root required',
+        'root.child': 'Child must be a string',
+      });
+    });
+
+    it('produit un mapping des contraintes recursif (en profondeur 2)', () => {
+      const error = {
+        property: 'root',
+        constraints: { isDefined: 'Root required' },
+        children: [
+          {
+            property: 'child',
+            constraints: { isString: 'Child must be a string' },
+            children: [
+              {
+                property: 'grand',
+                constraints: { isNumber: 'Grand must be a number' },
+                children: [],
+              },
+            ],
+          },
+        ],
+      } as any;
+
+      const validations = (executor as any).validationRecursive(error);
+      expect(validations).toEqual({
+        root: 'Root required',
+        'root.child': 'Child must be a string',
+        'root.child.child': 'Child must be a string',
+        'root.child.child.grand': 'Grand must be a number',
+      });
+    });
+  });
+});
+

tests/backend-runner/_validators/is-action-constraint.validator.spec.ts

@@ -0,0 +1,45 @@
+import { ValidationError } from 'class-validator';
+import { IsActionConstraintValidator } from '~/backend-runner/_validators/is-action-constraint.validator';
+import { BackendConfigActionDto } from '~/backend-runner/_dto/backend-config-v1.dto';
+import { ActionType } from '~/backend-runner/_enum/action-type.enum';
+import { OnErrorType } from '~/backend-runner/_enum/on-error-type.enum';
+
+describe('IsActionConstraintValidator', () => {
+  const validator = new IsActionConstraintValidator();
+
+  it("retourne true pour une structure d'actions valide", async () => {
+    const dto = new BackendConfigActionDto();
+    dto.script = 'echo hello';
+    dto.onError = OnErrorType.STOP;
+
+    await expect(
+      validator.validate({
+        [ActionType.LIST_BACKENDS]: dto,
+      } as any),
+    ).resolves.toBe(true);
+  });
+
+  it("retourne false si une cle n'est pas une ActionType valide", async () => {
+    const dto = new BackendConfigActionDto();
+    dto.script = 'echo hello';
+
+    await expect(
+      validator.validate({
+        NOT_A_REAL_ACTION: dto,
+      } as any),
+    ).resolves.toBe(false);
+  });
+
+  it('rejette si le DTO BackendConfigActionDto est invalide', async () => {
+    const dto = new BackendConfigActionDto();
+    // Script invalide => @IsString() + @IsNotEmpty()
+    dto.script = '';
+
+    await expect(
+      validator.validate({
+        [ActionType.LIST_BACKENDS]: dto,
+      } as any),
+    ).rejects.toEqual(expect.any(Array<ValidationError>));
+  });
+});
+