@squiz/job-runner-lib 1.66.1

package/src/domains/component/services/ComponentService.integration.spec.ts

@@ -0,0 +1,721 @@
+import unzipper from 'unzipper';
+import fsExtra from 'fs-extra';
+import path from 'path';
+import { ComponentConnectionManager, createConnectionManager } from '../../db';
+import { createPackage } from '../../__test__/createPackage';
+import { ComponentService } from './ComponentService';
+import { ManifestServiceForProduction } from '../../manifest';
+import { randomUUID } from 'crypto';
+
+import { ComponentSetComponentVersionStatus } from '../../component-set';
+import { getLogger } from '@squiz/dx-logger-lib';
+import { ComponentVersionInterface } from '../models/ComponentVersion';
+import * as TestHelpers from '../../../TestHelpers';
+import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
+
+type ComponentManifest = MANIFEST_MODELS.v1.ComponentManifest;
+
+describe('ComponentService', () => {
+  const namespace = 'test-namespace';
+  let db: ComponentConnectionManager;
+  let service: ComponentService;
+
+  beforeAll(async () => {
+    db = await createConnectionManager(
+      'management-api-test',
+      {
+        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
+      },
+      '',
+    );
+    await db.applyMigrations();
+    service = new ComponentService(
+      db,
+      console,
+      process.env.DATA_MOUNT_POINT!,
+      new ManifestServiceForProduction(process.env.DATA_MOUNT_POINT!, getLogger({ name: 'ComponentService' })),
+    );
+  });
+
+  afterAll(async () => {
+    await db.close();
+  });
+
+  describe('saveComponent', () => {
+    let componentTempLocation = '';
+    let componentName = '';
+    const componentVersion = '1.0.0';
+
+    async function createComponentAtTempLocation(componentTempLocation: string) {
+      const componentName = path.basename(componentTempLocation);
+
+      const newComponent = createPackage(namespace, path.basename(componentTempLocation), componentVersion);
+      await newComponent.finalize();
+      await newComponent.pipe(unzipper.Extract({ path: componentTempLocation })).promise();
+
+      return componentName;
+    }
+
+    beforeAll(async () => {
+      componentTempLocation = await TestHelpers.ComponentFixture.createFixtureDirectory();
+      componentName = await createComponentAtTempLocation(componentTempLocation);
+    });
+
+    afterAll(async () => {
+      await service.deleteComponent(namespace, componentName);
+
+      if (fsExtra.pathExistsSync(componentTempLocation)) {
+        fsExtra.rmSync(componentTempLocation, { force: true, recursive: true });
+      }
+    });
+
+    it('should take a location to a component and move it to the DATA_MOUNT_POINT as well as update the db', async () => {
+      await service.saveComponent(componentTempLocation);
+
+      const compDestination = path.join(process.env.DATA_MOUNT_POINT!, namespace, componentName, componentVersion);
+
+      expect(fsExtra.pathExistsSync(compDestination)).toEqual(true);
+      expect(fsExtra.pathExistsSync(path.join(compDestination, 'manifest.json'))).toEqual(true);
+
+      const component = await db.repositories.component.getComponentByName(`${namespace}/${componentName}`);
+      const componentVersionObj = await db.repositories.componentVersion.getComponentByNameAndVersion(
+        `${namespace}/${componentName}`,
+        componentVersion,
+      );
+
+      expect(component).toEqual({ name: `${namespace}/${componentName}` });
+      expect(componentVersionObj).toEqual({
+        componentName: `${namespace}/${componentName}`,
+        version: componentVersion,
+        description: 'some-description',
+        displayName: 'some-display-name',
+      });
+    }, 15_000);
+
+    it('should clean up temp location after save', async () => {
+      expect(fsExtra.pathExistsSync(componentTempLocation)).toEqual(false);
+    });
+
+    it('should throw an error if the component version already exists', async () => {
+      await createComponentAtTempLocation(componentTempLocation);
+
+      await expect(service.saveComponent(componentTempLocation)).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Component ${namespace}/${componentName} 1.0.0 already exists"`,
+      );
+
+      // should not clean up existing component
+      const compDestination = path.join(process.env.DATA_MOUNT_POINT!, namespace, componentName, componentVersion);
+      expect(fsExtra.pathExistsSync(compDestination)).toEqual(true);
+    }, 15_000);
+  });
+
+  describe('saveComponent - validations', () => {
+    const testComponentLocations: string[] = [];
+
+    afterAll(async () => {
+      for (let i = 0; i < testComponentLocations.length; i++) {
+        const componentTempLocation = testComponentLocations[i];
+        if (fsExtra.pathExistsSync(componentTempLocation)) {
+          fsExtra.rmSync(componentTempLocation, { force: true, recursive: true });
+        }
+      }
+    });
+
+    async function createComponentAtTempLocation(
+      componentTempLocation: string,
+      componentName: string,
+      version: string,
+      manifest: ComponentManifest,
+    ) {
+      const newComponent = createPackage(namespace, componentName, version, manifest);
+      await newComponent.finalize();
+      await newComponent.pipe(unzipper.Extract({ path: componentTempLocation })).promise();
+    }
+
+    it('should fail upload if fn output data is not valid', async () => {
+      const componentTempLocation = await TestHelpers.ComponentFixture.createFixtureDirectory();
+      testComponentLocations.push(componentTempLocation);
+
+      const componentName = path.basename(componentTempLocation);
+      const componentVersion = '1.0.0';
+
+      const manifest: ComponentManifest = {
+        mainFunction: 'main',
+        $schema: 'http://../schemas/v1.json#',
+        name: componentName,
+        version: componentVersion,
+        namespace: namespace,
+        displayName: `some-display-name`,
+        description: 'some-description',
+        functions: [
+          {
+            entry: 'main.js',
+            input: { type: 'object', properties: { something: { type: 'string' } }, required: [] },
+            name: 'main',
+            output: {
+              responseType: 'html',
+              staticFiles: [
+                {
+                  location: 'header',
+                  file: {
+                    type: 'css',
+                    filepath: 'non-existent-file.css',
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      };
+
+      await createComponentAtTempLocation(componentTempLocation, componentName, componentVersion, manifest);
+      await expect(service.saveComponent(componentTempLocation)).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"function main defines static files but manifest has no staticFiles.locationRoot defined"`,
+      );
+    }, 15_000);
+
+    it('should fail upload if preview data is not valid', async () => {
+      const componentTempLocation = await TestHelpers.ComponentFixture.createFixtureDirectory();
+      testComponentLocations.push(componentTempLocation);
+
+      const componentName = path.basename(componentTempLocation);
+      const componentVersion = '1.0.0';
+
+      const manifest: ComponentManifest = {
+        mainFunction: 'main',
+        $schema: 'http://../schemas/v1.json#',
+        name: componentName,
+        version: componentVersion,
+        namespace: namespace,
+        displayName: `some-display-name`,
+        description: 'some-description',
+        functions: [
+          {
+            entry: 'main.js',
+            input: { type: 'object', properties: { something: { type: 'string' } }, required: [] },
+            name: 'main',
+            output: {
+              responseType: 'html',
+            },
+          },
+        ],
+        previews: {
+          preview1: {
+            functionData: {
+              'non-existent-fn': {
+                inputData: {
+                  type: 'inline',
+                  value: {
+                    something: 'foo',
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      await createComponentAtTempLocation(componentTempLocation, componentName, componentVersion, manifest);
+      await expect(service.saveComponent(componentTempLocation)).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Invalid preview data for preview "preview1": "non-existent-fn" function for test-namespace/${componentName} 1.0.0 could not be found"`,
+      );
+    }, 15_000);
+
+    it('should fail upload if mocked url data is not valid', async () => {
+      const componentTempLocation = await TestHelpers.ComponentFixture.createFixtureDirectory();
+      testComponentLocations.push(componentTempLocation);
+
+      const componentName = path.basename(componentTempLocation);
+      const componentVersion = '1.0.0';
+
+      const manifest: ComponentManifest = {
+        mainFunction: 'main',
+        $schema: 'http://../schemas/v1.json#',
+        name: componentName,
+        version: componentVersion,
+        namespace: namespace,
+        displayName: `some-display-name`,
+        description: 'some-description',
+        functions: [
+          {
+            entry: 'main.js',
+            input: { type: 'object', properties: { something: { type: 'string' } }, required: [] },
+            name: 'main',
+            output: {
+              responseType: 'html',
+            },
+          },
+        ],
+        mockedUris: {
+          'foo://non-existent-file-uri': {
+            type: 'file',
+            path: './non-existent-uri.json',
+          },
+        },
+      };
+
+      await createComponentAtTempLocation(componentTempLocation, componentName, componentVersion, manifest);
+      await expect(service.saveComponent(componentTempLocation)).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Mocked URI object file "./non-existent-uri.json" does not exist"`,
+      );
+    }, 15_000);
+  });
+
+  describe('getComponentForWeb', () => {
+    const compName1 = `name-space/${randomUUID()}`;
+    const compName2 = `name-space/${randomUUID()}`;
+
+    beforeAll(async () => {
+      await db.repositories.component.create({ name: compName1 });
+      await db.repositories.componentVersion.create({
+        componentName: compName1,
+        description: 'my description',
+        displayName: 'my comp',
+        version: '1.0.0',
+        icon: undefined,
+      });
+      await db.repositories.componentVersion.create({
+        componentName: compName1,
+        description: 'my description 2',
+        displayName: 'my comp',
+        version: '2.0.0',
+        icon: {
+          id: 'child_friendly',
+          color: { type: 'enum', value: 'orange' },
+        },
+      });
+
+      await db.repositories.component.create({ name: compName2 });
+      await db.repositories.componentVersion.create({
+        componentName: compName2,
+        description: 'comp 2',
+        displayName: 'my other comp',
+        version: '1.0.0',
+        icon: undefined,
+      });
+      await db.repositories.componentVersion.create({
+        componentName: compName2,
+        description: 'comp 2 - 2',
+        displayName: 'my other comp',
+        version: '2.0.0',
+        icon: {
+          id: '123',
+          color: { type: 'enum', value: 'green' },
+        },
+      });
+    });
+
+    afterAll(async () => {
+      await db.repositories.component.delete({ name: compName1 });
+      await db.repositories.component.delete({ name: compName2 });
+    });
+
+    it('should return a list of the components version', async () => {
+      const [namespace, name] = compName1.split('/');
+      const result = await service.getComponentForWeb(namespace, name);
+
+      expect(result).toEqual({
+        versions: [
+          { description: 'my description', displayName: 'my comp', icon: undefined, version: '1.0.0' },
+          {
+            description: 'my description 2',
+            displayName: 'my comp',
+            icon: { color: { type: 'enum', value: 'orange' }, id: 'child_friendly' },
+            version: '2.0.0',
+          },
+        ],
+      });
+    });
+
+    it("should throw error if component doesn't exist", async () => {
+      await expect(service.getComponentForWeb(namespace, 'no-real')).rejects.toThrowError();
+    });
+  });
+
+  describe('getComponentVersionForWeb', () => {
+    const compName1 = `name-space/${randomUUID()}`;
+    const compName2 = `name-space/${randomUUID()}`;
+    const setName1 = randomUUID();
+    const setName2 = randomUUID();
+
+    let componentVersionOne: ComponentVersionInterface;
+    let componentVersionTwo: ComponentVersionInterface;
+
+    beforeAll(async () => {
+      await db.repositories.component.create({ name: compName1 });
+      componentVersionOne = await db.repositories.componentVersion.create({
+        componentName: compName1,
+        description: 'my description',
+        displayName: 'my comp',
+        version: '1.0.0',
+        icon: undefined,
+      });
+      componentVersionTwo = await db.repositories.componentVersion.create({
+        componentName: compName1,
+        description: 'my description 2',
+        displayName: 'my comp',
+        version: '2.0.0',
+        icon: {
+          id: 'child_friendly',
+          color: { type: 'enum', value: 'orange' },
+        },
+      });
+
+      await db.repositories.component.create({ name: compName2 });
+      await db.repositories.componentVersion.create({
+        componentName: compName2,
+        description: 'comp 2',
+        displayName: 'my other comp',
+        version: '1.0.0',
+        icon: undefined,
+      });
+      await db.repositories.componentVersion.create({
+        componentName: compName2,
+        description: 'comp 2 - 2',
+        displayName: 'my other comp',
+        version: '2.0.0',
+        icon: {
+          id: '123',
+          color: { type: 'enum', value: 'green' },
+        },
+      });
+
+      await db.repositories.componentSet.create({
+        webPath: setName1,
+        description: 'description',
+        displayName: 'displayname-' + setName1,
+        environmentVariables: {},
+        headers: {},
+      });
+      await db.repositories.componentSet.create({
+        webPath: setName2,
+        description: 'description',
+        displayName: 'displayname-' + setName2,
+        environmentVariables: {},
+        headers: {},
+      });
+
+      await db.repositories.componentSetComponentVersion.create({
+        componentName: compName1,
+        componentVersion: '1.0.0',
+        componentSetWebPath: setName1,
+        environmentVariables: {},
+        status: ComponentSetComponentVersionStatus.active,
+      });
+
+      await db.repositories.componentSetComponentVersion.create({
+        componentName: compName1,
+        componentVersion: '1.0.0',
+        componentSetWebPath: setName2,
+        environmentVariables: {},
+        status: ComponentSetComponentVersionStatus.active,
+      });
+
+      await db.repositories.componentSetComponentVersion.create({
+        componentName: compName2,
+        componentVersion: '1.0.0',
+        componentSetWebPath: setName2,
+        environmentVariables: {},
+        status: ComponentSetComponentVersionStatus.active,
+      });
+
+      await db.repositories.componentSetComponentVersion.create({
+        componentName: compName1,
+        componentVersion: '2.0.0',
+        componentSetWebPath: setName2,
+        environmentVariables: {},
+        status: ComponentSetComponentVersionStatus.active,
+      });
+    });
+
+    afterAll(async () => {
+      await db.repositories.componentSet.delete({ webPath: setName1 });
+      await db.repositories.componentSet.delete({ webPath: setName2 });
+      await db.repositories.component.delete({ name: compName1 });
+      await db.repositories.component.delete({ name: compName2 });
+    });
+
+    it('should return an object with all of the sets the component version is a part of', async () => {
+      const [namespace, name] = compName1.split('/');
+      const result = await service.getComponentVersionForWeb(namespace, name, componentVersionOne.version);
+
+      expect(result).toEqual({
+        description: componentVersionOne.description,
+        displayName: componentVersionOne.displayName,
+        version: componentVersionOne.version,
+        icon: componentVersionOne.icon,
+        name: name,
+        namespace: namespace,
+
+        sets: [
+          {
+            displayName: 'displayname-' + setName1,
+            webPath: setName1,
+          },
+          {
+            displayName: 'displayname-' + setName2,
+            webPath: setName2,
+          },
+        ],
+      });
+    });
+    it("should return an object with an empty array for sets if version isn't a part of any sets", async () => {
+      const [namespace, name] = componentVersionTwo.componentName.split('/');
+      const result = await service.getComponentVersionForWeb(namespace, name, componentVersionTwo.version);
+
+      expect(result).toEqual({
+        description: componentVersionTwo.description,
+        icon: componentVersionTwo.icon,
+        displayName: componentVersionTwo.displayName,
+        version: componentVersionTwo.version,
+        name: name,
+        namespace: namespace,
+        sets: [
+          {
+            displayName: 'displayname-' + setName2,
+            webPath: setName2,
+          },
+        ],
+      });
+    });
+    it('should only include the sets the version is a prt of', async () => {
+      const [namespace, name] = compName2.split('/');
+      const result = await service.getComponentVersionForWeb(namespace, name, '1.0.0');
+
+      expect(result).toEqual({
+        description: 'comp 2',
+        displayName: 'my other comp',
+        icon: undefined,
+        name: name,
+        namespace: 'name-space',
+        version: '1.0.0',
+        sets: [
+          {
+            displayName: 'displayname-' + setName2,
+            webPath: setName2,
+          },
+        ],
+      });
+
+      const result2 = await service.getComponentVersionForWeb(namespace, name, '2.0.0');
+      expect(result2).toEqual({
+        description: 'comp 2 - 2',
+        displayName: 'my other comp',
+        icon: {
+          id: '123',
+          color: { type: 'enum', value: 'green' },
+        },
+        name: name,
+        namespace: 'name-space',
+        version: '2.0.0',
+        sets: [],
+      });
+    });
+
+    it("should throw error if component doesn't exist", async () => {
+      await expect(service.getComponentForWeb(namespace, 'no-real')).rejects.toThrowError();
+    });
+  });
+
+  describe('saveComponentVersion', () => {
+    let componentName = '';
+    let componentTempLocation = '';
+    const componentVersion = '1.0.0';
+
+    async function createComponentAtTempLocation(componentTempLocation: string, version: string) {
+      const componentName = path.basename(componentTempLocation);
+
+      const newComponent = createPackage(namespace, path.basename(componentTempLocation), version);
+      await newComponent.finalize();
+      await newComponent.pipe(unzipper.Extract({ path: componentTempLocation })).promise();
+
+      return componentName;
+    }
+
+    beforeAll(async () => {
+      componentTempLocation = await TestHelpers.ComponentFixture.createFixtureDirectory();
+      componentName = await createComponentAtTempLocation(componentTempLocation, componentVersion);
+      await service.saveComponent(componentTempLocation);
+    }, 10_000);
+
+    afterAll(async () => {
+      if (fsExtra.pathExistsSync(componentTempLocation)) {
+        fsExtra.rmSync(componentTempLocation, { force: true, recursive: true });
+      }
+      await service.deleteComponent(namespace, componentName);
+    });
+
+    it('should save new component by adding the version in filesystem and db, and same when deleting', async () => {
+      // first create the new component version and check
+      fsExtra.mkdirSync(componentTempLocation);
+      componentName = await createComponentAtTempLocation(componentTempLocation, '2.0.0');
+      await service.saveComponent(componentTempLocation);
+
+      const compVersionDestination = path.join(process.env.DATA_MOUNT_POINT!, namespace, componentName, '2.0.0');
+
+      expect(fsExtra.pathExistsSync(compVersionDestination)).toEqual(true);
+      expect(fsExtra.pathExistsSync(path.join(compVersionDestination, 'manifest.json'))).toEqual(true);
+
+      const componentVersionObj = await db.repositories.componentVersion.getComponentByNameAndVersion(
+        `${namespace}/${componentName}`,
+        '2.0.0',
+      );
+      expect(componentVersionObj).toEqual({
+        componentName: `${namespace}/${componentName}`,
+        version: '2.0.0',
+        description: 'some-description',
+        displayName: 'some-display-name',
+      });
+
+      // now delete the component version
+      await service.deleteComponentVersion(namespace, componentName, '2.0.0');
+
+      expect(fsExtra.pathExistsSync(compVersionDestination)).toEqual(false);
+      const componentVersionObj2 = await db.repositories.componentVersion.getComponentByNameAndVersion(
+        `${namespace}/${componentName}`,
+        '2.0.0',
+      );
+      expect(componentVersionObj2).toEqual(undefined);
+    }, 15_000);
+
+    it('should clean up temp location after save', async () => {
+      expect(fsExtra.pathExistsSync(componentTempLocation)).toEqual(false);
+    });
+  });
+
+  describe('deleteComponentVersion', () => {
+    let componentName = '';
+    let componentTempLocation = '';
+    const componentVersion = '1.0.0';
+
+    async function createComponentAtTempLocation(componentTempLocation: string, version: string) {
+      const componentName = path.basename(componentTempLocation);
+
+      const newComponent = createPackage(namespace, path.basename(componentTempLocation), version);
+      await newComponent.finalize();
+      await newComponent.pipe(unzipper.Extract({ path: componentTempLocation })).promise();
+
+      return componentName;
+    }
+
+    beforeAll(async () => {
+      componentTempLocation = await TestHelpers.ComponentFixture.createFixtureDirectory();
+      componentName = await createComponentAtTempLocation(componentTempLocation, componentVersion);
+      await service.saveComponent(componentTempLocation);
+    }, 15_000);
+
+    afterAll(async () => {
+      if (fsExtra.pathExistsSync(componentTempLocation)) {
+        fsExtra.rmSync(componentTempLocation, { force: true, recursive: true });
+      }
+      await service.deleteComponent(namespace, componentName);
+    }, 15_000);
+
+    it('should throw error when deleting the invalid version component value', async () => {
+      await expect(
+        service.deleteComponentVersion(namespace, componentName, '../other/3.0.0'),
+      ).rejects.toThrowErrorMatchingInlineSnapshot('"Component version ../other/3.0.0 is invalid"');
+    }, 15_000);
+
+    it('should throw error when deleting the version component that does not exist', async () => {
+      await expect(
+        service.deleteComponentVersion(namespace, componentName, '3.0.0'),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Component version 3.0.0 for component ${namespace}/${componentName} not found"`,
+      );
+    }, 15_000);
+
+    it('should throw error when deleting the version component on component that does not exist', async () => {
+      await expect(
+        service.deleteComponentVersion(namespace, 'foo', '3.0.0'),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`"Component ${namespace}/foo not found"`);
+    }, 15_000);
+  });
+
+  describe('getPaginatedComponents', () => {
+    const compName1 = `name-space-x/${randomUUID()}`;
+    const compName2 = `name-space-y/${randomUUID()}`;
+
+    beforeAll(async () => {
+      await db.repositories.component.create({ name: compName1 });
+      await db.repositories.componentVersion.create({
+        componentName: compName1,
+        description: 'my description',
+        displayName: 'my comp',
+        version: '1.0.0',
+        icon: undefined,
+      });
+      await db.repositories.componentVersion.create({
+        componentName: compName1,
+        description: 'my description 2',
+        displayName: 'my comp',
+        version: '2.0.0',
+        icon: {
+          id: 'child_friendly',
+          color: { type: 'enum', value: 'orange' },
+        },
+      });
+
+      await db.repositories.component.create({ name: compName2 });
+      await db.repositories.componentVersion.create({
+        componentName: compName2,
+        description: 'comp 2',
+        displayName: 'my other comp',
+        version: '1.0.0',
+        icon: undefined,
+      });
+      await db.repositories.componentVersion.create({
+        componentName: compName2,
+        description: 'comp 2 - 2',
+        displayName: 'my other comp',
+        version: '2.3.5',
+        icon: {
+          id: '123',
+          color: { type: 'enum', value: 'green' },
+        },
+      });
+    });
+
+    afterAll(async () => {
+      await db.repositories.component.delete({ name: compName1 });
+      await db.repositories.component.delete({ name: compName2 });
+    });
+
+    it('should return a paginated list with the components by their highest version', async () => {
+      const initResult = await service.getPaginatedComponents();
+      let foundComponents = 0;
+
+      for (let i = 1; i <= initResult.pageInfo.totalPages; i++) {
+        const result = await service.getPaginatedComponents(i);
+
+        const pageComponents = result.items;
+
+        pageComponents.forEach((component) => {
+          if (component.name === compName1) {
+            expect(component.latestVersion.version).toEqual('2.0.0');
+            foundComponents++;
+          } else if (component.name === compName2) {
+            expect(component.latestVersion.version).toEqual('2.3.5');
+            foundComponents++;
+          }
+        });
+      }
+
+      expect(foundComponents).toEqual(2);
+    }, 60_000);
+
+    it('should return a paginated list based on the page size', async () => {
+      const result = await service.getPaginatedComponents(1, [], 'asc', 2);
+
+      expect(result.items).toHaveLength(2);
+    }, 60_000);
+
+    it('should return a paginated list based on the search field string', async () => {
+      const result = await service.getPaginatedComponents(1, [], 'asc', 10, {
+        componentName: 'space-x',
+      });
+
+      expect(result.items).toHaveLength(1);
+    }, 60_000);
+  });
+});