@spinnaker/core 2026.0.2 → 2026.1.0

package/dist/managed/graphql/client.d.ts

@@ -1,5 +1,5 @@
 import { ApolloClient } from '@apollo/client';
 export declare const createApolloClient: () => {
     client: ApolloClient<import("@apollo/client").NormalizedCacheObject>;
-    onRefresh: () => Promise<import("@apollo/client").ApolloQueryResult<any>[]>;
+    onRefresh: () => Promise<import("@apollo/client").InteropApolloQueryResult<any>[]>;
 };

package/dist/managed/graphql/graphql-sdk.d.ts

@@ -814,7 +814,7 @@ export declare const FetchApplicationDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchApplicationQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationQuery, FetchApplicationQueryVariables>): Apollo.QueryResult<FetchApplicationQuery, Exact<{
+export declare function useFetchApplicationQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationQuery, FetchApplicationQueryVariables>): Apollo.InteropQueryResult<FetchApplicationQuery, Exact<{
     appName: string;
     statuses?: MdArtifactStatusInEnvironment | MdArtifactStatusInEnvironment[];
 }>>;
@@ -842,7 +842,7 @@ export declare const FetchCurrentVersionDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchCurrentVersionQuery(baseOptions: Apollo.QueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>): Apollo.QueryResult<FetchCurrentVersionQuery, Exact<{
+export declare function useFetchCurrentVersionQuery(baseOptions: Apollo.QueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>): Apollo.InteropQueryResult<FetchCurrentVersionQuery, Exact<{
     appName: string;
 }>>;
 export declare function useFetchCurrentVersionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>): Apollo.LazyQueryResultTuple<FetchCurrentVersionQuery, Exact<{
@@ -869,7 +869,7 @@ export declare const FetchVersionsHistoryDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchVersionsHistoryQuery(baseOptions: Apollo.QueryHookOptions<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>): Apollo.QueryResult<FetchVersionsHistoryQuery, Exact<{
+export declare function useFetchVersionsHistoryQuery(baseOptions: Apollo.QueryHookOptions<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>): Apollo.InteropQueryResult<FetchVersionsHistoryQuery, Exact<{
     appName: string;
     limit?: number;
 }>>;
@@ -897,7 +897,7 @@ export declare const FetchPinnedVersionsDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchPinnedVersionsQuery(baseOptions: Apollo.QueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>): Apollo.QueryResult<FetchPinnedVersionsQuery, Exact<{
+export declare function useFetchPinnedVersionsQuery(baseOptions: Apollo.QueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>): Apollo.InteropQueryResult<FetchPinnedVersionsQuery, Exact<{
     appName: string;
 }>>;
 export declare function useFetchPinnedVersionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>): Apollo.LazyQueryResultTuple<FetchPinnedVersionsQuery, Exact<{
@@ -924,7 +924,7 @@ export declare const FetchVersionDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchVersionQuery(baseOptions: Apollo.QueryHookOptions<FetchVersionQuery, FetchVersionQueryVariables>): Apollo.QueryResult<FetchVersionQuery, Exact<{
+export declare function useFetchVersionQuery(baseOptions: Apollo.QueryHookOptions<FetchVersionQuery, FetchVersionQueryVariables>): Apollo.InteropQueryResult<FetchVersionQuery, Exact<{
     appName: string;
     versions?: string | string[];
 }>>;
@@ -952,7 +952,7 @@ export declare const FetchResourceStatusDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchResourceStatusQuery(baseOptions: Apollo.QueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>): Apollo.QueryResult<FetchResourceStatusQuery, Exact<{
+export declare function useFetchResourceStatusQuery(baseOptions: Apollo.QueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>): Apollo.InteropQueryResult<FetchResourceStatusQuery, Exact<{
     appName: string;
 }>>;
 export declare function useFetchResourceStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>): Apollo.LazyQueryResultTuple<FetchResourceStatusQuery, Exact<{
@@ -978,7 +978,7 @@ export declare const FetchNotificationsDocument: Apollo.DocumentNode;
  *   },
  * });
  */
-export declare function useFetchNotificationsQuery(baseOptions: Apollo.QueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>): Apollo.QueryResult<FetchNotificationsQuery, Exact<{
+export declare function useFetchNotificationsQuery(baseOptions: Apollo.QueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>): Apollo.InteropQueryResult<FetchNotificationsQuery, Exact<{
     appName: string;
 }>>;
 export declare function useFetchNotificationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>): Apollo.LazyQueryResultTuple<FetchNotificationsQuery, Exact<{
@@ -1004,7 +1004,7 @@ export declare const FetchApplicationManagementDataDocument: Apollo.DocumentNode
  *   },
  * });
  */
-export declare function useFetchApplicationManagementDataQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>): Apollo.QueryResult<FetchApplicationManagementDataQuery, Exact<{
+export declare function useFetchApplicationManagementDataQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>): Apollo.InteropQueryResult<FetchApplicationManagementDataQuery, Exact<{
     appName: string;
 }>>;
 export declare function useFetchApplicationManagementDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>): Apollo.LazyQueryResultTuple<FetchApplicationManagementDataQuery, Exact<{
@@ -1030,7 +1030,7 @@ export declare const FetchApplicationManagementStatusDocument: Apollo.DocumentNo
  *   },
  * });
  */
-export declare function useFetchApplicationManagementStatusQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>): Apollo.QueryResult<FetchApplicationManagementStatusQuery, Exact<{
+export declare function useFetchApplicationManagementStatusQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>): Apollo.InteropQueryResult<FetchApplicationManagementStatusQuery, Exact<{
     appName: string;
 }>>;
 export declare function useFetchApplicationManagementStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>): Apollo.LazyQueryResultTuple<FetchApplicationManagementStatusQuery, Exact<{

package/dist/pipeline/config/stages/bakeManifest/ManifestRenderers.d.ts

@@ -5,6 +5,6 @@ export declare enum ManifestRenderers {
     KUSTOMIZE = "KUSTOMIZE",
     KUSTOMIZE4 = "KUSTOMIZE4"
 }
-export declare const HELM_RENDERERS: Readonly<ManifestRenderers[]>;
+export declare const HELM_RENDERERS: readonly ManifestRenderers[];
 export declare const HELMFILE_RENDERER: Readonly<ManifestRenderers>;
-export declare const KUSTOMIZE_RENDERERS: Readonly<ManifestRenderers[]>;
+export declare const KUSTOMIZE_RENDERERS: readonly ManifestRenderers[];

package/dist/pipeline/config/triggers/Triggers.d.ts

@@ -4,6 +4,7 @@ import type { IPipeline } from '../../../domain';
 export interface ITriggersProps {
     application: Application;
     pipeline: IPipeline;
+    pipelineConfig?: IPipeline;
     fieldUpdated: () => void;
     updatePipelineConfig: (changes: Partial<IPipeline>) => void;
     revertCount: number;

package/dist/pipeline/config/triggers/index.d.ts

@@ -11,4 +11,3 @@ import './plugin/plugin.trigger';
 import './pubsub/pubsub.trigger';
 import './travis/travis.trigger';
 import './webhook/webhook.trigger';
-import './wercker/wercker.trigger';

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/spinnaker/spinnaker.git"
   },
   "license": "Apache-2.0",
-  "version": "2026.0.2",
+  "version": "2026.1.0",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "publishConfig": {
@@ -59,7 +59,7 @@
     "jquery-textcomplete": "1.6.1",
     "js-worker-search": "npm:js-worker-search-uuid-fix@^1.4.2",
     "js-yaml": "3.13.1",
-    "lodash": "4.17.23",
+    "lodash": "4.18.1",
     "lodash-decorators": "4.5.0",
     "luxon": "1.23.0",
     "memoize-one": "6.0.0",
@@ -128,5 +128,5 @@
     "shx": "0.3.3",
     "typescript": "5.0.4"
   },
-  "gitHead": "f81cd582f8abad99f82ee96ae11cdfb59a0c643c"
+  "gitHead": "b43289872672de89234911de45d1cba0dd18373f"
 }

package/src/application/search/react-ultimate-pagination.d.ts

@@ -22,7 +22,7 @@ declare module 'react-ultimate-pagination' {
 
   export function createUltimatePagination(options: {
     itemTypeToComponent: ItemTypeToComponent;
-    WrapperComponent: React.ComponentClass = 'div';
+    WrapperComponent?: React.ComponentClass | string;
   }): React.ComponentClass<IUltimatePaginationProps>;
   export interface ItemTypes {
     PAGE: 'PAGE';

package/src/ci/igor.service.ts

@@ -6,7 +6,6 @@ import type { IBuild, IGcbTrigger, IJobConfig } from '../domain';
 export enum BuildServiceType {
   Jenkins = 'jenkins',
   Travis = 'travis',
-  Wercker = 'wercker',
   Concourse = 'concourse',
 }
 

package/src/domain/ITrigger.ts

@@ -51,13 +51,7 @@ export interface IBuildTrigger extends ITrigger {
   project: string;
   propertyFile?: string;
   master: string;
-  type: 'jenkins' | 'travis' | 'wercker' | 'concourse';
-}
-
-export interface IWerckerTrigger extends IBuildTrigger {
-  app: string;
-  pipeline: string;
-  type: 'wercker';
+  type: 'jenkins' | 'travis' | 'concourse';
 }
 
 export interface IConcourseTrigger extends IBuildTrigger {
@@ -94,9 +88,3 @@ export interface IWebhookTrigger extends ITrigger {
 export interface ICDEventsTrigger extends IWebhookTrigger {
   attributeConstraints: { [key: string]: string };
 }
-
-export interface IWerckerTrigger extends IBuildTrigger {
-  app: string;
-  pipeline: string;
-  type: 'wercker';
-}

package/src/help/help.contents.ts

@@ -351,12 +351,6 @@ const helpContents: { [key: string]: string } = {
       If Travis reports the build status as UNSTABLE,
       Spinnaker will mark the stage as TERMINAL; subsequent execution will be determined based on the configuration of the
       <b>If build fails</b> option for this stage.`,
-  'pipeline.config.wercker.markUnstableAsSuccessful.true':
-    'If Wercker reports the build status as UNSTABLE, Spinnaker will mark the stage as SUCCEEDED and continue execution of the pipeline.',
-  'pipeline.config.wercker.markUnstableAsSuccessful.false': `
-      If Wercker reports the build status as UNSTABLE,
-      Spinnaker will mark the stage as FAILED; subsequent execution will be determined based on the configuration of the
-      <b>If build fails</b> option for this stage.`,
   'pipeline.config.cron.expression':
     '<strong>Format (Year is optional)</strong><p><samp>Seconds  Minutes  Hour  DayOfMonth  Month  DayOfWeek  (Year)</samp></p>' +
     '<p><strong>Example: every 30 minutes</strong></p><samp>0 0/30 * * * ?</samp>' +
@@ -488,11 +482,9 @@ const helpContents: { [key: string]: string } = {
     'if unchecked, marks the stage as successful right away without waiting for the Jenkins job to complete',
   'travis.waitForCompletion':
     'if unchecked, marks the stage as successful right away without waiting for the Travis job to complete',
-  'wercker.waitForCompletion':
-    'if unchecked, marks the stage as successful right away without waiting for the Wercker job to complete',
   'script.waitForCompletion':
     'if unchecked, marks the stage as successful right away without waiting for the script to complete',
-  // eslint-disable-next-line no-useless-escape
+
   'markdown.examples': `
     Some examples of markdown syntax: <br/> \`*italic*\` <br/> \`**bold**\` <br/> \`[link text](http://url-goes-here)\`
   `,

package/src/pipeline/config/pipelineConfigView.html

@@ -5,6 +5,7 @@
       application="application"
       field-updated="stageFieldUpdated"
       pipeline="isV2TemplatedPipeline ? pipeline : pipelineConfig"
+      pipeline-config="pipelineConfig"
       update-pipeline-config="updatePipelineConfig"
       revert-count="viewState.revertCount"
     >

package/src/pipeline/config/stages/bakeManifest/ManifestRenderers.ts

@@ -6,9 +6,9 @@ export enum ManifestRenderers {
   KUSTOMIZE4 = 'KUSTOMIZE4',
 }
 
-export const HELM_RENDERERS: Readonly<ManifestRenderers[]> = [ManifestRenderers.HELM2, ManifestRenderers.HELM3];
+export const HELM_RENDERERS: readonly ManifestRenderers[] = [ManifestRenderers.HELM2, ManifestRenderers.HELM3];
 export const HELMFILE_RENDERER: Readonly<ManifestRenderers> = ManifestRenderers.HELMFILE;
-export const KUSTOMIZE_RENDERERS: Readonly<ManifestRenderers[]> = [
+export const KUSTOMIZE_RENDERERS: readonly ManifestRenderers[] = [
   ManifestRenderers.KUSTOMIZE,
   ManifestRenderers.KUSTOMIZE4,
 ];

package/src/pipeline/config/stages/createLoadBalancer/createLoadBalancerStage.js

@@ -30,23 +30,50 @@ angular
         $scope.stage.loadBalancers = $scope.stage.loadBalancers || [];
       }
 
+      function appendLoadBalancers(loadBalancers) {
+        if (Array.isArray(loadBalancers)) {
+          $scope.stage.loadBalancers.push(...loadBalancers);
+        } else if (loadBalancers) {
+          $scope.stage.loadBalancers.push(loadBalancers);
+        }
+      }
+
+      function updateLoadBalancerAtIndex(loadBalancer, index) {
+        if (Array.isArray(loadBalancer)) {
+          $scope.stage.loadBalancers.splice(index, 1, ...loadBalancer);
+        } else if (loadBalancer) {
+          $scope.stage.loadBalancers[index] = loadBalancer;
+        }
+      }
+
+      function openLoadBalancerModal(config, loadBalancer, isNew) {
+        if (config.pipelineCreateLoadBalancerModal) {
+          return config.pipelineCreateLoadBalancerModal({
+            application: $scope.application,
+            loadBalancer,
+            isNew,
+            $uibModal,
+          });
+        }
+        return $uibModal.open({
+          templateUrl: config.createLoadBalancerTemplateUrl,
+          controller: `${config.createLoadBalancerController} as ctrl`,
+          size: 'lg',
+          resolve: {
+            application: () => $scope.application,
+            loadBalancer: () => loadBalancer,
+            isNew: () => isNew,
+            forPipelineConfig: () => true,
+          },
+        }).result;
+      }
+
       this.addLoadBalancer = function () {
         ProviderSelectionService.selectProvider($scope.application, 'loadBalancer').then(function (selectedProvider) {
           const config = CloudProviderRegistry.getValue(selectedProvider, 'loadBalancer');
-          $uibModal
-            .open({
-              templateUrl: config.createLoadBalancerTemplateUrl,
-              controller: `${config.createLoadBalancerController} as ctrl`,
-              size: 'lg',
-              resolve: {
-                application: () => $scope.application,
-                loadBalancer: () => null,
-                isNew: () => true,
-                forPipelineConfig: () => true,
-              },
-            })
-            .result.then(function (newLoadBalancer) {
-              $scope.stage.loadBalancers.push(newLoadBalancer);
+          openLoadBalancerModal(config, null, true)
+            .then(function (newLoadBalancer) {
+              appendLoadBalancers(newLoadBalancer);
             })
             .catch(() => {});
         });
@@ -55,20 +82,10 @@ angular
       this.editLoadBalancer = function (loadBalancer, index) {
         ProviderSelectionService.selectProvider($scope.application, 'loadBalancer').then(function (selectedProvider) {
           const config = CloudProviderRegistry.getValue(selectedProvider, 'loadBalancer');
-          $uibModal
-            .open({
-              templateUrl: config.createLoadBalancerTemplateUrl,
-              controller: `${config.createLoadBalancerController} as ctrl`,
-              size: 'lg',
-              resolve: {
-                application: () => $scope.application,
-                loadBalancer: () => angular.copy(loadBalancer),
-                isNew: () => false,
-                forPipelineConfig: () => true,
-              },
-            })
-            .result.then(function (updatedLoadBalancer) {
-              $scope.stage.loadBalancers[index] = updatedLoadBalancer;
+          const loadBalancerCopy = angular.copy(loadBalancer);
+          openLoadBalancerModal(config, loadBalancerCopy, false)
+            .then(function (updatedLoadBalancer) {
+              updateLoadBalancerAtIndex(updatedLoadBalancer, index);
             })
             .catch(() => {});
         });

package/src/pipeline/config/stages/createLoadBalancer/createLoadBalancerStage.spec.js

@@ -0,0 +1,101 @@
+import { CloudProviderRegistry, ProviderSelectionService } from '../../../../cloudProvider';
+import { name as moduleName } from './createLoadBalancerStage';
+
+describe('createLoadBalancerStageCtrl', function () {
+  beforeEach(() => {
+    window.module(moduleName);
+  });
+
+  beforeEach(
+    window.inject(function ($controller, $rootScope, $q) {
+      this.$scope = $rootScope.$new();
+      this.$scope.stage = {};
+      this.$scope.application = {};
+      this.$uibModal = {
+        open: jasmine.createSpy('open').and.returnValue({ result: $q.when([{ name: 'lb1' }, { name: 'lb2' }]) }),
+      };
+
+      spyOn(ProviderSelectionService, 'selectProvider').and.returnValue($q.when('gce'));
+      this.cloudProviderConfig = {
+        createLoadBalancerTemplateUrl: 'template',
+        createLoadBalancerController: 'ctrl',
+      };
+      spyOn(CloudProviderRegistry, 'getValue').and.callFake(() => this.cloudProviderConfig);
+
+      this.ctrl = $controller('createLoadBalancerStageCtrl', {
+        $scope: this.$scope,
+        $uibModal: this.$uibModal,
+      });
+      this.$rootScope = $rootScope;
+      this.$q = $q;
+    }),
+  );
+
+  it('flattens array results when adding load balancers', function () {
+    this.ctrl.addLoadBalancer();
+    this.$rootScope.$digest();
+
+    expect(this.$scope.stage.loadBalancers).toEqual([{ name: 'lb1' }, { name: 'lb2' }]);
+  });
+
+  it('splices array results when editing a load balancer', function () {
+    this.$scope.stage.loadBalancers = [{ name: 'old' }];
+    this.$uibModal.open.and.returnValue({ result: this.$q.when([{ name: 'new1' }, { name: 'new2' }]) });
+
+    this.ctrl.editLoadBalancer(this.$scope.stage.loadBalancers[0], 0);
+    this.$rootScope.$digest();
+
+    expect(this.$scope.stage.loadBalancers).toEqual([{ name: 'new1' }, { name: 'new2' }]);
+  });
+
+  it('uses provider hook when adding load balancers', function () {
+    const hookResult = { name: 'hook-lb' };
+    this.cloudProviderConfig.pipelineCreateLoadBalancerModal = jasmine
+      .createSpy('pipelineCreateLoadBalancerModal')
+      .and.returnValue(this.$q.when(hookResult));
+
+    this.ctrl.addLoadBalancer();
+    this.$rootScope.$digest();
+
+    expect(this.cloudProviderConfig.pipelineCreateLoadBalancerModal).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        application: this.$scope.application,
+        loadBalancer: null,
+        isNew: true,
+        $uibModal: this.$uibModal,
+      }),
+    );
+    expect(this.$uibModal.open).not.toHaveBeenCalled();
+    expect(this.$scope.stage.loadBalancers).toEqual([hookResult]);
+  });
+
+  it('uses provider hook when editing a load balancer', function () {
+    this.$scope.stage.loadBalancers = [{ name: 'old' }];
+    const hookResult = { name: 'updated' };
+    this.cloudProviderConfig.pipelineCreateLoadBalancerModal = jasmine
+      .createSpy('pipelineCreateLoadBalancerModal')
+      .and.returnValue(this.$q.when(hookResult));
+
+    this.ctrl.editLoadBalancer(this.$scope.stage.loadBalancers[0], 0);
+    this.$rootScope.$digest();
+
+    const hookArgs = this.cloudProviderConfig.pipelineCreateLoadBalancerModal.calls.mostRecent().args[0];
+    expect(hookArgs.loadBalancer).toEqual({ name: 'old' });
+    expect(hookArgs.loadBalancer).not.toBe(this.$scope.stage.loadBalancers[0]);
+    expect(hookArgs.isNew).toBe(false);
+    expect(this.$uibModal.open).not.toHaveBeenCalled();
+    expect(this.$scope.stage.loadBalancers).toEqual([hookResult]);
+  });
+
+  it('flattens array results when hook returns array', function () {
+    this.cloudProviderConfig.pipelineCreateLoadBalancerModal = jasmine
+      .createSpy('pipelineCreateLoadBalancerModal')
+      .and.returnValue(this.$q.when([{ name: 'hook1' }, { name: 'hook2' }]));
+
+    this.ctrl.addLoadBalancer();
+    this.$rootScope.$digest();
+
+    expect(this.$uibModal.open).not.toHaveBeenCalled();
+    expect(this.$scope.stage.loadBalancers).toEqual([{ name: 'hook1' }, { name: 'hook2' }]);
+  });
+});

package/src/pipeline/config/triggers/MetadataPageContent.spec.tsx

@@ -0,0 +1,140 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { MetadataPage } from './MetadataPageContent';
+import type { IPipeline, IPipelineTag } from '../../../domain';
+
+describe('<MetadataPageContent />', () => {
+  let updatePipelineConfigSpy: jasmine.Spy;
+
+  const makePipeline = (overrides: Partial<IPipeline> = {}): IPipeline => ({
+    application: 'products',
+    id: 'pipeline-1',
+    keepWaitingPipelines: false,
+    limitConcurrent: true,
+    name: 'test-pipeline',
+    parameterConfig: [],
+    stages: [],
+    triggers: [],
+    ...overrides,
+  });
+
+  beforeEach(() => {
+    updatePipelineConfigSpy = jasmine.createSpy('updatePipelineConfig');
+  });
+
+  describe('Rendering tags', () => {
+    it('renders tag rows when pipeline has tags', () => {
+      const tags: IPipelineTag[] = [
+        { name: 'service', value: 'products' },
+        { name: 'type', value: 'scale' },
+      ];
+      const pipeline = makePipeline({ tags });
+      const wrapper = mount(<MetadataPage pipeline={pipeline} updatePipelineConfig={updatePipelineConfigSpy} />);
+
+      const tagInputs = wrapper.find('table.tags tbody tr');
+      expect(tagInputs.length).toBe(2);
+
+      const nameInputs = wrapper.find('table.tags tbody input[type="text"]');
+      expect(nameInputs.at(0).prop('value')).toBe('service');
+      expect(nameInputs.at(1).prop('value')).toBe('products');
+      expect(nameInputs.at(2).prop('value')).toBe('type');
+      expect(nameInputs.at(3).prop('value')).toBe('scale');
+    });
+
+    it('renders no tag rows when pipeline.tags is undefined', () => {
+      const pipeline = makePipeline();
+      const wrapper = mount(<MetadataPage pipeline={pipeline} updatePipelineConfig={updatePipelineConfigSpy} />);
+
+      const tagRows = wrapper.find('table.tags tbody tr');
+      expect(tagRows.length).toBe(0);
+    });
+
+    it('renders no tag rows when pipeline.tags is an empty array', () => {
+      const pipeline = makePipeline({ tags: [] });
+      const wrapper = mount(<MetadataPage pipeline={pipeline} updatePipelineConfig={updatePipelineConfigSpy} />);
+
+      const tagRows = wrapper.find('table.tags tbody tr');
+      expect(tagRows.length).toBe(0);
+    });
+  });
+
+  describe('V2 templated pipeline plan vs instance config', () => {
+    it('renders no tags when given the Orca plan which does not include instance-level tags', () => {
+      const instanceConfig = makePipeline({
+        tags: [
+          { name: 'service', value: 'products' },
+          { name: 'type', value: 'eval' },
+        ],
+      });
+
+      const orcaPlan = makePipeline({
+        name: instanceConfig.name,
+        // Orca plan does NOT include instance-level tags
+      });
+
+      const wrapper = mount(<MetadataPage pipeline={orcaPlan} updatePipelineConfig={updatePipelineConfigSpy} />);
+      const tagRows = wrapper.find('table.tags tbody tr');
+      expect(tagRows.length).toBe(0);
+    });
+
+    it('renders tags when given the raw instance config directly', () => {
+      const instanceConfig = makePipeline({
+        tags: [
+          { name: 'service', value: 'products' },
+          { name: 'type', value: 'eval' },
+        ],
+      });
+
+      const wrapper = mount(<MetadataPage pipeline={instanceConfig} updatePipelineConfig={updatePipelineConfigSpy} />);
+      const tagRows = wrapper.find('table.tags tbody tr');
+      expect(tagRows.length).toBe(2);
+    });
+  });
+
+  describe('Adding a tag', () => {
+    it('calls updatePipelineConfig with new empty tag appended', () => {
+      const pipeline = makePipeline({
+        tags: [{ name: 'service', value: 'products' }],
+      });
+      const wrapper = mount(<MetadataPage pipeline={pipeline} updatePipelineConfig={updatePipelineConfigSpy} />);
+
+      wrapper.find('button.add-new').simulate('click');
+      expect(updatePipelineConfigSpy).toHaveBeenCalledTimes(1);
+      expect(updatePipelineConfigSpy).toHaveBeenCalledWith({
+        tags: [
+          { name: 'service', value: 'products' },
+          { name: '', value: '' },
+        ],
+      });
+    });
+
+    it('creates the first tag when pipeline has no tags', () => {
+      const pipeline = makePipeline();
+      const wrapper = mount(<MetadataPage pipeline={pipeline} updatePipelineConfig={updatePipelineConfigSpy} />);
+
+      wrapper.find('button.add-new').simulate('click');
+      expect(updatePipelineConfigSpy).toHaveBeenCalledTimes(1);
+      expect(updatePipelineConfigSpy).toHaveBeenCalledWith({
+        tags: [{ name: '', value: '' }],
+      });
+    });
+  });
+
+  describe('Deleting a tag', () => {
+    it('removes the tag at the clicked index', () => {
+      const tags: IPipelineTag[] = [
+        { name: 'service', value: 'products' },
+        { name: 'type', value: 'scale' },
+      ];
+      const pipeline = makePipeline({ tags });
+      const wrapper = mount(<MetadataPage pipeline={pipeline} updatePipelineConfig={updatePipelineConfigSpy} />);
+
+      wrapper.find('.glyphicon-trash').at(0).simulate('click');
+      expect(updatePipelineConfigSpy).toHaveBeenCalledTimes(1);
+      expect(updatePipelineConfigSpy).toHaveBeenCalledWith({
+        tags: [{ name: 'type', value: 'scale' }],
+      });
+    });
+  });
+});

package/src/pipeline/config/triggers/Triggers.spec.tsx

@@ -0,0 +1,80 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { MetadataPageContent } from './MetadataPageContent';
+import { Triggers } from './Triggers';
+import { ApplicationModelBuilder } from '../../../application';
+import type { IPipeline, IPipelineTag } from '../../../domain';
+
+describe('<Triggers />', () => {
+  const makePipeline = (overrides: Partial<IPipeline> = {}): IPipeline => ({
+    application: 'products',
+    id: 'pipeline-1',
+    keepWaitingPipelines: false,
+    limitConcurrent: true,
+    name: 'test-pipeline',
+    parameterConfig: [],
+    stages: [],
+    triggers: [],
+    ...overrides,
+  });
+
+  const instanceTags: IPipelineTag[] = [
+    { name: 'service', value: 'products' },
+    { name: 'type', value: 'eval' },
+  ];
+
+  let defaultProps: any;
+
+  beforeEach(() => {
+    defaultProps = {
+      application: ApplicationModelBuilder.createApplicationForTests('products'),
+      fieldUpdated: jasmine.createSpy('fieldUpdated'),
+      updatePipelineConfig: jasmine.createSpy('updatePipelineConfig'),
+      revertCount: 0,
+    };
+  });
+
+  describe('MetadataPageContent pipeline prop routing', () => {
+    it('receives the plan pipeline when pipelineConfig is not provided', () => {
+      const plan = makePipeline({ name: 'test-pipeline' });
+
+      const wrapper = shallow(<Triggers {...defaultProps} pipeline={plan} />);
+      const metadataContent = wrapper.find(MetadataPageContent);
+
+      expect(metadataContent.prop('pipeline')).toBe(plan);
+      expect(metadataContent.prop('pipeline').tags).toBeUndefined();
+    });
+
+    it('receives the raw config instead of the plan when pipelineConfig is provided', () => {
+      const plan = makePipeline({ name: 'test-pipeline' });
+      const rawConfig = makePipeline({ name: 'test-pipeline', tags: instanceTags });
+
+      const wrapper = shallow(<Triggers {...defaultProps} pipeline={plan} pipelineConfig={rawConfig} />);
+      const metadataContent = wrapper.find(MetadataPageContent);
+
+      expect(metadataContent.prop('pipeline')).toBe(rawConfig);
+      expect(metadataContent.prop('pipeline').tags).toEqual(instanceTags);
+    });
+
+    it('uses pipeline directly for standard non-templated pipelines without pipelineConfig', () => {
+      const standardPipeline = makePipeline({
+        tags: [{ name: 'env', value: 'prod' }],
+      });
+
+      const wrapper = shallow(<Triggers {...defaultProps} pipeline={standardPipeline} />);
+      const metadataContent = wrapper.find(MetadataPageContent);
+
+      expect(metadataContent.prop('pipeline')).toBe(standardPipeline);
+      expect(metadataContent.prop('pipeline').tags).toEqual([{ name: 'env', value: 'prod' }]);
+    });
+
+    it('passes updatePipelineConfig through to MetadataPageContent', () => {
+      const pipeline = makePipeline();
+      const wrapper = shallow(<Triggers {...defaultProps} pipeline={pipeline} />);
+      const metadataContent = wrapper.find(MetadataPageContent);
+
+      expect(metadataContent.prop('updatePipelineConfig')).toBe(defaultProps.updatePipelineConfig);
+    });
+  });
+});