@squiz/job-runner-lib 1.66.2 → 2.1.0

package/lib/domains/component-set/services/ComponentSetServiceForProduction.integration.spec.js

@@ -1,2565 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const unzipper_1 = __importDefault(require("unzipper"));
-const fs_1 = __importDefault(require("fs"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const dx_logger_lib_1 = require("@squiz/dx-logger-lib");
-const db_1 = require("../../db");
-const ComponentSetServiceForProduction_1 = require("./ComponentSetServiceForProduction");
-const ComponentService_1 = require("../../component/services/ComponentService");
-const createPackage_1 = require("../../__test__/createPackage");
-const manifest_1 = require("../../manifest");
-const crypto_1 = require("crypto");
-const loadAllUnitTestComponents_1 = require("../../__test__/loadAllUnitTestComponents");
-const ComponentSetComponentVersion_1 = require("../models/ComponentSetComponentVersion");
-describe('ComponentSetServiceForProduction', () => {
-    let db;
-    const logger = (0, dx_logger_lib_1.getLogger)({
-        name: 'component-lib',
-    });
-    let service;
-    let componentService;
-    let manifestService;
-    const mockInfo = jest.fn();
-    const mockFlush = jest.fn();
-    const componentLoggingService = { info: mockInfo, flush: mockFlush };
-    const namespace = 'unit-test-components';
-    let componentTempLocation1 = '';
-    let componentTempLocation2 = '';
-    async function createComponentAtTempLocation(componentTempLocation, componentName, version) {
-        const newComponent = (0, createPackage_1.createPackage)(namespace, componentName, version);
-        await newComponent.finalize();
-        await newComponent.pipe(unzipper_1.default.Extract({ path: componentTempLocation })).promise();
-    }
-    beforeAll(async () => {
-        db = await (0, db_1.createConnectionManager)('management-api-test', {
-            databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING,
-        }, '');
-        await db.applyMigrations();
-        manifestService = new manifest_1.ManifestServiceForProduction(process.env.DATA_MOUNT_POINT, logger);
-        await (0, loadAllUnitTestComponents_1.loadAllUnitTestComponents)(process.env.DATA_MOUNT_POINT, db, manifestService);
-        service = new ComponentSetServiceForProduction_1.ComponentSetServiceForProduction(db, logger, manifestService, componentLoggingService);
-        componentService = new ComponentService_1.ComponentService(db, console, process.env.DATA_MOUNT_POINT, manifestService);
-        await db.repositories.component.delete({ name: 'foo' });
-        // create two versions for a test component "foo"
-        // for all the tests
-        componentTempLocation1 = fs_1.default.mkdtempSync('test1-');
-        await createComponentAtTempLocation(componentTempLocation1, 'foo', '1.0.0');
-        await componentService.saveComponent(componentTempLocation1);
-        componentTempLocation2 = fs_1.default.mkdtempSync('test2-');
-        await createComponentAtTempLocation(componentTempLocation2, 'foo', '2.0.0');
-        await componentService.saveComponent(componentTempLocation2);
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    afterAll(async () => {
-        if (fs_extra_1.default.pathExistsSync(componentTempLocation1)) {
-            fs_extra_1.default.rmSync(componentTempLocation1, { force: true, recursive: true });
-        }
-        if (fs_extra_1.default.pathExistsSync(componentTempLocation2)) {
-            fs_extra_1.default.rmSync(componentTempLocation2, { force: true, recursive: true });
-        }
-        await componentService.deleteComponent(namespace, 'foo');
-        await db.close();
-    });
-    describe('addComponentSet', () => {
-        const webPath = 'set-web-path';
-        const testWebPaths = ['set-web-path'];
-        afterAll(async () => {
-            for (const webPath of testWebPaths) {
-                await db.repositories.componentSet.delete({ webPath });
-                await db.repositories.componentSetComponentVersion.delete({ componentSetWebPath: webPath });
-            }
-        });
-        it('should create new component set with all the data in the respective tables and return component object', async () => {
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^1.0.0',
-                        excludedVersions: ['2.2.2', '3.3.3'],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            expect(componentSet).toEqual({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                            description: 'some-description',
-                            displayName: 'some-display-name',
-                            icon: undefined,
-                            editable: true,
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^1.0.0',
-                        excludedVersions: ['3.3.3', '2.2.2'],
-                        editableVersions: ['2.0.0', '1.0.0'],
-                    },
-                },
-            });
-            const csResult = await db.repositories.componentSet.getComponentSetByWebPath(webPath);
-            expect(csResult).toEqual({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-            });
-            const cscvResult = await db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
-            expect(cscvResult).toHaveLength(1);
-            expect(cscvResult[0]).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '1.0.0',
-                environmentVariables: {
-                    'some-var': 'some-custom-var',
-                },
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active,
-            });
-            await expect(db.repositories.componentSetRule.getComponentSetRulesForSet(webPath)).resolves.toEqual({
-                'unit-test-components/foo': '^1.0.0',
-            });
-            await expect(db.repositories.componentSetComponentVersionExcluded.getComponentSetExcludedVersions(webPath)).resolves.toEqual({
-                'unit-test-components/foo': ['3.3.3', '2.2.2'],
-            });
-            await expect(db.repositories.componentSetComponentVersionEditable.getComponentSetEditableVersions(webPath)).resolves.toEqual({
-                'unit-test-components/foo': ['2.0.0', '1.0.0'],
-            });
-            await expect(service.componentVersionExcludedFromSet(webPath, 'unit-test-components/foo', '2.2.2')).resolves.toEqual(true);
-            await expect(service.componentVersionExcludedFromSet(webPath, 'unit-test-components/foo', '3.3.3')).resolves.toEqual(true);
-            await expect(service.componentVersionExcludedFromSet(webPath, 'unit-test-components/foo', '1.0.0')).resolves.toEqual(false);
-            expect(mockInfo).toHaveBeenCalledWith('Component set added: set-web-path.', undefined, undefined, 'componentSetId:set-web-path');
-            expect(mockFlush).toHaveBeenCalled();
-        }, 15000);
-        it('should add components automatically matching component rules', async () => {
-            const webPath = 'set-web-path-2';
-            testWebPaths.push('set-web-path-2');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0 || 2.0.0',
-                        excludedVersions: [],
-                        editableVersions: ['2.0.0', '1.0.0'],
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [
-                "2.0.0",
-                "1.0.0",
-              ],
-              "excludedVersions": [],
-              "renderableVersionPattern": "1.0.0 || 2.0.0",
-            },
-          },
-          "components": {
-            "unit-test-components/foo": [
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": true,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "2.0.0",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": true,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "1.0.0",
-              },
-            ],
-          },
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-2",
-        }
-      `);
-        }, 15000);
-        it('should not add any components of renderable version rule is set as empty string', async () => {
-            const webPath = 'set-web-path-empty-renderable-rule';
-            testWebPaths.push('set-web-path-empty-renderable-rule');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '',
-                        excludedVersions: [],
-                        editableVersions: ['2.0.0', '1.0.0'],
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [
-                "2.0.0",
-                "1.0.0",
-              ],
-              "excludedVersions": [],
-              "renderableVersionPattern": "",
-            },
-          },
-          "components": {},
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-empty-renderable-rule",
-        }
-      `);
-        }, 15000);
-        it('should should all component versions as non-editable if editable rule not specified', async () => {
-            const webPath = 'set-web-path-edit';
-            testWebPaths.push('set-web-path-edit');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0 || 2.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [],
-              "excludedVersions": [],
-              "renderableVersionPattern": "1.0.0 || 2.0.0",
-            },
-          },
-          "components": {
-            "unit-test-components/foo": [
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "2.0.0",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "1.0.0",
-              },
-            ],
-          },
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-edit",
-        }
-      `);
-        }, 15000);
-        it('should set latest version in add components as "editable" if editable rule is set as "latest"', async () => {
-            const webPath = 'set-web-path-edit-4';
-            testWebPaths.push('set-web-path-edit-4');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0 || 2.0.0',
-                        excludedVersions: [],
-                        editableVersions: 'latest',
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [
-                "latest",
-              ],
-              "excludedVersions": [],
-              "renderableVersionPattern": "1.0.0 || 2.0.0",
-            },
-          },
-          "components": {
-            "unit-test-components/foo": [
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": true,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "2.0.0",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "1.0.0",
-              },
-            ],
-          },
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-edit-4",
-        }
-      `);
-        }, 15000);
-        it('should set latest version in add components as "editable" if not editable rule is set as "latest" - with excluded version specified', async () => {
-            const webPath = 'set-web-path-edit-2';
-            testWebPaths.push('set-web-path-edit-2');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0 || 2.0.0',
-                        excludedVersions: ['2.0.0'],
-                        editableVersions: 'latest',
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [
-                "latest",
-              ],
-              "excludedVersions": [
-                "2.0.0",
-              ],
-              "renderableVersionPattern": "1.0.0 || 2.0.0",
-            },
-          },
-          "components": {
-            "unit-test-components/foo": [
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": true,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "1.0.0",
-              },
-            ],
-          },
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-edit-2",
-        }
-      `);
-        }, 15000);
-        it('should add components automatically matching component rules but should not add "excluded" ones', async () => {
-            const webPath = 'set-web-path-3';
-            testWebPaths.push('set-web-path-3');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0 || 2.0.0',
-                        excludedVersions: ['1.0.0', '2.2.2'],
-                        editableVersions: [],
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [],
-              "excludedVersions": [
-                "2.2.2",
-                "1.0.0",
-              ],
-              "renderableVersionPattern": "1.0.0 || 2.0.0",
-            },
-          },
-          "components": {
-            "unit-test-components/foo": [
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "2.0.0",
-              },
-            ],
-          },
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-3",
-        }
-      `);
-        }, 15000);
-        it('should not be case-sensitive when finding component set', async () => {
-            await expect(service.getComponentSet(webPath.toUpperCase())).resolves.toEqual(await service.getComponentSet(webPath));
-        });
-        it('should throw error if creating duplicate component set', async () => {
-            await expect(service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Component set with web path set-web-path already exists"`);
-        }, 15000);
-        it('should throw error webPath is empty', async () => {
-            await expect(service.addComponentSet({
-                webPath: '',
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Component set \'webPath\' must be specificed and non-empty"');
-        }, 15000);
-        it('should throw error webPath has invalid chars', async () => {
-            await expect(service.addComponentSet({
-                webPath: 'invali@d-name',
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Invalid Component Set web path. Only [A-Za-z0-9_-.] chars are allowed"');
-        }, 15000);
-        it('should throw error if component name does not exist', async () => {
-            await expect(service.addComponentSet({
-                webPath: 'some-other-webpath',
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo2': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Component unit-test-components/foo2 with version 1.0.0 does not exists"');
-        }, 15000);
-        it('should throw error if component version does not exist', async () => {
-            await expect(service.addComponentSet({
-                webPath: 'some-other-webpath',
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.1.1',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Component unit-test-components/foo with version 1.1.1 does not exists"');
-        }, 15000);
-        it('should throw error if duplicate component versions in components', async () => {
-            await expect(service.addComponentSet({
-                webPath: (0, crypto_1.randomUUID)(),
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                        },
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var2': 'some-custom-var2',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Multiple componet version entries for component unit-test-components/foo with version 1.0.0"`);
-        }, 15000);
-        it('should error if added component does not satisfy componentVersionRules', async () => {
-            await expect(service.addComponentSet({
-                webPath: (0, crypto_1.randomUUID)(),
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^2.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Component versions must satisfy version rule"`);
-        });
-    });
-    describe('updateComponentSet', () => {
-        const webPath = 'set-web-path';
-        beforeAll(async () => {
-            await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-        });
-        afterAll(async () => {
-            await db.repositories.componentSet.delete({ webPath });
-            await db.repositories.componentSetComponentVersion.delete({ componentSetWebPath: webPath });
-        });
-        it('should update existing component set with all the data in the respective tables and return component object', async () => {
-            const componentSet = await service.updateComponentSet(webPath, {
-                displayName: 'some-display-name - updated',
-                description: 'some-description - updated',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                    'some-var2': 'some-val2',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val - updated',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['2.2.2', '3.3.3'],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            expect(componentSet).toEqual({
-                webPath: webPath,
-                displayName: 'some-display-name - updated',
-                description: 'some-description - updated',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                    'some-var2': 'some-val2',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val - updated',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '2.0.0',
-                            environmentVariables: {},
-                            description: 'some-description',
-                            displayName: 'some-display-name',
-                            icon: undefined,
-                            editable: true,
-                        },
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                            description: 'some-description',
-                            displayName: 'some-display-name',
-                            icon: undefined,
-                            editable: true,
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['3.3.3', '2.2.2'],
-                        editableVersions: ['2.0.0', '1.0.0'],
-                    },
-                },
-            });
-            const csResult = await db.repositories.componentSet.getComponentSetByWebPath(webPath);
-            expect(csResult).toEqual({
-                webPath: webPath,
-                displayName: 'some-display-name - updated',
-                description: 'some-description - updated',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                    'some-var2': 'some-val2',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val - updated',
-                },
-            });
-            const cscvResult = await db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
-            expect(cscvResult).toHaveLength(2);
-            const versionV1 = cscvResult.find((result) => result.componentVersion === '1.0.0');
-            const versionV2 = cscvResult.find((result) => result.componentVersion === '2.0.0');
-            expect(versionV2).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '2.0.0',
-                environmentVariables: {},
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active,
-            });
-            expect(versionV1).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '1.0.0',
-                environmentVariables: {
-                    'some-var': 'some-custom-var',
-                },
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active,
-            });
-            await expect(db.repositories.componentSetRule.find({ componentSet: webPath })).resolves.toEqual([
-                { componentSet: webPath, componentName: 'unit-test-components/foo', versionPattern: '*' },
-            ]);
-            await expect(db.repositories.componentSetComponentVersionExcluded.getComponentSetExcludedVersions(webPath)).resolves.toEqual({
-                'unit-test-components/foo': ['3.3.3', '2.2.2'],
-            });
-            await expect(db.repositories.componentSetComponentVersionEditable.getComponentSetEditableVersions(webPath)).resolves.toEqual({
-                'unit-test-components/foo': ['2.0.0', '1.0.0'],
-            });
-            expect(mockInfo).toHaveBeenCalledWith(`Component set updated: "set-web-path". Changed from {"unit-test-components/foo":[{"version":"1.0.0","description":"some-description","displayName":"some-display-name","editable":false}]} to {"unit-test-components/foo":[{"version":"2.0.0","description":"some-description","displayName":"some-display-name","editable":true},{"version":"1.0.0","description":"some-description","displayName":"some-display-name","editable":true}]}.`, undefined, undefined, 'componentSetId:set-web-path ');
-            expect(mockFlush).toHaveBeenCalled();
-        }, 15000);
-        it('should log the change to the component if the component itself was changed', async () => {
-            const webPath = 'newpath';
-            await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-            await service.updateComponentSet(webPath, {
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var - updated',
-                            },
-                        },
-                    ],
-                },
-            });
-            expect(mockInfo).toHaveBeenCalledWith(`Component set updated: "${webPath}". Changed from ${JSON.stringify({
-                'unit-test-components/foo': [
-                    {
-                        version: '1.0.0',
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        editable: false,
-                    },
-                ],
-            })} to ${JSON.stringify({
-                'unit-test-components/foo': [
-                    {
-                        version: '1.0.0',
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        editable: false,
-                    },
-                ],
-            })}.`, undefined, undefined, 'componentSetId:newpath ');
-            expect(mockFlush).toHaveBeenCalled();
-        });
-        it('should set latest version as "editable" if editable rule not specified', async () => {
-            const componentSet = await service.updateComponentSet(webPath, {
-                displayName: 'some-display-name - updated',
-                description: 'some-description - updated',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                    'some-var2': 'some-val2',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val - updated',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['3.3.3', '2.2.2'],
-                        editableVersions: 'latest',
-                    },
-                },
-            });
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": false,
-              "environmentVariables": {
-                "some-var": "some-custom-var",
-              },
-              "icon": undefined,
-              "version": "1.0.0",
-            },
-          ],
-        }
-      `);
-        }, 15000);
-        it('should set latest version as "editable" if editable rule not specified - with latest "excluded"', async () => {
-            const componentSet = await service.updateComponentSet(webPath, {
-                displayName: 'some-display-name - updated',
-                description: 'some-description - updated',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                    'some-var2': 'some-val2',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val - updated',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['2.0.0'],
-                        editableVersions: 'latest',
-                    },
-                },
-            });
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {
-                "some-var": "some-custom-var",
-              },
-              "icon": undefined,
-              "version": "1.0.0",
-            },
-          ],
-        }
-      `);
-        }, 15000);
-        it('should make components in the set not active if componentVersionRule is updated to not include it', async () => {
-            const componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^2.0.0',
-                        excludedVersions: [],
-                        editableVersions: ['latest', '2.0.0', '1.1.1'],
-                    },
-                },
-            });
-            expect(componentSet.components).toEqual({
-                'unit-test-components/foo': [
-                    {
-                        version: '2.0.0',
-                        environmentVariables: {},
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        icon: undefined,
-                        editable: true,
-                    },
-                ],
-            });
-            const cscvResult = await db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
-            expect(cscvResult.find((c) => c.componentVersion === '1.0.0')).toHaveProperty('status', ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.excluded);
-            expect(cscvResult.find((c) => c.componentVersion === '2.0.0')).toHaveProperty('status', ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active);
-        });
-        it('should remove components from set if the componentVersionRule is removed', async () => {
-            const componentSet = await service.updateComponentSet(webPath, { componentVersionRules: {} });
-            expect(componentSet.components).toEqual({});
-            expect(componentSet.componentVersionRules).toEqual({});
-        });
-        it('should exclude the "excluded" component version from the set', async () => {
-            // this shouldn't exclude any of the components
-            // since "excluded" versions are not there
-            const componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['5.0.0', '3.3.3'],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {
-                "some-var": "some-custom-var",
-              },
-              "icon": undefined,
-              "version": "1.0.0",
-            },
-          ],
-        }
-      `);
-            const cscvResult = await db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
-            const versionV1 = cscvResult.find((result) => result.componentVersion === '1.0.0');
-            const versionV2 = cscvResult.find((result) => result.componentVersion === '2.0.0');
-            expect(versionV2).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '2.0.0',
-                environmentVariables: {},
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active,
-            });
-            expect(versionV1).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '1.0.0',
-                environmentVariables: {
-                    'some-var': 'some-custom-var',
-                },
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active,
-            });
-            // this should exclude "1.0.0" version
-            const componentSet2 = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['1.0.0', '3.3.3'],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            expect(componentSet2.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-          ],
-        }
-      `);
-            const cscvResult_2 = await db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
-            const versionV1_2 = cscvResult_2.find((result) => result.componentVersion === '1.0.0');
-            const versionV2_2 = cscvResult_2.find((result) => result.componentVersion === '2.0.0');
-            expect(versionV2_2).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '2.0.0',
-                environmentVariables: {},
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.active,
-            });
-            expect(versionV1_2).toEqual({
-                componentSetWebPath: 'set-web-path',
-                componentName: 'unit-test-components/foo',
-                componentVersion: '1.0.0',
-                environmentVariables: {
-                    'some-var': 'some-custom-var',
-                },
-                status: ComponentSetComponentVersion_1.ComponentSetComponentVersionStatus.excluded,
-            });
-        }, 15000);
-        it('should retain the existing env vars data even after being "excluded" from the set', async () => {
-            let componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['1.0.0'],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-          ],
-        }
-      `);
-            componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: [],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            // env var set in "1.0.0" is still there
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {
-                "some-var": "some-custom-var",
-              },
-              "icon": undefined,
-              "version": "1.0.0",
-            },
-          ],
-        }
-      `);
-        }, 15000);
-        it('should retain the existing env vars data even after being "excluded" from the set - via rules', async () => {
-            let componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '2.0.0',
-                        excludedVersions: [],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-          ],
-        }
-      `);
-            componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: [],
-                        editableVersions: ['1.0.0', '2.0.0'],
-                    },
-                },
-            });
-            // env var set in "1.0.0" is still there
-            expect(componentSet.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {},
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": true,
-              "environmentVariables": {
-                "some-var": "some-custom-var",
-              },
-              "icon": undefined,
-              "version": "1.0.0",
-            },
-          ],
-        }
-      `);
-        }, 15000);
-        it('should throw error if added componentVersion does not satisfy existing componentVersionRules', async () => {
-            const componentSet = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-                components: { 'unit-test-components/foo': [{ version: '1.0.0', environmentVariables: {} }] },
-            });
-            const componentVersions = [
-                ...componentSet.components['unit-test-components/foo'],
-                {
-                    version: '2.0.0',
-                    environmentVariables: {},
-                },
-            ];
-            await expect(service.updateComponentSet(webPath, {
-                components: {
-                    'unit-test-components/foo': componentVersions,
-                },
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Component versions must satisfy version rule"`);
-        });
-        it('should allow setting componentVersion env vars if it satisfies added componentVersionRules in same update', async () => {
-            await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-            const result = await service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var-1',
-                            },
-                        },
-                        {
-                            version: '2.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-custom-var-2',
-                            },
-                        },
-                    ],
-                },
-            });
-            expect(result.components).toMatchInlineSnapshot(`
-        {
-          "unit-test-components/foo": [
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": false,
-              "environmentVariables": {
-                "some-var": "some-custom-var-2",
-              },
-              "icon": undefined,
-              "version": "2.0.0",
-            },
-            {
-              "description": "some-description",
-              "displayName": "some-display-name",
-              "editable": false,
-              "environmentVariables": {
-                "some-var": "some-custom-var-1",
-              },
-              "icon": undefined,
-              "version": "1.0.0",
-            },
-          ],
-        }
-      `);
-        });
-        it('should throw error if specified componentVersion does not satisfy a new componentVersionRule', async () => {
-            const version = [
-                {
-                    version: '2.0.0',
-                    environmentVariables: {},
-                },
-            ];
-            await expect(service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-                components: {
-                    'unit-test-components/foo': version,
-                },
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Component versions must satisfy version rule"`);
-        });
-        it('should throw error if component set web path does not exist', async () => {
-            await expect(service.updateComponentSet('idontexist', {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo2': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Component set with web path idontexist does not exist"');
-        }, 15000);
-        it('should throw error if component name does not exist', async () => {
-            await expect(service.updateComponentSet(webPath, {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo2': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Component unit-test-components/foo2 with version 1.0.0 does not exists"');
-        }, 15000);
-        it('should throw error if component version does not exist', async () => {
-            await expect(service.updateComponentSet(webPath, {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo2': [
-                        {
-                            version: '1.1.1',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Component unit-test-components/foo2 with version 1.1.1 does not exists"');
-        }, 15000);
-        it('should throw error if env var set on component version is not defined on the component set', async () => {
-            await expect(service.updateComponentSet(webPath, {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo2': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                'some-var': 'some-val',
-                                'some-other-var': 'some-val',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {},
-            })).rejects.toThrowErrorMatchingInlineSnapshot('"Env var(s) \'some-other-var\' defined on component unit-test-components/foo2 with version 1.0.0 is/are not defined on the component set"');
-        }, 15000);
-        it('should throw error if componentVersionRules has an invalid semver range', async () => {
-            await expect(service.updateComponentSet(webPath, {
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: 'abcd',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Invalid renderable component version semver value: abcd"`);
-        });
-        it('should throw error if the header name contains invalid characters', async () => {
-            await expect(service.updateComponentSet(webPath, {
-                headers: {
-                    'inv@lid-n@m3': 'value',
-                },
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Invalid 'header' name for 'inv@lid-n@m3'. Only [A-Za-z0-9_-.] chars are allowed"`);
-        });
-        it('should throw error if the header name contains whitespace', async () => {
-            await expect(service.updateComponentSet(webPath, {
-                headers: {
-                    'variable name': 'value',
-                },
-            })).rejects.toThrowErrorMatchingInlineSnapshot(`"Invalid 'header' name for 'variable name'. Only [A-Za-z0-9_-.] chars are allowed"`);
-        });
-    });
-    describe('getComponentSet', () => {
-        const webPath = 'set-web-path';
-        const setWithIconWebPath = (0, crypto_1.randomUUID)();
-        beforeAll(async () => {
-            await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-        });
-        afterAll(async () => {
-            await db.repositories.componentSet.delete({ webPath });
-            await db.repositories.componentSet.delete({ webPath: setWithIconWebPath });
-            await db.repositories.componentSetComponentVersion.delete({ componentSetWebPath: webPath });
-        });
-        it('should return the component set object', async () => {
-            const componentSet = await service.getComponentSetWebModel(webPath);
-            expect(componentSet).toEqual({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    'unit-test-components/foo': [
-                        {
-                            environmentVariables: {},
-                            version: '1.0.0',
-                            description: 'some-description',
-                            displayName: 'some-display-name',
-                            icon: undefined,
-                            editable: false,
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '^1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-        }, 15000);
-        it('should return the icon, displayName and description of each component version in the set', async () => {
-            const componentSetFromCreate = await service.addComponentSet({
-                webPath: setWithIconWebPath,
-                description: 'component set description',
-                displayName: 'test - ' + setWithIconWebPath,
-                componentVersionRules: {
-                    'unit-test-components/test-icon-component': {
-                        renderableVersionPattern: '1.0.0 || 1.0.3',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-            const expected = {
-                webPath: setWithIconWebPath,
-                description: 'component set description',
-                displayName: 'test - ' + setWithIconWebPath,
-                componentVersionRules: {
-                    'unit-test-components/test-icon-component': {
-                        renderableVersionPattern: '1.0.0 || 1.0.3',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-                environmentVariables: {},
-                headers: {},
-                components: {
-                    'unit-test-components/test-icon-component': [
-                        {
-                            version: '1.0.3',
-                            environmentVariables: {},
-                            description: 'test with hex icon colour',
-                            displayName: 'test icon component',
-                            icon: {
-                                color: {
-                                    type: 'hex',
-                                    value: '#2D2D2D',
-                                },
-                                id: 'zoom_in',
-                            },
-                            editable: false,
-                        },
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                            description: 'test icon component with enum colour',
-                            displayName: 'test icon component',
-                            icon: {
-                                color: {
-                                    type: 'enum',
-                                    value: 'gray',
-                                },
-                                id: 'add_box',
-                            },
-                            editable: false,
-                        },
-                    ],
-                },
-            };
-            expect(componentSetFromCreate).toEqual(expected);
-            const requestedSet = await service.getComponentSetWebModel(setWithIconWebPath);
-            expect(requestedSet).toEqual(expected);
-        }, 15000);
-        it('should throw error if component set web path does not exist', async () => {
-            await expect(service.getComponentSetWebModel('idontexist')).rejects.toThrowErrorMatchingInlineSnapshot('"Component set with web path idontexist does not exist"');
-        }, 15000);
-    });
-    describe('getAllComponentSets', () => {
-        const webPath = 'set-web-path';
-        beforeAll(async () => {
-            await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-        });
-        afterAll(async () => {
-            await db.repositories.componentSet.delete({ webPath });
-            await db.repositories.componentSetComponentVersion.delete({ componentSetWebPath: webPath });
-        });
-        it('should return all the component set objects', async () => {
-            const componentSets = await service.getAllComponentSets();
-            expect(componentSets.filter((c) => c.webPath === webPath)).toEqual([
-                {
-                    webPath: webPath,
-                    displayName: 'some-display-name',
-                    description: 'some-description',
-                    environmentVariables: {
-                        'some-var': 'some-val',
-                    },
-                    headers: {
-                        'some-header-name': 'some-header-val',
-                    },
-                    components: {
-                        'unit-test-components/foo': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: {},
-                                description: 'some-description',
-                                displayName: 'some-display-name',
-                                icon: undefined,
-                                editable: false,
-                            },
-                        ],
-                    },
-                    componentVersionRules: {
-                        'unit-test-components/foo': {
-                            renderableVersionPattern: '1.0.0',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                    },
-                },
-            ]);
-        });
-    });
-    describe('componentVersionInSet', () => {
-        let componentVersionSet;
-        let manifest100;
-        let manifest110;
-        beforeAll(async () => {
-            manifest100 = await manifestService.loadManifest('unit-test-components', 'test-component', '1.0.0');
-            manifest110 = await manifestService.loadManifest('unit-test-components', 'test-component', '1.1.0');
-            componentVersionSet = await service.addComponentSet({
-                webPath: (0, crypto_1.randomUUID)(),
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {},
-                headers: {},
-                componentVersionRules: {
-                    'unit-test-components/test-component': {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-        });
-        afterAll(async () => {
-            await service.deleteComponentSet(componentVersionSet.webPath);
-        });
-        it('should check if component version exists in the set', async () => {
-            const resultTrue = await service.componentVersionInSet(manifest100, componentVersionSet.webPath);
-            expect(resultTrue).toEqual(true);
-            const resultFalse = await service.componentVersionInSet(manifest110, componentVersionSet.webPath);
-            expect(resultFalse).toEqual(false);
-        });
-    });
-    describe('getComponentsRuntimeSetData', () => {
-        const webPath = (0, crypto_1.randomUUID)();
-        const componentName = 'test-environment-variables';
-        const componentRoot = path_1.default.resolve(path_1.default.join(__dirname, '..', '..', '..', '..', '..', '..', 'test-components'));
-        const manifestService = new manifest_1.ManifestServiceForProduction(componentRoot, logger);
-        let testEnvVar100;
-        let testEnvVar102;
-        let testSet;
-        beforeAll(async () => {
-            testEnvVar100 = await manifestService.loadManifest('unit-test-components', 'test-environment-variables', '1.0.0');
-            testEnvVar102 = await manifestService.loadManifest('unit-test-components', 'test-environment-variables', '1.0.2');
-            testSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    TEST_VARIABLE: 'value',
-                    ADDITIONAL_VAR: '123',
-                },
-                headers: {},
-                components: {},
-                componentVersionRules: {},
-            });
-        });
-        afterAll(async () => {
-            await service.deleteComponentSet(testSet.webPath);
-        });
-        it('should return run time component set with component environment variable thats been overridden', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.0');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    TEST_VARIABLE: 'some-default-val',
-                },
-                headers: {},
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {
-                                TEST_VARIABLE: '1.0.0 value',
-                            },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({ TEST_VARIABLE: '1.0.0 value' });
-        });
-        it('should return render runtime set with requested variable', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.0');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    TEST_VARIABLE: 'some-default-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({ TEST_VARIABLE: 'some-default-val' });
-        });
-        it('should return render runtime set with only component requested variables', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.0');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    TEST_VARIABLE: 'some value',
-                    'some-var1': 'some value1',
-                    'some-var2': 'some value2',
-                    'some-var3': 'some value3',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({
-                TEST_VARIABLE: 'some value',
-            });
-        });
-        it('should return nothing if no env vars requested', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.1');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    TEST_VARIABLE: 'some value',
-                    'some-var1': 'some value1',
-                    'some-var2': 'some value2',
-                    'some-var3': 'some value3',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.1',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.1',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({});
-        });
-        it('should allow multiple components to have different values for same env var', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.0');
-            const manifest2 = await manifestService.loadManifest(namespace, componentName, '1.0.2');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    TEST_VARIABLE: 'some value',
-                    'some-var1': 'some value1',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: { TEST_VARIABLE: '1.0.0' },
-                        },
-                        {
-                            version: '1.0.2',
-                            environmentVariables: { TEST_VARIABLE: '1.0.2' },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.0 || 1.0.2',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({ TEST_VARIABLE: '1.0.0' });
-            const compRuntimeSetData2 = await service.getComponentsRuntimeSetData(manifest2, nextSet);
-            expect(compRuntimeSetData2.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData2.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData2.environment).toEqual({ TEST_VARIABLE: '1.0.2' });
-        });
-        it('should throw an error if env var is not available', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.0');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {},
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                        {
-                            version: '1.0.2',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.0 || 1.0.2',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            await expect(service.getComponentsRuntimeSetData(manifest, nextSet)).rejects.toThrowError(new Error('Missing required environment variables: "TEST_VARIABLE"'));
-        });
-        it('should throw an error if only override is provided', async () => {
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.0');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: { TEST_VARIABLE: 'value' },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: { TEST_VARIABLE: 'value' },
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            nextSet.environmentVariables = {};
-            await expect(service.getComponentsRuntimeSetData(manifest, nextSet)).rejects.toThrowError(new Error('Missing required environment variables: "TEST_VARIABLE"'));
-        });
-        it('should not throw an error for missing env vars if env vars are defined as non-mandatory', async () => {
-            // this component manifest defines a non-mandatory env var
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.3');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {},
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.3',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.3',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({});
-        });
-        it('should throw error for all missing mandatory env vars', async () => {
-            // manifest defines M_VAR and M_VAR2 as mandatory vars and NM_VAR as non-mandatory
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.4');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {},
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.4',
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.4',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            await expect(service.getComponentsRuntimeSetData(manifest, nextSet)).rejects.toThrowError(new Error('Missing required environment variables: "M_VAR","M_VAR2"'));
-        });
-        it('should have runtime set return all defined env vars in the manifest that are provided', async () => {
-            // manifest defines M_VAR and M_VAR2 as mandatory vars and NM_VAR as non-mandatory
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.4');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    M_VAR: 'm-var-val',
-                    M_VAR2: 'm-var2-val',
-                    NM_VAR: 'nm-var-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.4',
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.4',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({
-                M_VAR: 'm-var-val',
-                M_VAR2: 'm-var2-val',
-                NM_VAR: 'nm-var-val',
-            });
-        });
-        it('should have runtime set not return non-mandatory env vars that are not provided', async () => {
-            // manifest defines M_VAR and M_VAR2 as mandatory vars and NM_VAR as non-mandatory
-            const manifest = await manifestService.loadManifest(namespace, componentName, '1.0.4');
-            const update = {
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    M_VAR: 'm-var-val',
-                    M_VAR2: 'm-var2-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/${componentName}`]: [
-                        {
-                            version: '1.0.4',
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/${componentName}`]: {
-                        renderableVersionPattern: '1.0.4',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            };
-            await service.updateComponentSet(testSet.webPath, update);
-            const nextSet = await service.getComponentSet(testSet.webPath);
-            const compRuntimeSetData = await service.getComponentsRuntimeSetData(manifest, nextSet);
-            expect(compRuntimeSetData.displayName).toEqual('some-display-name');
-            expect(compRuntimeSetData.webPath).toEqual(testSet.webPath);
-            expect(compRuntimeSetData.environment).toEqual({
-                M_VAR: 'm-var-val',
-                M_VAR2: 'm-var2-val',
-            });
-        });
-        describe('getComponentsRuntimeSetData environment variables', () => {
-            let set;
-            let testComponent100;
-            beforeAll(async () => {
-                testComponent100 = await manifestService.loadManifest('unit-test-components', 'test-component', '1.0.0');
-                const setWebModel = await service.addComponentSet({
-                    webPath: (0, crypto_1.randomUUID)(),
-                    displayName: 'some-display-name',
-                    description: 'some-description',
-                    environmentVariables: {
-                        TEST_VARIABLE: 'value',
-                        ADDITIONAL_VAR: '123',
-                    },
-                    headers: {},
-                    components: {
-                        'unit-test-components/test-environment-variables': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: { TEST_VARIABLE: 'test-component-override-1.0.1' },
-                            },
-                            {
-                                version: '1.0.2',
-                                environmentVariables: { TEST_VARIABLE: 'test-component-override-1.0.2' },
-                            },
-                        ],
-                        'unit-test-components/test-component': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: {},
-                            },
-                        ],
-                    },
-                    componentVersionRules: {
-                        'unit-test-components/test-environment-variables': {
-                            renderableVersionPattern: '1.0.0 || 1.0.2',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                        'unit-test-components/test-component': {
-                            renderableVersionPattern: '1.0.0',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                    },
-                });
-                set = await service.getComponentSet(setWebModel.webPath);
-            });
-            afterAll(async () => {
-                await service.deleteComponentSet(set.webPath);
-            });
-            it('should not return any environment variables if none are requested by component', async () => {
-                const runtimeSetData = await service.getComponentsRuntimeSetData(testComponent100, set);
-                expect(runtimeSetData).toEqual({
-                    displayName: 'some-display-name',
-                    webPath: set.webPath,
-                    environment: {},
-                });
-            });
-            it('should not return any environment variables if none are requested by component even if value overridden for component', async () => {
-                const update = {
-                    displayName: 'some-display-name',
-                    description: 'some-description',
-                    environmentVariables: {
-                        TEST_VARIABLE: 'value',
-                        ADDITIONAL_VAR: '123',
-                    },
-                    headers: {},
-                    components: {
-                        'unit-test-components/test-component': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: { ADDITIONAL_VAR: 'a value' },
-                            },
-                        ],
-                    },
-                    componentVersionRules: {
-                        'unit-test-components/test-component': {
-                            renderableVersionPattern: '1.0.0',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                    },
-                };
-                await service.updateComponentSet(set.webPath, update);
-                const runtimeSet = await service.getComponentSet(set.webPath);
-                const runtimeSetData = await service.getComponentsRuntimeSetData(testComponent100, runtimeSet);
-                expect(runtimeSetData).toEqual({
-                    displayName: 'some-display-name',
-                    webPath: set.webPath,
-                    environment: {},
-                });
-            });
-            it('should allow components to have individual environment variable value overrides', async () => {
-                const update = {
-                    displayName: 'some-display-name',
-                    description: 'some-description',
-                    environmentVariables: {
-                        TEST_VARIABLE: 'value',
-                        ADDITIONAL_VAR: '123',
-                    },
-                    headers: {},
-                    components: {
-                        'unit-test-components/test-environment-variables': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: { TEST_VARIABLE: 'test-component-override-1.0.1' },
-                            },
-                            {
-                                version: '1.0.2',
-                                environmentVariables: { TEST_VARIABLE: 'test-component-override-1.0.2' },
-                            },
-                        ],
-                        'unit-test-components/test-component': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: {},
-                            },
-                        ],
-                    },
-                    componentVersionRules: {
-                        'unit-test-components/test-environment-variables': {
-                            renderableVersionPattern: '1.0.0 || 1.0.2',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                        'unit-test-components/test-component': {
-                            renderableVersionPattern: '1.0.0',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                    },
-                };
-                await service.updateComponentSet(set.webPath, update);
-                const runtimeSet = await service.getComponentSet(set.webPath);
-                let runtimeSetData = await service.getComponentsRuntimeSetData(testEnvVar100, runtimeSet);
-                expect(runtimeSetData).toEqual({
-                    displayName: 'some-display-name',
-                    webPath: set.webPath,
-                    environment: { TEST_VARIABLE: 'test-component-override-1.0.1' },
-                });
-                runtimeSetData = await service.getComponentsRuntimeSetData(testEnvVar102, set);
-                expect(runtimeSetData).toEqual({
-                    displayName: 'some-display-name',
-                    webPath: set.webPath,
-                    environment: { TEST_VARIABLE: 'test-component-override-1.0.2' },
-                });
-            });
-            it('should use toplevel envvars is no override', async () => {
-                const update = {
-                    displayName: 'some-display-name',
-                    description: 'some-description',
-                    environmentVariables: {
-                        TEST_VARIABLE: 'value',
-                        ADDITIONAL_VAR: '123',
-                    },
-                    headers: {},
-                    components: {
-                        'unit-test-components/test-environment-variables': [
-                            {
-                                version: '1.0.0',
-                                environmentVariables: {},
-                            },
-                        ],
-                    },
-                    componentVersionRules: {
-                        'unit-test-components/test-environment-variables': {
-                            renderableVersionPattern: '1.0.0',
-                            excludedVersions: [],
-                            editableVersions: [],
-                        },
-                    },
-                };
-                await service.updateComponentSet(set.webPath, update);
-                const runtimeSetData = await service.getComponentsRuntimeSetData(testEnvVar100, set);
-                expect(runtimeSetData).toEqual({
-                    displayName: 'some-display-name',
-                    webPath: set.webPath,
-                    environment: { TEST_VARIABLE: 'value' },
-                });
-            });
-        });
-    });
-    describe('deleteComponentSet', () => {
-        const webPath = 'set-web-path';
-        beforeAll(async () => {
-            await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                components: {
-                    [`${namespace}/foo`]: [
-                        {
-                            version: '1.0.0',
-                            environmentVariables: {},
-                        },
-                        {
-                            version: '2.0.0',
-                            environmentVariables: {},
-                        },
-                    ],
-                },
-                componentVersionRules: {
-                    [`${namespace}/foo`]: {
-                        renderableVersionPattern: '1.0.0 || 2.0.0',
-                        excludedVersions: [],
-                        editableVersions: [],
-                    },
-                },
-            });
-        });
-        afterAll(async () => {
-            await db.repositories.componentSet.delete({ webPath });
-            await db.repositories.componentSetComponentVersion.delete({ componentSetWebPath: webPath });
-        });
-        it('should delete the existing component set in all of the relevant tables', async () => {
-            const result = await service.deleteComponentSet(webPath);
-            expect(result).toEqual(1);
-            const csResult = await db.repositories.componentSet.getComponentSetByWebPath(webPath);
-            expect(csResult).toEqual(undefined);
-            const cscvResult = await db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
-            expect(cscvResult).toHaveLength(0);
-            expect(mockInfo).toHaveBeenCalledWith(`Component set deleted: set-web-path.`, undefined, undefined, 'componentSetId:set-web-path');
-            expect(mockFlush).toHaveBeenCalled();
-        }, 15000);
-        it('should throw error if component set web path does not exist', async () => {
-            await expect(service.deleteComponentSet('idontexist')).rejects.toThrowErrorMatchingInlineSnapshot('"Component set with web path idontexist does not exist"');
-        }, 15000);
-    });
-    describe('getPaginatedComponentSets', () => {
-        beforeAll(async () => {
-            const allComponents = await service.getAllComponentSets();
-            for (const cSet of allComponents) {
-                await db.repositories.componentSet.delete({ webPath: cSet.webPath });
-            }
-            await service.addComponentSet({
-                webPath: 'wp-1',
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {},
-                headers: {},
-                components: {},
-            });
-            await service.addComponentSet({
-                webPath: 'wp-2',
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {},
-                headers: {},
-                components: {},
-            });
-        });
-        afterAll(async () => {
-            await db.repositories.componentSet.delete({ webPath: 'wp-1' });
-            await db.repositories.componentSet.delete({ webPath: 'wp-2' });
-        });
-        it('should return all the component sets list and page info', async () => {
-            const componentSets = await service.getPaginatedComponentSets();
-            expect(componentSets).toEqual({
-                items: [
-                    {
-                        components: {},
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        environmentVariables: {},
-                        headers: {},
-                        webPath: 'wp-1',
-                        componentVersionRules: {},
-                    },
-                    {
-                        components: {},
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        environmentVariables: {},
-                        headers: {},
-                        webPath: 'wp-2',
-                        componentVersionRules: {},
-                    },
-                ],
-                pageInfo: {
-                    current: 1,
-                    next: null,
-                    pageSize: 20,
-                    previous: null,
-                    totalItems: 2,
-                    totalPages: 1,
-                },
-            });
-        });
-        it('should return all the component sets list based on given specified sorting options', async () => {
-            const componentSets = await service.getPaginatedComponentSets(1, ['webPath'], 'desc');
-            expect(componentSets).toEqual({
-                items: [
-                    {
-                        components: {},
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        environmentVariables: {},
-                        headers: {},
-                        webPath: 'wp-2',
-                        componentVersionRules: {},
-                    },
-                    {
-                        components: {},
-                        description: 'some-description',
-                        displayName: 'some-display-name',
-                        environmentVariables: {},
-                        headers: {},
-                        webPath: 'wp-1',
-                        componentVersionRules: {},
-                    },
-                ],
-                pageInfo: {
-                    current: 1,
-                    next: null,
-                    pageSize: 20,
-                    previous: null,
-                    totalItems: 2,
-                    totalPages: 1,
-                },
-            });
-        });
-    });
-    describe('addToComponentSet - more components with non standard versions', () => {
-        const testWebPaths = ['set-web-path'];
-        let componentTempLocation3 = '';
-        let componentTempLocation4 = '';
-        let componentTempLocation5 = '';
-        let componentTempLocation6 = '';
-        beforeAll(async () => {
-            componentTempLocation3 = fs_1.default.mkdtempSync('test3-');
-            await createComponentAtTempLocation(componentTempLocation3, 'foo', '0.0.11');
-            await componentService.saveComponent(componentTempLocation3);
-            componentTempLocation4 = fs_1.default.mkdtempSync('test4-');
-            await createComponentAtTempLocation(componentTempLocation4, 'foo', '0.0.12');
-            await componentService.saveComponent(componentTempLocation4);
-            componentTempLocation5 = fs_1.default.mkdtempSync('test5-');
-            await createComponentAtTempLocation(componentTempLocation5, 'foo', '10.5.2');
-            await componentService.saveComponent(componentTempLocation5);
-            componentTempLocation6 = fs_1.default.mkdtempSync('test6-');
-            await createComponentAtTempLocation(componentTempLocation6, 'foo', '9.0.1');
-            await componentService.saveComponent(componentTempLocation6);
-        });
-        afterAll(async () => {
-            if (fs_extra_1.default.pathExistsSync(componentTempLocation3)) {
-                fs_extra_1.default.rmSync(componentTempLocation3, { force: true, recursive: true });
-            }
-            if (fs_extra_1.default.pathExistsSync(componentTempLocation4)) {
-                fs_extra_1.default.rmSync(componentTempLocation4, { force: true, recursive: true });
-            }
-            if (fs_extra_1.default.pathExistsSync(componentTempLocation5)) {
-                fs_extra_1.default.rmSync(componentTempLocation5, { force: true, recursive: true });
-            }
-            if (fs_extra_1.default.pathExistsSync(componentTempLocation6)) {
-                fs_extra_1.default.rmSync(componentTempLocation6, { force: true, recursive: true });
-            }
-            for (const webPath of testWebPaths) {
-                await db.repositories.componentSet.delete({ webPath });
-                await db.repositories.componentSetComponentVersion.delete({ componentSetWebPath: webPath });
-            }
-        });
-        it('should have only the highest semver version as editable true when the editable rule is latest and there is a higher number of components with non uniform versions', async () => {
-            const webPath = 'set-web-path-3';
-            testWebPaths.push('set-web-path-3');
-            const componentSet = await service.addComponentSet({
-                webPath: webPath,
-                displayName: 'some-display-name',
-                description: 'some-description',
-                environmentVariables: {
-                    'some-var': 'some-val',
-                },
-                headers: {
-                    'some-header-name': 'some-header-val',
-                },
-                componentVersionRules: {
-                    'unit-test-components/foo': {
-                        renderableVersionPattern: '*',
-                        excludedVersions: ['0.0.11'],
-                        editableVersions: 'latest',
-                    },
-                },
-            });
-            expect(componentSet).toMatchInlineSnapshot(`
-        {
-          "componentVersionRules": {
-            "unit-test-components/foo": {
-              "editableVersions": [
-                "latest",
-              ],
-              "excludedVersions": [
-                "0.0.11",
-              ],
-              "renderableVersionPattern": "*",
-            },
-          },
-          "components": {
-            "unit-test-components/foo": [
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "9.0.1",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "2.0.0",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": true,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "10.5.2",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "1.0.0",
-              },
-              {
-                "description": "some-description",
-                "displayName": "some-display-name",
-                "editable": false,
-                "environmentVariables": {},
-                "icon": undefined,
-                "version": "0.0.12",
-              },
-            ],
-          },
-          "description": "some-description",
-          "displayName": "some-display-name",
-          "environmentVariables": {
-            "some-var": "some-val",
-          },
-          "headers": {
-            "some-header-name": "some-header-val",
-          },
-          "webPath": "set-web-path-3",
-        }
-      `);
-            expect(mockInfo).toHaveBeenCalledWith(`Component set added: set-web-path-3.`, undefined, undefined, 'componentSetId:set-web-path-3');
-            expect(mockFlush).toHaveBeenCalled();
-        }, 15000);
-    });
-});
-//# sourceMappingURL=ComponentSetServiceForProduction.integration.spec.js.map