@squiz/job-runner-lib 1.66.1 → 2.1.0

package/src/domains/component-set/models/ComponentSet.spec.ts

@@ -1,66 +0,0 @@
-import { ComponentSet } from './ComponentSet';
-
-describe('ComponentSetImpl', () => {
-  it('should create object if only web path provided', () => {
-    expect(
-      new ComponentSet({
-        webPath: 'web-path',
-      }),
-    ).toEqual(
-      new ComponentSet({
-        webPath: 'web-path',
-      }),
-    );
-  });
-
-  it('should not allow empty web path', () => {
-    expect(
-      () =>
-        new ComponentSet({
-          webPath: '',
-          displayName: 'display-name',
-          description: 'description',
-
-          environmentVariables: {},
-          headers: {},
-        }),
-    ).toThrowErrorMatchingInlineSnapshot('"webPath.length must have length greater than 0"');
-  });
-
-  it('should not allow missing web path', () => {
-    expect(
-      () =>
-        new ComponentSet({
-          displayName: 'display-name',
-          description: 'description',
-
-          environmentVariables: {},
-          headers: {},
-        }),
-    ).toThrowErrorMatchingInlineSnapshot('"webPath must be a string"');
-  });
-
-  it('should set provided properties', () => {
-    expect(
-      new ComponentSet({
-        webPath: 'web-path',
-
-        displayName: 'display-name',
-        description: 'description',
-
-        environmentVariables: { my_var: '123' },
-        headers: { 'my-header': '123' },
-      }),
-    ).toEqual(
-      new ComponentSet({
-        webPath: 'web-path',
-
-        displayName: 'display-name',
-        description: 'description',
-
-        environmentVariables: { my_var: '123' },
-        headers: { 'my-header': '123' },
-      }),
-    );
-  });
-});

package/src/domains/component-set/models/ComponentSet.ts

@@ -1,67 +0,0 @@
-import {
-  assertIsDefined,
-  assertIsString,
-  assertIsMapOfStringString,
-  assertAssign,
-  assertAssignWithDefaultUndefinedValue,
-} from '@squiz/dx-common-lib';
-import { AssertionError } from 'assert';
-import { Headers } from '../services/Headers';
-
-export interface ComponentSetInterface {
-  webPath: string;
-  displayName: string;
-  description: string;
-
-  environmentVariables: { [key: string]: string };
-  headers: Headers;
-}
-
-const VALID_WEB_PATH_REGEX = /^[a-z0-9\-_.]+$/i;
-
-export class ComponentSet implements ComponentSetInterface {
-  public webPath: string;
-  public displayName: string;
-  public description: string;
-
-  public environmentVariables: { [key: string]: string };
-  public headers: Headers;
-
-  constructor(data?: Record<string, unknown>) {
-    assertIsDefined(data);
-
-    this.webPath = assertAssign(data.webPath, assertIsString, 'webPath must be a string');
-
-    this.displayName = assertAssignWithDefaultUndefinedValue(
-      data.displayName,
-      assertIsString,
-      '',
-      'displayName must be a string',
-    );
-    this.description = assertAssignWithDefaultUndefinedValue(
-      data.description,
-      assertIsString,
-      '',
-      'description must be a string',
-    );
-
-    this.environmentVariables = assertAssignWithDefaultUndefinedValue(
-      data.environmentVariables,
-      assertIsMapOfStringString,
-      {},
-    );
-    this.headers = assertAssignWithDefaultUndefinedValue(data.headers, assertIsMapOfStringString, {});
-
-    if (this.webPath.length === 0) {
-      throw new AssertionError({
-        message: 'webPath.length must have length greater than 0',
-      });
-    }
-
-    if (VALID_WEB_PATH_REGEX.test(this.webPath) === false) {
-      throw new AssertionError({
-        message: `Invalid Component Set web path, it must meet ${VALID_WEB_PATH_REGEX.toString()}`,
-      });
-    }
-  }
-}

package/src/domains/component-set/models/ComponentSetComponentVersion.spec.ts

@@ -1,106 +0,0 @@
-import { ComponentSetComponentVersion, ComponentSetComponentVersionStatus } from './ComponentSetComponentVersion';
-
-describe('ComponentSetComponentVersion', () => {
-  it('should create component set component version if webPath, component name and version are provided', () => {
-    const model = new ComponentSetComponentVersion({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: 'version',
-    });
-
-    expect(model.componentSetWebPath).toEqual('web-path');
-    expect(model.componentName).toEqual('name');
-    expect(model.componentVersion).toEqual('version');
-  });
-
-  it('should set default status to "active" when not provided', () => {
-    const model = new ComponentSetComponentVersion({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: 'version',
-    });
-
-    expect(model.status).toEqual(ComponentSetComponentVersionStatus.active);
-  });
-
-  it('should allow creation with optional environmentVariables', () => {
-    const model = new ComponentSetComponentVersion({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: 'version',
-
-      environmentVariables: {
-        var: '123',
-      },
-    });
-
-    expect(model.componentSetWebPath).toEqual('web-path');
-    expect(model.componentName).toEqual('name');
-    expect(model.componentVersion).toEqual('version');
-    expect(model.environmentVariables).toEqual({
-      var: '123',
-    });
-  });
-
-  it('should allow "status" to be set', () => {
-    const model = new ComponentSetComponentVersion({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: 'version',
-      status: ComponentSetComponentVersionStatus.excluded,
-    });
-
-    expect(model.componentSetWebPath).toEqual('web-path');
-    expect(model.componentName).toEqual('name');
-    expect(model.componentVersion).toEqual('version');
-    expect(model.status).toEqual(ComponentSetComponentVersionStatus.excluded);
-  });
-
-  it('should throw error if componentSetWebPath not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersion({
-          componentName: 'name',
-          componentVersion: 'version',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"componentSetWebPath must be a string"`);
-  });
-
-  it('should throw error if componentName not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersion({
-          componentSetWebPath: 'web-path',
-
-          componentVersion: 'version',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"componentName must be a string"`);
-  });
-
-  it('should throw error if componentVersion not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersion({
-          componentSetWebPath: 'web-path',
-          componentName: 'name',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"componentVersion must be a string"`);
-  });
-
-  it('should throw error if "status" is not a valid enum value', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersion({
-          componentSetWebPath: 'web-path',
-          componentName: 'name',
-          componentVersion: 'version',
-          status: 'foo',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`
-      "'foo' in [
-        'active',
-        'excluded'
-      ]"
-    `);
-  });
-});

package/src/domains/component-set/models/ComponentSetComponentVersion.ts

@@ -1,54 +0,0 @@
-import {
-  assertIsString,
-  assertIsDefined,
-  assertIsMapOfStringString,
-  assertAssign,
-  assertAssignWithDefaultUndefinedValue,
-  assertIsEnumValue,
-} from '@squiz/dx-common-lib';
-
-export enum ComponentSetComponentVersionStatus {
-  active = 'active',
-  excluded = 'excluded',
-}
-
-export interface ComponentSetComponentVersionInterface {
-  componentSetWebPath: string;
-  componentName: string;
-  componentVersion: string;
-  environmentVariables: { [key: string]: string };
-  status: ComponentSetComponentVersionStatus;
-}
-
-export class ComponentSetComponentVersion implements ComponentSetComponentVersionInterface {
-  public componentSetWebPath: string = '';
-  public componentName: string = '';
-  public componentVersion: string = '';
-  public environmentVariables: { [key: string]: string };
-  public status: ComponentSetComponentVersionStatus = ComponentSetComponentVersionStatus.active;
-
-  constructor(data?: Record<string, unknown>) {
-    assertIsDefined(data);
-
-    this.componentSetWebPath = assertAssign(
-      data.componentSetWebPath,
-      assertIsString,
-      'componentSetWebPath must be a string',
-    );
-
-    this.componentName = assertAssign(data.componentName, assertIsString, 'componentName must be a string');
-    this.componentVersion = assertAssign(data.componentVersion, assertIsString, 'componentVersion must be a string');
-
-    this.environmentVariables = assertAssignWithDefaultUndefinedValue(
-      data.environmentVariables,
-      assertIsMapOfStringString,
-      {},
-    );
-
-    if (data.status === undefined) {
-      data.status = ComponentSetComponentVersionStatus.active;
-    }
-    assertIsEnumValue(data.status, ComponentSetComponentVersionStatus);
-    this.status = data.status as ComponentSetComponentVersionStatus;
-  }
-}

package/src/domains/component-set/models/ComponentSetComponentVersionEditable.spec.ts

@@ -1,82 +0,0 @@
-import { ComponentSetComponentVersionEditable } from './ComponentSetComponentVersionEditable';
-
-describe('ComponentSetComponentVersionEditable', () => {
-  it('should create component set component version editable if webPath, component name and version are provided', () => {
-    const model = new ComponentSetComponentVersionEditable({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: '1.1.1',
-    });
-
-    expect(model.componentSetWebPath).toEqual('web-path');
-    expect(model.componentName).toEqual('name');
-    expect(model.componentVersion).toEqual('1.1.1');
-  });
-
-  it('should throw error if componentSetWebPath not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionEditable({
-          componentName: 'name',
-          componentVersion: 'version',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-  });
-
-  it('should throw error if componentName not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionEditable({
-          componentSetWebPath: 'web-path',
-
-          componentVersion: 'version',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-  });
-
-  it('should throw error if componentVersion not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionEditable({
-          componentSetWebPath: 'web-path',
-          componentName: 'name',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
-  });
-
-  it('should create component set component version editable if "latest" version value is provided', () => {
-    const model = new ComponentSetComponentVersionEditable({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: 'latest',
-    });
-
-    expect(model.componentSetWebPath).toEqual('web-path');
-    expect(model.componentName).toEqual('name');
-    expect(model.componentVersion).toEqual('latest');
-  });
-
-  it('should throw error if invalid semvar version is provided', () => {
-    ['foo', '1.1.', '1.2.*', '1.1.1.1'].map((v) => {
-      expect(
-        () =>
-          new ComponentSetComponentVersionEditable({
-            componentSetWebPath: 'web-path',
-            componentName: 'name',
-            componentVersion: v,
-          }),
-      ).toThrowErrorMatchingInlineSnapshot(`"editable component version must be a valid semver version or "latest""`);
-    });
-  });
-
-  it('should throw error if invalid version is provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionEditable({
-          componentSetWebPath: 'web-path',
-          componentName: 'name',
-          componentVersion: '*&.1.1',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"editable component version must be a valid semver version or "latest""`);
-  });
-});

package/src/domains/component-set/models/ComponentSetComponentVersionEditable.ts

@@ -1,46 +0,0 @@
-import { assertIsString, assertIsDefined, assertIsMapOfStringString } from '@squiz/dx-common-lib';
-import * as assert from 'assert/strict';
-import * as semver from 'semver';
-import { EditableComponentVersionTypes } from '../web-models/ComponentSetForWeb';
-
-export interface ComponentSetComponentVersionEditableInterface {
-  componentSetWebPath: string;
-  componentName: string;
-  componentVersion: string;
-}
-
-export class ComponentSetComponentVersionEditable implements ComponentSetComponentVersionEditableInterface {
-  public componentSetWebPath: string = '';
-  public componentName: string = '';
-  public componentVersion: string = '';
-
-  constructor(data?: Record<string, unknown>) {
-    assertIsComponentVersionEditable(data);
-
-    this.componentSetWebPath = data.componentSetWebPath;
-    this.componentName = data.componentName;
-    this.componentVersion = data.componentVersion;
-  }
-}
-
-export function assertIsComponentVersionEditable(
-  data?: unknown,
-): asserts data is ComponentSetComponentVersionEditableInterface {
-  assertIsDefined(data);
-  assertIsMapOfStringString(data);
-
-  assertIsString(data['componentName']);
-  assert.ok(data['componentName'].length > 0, 'componentName must not be an empty string');
-
-  assertIsString(data['componentSetWebPath']);
-  assert.ok(data['componentSetWebPath'].length > 0, 'componentSetWebPath must not be an empty string');
-
-  assertIsString(data['componentVersion']);
-  assert.ok(data['componentVersion'].length > 0, 'editable component version must not be an empty string');
-  if (data['componentVersion'] !== EditableComponentVersionTypes.Latest) {
-    assert.ok(
-      semver.valid(data['componentVersion']),
-      `editable component version must be a valid semver version or "${EditableComponentVersionTypes.Latest}"`,
-    );
-  }
-}

package/src/domains/component-set/models/ComponentSetComponentVersionExcluded.spec.ts

@@ -1,46 +0,0 @@
-import { ComponentSetComponentVersionExcluded } from './ComponentSetComponentVersionExcluded';
-
-describe('ComponentSetComponentVersionExcluded', () => {
-  it('should create component set component version excluded if webPath, component name and version are provided', () => {
-    const model = new ComponentSetComponentVersionExcluded({
-      componentSetWebPath: 'web-path',
-      componentName: 'name',
-      componentVersion: 'version',
-    });
-
-    expect(model.componentSetWebPath).toEqual('web-path');
-    expect(model.componentName).toEqual('name');
-    expect(model.componentVersion).toEqual('version');
-  });
-
-  it('should throw error if componentSetWebPath not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionExcluded({
-          componentName: 'name',
-          componentVersion: 'version',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"componentSetWebPath must be a string"`);
-  });
-
-  it('should throw error if componentName not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionExcluded({
-          componentSetWebPath: 'web-path',
-
-          componentVersion: 'version',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"componentName must be a string"`);
-  });
-
-  it('should throw error if componentVersion not provided', () => {
-    expect(
-      () =>
-        new ComponentSetComponentVersionExcluded({
-          componentSetWebPath: 'web-path',
-          componentName: 'name',
-        }),
-    ).toThrowErrorMatchingInlineSnapshot(`"componentVersion must be a string"`);
-  });
-});

package/src/domains/component-set/models/ComponentSetComponentVersionExcluded.ts

@@ -1,26 +0,0 @@
-import { assertIsString, assertIsDefined, assertAssign } from '@squiz/dx-common-lib';
-
-export interface ComponentSetComponentVersionExcludedInterface {
-  componentSetWebPath: string;
-  componentName: string;
-  componentVersion: string;
-}
-
-export class ComponentSetComponentVersionExcluded implements ComponentSetComponentVersionExcludedInterface {
-  public componentSetWebPath: string = '';
-  public componentName: string = '';
-  public componentVersion: string = '';
-
-  constructor(data?: Record<string, unknown>) {
-    assertIsDefined(data);
-
-    this.componentSetWebPath = assertAssign(
-      data.componentSetWebPath,
-      assertIsString,
-      'componentSetWebPath must be a string',
-    );
-
-    this.componentName = assertAssign(data.componentName, assertIsString, 'componentName must be a string');
-    this.componentVersion = assertAssign(data.componentVersion, assertIsString, 'componentVersion must be a string');
-  }
-}

package/src/domains/component-set/models/ComponentSetRule.spec.ts

@@ -1,39 +0,0 @@
-import { ComponentSetRule } from './ComponentSetRule';
-
-describe('ComponentSetRule', () => {
-  const validAttributes = {
-    componentName: 'some componentName',
-    componentSet: 'some componentSet',
-    versionPattern: '^1.0.0',
-  };
-
-  it('returns a valid model with valid attributes', () => {
-    expect(new ComponentSetRule(validAttributes)).toEqual(validAttributes);
-  });
-
-  it('returns a valid model with a superset of valid attributes', () => {
-    expect(new ComponentSetRule({ ...validAttributes, notRealAttribute: '124' })).toEqual(validAttributes);
-  });
-
-  const requiredAttributes = ['componentName', 'componentSet'];
-  it.each(requiredAttributes)('errors for %s on empty property', (property) => {
-    expect(() => new ComponentSetRule({ ...validAttributes, [property]: '' })).toThrowError(
-      `${property} must not be an empty string`,
-    );
-  });
-
-  const invalidSemvers = ['abc', '1.0.0.0', '$1.0.0', 'abc-1.0.0', '1*'];
-  it.each(invalidSemvers)('errors on invalid versionPattern with %s', (invalidVersion) => {
-    expect(() => new ComponentSetRule({ ...validAttributes, versionPattern: invalidVersion })).toThrowError(
-      'versionPattern must be a valid semver',
-    );
-  });
-
-  const validSemvers = ['^1.0.0', '1.4.5', '~0.0.1', '*', '1.*', ''];
-  it.each(validSemvers)('returns a valid model with valid versionPattern %s', (validVersion) => {
-    expect(new ComponentSetRule({ ...validAttributes, versionPattern: validVersion })).toHaveProperty(
-      'versionPattern',
-      validVersion,
-    );
-  });
-});

package/src/domains/component-set/models/ComponentSetRule.ts

@@ -1,37 +0,0 @@
-import { assertIsDefined, assertIsMapOfStringString, assertIsString } from '@squiz/dx-common-lib';
-import * as assert from 'assert/strict';
-import * as semver from 'semver';
-
-export interface ComponentSetRuleInterface {
-  componentName: string;
-  componentSet: string;
-  versionPattern: string;
-}
-
-export class ComponentSetRule implements ComponentSetRuleInterface {
-  public componentName: string;
-  public componentSet: string;
-  public versionPattern: string;
-
-  constructor(data?: Record<string, unknown>) {
-    assertIsCompenentSetRule(data);
-
-    this.componentName = data.componentName;
-    this.componentSet = data.componentSet;
-    this.versionPattern = data.versionPattern;
-  }
-}
-
-export function assertIsCompenentSetRule(data?: unknown): asserts data is ComponentSetRuleInterface {
-  assertIsDefined(data);
-  assertIsMapOfStringString(data);
-
-  assertIsString(data['componentName']);
-  assert.ok(data['componentName'].length > 0, 'componentName must not be an empty string');
-
-  assertIsString(data['componentSet']);
-  assert.ok(data['componentSet'].length > 0, 'componentSet must not be an empty string');
-
-  assertIsString(data['versionPattern']);
-  assert.ok(semver.validRange(data['versionPattern']), 'versionPattern must be a valid semver');
-}