@squiz/job-runner-lib 1.66.1

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

@@ -0,0 +1,2565 @@
+"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