@spinnaker/google 2026.3.2 → 2026.4.0

package/src/securityGroup/details/GceSecurityGroupDetails.spec.tsx

@@ -1,5 +1,6 @@
+import type { Mock } from 'vitest';
 import React from 'react';
-import { mount as enzymeMount, shallow } from 'enzyme';
+import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
 
 import { AccountService, ConfirmationModalService, DeckRuntimeContext, SecurityGroupWriter } from '@spinnaker/core';
 
@@ -11,11 +12,11 @@ describe('GceSecurityGroupDetails', () => {
   const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) => (
     <DeckRuntimeContext.Provider value={{ services: runtimeServices } as any}>{children}</DeckRuntimeContext.Provider>
   );
-  const mount = (component: React.ReactElement) => enzymeMount(component, { wrappingComponent: RuntimeWrapper });
+  const renderWithRuntime = (component: React.ReactElement) => render(<RuntimeWrapper>{component}</RuntimeWrapper>);
 
   beforeEach(() => {
     runtimeServices = {};
-    spyOn(AccountService, 'challengeDestructiveActions').and.resolveTo(false);
+    vi.spyOn(AccountService, 'challengeDestructiveActions').mockResolvedValue(false);
   });
 
   const firstRoute = {
@@ -48,83 +49,72 @@ describe('GceSecurityGroupDetails', () => {
     };
   }
 
-  async function flush(): Promise<void> {
-    await Promise.resolve();
-    await Promise.resolve();
-  }
-
   it('reloads the current firewall details after the security group data source refreshes', async () => {
     let refreshDetails: (() => void) | undefined;
     const app = {
       securityGroups: {
-        onRefresh: jasmine.createSpy('onRefresh').and.callFake((callback: () => void) => {
+        onRefresh: vi.fn().mockImplementation((callback: () => void) => {
           refreshDetails = callback;
-          return jasmine.createSpy('unsubscribe');
+          return vi.fn();
         }),
       },
     };
     const reader = {
-      getSecurityGroupDetails: jasmine
-        .createSpy('getSecurityGroupDetails')
-        .and.returnValues(
-          Promise.resolve(details('first-firewall', 'before refresh')),
-          Promise.resolve(details('first-firewall', 'after refresh')),
-        ),
+      getSecurityGroupDetails: vi
+        .fn()
+        .mockReturnValueOnce(Promise.resolve(details('first-firewall', 'before refresh')))
+        .mockReturnValueOnce(Promise.resolve(details('first-firewall', 'after refresh'))),
     };
     runtimeServices.securityGroupReader = reader;
-    const wrapper = mount(<GceSecurityGroupDetails app={app as any} resolvedSecurityGroup={firstRoute} />);
+    const rendered = renderWithRuntime(<GceSecurityGroupDetails app={app as any} resolvedSecurityGroup={firstRoute} />);
 
-    await flush();
-    wrapper.update();
-    expect(wrapper.text()).toContain('before refresh');
+    await waitFor(() => expect(screen.getByText('before refresh')).toBeInTheDocument());
     expect(refreshDetails).toBeDefined();
 
-    refreshDetails?.();
-    await flush();
-    wrapper.update();
+    await act(async () => refreshDetails?.());
 
     expect(reader.getSecurityGroupDetails).toHaveBeenCalledTimes(2);
-    expect(wrapper.text()).toContain('after refresh');
-    wrapper.unmount();
+    await waitFor(() => expect(screen.getByText('after refresh')).toBeInTheDocument());
+    rendered.unmount();
   });
 
   it('clears prior details and actions on route change and ignores an out-of-order response', async () => {
     const secondRequest = deferred<any>();
     const thirdRequest = deferred<any>();
     const reader = {
-      getSecurityGroupDetails: jasmine
-        .createSpy('getSecurityGroupDetails')
-        .and.returnValues(
-          Promise.resolve(details('first-firewall', 'first details')),
-          secondRequest.promise,
-          thirdRequest.promise,
-        ),
+      getSecurityGroupDetails: vi
+        .fn()
+        .mockReturnValueOnce(Promise.resolve(details('first-firewall', 'first details')))
+        .mockReturnValueOnce(secondRequest.promise)
+        .mockReturnValueOnce(thirdRequest.promise),
     };
     runtimeServices.securityGroupReader = reader;
-    const app = { securityGroups: { onRefresh: () => jasmine.createSpy('unsubscribe') } };
-    const wrapper = mount(<GceSecurityGroupDetails app={app as any} resolvedSecurityGroup={firstRoute} />);
-
-    await flush();
-    wrapper.update();
-    expect(wrapper.find(GceSecurityGroupActions).length).toBe(1);
-    expect(wrapper.text()).toContain('first details');
-
-    wrapper.setProps({ resolvedSecurityGroup: { ...firstRoute, name: 'second-firewall' } });
-    expect(wrapper.find(GceSecurityGroupActions).length).toBe(0);
-    expect(wrapper.text()).not.toContain('first details');
-
-    wrapper.setProps({ resolvedSecurityGroup: { ...firstRoute, name: 'third-firewall' } });
-    secondRequest.resolve(details('second-firewall', 'stale second details'));
-    await flush();
-    wrapper.update();
-    expect(wrapper.text()).not.toContain('stale second details');
-
-    thirdRequest.resolve(details('third-firewall', 'current third details'));
-    await flush();
-    wrapper.update();
-    expect(wrapper.text()).toContain('current third details');
-    expect(wrapper.find(GceSecurityGroupActions).length).toBe(1);
-    wrapper.unmount();
+    const app = { securityGroups: { onRefresh: () => vi.fn() } };
+    const rendered = renderWithRuntime(<GceSecurityGroupDetails app={app as any} resolvedSecurityGroup={firstRoute} />);
+
+    await waitFor(() => expect(screen.getByText('first details')).toBeInTheDocument());
+    expect(screen.getByRole('button', { name: /Firewall Actions/ })).toBeInTheDocument();
+
+    rendered.rerender(
+      <RuntimeWrapper>
+        <GceSecurityGroupDetails app={app as any} resolvedSecurityGroup={{ ...firstRoute, name: 'second-firewall' }} />
+      </RuntimeWrapper>,
+    );
+    expect(screen.queryByRole('button', { name: /Firewall Actions/ })).not.toBeInTheDocument();
+    expect(screen.queryByText('first details')).not.toBeInTheDocument();
+
+    rendered.rerender(
+      <RuntimeWrapper>
+        <GceSecurityGroupDetails app={app as any} resolvedSecurityGroup={{ ...firstRoute, name: 'third-firewall' }} />
+      </RuntimeWrapper>,
+    );
+    await act(async () => secondRequest.resolve(details('second-firewall', 'stale second details')));
+    expect(screen.queryByText('stale second details')).not.toBeInTheDocument();
+
+    await act(async () => thirdRequest.resolve(details('third-firewall', 'current third details')));
+    await waitFor(() => expect(screen.getByText('current third details')).toBeInTheDocument());
+    expect(screen.getByRole('button', { name: /Firewall Actions/ })).toBeInTheDocument();
+    rendered.unmount();
   });
 });
 
@@ -133,11 +123,11 @@ describe('GceSecurityGroupActions', () => {
   const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) => (
     <DeckRuntimeContext.Provider value={{ services: runtimeServices }}>{children}</DeckRuntimeContext.Provider>
   );
-  const mountActions = (component: React.ReactElement) => enzymeMount(component, { wrappingComponent: RuntimeWrapper });
+  const renderActions = (component: React.ReactElement) => render(<RuntimeWrapper>{component}</RuntimeWrapper>);
 
   const app = {
     name: 'my-app',
-    securityGroups: { refresh: jasmine.createSpy('refresh') },
+    securityGroups: { refresh: vi.fn() },
   };
   const resolvedSecurityGroup = {
     accountId: 'my-account',
@@ -156,24 +146,26 @@ describe('GceSecurityGroupActions', () => {
   };
 
   it('opens edit and clone modals and confirms deletion with complete firewall identity', () => {
-    spyOn(GceSecurityGroupModal, 'show');
-    spyOn(ConfirmationModalService, 'confirm');
-    spyOn(SecurityGroupWriter, 'deleteSecurityGroup').and.returnValue(Promise.resolve({} as any));
-    const wrapper = mountActions(
+    vi.spyOn(GceSecurityGroupModal, 'show').mockReturnValue(undefined);
+    vi.spyOn(ConfirmationModalService, 'confirm').mockReturnValue(undefined);
+    vi.spyOn(SecurityGroupWriter, 'deleteSecurityGroup').mockReturnValue(Promise.resolve({} as any));
+    const rendered = renderActions(
       <GceSecurityGroupActions
         app={app as any}
         resolvedSecurityGroup={resolvedSecurityGroup}
         securityGroup={securityGroup}
       />,
     );
-    const items = wrapper.find('button[data-action]');
+    const items = Array.from(rendered.container.querySelectorAll<HTMLButtonElement>('button[data-action]'));
 
-    expect(items.map((item) => item.text())).toEqual(['Edit Inbound Rules', 'Clone Firewall', 'Delete Firewall']);
-    items.at(0).prop('onClick')({} as any);
-    items.at(1).prop('onClick')({} as any);
-    items.at(2).prop('onClick')({} as any);
+    expect(items.map((item) => item.textContent?.trim())).toEqual([
+      'Edit Inbound Rules',
+      'Clone Firewall',
+      'Delete Firewall',
+    ]);
+    items.forEach((item) => fireEvent.click(item));
 
-    const firewallWithIdentity = jasmine.objectContaining({
+    const firewallWithIdentity = expect.objectContaining({
       accountId: 'my-account',
       id: 'my-firewall',
       name: 'my-firewall',
@@ -197,25 +189,25 @@ describe('GceSecurityGroupActions', () => {
       runtimeServices,
     );
     expect(ConfirmationModalService.confirm).toHaveBeenCalledWith(
-      jasmine.objectContaining({
+      expect.objectContaining({
         account: 'my-account',
         buttonText: 'Delete my-firewall',
         header: 'Really delete my-firewall?',
-        taskMonitorConfig: jasmine.objectContaining({ application: app as any, title: 'Deleting my-firewall' }),
+        taskMonitorConfig: expect.objectContaining({ application: app as any, title: 'Deleting my-firewall' }),
       }),
     );
 
-    const confirmation = (ConfirmationModalService.confirm as jasmine.Spy).calls.mostRecent().args[0];
+    const confirmation = (ConfirmationModalService.confirm as Mock).mock.lastCall[0];
     confirmation.submitMethod();
     expect(SecurityGroupWriter.deleteSecurityGroup).toHaveBeenCalledWith(
       firewallWithIdentity,
       app as any,
-      jasmine.objectContaining({ cloudProvider: 'gce', securityGroupName: 'my-firewall' }),
+      expect.objectContaining({ cloudProvider: 'gce', securityGroupName: 'my-firewall' }),
     );
   });
 
   it('disables host-project shared-VPC actions and explains why they are read-only', () => {
-    const wrapper = mountActions(
+    const rendered = renderActions(
       <GceSecurityGroupActions
         app={app as any}
         resolvedSecurityGroup={resolvedSecurityGroup}
@@ -223,10 +215,9 @@ describe('GceSecurityGroupActions', () => {
       />,
     );
 
-    expect(wrapper.find('button[data-action]').length).toBe(3);
-    wrapper.find('button[data-action]').forEach((item) => expect(item.prop('disabled')).toBe(true));
-    expect(wrapper.find('.shared-vpc-warning').text()).toContain(
-      'You cannot modify shared VPC host project firewall rules.',
-    );
+    const items = Array.from(rendered.container.querySelectorAll<HTMLButtonElement>('button[data-action]'));
+    expect(items).toHaveLength(3);
+    items.forEach((item) => expect(item).toBeDisabled());
+    expect(screen.getByText('You cannot modify shared VPC host project firewall rules.')).toBeInTheDocument();
   });
 });

package/src/serverGroup/configure/serverGroupCommandBuilder.service.spec.js

@@ -11,25 +11,25 @@ describe('GceServerGroupCommandBuilder', () => {
   let xpnNamingService;
 
   beforeEach(() => {
-    spyOn(AccountService, 'listAccounts').and.resolveTo([{ name: 'test-account' }]);
-    spyOn(ExpectedArtifactService, 'getExpectedArtifactsAvailableToStage').and.returnValue([]);
-    instanceTypeService = jasmine.createSpyObj('instanceTypeService', [
-      'getCategories',
-      'getInstanceTypeDetails',
-      'getCategoryForInstanceType',
-    ]);
-    instanceTypeService.getCategories.and.resolveTo([
+    vi.spyOn(AccountService, 'listAccounts').mockResolvedValue([{ name: 'test-account' }]);
+    vi.spyOn(ExpectedArtifactService, 'getExpectedArtifactsAvailableToStage').mockReturnValue([]);
+    instanceTypeService = {
+      getCategories: vi.fn(),
+      getInstanceTypeDetails: vi.fn(),
+      getCategoryForInstanceType: vi.fn(),
+    };
+    instanceTypeService.getCategories.mockResolvedValue([
       { type: 'custom', families: [{ instanceTypes: [{ name: 'n1-standard-1' }] }] },
     ]);
-    instanceTypeService.getInstanceTypeDetails.and.resolveTo({
+    instanceTypeService.getInstanceTypeDetails.mockResolvedValue({
       storage: { localSSDSupported: false, size: 10, count: 1 },
     });
-    instanceTypeService.getCategoryForInstanceType.and.resolveTo('custom');
-    customInstanceBuilder = jasmine.createSpyObj('customInstanceBuilder', ['parseInstanceTypeString']);
-    customInstanceBuilder.parseInstanceTypeString.and.returnValue({});
-    xpnNamingService = jasmine.createSpyObj('xpnNamingService', ['deriveProjectId', 'decorateXpnResourceIfNecessary']);
-    xpnNamingService.deriveProjectId.and.returnValue('test-project');
-    xpnNamingService.decorateXpnResourceIfNecessary.and.callFake((_projectId, resource) => resource);
+    instanceTypeService.getCategoryForInstanceType.mockResolvedValue('custom');
+    customInstanceBuilder = { parseInstanceTypeString: vi.fn() };
+    customInstanceBuilder.parseInstanceTypeString.mockReturnValue({});
+    xpnNamingService = { deriveProjectId: vi.fn(), decorateXpnResourceIfNecessary: vi.fn() };
+    xpnNamingService.deriveProjectId.mockReturnValue('test-project');
+    xpnNamingService.decorateXpnResourceIfNecessary.mockImplementation((_projectId, resource) => resource);
 
     const promiseService = { all: (values) => Promise.all(values), resolve: (value) => Promise.resolve(value) };
     builder = new GceServerGroupCommandBuilder(
@@ -153,6 +153,26 @@ describe('GceServerGroupCommandBuilder', () => {
     expect(serverGroup.instanceFlexibilityPolicy.instanceSelections.preferred.machineTypes).toEqual(['n2-standard-8']);
   });
 
+  it('keeps Clouddriver-managed load balancer metadata out of clone instance metadata', async () => {
+    const promiseService = { all: (values) => Promise.all(values), resolve: (value) => Promise.resolve(value) };
+    const defaultHiddenKeysBuilder = new GceServerGroupCommandBuilder(
+      promiseService,
+      instanceTypeService,
+      customInstanceBuilder,
+      xpnNamingService,
+    );
+    const serverGroup = buildServerGroup();
+    serverGroup.launchConfig.instanceTemplate.properties.metadata.items = [
+      { key: 'load-balancer-names', value: 'listener-a,listener-b' },
+      { key: 'regional-external-load-balancer-names', value: 'listener-a,listener-b' },
+      { key: 'team', value: 'payments' },
+    ];
+
+    const command = await defaultHiddenKeysBuilder.buildServerGroupCommandFromExisting(application(), serverGroup);
+
+    expect(command.instanceMetadata).toEqual({ team: 'payments' });
+  });
+
   it('preserves absent versus explicitly empty clone flexibility policies', async () => {
     const absent = buildServerGroup();
     const empty = buildServerGroup();

package/src/serverGroup/configure/serverGroupConfiguration.service.js

@@ -428,6 +428,7 @@ export class GceServerGroupConfigurationService {
           command.loadBalancers,
           command.credentials,
           newLoadBalancerObjects,
+          command.region,
         );
         const matched = _.intersection(command.backingData.filtered.loadBalancers, command.loadBalancers);
         const removed = _.xor(matched, command.loadBalancers);
@@ -452,7 +453,12 @@ export class GceServerGroupConfigurationService {
       const lbIndex = command.backingData.filtered.loadBalancerIndex;
 
       const backendServices = command.loadBalancers.reduce((backendServices, lbName) => {
-        if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(lbIndex[lbName])) {
+        // Clouddriver attaches every EXTERNAL_MANAGED backend service; its regional names must not
+        // enter the global backend-service-names metadata.
+        if (
+          gceHttpLoadBalancerUtils.isHttpLoadBalancer(lbIndex[lbName]) &&
+          lbIndex[lbName].loadBalancerType !== 'EXTERNAL_MANAGED'
+        ) {
           backendServices[lbName] = _.intersection(lbIndex[lbName].backendServices, backendsFromMetadata);
         }
         return backendServices;

package/src/serverGroup/configure/serverGroupConfiguration.service.spec.js

@@ -1,9 +1,79 @@
 'use strict';
 
-import { GCE_DISTRIBUTION_POLICY_TARGET_SHAPES } from './serverGroupConfiguration.service';
+import { nativePromiseService } from '@spinnaker/core';
 
-describe('gceServerGroupConfigurationService target shapes', function () {
-  it('exposes BALANCED and ANY_SINGLE_ZONE alongside ANY and EVEN', function () {
-    expect(GCE_DISTRIBUTION_POLICY_TARGET_SHAPES).toEqual(['ANY', 'EVEN', 'BALANCED', 'ANY_SINGLE_ZONE']);
+import {
+  GCE_DISTRIBUTION_POLICY_TARGET_SHAPES,
+  GceServerGroupConfigurationService,
+} from './serverGroupConfiguration.service';
+
+describe('GceServerGroupConfigurationService', () => {
+  let service;
+
+  beforeEach(() => {
+    service = new GceServerGroupConfigurationService(nativePromiseService, {
+      securityGroupReader: {},
+      loadBalancerReader: {},
+    });
+  });
+
+  describe('configureLoadBalancerOptions', () => {
+    it('scopes EXTERNAL_MANAGED listener normalization by account and region without seeding global backends', () => {
+      const command = {
+        credentials: 'account-a',
+        region: 'europe-west1',
+        loadBalancers: ['external-listener'],
+        backendServiceMetadata: ['europe-backend'],
+        backingData: {
+          loadBalancers: [
+            {
+              accounts: [
+                {
+                  name: 'account-a',
+                  regions: [
+                    {
+                      loadBalancers: [
+                        {
+                          account: 'account-a',
+                          listeners: [{ name: 'external-listener' }],
+                          loadBalancerType: 'EXTERNAL_MANAGED',
+                          name: 'external-listener',
+                          provider: 'gce',
+                          region: 'us-central1',
+                          urlMapName: 'app-main',
+                          backendServices: ['central-backend', 'other-backend'],
+                        },
+                        {
+                          account: 'account-a',
+                          listeners: [{ name: 'external-listener' }],
+                          loadBalancerType: 'EXTERNAL_MANAGED',
+                          name: 'external-listener',
+                          provider: 'gce',
+                          region: 'europe-west1',
+                          urlMapName: 'app-main',
+                          backendServices: ['europe-backend'],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+          filtered: {},
+        },
+      };
+
+      service.configureLoadBalancerOptions(command);
+
+      expect(command.loadBalancers).toEqual(['app-main (account-a/europe-west1/EXTERNAL_MANAGED)']);
+      expect(command.backendServices).toBeUndefined();
+    });
+  });
+
+  describe('target shapes', () => {
+    it('exposes BALANCED and ANY_SINGLE_ZONE alongside ANY and EVEN', () => {
+      expect(GCE_DISTRIBUTION_POLICY_TARGET_SHAPES).toEqual(['ANY', 'EVEN', 'BALANCED', 'ANY_SINGLE_ZONE']);
+    });
   });
 });