@squiz/job-runner-lib 1.66.1

package/src/domains/component-set/services/ComponentSetServiceForProduction.integration.spec.ts

@@ -0,0 +1,2898 @@
+import unzipper from 'unzipper';
+import fs from 'fs';
+import fsExtra from 'fs-extra';
+import path from 'path';
+import { getLogger, Logger } from '@squiz/dx-logger-lib';
+import { ComponentConnectionManager, createConnectionManager } from '../../db';
+import { ComponentSetServiceForProduction } from './ComponentSetServiceForProduction';
+import { ComponentService } from '../../component/services/ComponentService';
+import { createPackage } from '../../__test__/createPackage';
+import { Manifest, ManifestService, ManifestServiceForProduction } from '../../manifest';
+import { randomUUID } from 'crypto';
+import {
+  ComponentSetWebModel,
+  ComponentSetWebModelForUpdate,
+  ComponentVersionWebModelForCreate,
+} from '../web-models/ComponentSetForWeb';
+import { loadAllUnitTestComponents } from '../../__test__/loadAllUnitTestComponents';
+import { ComponentSet } from '../models/ComponentSet';
+
+import { ComponentSetComponentVersionStatus } from '../models/ComponentSetComponentVersion';
+import { ComponentLogger } from '@squiz/component-logger-lib';
+
+describe('ComponentSetServiceForProduction', () => {
+  let db: ComponentConnectionManager;
+
+  const logger: Logger = getLogger({
+    name: 'component-lib',
+  });
+
+  let service: ComponentSetServiceForProduction;
+  let componentService: ComponentService;
+  let manifestService: ManifestService;
+  const mockInfo = jest.fn();
+  const mockFlush = jest.fn();
+  const componentLoggingService = { info: mockInfo, flush: mockFlush } as unknown as ComponentLogger;
+
+  const namespace = 'unit-test-components';
+  let componentTempLocation1 = '';
+  let componentTempLocation2 = '';
+
+  async function createComponentAtTempLocation(componentTempLocation: string, componentName: string, version: string) {
+    const newComponent = createPackage(namespace, componentName, version);
+    await newComponent.finalize();
+    await newComponent.pipe(unzipper.Extract({ path: componentTempLocation })).promise();
+  }
+
+  beforeAll(async () => {
+    db = await createConnectionManager(
+      'management-api-test',
+      {
+        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
+      },
+      '',
+    );
+    await db.applyMigrations();
+
+    manifestService = new ManifestServiceForProduction(process.env.DATA_MOUNT_POINT!, logger);
+
+    await loadAllUnitTestComponents(process.env.DATA_MOUNT_POINT!, db, manifestService);
+
+    service = new ComponentSetServiceForProduction(db, logger, manifestService, componentLoggingService);
+    componentService = new 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.mkdtempSync('test1-');
+    await createComponentAtTempLocation(componentTempLocation1, 'foo', '1.0.0');
+    await componentService.saveComponent(componentTempLocation1);
+    componentTempLocation2 = fs.mkdtempSync('test2-');
+    await createComponentAtTempLocation(componentTempLocation2, 'foo', '2.0.0');
+    await componentService.saveComponent(componentTempLocation2);
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(async () => {
+    if (fsExtra.pathExistsSync(componentTempLocation1)) {
+      fsExtra.rmSync(componentTempLocation1, { force: true, recursive: true });
+    }
+    if (fsExtra.pathExistsSync(componentTempLocation2)) {
+      fsExtra.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: 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();
+    }, 15_000);
+
+    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",
+        }
+      `);
+    }, 15_000);
+
+    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",
+        }
+      `);
+    }, 15_000);
+
+    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",
+        }
+      `);
+    }, 15_000);
+
+    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",
+        }
+      `);
+    }, 15_000);
+
+    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",
+        }
+      `);
+    }, 15_000);
+
+    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",
+        }
+      `);
+    }, 15_000);
+
+    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"`);
+    }, 15_000);
+
+    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"');
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+
+    it('should throw error if duplicate component versions in components', async () => {
+      await expect(
+        service.addComponentSet({
+          webPath: 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"`,
+      );
+    }, 15_000);
+
+    it('should error if added component does not satisfy componentVersionRules', async () => {
+      await expect(
+        service.addComponentSet({
+          webPath: 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: 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: 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();
+    }, 15_000);
+
+    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",
+            },
+          ],
+        }
+      `);
+    }, 15_000);
+
+    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",
+            },
+          ],
+        }
+      `);
+    }, 15_000);
+
+    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',
+        ComponentSetComponentVersionStatus.excluded,
+      );
+      expect(cscvResult.find((c) => c.componentVersion === '2.0.0')).toHaveProperty(
+        'status',
+        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: 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: 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: 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: ComponentSetComponentVersionStatus.excluded,
+      });
+    }, 15_000);
+
+    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",
+            },
+          ],
+        }
+      `);
+    }, 15_000);
+
+    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",
+            },
+          ],
+        }
+      `);
+    }, 15_000);
+
+    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: ComponentVersionWebModelForCreate[] = [
+        ...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: ComponentVersionWebModelForCreate[] = [
+        {
+          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"');
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+
+    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 = 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: [],
+          },
+        },
+      });
+    }, 15_000);
+
+    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: ComponentSetWebModel = {
+        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);
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+  });
+
+  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: ComponentSetWebModel;
+    let manifest100: Manifest;
+    let manifest110: Manifest;
+
+    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: 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 = randomUUID();
+    const componentName = 'test-environment-variables';
+    const componentRoot = path.resolve(path.join(__dirname, '..', '..', '..', '..', '..', '..', 'test-components'));
+    const manifestService = new ManifestServiceForProduction(componentRoot, logger);
+
+    let testEnvVar100: Manifest;
+    let testEnvVar102: Manifest;
+
+    let testSet: ComponentSetWebModel;
+
+    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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSetWebModelForUpdate = {
+        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: ComponentSet;
+      let testComponent100: Manifest;
+
+      beforeAll(async () => {
+        testComponent100 = await manifestService.loadManifest('unit-test-components', 'test-component', '1.0.0');
+
+        const setWebModel = await service.addComponentSet({
+          webPath: 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: ComponentSetWebModelForUpdate = {
+          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: ComponentSetWebModelForUpdate = {
+          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: ComponentSetWebModelForUpdate = {
+          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();
+    }, 15_000);
+
+    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"',
+      );
+    }, 15_000);
+  });
+
+  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.mkdtempSync('test3-');
+      await createComponentAtTempLocation(componentTempLocation3, 'foo', '0.0.11');
+      await componentService.saveComponent(componentTempLocation3);
+      componentTempLocation4 = fs.mkdtempSync('test4-');
+      await createComponentAtTempLocation(componentTempLocation4, 'foo', '0.0.12');
+      await componentService.saveComponent(componentTempLocation4);
+      componentTempLocation5 = fs.mkdtempSync('test5-');
+      await createComponentAtTempLocation(componentTempLocation5, 'foo', '10.5.2');
+      await componentService.saveComponent(componentTempLocation5);
+      componentTempLocation6 = fs.mkdtempSync('test6-');
+      await createComponentAtTempLocation(componentTempLocation6, 'foo', '9.0.1');
+      await componentService.saveComponent(componentTempLocation6);
+    });
+
+    afterAll(async () => {
+      if (fsExtra.pathExistsSync(componentTempLocation3)) {
+        fsExtra.rmSync(componentTempLocation3, { force: true, recursive: true });
+      }
+      if (fsExtra.pathExistsSync(componentTempLocation4)) {
+        fsExtra.rmSync(componentTempLocation4, { force: true, recursive: true });
+      }
+      if (fsExtra.pathExistsSync(componentTempLocation5)) {
+        fsExtra.rmSync(componentTempLocation5, { force: true, recursive: true });
+      }
+      if (fsExtra.pathExistsSync(componentTempLocation6)) {
+        fsExtra.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);
+  });
+});