@spinnaker/google 2026.2.2 → 2026.3.0

package/src/loadBalancer/configure/network/GceNetworkLoadBalancerModal.spec.tsx

@@ -0,0 +1,303 @@
+import React from 'react';
+import { shallow } from 'enzyme';
+
+import { GceNetworkLoadBalancerEditor } from './GceNetworkLoadBalancerEditor';
+import {
+  GceNetworkLoadBalancerModal,
+  normalizeGceNetworkLoadBalancerCommand,
+  serializeGceNetworkLoadBalancerCommand,
+  submitGceNetworkLoadBalancerCommand,
+} from './GceNetworkLoadBalancerModal';
+
+describe('GceNetworkLoadBalancerModal', () => {
+  const application = { name: 'app' } as any;
+
+  it('normalizes persisted NETWORK details and resource references for edit', () => {
+    const command = normalizeGceNetworkLoadBalancerCommand(
+      {
+        account: 'account-a',
+        healthCheck: {
+          checkIntervalSec: 15,
+          healthyThreshold: 3,
+          name: 'app-main-hc',
+          port: '8080',
+          requestPath: 'health',
+          selfLink: 'projects/test/global/httpHealthChecks/app-main-hc',
+          timeoutSec: 7,
+          unhealthyThreshold: 4,
+        },
+        ipAddress: 'projects/test/regions/europe-west1/addresses/app-main-ip',
+        ipProtocol: 'udp',
+        loadBalancerName: 'app-main',
+        network: 'projects/test/global/networks/default',
+        portRange: 8080,
+        region: 'europe-west1',
+        sessionAffinity: 'client_ip_proto',
+        targetPool: 'projects/test/regions/europe-west1/targetPools/app-main-tp',
+      },
+      'edit',
+    );
+
+    expect(command).toEqual(
+      jasmine.objectContaining({
+        credentials: 'account-a',
+        loadBalancerType: 'NETWORK',
+        mode: 'edit',
+        name: 'app-main',
+        network: { name: 'default', selfLink: 'projects/test/global/networks/default' },
+        region: 'europe-west1',
+        sessionAffinity: 'CLIENT_IP_PROTO',
+        targetPool: {
+          name: 'app-main-tp',
+          selfLink: 'projects/test/regions/europe-west1/targetPools/app-main-tp',
+        },
+      }),
+    );
+    expect(command.listeners).toEqual([
+      {
+        address: {
+          name: 'app-main-ip',
+          selfLink: 'projects/test/regions/europe-west1/addresses/app-main-ip',
+        },
+        name: 'app-main',
+        portRange: '8080',
+        protocol: 'UDP',
+      },
+    ]);
+    expect(command.healthChecks).toEqual([
+      jasmine.objectContaining({
+        checkIntervalSec: 15,
+        healthyThreshold: 3,
+        name: 'app-main-hc',
+        port: 8080,
+        requestPath: '/health',
+        selfLink: 'projects/test/global/httpHealthChecks/app-main-hc',
+        timeoutSec: 7,
+        unhealthyThreshold: 4,
+      }),
+    ]);
+  });
+
+  it('normalizes the nested load-balancer details shape used by infrastructure edit', () => {
+    const command = normalizeGceNetworkLoadBalancerCommand(
+      {
+        account: 'account-a',
+        elb: {
+          healthCheck: { port: 53, requestPath: '/health' },
+          ipAddress: 'address-a',
+          listenerDescriptions: [{ listener: { loadBalancerPort: '53', protocol: 'UDP' } }],
+          sessionAffinity: 'CLIENT_IP',
+        },
+        name: 'app-main',
+        network: 'network-a',
+        region: 'europe-west1',
+        targetPool: 'target-pool-a',
+      },
+      'edit',
+    );
+
+    expect(command.listeners[0]).toEqual({
+      address: { name: 'address-a' },
+      name: 'app-main',
+      portRange: '53',
+      protocol: 'UDP',
+    });
+    expect(command.healthChecks[0]).toEqual(jasmine.objectContaining({ port: 53, requestPath: '/health' }));
+    expect(command.sessionAffinity).toBe('CLIENT_IP');
+  });
+
+  it('creates the historical NETWORK defaults without inventing persisted references', () => {
+    const command = normalizeGceNetworkLoadBalancerCommand({}, 'create', 'app', {
+      credentials: 'account-a',
+      region: 'europe-west1',
+    });
+
+    expect(command).toEqual(
+      jasmine.objectContaining({
+        credentials: 'account-a',
+        loadBalancerType: 'NETWORK',
+        mode: 'create',
+        name: 'app',
+        network: undefined,
+        region: 'europe-west1',
+        sessionAffinity: 'NONE',
+        targetPool: undefined,
+      }),
+    );
+    expect(command.listeners).toEqual([{ name: 'app', portRange: '8080', protocol: 'TCP' }]);
+    expect(command.healthChecks).toEqual([
+      {
+        checkIntervalSec: 10,
+        healthCheckType: 'HTTP',
+        healthyThreshold: 10,
+        port: 80,
+        requestPath: '/',
+        timeoutSec: 5,
+        unhealthyThreshold: 2,
+      },
+    ]);
+  });
+
+  ([null, undefined] as const).forEach((loadBalancer) => {
+    it(`initializes infrastructure create when the persisted load balancer is ${String(loadBalancer)}`, () => {
+      const wrapper = shallow(
+        <GceNetworkLoadBalancerModal
+          app={application}
+          closeModal={jasmine.createSpy('closeModal')}
+          data={emptyData()}
+          dismissModal={jasmine.createSpy('dismissModal')}
+          loadBalancer={loadBalancer as any}
+          mode="create"
+        />,
+      );
+
+      const command = wrapper.find(GceNetworkLoadBalancerEditor).prop('command');
+      expect(command.mode).toBe('create');
+      expect(command.listeners).toEqual([{ name: 'app', portRange: '8080', protocol: 'TCP' }]);
+      expect(command.healthChecks).toEqual([
+        {
+          checkIntervalSec: 10,
+          healthCheckType: 'HTTP',
+          healthyThreshold: 10,
+          port: 80,
+          requestPath: '/',
+          timeoutSec: 5,
+          unhealthyThreshold: 2,
+        },
+      ]);
+    });
+  });
+
+  it('serializes the exact Clouddriver NETWORK contract without editor-only network or persisted references', () => {
+    const command = normalizeGceNetworkLoadBalancerCommand(
+      {
+        account: 'account-a',
+        healthCheck: {
+          checkIntervalSec: 15,
+          healthCheckType: 'HTTP',
+          healthyThreshold: 3,
+          name: 'persisted-name',
+          port: 8080,
+          requestPath: '/health',
+          selfLink: 'projects/test/global/httpHealthChecks/persisted-name',
+          timeoutSec: 7,
+          unhealthyThreshold: 4,
+        },
+        ipAddress: 'address-a',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-main',
+        network: 'network-a',
+        portRange: '80-81',
+        region: 'europe-west1',
+        sessionAffinity: 'CLIENT_IP',
+        targetPool: 'target-pool-a',
+      },
+      'pipeline',
+    );
+
+    const payload = serializeGceNetworkLoadBalancerCommand(command);
+
+    expect(payload).toEqual({
+      cloudProvider: 'gce',
+      credentials: 'account-a',
+      healthCheck: {
+        checkIntervalSec: 15,
+        healthyThreshold: 3,
+        port: 8080,
+        requestPath: '/health',
+        timeoutSec: 7,
+        unhealthyThreshold: 4,
+      },
+      ipAddress: 'address-a',
+      ipProtocol: 'TCP',
+      loadBalancerName: 'app-main',
+      loadBalancerType: 'NETWORK',
+      name: 'app-main',
+      portRange: '80-81',
+      provider: 'gce',
+      region: 'europe-west1',
+      sessionAffinity: 'CLIENT_IP',
+      type: 'upsertLoadBalancer',
+    });
+    expect((payload as any).network).toBeUndefined();
+    expect((payload as any).targetPool).toBeUndefined();
+    expect((payload as any).healthChecks).toBeUndefined();
+    expect((payload as any).listeners).toBeUndefined();
+    expect((payload as any).mode).toBeUndefined();
+  });
+
+  it('returns only the normalized command in pipeline mode', () => {
+    const executeTask = jasmine.createSpy('executeTask');
+    const command = validCommand('pipeline');
+
+    const result = submitGceNetworkLoadBalancerCommand(command, { application, executeTask });
+
+    expect(result).toEqual(serializeGceNetworkLoadBalancerCommand(command));
+    expect(executeTask).not.toHaveBeenCalled();
+  });
+
+  (['create', 'edit'] as const).forEach((mode) => {
+    it(`executes the direct normalized job in infrastructure ${mode} mode`, () => {
+      const task = Promise.resolve({ id: 'task' });
+      const executeTask = jasmine.createSpy('executeTask').and.returnValue(task);
+      const command = validCommand(mode);
+
+      const result = submitGceNetworkLoadBalancerCommand(command, { application, executeTask });
+
+      expect(result).toBe(task);
+      expect(executeTask).toHaveBeenCalledOnceWith({
+        application,
+        description: `${mode === 'edit' ? 'Update' : 'Create'} Load Balancer: app-main`,
+        job: [serializeGceNetworkLoadBalancerCommand(command)],
+      });
+    });
+  });
+
+  it('exposes pipeline support and passes edit mode to the editor', () => {
+    expect(GceNetworkLoadBalancerModal.supportsPipelineConfig).toBe(true);
+    expect(typeof GceNetworkLoadBalancerModal.show).toBe('function');
+    const wrapper = shallow(
+      <GceNetworkLoadBalancerModal
+        app={application}
+        closeModal={jasmine.createSpy('closeModal')}
+        data={emptyData()}
+        dismissModal={jasmine.createSpy('dismissModal')}
+        isNew={false}
+        loadBalancer={{ account: 'account-a', name: 'app-main', region: 'europe-west1' } as any}
+      />,
+    );
+
+    expect(wrapper.find(GceNetworkLoadBalancerEditor).prop('command').mode).toBe('edit');
+  });
+});
+
+function validCommand(mode: 'create' | 'edit' | 'pipeline'): any {
+  return normalizeGceNetworkLoadBalancerCommand(
+    {
+      account: 'account-a',
+      healthCheck: { port: 80, requestPath: '/' },
+      ipAddress: 'address-a',
+      ipProtocol: 'TCP',
+      loadBalancerName: 'app-main',
+      network: 'network-a',
+      portRange: '80',
+      region: 'europe-west1',
+      sessionAffinity: 'NONE',
+      targetPool: 'target-pool-a',
+    },
+    mode,
+  );
+}
+
+function emptyData(): any {
+  return {
+    accounts: [],
+    addresses: [],
+    backendServices: [],
+    certificates: [],
+    healthChecks: [],
+    networks: [],
+    regions: [],
+    subnets: [],
+  };
+}

package/src/loadBalancer/configure/network/GceNetworkLoadBalancerModal.tsx

@@ -0,0 +1,368 @@
+import React from 'react';
+
+import type { Application, IModalComponentProps, ITask, ITaskCommand } from '@spinnaker/core';
+import {
+  InfrastructureCaches,
+  ModalClose,
+  ReactModal,
+  SubmitButton,
+  TaskExecutor,
+  TaskMonitor,
+  TaskMonitorWrapper,
+} from '@spinnaker/core';
+
+import type { GceNetworkSessionAffinity, IGceNetworkLoadBalancerCommand } from './GceNetworkLoadBalancerEditor';
+import {
+  createGceNetworkHealthCheck,
+  GceNetworkLoadBalancerEditor,
+  validateGceNetworkLoadBalancerCommand,
+} from './GceNetworkLoadBalancerEditor';
+import type {
+  GceLoadBalancerEditorMode,
+  IGceLoadBalancerData,
+  IGceLoadBalancerDataReaders,
+  IGceLoadBalancerDataState,
+  IGceLoadBalancerHealthCheck,
+  IGceResourceReference,
+  IGceSerializedLoadBalancerCommand,
+} from '../common';
+import {
+  GceLoadBalancerDataController,
+  normalizeGceLoadBalancerCommand,
+  serializeGceLoadBalancerCommand,
+} from '../common';
+import { GCEProviderSettings } from '../../../gce.settings';
+
+type UnknownRecord = Record<string, any>;
+
+const EMPTY_DATA: IGceLoadBalancerData = {
+  accounts: [],
+  addresses: [],
+  backendServices: [],
+  certificates: [],
+  healthChecks: [],
+  networks: [],
+  regions: [],
+  subnets: [],
+};
+const SESSION_AFFINITIES: GceNetworkSessionAffinity[] = ['NONE', 'CLIENT_IP', 'CLIENT_IP_PROTO'];
+
+interface IGceNetworkHealthCheckPayload {
+  checkIntervalSec?: number;
+  healthyThreshold?: number;
+  port?: number;
+  requestPath?: string;
+  timeoutSec?: number;
+  unhealthyThreshold?: number;
+}
+
+export interface IGceNetworkLoadBalancerPayload extends IGceSerializedLoadBalancerCommand {
+  healthCheck: IGceNetworkHealthCheckPayload | null;
+  sessionAffinity: GceNetworkSessionAffinity;
+}
+
+export interface IGceNetworkLoadBalancerModalProps extends IModalComponentProps {
+  app?: Application;
+  application?: Application;
+  credentials?: string;
+  data?: IGceLoadBalancerData;
+  dataReaders?: IGceLoadBalancerDataReaders;
+  executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+  forPipelineConfig?: boolean;
+  isNew?: boolean;
+  loadBalancer?: UnknownRecord;
+  mode?: GceLoadBalancerEditorMode;
+}
+
+interface IGceNetworkLoadBalancerModalState extends IGceLoadBalancerDataState {
+  command: IGceNetworkLoadBalancerCommand;
+  taskMonitor: TaskMonitor;
+}
+
+interface IGceNetworkSubmissionDependencies {
+  application: Application;
+  executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+}
+
+export function normalizeGceNetworkLoadBalancerCommand(
+  persisted: UnknownRecord | null | undefined = {},
+  mode: GceLoadBalancerEditorMode,
+  applicationName = '',
+  defaults: Partial<Record<'credentials' | 'region', unknown>> = {},
+): IGceNetworkLoadBalancerCommand {
+  const persistedLoadBalancer = persisted || {};
+  const details =
+    persistedLoadBalancer.elb && typeof persistedLoadBalancer.elb === 'object' ? persistedLoadBalancer.elb : {};
+  const listener = details.listenerDescriptions?.[0]?.listener || {};
+  const sourceDetails: UnknownRecord = {
+    ...details,
+    ...persistedLoadBalancer,
+    healthCheck:
+      persistedLoadBalancer.healthCheck !== undefined ? persistedLoadBalancer.healthCheck : details.healthCheck,
+    ipAddress: persistedLoadBalancer.ipAddress !== undefined ? persistedLoadBalancer.ipAddress : details.ipAddress,
+    ipProtocol:
+      persistedLoadBalancer.ipProtocol !== undefined
+        ? persistedLoadBalancer.ipProtocol
+        : details.ipProtocol || listener.protocol,
+    portRange:
+      persistedLoadBalancer.portRange !== undefined
+        ? persistedLoadBalancer.portRange
+        : details.portRange || listener.loadBalancerPort,
+    sessionAffinity:
+      persistedLoadBalancer.sessionAffinity !== undefined
+        ? persistedLoadBalancer.sessionAffinity
+        : details.sessionAffinity,
+    targetPool: persistedLoadBalancer.targetPool !== undefined ? persistedLoadBalancer.targetPool : details.targetPool,
+  };
+  const hasHealthCheck =
+    Object.prototype.hasOwnProperty.call(persistedLoadBalancer, 'healthCheck') ||
+    Object.prototype.hasOwnProperty.call(details, 'healthCheck') ||
+    sourceDetails.healthChecks;
+  const persistedHealthChecks = sourceDetails.healthChecks?.length
+    ? sourceDetails.healthChecks
+    : sourceDetails.healthCheck
+    ? [normalizeHealthCheckInput(sourceDetails.healthCheck)]
+    : [];
+  const source: UnknownRecord = {
+    ...defaults,
+    ...sourceDetails,
+    credentials: sourceDetails.credentials || sourceDetails.account || defaults.credentials,
+    healthChecks: persistedHealthChecks,
+    ipAddress: normalizeReference(sourceDetails.ipAddress),
+    loadBalancerType: 'NETWORK',
+    name: sourceDetails.name || sourceDetails.loadBalancerName || applicationName,
+    network: normalizeReference(sourceDetails.network),
+    region: sourceDetails.region || defaults.region,
+  };
+  const command = normalizeGceLoadBalancerCommand(source, mode);
+  const hasListener =
+    (Array.isArray(sourceDetails.listeners) && sourceDetails.listeners.length > 0) ||
+    sourceDetails.ipAddress !== undefined ||
+    sourceDetails.ipProtocol !== undefined ||
+    sourceDetails.portRange !== undefined ||
+    sourceDetails.ports !== undefined;
+  if (!hasListener) {
+    command.listeners = [{ name: command.name, portRange: '8080', protocol: 'TCP' }];
+  }
+  if (mode === 'create' && !hasHealthCheck) {
+    command.healthChecks = [createGceNetworkHealthCheck()];
+  }
+
+  return {
+    ...command,
+    loadBalancerType: 'NETWORK',
+    sessionAffinity: normalizeSessionAffinity(sourceDetails.sessionAffinity),
+    targetPool: normalizeReference(sourceDetails.targetPool),
+  } as IGceNetworkLoadBalancerCommand;
+}
+
+export function serializeGceNetworkLoadBalancerCommand(
+  command: IGceNetworkLoadBalancerCommand,
+): IGceNetworkLoadBalancerPayload {
+  const serialized = serializeGceLoadBalancerCommand(command);
+  delete serialized.healthChecks;
+  delete serialized.listeners;
+  delete serialized.network;
+  delete serialized.targetPool;
+  delete serialized.mode;
+
+  return {
+    ...serialized,
+    healthCheck: serializeHealthCheck(command.healthChecks[0]),
+    sessionAffinity: command.sessionAffinity,
+  } as IGceNetworkLoadBalancerPayload;
+}
+
+export function submitGceNetworkLoadBalancerCommand(
+  command: IGceNetworkLoadBalancerCommand,
+  { application, executeTask = TaskExecutor.executeTask }: IGceNetworkSubmissionDependencies,
+): IGceNetworkLoadBalancerPayload | Promise<ITask> {
+  const payload = serializeGceNetworkLoadBalancerCommand(command);
+  if (command.mode === 'pipeline') {
+    return payload;
+  }
+
+  return Promise.resolve(
+    executeTask({
+      application,
+      description: `${command.mode === 'edit' ? 'Update' : 'Create'} Load Balancer: ${command.name}`,
+      job: [payload],
+    }),
+  );
+}
+
+class GceNetworkLoadBalancerModalComponent extends React.Component<
+  IGceNetworkLoadBalancerModalProps,
+  IGceNetworkLoadBalancerModalState
+> {
+  private dataController?: GceLoadBalancerDataController;
+  private unsubscribe?: () => void;
+
+  public constructor(props: IGceNetworkLoadBalancerModalProps) {
+    super(props);
+    const application = this.application(props);
+    const mode = this.mode(props);
+    const command = normalizeGceNetworkLoadBalancerCommand(props.loadBalancer, mode, application?.name, {
+      credentials: props.credentials || GCEProviderSettings.defaults.account,
+      region: GCEProviderSettings.defaults.region,
+    });
+    this.state = {
+      command,
+      data: props.data || EMPTY_DATA,
+      status: props.data ? 'ready' : 'idle',
+      taskMonitor: new TaskMonitor({
+        application,
+        title: `${mode === 'edit' ? 'Updating' : 'Creating'} your load balancer`,
+        onDismiss: () => props.dismissModal?.(),
+        onTaskComplete: () => {
+          InfrastructureCaches.clearCache('healthChecks');
+          application?.loadBalancers?.refresh?.();
+          props.closeModal?.();
+        },
+      }),
+    };
+  }
+
+  public componentDidMount(): void {
+    if (this.props.data) return;
+    this.dataController = new GceLoadBalancerDataController(this.props.dataReaders);
+    this.unsubscribe = this.dataController.subscribe((state) => this.setState(state));
+    this.dataController.load(this.state.command.credentials);
+  }
+
+  public componentWillUnmount(): void {
+    this.unsubscribe?.();
+    this.dataController?.dispose();
+  }
+
+  public render(): JSX.Element {
+    const { command, data, status, taskMonitor } = this.state;
+    const errors = validateGceNetworkLoadBalancerCommand(command);
+    const heading =
+      command.mode === 'create'
+        ? 'Create Network Load Balancer'
+        : command.mode === 'pipeline'
+        ? 'Configure Network Load Balancer'
+        : `Edit ${command.name}`;
+
+    return (
+      <div className="modal-content">
+        <TaskMonitorWrapper monitor={taskMonitor} />
+        <ModalClose dismiss={this.props.dismissModal} />
+        <div className="modal-header">
+          <h3>{heading}</h3>
+        </div>
+        <div className="modal-body">
+          {status === 'loading' && <div className="horizontal center middle">Loading...</div>}
+          {status === 'error' && <div className="alert alert-danger">Unable to load GCE resources.</div>}
+          <GceNetworkLoadBalancerEditor command={command} data={data} onChange={this.updateCommand} />
+          {!!errors.length && (
+            <div className="alert alert-danger gce-network-validation-errors">
+              {errors.map((error) => (
+                <div key={error}>{error}</div>
+              ))}
+            </div>
+          )}
+        </div>
+        <div className="modal-footer">
+          <button
+            className="btn btn-default"
+            disabled={taskMonitor.submitting}
+            onClick={this.props.dismissModal}
+            type="button"
+          >
+            Cancel
+          </button>
+          <SubmitButton
+            isDisabled={!!errors.length || status === 'loading' || taskMonitor.submitting}
+            isFormSubmit={false}
+            label={command.mode === 'pipeline' ? 'Done' : command.mode === 'edit' ? 'Update' : 'Create'}
+            onClick={this.submit}
+            submitting={taskMonitor.submitting}
+          />
+        </div>
+      </div>
+    );
+  }
+
+  private application(props = this.props): Application {
+    return (props.application || props.app) as Application;
+  }
+
+  private mode(props = this.props): GceLoadBalancerEditorMode {
+    if (props.forPipelineConfig) return 'pipeline';
+    if (props.mode) return props.mode;
+    return props.isNew === false || props.loadBalancer ? 'edit' : 'create';
+  }
+
+  private updateCommand = (command: IGceNetworkLoadBalancerCommand): void => {
+    const accountChanged = command.credentials !== this.state.command.credentials;
+    this.setState({ command });
+    if (accountChanged) this.dataController?.load(command.credentials);
+  };
+
+  private submit = (): void => {
+    if (this.state.command.mode === 'pipeline') {
+      this.props.closeModal?.(
+        submitGceNetworkLoadBalancerCommand(this.state.command, {
+          application: this.application(),
+          executeTask: this.props.executeTask,
+        }),
+      );
+      return;
+    }
+    this.state.taskMonitor.submit(
+      () =>
+        submitGceNetworkLoadBalancerCommand(this.state.command, {
+          application: this.application(),
+          executeTask: this.props.executeTask,
+        }) as PromiseLike<ITask>,
+    );
+  };
+}
+
+export const GceNetworkLoadBalancerModal = Object.assign(GceNetworkLoadBalancerModalComponent, {
+  show: (props: IGceNetworkLoadBalancerModalProps) =>
+    ReactModal.show(GceNetworkLoadBalancerModalComponent, props, { dialogClassName: 'modal-lg' }),
+  supportsPipelineConfig: true,
+});
+
+function normalizeHealthCheckInput(value: unknown): UnknownRecord {
+  if (value && typeof value === 'object') return value as UnknownRecord;
+  const reference = normalizeReference(value);
+  return reference || {};
+}
+
+function normalizeReference(value: unknown): IGceResourceReference | undefined {
+  if (!value) return undefined;
+  if (typeof value === 'object') {
+    const reference = value as UnknownRecord;
+    const selfLink = String(reference.selfLink || '');
+    const name = String(reference.name || reference.id || selfLink.split('/').filter(Boolean).pop() || '');
+    return name ? ({ ...reference, name } as IGceResourceReference) : undefined;
+  }
+  const selfLink = String(value);
+  const name = selfLink.split('/').filter(Boolean).pop() || selfLink;
+  return selfLink.includes('/') ? { name, selfLink } : { name };
+}
+
+function normalizeSessionAffinity(value: unknown): GceNetworkSessionAffinity {
+  const normalized = String(value || 'NONE').toUpperCase() as GceNetworkSessionAffinity;
+  return SESSION_AFFINITIES.includes(normalized) ? normalized : 'NONE';
+}
+
+function serializeHealthCheck(healthCheck?: IGceLoadBalancerHealthCheck): IGceNetworkHealthCheckPayload | null {
+  if (!healthCheck) return null;
+  return {
+    checkIntervalSec: numberOrUndefined(healthCheck.checkIntervalSec),
+    healthyThreshold: numberOrUndefined(healthCheck.healthyThreshold),
+    port: numberOrUndefined(healthCheck.port),
+    requestPath: healthCheck.requestPath,
+    timeoutSec: numberOrUndefined(healthCheck.timeoutSec),
+    unhealthyThreshold: numberOrUndefined(healthCheck.unhealthyThreshold),
+  };
+}
+
+function numberOrUndefined(value: unknown): number | undefined {
+  return value === undefined || value === null || value === '' ? undefined : Number(value);
+}