@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/config/templates/configurePipelineTemplateModal.controller.spec.ts

@@ -1,300 +0,0 @@
-import type { IQService, IScope } from 'angular';
-import { mock } from 'angular';
-
-import { PipelineTemplateReader } from './PipelineTemplateReader';
-import type { Application } from '../../../application/application.model';
-import { ApplicationModelBuilder } from '../../../application/applicationModel.builder';
-import type { ConfigurePipelineTemplateModalController } from './configurePipelineTemplateModal.controller';
-import { CONFIGURE_PIPELINE_TEMPLATE_MODAL_CTRL } from './configurePipelineTemplateModal.controller';
-import type { IVariable } from './inputs/variableInput.service';
-import { PIPELINE_TEMPLATE_MODULE } from './pipelineTemplate.module';
-
-describe('Controller: ConfigurePipelineTemplateModalCtrl', () => {
-  let ctrl: ConfigurePipelineTemplateModalController, $scope: IScope, $q: IQService, application: Application;
-
-  // Hard to get the right newline and space characters with template strings.
-  const yaml =
-    '- name: orca-test\n' +
-    '  region: us-west-2\n' +
-    '  availabilityZones: []\n' +
-    '  capacity: 1\n' +
-    '  keyPair: example-keypair\n' +
-    '  loadBalancers:\n' +
-    '    - orca-test\n' +
-    '  securityGroups: []\n' +
-    '  strategy: highlander\n' +
-    '  instanceType: m3.xlarge\n';
-
-  const yamlAsObj = [
-    {
-      name: 'orca-test',
-      region: 'us-west-2',
-      availabilityZones: [] as any[],
-      capacity: 1,
-      keyPair: 'example-keypair',
-      loadBalancers: ['orca-test'],
-      securityGroups: [] as any[],
-      strategy: 'highlander',
-      instanceType: 'm3.xlarge',
-    },
-  ];
-
-  const template: any = {
-    variables: [
-      {
-        name: 'credentials',
-        group: 'Basic Settings',
-        type: 'string',
-        defaultValue: 'my-google-account',
-      },
-      {
-        name: 'cloudProvider',
-        group: 'Basic Settings',
-        type: 'string',
-        defaultValue: 'gce',
-      },
-      {
-        name: 'someObject',
-        group: 'Advanced Settings',
-        type: 'object',
-        defaultValue: yamlAsObj,
-      },
-      {
-        name: 'someList',
-        group: 'Advanced Settings',
-        type: 'list',
-        defaultValue: ['a', 'b', 'c'],
-      },
-      {
-        name: 'someInt',
-        type: 'int',
-        defaultValue: 42,
-      },
-    ],
-  };
-
-  beforeEach(mock.module(CONFIGURE_PIPELINE_TEMPLATE_MODAL_CTRL, PIPELINE_TEMPLATE_MODULE));
-
-  beforeEach(() => {
-    mock.inject(($controller: ng.IControllerService, $rootScope: ng.IRootScopeService, _$q_: IQService) => {
-      application = ApplicationModelBuilder.createStandaloneApplication('app');
-      $scope = $rootScope.$new();
-      $q = _$q_;
-      ctrl = $controller('ConfigurePipelineTemplateModalCtrl', {
-        $scope,
-        application,
-        $uibModalInstance: { close: $q.resolve(null) },
-        pipelineTemplateConfig: {
-          config: {
-            pipeline: {
-              name: 'My Managed Pipeline',
-              template: {
-                source: 'spinnaker://myPipelineId',
-              },
-            },
-          },
-        },
-        pipelineId: '1234',
-        executionId: null,
-        isNew: true,
-      }) as ConfigurePipelineTemplateModalController;
-    });
-  });
-
-  describe('data initialization', () => {
-    beforeEach(() => {
-      spyOn(PipelineTemplateReader, 'getPipelineTemplateFromSourceUrl').and.callFake(() => {
-        return $q.resolve(template);
-      });
-    });
-
-    it('sets `variableMetadataGroups` on the controller, groups by variable metadata `groupName`', () => {
-      ctrl.initialize();
-      $scope.$digest();
-
-      expect(ctrl.variableMetadataGroups).toBeDefined();
-      expect(ctrl.variableMetadataGroups.length).toEqual(3);
-      expect(ctrl.variableMetadataGroups.find((g) => g.name === 'Basic Settings').variableMetadata.length).toEqual(2);
-    });
-
-    it('sets `variables` on the controller, each with a property `value` provided by variable metadata `defaultValue`', () => {
-      ctrl.initialize();
-      $scope.$digest();
-
-      expect(ctrl.variables).toBeDefined();
-      expect(ctrl.variables.length).toEqual(5);
-      expect(ctrl.variables.map((v) => v.value)).toEqual(['my-google-account', 'gce', yaml, ['a', 'b', 'c'], 42]);
-    });
-
-    it('initializes variables on controller with variables provided from the pipeline template config ', () => {
-      const variables = {
-        credentials: 'my-credentials',
-        cloudProvider: 'gce',
-        someObject: { key: 'value' },
-        someList: ['a'],
-        someInt: 123,
-      };
-      ctrl.pipelineTemplateConfig.config.pipeline.variables = variables;
-      ctrl.initialize();
-      $scope.$digest();
-
-      expect(ctrl.variables.map((v) => v.value)).toEqual(['my-credentials', 'gce', 'key: value\n', ['a'], 123]);
-    });
-  });
-
-  describe('modal behavior if the underlying template changes', () => {
-    let templateA: any, templateB: any;
-
-    beforeEach(() => {
-      templateA = {
-        variables: [
-          {
-            name: 'letters',
-            group: 'Basic Settings',
-            type: 'list',
-            defaultValue: ['a', 'b', 'c'],
-          },
-        ],
-      };
-
-      templateB = {
-        variables: [
-          {
-            name: 'letters',
-            group: 'Basic Settings',
-            type: 'list',
-            defaultValue: ['a', 'b', 'c'],
-          },
-          {
-            name: 'numbers',
-            group: 'Basic Settings',
-            type: 'list',
-            defaultValue: [1, 2, 3],
-          },
-        ],
-      };
-    });
-
-    // This test should replicate the following steps:
-    // 1). User creates and saves template config using the `templateA` template.
-    // 2). User updates the template to add another variable (now the template is `templateB`).
-    // 3). User reopens the config modal - the new variable should be initialized with its default value.
-    it('initializes a new variable field with its default value', () => {
-      const spy = spyOn(PipelineTemplateReader, 'getPipelineTemplateFromSourceUrl');
-      spy.and.callFake(() => $q.resolve(templateA));
-
-      ctrl.initialize();
-      $scope.$digest();
-
-      ctrl.pipelineTemplateConfig = ctrl.buildConfig();
-
-      spy.and.callFake(() => $q.resolve(templateB));
-      ctrl.initialize();
-      $scope.$digest();
-
-      expect(ctrl.buildConfig().config.pipeline.variables).toEqual({
-        letters: ['a', 'b', 'c'],
-        numbers: [1, 2, 3],
-      });
-    });
-
-    // This test should replicate the following steps:
-    // 1). User creates and saves template config using the `templateB` template.
-    // 2). User updates the template to remove a variable (now the template is `templateA`).
-    // 3). User reopens the config modal - on save, the removed variable should no longer exist in the config.
-    it('prunes variables from the config if they no longer exist on the template', () => {
-      const spy = spyOn(PipelineTemplateReader, 'getPipelineTemplateFromSourceUrl');
-      spy.and.callFake(() => $q.resolve(templateB));
-
-      ctrl.initialize();
-      $scope.$digest();
-
-      ctrl.pipelineTemplateConfig = ctrl.buildConfig();
-
-      spy.and.callFake(() => $q.resolve(templateA));
-      ctrl.initialize();
-      $scope.$digest();
-
-      expect(ctrl.buildConfig().config.pipeline.variables).toEqual({
-        letters: ['a', 'b', 'c'],
-      });
-    });
-  });
-
-  describe('config creation', () => {
-    beforeEach(() => {
-      spyOn(PipelineTemplateReader, 'getPipelineTemplateFromSourceUrl').and.callFake(() => {
-        return $q.resolve(template);
-      });
-    });
-
-    it('builds map of variables', () => {
-      ctrl.initialize();
-      $scope.$digest();
-      const templateConfig = ctrl.buildConfig();
-
-      expect(templateConfig.config.pipeline.variables).toEqual({
-        credentials: 'my-google-account',
-        cloudProvider: 'gce',
-        someObject: yamlAsObj,
-        someList: ['a', 'b', 'c'],
-        someInt: 42,
-      });
-    });
-  });
-
-  describe('input validation', () => {
-    const createVariable = (type: string, value: any): IVariable => {
-      return {
-        type,
-        value,
-        name: 'variableName',
-      };
-    };
-
-    beforeEach(() => {
-      spyOn(PipelineTemplateReader, 'getPipelineTemplateFromSourceUrl').and.callFake(() => {
-        return $q.resolve(template);
-      });
-    });
-
-    it('verifies that input variables are not empty', () => {
-      ctrl.initialize();
-      $scope.$digest();
-
-      let v = createVariable('string', '');
-      ctrl.handleVariableChange(v);
-      expect(v.errors).toEqual([{ message: 'Field is required.' }]);
-
-      v = createVariable('object', '');
-      ctrl.handleVariableChange(v);
-      expect(v.errors).toEqual([{ message: 'Field is required.' }]);
-
-      v = createVariable('float', '');
-      ctrl.handleVariableChange(v);
-      expect(v.errors).toEqual([{ message: 'Field is required.' }]);
-
-      v = createVariable('int', '');
-      ctrl.handleVariableChange(v);
-      expect(v.errors).toEqual([{ message: 'Field is required.' }]);
-
-      v = createVariable('list', ['']);
-      ctrl.handleVariableChange(v);
-      expect(v.errors).toEqual([{ message: 'Field is required.', key: 0 }]);
-    });
-
-    it('validates yaml', () => {
-      ctrl.initialize();
-      $scope.$digest();
-
-      let v = createVariable('object', yaml);
-      ctrl.handleVariableChange(v);
-      expect(v.errors.length).toEqual(0);
-
-      const badYaml = `dropped: 'quote`;
-      v = createVariable('object', badYaml);
-      ctrl.handleVariableChange(v);
-      expect(v.errors.length).toEqual(1);
-    });
-  });
-});

package/src/pipeline/config/templates/configurePipelineTemplateModal.controller.ts

@@ -1,247 +0,0 @@
-import type { IController, IHttpPromiseCallbackArg, IScope } from 'angular';
-import { module } from 'angular';
-import type { IModalInstanceService } from 'angular-ui-bootstrap';
-import { dump, load } from 'js-yaml';
-import { chain, has, without } from 'lodash';
-
-import type {
-  IPipelineTemplate,
-  IPipelineTemplateConfig,
-  IPipelineTemplatePlanError,
-  IPipelineTemplatePlanResponse,
-  IVariableMetadata,
-} from './PipelineTemplateReader';
-import { PipelineTemplateReader } from './PipelineTemplateReader';
-import type { Application } from '../../../application/application.model';
-import type { IVariable } from './inputs/variableInput.service';
-import { VariableValidatorService } from './validators/variableValidator.service';
-
-export interface IVariableMetadataGroup {
-  name: string;
-  variableMetadata: IVariableMetadata[];
-}
-
-export interface IState {
-  error: boolean;
-  loading: boolean;
-  loadingError: boolean;
-  noVariables: boolean;
-  planErrors: IPipelineTemplatePlanError[];
-  inheritTemplateParameters: boolean;
-  inheritTemplateTriggers: boolean;
-  inheritTemplateExpectedArtifacts: boolean;
-}
-
-export class ConfigurePipelineTemplateModalController implements IController {
-  public pipelineName: string;
-  public variableMetadataGroups: IVariableMetadataGroup[];
-  public variables: IVariable[];
-  public state: IState = {
-    loading: true,
-    error: false,
-    planErrors: null,
-    loadingError: false,
-    noVariables: false,
-    inheritTemplateParameters: true,
-    inheritTemplateTriggers: true,
-    inheritTemplateExpectedArtifacts: true,
-  };
-  private template: IPipelineTemplate;
-  private source: string;
-
-  public static $inject = [
-    '$scope',
-    '$uibModalInstance',
-    'application',
-    'pipelineTemplateConfig',
-    'isNew',
-    'pipelineId',
-    'executionId',
-  ];
-  constructor(
-    private $scope: IScope,
-    private $uibModalInstance: IModalInstanceService,
-    private application: Application,
-    public pipelineTemplateConfig: IPipelineTemplateConfig,
-    public isNew: boolean,
-    private pipelineId: string,
-    private executionId: string,
-  ) {}
-
-  public $onInit(): void {
-    this.initialize();
-  }
-
-  public initialize(): void {
-    const { config } = this.pipelineTemplateConfig;
-    const defaultConfiguration = { inherit: ['expectedArtifacts', 'parameters', 'triggers'] };
-    const inherit: string[] = (config.configuration || defaultConfiguration).inherit;
-
-    this.state.inheritTemplateExpectedArtifacts = inherit.includes('expectedArtifacts');
-    this.state.inheritTemplateParameters = inherit.includes('parameters');
-    this.state.inheritTemplateTriggers = inherit.includes('triggers');
-    this.pipelineName = config.pipeline.name;
-    this.source = config.pipeline.template.source;
-    this.loadTemplate()
-      .then(() => {
-        this.groupVariableMetadata();
-        this.initializeVariables();
-        if (!this.variables.length) {
-          this.state.noVariables = true;
-        }
-      })
-      .then(() => (this.state.loading = false))
-      .catch(() => {
-        Object.assign(this.state, { loading: false, error: false, planErrors: null, loadingError: true });
-      });
-  }
-
-  public cancel(): void {
-    this.$uibModalInstance.dismiss();
-  }
-
-  public formIsValid(): boolean {
-    return this.variables.every((v) => v.errors.length === 0);
-  }
-
-  public submit(): PromiseLike<void> {
-    const config = this.buildConfig();
-    return PipelineTemplateReader.getPipelinePlan(config)
-      .then((plan) => {
-        const { parameterConfig, expectedArtifacts, triggers } = plan;
-        const inherited = {
-          ...config,
-          ...(this.state.inheritTemplateParameters && parameterConfig ? { parameterConfig } : {}),
-          ...(this.state.inheritTemplateExpectedArtifacts && expectedArtifacts ? { expectedArtifacts } : {}),
-          ...(this.state.inheritTemplateTriggers && triggers ? { triggers } : {}),
-        };
-        this.$uibModalInstance.close({ plan, config: inherited });
-      })
-      .catch((response: IHttpPromiseCallbackArg<IPipelineTemplatePlanResponse>) => {
-        Object.assign(this.state, { loading: false, error: true, planErrors: response.data && response.data.errors });
-      });
-  }
-
-  public dismissError(): void {
-    Object.assign(this.state, { error: false, planErrors: null, loadingError: false });
-  }
-
-  public buildConfig(): IPipelineTemplateConfig {
-    const inheritConfig = [
-      ...(this.state.inheritTemplateParameters ? ['parameters'] : []),
-      ...(this.state.inheritTemplateExpectedArtifacts ? ['expectedArtifacts'] : []),
-      ...(this.state.inheritTemplateTriggers ? ['triggers'] : []),
-    ];
-
-    return {
-      ...(this.pipelineTemplateConfig || {}),
-      type: 'templatedPipeline',
-      name: this.pipelineName,
-      application: this.application.name,
-      config: {
-        schema: '1',
-        pipeline: {
-          name: this.pipelineName,
-          application: this.application.name,
-          pipelineConfigId: this.pipelineId,
-          template: { source: this.source },
-          variables: this.transformVariablesForPipelinePlan(),
-        },
-        configuration: {
-          inherit: inheritConfig,
-        },
-      },
-    };
-  }
-
-  private loadTemplate(): PromiseLike<void> {
-    return PipelineTemplateReader.getPipelineTemplateFromSourceUrl(this.source, this.executionId, this.pipelineId).then(
-      (template) => {
-        this.template = template;
-      },
-    );
-  }
-
-  private transformVariablesForPipelinePlan(): { [key: string]: any } {
-    return chain(this.variables || [])
-      .cloneDeep()
-      .map((v) => {
-        if (v.type === 'object') {
-          v.value = load(v.value);
-        } else if (v.type === 'int') {
-          return [v.name, parseInt(v.value, 10)];
-        } else if (v.type === 'float') {
-          return [v.name, parseFloat(v.value)];
-        }
-        return [v.name, v.value];
-      })
-      .fromPairs()
-      .value();
-  }
-
-  public handleVariableChange = (newVariable: IVariable): void => {
-    const oldVariable = this.getVariable(newVariable.name);
-    newVariable.errors = VariableValidatorService.validate(newVariable);
-    this.variables = without(this.variables, oldVariable).concat([newVariable]);
-
-    // `handleVariableChange` is passed to a React component, and Angular has no idea when it has been called.
-    this.$scope.$digest();
-  };
-
-  private getVariable(name: string): IVariable {
-    return this.variables.find((v) => v.name === name);
-  }
-
-  private groupVariableMetadata(): void {
-    this.variableMetadataGroups = [];
-    (this.template.variables || []).forEach((v) => {
-      if (v.group) {
-        this.addToGroup(v.group, v);
-      } else {
-        this.addToGroup('Ungrouped', v);
-      }
-    });
-  }
-
-  private addToGroup(groupName: string, metadata: IVariableMetadata): void {
-    const group = this.variableMetadataGroups.find((g) => g.name === groupName);
-    if (group) {
-      group.variableMetadata.push(metadata);
-    } else {
-      this.variableMetadataGroups.push({ name: groupName, variableMetadata: [metadata] });
-    }
-  }
-
-  private initializeVariables(): void {
-    this.variables = (this.template.variables || []).map((v) => {
-      return {
-        name: v.name,
-        type: v.type || 'string',
-        errors: [],
-        value: this.getInitialVariableValue(v),
-        hideErrors: true,
-      };
-    });
-    this.variables.forEach((v) => (v.errors = VariableValidatorService.validate(v)));
-  }
-
-  private getInitialVariableValue(variable: IVariableMetadata): any {
-    if (has(this.pipelineTemplateConfig, `config.pipeline.variables.${variable.name}`)) {
-      let value = this.pipelineTemplateConfig.config.pipeline.variables[variable.name];
-      if (variable.type === 'object' && value) {
-        value = dump(value);
-      }
-      return value;
-    } else if (variable.type === 'object' && has(variable, 'defaultValue')) {
-      return dump(variable.defaultValue);
-    } else {
-      return variable.type === 'list' && !variable.defaultValue ? [''] : variable.defaultValue;
-    }
-  }
-}
-
-export const CONFIGURE_PIPELINE_TEMPLATE_MODAL_CTRL = 'spinnaker.core.pipeline.configureTemplate.modal.controller';
-module(CONFIGURE_PIPELINE_TEMPLATE_MODAL_CTRL, []).controller(
-  'ConfigurePipelineTemplateModalCtrl',
-  ConfigurePipelineTemplateModalController,
-);

package/src/pipeline/config/templates/configurePipelineTemplateModal.html

@@ -1,54 +0,0 @@
-<div ng-if="ctrl.state.loading" style="height: 300px">
-  <loading-spinner size="'small'"></loading-spinner>
-</div>
-<v2-modal-wizard
-  heading="Define template parameters: {{::ctrl.pipelineName}}"
-  dismiss="$dismiss()"
-  ng-if="!ctrl.state.loading"
->
-  <v2-wizard-page
-    key="{{::group.name}}"
-    label="{{::group.name}}"
-    mark-complete-on-view="false"
-    ng-if="!ctrl.state.error && !ctrl.state.loading && !ctrl.state.loadingError && ctrl.variableMetadataGroups"
-    ng-repeat="group in ctrl.variableMetadataGroups"
-  >
-    <variable
-      ng-repeat="metadata in group.variableMetadata"
-      class="clearfix"
-      variable-metadata="metadata"
-      variable="ctrl.getVariable(metadata.name)"
-      on-change="ctrl.handleVariableChange"
-    ></variable>
-  </v2-wizard-page>
-  <div ng-if="ctrl.state.error" class="alert alert-danger">
-    <p>Could not generate pipeline from provided template configuration.</p>
-    <p><template-plan-errors errors="ctrl.state.planErrors"></template-plan-errors></p>
-    <p><a href ng-click="ctrl.dismissError()">[dismiss]</a></p>
-  </div>
-  <div ng-if="ctrl.state.loadingError" class="alert alert-danger">
-    <p>Could not load pipeline template.</p>
-  </div>
-  <div ng-if="ctrl.state.noVariables && !ctrl.state.error" class="alert alert-info">
-    <p>This template has no variables to configure.</p>
-  </div>
-  <div ng-if="!ctrl.state.error" class="alert alert-info">
-    <strong>Inherit the following configuration from the template</strong>
-    <p><input type="checkbox" ng-model="ctrl.state.inheritTemplateExpectedArtifacts" /> Expected Artifacts</p>
-    <p><input type="checkbox" ng-model="ctrl.state.inheritTemplateTriggers" /> Triggers</p>
-    <p><input type="checkbox" ng-model="ctrl.state.inheritTemplateParameters" /> Parameters</p>
-  </div>
-  <div class="modal-footer" ng-if="!ctrl.state.loading">
-    <button ng-if="!ctrl.isNew && !ctrl.state.noVariables" class="btn btn-default" ng-click="ctrl.cancel()">
-      Cancel
-    </button>
-    <button ng-if="ctrl.state.noVariables" class="btn btn-default" ng-click="ctrl.submit()">Dismiss</button>
-    <submit-button
-      label="'Configure'"
-      ng-if="!ctrl.state.noVariables && !ctrl.state.error && !ctrl.state.loadingError"
-      is-disabled="!ctrl.formIsValid()"
-      on-click="ctrl.submit()"
-    >
-    </submit-button>
-  </div>
-</v2-modal-wizard>

package/src/pipeline/config/templates/pipelineTemplate.module.ts

@@ -1,23 +0,0 @@
-import { module } from 'angular';
-
-import { CONFIGURE_PIPELINE_TEMPLATE_MODAL_CTRL } from './configurePipelineTemplateModal.controller';
-import './inputs/BooleanInput';
-import './inputs/ListInput';
-import './inputs/NumberInput';
-import './inputs/ObjectInput';
-import './inputs/StringInput';
-import { TEMPLATE_PLAN_ERRORS } from './templatePlanErrors.component';
-import { CONFIGURE_PIPELINE_TEMPLATE_MODAL_V2_CTRL } from './v2/configurePipelineTemplateModalV2.controller';
-import './validators/list.validator';
-import './validators/number.validator';
-import './validators/object.validator';
-import './validators/string.validator';
-import { VARIABLE } from './variable.component';
-
-export const PIPELINE_TEMPLATE_MODULE = 'spinnaker.core.pipelineTemplate.module';
-module(PIPELINE_TEMPLATE_MODULE, [
-  CONFIGURE_PIPELINE_TEMPLATE_MODAL_CTRL,
-  CONFIGURE_PIPELINE_TEMPLATE_MODAL_V2_CTRL,
-  TEMPLATE_PLAN_ERRORS,
-  VARIABLE,
-]);

package/src/pipeline/config/templates/templatePlanErrors.component.ts

@@ -1,11 +0,0 @@
-import { module } from 'angular';
-import { react2angular } from 'react2angular';
-
-import { TemplatePlanErrors } from './TemplatePlanErrors';
-import { withErrorBoundary } from '../../../presentation/SpinErrorBoundary';
-
-export const TEMPLATE_PLAN_ERRORS = 'spinnaker.core.templatePlanErrors.component';
-module(TEMPLATE_PLAN_ERRORS, []).component(
-  'templatePlanErrors',
-  react2angular(withErrorBoundary(TemplatePlanErrors, 'templatePlanErrors'), ['errors']),
-);