@spinnaker/google 2026.3.1 → 2026.4.0

package/src/loadBalancer/configure/common/gceLoadBalancerSubmission.spec.ts

@@ -234,7 +234,7 @@ describe('GCE load balancer submission', () => {
       },
       'pipeline',
     );
-    const executeTask = jasmine.createSpy('executeTask');
+    const executeTask = vi.fn();
 
     const result = submitGceLoadBalancerCommand(command, { application: {} as any, executeTask });
 
@@ -244,7 +244,7 @@ describe('GCE load balancer submission', () => {
       'internal-api',
     ]);
     expect((result as any[])[0]).toEqual(
-      jasmine.objectContaining({
+      expect.objectContaining({
         ipProtocol: 'TCP',
         loadBalancerName: 'internal-http',
         network: 'network-a',
@@ -260,6 +260,302 @@ describe('GCE load balancer submission', () => {
     expect(executeTask).not.toHaveBeenCalled();
   });
 
+  it('builds exact EXTERNAL_MANAGED create jobs with regional network, tier, and certificate URL', () => {
+    const regionalCertUrl =
+      '//certificatemanager.googleapis.com/projects/test/locations/europe-west1/certificates/regional-cert';
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendServices: [
+          {
+            account: 'account-a',
+            backends: [],
+            healthCheck: 'check-a',
+            kind: 'regionBackendService',
+            name: 'backend-a',
+            portName: 'http',
+            protocol: 'HTTP',
+            selfLink: 'projects/test/regions/europe-west1/backendServices/backend-a',
+            sessionAffinity: 'NONE',
+          },
+        ],
+        defaultService: 'backend-a',
+        healthChecks: [
+          {
+            checkIntervalSec: 10,
+            healthCheckType: 'HTTP',
+            healthyThreshold: 2,
+            kind: 'healthCheck',
+            name: 'check-a',
+            port: 80,
+            requestPath: '/health',
+            selfLink: 'projects/test/regions/europe-west1/healthChecks/check-a',
+            timeoutSec: 5,
+            unhealthyThreshold: 3,
+          },
+        ],
+        listeners: [
+          {
+            certificate: regionalCertUrl,
+            ipAddress: '203.0.113.10',
+            name: 'app-https',
+            networkTier: 'STANDARD',
+            port: 443,
+            protocol: 'HTTPS',
+          },
+        ],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-main',
+        network: 'network-a',
+        region: 'europe-west1',
+      },
+      'create',
+    );
+
+    const jobs = buildGceLoadBalancerJobs(command);
+    const backendService = {
+      backends: [],
+      healthCheck: {
+        checkIntervalSec: 10,
+        healthCheckType: 'HTTP',
+        healthyThreshold: 2,
+        name: 'check-a',
+        port: 80,
+        requestPath: '/health',
+        timeoutSec: 5,
+        unhealthyThreshold: 3,
+      },
+      name: 'backend-a',
+      portName: 'http',
+      protocol: 'HTTP',
+      sessionAffinity: 'NONE',
+    };
+
+    expect(jobs).toEqual([
+      {
+        cloudProvider: 'gce',
+        credentials: 'account-a',
+        defaultService: backendService,
+        hostRules: [],
+        ipAddress: '203.0.113.10',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-https',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-https',
+        network: 'network-a',
+        networkTier: 'STANDARD',
+        portRange: '443',
+        provider: 'gce',
+        region: 'europe-west1',
+        type: 'upsertLoadBalancer',
+        urlMapName: 'app-main',
+        certificate: regionalCertUrl,
+      },
+    ]);
+    expect((jobs[0] as any).certificateMap).toBeUndefined();
+    expect(jobs[0].listeners).toBeUndefined();
+    expect(jobs[0].backendServices).toBeUndefined();
+    expect(jobs[0].healthChecks).toBeUndefined();
+  });
+
+  it('computes EXTERNAL_MANAGED listener deletions and backend diffs for edits', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        defaultService: {
+          backends: [],
+          healthCheck: 'default-check',
+          name: 'default-backend',
+        },
+        healthChecks: [
+          { healthCheckType: 'HTTP', name: 'default-check', port: 80 },
+          { healthCheckType: 'HTTP', name: 'removed-check', port: 8080 },
+        ],
+        listeners: [
+          { name: 'app-http', port: 80, protocol: 'HTTP' },
+          {
+            certificate: 'regional-cert',
+            name: 'app-https',
+            networkTier: 'STANDARD',
+            port: 443,
+            protocol: 'HTTPS',
+          },
+        ],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-main',
+        network: 'network-a',
+        region: 'europe-west1',
+        urlMapName: 'app-main',
+      },
+      'edit',
+    );
+    command.listeners = command.listeners.filter(({ name }) => name === 'app-http');
+    command.backendServices = command.backendServices.filter(({ name }) => name === 'default-backend');
+    command.healthChecks = command.healthChecks.filter(({ name }) => name === 'default-check');
+
+    const [job] = buildGceLoadBalancerJobs(command);
+
+    expect(job.listenersToDelete).toEqual(['app-https']);
+    expect(job.backendServiceDiff).toEqual([]);
+    expect(job).toEqual(
+      expect.objectContaining({
+        loadBalancerName: 'app-http',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        network: 'network-a',
+        networkTier: undefined,
+        region: 'europe-west1',
+        urlMapName: 'app-main',
+      }),
+    );
+  });
+
+  it('returns EXTERNAL_MANAGED pipeline operations without executing a task', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
+        defaultService: 'backend-a',
+        healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
+        listeners: [
+          {
+            ipAddress: '203.0.113.10',
+            name: 'external-http',
+            networkTier: 'STANDARD',
+            port: 80,
+            protocol: 'HTTP',
+          },
+        ],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-external',
+        network: 'network-a',
+        region: 'europe-west1',
+      },
+      'pipeline',
+    );
+    const executeTask = vi.fn();
+
+    const result = submitGceLoadBalancerCommand(command, { application: {} as any, executeTask });
+
+    expect(result).toEqual(buildGceLoadBalancerJobs(command));
+    expect((result as any[])[0]).toEqual(
+      expect.objectContaining({
+        ipAddress: '203.0.113.10',
+        loadBalancerName: 'external-http',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        network: 'network-a',
+        networkTier: 'STANDARD',
+        portRange: '80',
+        region: 'europe-west1',
+        urlMapName: 'app-external',
+      }),
+    );
+    expect(executeTask).not.toHaveBeenCalled();
+  });
+
+  it('serializes the exact REGIONAL_EXTERNAL_NETWORK Clouddriver contract', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendService: {
+          healthCheck: { healthCheckType: 'TCP', name: 'tcp-check', port: 80 },
+          name: 'app-main',
+          sessionAffinity: 'CLIENT_IP',
+        },
+        ipAddress: '35.1.2.3',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK',
+        networkTier: 'PREMIUM',
+        ports: ['80', '443'],
+        region: 'europe-west1',
+      },
+      'pipeline',
+    );
+
+    const [job] = buildGceLoadBalancerJobs(command);
+
+    expect(job).toEqual({
+      backendService: {
+        healthCheck: { healthCheckType: 'TCP', name: 'tcp-check', port: 80 },
+        name: 'app-main',
+        sessionAffinity: 'CLIENT_IP',
+      },
+      cloudProvider: 'gce',
+      credentials: 'account-a',
+      ipAddress: '35.1.2.3',
+      ipProtocol: 'TCP',
+      loadBalancerName: 'app-main',
+      loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK',
+      name: 'app-main',
+      networkTier: 'PREMIUM',
+      ports: ['80', '443'],
+      provider: 'gce',
+      region: 'europe-west1',
+      type: 'upsertLoadBalancer',
+    });
+    expect((job as any).portRange).toBeUndefined();
+    expect((job as any).backendServices).toBeUndefined();
+    expect((job as any).healthChecks).toBeUndefined();
+  });
+
+  it('preserves REGIONAL_EXTERNAL_NETWORK ipAddress and networkTier during edit serialization', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendService: {
+          healthCheck: { healthCheckType: 'UDP', name: 'udp-check', port: 53 },
+          name: 'app-main',
+          sessionAffinity: 'CLIENT_IP_PROTO',
+        },
+        ipAddress: '35.1.2.3',
+        ipProtocol: 'UDP',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK',
+        networkTier: 'PREMIUM',
+        ports: ['53'],
+        region: 'europe-west1',
+      },
+      'edit',
+    );
+    const [job] = buildGceLoadBalancerJobs(command);
+
+    expect(job.ipAddress).toBe('35.1.2.3');
+    expect(job.networkTier).toBe('PREMIUM');
+    expect(job.ipProtocol).toBe('UDP');
+    expect(job.ports).toEqual(['53']);
+  });
+
+  (['HTTP', 'INTERNAL_MANAGED'] as const).forEach((loadBalancerType) => {
+    it(`builds ${loadBalancerType} jobs without networkTier`, () => {
+      const command = normalizeGceLoadBalancerCommand(
+        {
+          account: 'account-a',
+          backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
+          defaultService: 'backend-a',
+          healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
+          listeners: [
+            {
+              ipAddress: '203.0.113.10',
+              name: 'frontend',
+              networkTier: 'STANDARD',
+              port: 80,
+              protocol: 'HTTP',
+            },
+          ],
+          loadBalancerType,
+          name: 'web',
+          network: loadBalancerType === 'INTERNAL_MANAGED' ? 'network-a' : undefined,
+          region: loadBalancerType === 'INTERNAL_MANAGED' ? 'europe-west1' : 'global',
+          subnet: loadBalancerType === 'INTERNAL_MANAGED' ? 'subnet-a' : undefined,
+        },
+        'create',
+      );
+
+      const [job] = buildGceLoadBalancerJobs(command);
+      expect(job.networkTier).toBeUndefined();
+    });
+  });
+
   it('round-trips a flat HTTP pipeline operation without nesting or changing its identities', () => {
     const operation = {
       cloudProvider: 'gce',

package/src/loadBalancer/configure/common/gceLoadBalancerSubmission.ts

@@ -10,7 +10,11 @@ import type {
   IGceResourceReference,
   IGceSerializedLoadBalancerCommand,
 } from './gceLoadBalancerModels';
-import { serializeGceLoadBalancerCommand } from './gceLoadBalancerModels';
+import {
+  serializeGceBackendService,
+  serializeGceHealthCheck,
+  serializeGceLoadBalancerCommand,
+} from './gceLoadBalancerModels';
 
 export interface IGceLoadBalancerSubmissionDependencies {
   application: Application;
@@ -23,9 +27,15 @@ export type GceLoadBalancerSubmissionResult =
   | GceLoadBalancerOperationList
   | Promise<ITask>;
 
+function isFlattenedHttpLoadBalancerType(loadBalancerType: IGceLoadBalancerCommand['loadBalancerType']): boolean {
+  return (
+    loadBalancerType === 'HTTP' || loadBalancerType === 'INTERNAL_MANAGED' || loadBalancerType === 'EXTERNAL_MANAGED'
+  );
+}
+
 export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceLoadBalancerOperationList {
   const serialized = serializeGceLoadBalancerCommand(command);
-  if (command.loadBalancerType !== 'HTTP' && command.loadBalancerType !== 'INTERNAL_MANAGED') {
+  if (!isFlattenedHttpLoadBalancerType(command.loadBalancerType)) {
     return [serialized];
   }
 
@@ -37,7 +47,10 @@ export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceL
     ...shared
   } = serialized;
   const backendServices = new Map(
-    command.backendServices.map((service) => [service.name, serializeBackendService(service, command.healthChecks)]),
+    command.backendServices.map((service) => [
+      service.name,
+      serializeBackendService(service, command.healthChecks, command.loadBalancerType === 'EXTERNAL_MANAGED'),
+    ]),
   );
   const defaultService = resolveBackendService(command.defaultService, backendServices);
   const hostRules = command.hostRules.flatMap((hostRule) =>
@@ -59,6 +72,7 @@ export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceL
 
   const jobs = ((listeners || []) as Array<Record<string, unknown>>).map((listener) => {
     const name = String(listener.name);
+    const networkTier = listener.networkTier as string | undefined;
     return {
       ...shared,
       certificate: listener.certificate || null,
@@ -70,6 +84,7 @@ export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceL
       name,
       portRange: listener.portRange,
       ...(listener.subnet ? { subnet: listener.subnet } : {}),
+      ...(command.loadBalancerType === 'EXTERNAL_MANAGED' ? { networkTier } : {}),
       urlMapName: command.name,
     } as IGceSerializedLoadBalancerCommand;
   });
@@ -82,7 +97,13 @@ export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceL
       .filter((name) => !listenerNames.has(name));
     jobs[0].backendServiceDiff = command.original.backendServices
       .filter((service) => !isEqual(service, currentBackendServices.get(service.name)))
-      .map((service) => serializeBackendService(service, command.original!.healthChecks));
+      .map((service) =>
+        serializeBackendService(
+          service,
+          command.original!.healthChecks,
+          command.loadBalancerType === 'EXTERNAL_MANAGED',
+        ),
+      );
   }
 
   return jobs;
@@ -91,10 +112,19 @@ export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceL
 function serializeBackendService(
   service: IGceLoadBalancerBackendService,
   healthChecks: IGceLoadBalancerHealthCheck[],
+  editorFieldsOnly = false,
 ): Record<string, unknown> {
   const healthCheck = service.healthCheck
     ? healthChecks.find(({ name }) => name === service.healthCheck?.name) || service.healthCheck
     : undefined;
+  // EXTERNAL_MANAGED sends only the backend-service and health-check fields its editor supports
+  // instead of echoing every cached field; other types send the cached object.
+  if (editorFieldsOnly) {
+    return {
+      ...serializeGceBackendService(service),
+      ...(healthCheck ? { healthCheck: serializeGceHealthCheck(healthCheck as IGceLoadBalancerHealthCheck) } : {}),
+    };
+  }
   return {
     ...service,
     ...(healthCheck ? { healthCheck: { ...healthCheck } } : {}),
@@ -114,7 +144,7 @@ export function submitGceLoadBalancerCommand(
 ): GceLoadBalancerSubmissionResult {
   const jobs = buildGceLoadBalancerJobs(command);
   if (command.mode === 'pipeline') {
-    return command.loadBalancerType === 'HTTP' || command.loadBalancerType === 'INTERNAL_MANAGED' ? jobs : jobs[0];
+    return isFlattenedHttpLoadBalancerType(command.loadBalancerType) ? jobs : jobs[0];
   }
 
   return Promise.resolve(

package/src/loadBalancer/configure/common/useGceLoadBalancerData.spec.tsx

@@ -1,68 +1,59 @@
-import React from 'react';
-import { mount } from 'enzyme';
+import type { Mocked } from 'vitest';
+import { act } from '@testing-library/react';
 
-import type { IGceLoadBalancerDataReaders, IGceLoadBalancerDataState } from './gceLoadBalancerData';
+import { renderHookHarness } from '../../../../../core/src/utils/testUtils/hookHarness';
+import type { IGceLoadBalancerDataReaders } from './gceLoadBalancerData';
 import { useGceLoadBalancerData } from './useGceLoadBalancerData';
 
 describe('useGceLoadBalancerData', () => {
   it('reloads data when the account changes', async () => {
     const readers = testReaders();
-    const states: IGceLoadBalancerDataState[] = [];
-    const wrapper = mount(<Harness account="first" readers={readers} onState={(state) => states.push(state)} />);
+    const hook = renderHookHarness(
+      ({ account, dataReaders }: { account: string; dataReaders: IGceLoadBalancerDataReaders }) =>
+        useGceLoadBalancerData(account, dataReaders),
+      { account: 'first', dataReaders: readers },
+    );
 
-    await settle();
-    wrapper.setProps({ account: 'second' });
-    await settle();
+    await act(settle);
+    hook.rerenderHook({ account: 'second', dataReaders: readers });
+    await act(settle);
 
-    expect(readers.regions.calls.allArgs()).toEqual([['first'], ['second']]);
-    expect(states[states.length - 1].status).toBe('ready');
-    wrapper.unmount();
+    expect(readers.regions.mock.calls).toEqual([['first'], ['second']]);
+    expect(hook.result.current.status).toBe('ready');
+    hook.unmount();
   });
 
   it('does not publish a request result after unmount', async () => {
     const regions = deferred<unknown[]>();
     const readers = testReaders();
-    readers.regions.and.returnValue(regions.promise);
-    const onState = jasmine.createSpy('onState');
-    const wrapper = mount(<Harness account="test-account" readers={readers} onState={onState} />);
-    await settle();
-    const callsBeforeUnmount = onState.calls.count();
+    readers.regions.mockReturnValue(regions.promise);
+    const hook = renderHookHarness(
+      ({ account, dataReaders }: { account: string; dataReaders: IGceLoadBalancerDataReaders }) =>
+        useGceLoadBalancerData(account, dataReaders),
+      { account: 'test-account', dataReaders: readers },
+    );
+    await act(settle);
+    const stateBeforeUnmount = hook.result.current;
 
-    wrapper.unmount();
+    hook.unmount();
     regions.resolve([{ name: 'late-region' }]);
-    await settle();
+    await act(settle);
 
-    expect(onState.calls.count()).toBe(callsBeforeUnmount);
+    expect(hook.result.current).toBe(stateBeforeUnmount);
   });
 });
 
-function Harness({
-  account,
-  readers,
-  onState,
-}: {
-  account: string;
-  readers: IGceLoadBalancerDataReaders;
-  onState: (state: IGceLoadBalancerDataState) => void;
-}) {
-  const state = useGceLoadBalancerData(account, readers);
-  React.useEffect(() => {
-    onState(state);
-  }, [state.status, state.data, state.error]);
-  return null;
-}
-
-function testReaders(): jasmine.SpyObj<IGceLoadBalancerDataReaders> {
-  return jasmine.createSpyObj<IGceLoadBalancerDataReaders>('readers', {
-    accounts: Promise.resolve([]),
-    addresses: Promise.resolve([]),
-    backendServices: Promise.resolve([]),
-    certificates: Promise.resolve([]),
-    healthChecks: Promise.resolve([]),
-    networks: Promise.resolve([]),
-    regions: Promise.resolve([]),
-    subnets: Promise.resolve([]),
-  });
+function testReaders(): Mocked<IGceLoadBalancerDataReaders> {
+  return {
+    accounts: vi.fn().mockReturnValue(Promise.resolve([])),
+    addresses: vi.fn().mockReturnValue(Promise.resolve([])),
+    backendServices: vi.fn().mockReturnValue(Promise.resolve([])),
+    certificates: vi.fn().mockReturnValue(Promise.resolve([])),
+    healthChecks: vi.fn().mockReturnValue(Promise.resolve([])),
+    networks: vi.fn().mockReturnValue(Promise.resolve([])),
+    regions: vi.fn().mockReturnValue(Promise.resolve([])),
+    subnets: vi.fn().mockReturnValue(Promise.resolve([])),
+  };
 }
 
 function deferred<T>() {