@spinnaker/google 2026.3.2 → 2026.4.0

package/src/gce.module.spec.ts

@@ -1,4 +1,4 @@
-import { mount as enzymeMount } from 'enzyme';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
 
 import {
@@ -8,13 +8,11 @@ import {
   ErrorModalService,
   InfrastructureCaches,
   LoadBalancerWriter,
-  ManagedMenuItem,
   nativePromiseService,
   ProviderServiceDelegate,
   Registry,
   ServerGroupReader,
   ServerGroupWarningMessageService,
-  SubmitButton,
   TaskExecutor,
 } from '@spinnaker/core';
 
@@ -34,11 +32,7 @@ import { GceSecurityGroupReader } from './securityGroup/securityGroup.reader';
 import { GceSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
 import { GceServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
 import { GceServerGroupConfigurationService } from './serverGroup/configure/serverGroupConfiguration.service';
-import {
-  cloneGceServerGroup,
-  GceServerGroupActions,
-  gceServerGroupDetailsGetter,
-} from './serverGroup/details/gceServerGroupDetails';
+import { cloneGceServerGroup, GceServerGroupActions } from './serverGroup/details/gceServerGroupDetails';
 import { GceServerGroupTransformer } from './serverGroup/serverGroup.transformer';
 import { GceSubnetRenderer } from './subnet/subnet.renderer';
 
@@ -46,7 +40,8 @@ describe('Google provider registration', () => {
   let runtimeServices: any;
   const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) =>
     React.createElement(DeckRuntimeContext.Provider, { value: { services: runtimeServices } as any }, children);
-  const mount = (component: React.ReactElement) => enzymeMount(component, { wrappingComponent: RuntimeWrapper });
+  const renderWithRuntime = (component: React.ReactElement) =>
+    render(React.createElement(RuntimeWrapper, undefined, component));
 
   beforeEach(() => {
     runtimeServices = {
@@ -152,8 +147,8 @@ describe('Google provider registration', () => {
       'serverGroup.commandBuilder',
     );
 
-    expect(commandBuilder.buildNewServerGroupCommand).toEqual(jasmine.any(Function));
-    expect(commandBuilder.buildServerGroupCommandFromExisting).toEqual(jasmine.any(Function));
+    expect(commandBuilder.buildNewServerGroupCommand).toEqual(expect.any(Function));
+    expect(commandBuilder.buildServerGroupCommandFromExisting).toEqual(expect.any(Function));
   });
 
   it('normalizes HTTP load balancers without constructor dependencies', () => {
@@ -185,30 +180,20 @@ describe('Google provider registration', () => {
     runtimeServices.securityGroupReader = {
       getAllSecurityGroups: () => Promise.resolve({}),
     };
-    const wrapper = mount(
+    renderWithRuntime(
       React.createElement(GceSecurityGroupModal, {
         application: { name: 'fnord', securityGroups: { data: [] } },
         credentials: 'test-account',
       }),
     );
 
-    wrapper.setState({
-      securityGroup: {
-        ...(wrapper.state() as any).securityGroup,
-        ipIngress: [{ type: 'tcp', startPort: 443, endPort: 443 }],
-        name: 'fnord-firewall',
-        network: 'default',
-        sourceRanges: ['10.0.0.0/8'],
-        sourceTags: [],
-        targetTags: [],
-      },
-    } as any);
-
-    await Promise.resolve();
-    await Promise.resolve();
-    wrapper.update();
+    fireEvent.change(screen.getByRole('textbox', { name: 'Name' }), { target: { value: 'fnord-firewall' } });
+    fireEvent.change(screen.getByRole('textbox', { name: 'Network' }), { target: { value: 'default' } });
+    fireEvent.change(screen.getByRole('textbox', { name: 'Source CIDRs' }), { target: { value: '10.0.0.0/8' } });
+    fireEvent.change(screen.getByRole('spinbutton', { name: 'Start port 1' }), { target: { value: '443' } });
+    fireEvent.change(screen.getByRole('spinbutton', { name: 'End port 1' }), { target: { value: '443' } });
 
-    expect(wrapper.find(SubmitButton).prop('isDisabled')).toBe(false);
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Create' })).toBeEnabled());
   });
 
   it('loads and enriches GCE load balancer details through the Core reader', async () => {
@@ -230,9 +215,9 @@ describe('Google provider registration', () => {
       defaultService: { name: 'backend-default', healthCheck: { name: 'hc-default' } },
     };
     const loadBalancerReader = {
-      getLoadBalancerDetails: jasmine
-        .createSpy('getLoadBalancerDetails')
-        .and.callFake((_provider: string, _account: string, _region: string, name: string) =>
+      getLoadBalancerDetails: vi
+        .fn()
+        .mockImplementation((_provider: string, _account: string, _region: string, name: string) =>
           Promise.resolve([
             {
               name,
@@ -244,11 +229,9 @@ describe('Google provider registration', () => {
         ),
     };
     const accountService = {
-      getAccountDetails: jasmine
-        .createSpy('getAccountDetails')
-        .and.returnValue(Promise.resolve({ project: 'gce-project' })),
+      getAccountDetails: vi.fn().mockReturnValue(Promise.resolve({ project: 'gce-project' })),
     };
-    const autoClose = jasmine.createSpy('autoClose');
+    const autoClose = vi.fn();
 
     const loadBalancer = await loadGceLoadBalancerDetails({
       app: { loadBalancers: { data: [summary] } } as any,
@@ -298,10 +281,10 @@ describe('Google provider registration', () => {
   });
 
   it('deletes HTTP load balancers by forwarding rule and preserves delete params', async () => {
-    const confirmSpy = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve({}) as any);
-    spyOn(LoadBalancerWriter, 'deleteLoadBalancer').and.returnValue(Promise.resolve({}) as any);
-    const clearCacheSpy = spyOn(InfrastructureCaches, 'clearCache');
-    const executeTaskSpy = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({}) as any);
+    const confirmSpy = vi.spyOn(ConfirmationModalService, 'confirm').mockReturnValue(Promise.resolve({}) as any);
+    vi.spyOn(LoadBalancerWriter, 'deleteLoadBalancer').mockReturnValue(Promise.resolve({}) as any);
+    const clearCacheSpy = vi.spyOn(InfrastructureCaches, 'clearCache').mockReturnValue(undefined);
+    const executeTaskSpy = vi.spyOn(TaskExecutor, 'executeTask').mockReturnValue(Promise.resolve({}) as any);
     const app = { name: 'fnord' };
     const loadBalancer = {
       account: 'test-account',
@@ -313,12 +296,10 @@ describe('Google provider registration', () => {
       urlMapName: 'frontend-map',
     };
 
-    const wrapper = mount(React.createElement(GceLoadBalancerActions, { app, loadBalancer }));
-    wrapper
-      .find(ManagedMenuItem)
-      .filterWhere((item) => item.prop('children') === 'Delete Load Balancer')
-      .prop('onClick')();
-    const modalParams = confirmSpy.calls.mostRecent().args[0] as any;
+    render(React.createElement(GceLoadBalancerActions, { app, loadBalancer }));
+    fireEvent.click(screen.getByText('Delete Load Balancer'));
+    await waitFor(() => expect(confirmSpy).toHaveBeenCalled());
+    const modalParams = confirmSpy.mock.lastCall[0] as any;
     await modalParams.submitMethod({ deleteHealthChecks: true, reason: 'cleanup' });
 
     expect(LoadBalancerWriter.deleteLoadBalancer).not.toHaveBeenCalled();
@@ -328,7 +309,7 @@ describe('Google provider registration', () => {
       application: app,
       description: 'Delete load balancer: frontend-map in test-account:global',
       job: [
-        jasmine.objectContaining({
+        expect.objectContaining({
           cloudProvider: 'gce',
           credentials: 'test-account',
           deleteHealthChecks: true,
@@ -343,79 +324,85 @@ describe('Google provider registration', () => {
     });
   });
 
-  it('loads GCE server group details even when the app summary is not loaded yet', (done) => {
-    const autoClose = jasmine.createSpy('autoClose');
-    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(
-      Promise.resolve({
-        account: 'test-account',
-        launchConfig: {
-          instanceTemplate: {
-            properties: { networkInterfaces: [] },
-            selfLink:
-              'https://compute.googleapis.com/compute/beta/projects/gce-project/global/instanceTemplates/fnord-v001',
+  it('loads GCE server group details even when the app summary is not loaded yet', () =>
+    new Promise((done, reject) => {
+      googlePackage.registerGoogleProvider();
+      const registeredDetailsGetter = CloudProviderRegistry.getValue('gce', 'serverGroup.detailsGetter');
+      const autoClose = vi.fn();
+      vi.spyOn(ServerGroupReader, 'getServerGroup').mockReturnValue(
+        Promise.resolve({
+          account: 'test-account',
+          launchConfig: {
+            instanceTemplate: {
+              properties: { networkInterfaces: [] },
+              selfLink:
+                'https://compute.googleapis.com/compute/beta/projects/gce-project/global/instanceTemplates/fnord-v001',
+            },
           },
-        },
-        name: 'fnord-v001',
-        region: 'us-central1',
-        zones: ['us-central1-b', 'us-central1-a'],
-      }) as any,
-    );
+          name: 'fnord-v001',
+          region: 'us-central1',
+          zones: ['us-central1-b', 'us-central1-a'],
+        }) as any,
+      );
 
-    gceServerGroupDetailsGetter(
-      {
-        app: { loadBalancers: { data: [] }, name: 'fnord', serverGroups: { data: [] } },
-        serverGroup: { accountId: 'test-account', name: 'fnord-v001', region: 'us-central1' },
-      },
-      autoClose,
-    ).subscribe({
-      error: done.fail,
-      next: (serverGroup: any) => {
-        expect(serverGroup.name).toBe('fnord-v001');
-        expect(serverGroup.account).toBe('test-account');
-        expect(serverGroup.zones).toEqual(['us-central1-a', 'us-central1-b']);
-      },
-      complete: () => {
-        expect(autoClose).not.toHaveBeenCalled();
-        expect(ServerGroupReader.getServerGroup).toHaveBeenCalledWith(
-          'fnord',
-          'test-account',
-          'us-central1',
-          'fnord-v001',
-        );
-        done();
-      },
-    });
-  });
-
-  it('loads GCE server group details when the launch template is missing', (done) => {
-    const autoClose = jasmine.createSpy('autoClose');
-    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(
-      Promise.resolve({
-        account: 'test-account',
-        name: 'fnord-v001',
-        region: 'us-central1',
-        zones: ['us-central1-a'],
-      }) as any,
-    );
-
-    gceServerGroupDetailsGetter(
-      {
-        app: { loadBalancers: { data: [] }, name: 'fnord', serverGroups: { data: [] } },
-        serverGroup: { accountId: 'test-account', name: 'fnord-v001', region: 'us-central1' },
-      },
-      autoClose,
-    ).subscribe({
-      error: done.fail,
-      next: (serverGroup: any) => {
-        expect(serverGroup.name).toBe('fnord-v001');
-        expect(serverGroup.logsLink).toBeUndefined();
-      },
-      complete: () => {
-        expect(autoClose).not.toHaveBeenCalled();
-        done();
-      },
-    });
-  });
+      registeredDetailsGetter(
+        {
+          app: { loadBalancers: { data: [] }, name: 'fnord', serverGroups: { data: [] } },
+          serverGroup: { accountId: 'test-account', name: 'fnord-v001', region: 'us-central1' },
+        },
+        autoClose,
+      ).subscribe({
+        error: reject,
+        next: (serverGroup: any) => {
+          expect(serverGroup.name).toBe('fnord-v001');
+          expect(serverGroup.account).toBe('test-account');
+          expect(serverGroup.zones).toEqual(['us-central1-a', 'us-central1-b']);
+        },
+        complete: () => {
+          expect(autoClose).not.toHaveBeenCalled();
+          expect(ServerGroupReader.getServerGroup).toHaveBeenCalledWith(
+            'fnord',
+            'test-account',
+            'us-central1',
+            'fnord-v001',
+          );
+          done();
+        },
+      });
+    }));
+
+  it('loads GCE server group details when the launch template is missing', () =>
+    new Promise((done, reject) => {
+      googlePackage.registerGoogleProvider();
+      const registeredDetailsGetter = CloudProviderRegistry.getValue('gce', 'serverGroup.detailsGetter');
+      const autoClose = vi.fn();
+      vi.spyOn(ServerGroupReader, 'getServerGroup').mockReturnValue(
+        Promise.resolve({
+          account: 'test-account',
+          name: 'fnord-v001',
+          region: 'us-central1',
+          zones: ['us-central1-a'],
+        }) as any,
+      );
+
+      registeredDetailsGetter(
+        {
+          app: { loadBalancers: { data: [] }, name: 'fnord', serverGroups: { data: [] } },
+          serverGroup: { accountId: 'test-account', name: 'fnord-v001', region: 'us-central1' },
+        },
+        autoClose,
+      ).subscribe({
+        error: reject,
+        next: (serverGroup: any) => {
+          expect(serverGroup.name).toBe('fnord-v001');
+          expect(serverGroup.logsLink).toBeUndefined();
+        },
+        complete: () => {
+          expect(autoClose).not.toHaveBeenCalled();
+          done();
+        },
+      });
+    }));
 
   it('builds GCE instance logs links with the expected resource type', async () => {
     const instance = decorateInstance({
@@ -430,64 +417,56 @@ describe('Google provider registration', () => {
   });
 
   it('does not force Google health provider params when platform-health override is disabled', async () => {
-    const confirmSpy = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve({}) as any);
-    const writer = { enableServerGroup: jasmine.createSpy('enableServerGroup').and.returnValue(Promise.resolve({})) };
+    const confirmSpy = vi.spyOn(ConfirmationModalService, 'confirm').mockReturnValue(Promise.resolve({}) as any);
+    const writer = { enableServerGroup: vi.fn().mockReturnValue(Promise.resolve({})) };
     runtimeServices.serverGroupWriter = writer;
 
-    mount(
+    renderWithRuntime(
       React.createElement(GceServerGroupActions, {
         app: { attributes: { platformHealthOnly: true, platformHealthOnlyShowOverride: false }, name: 'fnord' },
         serverGroup: { account: 'test-account', isDisabled: true, name: 'fnord-v001', region: 'us-central1' },
       }),
-    )
-      .find('a')
-      .filterWhere((link) => link.text() === 'Enable')
-      .simulate('click');
+    );
+    fireEvent.click(screen.getByText('Enable', { selector: 'a' }));
 
-    const modalParams = confirmSpy.calls.mostRecent().args[0] as any;
+    const modalParams = confirmSpy.mock.lastCall[0] as any;
     expect(modalParams.platformHealthOnlyShowOverride).toBe(false);
     await modalParams.submitMethod({ reason: 'not forced' });
-    expect(writer.enableServerGroup.calls.mostRecent().args[2].interestingHealthProviderNames).toBeUndefined();
+    expect(writer.enableServerGroup.mock.lastCall[2].interestingHealthProviderNames).toBeUndefined();
   });
 
   it('adds Google health provider params to GCE server group actions when platform health only is enabled', async () => {
-    const confirmSpy = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve({}) as any);
-    spyOn(ServerGroupWarningMessageService, 'addDisableWarningMessage');
-    spyOn(ServerGroupWarningMessageService, 'addDestroyWarningMessage');
+    const confirmSpy = vi.spyOn(ConfirmationModalService, 'confirm').mockReturnValue(Promise.resolve({}) as any);
+    vi.spyOn(ServerGroupWarningMessageService, 'addDisableWarningMessage').mockReturnValue(undefined);
+    vi.spyOn(ServerGroupWarningMessageService, 'addDestroyWarningMessage').mockReturnValue(undefined);
     const writer = {
-      destroyServerGroup: jasmine.createSpy('destroyServerGroup').and.returnValue(Promise.resolve({})),
-      disableServerGroup: jasmine.createSpy('disableServerGroup').and.returnValue(Promise.resolve({})),
+      destroyServerGroup: vi.fn().mockReturnValue(Promise.resolve({})),
+      disableServerGroup: vi.fn().mockReturnValue(Promise.resolve({})),
     };
     runtimeServices.serverGroupWriter = writer;
     const app = { attributes: { platformHealthOnly: true, platformHealthOnlyShowOverride: true }, name: 'fnord' };
     const serverGroup = { account: 'test-account', isDisabled: false, name: 'fnord-v001', region: 'us-central1' };
 
-    const wrapper = mount(React.createElement(GceServerGroupActions, { app, serverGroup }));
-    wrapper
-      .find('a')
-      .filterWhere((link) => link.text() === 'Disable')
-      .simulate('click');
-    let modalParams = confirmSpy.calls.mostRecent().args[0] as any;
+    renderWithRuntime(React.createElement(GceServerGroupActions, { app, serverGroup }));
+    fireEvent.click(screen.getByText('Disable', { selector: 'a' }));
+    let modalParams = confirmSpy.mock.lastCall[0] as any;
     expect(modalParams.platformHealthOnlyShowOverride).toBe(true);
     await modalParams.submitMethod({ reason: 'platform health only' });
-    expect(writer.disableServerGroup.calls.mostRecent().args[2].interestingHealthProviderNames).toEqual(['Google']);
+    expect(writer.disableServerGroup.mock.lastCall[2].interestingHealthProviderNames).toEqual(['Google']);
 
-    wrapper
-      .find('a')
-      .filterWhere((link) => link.text() === 'Destroy')
-      .simulate('click');
-    modalParams = confirmSpy.calls.mostRecent().args[0] as any;
+    fireEvent.click(screen.getByText('Destroy', { selector: 'a' }));
+    modalParams = confirmSpy.mock.lastCall[0] as any;
     expect(modalParams.platformHealthOnlyShowOverride).toBe(true);
     await modalParams.submitMethod({ reason: 'platform health only' });
-    expect(writer.destroyServerGroup.calls.mostRecent().args[2].interestingHealthProviderNames).toEqual(['Google']);
+    expect(writer.destroyServerGroup.mock.lastCall[2].interestingHealthProviderNames).toEqual(['Google']);
   });
 
   it('shows an error when the GCE clone command cannot be built', async () => {
-    const errorSpy = spyOn(ErrorModalService, 'error').and.returnValue(Promise.resolve({}) as any);
+    const errorSpy = vi.spyOn(ErrorModalService, 'error').mockReturnValue(Promise.resolve({}) as any);
     const commandBuilder = {
-      buildServerGroupCommandFromExisting: jasmine
-        .createSpy('buildServerGroupCommandFromExisting')
-        .and.returnValue(Promise.reject({ data: { message: 'missing launch template' } })),
+      buildServerGroupCommandFromExisting: vi
+        .fn()
+        .mockReturnValue(Promise.reject({ data: { message: 'missing launch template' } })),
     };
 
     await cloneGceServerGroup(
@@ -508,8 +487,8 @@ describe('Google provider registration', () => {
   });
 
   it('closes GCE load balancer details when no matching summary exists', async () => {
-    const loadBalancerReader = { getLoadBalancerDetails: jasmine.createSpy('getLoadBalancerDetails') };
-    const autoClose = jasmine.createSpy('autoClose');
+    const loadBalancerReader = { getLoadBalancerDetails: vi.fn() };
+    const autoClose = vi.fn();
 
     const loadBalancer = await loadGceLoadBalancerDetails({
       app: { loadBalancers: { data: [] } } as any,
@@ -555,8 +534,8 @@ describe('Google provider registration', () => {
 
       expectedStages.forEach((provides) => {
         const stage = gceStages.find((candidate: any) => candidate.provides === provides);
-        expect(stage).withContext(`gce ${provides} stage`).toBeDefined();
-        expect(stage?.component).withContext(`gce ${provides} stage component`).toBeDefined();
+        expect(stage, `gce ${provides} stage`).toBeDefined();
+        expect(stage?.component, `gce ${provides} stage component`).toBeDefined();
       });
     } finally {
       Registry.pipeline = previousPipeline;
@@ -591,7 +570,7 @@ describe('Google provider registration', () => {
 
       expectedStages.forEach((provides) => {
         const registrations = gceStages.filter((stage: any) => stage.provides === provides);
-        expect(registrations.length).withContext(`gce ${provides} registration count`).toBe(1);
+        expect(registrations.length, `gce ${provides} registration count`).toBe(1);
       });
     } finally {
       Registry.pipeline = previousPipeline;