@spinnaker/google 2026.3.2 → 2026.4.0

package/src/loadBalancer/configure/http/GceHttpLoadBalancerListenerEditor.tsx

@@ -24,6 +24,22 @@ function selectedReference(name: string, options: IGceLoadBalancerDataItem[]): I
   return (options.find((option) => option.name === name) || { name }) as IGceResourceReference;
 }
 
+function certificateManagerReference(resourceUrl: string): IGceResourceReference | undefined {
+  const selfLink = resourceUrl.trim();
+  if (!selfLink) {
+    return undefined;
+  }
+  return {
+    name: selfLink.split('/').filter(Boolean).pop() || selfLink,
+    selfLink,
+  };
+}
+
+function certificateManagerUrl(certificate: IGceResourceReference | undefined): string {
+  const selfLink = certificate?.selfLink || '';
+  return selfLink.includes('/sslCertificates/') ? '' : selfLink;
+}
+
 export function GceHttpLoadBalancerListenerEditor({
   addresses,
   certificates,
@@ -34,6 +50,24 @@ export function GceHttpLoadBalancerListenerEditor({
   subnets,
 }: IGceHttpLoadBalancerListenerEditorProps): JSX.Element {
   const protocols = ['HTTP', 'HTTPS'];
+  const externalManaged = loadBalancerType === 'EXTERNAL_MANAGED';
+  const reservedNetworkTier = listener.address?.networkTier as string | undefined;
+
+  const updateAddress = (name: string): void => {
+    const address = selectedReference(name, addresses);
+    if (externalManaged) {
+      const selectedAddress = addresses.find((option) => option.name === name);
+      const networkTier = (selectedAddress as { networkTier?: string } | undefined)?.networkTier;
+      onChange({
+        ...listener,
+        address,
+        ...(networkTier ? { networkTier } : {}),
+      });
+      return;
+    }
+    const { networkTier: _networkTier, ...listenerWithoutTier } = listener;
+    onChange({ ...listenerWithoutTier, address });
+  };
 
   return (
     <fieldset className="gce-http-listener">
@@ -99,7 +133,7 @@ export function GceHttpLoadBalancerListenerEditor({
         <select
           data-testid="listener-address"
           value={listener.address?.name || ''}
-          onChange={(event) => onChange({ ...listener, address: selectedReference(event.target.value, addresses) })}
+          onChange={(event) => updateAddress(event.target.value)}
         >
           <option value="">Ephemeral</option>
           {addresses.map((address) => (
@@ -132,19 +166,53 @@ export function GceHttpLoadBalancerListenerEditor({
               ))}
             </select>
           </label>
-          <label>
-            Certificate map
-            <input
-              data-testid="listener-certificate-map"
-              type="text"
-              value={listener.certificateMap || ''}
-              onChange={(event) =>
-                onChange({ ...listener, certificate: undefined, certificateMap: event.target.value || undefined })
-              }
-            />
-          </label>
+          {externalManaged && (
+            <label>
+              Certificate Manager resource URL
+              <input
+                data-testid="listener-certificate-manager-url"
+                placeholder="//certificatemanager.googleapis.com/projects/.../locations/.../certificates/..."
+                type="text"
+                value={certificateManagerUrl(listener.certificate)}
+                onChange={(event) =>
+                  onChange({
+                    ...listener,
+                    certificate: certificateManagerReference(event.target.value),
+                    certificateMap: undefined,
+                  })
+                }
+              />
+            </label>
+          )}
+          {!externalManaged && (
+            <label>
+              Certificate map
+              <input
+                data-testid="listener-certificate-map"
+                type="text"
+                value={listener.certificateMap || ''}
+                onChange={(event) =>
+                  onChange({ ...listener, certificate: undefined, certificateMap: event.target.value || undefined })
+                }
+              />
+            </label>
+          )}
         </>
       )}
+      {externalManaged && (
+        <label>
+          Network tier
+          <select
+            data-testid="listener-network-tier"
+            disabled={Boolean(reservedNetworkTier)}
+            value={reservedNetworkTier || listener.networkTier || 'PREMIUM'}
+            onChange={(event) => onChange({ ...listener, networkTier: event.target.value })}
+          >
+            <option value="PREMIUM">Premium</option>
+            <option value="STANDARD">Standard</option>
+          </select>
+        </label>
+      )}
       <button type="button" className="btn btn-sm btn-default" onClick={onRemove}>
         Remove listener
       </button>

package/src/loadBalancer/configure/http/GceHttpLoadBalancerModal.spec.tsx

@@ -1,9 +1,11 @@
 import React from 'react';
-import { shallow } from 'enzyme';
+import { fireEvent, screen } from '@testing-library/react';
 
 import { TaskExecutor } from '@spinnaker/core';
+import { renderWithRouter } from '../../../../../core/src/utils/testUtils/rtl';
 
 import { buildGceLoadBalancerJobs } from '../common';
+import { validateGceHttpLoadBalancerCommand } from './GceHttpLoadBalancerEditor';
 import { GceHttpLoadBalancerModal, initializeGceHttpLoadBalancerCommand } from './GceHttpLoadBalancerModal';
 
 describe('GceHttpLoadBalancerModal', () => {
@@ -75,71 +77,79 @@ describe('GceHttpLoadBalancerModal', () => {
   });
 
   it('returns exact operations without executing a task in pipeline-edit mode', () => {
-    const closeModal = jasmine.createSpy('closeModal');
-    const executeTask = spyOn(TaskExecutor, 'executeTask');
-    const modal = new GceHttpLoadBalancerModal({
-      app: application,
-      closeModal,
-      dismissModal: jasmine.createSpy('dismissModal'),
-      forPipelineConfig: true,
-      isNew: false,
-      loadBalancer: {
-        account: 'account-a',
-        backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
-        defaultService: 'backend-a',
-        healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
-        hostRules: [
-          {
-            hostPatterns: ['api.example.com'],
-            pathMatcher: {
-              defaultService: 'backend-a',
-              pathRules: [{ backendService: 'backend-a', paths: ['/v1'] }],
-            },
+    const closeModal = vi.fn();
+    const executeTask = vi.spyOn(TaskExecutor, 'executeTask').mockReturnValue(undefined);
+    const loadBalancer = {
+      account: 'account-a',
+      backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
+      defaultService: 'backend-a',
+      healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
+      hostRules: [
+        {
+          hostPatterns: ['api.example.com'],
+          pathMatcher: {
+            defaultService: 'backend-a',
+            pathRules: [{ backendService: 'backend-a', paths: ['/v1'] }],
           },
-        ],
-        listeners: [{ ipAddress: 'address-a', name: 'frontend', port: 80, protocol: 'HTTP' }],
-        loadBalancerType: 'HTTP',
-        name: 'test-app-main',
-      },
-      mode: 'edit',
-    } as any);
-    const expectedOperations = buildGceLoadBalancerJobs((modal as any).state.command);
+        },
+      ],
+      listeners: [{ ipAddress: 'address-a', name: 'frontend', port: 80, protocol: 'HTTP' }],
+      loadBalancerType: 'HTTP',
+      name: 'test-app-main',
+    };
+    const expectedOperations = buildGceLoadBalancerJobs(
+      initializeGceHttpLoadBalancerCommand(loadBalancer, 'pipeline', application),
+    );
+    renderWithRouter(
+      <GceHttpLoadBalancerModal
+        app={application}
+        closeModal={closeModal}
+        data={emptyData}
+        dismissModal={vi.fn()}
+        forPipelineConfig={true}
+        isNew={false}
+        loadBalancer={loadBalancer}
+      />,
+    );
 
-    (modal as any).submit();
+    fireEvent.click(screen.getByRole('button', { name: 'Done' }));
 
-    expect((modal as any).state.command.mode).toBe('pipeline');
     expect(executeTask).not.toHaveBeenCalled();
-    expect(closeModal).toHaveBeenCalledOnceWith(expectedOperations);
+    expect(closeModal).toHaveBeenCalledExactlyOnceWith(expectedOperations);
     expect(expectedOperations.map(({ loadBalancerName }) => loadBalancerName)).toEqual(['frontend']);
   });
 
   it('executes an update task instead of returning operations in infrastructure-edit mode', () => {
-    const closeModal = jasmine.createSpy('closeModal');
-    const executeTask = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({ id: 'task' }) as any);
-    const modal = new GceHttpLoadBalancerModal({
-      app: application,
-      closeModal,
-      dismissModal: jasmine.createSpy('dismissModal'),
-      forPipelineConfig: false,
-      isNew: false,
-      loadBalancer: {
-        account: 'account-a',
-        backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
-        defaultService: 'backend-a',
-        healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
-        listeners: [{ ipAddress: 'address-a', name: 'frontend', port: 80, protocol: 'HTTP' }],
-        loadBalancerType: 'HTTP',
-        name: 'test-app-main',
-      },
-      mode: 'edit',
-    } as any);
-    const expectedOperations = buildGceLoadBalancerJobs((modal as any).state.command);
+    const closeModal = vi.fn();
+    const executeTask = vi.fn().mockReturnValue(Promise.resolve({ id: 'task' }));
+    const loadBalancer = {
+      account: 'account-a',
+      backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
+      defaultService: 'backend-a',
+      healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
+      listeners: [{ ipAddress: 'address-a', name: 'frontend', port: 80, protocol: 'HTTP' }],
+      loadBalancerType: 'HTTP',
+      name: 'test-app-main',
+    };
+    const expectedOperations = buildGceLoadBalancerJobs(
+      initializeGceHttpLoadBalancerCommand(loadBalancer, 'edit', application),
+    );
+    renderWithRouter(
+      <GceHttpLoadBalancerModal
+        app={application}
+        closeModal={closeModal}
+        data={emptyData}
+        dismissModal={vi.fn()}
+        executeTask={executeTask}
+        isNew={false}
+        loadBalancer={loadBalancer}
+      />,
+    );
 
-    (modal as any).submit();
+    fireEvent.click(screen.getByRole('button', { name: 'Update' }));
 
-    expect((modal as any).state.command.mode).toBe('edit');
     expect(closeModal).not.toHaveBeenCalled();
-    expect(executeTask).toHaveBeenCalledOnceWith({
+    expect(executeTask).toHaveBeenCalledExactlyOnceWith({
       application,
       description: 'Update Load Balancer: test-app-main',
       job: expectedOperations,
@@ -147,37 +157,40 @@ describe('GceHttpLoadBalancerModal', () => {
   });
 
   it('executes normalized listener jobs in infrastructure mode', () => {
-    const executeTask = jasmine.createSpy('executeTask').and.returnValue(Promise.resolve({ id: 'task' }));
-    const modal = new GceHttpLoadBalancerModal({
-      app: application,
-      closeModal: jasmine.createSpy('closeModal'),
-      dismissModal: jasmine.createSpy('dismissModal'),
-      executeTask,
-      loadBalancer: {
-        account: 'account-a',
-        backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
-        defaultService: 'backend-a',
-        healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
-        listeners: [
-          { ipAddress: 'address-a', name: 'frontend-a', port: 80, protocol: 'HTTP' },
-          { ipAddress: 'address-b', name: 'frontend-b', port: 8080, protocol: 'HTTP' },
-        ],
-        loadBalancerType: 'INTERNAL_MANAGED',
-        name: 'test-app-main',
-        network: 'network-a',
-        region: 'europe-west1',
-        subnet: 'subnet-a',
-      },
-      mode: 'create',
-    } as any);
+    const executeTask = vi.fn().mockReturnValue(Promise.resolve({ id: 'task' }));
+    renderWithRouter(
+      <GceHttpLoadBalancerModal
+        app={application}
+        closeModal={vi.fn()}
+        data={emptyData}
+        dismissModal={vi.fn()}
+        executeTask={executeTask}
+        loadBalancer={{
+          account: 'account-a',
+          backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
+          defaultService: 'backend-a',
+          healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
+          listeners: [
+            { ipAddress: 'address-a', name: 'frontend-a', port: 80, protocol: 'HTTP' },
+            { ipAddress: 'address-b', name: 'frontend-b', port: 8080, protocol: 'HTTP' },
+          ],
+          loadBalancerType: 'INTERNAL_MANAGED',
+          name: 'test-app-main',
+          network: 'network-a',
+          region: 'europe-west1',
+          subnet: 'subnet-a',
+        }}
+        mode="create"
+      />,
+    );
 
-    (modal as any).submit();
+    fireEvent.click(screen.getByRole('button', { name: 'Create' }));
 
     expect(executeTask).toHaveBeenCalled();
-    const jobs = executeTask.calls.mostRecent().args[0].job;
+    const jobs = executeTask.mock.lastCall[0].job;
     expect(jobs.map(({ name }: any) => name)).toEqual(['frontend-a', 'frontend-b']);
     expect(jobs[0]).toEqual(
-      jasmine.objectContaining({
+      expect.objectContaining({
         ipAddress: 'address-a',
         ipProtocol: 'TCP',
         loadBalancerName: 'frontend-a',
@@ -189,11 +202,56 @@ describe('GceHttpLoadBalancerModal', () => {
   });
 
   it('serializes INTERNAL_MANAGED HTTPS listeners with certificates', () => {
-    const closeModal = jasmine.createSpy('closeModal');
+    const closeModal = vi.fn();
+    renderWithRouter(
+      <GceHttpLoadBalancerModal
+        app={application}
+        closeModal={closeModal}
+        data={emptyData}
+        dismissModal={vi.fn()}
+        forPipelineConfig={true}
+        loadBalancer={{
+          account: 'account-a',
+          backendServices: [{ healthCheck: 'check-a', name: 'backend-a', portName: 'http' }],
+          defaultService: 'backend-a',
+          healthChecks: [{ healthCheckType: 'HTTPS', name: 'check-a', port: 443, requestPath: '/health' }],
+          listeners: [
+            {
+              certificate: 'regional-cert',
+              name: 'internal-https',
+              port: 443,
+              protocol: 'HTTPS',
+              subnet: 'subnet-a',
+            },
+          ],
+          loadBalancerType: 'INTERNAL_MANAGED',
+          name: 'test-app-internal',
+          network: 'network-a',
+          region: 'europe-west1',
+          subnet: 'subnet-a',
+        }}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Done' }));
+
+    expect(closeModal).toHaveBeenCalledWith([
+      expect.objectContaining({
+        certificate: 'regional-cert',
+        loadBalancerName: 'internal-https',
+        portRange: '443',
+      }),
+    ]);
+  });
+
+  it('flattens EXTERNAL_MANAGED pipeline payloads with regional network tier and certificate URL', () => {
+    const closeModal = vi.fn();
+    const regionalCertUrl =
+      '//certificatemanager.googleapis.com/projects/test/locations/europe-west1/certificates/regional-cert';
     const modal = new GceHttpLoadBalancerModal({
       app: application,
       closeModal,
-      dismissModal: jasmine.createSpy('dismissModal'),
+      dismissModal: vi.fn(),
       forPipelineConfig: true,
       loadBalancer: {
         account: 'account-a',
@@ -202,42 +260,86 @@ describe('GceHttpLoadBalancerModal', () => {
         healthChecks: [{ healthCheckType: 'HTTPS', name: 'check-a', port: 443, requestPath: '/health' }],
         listeners: [
           {
-            certificate: 'regional-cert',
-            name: 'internal-https',
+            certificate: regionalCertUrl,
+            ipAddress: '203.0.113.10',
+            name: 'external-https',
+            networkTier: 'STANDARD',
             port: 443,
             protocol: 'HTTPS',
-            subnet: 'subnet-a',
           },
         ],
-        loadBalancerType: 'INTERNAL_MANAGED',
-        name: 'test-app-internal',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'test-app-external',
         network: 'network-a',
         region: 'europe-west1',
-        subnet: 'subnet-a',
       },
     } as any);
 
     (modal as any).submit();
 
     expect(closeModal).toHaveBeenCalledWith([
-      jasmine.objectContaining({
-        certificate: 'regional-cert',
-        loadBalancerName: 'internal-https',
+      expect.objectContaining({
+        certificate: regionalCertUrl,
+        loadBalancerName: 'external-https',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        network: 'network-a',
+        networkTier: 'STANDARD',
         portRange: '443',
+        region: 'europe-west1',
+        urlMapName: 'test-app-external',
       }),
     ]);
+    const operations = closeModal.mock.lastCall[0];
+    expect((operations as any[])[0].certificateMap).toBeUndefined();
+    expect((operations as any[])[0].listeners).toBeUndefined();
+  });
+
+  it('initializes persisted EXTERNAL_MANAGED data with raw listener identity and regional certificate URL', () => {
+    const regionalCertUrl =
+      '//certificatemanager.googleapis.com/projects/test/locations/europe-west1/certificates/regional-cert';
+    const command = initializeGceHttpLoadBalancerCommand(
+      {
+        account: 'account-a',
+        listeners: [
+          {
+            certificate: regionalCertUrl,
+            ipAddress: '203.0.113.10',
+            name: 'external-https',
+            networkTier: 'STANDARD',
+            port: 443,
+            protocol: 'HTTPS',
+          },
+        ],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        urlMapName: 'test-app-external',
+      },
+      'edit',
+      application,
+    );
+
+    expect(command.name).toBe('test-app-external');
+    expect(command.loadBalancerType).toBe('EXTERNAL_MANAGED');
+    expect(command.listeners[0]).toEqual({
+      address: { name: '203.0.113.10' },
+      certificate: { name: 'regional-cert', selfLink: regionalCertUrl },
+      name: 'external-https',
+      networkTier: 'STANDARD',
+      portRange: '443',
+      protocol: 'HTTPS',
+    });
+    expect(command.listeners[0].certificateMap).toBeUndefined();
   });
 
   (['HTTP', 'INTERNAL_MANAGED'] as const).forEach((loadBalancerType) => {
     ['pipeline', 'infrastructure'].forEach((submissionMode) => {
       it(`rejects ${loadBalancerType} ${submissionMode} commands with an unresolved path default and non-443 HTTPS port`, () => {
-        const closeModal = jasmine.createSpy('closeModal');
-        const executeTask = jasmine.createSpy('executeTask');
+        const closeModal = vi.fn();
+        const executeTask = vi.fn();
         const props = {
           app: application,
           closeModal,
           data: emptyData,
-          dismissModal: jasmine.createSpy('dismissModal'),
+          dismissModal: vi.fn(),
           executeTask,
           forPipelineConfig: submissionMode === 'pipeline',
           loadBalancer: {
@@ -255,38 +357,37 @@ describe('GceHttpLoadBalancerModal', () => {
           },
           mode: submissionMode === 'infrastructure' ? 'create' : undefined,
         } as any;
-        const wrapper = shallow(<GceHttpLoadBalancerModal {...props} />);
-        const modal = wrapper.instance() as any;
-        modal.setState({
-          command: {
-            ...modal.state.command,
-            listeners: [{ ...modal.state.command.listeners[0], portRange: '8443' }],
-          },
-        });
-        wrapper.update();
-
-        modal.submit();
+        const command = initializeGceHttpLoadBalancerCommand(
+          props.loadBalancer,
+          submissionMode === 'pipeline' ? 'pipeline' : 'create',
+          application,
+        );
+        command.listeners = [{ ...command.listeners[0], portRange: '8443' }];
+        expect(validateGceHttpLoadBalancerCommand(command)).toEqual(
+          expect.arrayContaining([
+            'Path matcher default backend service is required.',
+            'HTTPS listeners must use port 443.',
+          ]),
+        );
+        renderWithRouter(<GceHttpLoadBalancerModal {...props} />);
 
         expect(executeTask).not.toHaveBeenCalled();
         expect(closeModal).not.toHaveBeenCalled();
-        expect(wrapper.find('.gce-http-validation-errors').text()).toContain(
-          'Path matcher default backend service is required.',
-        );
-        expect(wrapper.find('.gce-http-validation-errors').text()).toContain('HTTPS listeners must use port 443.');
-        expect(wrapper.find('.btn-primary').prop('disabled')).toBe(true);
+        expect(screen.getByText('Path matcher default backend service is required.')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: submissionMode === 'pipeline' ? 'Done' : 'Create' })).toBeDisabled();
       });
     });
   });
 
   ['pipeline', 'infrastructure'].forEach((submissionMode) => {
     it(`does not submit invalid ${submissionMode} commands`, () => {
-      const closeModal = jasmine.createSpy('closeModal');
-      const executeTask = jasmine.createSpy('executeTask');
+      const closeModal = vi.fn();
+      const executeTask = vi.fn();
       const props = {
         app: application,
         closeModal,
         data: emptyData,
-        dismissModal: jasmine.createSpy('dismissModal'),
+        dismissModal: vi.fn(),
         executeTask,
         forPipelineConfig: submissionMode === 'pipeline',
         loadBalancer: {
@@ -297,30 +398,29 @@ describe('GceHttpLoadBalancerModal', () => {
         },
         mode: submissionMode === 'infrastructure' ? 'create' : undefined,
       } as any;
-      const modal = new GceHttpLoadBalancerModal(props);
-      const wrapper = shallow(<GceHttpLoadBalancerModal {...props} />);
-
-      (modal as any).submit();
+      renderWithRouter(<GceHttpLoadBalancerModal {...props} />);
 
       expect(executeTask).not.toHaveBeenCalled();
       expect(closeModal).not.toHaveBeenCalled();
-      expect(wrapper.find('.gce-http-validation-errors').exists()).toBe(true);
-      expect(wrapper.find('.btn-primary').prop('disabled')).toBe(true);
+      expect(screen.getByText('Name is required.')).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: submissionMode === 'pipeline' ? 'Done' : 'Create' })).toBeDisabled();
     });
   });
 
   it('renders modal controls as non-submit buttons', () => {
-    const wrapper = shallow(
+    const { container } = renderWithRouter(
       <GceHttpLoadBalancerModal
         app={application}
-        closeModal={jasmine.createSpy('closeModal')}
+        closeModal={vi.fn()}
         data={emptyData}
-        dismissModal={jasmine.createSpy('dismissModal')}
+        dismissModal={vi.fn()}
         loadBalancer={{ account: 'account-a', loadBalancerType: 'HTTP', name: 'test-app-main' } as any}
         mode="edit"
       />,
     );
 
-    expect(wrapper.find('button').everyWhere((button) => button.prop('type') === 'button')).toBe(true);
+    expect(
+      Array.from(container.querySelectorAll('button')).every((button) => button.getAttribute('type') === 'button'),
+    ).toBe(true);
   });
 });

package/src/loadBalancer/configure/http/GceHttpLoadBalancerModal.tsx

@@ -43,7 +43,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;
 }
 
@@ -171,7 +171,13 @@ export class GceHttpLoadBalancerModal extends React.Component<
     const validationErrors = validateGceHttpLoadBalancerCommand(command);
     const heading =
       command.mode === 'create'
-        ? `Create ${command.loadBalancerType === 'HTTP' ? 'HTTP(S)' : 'Internal managed HTTP(S)'} load balancer`
+        ? `Create ${
+            command.loadBalancerType === 'INTERNAL_MANAGED'
+              ? 'Internal managed HTTP(S)'
+              : command.loadBalancerType === 'EXTERNAL_MANAGED'
+              ? 'External managed HTTP(S)'
+              : 'HTTP(S)'
+          } load balancer`
         : `Edit ${command.name}`;
 
     return (