@spinnaker/google 2026.2.2 → 2026.3.0

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

@@ -0,0 +1,313 @@
+import React from 'react';
+import { mount, shallow } from 'enzyme';
+
+import { LoadBalancerWriter, TaskMonitorWrapper } from '@spinnaker/core';
+
+import { GceProxyLoadBalancerEditor } from './GceProxyLoadBalancerEditor';
+import {
+  GceProxyLoadBalancerModal,
+  normalizeGceProxyLoadBalancerCommand,
+  serializeGceProxyLoadBalancerCommand,
+  submitGceProxyLoadBalancerCommand,
+} from './GceProxyLoadBalancerModal';
+
+describe('GceProxyLoadBalancerModal', () => {
+  const application = {
+    loadBalancers: { onNextRefresh: jasmine.createSpy('onNextRefresh'), refresh: jasmine.createSpy('refresh') },
+    name: 'app',
+  } as any;
+
+  it('normalizes the historical singular backend service contract for edit without losing references', () => {
+    const command = normalizeGceProxyLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendService: {
+          affinityCookieTtlSec: 120,
+          connectionDrainingTimeoutSec: 30,
+          healthCheck: {
+            checkIntervalSec: 10,
+            healthCheckType: 'TCP',
+            name: 'removed-check',
+            port: 443,
+            selfLink: 'projects/test/global/healthChecks/removed-check',
+            timeoutSec: 5,
+          },
+          name: 'removed-backend',
+          portName: 'tls',
+          sessionAffinity: 'GENERATED_COOKIE',
+        },
+        certificate: 'projects/test/global/sslCertificates/removed-cert',
+        ipAddress: 'projects/test/global/addresses/removed-address',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'SSL',
+        portRange: '443',
+        region: 'global',
+      },
+      'edit',
+      'SSL',
+    );
+
+    expect(command.mode).toBe('edit');
+    expect(command.listeners[0]).toEqual(
+      jasmine.objectContaining({
+        address: { name: 'removed-address', selfLink: 'projects/test/global/addresses/removed-address' },
+        certificate: { name: 'removed-cert', selfLink: 'projects/test/global/sslCertificates/removed-cert' },
+        protocol: 'SSL',
+      }),
+    );
+    expect(command.backendServices[0]).toEqual(
+      jasmine.objectContaining({
+        affinityCookieTtlSec: 120,
+        connectionDrainingTimeoutSec: 30,
+        healthCheck: {
+          name: 'removed-check',
+          selfLink: 'projects/test/global/healthChecks/removed-check',
+        },
+        name: 'removed-backend',
+        portName: 'tls',
+        protocol: 'TCP',
+        sessionAffinity: 'GENERATED_COOKIE',
+      }),
+    );
+    expect(command.healthChecks[0]).toEqual(
+      jasmine.objectContaining({ healthCheckType: 'TCP', name: 'removed-check', port: 443, timeoutSec: 5 }),
+    );
+  });
+
+  it('serializes SSL frontend state to the compatible historical Clouddriver operation payload', () => {
+    const command = normalizeGceProxyLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendService: {
+          connectionDrainingTimeoutSec: 30,
+          name: 'app-main',
+          portName: 'tls',
+          sessionAffinity: 'NONE',
+        },
+        certificate: 'cert-a',
+        healthChecks: [
+          {
+            checkIntervalSec: '15',
+            healthCheckType: 'HTTP',
+            healthyThreshold: '2',
+            host: 'api.internal',
+            name: 'check-a',
+            port: '8080',
+            proxyHeader: 'PROXY_V1',
+            requestPath: 'ready',
+            timeoutSec: '5',
+            unhealthyThreshold: '3',
+            useServingPort: false,
+          },
+        ],
+        ipAddress: 'address-a',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'SSL',
+        portRange: '443',
+      },
+      'pipeline',
+      'SSL',
+    );
+
+    const payload = serializeGceProxyLoadBalancerCommand(command);
+
+    expect(command.listeners[0].protocol).toBe('SSL');
+    expect(payload).toEqual(
+      jasmine.objectContaining({
+        backendService: jasmine.objectContaining({
+          connectionDrainingTimeoutSec: 30,
+          healthCheck: jasmine.objectContaining({
+            checkIntervalSec: 15,
+            healthCheckType: 'HTTP',
+            healthyThreshold: 2,
+            host: 'api.internal',
+            name: 'check-a',
+            port: 8080,
+            proxyHeader: 'PROXY_V1',
+            requestPath: '/ready',
+            timeoutSec: 5,
+            unhealthyThreshold: 3,
+            useServingPort: false,
+          }),
+          name: 'app-main',
+          portName: 'tls',
+          protocol: undefined,
+          sessionAffinity: 'NONE',
+        }),
+        certificate: 'cert-a',
+        cloudProvider: 'gce',
+        credentials: 'account-a',
+        ipAddress: 'address-a',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'SSL',
+        name: 'app-main',
+        portRange: '443',
+        provider: 'gce',
+        region: 'global',
+        type: 'upsertLoadBalancer',
+      }),
+    );
+    expect(payload.backendServices).toBeUndefined();
+    expect(payload.healthChecks).toBeUndefined();
+  });
+
+  it('serializes INTERNAL listeners as regional ports with the selected backend protocol', () => {
+    const command = normalizeGceProxyLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendService: { name: 'app-main', sessionAffinity: 'NONE' },
+        healthChecks: [{ healthCheckType: 'TCP', name: 'check-a', port: 80 }],
+        ipAddress: '10.0.0.2',
+        ipProtocol: 'UDP',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'INTERNAL',
+        network: 'network-a',
+        ports: ['80', '443'],
+        region: 'europe-west1',
+        subnet: 'subnet-a',
+      },
+      'create',
+      'INTERNAL',
+    );
+
+    const payload = serializeGceProxyLoadBalancerCommand(command);
+
+    expect(payload).toEqual(
+      jasmine.objectContaining({
+        ipProtocol: 'UDP',
+        network: 'network-a',
+        ports: ['80', '443'],
+        region: 'europe-west1',
+        subnet: 'subnet-a',
+      }),
+    );
+    expect(payload.portRange).toBeUndefined();
+  });
+
+  it('returns the operation payload through the modal in pipeline mode without starting a task', () => {
+    const closeModal = jasmine.createSpy('closeModal');
+    const taskMonitor = { submit: jasmine.createSpy('submit') } as any;
+    const command = validCommand('pipeline');
+
+    submitGceProxyLoadBalancerCommand(command, { application, closeModal, taskMonitor });
+
+    expect(closeModal).toHaveBeenCalledOnceWith(serializeGceProxyLoadBalancerCommand(command));
+    expect(taskMonitor.submit).not.toHaveBeenCalled();
+  });
+
+  (['create', 'edit'] as const).forEach((mode) => {
+    it(`submits the Clouddriver payload through LoadBalancerWriter in infrastructure ${mode} mode`, () => {
+      const upsert = spyOn(LoadBalancerWriter, 'upsertLoadBalancer').and.returnValue(new Promise(() => {}));
+      let operation: (() => PromiseLike<any>) | undefined;
+      const taskMonitor = {
+        submit: jasmine.createSpy('submit').and.callFake((submitOperation: () => PromiseLike<any>) => {
+          operation = submitOperation;
+        }),
+      } as any;
+      const command = validCommand(mode);
+
+      submitGceProxyLoadBalancerCommand(command, {
+        application,
+        closeModal: jasmine.createSpy('closeModal'),
+        taskMonitor,
+      });
+      operation?.();
+
+      expect(upsert).toHaveBeenCalledWith(
+        serializeGceProxyLoadBalancerCommand(command),
+        application,
+        mode === 'create' ? 'Create' : 'Update',
+        { healthCheck: {} },
+      );
+    });
+  });
+
+  it('exposes pipeline support and locks infrastructure identity fields in edit mode', () => {
+    expect(GceProxyLoadBalancerModal.supportsPipelineConfig).toBe(true);
+    expect(typeof GceProxyLoadBalancerModal.show).toBe('function');
+    const wrapper = shallow(
+      <GceProxyLoadBalancerModal
+        app={application}
+        closeModal={jasmine.createSpy('closeModal')}
+        dismissModal={jasmine.createSpy('dismissModal')}
+        isNew={false}
+        loadBalancer={
+          {
+            account: 'account-a',
+            backendService: { name: 'app-main' },
+            loadBalancerType: 'TCP',
+            name: 'app-main',
+            portRange: '443',
+          } as any
+        }
+        loadBalancerType="TCP"
+      />,
+    );
+
+    expect(wrapper.find(GceProxyLoadBalancerEditor).prop('command').mode).toBe('edit');
+    expect(wrapper.find(GceProxyLoadBalancerEditor).prop('disabled')).toBe(true);
+  });
+
+  it('owns its refresh subscription across replacement and unmount', () => {
+    const firstUnsubscribe = jasmine.createSpy('firstUnsubscribe');
+    const secondUnsubscribe = jasmine.createSpy('secondUnsubscribe');
+    const callbacks: Array<() => void> = [];
+    const onNextRefresh = jasmine.createSpy('onNextRefresh').and.callFake((callback: () => void) => {
+      callbacks.push(callback);
+      return callbacks.length === 1 ? firstUnsubscribe : secondUnsubscribe;
+    });
+    const refresh = jasmine.createSpy('refresh');
+    const closeModal = jasmine.createSpy('closeModal');
+    const pending = new Promise<any[]>(() => undefined);
+    const readers = {
+      accounts: () => pending,
+      addresses: () => pending,
+      backendServices: () => pending,
+      certificates: () => pending,
+      healthChecks: () => pending,
+      networks: () => pending,
+      regions: () => pending,
+      subnets: () => pending,
+    };
+    const wrapper = mount(
+      <GceProxyLoadBalancerModal
+        application={{ loadBalancers: { onNextRefresh, refresh }, name: 'app' } as any}
+        closeModal={closeModal}
+        loadBalancerType="TCP"
+        readers={readers}
+      />,
+    );
+    const taskMonitor = wrapper.find(TaskMonitorWrapper).prop('monitor');
+
+    taskMonitor.config.onTaskComplete();
+
+    expect(onNextRefresh.calls.first().invocationOrder).toBeLessThan(refresh.calls.first().invocationOrder);
+
+    taskMonitor.config.onTaskComplete();
+
+    expect(firstUnsubscribe).toHaveBeenCalledTimes(1);
+
+    wrapper.unmount();
+    callbacks[1]();
+
+    expect(secondUnsubscribe).toHaveBeenCalledTimes(1);
+    expect(closeModal).not.toHaveBeenCalled();
+  });
+});
+
+function validCommand(mode: 'create' | 'edit' | 'pipeline'): any {
+  return normalizeGceProxyLoadBalancerCommand(
+    {
+      account: 'account-a',
+      backendService: { name: 'app-main', portName: 'tcp', sessionAffinity: 'NONE' },
+      healthChecks: [{ healthCheckType: 'TCP', name: 'check-a', port: 443 }],
+      loadBalancerName: 'app-main',
+      loadBalancerType: 'TCP',
+      portRange: '443',
+    },
+    mode,
+    'TCP',
+  );
+}

package/src/loadBalancer/configure/common/GceProxyLoadBalancerModal.tsx

@@ -0,0 +1,241 @@
+import React from 'react';
+
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import {
+  InfrastructureCaches,
+  LoadBalancerWriter,
+  ModalClose,
+  ReactModal,
+  Spinner,
+  SubmitButton,
+  TaskMonitor,
+  TaskMonitorWrapper,
+} from '@spinnaker/core';
+
+import {
+  applyGceProxyTypeConstraints,
+  GceProxyLoadBalancerEditor,
+  validateGceProxyLoadBalancerCommand,
+} from './GceProxyLoadBalancerEditor';
+import type { GceProxyLoadBalancerType } from './GceProxyLoadBalancerEditor';
+import type { IGceLoadBalancerDataReaders } from './gceLoadBalancerData';
+import type {
+  GceLoadBalancerEditorMode,
+  IGceLoadBalancerCommand,
+  IGceSerializedLoadBalancerCommand,
+} from './gceLoadBalancerModels';
+import { normalizeGceLoadBalancerCommand, serializeGceLoadBalancerCommand } from './gceLoadBalancerModels';
+import { useGceLoadBalancerData } from './useGceLoadBalancerData';
+
+type UnknownRecord = Record<string, any>;
+
+export interface IGceProxyLoadBalancerPayload extends IGceSerializedLoadBalancerCommand {
+  backendService: UnknownRecord;
+  backendServices?: undefined;
+  healthChecks?: undefined;
+  ports?: string[];
+}
+
+export interface IGceProxyLoadBalancerModalProps extends IModalComponentProps {
+  app?: Application;
+  application?: Application;
+  forPipelineConfig?: boolean;
+  isNew?: boolean;
+  loadBalancer?: UnknownRecord;
+  loadBalancerType?: GceProxyLoadBalancerType | string;
+  readers?: IGceLoadBalancerDataReaders;
+}
+
+interface IGceProxySubmissionDependencies {
+  application: Application;
+  closeModal?: (command: IGceProxyLoadBalancerPayload) => void;
+  taskMonitor: Pick<TaskMonitor, 'submit'>;
+}
+
+export function normalizeGceProxyLoadBalancerCommand(
+  persisted: UnknownRecord | undefined,
+  mode: GceLoadBalancerEditorMode,
+  loadBalancerType: GceProxyLoadBalancerType,
+  applicationName = '',
+): IGceLoadBalancerCommand {
+  const source = persisted || {};
+  const backendService = source.backendService || source.backendServices?.[0];
+  const nestedHealthCheck = backendService?.healthCheck;
+  const normalizedSource: UnknownRecord = {
+    ...source,
+    backendServices: backendService ? [{ ...backendService }] : source.backendServices,
+    healthChecks: source.healthChecks?.length ? source.healthChecks : nestedHealthCheck ? [nestedHealthCheck] : [],
+    loadBalancerType,
+    name: source.name || source.loadBalancerName || applicationName,
+  };
+
+  const normalized = normalizeGceLoadBalancerCommand(normalizedSource, mode);
+  if (normalized.backendServices[0]?.healthCheck) {
+    const { name, selfLink } = normalized.backendServices[0].healthCheck;
+    normalized.backendServices[0].healthCheck = selfLink ? { name, selfLink } : { name };
+  }
+  return applyGceProxyTypeConstraints(normalized);
+}
+
+export function serializeGceProxyLoadBalancerCommand(command: IGceLoadBalancerCommand): IGceProxyLoadBalancerPayload {
+  const constrained = applyGceProxyTypeConstraints(command);
+  const serialized = serializeGceLoadBalancerCommand(constrained) as IGceProxyLoadBalancerPayload;
+  const backendSource = constrained.backendServices[0] || ({ name: constrained.name } as UnknownRecord);
+  const backendService: UnknownRecord = { ...backendSource };
+  const healthCheck = constrained.healthChecks[0] || backendSource.healthCheck;
+
+  delete backendService.protocol;
+  backendService.protocol = undefined;
+  backendService.healthCheck = healthCheck ? { ...healthCheck } : undefined;
+  backendService.name = backendService.name || constrained.name;
+  serialized.backendService = backendService;
+  delete serialized.backendServices;
+  delete serialized.healthChecks;
+
+  if (constrained.loadBalancerType === 'INTERNAL') {
+    serialized.ipProtocol = constrained.listeners[0]?.protocol || 'TCP';
+    serialized.ports = splitPorts(constrained.listeners[0]?.portRange);
+    delete serialized.portRange;
+  } else {
+    serialized.ipProtocol = String(backendSource.protocol || 'TCP');
+  }
+
+  return serialized;
+}
+
+export function submitGceProxyLoadBalancerCommand(
+  command: IGceLoadBalancerCommand,
+  { application, closeModal, taskMonitor }: IGceProxySubmissionDependencies,
+): void {
+  const payload = serializeGceProxyLoadBalancerCommand(command);
+  if (command.mode === 'pipeline') {
+    closeModal?.(payload);
+    return;
+  }
+
+  const descriptor = command.mode === 'edit' ? 'Update' : 'Create';
+  taskMonitor.submit(() =>
+    LoadBalancerWriter.upsertLoadBalancer(payload as any, application, descriptor, { healthCheck: {} }),
+  );
+}
+
+function GceProxyLoadBalancerModalComponent(props: IGceProxyLoadBalancerModalProps): JSX.Element {
+  const application = (props.application || props.app) as Application;
+  const mode: GceLoadBalancerEditorMode = props.forPipelineConfig
+    ? 'pipeline'
+    : props.isNew === false
+    ? 'edit'
+    : 'create';
+  const type = resolveProxyType(props.loadBalancerType || props.loadBalancer?.loadBalancerType);
+  const [command, setCommand] = React.useState(() =>
+    normalizeGceProxyLoadBalancerCommand(props.loadBalancer, mode, type, application?.name),
+  );
+  const dataState = useGceLoadBalancerData(command.credentials, props.readers);
+  const applicationRefreshUnsubscribe = React.useRef<(() => void) | undefined>();
+  const isUnmounted = React.useRef(false);
+  const [taskMonitor] = React.useState(
+    () =>
+      new TaskMonitor({
+        application,
+        title: `${mode === 'edit' ? 'Updating' : 'Creating'} your load balancer`,
+        onDismiss: () => props.dismissModal?.(),
+        onTaskComplete: () => {
+          InfrastructureCaches.clearCache('healthChecks');
+          const loadBalancers = (application as any)?.loadBalancers || application?.getDataSource?.('loadBalancers');
+          const close = () => {
+            applicationRefreshUnsubscribe.current?.();
+            applicationRefreshUnsubscribe.current = undefined;
+            if (isUnmounted.current) {
+              return;
+            }
+            props.closeModal?.();
+          };
+          if (loadBalancers?.onNextRefresh) {
+            applicationRefreshUnsubscribe.current?.();
+            applicationRefreshUnsubscribe.current = undefined;
+            applicationRefreshUnsubscribe.current = loadBalancers.onNextRefresh(close);
+            loadBalancers.refresh?.();
+          } else {
+            close();
+          }
+        },
+      }),
+  );
+  React.useEffect(
+    () => () => {
+      isUnmounted.current = true;
+      applicationRefreshUnsubscribe.current?.();
+      applicationRefreshUnsubscribe.current = undefined;
+    },
+    [],
+  );
+  const errors = validateGceProxyLoadBalancerCommand(command);
+  const submitting = taskMonitor.submitting;
+  const heading =
+    mode === 'create'
+      ? `Create ${type} Load Balancer`
+      : mode === 'pipeline'
+      ? `Configure ${type} Load Balancer`
+      : `Edit ${command.name}`;
+  const submit = () =>
+    submitGceProxyLoadBalancerCommand(command, { application, closeModal: props.closeModal, taskMonitor });
+
+  return (
+    <div className="modal-content">
+      <TaskMonitorWrapper monitor={taskMonitor} />
+      <ModalClose dismiss={props.dismissModal} />
+      <div className="modal-header">
+        <h3>{heading}</h3>
+      </div>
+      <div className="modal-body">
+        {dataState.status === 'loading' && <Spinner size="large" />}
+        {dataState.status === 'error' && (
+          <div className="alert alert-danger">Unable to load GCE load balancer resources.</div>
+        )}
+        <GceProxyLoadBalancerEditor
+          command={command}
+          data={dataState.data}
+          disabled={mode === 'edit'}
+          onChange={setCommand}
+        />
+        {!!errors.length && (
+          <div className="alert alert-danger gce-proxy-validation-errors">
+            {errors.map((error) => (
+              <div key={error}>{error}</div>
+            ))}
+          </div>
+        )}
+      </div>
+      <div className="modal-footer">
+        <button className="btn btn-default" disabled={submitting} onClick={props.dismissModal} type="button">
+          Cancel
+        </button>
+        <SubmitButton
+          isDisabled={!!errors.length || dataState.status === 'loading' || submitting}
+          isFormSubmit={false}
+          label={mode === 'pipeline' ? 'Done' : mode === 'edit' ? 'Update' : 'Create'}
+          onClick={submit}
+          submitting={submitting}
+        />
+      </div>
+    </div>
+  );
+}
+
+export const GceProxyLoadBalancerModal = Object.assign(GceProxyLoadBalancerModalComponent, {
+  show: (props: IGceProxyLoadBalancerModalProps) =>
+    ReactModal.show(GceProxyLoadBalancerModalComponent, props, { dialogClassName: 'modal-lg' }),
+  supportsPipelineConfig: true,
+});
+
+function resolveProxyType(value: unknown): GceProxyLoadBalancerType {
+  const type = String(value || '').toUpperCase();
+  return type === 'INTERNAL' || type === 'SSL' || type === 'TCP' ? type : 'TCP';
+}
+
+function splitPorts(value: string | undefined): string[] {
+  return String(value || '')
+    .split(',')
+    .map((port) => port.trim())
+    .filter(Boolean);
+}

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

@@ -0,0 +1,117 @@
+import {
+  GceLoadBalancerDataController,
+  IGceLoadBalancerDataReaders,
+  mergeGceResourceOptions,
+} from './gceLoadBalancerData';
+
+describe('GCE load balancer data', () => {
+  it('loads every editor data source and scopes regions to the selected account', async () => {
+    const readers = testReaders();
+    const controller = new GceLoadBalancerDataController(readers);
+
+    await controller.load('test-account');
+
+    expect(readers.accounts).toHaveBeenCalledWith();
+    expect(readers.regions).toHaveBeenCalledWith('test-account');
+    expect(readers.networks).toHaveBeenCalledWith();
+    expect(readers.subnets).toHaveBeenCalledWith();
+    expect(readers.certificates).toHaveBeenCalledWith();
+    expect(readers.addresses).toHaveBeenCalledWith();
+    expect(readers.healthChecks).toHaveBeenCalledWith();
+    expect(readers.backendServices).toHaveBeenCalledWith();
+    expect(controller.getState()).toEqual({
+      data: {
+        accounts: [{ name: 'test-account' }],
+        addresses: [{ name: 'address' }],
+        backendServices: [{ name: 'backend' }],
+        certificates: [{ name: 'certificate' }],
+        healthChecks: [{ name: 'check' }],
+        networks: [{ name: 'network' }],
+        regions: [{ name: 'europe-west1' }],
+        subnets: [{ name: 'subnet' }],
+      },
+      error: undefined,
+      status: 'ready',
+    });
+  });
+
+  it('publishes only the latest request', async () => {
+    const first = deferred<unknown[]>();
+    const second = deferred<unknown[]>();
+    const readers = testReaders();
+    readers.regions.and.callFake((account: string) => (account === 'first' ? first.promise : second.promise));
+    const controller = new GceLoadBalancerDataController(readers);
+
+    const firstLoad = controller.load('first');
+    const secondLoad = controller.load('second');
+    second.resolve([{ name: 'second-region' }]);
+    await secondLoad;
+    first.resolve([{ name: 'stale-region' }]);
+    await firstLoad;
+
+    expect(controller.getState().data.regions).toEqual([{ name: 'second-region' }]);
+    expect(controller.getState().status).toBe('ready');
+  });
+
+  it('reports an error from the latest request', async () => {
+    const readers = testReaders();
+    const failure = new Error('regions failed');
+    readers.regions.and.returnValue(Promise.reject(failure));
+    const controller = new GceLoadBalancerDataController(readers);
+
+    await controller.load('test-account');
+
+    expect(controller.getState().status).toBe('error');
+    expect(controller.getState().error).toBe(failure);
+  });
+
+  it('does not publish responses after disposal', async () => {
+    const pendingRegions = deferred<unknown[]>();
+    const readers = testReaders();
+    readers.regions.and.returnValue(pendingRegions.promise);
+    const controller = new GceLoadBalancerDataController(readers);
+    const listener = jasmine.createSpy('listener');
+    controller.subscribe(listener);
+
+    const loading = controller.load('test-account');
+    listener.calls.reset();
+    controller.dispose();
+    pendingRegions.resolve([{ name: 'late-region' }]);
+    await loading;
+
+    expect(listener).not.toHaveBeenCalled();
+    expect(controller.getState().status).toBe('loading');
+  });
+
+  it('keeps persisted references that are missing from fresh reader data', () => {
+    const available = [{ name: 'available' }];
+    const persisted = [
+      { name: 'available', selfLink: 'available-link' },
+      { name: 'removed', selfLink: 'removed-link', staleMetadata: true },
+    ];
+
+    expect(mergeGceResourceOptions(available, persisted)).toEqual([
+      { name: 'available' },
+      { name: 'removed', selfLink: 'removed-link', staleMetadata: true },
+    ]);
+  });
+});
+
+function testReaders(): jasmine.SpyObj<IGceLoadBalancerDataReaders> {
+  return jasmine.createSpyObj<IGceLoadBalancerDataReaders>('readers', {
+    accounts: Promise.resolve([{ name: 'test-account' }]),
+    addresses: Promise.resolve([{ name: 'address' }]),
+    backendServices: Promise.resolve([{ name: 'backend' }]),
+    certificates: Promise.resolve([{ name: 'certificate' }]),
+    healthChecks: Promise.resolve([{ name: 'check' }]),
+    networks: Promise.resolve([{ name: 'network' }]),
+    regions: Promise.resolve([{ name: 'europe-west1' }]),
+    subnets: Promise.resolve([{ name: 'subnet' }]),
+  });
+}
+
+function deferred<T>() {
+  let resolve: (value: T) => void;
+  const promise = new Promise<T>((resolver) => (resolve = resolver));
+  return { promise, resolve: resolve! };
+}