@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/configure/wizard/pages/Policies.spec.tsx

@@ -0,0 +1,317 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import type { IGceServerGroupCommand } from '../GceServerGroupWizard.types';
+import { Policies } from './Policies';
+import { GceAutoHealingPolicyEditor } from '../../../../autoHealingPolicy';
+import { GceAutoscalingPolicyEditor } from '../../../../autoscalingPolicy';
+
+describe('GCE server group Policies page', () => {
+  it('reuses the policy editors and supplies autohealing health checks from filtered backing data', async () => {
+    const values = command({
+      enableAutoScaling: true,
+      enableAutoHealing: true,
+      autoscalingPolicy: { minNumReplicas: 1, maxNumReplicas: 4, unknownPolicyField: 'keep' },
+      autoHealingPolicy: { healthCheck: 'check', initialDelaySec: 300, unknownPolicyField: 'keep' },
+      backingData: {
+        healthChecks: [{ account: 'wrong', name: 'unfiltered' }],
+        filtered: {
+          healthChecks: [
+            {
+              displayName: 'check',
+              kind: 'healthCheck',
+              name: 'check',
+              selfLink: 'https://compute/healthChecks/check',
+            },
+          ],
+        },
+      },
+    });
+    const wrapper = shallow(<Policies app={{} as any} formik={formik(values)} />);
+
+    expect(wrapper.find(GceAutoscalingPolicyEditor).prop('policy')).toBe(values.autoscalingPolicy);
+    expect(wrapper.find(GceAutoHealingPolicyEditor).prop('policy')).toBe(values.autoHealingPolicy);
+
+    const reader = wrapper.find(GceAutoHealingPolicyEditor).prop('reader') as any;
+    expect(await reader.listHealthChecks()).toEqual([
+      jasmine.objectContaining({ account: 'account', name: 'check', selfLink: 'https://compute/healthChecks/check' }),
+    ]);
+  });
+
+  it('round trips autoscaling through fixed capacity using the canonical policy and supported source contract', () => {
+    const persistedPolicy = { minNumReplicas: 1, maxNumReplicas: 4, unknownPolicyField: 'keep' };
+    const persisted = command({
+      enableAutoScaling: true,
+      autoscalingPolicy: persistedPolicy,
+      capacity: { min: 1, max: 4, desired: 2 },
+      source: { region: 'us-central1', serverGroupName: 'app-v001', useSourceCapacity: true },
+      viewState: { mode: 'clone', useSimpleCapacity: false, unrelated: 'keep' },
+    });
+    const persistedFormik = formik(persisted);
+    const persistedPage = shallow(<Policies app={{} as any} formik={persistedFormik} />);
+
+    persistedPage.find('[data-testid="enable-autoscaling"]').simulate('change', { target: { checked: false } });
+
+    expect(persisted.enableAutoScaling).toBe(false);
+    expect(persisted.autoscalingPolicy).toBeNull();
+    expect(persisted.overwriteAncestorAutoscalingPolicy).toBe(true);
+    expect(persisted.source).toEqual({
+      region: 'us-central1',
+      serverGroupName: 'app-v001',
+      useSourceCapacity: false,
+    });
+    expect(persisted.viewState).toEqual({ mode: 'clone', useSimpleCapacity: true, unrelated: 'keep' });
+    expect(persisted.capacity).toEqual({ min: 2, max: 2, desired: 2 });
+
+    persistedPage.setProps({ formik: persistedFormik });
+    persistedPage.find('[data-testid="enable-autoscaling"]').simulate('change', { target: { checked: true } });
+
+    expect(persisted.enableAutoScaling).toBe(true);
+    expect(persisted.overwriteAncestorAutoscalingPolicy).toBe(false);
+    expect(persisted.autoscalingPolicy).toEqual({
+      minNumReplicas: 2,
+      maxNumReplicas: 2,
+      coolDownPeriodSec: 60,
+      cpuUtilization: { utilizationTarget: 0.5 },
+    });
+    expect(persisted.source.useSourceCapacity).toBe(false);
+    expect(persisted.viewState).toEqual({ mode: 'clone', useSimpleCapacity: false, unrelated: 'keep' });
+    expect(persisted.capacity).toEqual({ min: 2, max: 2, desired: 2 });
+  });
+
+  (['create', 'createPipeline', 'editPipeline'] as const).forEach((mode) => {
+    it(`does not overwrite ancestor autoscaling when disabling in ${mode} mode`, () => {
+      const values = command({
+        autoscalingPolicy: { minNumReplicas: 1, maxNumReplicas: 4 },
+        viewState: { mode },
+      });
+      const wrapper = shallow(<Policies app={{} as any} formik={formik(values)} />);
+
+      wrapper.find('[data-testid="enable-autoscaling"]').simulate('change', { target: { checked: false } });
+
+      expect(values.overwriteAncestorAutoscalingPolicy).toBe(false);
+    });
+  });
+
+  it('preserves autohealing policy fields and limits ancestor overwrite to clone disables', () => {
+    const policy = { healthCheck: 'check', initialDelaySec: 300, unknownPolicyField: 'keep' };
+    const clone = command({ enableAutoHealing: true, autoHealingPolicy: policy, viewState: { mode: 'clone' } });
+    const clonePage = shallow(<Policies app={{} as any} formik={formik(clone)} />);
+
+    clonePage.find('[data-testid="enable-autohealing"]').simulate('change', { target: { checked: false } });
+
+    expect(clone.enableAutoHealing).toBe(false);
+    expect(clone.overwriteAncestorAutoHealingPolicy).toBe(true);
+    expect(clone.autoHealingPolicy).toBe(policy);
+
+    const create = command({ enableAutoHealing: true, autoHealingPolicy: policy, viewState: { mode: 'create' } });
+    const createPage = shallow(<Policies app={{} as any} formik={formik(create)} />);
+    createPage.find('[data-testid="enable-autohealing"]').simulate('change', { target: { checked: false } });
+
+    expect(create.overwriteAncestorAutoHealingPolicy).toBe(false);
+  });
+
+  it('creates valid defaults on first enable and synchronizes compatibility state', () => {
+    const values = command({
+      enableAutoScaling: false,
+      enableAutoHealing: false,
+      autoscalingPolicy: undefined,
+      autoHealingPolicy: undefined,
+      overwriteAncestorAutoHealingPolicy: true,
+      capacity: { min: 3, max: 3, desired: 3 },
+      source: { useSourceCapacity: true },
+      viewState: { mode: 'clone' },
+    });
+    const wrapper = shallow(<Policies app={{} as any} formik={formik(values)} />);
+
+    wrapper.find('[data-testid="enable-autoscaling"]').simulate('change', { target: { checked: true } });
+    wrapper.find('[data-testid="enable-autohealing"]').simulate('change', { target: { checked: true } });
+
+    expect(values.autoscalingPolicy).toEqual({
+      minNumReplicas: 3,
+      maxNumReplicas: 3,
+      coolDownPeriodSec: 60,
+      cpuUtilization: { utilizationTarget: 0.5 },
+    });
+    expect(values.capacity).toEqual({ min: 3, max: 3, desired: 3 });
+    expect(values.source.useSourceCapacity).toBe(false);
+    expect(values.viewState).toEqual({ mode: 'clone', useSimpleCapacity: false });
+    expect(values.autoHealingPolicy).toEqual({ initialDelaySec: 300 });
+    expect(values.overwriteAncestorAutoHealingPolicy).toBe(false);
+  });
+
+  it('derives autoscaling rendering and validation from canonical policy presence', () => {
+    const page = new Policies({ app: {} as any, formik: formik(command()) } as any);
+    const canonical = command({
+      enableAutoScaling: false,
+      autoscalingPolicy: { minNumReplicas: 3, maxNumReplicas: 2, cpuUtilization: {} },
+    });
+    const canonicalWrapper = shallow(<Policies app={{} as any} formik={formik(canonical)} />);
+
+    expect(canonicalWrapper.find('[data-testid="enable-autoscaling"]').prop('checked')).toBe(true);
+    expect(canonicalWrapper.find(GceAutoscalingPolicyEditor).exists()).toBe(true);
+
+    expect(
+      page.validate({
+        ...canonical,
+        enableAutoHealing: true,
+        autoHealingPolicy: {
+          healthCheckUrl: 'https://compute/healthChecks/web',
+          initialDelaySec: -1,
+          maxUnavailable: { fixed: 1, percent: 1 },
+        } as any,
+      }),
+    ).toEqual({
+      autoscalingPolicy: {
+        maxNumReplicas: 'Maximum capacity must be at least the minimum capacity.',
+        coolDownPeriodSec: 'Cool-down period must be an integer of at least 15 seconds.',
+        metric: 'At least one complete autoscaling metric required.',
+      },
+      autoHealingPolicy: {
+        healthCheck: 'Health check required.',
+        healthCheckKind: 'Health check kind required.',
+        initialDelaySec: 'Initial delay must be an integer between 0 and 2147483647 seconds.',
+      },
+    });
+    expect(
+      page.validate(
+        command({
+          enableAutoScaling: true,
+          autoscalingPolicy: null,
+          enableAutoHealing: false,
+          autoHealingPolicy: { unknownPolicyField: 'keep' },
+        }),
+      ),
+    ).toEqual({});
+  });
+
+  it('synchronizes edited autoscaling policy bounds and prevents source inheritance', () => {
+    const values = command({
+      enableAutoScaling: false,
+      autoscalingPolicy: {
+        minNumReplicas: 1,
+        maxNumReplicas: 4,
+        coolDownPeriodSec: 60,
+        cpuUtilization: { utilizationTarget: 0.5 },
+      },
+      capacity: { min: 1, max: 4, desired: 3 },
+      source: { useSourceCapacity: true },
+      viewState: { mode: 'editPipeline', useSimpleCapacity: true, unrelated: 'keep' },
+    });
+    const wrapper = shallow(<Policies app={{} as any} formik={formik(values)} />);
+    const policy = {
+      minNumReplicas: 2,
+      maxNumReplicas: 6,
+      coolDownPeriodSec: 90,
+      cpuUtilization: { utilizationTarget: 0.7 },
+    };
+
+    wrapper.find(GceAutoscalingPolicyEditor).prop('onChange')(policy);
+
+    expect(values.autoscalingPolicy).toBe(policy);
+    expect(values.capacity).toEqual({ min: 2, max: 6, desired: 3 });
+    expect(values.enableAutoScaling).toBe(true);
+    expect(values.source.useSourceCapacity).toBe(false);
+    expect(values.viewState).toEqual({ mode: 'editPipeline', useSimpleCapacity: false, unrelated: 'keep' });
+  });
+
+  it('requires autoscaling capacity, cooldown, and real metric values', () => {
+    const page = new Policies({ app: {} as any, formik: formik(command()) } as any);
+
+    expect(
+      page.validate(
+        command({
+          enableAutoScaling: true,
+          autoscalingPolicy: {
+            cpuUtilization: { utilizationTarget: 0 },
+            loadBalancingUtilization: { utilizationTarget: 1 },
+            customMetricUtilizations: [{ metric: 'custom' }],
+          },
+        }),
+      ),
+    ).toEqual({
+      autoscalingPolicy: {
+        minNumReplicas: 'Minimum capacity must be a nonnegative integer.',
+        maxNumReplicas: 'Maximum capacity must be a nonnegative integer.',
+        coolDownPeriodSec: 'Cool-down period must be an integer of at least 15 seconds.',
+        metric: 'At least one complete autoscaling metric required.',
+      },
+    });
+  });
+
+  it('matches autoscaling schedule and scale-in validation from the completed modal', () => {
+    const page = new Policies({ app: {} as any, formik: formik(command()) } as any);
+    const values = command({
+      enableAutoScaling: true,
+      autoscalingPolicy: {
+        minNumReplicas: 0,
+        maxNumReplicas: 2,
+        coolDownPeriodSec: 15,
+        cpuUtilization: { utilizationTarget: 0.5 },
+        scalingSchedules: [{ scheduleName: 'incomplete' }],
+        scaleInControl: { maxScaledInReplicas: { percent: 101 }, timeWindowSec: 30 },
+      },
+    });
+
+    expect(page.validate(values)).toEqual({
+      autoscalingPolicy: {
+        scalingSchedules: 'Every scaling schedule must be complete and within supported bounds.',
+        scaleInControl: 'Scale-in control values are outside supported bounds.',
+      },
+    });
+  });
+
+  it('accepts complete policies at modal boundary values', () => {
+    const page = new Policies({ app: {} as any, formik: formik(command()) } as any);
+
+    expect(
+      page.validate(
+        command({
+          enableAutoScaling: true,
+          autoscalingPolicy: {
+            minNumReplicas: 0,
+            maxNumReplicas: 2,
+            coolDownPeriodSec: 15,
+            cpuUtilization: { utilizationTarget: 0.5 },
+            scalingSchedules: [
+              {
+                scheduleName: 'overnight',
+                minimumRequiredInstances: 1,
+                scheduleCron: '0 0 * * *',
+                timezone: 'Europe/London',
+                duration: 301,
+              },
+            ],
+            scaleInControl: { maxScaledInReplicas: { percent: 100 }, timeWindowSec: 60 },
+          },
+          enableAutoHealing: true,
+          autoHealingPolicy: {
+            healthCheck: 'web',
+            healthCheckKind: 'healthCheck',
+            initialDelaySec: 0,
+            maxUnavailable: { percent: 100 },
+          } as any,
+        }),
+      ),
+    ).toEqual({});
+  });
+});
+
+function command(overrides: Partial<IGceServerGroupCommand> = {}): IGceServerGroupCommand {
+  return {
+    credentials: 'account',
+    regional: false,
+    viewState: { mode: 'create' },
+    backingData: { filtered: { healthChecks: [] } },
+    ...overrides,
+  } as IGceServerGroupCommand;
+}
+
+function formik(values: IGceServerGroupCommand): any {
+  return {
+    values,
+    setFieldValue: jasmine.createSpy('setFieldValue').and.callFake((field: string, value: any) => {
+      values[field] = value;
+    }),
+  };
+}

package/src/serverGroup/configure/wizard/pages/Policies.tsx

@@ -0,0 +1,293 @@
+import React from 'react';
+
+import type { IGceServerGroupCommand } from '../GceServerGroupWizard.types';
+import { GceServerGroupWizardPage } from '../GceServerGroupWizardPage';
+import { GceAutoHealingPolicyEditor } from '../../../../autoHealingPolicy';
+import { GceAutoscalingPolicyEditor } from '../../../../autoscalingPolicy';
+import type { IGceAutoscalingPolicy } from '../../../../autoscalingPolicy';
+import { GcePredictiveMethod } from '../../../../autoscalingPolicy';
+import type { IGceAutoHealingPolicy } from '../../../../domain';
+import { GCEProviderSettings } from '../../../../gce.settings';
+
+const MAX_INT = 2147483647;
+const MAX_SCHEDULE_DURATION_SECONDS = 14 * 24 * 60 * 60;
+
+function isIntegerInRange(value: unknown, minimum: number, maximum = MAX_INT): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isFinite(value) &&
+    Number.isInteger(value) &&
+    value >= minimum &&
+    value <= maximum
+  );
+}
+
+function isUtilizationTarget(value: unknown, maximum?: number): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 && (maximum === undefined || value < maximum);
+}
+
+function isValidCustomMetric(metric: NonNullable<IGceAutoscalingPolicy['customMetricUtilizations']>[number]): boolean {
+  if (!metric.metric?.trim() || !metric.metricExportScope) {
+    return false;
+  }
+  if (
+    metric.metricExportScope === 'SINGLE_TIME_SERIES_PER_GROUP' &&
+    metric.scalingpolicy === 'SINGLE_INSTANCE_ASSIGNMENT'
+  ) {
+    return (
+      typeof metric.singleInstanceAssignment === 'number' &&
+      Number.isFinite(metric.singleInstanceAssignment) &&
+      metric.singleInstanceAssignment >= 0
+    );
+  }
+  if (metric.metricExportScope === 'SINGLE_TIME_SERIES_PER_GROUP' && metric.scalingpolicy !== 'UTILIZATION_TARGET') {
+    return false;
+  }
+  return isUtilizationTarget(metric.utilizationTarget) && Boolean(metric.utilizationTargetType);
+}
+
+function hasValidMetrics(policy: IGceAutoscalingPolicy): boolean {
+  const cpuConfigured = Boolean(policy.cpuUtilization && Object.keys(policy.cpuUtilization).length);
+  const loadBalancingConfigured = Boolean(
+    policy.loadBalancingUtilization && Object.keys(policy.loadBalancingUtilization).length,
+  );
+  const customMetrics = policy.customMetricUtilizations || [];
+  const cpuValid = !cpuConfigured || isUtilizationTarget(policy.cpuUtilization?.utilizationTarget, 1);
+  const loadBalancingValid =
+    !loadBalancingConfigured || isUtilizationTarget(policy.loadBalancingUtilization?.utilizationTarget, 1);
+  return (
+    cpuValid &&
+    loadBalancingValid &&
+    customMetrics.every(isValidCustomMetric) &&
+    ((cpuConfigured && cpuValid) ||
+      (loadBalancingConfigured && loadBalancingValid) ||
+      (customMetrics.length > 0 && customMetrics.every(isValidCustomMetric)))
+  );
+}
+
+function hasValidSchedules(policy: IGceAutoscalingPolicy): boolean {
+  return (policy.scalingSchedules || []).every(
+    (schedule) =>
+      Boolean(schedule.scheduleName?.trim()) &&
+      isIntegerInRange(schedule.minimumRequiredInstances, 0, policy.maxNumReplicas) &&
+      Boolean(schedule.scheduleCron?.trim()) &&
+      Boolean(schedule.timezone?.trim()) &&
+      isIntegerInRange(schedule.duration, 301, MAX_SCHEDULE_DURATION_SECONDS),
+  );
+}
+
+function hasValidScaleInControl(policy: IGceAutoscalingPolicy): boolean {
+  if (!policy.scaleInControl) {
+    return true;
+  }
+  const { maxScaledInReplicas, timeWindowSec } = policy.scaleInControl;
+  const hasFixed = maxScaledInReplicas?.fixed !== undefined;
+  const hasPercent = maxScaledInReplicas?.percent !== undefined;
+  if (hasFixed === hasPercent || !isIntegerInRange(timeWindowSec, 60, 3600)) {
+    return false;
+  }
+  return hasPercent
+    ? isIntegerInRange(maxScaledInReplicas?.percent, 0, 100)
+    : isIntegerInRange(maxScaledInReplicas?.fixed, 0);
+}
+
+export class Policies extends GceServerGroupWizardPage {
+  public validate(values: IGceServerGroupCommand): { [key: string]: any } {
+    const errors: { [key: string]: any } = {};
+
+    if (values.autoscalingPolicy) {
+      const policy = values.autoscalingPolicy as IGceAutoscalingPolicy;
+      const policyErrors: { [key: string]: string } = {};
+      const validMinimum = isIntegerInRange(policy.minNumReplicas, 0);
+      const validMaximum = isIntegerInRange(policy.maxNumReplicas, 0);
+      if (!validMinimum) {
+        policyErrors.minNumReplicas = 'Minimum capacity must be a nonnegative integer.';
+      }
+      if (!validMaximum) {
+        policyErrors.maxNumReplicas = 'Maximum capacity must be a nonnegative integer.';
+      } else if (validMinimum && policy.maxNumReplicas < policy.minNumReplicas) {
+        policyErrors.maxNumReplicas = 'Maximum capacity must be at least the minimum capacity.';
+      }
+      if (!isIntegerInRange(policy.coolDownPeriodSec, 15)) {
+        policyErrors.coolDownPeriodSec = 'Cool-down period must be an integer of at least 15 seconds.';
+      }
+      if (!hasValidMetrics(policy)) {
+        policyErrors.metric = 'At least one complete autoscaling metric required.';
+      }
+      if (!hasValidSchedules(policy)) {
+        policyErrors.scalingSchedules = 'Every scaling schedule must be complete and within supported bounds.';
+      }
+      if (!hasValidScaleInControl(policy)) {
+        policyErrors.scaleInControl = 'Scale-in control values are outside supported bounds.';
+      }
+      const predictiveEnabled = policy.cpuUtilization?.predictiveMethod === GcePredictiveMethod.STANDARD;
+      if (predictiveEnabled && !GCEProviderSettings.feature.predictiveAutoscaling) {
+        policyErrors.predictiveAutoscaling = 'Predictive autoscaling is not enabled.';
+      }
+      if (Object.keys(policyErrors).length) {
+        errors.autoscalingPolicy = policyErrors;
+      }
+    }
+
+    if (values.enableAutoHealing) {
+      const policy = (values.autoHealingPolicy || {}) as IGceAutoHealingPolicy;
+      const policyErrors: { [key: string]: string } = {};
+      if (!policy.healthCheck?.trim()) {
+        policyErrors.healthCheck = 'Health check required.';
+      }
+      if (!policy.healthCheckKind) {
+        policyErrors.healthCheckKind = 'Health check kind required.';
+      }
+      if (!isIntegerInRange(policy.initialDelaySec, 0)) {
+        policyErrors.initialDelaySec = 'Initial delay must be an integer between 0 and 2147483647 seconds.';
+      }
+      if (Object.keys(policyErrors).length) {
+        errors.autoHealingPolicy = policyErrors;
+      }
+    }
+
+    return errors;
+  }
+
+  private setField = (field: string, value: any): void => {
+    this.props.formik.setFieldValue(field, value);
+  };
+
+  private toggleAutoscaling = (enabled: boolean): void => {
+    const { values } = this.props.formik;
+    const persistedPolicy = values.autoscalingPolicy as IGceAutoscalingPolicy | undefined;
+    this.setField(
+      'overwriteAncestorAutoscalingPolicy',
+      !enabled && values.viewState?.mode === 'clone' && Boolean(persistedPolicy),
+    );
+    if (enabled) {
+      const desired = values.capacity?.desired ?? 1;
+      this.setAutoscalingPolicy(
+        persistedPolicy || {
+          minNumReplicas: desired,
+          maxNumReplicas: desired,
+          coolDownPeriodSec: 60,
+          cpuUtilization: { utilizationTarget: 0.5 },
+        },
+      );
+      return;
+    }
+
+    this.setField('enableAutoScaling', false);
+    this.setField('autoscalingPolicy', null);
+    this.setField('source', { ...values.source, useSourceCapacity: false });
+    this.setField('viewState', { ...values.viewState, useSimpleCapacity: true });
+    const desired = values.capacity?.desired ?? 1;
+    this.setField('capacity', { min: desired, max: desired, desired });
+  };
+
+  private setAutoscalingPolicy = (policy: IGceAutoscalingPolicy): void => {
+    const { values } = this.props.formik;
+    const min = policy.minNumReplicas;
+    const max = policy.maxNumReplicas;
+    const desired = coherentDesiredCapacity(values.capacity?.desired, min, max);
+
+    this.setField('enableAutoScaling', true);
+    this.setField('autoscalingPolicy', policy);
+    this.setField('source', { ...values.source, useSourceCapacity: false });
+    this.setField('viewState', { ...values.viewState, useSimpleCapacity: false });
+    this.setField('capacity', { ...values.capacity, min, max, desired });
+  };
+
+  private toggleAutohealing = (enabled: boolean): void => {
+    const { values } = this.props.formik;
+    const persistedPolicy = values.autoHealingPolicy as IGceAutoHealingPolicy | undefined;
+    this.setField('enableAutoHealing', enabled);
+    this.setField(
+      'overwriteAncestorAutoHealingPolicy',
+      !enabled && values.viewState?.mode === 'clone' && Boolean(persistedPolicy),
+    );
+    if (enabled && !persistedPolicy) {
+      this.setField('autoHealingPolicy', { initialDelaySec: 300 });
+    }
+  };
+
+  private filteredHealthCheckReader(): any {
+    const { values } = this.props.formik;
+    const healthChecks = values.backingData?.filtered?.healthChecks || [];
+    return {
+      listHealthChecks: () =>
+        Promise.resolve(
+          healthChecks.map((healthCheck: any) => ({
+            ...healthCheck,
+            account: values.credentials,
+          })),
+        ),
+    };
+  }
+
+  public render(): JSX.Element {
+    const { values } = this.props.formik;
+    const autoscalingEnabled = Boolean(values.autoscalingPolicy);
+    const autohealingEnabled = values.enableAutoHealing ?? Boolean(values.autoHealingPolicy);
+
+    return (
+      <div className="container-fluid form-horizontal" data-testid="gce-policies-page">
+        <section>
+          <div className="form-group">
+            <div className="col-md-4 sm-label-right">
+              <b>Enable Autoscaling</b>
+            </div>
+            <div className="col-md-6 checkbox">
+              <label>
+                <input
+                  checked={autoscalingEnabled}
+                  data-testid="enable-autoscaling"
+                  onChange={(event) => this.toggleAutoscaling(event.target.checked)}
+                  type="checkbox"
+                />
+                <span className="sr-only">Enable Autoscaling</span>
+              </label>
+            </div>
+          </div>
+          {autoscalingEnabled && (
+            <GceAutoscalingPolicyEditor
+              policy={(values.autoscalingPolicy || {}) as IGceAutoscalingPolicy}
+              onChange={this.setAutoscalingPolicy}
+            />
+          )}
+        </section>
+
+        <section>
+          <div className="form-group">
+            <div className="col-md-4 sm-label-right">
+              <b>Enable Autohealing</b>
+            </div>
+            <div className="col-md-6 checkbox">
+              <label>
+                <input
+                  checked={autohealingEnabled}
+                  data-testid="enable-autohealing"
+                  onChange={(event) => this.toggleAutohealing(event.target.checked)}
+                  type="checkbox"
+                />
+                <span className="sr-only">Enable Autohealing</span>
+              </label>
+            </div>
+          </div>
+          {autohealingEnabled && (
+            <GceAutoHealingPolicyEditor
+              key={values.credentials || ''}
+              account={values.credentials || ''}
+              policy={(values.autoHealingPolicy || {}) as IGceAutoHealingPolicy}
+              reader={this.filteredHealthCheckReader()}
+              onChange={(policy) => this.setField('autoHealingPolicy', policy)}
+            />
+          )}
+        </section>
+      </div>
+    );
+  }
+}
+
+function coherentDesiredCapacity(desired: any, min: any, max: any): any {
+  if (typeof desired === 'number' && typeof min === 'number' && typeof max === 'number') {
+    return Math.min(max, Math.max(min, desired));
+  }
+  return desired ?? min ?? max ?? 1;
+}