@spinnaker/google 2026.3.1 → 2026.4.0

package/dist/loadBalancer/configure/common/gceLoadBalancerModels.d.ts

@@ -1,4 +1,4 @@
-export declare const GCE_LOAD_BALANCER_TYPES: readonly ["NETWORK", "INTERNAL", "TCP", "SSL", "HTTP", "INTERNAL_MANAGED"];
+export declare const GCE_LOAD_BALANCER_TYPES: readonly ["NETWORK", "INTERNAL", "TCP", "SSL", "HTTP", "INTERNAL_MANAGED", "EXTERNAL_MANAGED", "REGIONAL_EXTERNAL_NETWORK"];
 export type GceLoadBalancerType = typeof GCE_LOAD_BALANCER_TYPES[number];
 export type GceLoadBalancerEditorMode = 'create' | 'edit' | 'pipeline';
 export type GceLoadBalancerProtocol = 'TCP' | 'UDP' | 'HTTP' | 'HTTPS' | 'HTTP2' | 'GRPC' | 'SSL';
@@ -24,6 +24,7 @@ export interface IGceLoadBalancerListener {
     address?: IGceResourceReference;
     certificate?: IGceResourceReference;
     certificateMap?: string;
+    networkTier?: string;
     subnet?: IGceResourceReference;
 }
 export interface IGceLoadBalancerHealthCheck {
@@ -33,7 +34,7 @@ export interface IGceLoadBalancerHealthCheck {
     healthyThreshold?: number;
     host?: string;
     name?: string;
-    port?: number;
+    port?: number | string;
     proxyHeader?: string;
     requestPath?: string;
     timeoutSec?: number;
@@ -42,8 +43,15 @@ export interface IGceLoadBalancerHealthCheck {
     [key: string]: unknown;
 }
 export interface IGceLoadBalancerBackendService {
+    affinityCookieTtlSec?: number;
+    backends?: unknown[];
+    connectionDrainingTimeoutSec?: number;
+    enableCDN?: boolean;
     name: string;
     healthCheck?: IGceResourceReference;
+    portName?: string;
+    protocol?: GceLoadBalancerProtocol;
+    sessionAffinity?: string;
     [key: string]: unknown;
 }
 export interface IGceLoadBalancerPathRule {
@@ -76,6 +84,7 @@ interface IGceLoadBalancerCommandBase {
     defaultService?: IGceResourceReference;
     network?: IGceResourceReference;
     original?: IGceLoadBalancerOriginalState;
+    networkTier?: string;
     subnet?: IGceResourceReference;
 }
 export interface IGceCreateLoadBalancerCommand extends IGceLoadBalancerCommandBase {
@@ -103,4 +112,6 @@ type UnknownRecord = Record<string, unknown>;
 export declare function normalizeGceLoadBalancerCommand(persisted: UnknownRecord, mode: GceLoadBalancerEditorMode): IGceLoadBalancerCommand;
 export declare function serializeGceLoadBalancerCommand(command: IGceLoadBalancerCommand): IGceSerializedLoadBalancerCommand;
 export declare function normalizeGceHealthCheck(value: unknown): IGceLoadBalancerHealthCheck;
+export declare function serializeGceBackendService(service: IGceLoadBalancerBackendService): UnknownRecord;
+export declare function serializeGceHealthCheck(healthCheck: IGceLoadBalancerHealthCheck): UnknownRecord;
 export {};

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerEditor.d.ts

@@ -8,8 +8,11 @@ export interface IGceHttpLoadBalancerEditorProps {
 }
 interface IGceHttpLoadBalancerDataItem extends IGceLoadBalancerDataItem {
     account?: string;
+    address?: string;
+    addressType?: string;
     id?: string;
     network?: string;
+    purpose?: string;
     region?: string;
 }
 export declare function FormRow({ children, label }: {

package/dist/loadBalancer/configure/http/GceHttpLoadBalancerModal.d.ts

@@ -12,7 +12,7 @@ export interface IGceHttpLoadBalancerModalProps extends IModalComponentProps {
     forPipelineConfig?: boolean;
     isNew?: boolean;
     loadBalancer?: Record<string, unknown>;
-    loadBalancerType?: Extract<GceLoadBalancerType, 'HTTP' | 'INTERNAL_MANAGED'>;
+    loadBalancerType?: Extract<GceLoadBalancerType, 'HTTP' | 'INTERNAL_MANAGED' | 'EXTERNAL_MANAGED'>;
     mode?: GceLoadBalancerEditorMode;
 }
 interface IGceHttpLoadBalancerModalState extends IGceLoadBalancerDataState {

package/dist/loadBalancer/configure/network/GceRegionalExternalNetworkLoadBalancerEditor.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import type { IGceLoadBalancerCommand, IGceLoadBalancerData, IGceLoadBalancerDataItem, IGceLoadBalancerHealthCheck } from '../common';
+export type GceRegionalExternalNetworkSessionAffinity = 'NONE' | 'CLIENT_IP' | 'CLIENT_IP_PROTO' | 'CLIENT_IP_PORT_PROTO';
+export type IGceRegionalExternalNetworkLoadBalancerCommand = IGceLoadBalancerCommand & {
+    loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK';
+    ports: string[];
+};
+interface IGceRegionalExternalNetworkDataItem extends IGceLoadBalancerDataItem {
+    account?: string;
+    address?: string;
+    addressType?: string;
+    credentials?: string;
+    networkTier?: string;
+    region?: string;
+}
+export interface IGceRegionalExternalNetworkLoadBalancerOptions {
+    accounts: IGceRegionalExternalNetworkDataItem[];
+    addresses: IGceRegionalExternalNetworkDataItem[];
+    regions: IGceRegionalExternalNetworkDataItem[];
+}
+export interface IGceRegionalExternalNetworkLoadBalancerEditorProps {
+    command: IGceRegionalExternalNetworkLoadBalancerCommand;
+    data: IGceLoadBalancerData;
+    onChange: (command: IGceRegionalExternalNetworkLoadBalancerCommand) => void;
+}
+export declare function createGceRegionalExternalNetworkHealthCheck(name: string): IGceLoadBalancerHealthCheck;
+export declare function buildGceRegionalExternalNetworkLoadBalancerOptions(command: IGceRegionalExternalNetworkLoadBalancerCommand, data: IGceLoadBalancerData): IGceRegionalExternalNetworkLoadBalancerOptions;
+export declare function validateGceRegionalExternalNetworkLoadBalancerCommand(command: IGceRegionalExternalNetworkLoadBalancerCommand): string[];
+export declare function GceRegionalExternalNetworkLoadBalancerEditor({ command, data, onChange, }: IGceRegionalExternalNetworkLoadBalancerEditorProps): JSX.Element;
+export {};

package/dist/loadBalancer/configure/network/GceRegionalExternalNetworkLoadBalancerModal.d.ts

@@ -0,0 +1,53 @@
+import React from 'react';
+import type { Application, IModalComponentProps, ITask, ITaskCommand } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IGceRegionalExternalNetworkLoadBalancerCommand } from './GceRegionalExternalNetworkLoadBalancerEditor';
+import type { GceLoadBalancerEditorMode, IGceLoadBalancerData, IGceLoadBalancerDataReaders, IGceLoadBalancerDataState, IGceSerializedLoadBalancerCommand } from '../common';
+type UnknownRecord = Record<string, any>;
+export interface IGceRegionalExternalNetworkLoadBalancerPayload extends IGceSerializedLoadBalancerCommand {
+    backendService: UnknownRecord;
+    ipAddress?: string;
+    ipProtocol: string;
+    networkTier?: string;
+    ports: string[];
+}
+export interface IGceRegionalExternalNetworkLoadBalancerModalProps 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 IGceRegionalExternalNetworkLoadBalancerModalState extends IGceLoadBalancerDataState {
+    command: IGceRegionalExternalNetworkLoadBalancerCommand;
+    taskMonitor: TaskMonitor;
+}
+interface IGceRegionalExternalNetworkSubmissionDependencies {
+    application: Application;
+    executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+}
+export declare function normalizeGceRegionalExternalNetworkLoadBalancerCommand(persisted: UnknownRecord | null | undefined, mode: GceLoadBalancerEditorMode, applicationName?: string, defaults?: Partial<Record<'credentials' | 'region', unknown>>): IGceRegionalExternalNetworkLoadBalancerCommand;
+export declare function serializeGceRegionalExternalNetworkLoadBalancerCommand(command: IGceRegionalExternalNetworkLoadBalancerCommand): IGceRegionalExternalNetworkLoadBalancerPayload;
+export declare function submitGceRegionalExternalNetworkLoadBalancerCommand(command: IGceRegionalExternalNetworkLoadBalancerCommand, { application, executeTask }: IGceRegionalExternalNetworkSubmissionDependencies): IGceRegionalExternalNetworkLoadBalancerPayload | Promise<ITask>;
+declare class GceRegionalExternalNetworkLoadBalancerModalComponent extends React.Component<IGceRegionalExternalNetworkLoadBalancerModalProps, IGceRegionalExternalNetworkLoadBalancerModalState> {
+    private dataController?;
+    private unsubscribe?;
+    constructor(props: IGceRegionalExternalNetworkLoadBalancerModalProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+    private application;
+    private mode;
+    private updateCommand;
+    private submit;
+}
+export declare const GceRegionalExternalNetworkLoadBalancerModal: typeof GceRegionalExternalNetworkLoadBalancerModalComponent & {
+    show: (props: IGceRegionalExternalNetworkLoadBalancerModalProps) => Promise<any>;
+    supportsPipelineConfig: boolean;
+};
+export {};

package/dist/loadBalancer/httpLoadBalancerUtils.service.d.ts

@@ -1,6 +1,8 @@
 import type { IGceHttpLoadBalancer, IGceLoadBalancer } from '../domain/loadBalancer';
 export declare class GceHttpLoadBalancerUtils {
     static REGION: string;
+    static HTTP_LOAD_BALANCER_TYPES: string[];
     isHttpLoadBalancer(lb: IGceLoadBalancer): lb is IGceHttpLoadBalancer;
-    normalizeLoadBalancerNamesForAccount(loadBalancerNames: string[], account: string, loadBalancers: IGceLoadBalancer[]): string[];
+    isRegionalHttpLoadBalancer(lb: IGceLoadBalancer): lb is IGceHttpLoadBalancer;
+    normalizeLoadBalancerNamesForAccount(loadBalancerNames: string[], account: string, loadBalancers: IGceLoadBalancer[], region?: string): string[];
 }

package/dist/serverGroup/configure/wizard/GceCloneServerGroupModal.d.ts

@@ -31,6 +31,7 @@ export declare class GceCloneServerGroupModalComponent extends React.Component<I
     static show(props: IGceCloneServerGroupModalProps, runtimeServices: DeckRuntimeServices): Promise<any>;
     constructor(props: IGceCloneServerGroupModalProps & IRouterInjectedProps, context: React.ContextType<typeof DeckRuntimeContext>);
     componentDidMount(): void;
+    componentDidUpdate(previousProps: IGceCloneServerGroupModalProps & IRouterInjectedProps): void;
     componentWillUnmount(): void;
     private configureCommand;
     private retryConfiguration;
@@ -46,4 +47,6 @@ export declare const GceCloneServerGroupModal: React.ForwardRefExoticComponent<O
 } & React.RefAttributes<any>> & {
     show: typeof GceCloneServerGroupModalComponent.show;
 };
+export declare function reconcileGceServerGroupCommand(persistedCommand: IGceServerGroupCommand, configuredCommand: IGceServerGroupCommand): IGceServerGroupCommand;
+export declare function initializePipelineCreateCommand(baseCommand: IGceServerGroupCommand, placeholder: IGceServerGroupCommand): IGceServerGroupCommand;
 export {};

package/dist/serverGroup/configure/wizard/GceServerGroupWizard.types.d.ts

@@ -107,6 +107,7 @@ export interface IGceServerGroupCommandValidationErrors {
     };
     freeFormDetails?: string;
     image?: string;
+    loadBalancers?: string;
     region?: string;
     stack?: string;
     zone?: string;

package/dist/serverGroup/configure/wizard/customInstance/CustomInstanceConfigurer.d.ts

@@ -17,7 +17,7 @@ export interface ICustomInstanceConfigurerProps {
     onChange: (config: ICustomInstanceConfig) => void;
 }
 export declare class CustomInstanceConfigurer extends React.Component<ICustomInstanceConfigurerProps> {
-    render(): JSX.Element;
+    render(): React.JSX.Element;
     private handleVCpuChange;
     private handleMemoryChange;
     private handleInstanceFamilyChange;

package/dist/serverGroup/configure/wizard/customInstance/GceCustomInstanceBuilder.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="react" />
+import React from 'react';
 import type { ICustomInstanceBuilderProps } from '@spinnaker/core';
-export declare function GceCustomInstanceBuilder({ command, onTypeChanged }: ICustomInstanceBuilderProps): JSX.Element;
+export declare function GceCustomInstanceBuilder({ command, onTypeChanged }: ICustomInstanceBuilderProps): React.JSX.Element;

package/dist/serverGroup/configure/wizard/pages/AdvancedSettings.d.ts

@@ -18,3 +18,6 @@ export declare class AdvancedSettings extends GceServerGroupWizardPage {
     private booleanRadios;
     render(): JSX.Element;
 }
+export declare function validateGceAdvancedSettings(values: IGceServerGroupCommand): {
+    [key: string]: string;
+};

package/dist/serverGroup/configure/wizard/pages/GceServerGroupLoadBalancers.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import type { IGceServerGroupCommand, IGceServerGroupCommandValidationErrors, IGceServerGroupWizardPageProps } from '../GceServerGroupWizard.types';
 import { GceServerGroupWizardPage } from '../GceServerGroupWizardPage';
+export declare function validateGceServerGroupLoadBalancers(values: IGceServerGroupCommand): IGceServerGroupCommandValidationErrors;
 export declare class GceServerGroupLoadBalancers extends GceServerGroupWizardPage<IGceServerGroupWizardPageProps> {
     validate(values: IGceServerGroupCommand): IGceServerGroupCommandValidationErrors;
     render(): React.ReactElement;

package/dist/serverGroup/configure/wizard/pages/Policies.d.ts

@@ -1,10 +1,26 @@
 /// <reference types="react" />
 import type { IGceServerGroupCommand } from '../GceServerGroupWizard.types';
 import { GceServerGroupWizardPage } from '../GceServerGroupWizardPage';
+interface IAutoscalingPolicyValidationErrors {
+    coolDownPeriodSec?: string;
+    maxNumReplicas?: string;
+    metric?: string;
+    minNumReplicas?: string;
+    predictiveAutoscaling?: string;
+    scaleInControl?: string;
+    scalingSchedules?: string;
+}
+interface IAutoHealingPolicyValidationErrors {
+    healthCheck?: string;
+    healthCheckKind?: string;
+    initialDelaySec?: string;
+}
+interface IPoliciesValidationErrors {
+    autoHealingPolicy?: IAutoHealingPolicyValidationErrors;
+    autoscalingPolicy?: IAutoscalingPolicyValidationErrors;
+}
 export declare class Policies extends GceServerGroupWizardPage {
-    validate(values: IGceServerGroupCommand): {
-        [key: string]: any;
-    };
+    validate(values: IGceServerGroupCommand): IPoliciesValidationErrors;
     private setField;
     private toggleAutoscaling;
     private setAutoscalingPolicy;
@@ -12,3 +28,5 @@ export declare class Policies extends GceServerGroupWizardPage {
     private filteredHealthCheckReader;
     render(): JSX.Element;
 }
+export declare function validateGceServerGroupPolicies(values: IGceServerGroupCommand): IPoliciesValidationErrors;
+export {};

package/dist/serverGroup/configure/wizard/pages/ServerGroupBasicSettings.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import type { IGceServerGroupCommand, IGceServerGroupCommandValidationErrors } from '../GceServerGroupWizard.types';
 import { GceServerGroupWizardPage } from '../GceServerGroupWizardPage';
+export declare function validateGceServerGroupBasicSettings(values: IGceServerGroupCommand): IGceServerGroupCommandValidationErrors;
 export declare class ServerGroupBasicSettings extends GceServerGroupWizardPage {
     validate(values: IGceServerGroupCommand): IGceServerGroupCommandValidationErrors;
     private parentChanged;

package/dist/serverGroup/configure/wizard/pages/ServerGroupCapacity.d.ts

@@ -16,6 +16,7 @@ interface ICapacityValidationErrors {
     instanceFlexibilityPolicy?: string;
     zone?: string;
 }
+export declare function validateGceServerGroupCapacity(values: IGceServerGroupCommand): ICapacityValidationErrors;
 export declare class ServerGroupCapacity extends GceServerGroupWizardPage {
     validate(values: IGceServerGroupCommand): ICapacityValidationErrors;
     private commandChanged;

package/dist/serverGroup/configure/wizard/pages/ServerGroupImageSettings.d.ts

@@ -9,3 +9,4 @@ export declare class ServerGroupImageSettings extends GceServerGroupWizardPage {
     private renderImageSelect;
     render(): JSX.Element;
 }
+export declare function validateGceServerGroupImageSettings(values: IGceServerGroupCommand): IGceServerGroupCommandValidationErrors;

package/dist/serverGroup/configure/wizard/pages/ServerGroupInstanceType.d.ts

@@ -7,6 +7,7 @@ interface IGceInstanceTypeValidationErrors {
     disks?: string;
     instanceType?: string;
 }
+export declare function validateGceServerGroupInstanceType(values: IGceServerGroupCommand): IGceInstanceTypeValidationErrors;
 export declare class ServerGroupInstanceType extends GceServerGroupWizardPage {
     static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
     context: React.ContextType<typeof DeckRuntimeContext>;

package/dist/serverGroup/configure/wizard/zones/GceInstanceFlexibilityConfigurer.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import type { IGceInstanceFlexibilityPolicy } from '../../../../domain/serverGroup';
 export interface IGceInstanceFlexibilityConfigurerProps {
     instanceFlexibilityPolicy?: IGceInstanceFlexibilityPolicy;
@@ -9,7 +9,7 @@ export interface IGceInstanceFlexibilityConfigurerProps {
 }
 /** First unused selection-N name so rename/remove cannot overwrite an existing entry. */
 export declare function nextSelectionName(existingNames: string[]): string;
-export declare function GceInstanceFlexibilityConfigurer({ instanceFlexibilityPolicy, regional, targetShape: targetShapeProp, validationError, setInstanceFlexibilityPolicy, }: IGceInstanceFlexibilityConfigurerProps): JSX.Element;
+export declare function GceInstanceFlexibilityConfigurer({ instanceFlexibilityPolicy, regional, targetShape: targetShapeProp, validationError, setInstanceFlexibilityPolicy, }: IGceInstanceFlexibilityConfigurerProps): React.JSX.Element;
 export declare function hasValidFlexibilityPolicy(command: {
     regional?: boolean;
     distributionPolicy?: {

package/dist/serverGroup/details/GceInstanceFlexibilityPolicyDetails.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="react" />
+import React from 'react';
 import type { IGceInstanceFlexibilityPolicy } from '../../domain/serverGroup';
 export interface IGceInstanceFlexibilityPolicyDetailsProps {
     instanceFlexibilityPolicy?: IGceInstanceFlexibilityPolicy;
 }
-export declare function GceInstanceFlexibilityPolicyDetails({ instanceFlexibilityPolicy, }: IGceInstanceFlexibilityPolicyDetailsProps): JSX.Element;
+export declare function GceInstanceFlexibilityPolicyDetails({ instanceFlexibilityPolicy, }: IGceInstanceFlexibilityPolicyDetailsProps): React.JSX.Element;

package/dist/serverGroup/details/stateful/MarkDiskStatefulButton.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import type { Application } from '@spinnaker/core';
 import type { IGceServerGroup } from '../../../domain';
 interface IMarkDiskStatefulButtonProps {
@@ -6,5 +6,5 @@ interface IMarkDiskStatefulButtonProps {
     deviceName: string;
     serverGroup: IGceServerGroup;
 }
-export declare function MarkDiskStatefulButton({ application, deviceName, serverGroup }: IMarkDiskStatefulButtonProps): JSX.Element;
+export declare function MarkDiskStatefulButton({ application, deviceName, serverGroup }: IMarkDiskStatefulButtonProps): React.JSX.Element;
 export {};

package/dist/serverGroup/details/stateful/UpdateBootImageButton.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import type { Application } from '@spinnaker/core';
 import type { IGceServerGroup } from '../../../domain';
 interface IUpdateBootImageButtonProps {
@@ -6,5 +6,5 @@ interface IUpdateBootImageButtonProps {
     bootImage: string;
     serverGroup: IGceServerGroup;
 }
-export declare function UpdateBootImageButton(props: IUpdateBootImageButtonProps): JSX.Element;
+export declare function UpdateBootImageButton(props: IUpdateBootImageButtonProps): React.JSX.Element;
 export {};

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/spinnaker/spinnaker.git"
   },
   "license": "Apache-2.0",
-  "version": "2026.3.1",
+  "version": "2026.4.0",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "publishConfig": {
@@ -23,18 +23,18 @@
   "dependencies": {
     "@spinnaker/core": "^0.29.1",
     "lodash": "4.18.1",
-    "react": "16.14.0",
+    "react": "17.0.2",
     "react-select": "1.2.1",
-    "rxjs": "6.6.7"
+    "rxjs": "7.8.2"
   },
   "devDependencies": {
     "@spinnaker/eslint-plugin": "^3.0.2",
     "@spinnaker/scripts": "^0.4.0",
     "@types/lodash": "4.14.64",
-    "@types/react": "16.14.10",
+    "@types/react": "17.0.93",
     "@types/react-select": "1.3.4",
     "shx": "0.3.3",
     "typescript": "5.0.4"
   },
-  "gitHead": "edb1aa9de446184eadee134ea51110609278929f"
+  "gitHead": "8d2819815061bd8ddc714287d229fce3d3d0a16b"
 }

package/src/autoHealingPolicy/GceAutoHealingPolicyEditor.spec.tsx

@@ -1,18 +1,13 @@
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
 import React from 'react';
-import { shallow } from 'enzyme';
 
-import { IGceHealthCheckKind } from '../domain';
 import { GceAutoHealingPolicyEditor } from './GceAutoHealingPolicyEditor';
+import { IGceHealthCheckKind } from '../domain';
 
 describe('GceAutoHealingPolicyEditor', () => {
-  async function flush(): Promise<void> {
-    await Promise.resolve();
-    await Promise.resolve();
-  }
-
   it('loads only health checks from the selected account', async () => {
     const reader = {
-      listHealthChecks: jasmine.createSpy('listHealthChecks').and.returnValue(
+      listHealthChecks: vi.fn().mockReturnValue(
         Promise.resolve([
           {
             account: 'my-account',
@@ -29,26 +24,40 @@ describe('GceAutoHealingPolicyEditor', () => {
         ]),
       ),
     };
-    const wrapper = shallow(
+    render(
       <GceAutoHealingPolicyEditor account="my-account" policy={{}} onChange={() => undefined} reader={reader as any} />,
     );
 
-    await flush();
-    wrapper.update();
-
-    expect(wrapper.find('[data-testid="health-check"] option').length).toBe(2);
-    expect(wrapper.find('[data-testid="health-check"]').text()).toContain('web');
-    expect(wrapper.find('[data-testid="health-check"]').text()).not.toContain('other');
+    const select = await screen.findByTestId('health-check');
+    await waitFor(() => expect(reader.listHealthChecks).toHaveBeenCalled());
+    expect(within(select).getAllByRole('option')).toHaveLength(2);
+    expect(select).toHaveTextContent('web');
+    expect(select).not.toHaveTextContent('other');
   });
 
-  it('writes the selected health check name and kind from its URL', () => {
-    const onChange = jasmine.createSpy('onChange');
-    const wrapper = shallow(
-      <GceAutoHealingPolicyEditor account="my-account" policy={{ initialDelaySec: 0 }} onChange={onChange} />,
-      { disableLifecycleMethods: true },
+  it('writes the selected health check name and kind from its URL', async () => {
+    const onChange = vi.fn();
+    const reader = {
+      listHealthChecks: vi.fn().mockResolvedValue([
+        {
+          account: 'my-account',
+          kind: IGceHealthCheckKind.httpHealthCheck,
+          name: 'web',
+          selfLink: 'https://compute/httpHealthChecks/web',
+        },
+      ]),
+    };
+    render(
+      <GceAutoHealingPolicyEditor
+        account="my-account"
+        policy={{ initialDelaySec: 0 }}
+        onChange={onChange}
+        reader={reader as any}
+      />,
     );
 
-    wrapper.find('[data-testid="health-check"]').simulate('change', {
+    await waitFor(() => expect(screen.getByTestId('health-check')).toBeEnabled());
+    fireEvent.change(screen.getByTestId('health-check'), {
       target: { value: 'https://compute/httpHealthChecks/web' },
     });
 
@@ -61,11 +70,11 @@ describe('GceAutoHealingPolicyEditor', () => {
   });
 
   it('normalizes an existing healthCheck URL into its URL, name, and kind fields', async () => {
-    const onChange = jasmine.createSpy('onChange');
+    const onChange = vi.fn();
     const reader = {
-      listHealthChecks: jasmine.createSpy('listHealthChecks').and.returnValue(Promise.resolve([])),
+      listHealthChecks: vi.fn().mockReturnValue(Promise.resolve([])),
     };
-    shallow(
+    render(
       <GceAutoHealingPolicyEditor
         account="my-account"
         policy={{ healthCheck: 'https://compute/httpHealthChecks/web', initialDelaySec: 0 }}
@@ -74,20 +83,20 @@ describe('GceAutoHealingPolicyEditor', () => {
       />,
     );
 
-    await flush();
-
-    expect(onChange).toHaveBeenCalledWith({
-      healthCheckUrl: 'https://compute/httpHealthChecks/web',
-      healthCheck: 'web',
-      healthCheckKind: IGceHealthCheckKind.httpHealthCheck,
-      initialDelaySec: 0,
-    });
+    await waitFor(() =>
+      expect(onChange).toHaveBeenCalledWith({
+        healthCheckUrl: 'https://compute/httpHealthChecks/web',
+        healthCheck: 'web',
+        healthCheckKind: IGceHealthCheckKind.httpHealthCheck,
+        initialDelaySec: 0,
+      }),
+    );
   });
 
   it('resolves an existing healthCheck name to the matching URL and kind', async () => {
-    const onChange = jasmine.createSpy('onChange');
+    const onChange = vi.fn();
     const reader = {
-      listHealthChecks: jasmine.createSpy('listHealthChecks').and.returnValue(
+      listHealthChecks: vi.fn().mockReturnValue(
         Promise.resolve([
           {
             account: 'my-account',
@@ -98,7 +107,7 @@ describe('GceAutoHealingPolicyEditor', () => {
         ]),
       ),
     };
-    shallow(
+    render(
       <GceAutoHealingPolicyEditor
         account="my-account"
         policy={{ healthCheck: 'web', initialDelaySec: 0 }}
@@ -107,27 +116,34 @@ describe('GceAutoHealingPolicyEditor', () => {
       />,
     );
 
-    await flush();
-
-    expect(onChange).toHaveBeenCalledWith({
-      healthCheckUrl: 'https://compute/healthChecks/web',
-      healthCheck: 'web',
-      healthCheckKind: IGceHealthCheckKind.healthCheck,
-      initialDelaySec: 0,
-    });
+    await waitFor(() =>
+      expect(onChange).toHaveBeenCalledWith({
+        healthCheckUrl: 'https://compute/healthChecks/web',
+        healthCheck: 'web',
+        healthCheckKind: IGceHealthCheckKind.healthCheck,
+        initialDelaySec: 0,
+      }),
+    );
   });
 
-  it('preserves zero for initial delay without rendering legacy max unavailable controls', () => {
-    const onChange = jasmine.createSpy('onChange');
+  it('preserves zero for initial delay without rendering legacy max unavailable controls', async () => {
+    const onChange = vi.fn();
+    const reader = { listHealthChecks: vi.fn().mockResolvedValue([]) };
     const legacyPolicy = { initialDelaySec: 0, maxUnavailable: { percent: 0 } };
-    const wrapper = shallow(
-      <GceAutoHealingPolicyEditor account="my-account" policy={legacyPolicy as any} onChange={onChange} />,
-      { disableLifecycleMethods: true },
+    const { container } = render(
+      <GceAutoHealingPolicyEditor
+        account="my-account"
+        policy={legacyPolicy as any}
+        onChange={onChange}
+        reader={reader as any}
+      />,
     );
 
-    expect(wrapper.find('[data-testid="initial-delay"]').prop('value')).toBe(0);
-    expect(wrapper.find('[data-testid="max-unavailable"]').exists()).toBe(false);
-    expect(wrapper.find('[data-testid="max-unavailable-unit"]').exists()).toBe(false);
-    expect(wrapper.text()).not.toContain('Max unavailable');
+    await waitFor(() => expect(screen.getByTestId('health-check')).toBeEnabled());
+    expect(reader.listHealthChecks).toHaveBeenCalled();
+    expect(screen.getByTestId('initial-delay')).toHaveValue(0);
+    expect(screen.queryByTestId('max-unavailable')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('max-unavailable-unit')).not.toBeInTheDocument();
+    expect(container).not.toHaveTextContent('Max unavailable');
   });
 });