@squiz/job-runner-lib 1.66.1

package/src/domains/manifest/services/AbstractManifestService.spec.ts

@@ -0,0 +1,427 @@
+import { AbstractManifestService } from './AbstractManifestService';
+
+import path from 'path';
+import { ManifestValidationError } from '../errors/ManifestValidationError';
+import { ResourceNotFoundError } from '@squiz/dx-common-lib';
+import { Manifest } from '../ManifestModel';
+import { getLogger } from '@squiz/dx-logger-lib';
+
+class TestAbstractManifestService extends AbstractManifestService {
+  async listAllComponentManifests(): Promise<Manifest[]> {
+    return [];
+  }
+
+  async getManifestPath(namespace: string, componentName: string, version: string): Promise<string> {
+    return path.join(
+      __dirname,
+      '..',
+      '..',
+      '..',
+      '..',
+      '..',
+      '..',
+      'test-components',
+      namespace,
+      componentName,
+      version,
+      'manifest.json',
+    );
+  }
+}
+
+describe('AbstractManifestService', () => {
+  const service = new TestAbstractManifestService(getLogger({ name: 'AbstractManifestService' }));
+
+  describe('v1', () => {
+    it('should be able to load a component manifest', async () => {
+      const manifest = await service.loadManifest('unit-test-components', 'test-component', '1.0.0');
+      expect(manifest.getName()).toEqual('unit-test-components/test-component');
+      expect(manifest.getVersion()).toEqual('1.0.0');
+      expect(manifest.getSchemaVersion()).toEqual('v1');
+      expect(manifest.getModel()).toMatchInlineSnapshot(`
+        {
+          "$schema": "http://localhost:3000/schemas/v1.json#",
+          "description": "some-description",
+          "displayName": "some-display-name",
+          "functions": [
+            {
+              "entry": "main.js",
+              "input": {
+                "properties": {
+                  "something": {
+                    "type": "string",
+                  },
+                },
+                "required": [
+                  "something",
+                ],
+                "type": "object",
+              },
+              "name": "main",
+              "output": {
+                "responseType": "html",
+              },
+            },
+            {
+              "entry": "promise.js",
+              "input": {
+                "properties": {
+                  "something": {
+                    "type": "string",
+                  },
+                },
+                "required": [
+                  "something",
+                ],
+                "type": "object",
+              },
+              "name": "promise-func",
+              "output": {
+                "responseType": "html",
+              },
+            },
+          ],
+          "mainFunction": "main",
+          "name": "test-component",
+          "namespace": "unit-test-components",
+          "previews": {
+            "preview1": {
+              "functionData": {
+                "main": {
+                  "inputData": {
+                    "type": "inline",
+                    "value": {
+                      "something": "something",
+                    },
+                  },
+                },
+              },
+            },
+          },
+          "version": "1.0.0",
+        }
+      `);
+    });
+
+    it("should throw a ManifestNotFound error if component doesn't exist", async () => {
+      await expect(service.loadManifest('unit-test-components', 'test-not-real', '1.0.0')).rejects.toThrowError(
+        new ManifestValidationError(`manifest for unit-test-components/test-not-real 1.0.0 could not be found`),
+      );
+    });
+
+    describe('validation rules', () => {
+      it('should ensure the $schema is valid', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-component', '1.0.2')).rejects.toThrowError(
+          new ManifestValidationError(
+            'Could not determine manifest version. Your manifest must have a $schema property defined.',
+          ),
+        );
+      });
+
+      it('should return a validation error when the component has inaccessible entry file', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-component', '1.0.3')).rejects.toThrowError(
+          new ManifestValidationError('"main\'s" entry file "missing-entry-file.js" is inaccessible'),
+        );
+      });
+
+      it('should throw an error if the main functions does not exist', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-component', '1.0.5')).rejects.toThrowError(
+          new ManifestValidationError('"test-component 1.0.5" main function could not be found in function list'),
+        );
+      });
+
+      it('should throw an error if entry file trying to access outside the entry point', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-component', '1.0.6')).rejects.toThrowError(
+          new ManifestValidationError(
+            'access to component "file-accessing-outside-parent-func\'s" entry file "../1.0.4/render-json.js" outside the parent directory in "test-component 1.0.6" is not allowed',
+          ),
+        );
+      });
+
+      it('should throw an error if component has invalid name', async () => {
+        await expect(
+          service.loadManifest('unit-test-components', 'test-component', '1.1.1'),
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"failed validation: Value in \`#/functions/0/name\` should match \`^[a-z][a-z0-9_\\-]+$\`, but received \`invalid-function-name-!!!!\`"`,
+        );
+      });
+
+      it('should throw an error if component defined static files in function but has no static-root defined', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.6')).rejects.toThrowError(
+          new ManifestValidationError(
+            'function main defines static files but manifest has no staticFiles.locationRoot defined',
+          ),
+        );
+      });
+
+      it('should throw an error if component defined static files in function are not all absolute paths but has no static-root defined', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.5')).rejects.toThrowError(
+          new ManifestValidationError(
+            'function main defines static files but manifest has no staticFiles.locationRoot defined',
+          ),
+        );
+      });
+
+      it('should not throw an error if component defined static files in function are all absolute paths and has no static-root defined', async () => {
+        const manifestPath = path.resolve(
+          `${process.env.DATA_MOUNT_POINT}/unit-test-components/test-static-files/1.0.7/manifest.json`,
+        );
+
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.7')).resolves
+          .toMatchInlineSnapshot(`
+          ManifestV1 {
+            "manifest": {
+              "$schema": "http://localhost:3000/schemas/v1.json#",
+              "description": "some-description",
+              "displayName": "some-display-name",
+              "functions": [
+                {
+                  "entry": "main.js",
+                  "input": {},
+                  "name": "main",
+                  "output": {
+                    "responseType": "html",
+                    "staticFiles": [
+                      {
+                        "file": {
+                          "filepath": "https://cdn.tailwindcss.com",
+                          "type": "js",
+                        },
+                        "location": "header",
+                      },
+                    ],
+                  },
+                },
+              ],
+              "mainFunction": "main",
+              "name": "test-static-files",
+              "namespace": "unit-test-components",
+              "version": "1.0.7",
+            },
+            "manifestPath": "${manifestPath}",
+          }
+        `);
+      });
+
+      it('should throw an error if component has both a static file with absolute path and a relative path but has no static-root defined', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.8')).rejects.toThrowError(
+          new ManifestValidationError(
+            'function main defines static files but manifest has no staticFiles.locationRoot defined',
+          ),
+        );
+      });
+
+      // static files
+      it("should throw an error if fuction's static file is trying to access outside of root", async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.4')).rejects.toThrowError(
+          new ManifestValidationError(
+            'access to a static file "../../static-files-library/static-library-file.js" for "main" outside the parent directory in "test-static-files 1.0.4" is not allowed',
+          ),
+        );
+      });
+
+      it('should throw an error if static root is trying to access outside of root', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.3')).rejects.toThrowError(
+          new ManifestValidationError(
+            'access to a static file locationRoot outside the parent directory in "test-static-files 1.0.3" is not allowed',
+          ),
+        );
+      });
+
+      it("should throw an error if static root is defined but doesn't exist on disk", async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-static-files', '1.0.2')).rejects.toThrowError(
+          new ManifestValidationError(
+            '"main\'s" static file "static-files-library/static-file-does-not-exist.js" is inaccessible',
+          ),
+        );
+      });
+
+      it('should load a manifest containing an icon with valid properties color is enum', async () => {
+        const manifest = await service.loadManifest('unit-test-components', 'test-icon-component', '1.0.0');
+        expect(manifest.getModel().icon).toEqual({ id: 'add_box', color: { type: 'enum', value: 'gray' } });
+      });
+
+      it('should load a manifest containing an icon with valid properties color is hex', async () => {
+        const manifest = await service.loadManifest('unit-test-components', 'test-icon-component', '1.0.3');
+        const expectedResult = {
+          color: {
+            type: 'hex',
+            value: '#2D2D2D',
+          },
+          id: 'zoom_in',
+        };
+        expect(manifest.getModel().icon).toEqual(expectedResult);
+      });
+
+      it('should throw an error when loading manifest containing an icon with invalid properties', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-icon-component', '1.0.1')).rejects
+          .toThrowErrorMatchingInlineSnapshot(`
+          "failed validation: Expected given value \`not_a_valid_id\` in #/icon/id\` to be one of \`[10k, 10mp, 11mp, 123, 12mp, ... 2233 more]\`,
+          Value \`{"type":"hex","value":"(255,255,255)"}\` in \`#/icon/color\` does not match any given oneof schema"
+        `);
+      });
+
+      it('should throw an error when loading manifest containing an icon missing required properties', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-icon-component', '1.0.2')).rejects
+          .toThrowErrorMatchingInlineSnapshot(`
+          "failed validation: Expected given value \`not_a_valid_id\` in #/icon/id\` to be one of \`[10k, 10mp, 11mp, 123, 12mp, ... 2233 more]\`,
+          The required property \`color\` is missing at \`#/icon\`"
+        `);
+      });
+
+      it('should throw error if preview data is not valid', async () => {
+        await expect(service.loadManifest('unit-test-components', 'test-preview-component', '1.0.0')).rejects
+          .toThrowErrorMatchingInlineSnapshot(`
+          "Invalid preview data for preview "invalid-preview-data": failed validation: Expected \`not-an-integer\` (string) in \`#/integerValue\` to be of type \`number\`,
+          The required property \`nested\` is missing at \`#\`"
+        `);
+      });
+
+      it('should throw error if mocked URI data is not valid', async () => {
+        await expect(
+          service.loadManifest('unit-test-components', 'test-preview-component', '1.1.2'),
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Mocked URI object file "./non-existent-uri.json" does not exist"`,
+        );
+      });
+
+      it('should not throw error if checking a specific function that is valid in otherwise invalid manifset', async () => {
+        // note that this test scenario cannot happen in prod as one cannot deploy an invalid manifest
+        // this test just ensures that loading manifest with "validateFunction" validation option
+        // will just validate the bits specific to the given function
+        await expect(
+          service.loadManifest('unit-test-components', 'test-component', '1.2.0'),
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Invalid preview data for preview "test-preview": failed validation: The required property \`something\` is missing at \`#\`"`,
+        );
+
+        // now try loading again with "validateFunction" validation option
+        // this manifest bits relevant to this function are valid
+        const manifest = await service.loadManifest('unit-test-components', 'test-component', '1.2.0', {
+          validateFunction: 'other',
+        });
+        expect(manifest.getName()).toEqual('unit-test-components/test-component');
+        expect(manifest.getVersion()).toEqual('1.2.0');
+      });
+
+      it('should handle protected namespaces with validation options', async () => {
+        const manifest = await service.loadManifest('unit-test-components', 'test-component', '1.4.0');
+        expect(manifest.getModel().namespace).toEqual('squiz');
+
+        await expect(
+          service.loadManifest('unit-test-components', 'test-component', '1.4.0', { validateNamespace: true }),
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Namespace "squiz" is protected. You need to be a member of Squiz organisation and be logged into npm in order to use that namespace."`,
+        );
+      });
+    });
+
+    describe('readManifest', () => {
+      it('should read and validate a manifest from a file path', async () => {
+        const p = path.join(
+          __dirname,
+          '../../../../../..',
+          'test-components/unit-test-components/test-component/1.0.0/manifest.json',
+        );
+
+        await expect(service.readManifest(p)).resolves.toThrowErrorMatchingInlineSnapshot(`undefined`);
+      });
+
+      it("should throw a ResourceNotFoundError error if manifest doesn't exist", async () => {
+        const p = path.join(
+          __dirname,
+          '../../../../../..',
+          'test-components/unit-test-components/not-real/manifest.json',
+        );
+
+        await expect(service.readManifest(p)).rejects.toThrowError(
+          new ResourceNotFoundError(`manifest could not be found`),
+        );
+      });
+    });
+  });
+  describe('JobV1', () => {
+    it('should read and validate a job manifest from a file path', async () => {
+      const p = path.join(__dirname, '../../../../../..', 'test-jobs/unit-test-jobs/test-job/1.0.0/manifest.json');
+      const res = await service.readJobManifest(p);
+
+      expect(res).toMatchInlineSnapshot(`
+      JobManifestV1 {
+        "manifest": {
+          "$schema": "http://localhost:3040/schemas/JobV1.json#",
+          "concurrency": 2,
+          "description": "some-description",
+          "displayName": "Test Job",
+          "functions": [
+            {
+              "entry": "main.js",
+              "input": {
+                "properties": {
+                  "something": {
+                    "type": "string",
+                  },
+                },
+                "required": [
+                  "something",
+                ],
+                "type": "object",
+              },
+              "name": "main",
+            },
+            {
+              "entry": "promise.js",
+              "input": {
+                "properties": {
+                  "something": {
+                    "type": "string",
+                  },
+                },
+                "required": [
+                  "something",
+                ],
+                "type": "object",
+              },
+              "name": "promise-func",
+            },
+          ],
+          "mainFunction": "main",
+          "name": "test-job",
+          "timeout": 600,
+          "version": "1.0.0",
+        },
+        "manifestPath": "${p}",
+      }
+    `);
+    });
+
+    it("should throw a ResourceNotFoundError error if manifest doesn't exist", async () => {
+      const p = path.join(__dirname, '../../../../../..', 'test-jobs/unit-test-jobs/not-real/manifest.json');
+
+      await expect(service.readJobManifest(p)).rejects.toThrowError(
+        new ResourceNotFoundError(`manifest could not be found`),
+      );
+    });
+    it("should error if manifest doesn't meet schema version", async () => {
+      const p = path.join(
+        __dirname,
+        '../../../../../..',
+        'test-jobs/unit-test-jobs/invalid-schema-job/1.0.0/manifest.json',
+      );
+
+      await expect(service.readJobManifest(p)).rejects.toThrowError(
+        new ManifestValidationError(`Could not determine manifest version from $schema value.`),
+      );
+    });
+  });
+  it('should error if manifest is invalid', async () => {
+    const p = path.join(
+      __dirname,
+      '../../../../../..',
+      'test-jobs/unit-test-jobs/invalid-manifest-job/1.0.0/manifest.json',
+    );
+
+    await expect(service.readJobManifest(p)).rejects.toThrowError(
+      new ManifestValidationError('failed validation: The required property `concurrency` is missing at `#`'),
+    );
+  });
+});