@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/details/autoscalingPolicy/GceAutoscalingPolicyDetails.spec.tsx

@@ -0,0 +1,200 @@
+import React from 'react';
+import { shallow } from 'enzyme';
+
+import { ConfirmationModalService } from '@spinnaker/core';
+
+import { GceAutoscalingPolicyWriter } from '../../../autoscalingPolicy';
+import { GceAutoscalingPolicyDetails } from './GceAutoscalingPolicyDetails';
+import { GceUpsertAutoscalingPolicyModal } from './modal/GceUpsertAutoscalingPolicyModal';
+
+describe('GceAutoscalingPolicyDetails', () => {
+  const application = { name: 'my-app' } as any;
+  const serverGroup = { account: 'my-account', name: 'my-app-main-v001', region: 'us-central1' } as any;
+  const managedServerGroup = {
+    ...serverGroup,
+    isManaged: true,
+    managedResourceSummary: {
+      id: 'managed-resource-id',
+      isPaused: false,
+      locations: { account: 'my-account', regions: [] },
+    },
+  } as any;
+  const policy = {
+    minNumReplicas: 0,
+    maxNumReplicas: 5,
+    coolDownPeriodSec: 60,
+    mode: 'ON' as const,
+    cpuUtilization: { utilizationTarget: 0 },
+    scaleInControl: { maxScaledInReplicas: { percent: 0 }, timeWindowSec: 60 },
+    scalingSchedules: [{ scheduleName: 'overnight', enabled: false }],
+  };
+
+  it('summarizes zero-valued metrics, scale-in controls, and schedules', () => {
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={serverGroup}
+        policy={policy}
+      />,
+    );
+
+    expect(wrapper.text()).toContain('CPU Usage');
+    expect(wrapper.text()).toContain('0%');
+    expect(wrapper.text()).toContain('Max Scaled-in Replicas');
+    expect(wrapper.text()).toContain('overnight (disabled)');
+  });
+
+  it('opens edit after managed-resource confirmation proceeds', async () => {
+    const show = spyOn(GceUpsertAutoscalingPolicyModal, 'show');
+    const confirm = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve() as any);
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={managedServerGroup}
+        policy={policy}
+      />,
+    );
+
+    wrapper.find('[data-testid="edit-autoscaling-policy"]').simulate('click');
+    expect(show).not.toHaveBeenCalled();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(confirm).toHaveBeenCalledWith(jasmine.objectContaining({ header: 'Pause Management?' }));
+    expect(show).toHaveBeenCalledWith({ application, serverGroup: managedServerGroup, policy });
+  });
+
+  it('does not open edit when managed-resource confirmation is cancelled', async () => {
+    const show = spyOn(GceUpsertAutoscalingPolicyModal, 'show');
+    spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.reject() as any);
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={managedServerGroup}
+        policy={policy}
+      />,
+    );
+
+    wrapper.find('[data-testid="edit-autoscaling-policy"]').simulate('click');
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(show).not.toHaveBeenCalled();
+  });
+
+  it('opens add after managed-resource confirmation proceeds', async () => {
+    const show = spyOn(GceUpsertAutoscalingPolicyModal, 'show');
+    const confirm = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve() as any);
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={managedServerGroup}
+        policy={undefined as any}
+      />,
+    );
+
+    wrapper.find('[data-testid="add-autoscaling-policy"]').simulate('click');
+    expect(show).not.toHaveBeenCalled();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(confirm).toHaveBeenCalledWith(jasmine.objectContaining({ header: 'Pause Management?' }));
+    expect(show).toHaveBeenCalledWith({ application, serverGroup: managedServerGroup });
+  });
+
+  it('does not open add when managed-resource confirmation is cancelled', async () => {
+    const show = spyOn(GceUpsertAutoscalingPolicyModal, 'show');
+    spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.reject() as any);
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={managedServerGroup}
+        policy={undefined as any}
+      />,
+    );
+
+    wrapper.find('[data-testid="add-autoscaling-policy"]').simulate('click');
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(show).not.toHaveBeenCalled();
+  });
+
+  it('offers delete confirmation after managed-resource confirmation proceeds', async () => {
+    const confirm = spyOn(ConfirmationModalService, 'confirm').and.returnValues(
+      Promise.resolve() as any,
+      Promise.resolve() as any,
+    );
+    const deletePolicy = spyOn(GceAutoscalingPolicyWriter, 'deleteAutoscalingPolicy');
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={managedServerGroup}
+        policy={policy}
+      />,
+    );
+
+    wrapper.find('[data-testid="delete-autoscaling-policy"]').simulate('click');
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(confirm.calls.count()).toBe(2);
+    const deleteConfirmation = confirm.calls.mostRecent().args[0];
+    deleteConfirmation.submitMethod();
+
+    expect(deletePolicy).toHaveBeenCalledWith(application, managedServerGroup);
+  });
+
+  it('does not offer delete confirmation when managed-resource confirmation is cancelled', async () => {
+    const cancelledConfirmation = {
+      then: (_onProceed: () => void, onCancel: () => void) => Promise.resolve(onCancel()),
+    } as any;
+    const confirm = spyOn(ConfirmationModalService, 'confirm').and.returnValue(cancelledConfirmation);
+    const deletePolicy = spyOn(GceAutoscalingPolicyWriter, 'deleteAutoscalingPolicy');
+    const wrapper = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={true}
+        serverGroup={managedServerGroup}
+        policy={policy}
+      />,
+    );
+
+    wrapper.find('[data-testid="delete-autoscaling-policy"]').simulate('click');
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(confirm.calls.count()).toBe(1);
+    expect(confirm).toHaveBeenCalledWith(jasmine.objectContaining({ header: 'Pause Management?' }));
+    expect(deletePolicy).not.toHaveBeenCalled();
+  });
+
+  it('hides all mutation actions when mutations are disabled', () => {
+    const details = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={false}
+        serverGroup={serverGroup}
+        policy={policy}
+      />,
+    );
+    const emptyDetails = shallow(
+      <GceAutoscalingPolicyDetails
+        application={application}
+        mutationsEnabled={false}
+        serverGroup={serverGroup}
+        policy={undefined as any}
+      />,
+    );
+
+    expect(details.find('[data-testid="edit-autoscaling-policy"]').exists()).toBe(false);
+    expect(details.find('[data-testid="delete-autoscaling-policy"]').exists()).toBe(false);
+    expect(emptyDetails.isEmptyRender()).toBe(true);
+  });
+});

package/src/serverGroup/details/autoscalingPolicy/GceAutoscalingPolicyDetails.tsx

@@ -0,0 +1,153 @@
+import React from 'react';
+
+import type { Application, IManagedResource } from '@spinnaker/core';
+import { ConfirmationModalService, confirmNotManaged } from '@spinnaker/core';
+
+import type { IGceAutoscalingPolicy, IGcePolicyServerGroup } from '../../../autoscalingPolicy';
+import { GceAutoscalingPolicyWriter } from '../../../autoscalingPolicy';
+import { GCEProviderSettings } from '../../../gce.settings';
+import { GceUpsertAutoscalingPolicyModal } from './modal/GceUpsertAutoscalingPolicyModal';
+
+export interface IGceAutoscalingPolicyDetailsProps {
+  application: Application;
+  mutationsEnabled: boolean;
+  serverGroup: IGcePolicyServerGroup & IManagedResource & { autoscalingMessages?: string[] };
+  policy?: IGceAutoscalingPolicy;
+}
+
+function percentage(value?: number): string {
+  return value === undefined ? '-' : `${Math.round(value * 100)}%`;
+}
+
+export function GceAutoscalingPolicyDetails({
+  application,
+  mutationsEnabled,
+  serverGroup,
+  policy,
+}: IGceAutoscalingPolicyDetailsProps): JSX.Element | null {
+  const runIfNotManaged = (action: () => void): void => {
+    confirmNotManaged(serverGroup, application).then((notManaged) => notManaged && action());
+  };
+
+  if (!policy) {
+    return mutationsEnabled ? (
+      <button
+        className="btn btn-link"
+        data-testid="add-autoscaling-policy"
+        type="button"
+        onClick={() => runIfNotManaged(() => GceUpsertAutoscalingPolicyModal.show({ application, serverGroup }))}
+      >
+        Add autoscaling policy
+      </button>
+    ) : null;
+  }
+
+  const maxScaledInReplicas = policy.scaleInControl?.maxScaledInReplicas;
+  const maxScaledIn =
+    typeof maxScaledInReplicas?.percent === 'number'
+      ? `${maxScaledInReplicas.percent}%`
+      : typeof maxScaledInReplicas?.fixed === 'number'
+      ? `${maxScaledInReplicas.fixed}`
+      : undefined;
+
+  const deletePolicy = (): void => {
+    ConfirmationModalService.confirm({
+      header: `Really delete autoscaler for ${serverGroup.name}?`,
+      buttonText: 'Delete autoscaler',
+      account: serverGroup.account,
+      taskMonitorConfig: { application, title: `Deleting autoscaler for ${serverGroup.name}` },
+      submitMethod: () => GceAutoscalingPolicyWriter.deleteAutoscalingPolicy(application, serverGroup),
+    });
+  };
+
+  return (
+    <div className="gce-autoscaling-policy-details">
+      <dl className="horizontal-when-filters-collapsed">
+        {policy.cpuUtilization && (
+          <>
+            <dt>Target CPU Usage</dt>
+            <dd>CPU Usage: {percentage(policy.cpuUtilization.utilizationTarget)}</dd>
+          </>
+        )}
+        {GCEProviderSettings.feature.predictiveAutoscaling && policy.cpuUtilization?.predictiveMethod !== undefined && (
+          <>
+            <dt>Predictive Autoscaling</dt>
+            <dd>{policy.cpuUtilization.predictiveMethod}</dd>
+          </>
+        )}
+        {policy.loadBalancingUtilization && (
+          <>
+            <dt>Target HTTP Load Balancing Usage</dt>
+            <dd>{percentage(policy.loadBalancingUtilization.utilizationTarget)}</dd>
+          </>
+        )}
+        {(policy.customMetricUtilizations || []).map((metric, index) => (
+          <React.Fragment key={`${metric.metric}-${index}`}>
+            <dt>Monitoring Metric</dt>
+            <dd>
+              {metric.metric || '-'}: {metric.utilizationTarget ?? metric.singleInstanceAssignment ?? '-'}
+              {metric.utilizationTargetType === 'DELTA_PER_SECOND'
+                ? '/sec'
+                : metric.utilizationTargetType === 'DELTA_PER_MINUTE'
+                ? '/min'
+                : ''}
+            </dd>
+          </React.Fragment>
+        ))}
+        <dt>Min # VMs</dt>
+        <dd>{policy.minNumReplicas ?? '-'}</dd>
+        <dt>Max # VMs</dt>
+        <dd>{policy.maxNumReplicas ?? '-'}</dd>
+        <dt>Cool-down Period</dt>
+        <dd>{policy.coolDownPeriodSec ?? '-'} sec</dd>
+        <dt>Mode</dt>
+        <dd>{policy.mode || '-'}</dd>
+        {policy.scaleInControl && (
+          <>
+            <dt>Max Scaled-in Replicas</dt>
+            <dd>{maxScaledIn ?? '-'}</dd>
+            <dt>Scale-in Time Window</dt>
+            <dd>{policy.scaleInControl.timeWindowSec ?? '-'} seconds</dd>
+          </>
+        )}
+        {(policy.scalingSchedules || []).map((schedule, index) => (
+          <React.Fragment key={`${schedule.scheduleName}-${index}`}>
+            <dt>Scaling Schedule</dt>
+            <dd>
+              {schedule.scheduleName || '-'} ({schedule.enabled ? 'enabled' : 'disabled'})
+              {schedule.timezone ? `, ${schedule.timezone}` : ''}
+            </dd>
+          </React.Fragment>
+        ))}
+        {(serverGroup.autoscalingMessages || []).map((message, index) => (
+          <React.Fragment key={index}>
+            <dt>Message</dt>
+            <dd>{message}</dd>
+          </React.Fragment>
+        ))}
+      </dl>
+      {mutationsEnabled && (
+        <div className="text-right">
+          <button
+            className="btn btn-link"
+            data-testid="edit-autoscaling-policy"
+            type="button"
+            onClick={() =>
+              runIfNotManaged(() => GceUpsertAutoscalingPolicyModal.show({ application, serverGroup, policy }))
+            }
+          >
+            Edit
+          </button>
+          <button
+            className="btn btn-link"
+            data-testid="delete-autoscaling-policy"
+            type="button"
+            onClick={() => runIfNotManaged(deletePolicy)}
+          >
+            Delete
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}

package/src/serverGroup/details/autoscalingPolicy/index.ts

@@ -0,0 +1,2 @@
+export * from './GceAutoscalingPolicyDetails';
+export * from './modal/GceUpsertAutoscalingPolicyModal';

package/src/serverGroup/details/autoscalingPolicy/modal/GceUpsertAutoscalingPolicyModal.spec.tsx

@@ -0,0 +1,227 @@
+import { GceAutoscalingPolicyWriter } from '../../../../autoscalingPolicy';
+import { GcePredictiveMethod } from '../../../../autoscalingPolicy';
+import { GCEProviderSettings } from '../../../../gce.settings';
+import { GceUpsertAutoscalingPolicyModal } from './GceUpsertAutoscalingPolicyModal';
+
+describe('GceUpsertAutoscalingPolicyModal', () => {
+  const application = { name: 'my-app' } as any;
+  const serverGroup = { account: 'my-account', name: 'my-app-main-v001', region: 'us-central1' } as any;
+  const validPolicy = {
+    minNumReplicas: 0,
+    maxNumReplicas: 5,
+    coolDownPeriodSec: 60,
+    cpuUtilization: { utilizationTarget: 0.5 },
+  };
+
+  function isValid(policy: any): boolean {
+    const modal = new GceUpsertAutoscalingPolicyModal({ application, serverGroup, policy } as any);
+    modal.state.policy = policy;
+    return (modal as any).isValid();
+  }
+
+  async function flush(): Promise<void> {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  it('retains edited policy state when task creation is rejected', async () => {
+    const rejection = { failureMessage: 'No permission' };
+    spyOn(GceAutoscalingPolicyWriter, 'upsertAutoscalingPolicy').and.returnValue(Promise.reject(rejection));
+    const modal = new GceUpsertAutoscalingPolicyModal({
+      application: { name: 'my-app' },
+      serverGroup: { account: 'my-account', name: 'my-app-main-v001', region: 'us-central1' },
+      policy: { minNumReplicas: 0, cpuUtilization: { utilizationTarget: 0.5 } },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+    } as any);
+    const editedPolicy = { minNumReplicas: 0, cpuUtilization: { utilizationTarget: 0 } };
+    modal.state.policy = editedPolicy;
+
+    (modal as any).submit();
+    await flush();
+
+    expect(modal.state.policy).toBe(editedPolicy);
+    expect(modal.state.taskMonitor.error).toBe(true);
+  });
+
+  it('does not count empty metric objects as a configured metric', () => {
+    expect(
+      isValid({
+        ...validPolicy,
+        cpuUtilization: {},
+        loadBalancingUtilization: {},
+        customMetricUtilizations: [{}],
+      }),
+    ).toBe(false);
+  });
+
+  it('requires CPU utilization to be strictly between zero and one', () => {
+    expect(isValid({ ...validPolicy, cpuUtilization: { utilizationTarget: 0 } })).toBe(false);
+    expect(isValid({ ...validPolicy, cpuUtilization: { utilizationTarget: 1 } })).toBe(false);
+    expect(isValid({ ...validPolicy, cpuUtilization: { utilizationTarget: 0.999 } })).toBe(true);
+  });
+
+  it('requires custom utilization targets to be greater than zero', () => {
+    const customPolicy = {
+      ...validPolicy,
+      cpuUtilization: {},
+      customMetricUtilizations: [
+        {
+          metric: 'custom.googleapis.com/queue',
+          metricExportScope: 'TIME_SERIES_PER_INSTANCE',
+          utilizationTargetType: 'GAUGE',
+        },
+      ],
+    };
+
+    expect(
+      isValid({
+        ...customPolicy,
+        customMetricUtilizations: [{ ...customPolicy.customMetricUtilizations[0], utilizationTarget: 0 }],
+      }),
+    ).toBe(false);
+    expect(
+      isValid({
+        ...customPolicy,
+        customMetricUtilizations: [{ ...customPolicy.customMetricUtilizations[0], utilizationTarget: 5 }],
+      }),
+    ).toBe(true);
+  });
+
+  it('allows zero for group single-instance assignment', () => {
+    expect(
+      isValid({
+        ...validPolicy,
+        cpuUtilization: {},
+        customMetricUtilizations: [
+          {
+            metric: 'custom.googleapis.com/queue',
+            metricExportScope: 'SINGLE_TIME_SERIES_PER_GROUP',
+            scalingpolicy: 'SINGLE_INSTANCE_ASSIGNMENT',
+            singleInstanceAssignment: 0,
+          },
+        ],
+      }),
+    ).toBe(true);
+  });
+
+  it('requires custom metric fields appropriate to per-instance and group scopes', () => {
+    const missingPerInstanceType = {
+      ...validPolicy,
+      cpuUtilization: {},
+      customMetricUtilizations: [
+        {
+          metric: 'custom.googleapis.com/queue',
+          metricExportScope: 'TIME_SERIES_PER_INSTANCE',
+          utilizationTarget: 1,
+        },
+      ],
+    };
+    const missingGroupAssignment = {
+      ...validPolicy,
+      cpuUtilization: {},
+      customMetricUtilizations: [
+        {
+          metric: 'custom.googleapis.com/queue',
+          metricExportScope: 'SINGLE_TIME_SERIES_PER_GROUP',
+          scalingpolicy: 'SINGLE_INSTANCE_ASSIGNMENT',
+        },
+      ],
+    };
+    const missingGroupTarget = {
+      ...validPolicy,
+      cpuUtilization: {},
+      customMetricUtilizations: [
+        {
+          metric: 'custom.googleapis.com/queue',
+          metricExportScope: 'SINGLE_TIME_SERIES_PER_GROUP',
+          scalingpolicy: 'UTILIZATION_TARGET',
+          utilizationTargetType: 'GAUGE',
+        },
+      ],
+    };
+
+    expect(isValid(missingPerInstanceType)).toBe(false);
+    expect(isValid(missingGroupAssignment)).toBe(false);
+    expect(isValid(missingGroupTarget)).toBe(false);
+  });
+
+  it('requires complete scaling schedules within supported numeric bounds', () => {
+    expect(isValid({ ...validPolicy, scalingSchedules: [{ scheduleName: 'overnight' }] })).toBe(false);
+    expect(
+      isValid({
+        ...validPolicy,
+        scalingSchedules: [
+          {
+            scheduleName: 'overnight',
+            minimumRequiredInstances: -1,
+            scheduleCron: '0 0 * * *',
+            timezone: 'Europe/London',
+            duration: 300,
+          },
+        ],
+      }),
+    ).toBe(false);
+    expect(
+      isValid({
+        ...validPolicy,
+        scalingSchedules: [
+          {
+            scheduleName: 'overnight',
+            minimumRequiredInstances: 1,
+            scheduleCron: '0 0 * * *',
+            timezone: 'Europe/London',
+            duration: 1209601,
+          },
+        ],
+      }),
+    ).toBe(false);
+  });
+
+  it('rejects invalid finite and nonnegative policy bounds', () => {
+    expect(isValid({ ...validPolicy, minNumReplicas: -1 })).toBe(false);
+    expect(isValid({ ...validPolicy, maxNumReplicas: Number.POSITIVE_INFINITY })).toBe(false);
+    expect(isValid({ ...validPolicy, coolDownPeriodSec: Number.NaN })).toBe(false);
+  });
+
+  it('requires predictive autoscaling to be enabled and backed by a CPU target', () => {
+    const originalFeatureValue = GCEProviderSettings.feature.predictiveAutoscaling;
+    GCEProviderSettings.feature.predictiveAutoscaling = false;
+    expect(
+      isValid({
+        ...validPolicy,
+        cpuUtilization: { utilizationTarget: 0.5, predictiveMethod: GcePredictiveMethod.STANDARD },
+      }),
+    ).toBe(false);
+
+    GCEProviderSettings.feature.predictiveAutoscaling = true;
+    expect(
+      isValid({
+        ...validPolicy,
+        cpuUtilization: { predictiveMethod: GcePredictiveMethod.STANDARD },
+      }),
+    ).toBe(false);
+    GCEProviderSettings.feature.predictiveAutoscaling = originalFeatureValue;
+  });
+
+  it('requires scale-in controls to have one bounded maximum and a bounded time window', () => {
+    expect(
+      isValid({
+        ...validPolicy,
+        scaleInControl: { maxScaledInReplicas: { percent: 101 }, timeWindowSec: 60 },
+      }),
+    ).toBe(false);
+    expect(
+      isValid({
+        ...validPolicy,
+        scaleInControl: { maxScaledInReplicas: { fixed: Number.NaN }, timeWindowSec: 60 },
+      }),
+    ).toBe(false);
+    expect(
+      isValid({
+        ...validPolicy,
+        scaleInControl: { maxScaledInReplicas: { fixed: 1 }, timeWindowSec: 3601 },
+      }),
+    ).toBe(false);
+  });
+});