@kumori/aurora-backend-handler 1.0.0

package/test/deploy-service-helper.test.ts

@@ -0,0 +1,518 @@
+import { Service } from "@hestekumori/aurora-interfaces";
+import {
+  withDefaultValue,
+  handleParametersToGenerateData,
+  transformServiceToForm,
+  generateServiceSpec,
+  deployServiceHelper as deployService,
+  ServiceSpecForm,
+} from "../api/deploy-service-helper";
+
+jest.mock("@kumori/kumori-module-generator", () => ({
+  buildServiceDeploymentModuleWithLocalComponent: jest
+    .fn()
+    .mockResolvedValue(new Blob(["bundleFalso"])),
+}));
+
+jest.mock("../api/resources-api-service", () => ({
+  createVolume: jest.fn().mockResolvedValue({}),
+}));
+
+jest.mock("../websocket-manager", () => ({
+  getReferenceDomain: jest.fn().mockReturnValue("test-domain.com"),
+}));
+
+describe("withDefaultValue", () => {
+  it("retorna el valor si este no es null o undefined", () => {
+    expect(withDefaultValue("valor", "default")).toBe("valor");
+    expect(withDefaultValue(0, 10)).toBe(0);
+    expect(withDefaultValue(false, true)).toBe(false);
+  });
+
+  it("retorna el valor por defecto si el valor es null o undefined", () => {
+    expect(withDefaultValue(null, "default")).toBe("default");
+    expect(withDefaultValue(undefined, "default")).toBe("default");
+  });
+});
+
+describe("handleParametersToGenerateData", () => {
+  it("maneja parámetros básicos (string, number, boolean)", () => {
+    const formParams = [
+      { name: "param1", value: "valor1", type: "string" },
+      { name: "param2", value: "42", type: "number" },
+      { name: "param3", value: "true", type: "boolean" },
+    ];
+    const result = handleParametersToGenerateData(formParams, []);
+
+    expect(result.parameters).toHaveLength(3);
+    expect(result.environment).toHaveLength(3);
+    expect(result.parameters[0]).toEqual({
+      name: "param1",
+      type: "string",
+      defaultValue: "valor1",
+    });
+    expect(result.parameters[1].defaultValue).toBe(42);
+    expect(result.parameters[2].defaultValue).toBe(true);
+  });
+
+  it("maneja parámetros de tipo secret", () => {
+    const formParams = [{ name: "sec1", value: "secretValue", type: "secret" }];
+    const result = handleParametersToGenerateData(formParams, []);
+
+    expect(result.environment).toContainEqual({
+      varName: "sec1",
+      secret: "secretValue",
+    });
+    expect(result.resources).toContainEqual({
+      secret: { name: "secretValue" },
+    });
+  });
+
+  it("maneja parámetros de tipo file", () => {
+    const formParams = [
+      { name: "file1", value: "/path/to/file", type: "file" },
+    ];
+    const result = handleParametersToGenerateData(formParams, []);
+
+    expect(result.fileSystem).toContainEqual({
+      path: "/app/config/file1",
+      param: "file1",
+    });
+  });
+
+  it("maneja parámetros de tipo fileContent", () => {
+    const formParams = [
+      {
+        name: "file1",
+        value: "/custom/path",
+        type: "fileContent",
+        content: "contenido",
+      },
+    ];
+    const result = handleParametersToGenerateData(formParams, []);
+
+    expect(result.parameters[0].defaultValue).toBe("contenido");
+    expect(result.fileSystem[0].path).toBe("/custom/path");
+  });
+
+  it("maneja parámetros de tipo volume", () => {
+    const formParams = [{ name: "vol1", value: "/data", type: "volume" }];
+    const result = handleParametersToGenerateData(formParams, []);
+
+    expect(result.resources).toContainEqual({ volume: { name: "vol1" } });
+    expect(result.fileSystem).toContainEqual({
+      path: "/data",
+      resourceVolume: "vol1",
+    });
+  });
+
+  it("maneja parámetros de tipo serviceUrl", () => {
+    const formParams = [
+      { name: "url1", value: "https://api.example.com", type: "serviceUrl" },
+    ];
+    const result = handleParametersToGenerateData(formParams, []);
+
+    expect(result.parameters[0].defaultValue).toBe("https://api.example.com");
+  });
+
+  it("maneja tipos desconocidos", () => {
+    const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+    const formParams = [{ name: "param1", value: "valor", type: "unknown" }];
+
+    handleParametersToGenerateData(formParams, []);
+
+    expect(consoleSpy).toHaveBeenCalledWith("Unknown parameter type: unknown");
+    consoleSpy.mockRestore();
+  });
+
+  it("maneja recursos de tipo secret", () => {
+    const formResources = [
+      { name: "res1", type: "secret", value: "secretValue" },
+    ];
+    const result = handleParametersToGenerateData([], formResources);
+
+    expect(result.resources).toContainEqual({ secret: { name: "res1" } });
+  });
+});
+
+describe("transformServiceToForm", () => {
+  const createMockService = (overrides = {}): Service => ({
+    id: "servicio1",
+    tenant: "tenant1",
+    account: "account1",
+    environment: "env1",
+    name: "Servicio Prueba",
+    logo: "",
+    description: "",
+    revisions: [],
+    status: {
+      message: "running",
+      timestamp: "2024-01-01",
+      args: [],
+      code: "200",
+    },
+    role: [{ name: "servicio1", instances: [] }],
+    links: [],
+    resources: [],
+    parameters: [],
+    usage: {
+      current: {
+        cpu: 2,
+        memory: 512,
+        storage: 100,
+        volatileStorage: 10,
+        nonReplicatedStorage: 10,
+        persistentStorage: 20,
+      },
+      limit: {
+        cpu: { max: 4, min: 1 },
+        memory: { max: 1024, min: 256 },
+        storage: { max: 200, min: 50 },
+        volatileStorage: { max: 20, min: 5 },
+        nonReplicatedStorage: { max: 20, min: 5 },
+        persistentStorage: { max: 50, min: 10 },
+      },
+      cost: 100,
+    },
+    minReplicas: 1,
+    maxReplicas: 3,
+    lastDeployed: "",
+    project: "project1",
+    registry: "docker.io",
+    imageName: "miImagen",
+    entrypoint: "/iniciar",
+    cmd: "start",
+    serverChannels: [],
+    clientChannels: [],
+    duplexChannels: [],
+    cloudProvider: "aws",
+    ...overrides,
+  });
+
+  it("transforma correctamente un objeto Service básico", () => {
+    const service = createMockService({
+      clientChannels: [{ name: "clientChannel1", from: "", to: "" }],
+      serverChannels: [
+        {
+          name: "serverChannel1",
+          from: "",
+          to: "",
+          port: 8080,
+          isPublic: true,
+          protocol: "http",
+          portNum: 80,
+        },
+      ],
+    });
+
+    const form = transformServiceToForm(service);
+
+    expect(form.tenantId).toBe("tenant1");
+    expect(form.accountId).toBe("account1");
+    expect(form.serviceId).toBe("Servicio Prueba");
+    expect(form.cpuRequirements).toBe(4);
+    expect(form.memoryRequirements).toBe(1024);
+    expect(form.registryUrl).toBe("docker.io");
+    expect(form.imageTag).toBe("miImagen");
+    expect(form.clientChannels).toEqual([{ name: "clientChannel1" }]);
+    expect(form.channels[0].protocol).toBe("HTTPS");
+  });
+
+  it("maneja serverChannels con protocolo TCP", () => {
+    const service = createMockService({
+      serverChannels: [
+        {
+          name: "tcpChannel",
+          from: "",
+          to: "",
+          protocol: "tcp",
+        },
+      ],
+    });
+
+    const form = transformServiceToForm(service);
+    expect(form.channels[0].protocol).toBe("TCP");
+  });
+
+  it("maneja scaling configuration", () => {
+    const service = createMockService({
+      role: [
+        {
+          name: "servicio1",
+          instances: [],
+          scalling: {
+            cpu: { up: "80", down: "20" },
+            memory: { up: "80", down: "20" },
+            instances: { max: 5, min: 1 },
+            histeresys: "10",
+          },
+        },
+      ],
+    });
+
+    const form = transformServiceToForm(service);
+    expect(form.scaling).toBeDefined();
+    expect(form.scaling?.instances.max).toBe(5);
+  });
+});
+
+describe("generateServiceSpec", () => {
+  const createMockForm = (overrides = {}): ServiceSpecForm => ({
+    tenantId: "tenant1",
+    accountId: "account1",
+    environmentId: "env1",
+    serviceId: "servicio1",
+    cpuRequirements: 2,
+    memoryRequirements: 512,
+    registryUrl: "docker.io",
+    imageTag: "miImagen",
+    clientChannels: [],
+    channels: [],
+    defaultExecutable: {},
+    config: {
+      parameters: [],
+      resources: [],
+    },
+    ...overrides,
+  });
+
+  it("genera un ServiceWithLocalComponentSpec básico", async () => {
+    const form = createMockForm({
+      clientChannels: [{ name: "clientChannel1" }],
+    });
+
+    const serviceSpec = await generateServiceSpec(form);
+
+    expect(serviceSpec.type).toBe("service");
+    expect(serviceSpec.subtype).toBe("service_with_local_component");
+    expect(serviceSpec.tenantId).toBe("tenant1");
+    expect(serviceSpec.local_components["servicio1"].channels.client).toEqual([
+      "clientChannel1",
+    ]);
+  });
+
+  it("genera inbound roles para canales HTTPS públicos", async () => {
+    const form = createMockForm({
+      channels: [
+        {
+          channelName: "https1",
+          containerPort: 443,
+          isPublic: true,
+          protocol: "HTTPS",
+          domain: "example.com",
+        },
+      ],
+    });
+
+    const serviceSpec = await generateServiceSpec(form);
+
+    const inboundRole = serviceSpec.roles.find(
+      (role) => role.name === "https1_inbound"
+    );
+    expect(inboundRole).toBeDefined();
+    expect(inboundRole?.artifact.config.parameters).toContainEqual({
+      name: "type",
+      value: "https",
+      type: "string",
+    });
+  });
+
+  it("genera inbound roles para canales TCP públicos", async () => {
+    const form = createMockForm({
+      channels: [
+        {
+          channelName: "tcp1",
+          containerPort: 9000,
+          isPublic: true,
+          protocol: "TCP",
+          publicPort: "9000",
+        },
+      ],
+    });
+
+    const serviceSpec = await generateServiceSpec(form);
+
+    const inboundRole = serviceSpec.roles.find(
+      (role) => role.name === "tcp1_inbound"
+    );
+    expect(inboundRole).toBeDefined();
+  });
+
+  it("maneja volúmenes con diferentes tipos", async () => {
+    const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+    const form = createMockForm({
+      config: {
+        parameters: [],
+        resources: [
+          { name: "vol1", type: "volume", size: 5, kind: "volatile" },
+          { name: "vol2", type: "volume", size: 10, kind: "persistent" },
+          { name: "vol3", type: "volume", size: 15, kind: "nonreplicated" },
+        ],
+      },
+    });
+
+    const serviceSpec = await generateServiceSpec(form);
+
+    const resources = serviceSpec.deploymentConfig.resources;
+    expect(resources.some((r: any) => r.volume?.volume?.type === "volatile")).toBe(true);
+    expect(resources.some((r: any) => r.volume?.volume?.type === "persistent")).toBe(true);
+    expect(resources.some((r: any) => r.volume?.volume?.type === "nonreplicated")).toBe(true);
+
+    consoleSpy.mockRestore();
+  });
+
+  it("maneja scaling configuration", async () => {
+    const form = createMockForm({
+      scaling: {
+        cpu: { up: "80", down: "20" },
+        memory: { up: "80", down: "20" },
+        instances: { min: 1, max: 5 },
+        histeresys: "10",
+      },
+    });
+
+    const serviceSpec = await generateServiceSpec(form);
+
+    expect(serviceSpec.deploymentConfig.meta.scaling).toBeDefined();
+    expect(serviceSpec.deploymentConfig.meta.scaling.simple.servicio1.max_replicas).toBe(5);
+  });
+
+  it("genera spec con marketplace item de tipo service", async () => {
+    const form = createMockForm();
+    const marketplaceItem = {
+      type: "service" as const,
+      domain: "kumori.systems",
+      module: "marketplace/service",
+      version: "1.2.3",
+      serviceName: "MarketplaceService",
+      deploymentData: { name: "marketplaceRole" },
+      roles: ["role1", "role2"],
+    };
+
+    const serviceSpec = await generateServiceSpec(form, marketplaceItem as any);
+
+    const marketplaceRole = serviceSpec.roles.find(
+      (role) => role.name === "marketplaceRole"
+    );
+    expect(marketplaceRole?.artifact.artifactKind).toBe("service");
+    expect(serviceSpec.local_components).toEqual({});
+  });
+});
+
+describe("deployService", () => {
+  const mockClick = jest.fn();
+  
+  beforeAll(() => {
+    (global as any).URL = {
+      createObjectURL: jest.fn(() => "blob:mock-url"),
+    };
+
+    (global as any).document = {
+      createElement: jest.fn(() => ({
+        click: mockClick,
+        target: "",
+        href: "",
+      })),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const createMockService = (overrides = {}): Service => ({
+    id: "servicio1",
+    tenant: "tenant1",
+    account: "account1",
+    environment: "env1",
+    name: "Servicio Prueba",
+    logo: "",
+    description: "",
+    revisions: [],
+    status: {
+      message: "running",
+      timestamp: "2024-01-01",
+      args: [],
+      code: "200",
+    },
+    role: [{ name: "servicio1", instances: [] }],
+    links: [],
+    resources: [],
+    parameters: [],
+    usage: {
+      current: {
+        cpu: 2,
+        memory: 512,
+        storage: 100,
+        volatileStorage: 10,
+        nonReplicatedStorage: 10,
+        persistentStorage: 20,
+      },
+      limit: {
+        cpu: { max: 4, min: 1 },
+        memory: { max: 1024, min: 256 },
+        storage: { max: 200, min: 50 },
+        volatileStorage: { max: 20, min: 5 },
+        nonReplicatedStorage: { max: 20, min: 5 },
+        persistentStorage: { max: 50, min: 10 },
+      },
+      cost: 100,
+    },
+    minReplicas: 1,
+    maxReplicas: 3,
+    lastDeployed: "",
+    project: "project1",
+    registry: "docker.io",
+    imageName: "miImagen",
+    entrypoint: "/iniciar",
+    cmd: "start",
+    serverChannels: [],
+    clientChannels: [],
+    duplexChannels: [],
+    cloudProvider: "aws",
+    ...overrides,
+  });
+
+  it("retorna FormData con bundle y meta cuando download es false", async () => {
+    const service = createMockService({ download: false });
+
+    const formData = await deployService(service);
+
+    expect(formData.get("bundle")).toBeTruthy();
+    expect(formData.get("meta")).toBeTruthy();
+    expect(formData.get("comment")).toBe(" ");
+
+    const meta = JSON.parse(formData.get("meta") as string);
+    expect(meta.targetAccount).toBe("account1");
+    expect(meta.targetEnvironment).toBe("env1");
+  });
+
+  it("retorna FormData vacío y ejecuta descarga cuando download es true", async () => {
+    const service = createMockService({ download: true });
+
+    const formData = await deployService(service);
+
+    expect((global as any).URL.createObjectURL).toHaveBeenCalled();
+    expect((global as any).document.createElement).toHaveBeenCalledWith("a");
+    expect(mockClick).toHaveBeenCalled();
+    expect(Array.from(formData.keys()).length).toBe(0);
+  });
+
+  it("maneja deployment con marketplace item", async () => {
+    const service = createMockService();
+    const marketplaceItem = {
+      type: "service" as const,
+      domain: "kumori.systems",
+      module: "marketplace/service",
+      version: "1.0.0",
+      serviceName: "TestService",
+      deploymentData: { name: "testRole" },
+      roles: ["role1"],
+    };
+
+    const formData = await deployService(service, marketplaceItem as any);
+
+    expect(formData.get("bundle")).toBeTruthy();
+  });
+});

package/test/event-helper.test.ts

@@ -0,0 +1,152 @@
+
+import EventHelper from '../event-helper';
+import { EventNames } from './../event-names';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('EventHelper', () => {
+  const dummyGlobalEventHandler = {
+    publish: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+  };
+  
+  const eventHelper = new EventHelper(dummyGlobalEventHandler);
+
+
+  // --- Tenant ---
+  describe('Tenant events', () => {
+    test('tenant.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'tenant1', name: 'Tenant One' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.tenant.publish.creation(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateTenant, payload);
+    });
+
+    test('tenant.subscribe.creation llama a globalEventHandler.subscribe con el nombre de evento correcto y callback', () => {
+      const callback = jest.fn();
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'subscribe');
+      eventHelper.tenant.subscribe.creation(callback);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateTenant, callback);
+    });
+
+    test('tenant.unsubscribe.creation llama a globalEventHandler.unsubscribe con el nombre de evento correcto y callback', () => {
+      const callback = jest.fn();
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'unsubscribe');
+      eventHelper.tenant.unsubscribe.creation(callback);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateTenant, callback);
+    });
+  });
+
+  // --- User ---
+  describe('User events', () => {
+    test('user.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'user1', username: 'john.doe' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.user.publish.creation(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateUser, payload);
+    });
+
+    test('user.subscribe.creation llama a globalEventHandler.subscribe con el nombre de evento correcto y callback', () => {
+      const callback = jest.fn();
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'subscribe');
+      eventHelper.user.subscribe.creation(callback);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateUser, callback);
+    });
+  });
+
+  // --- Account ---
+  describe('Account events', () => {
+    test('account.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'acc1', name: 'Account One' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.account.publish.creation(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateAccount, payload);
+    });
+  });
+
+  // --- Environment ---
+  describe('Environment events', () => {
+    test('environment.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'env1', name: 'Environment One' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.environment.publish.creation(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateEnvironment, payload);
+    });
+  });
+
+  // --- Service ---
+  describe('Service events', () => {
+    test('service.publish.deploy llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'svc1', name: 'Service One' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.service.publish.deploy(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.DeployService, payload);
+    });
+  });
+
+  // --- Marketplace ---
+  describe('Marketplace events', () => {
+    test('marketplace.publish.deployItem llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'mkt1', name: 'Marketplace Item' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.marketplace.publish.deployItem(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.DeployMarketplaceItem, payload);
+    });
+  });
+
+  // --- Resource ---
+  describe('Resource events', () => {
+    test('resource.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'res1', name: 'Resource One' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.resource.publish.creation(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateResource, payload);
+    });
+  });
+
+  // --- Plan (payload de tipo string) ---
+  describe('Plan events', () => {
+    test('plan.publish.upgrade llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = 'Upgrade Data';
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.plan.publish.upgrade(payload);
+      expect(spy).toHaveBeenCalledWith(EventNames.UpdatePlan, payload);
+    });
+  });
+
+  // --- Organization ---
+  describe('Organization events', () => {
+    test('organization.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
+      const payload = { id: 'org1', name: 'Organization One' };
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.organization.publish.creation(payload as any);
+      expect(spy).toHaveBeenCalledWith(EventNames.CreateOrganization, payload);
+    });
+  });
+
+  // --- PlanProviders ---
+  describe('PlanProviders events', () => {
+    test('planProviders.publish.getPlans llama a globalEventHandler.publish con el nombre de evento correcto', () => {
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
+      eventHelper.planProviders.publish.loadPlans();
+      expect(spy).toHaveBeenCalledWith(EventNames.LoadPlanProviders, undefined);
+    });
+
+    test('planProviders.subscribe.getPlans llama a globalEventHandler.subscribe con el nombre de evento correcto y callback', () => {
+      const callback = jest.fn();
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'subscribe');
+      eventHelper.planProviders.subscribe.loadPlans(callback);
+      expect(spy).toHaveBeenCalledWith(EventNames.LoadPlanProviders, callback);
+    });
+
+    test('planProviders.unsubscribe.getPlans llama a globalEventHandler.unsubscribe con el nombre de evento correcto y callback', () => {
+      const callback = jest.fn();
+      const spy = jest.spyOn(eventHelper.globalEventHandler, 'unsubscribe');
+      eventHelper.planProviders.unsubscribe.loadPlans(callback);
+      expect(spy).toHaveBeenCalledWith(EventNames.LoadPlanProviders, callback);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "allowJs": true,
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  }
+}