@spinnaker/google 2026.3.2 → 2026.4.1

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

@@ -1,9 +1,9 @@
 import React from 'react';
-import { mount, shallow } from 'enzyme';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { UIRouterContext, UIRouterReact } from '@uirouter/react';
 
-import { LoadBalancerWriter, TaskMonitorWrapper } from '@spinnaker/core';
+import { LoadBalancerWriter, TaskReader } from '@spinnaker/core';
 
-import { GceProxyLoadBalancerEditor } from './GceProxyLoadBalancerEditor';
 import {
   GceProxyLoadBalancerModal,
   normalizeGceProxyLoadBalancerCommand,
@@ -13,7 +13,8 @@ import {
 
 describe('GceProxyLoadBalancerModal', () => {
   const application = {
-    loadBalancers: { onNextRefresh: jasmine.createSpy('onNextRefresh'), refresh: jasmine.createSpy('refresh') },
+    getDataSource: vi.fn(),
+    loadBalancers: { onNextRefresh: vi.fn(), refresh: vi.fn() },
     name: 'app',
   } as any;
 
@@ -50,14 +51,14 @@ describe('GceProxyLoadBalancerModal', () => {
 
     expect(command.mode).toBe('edit');
     expect(command.listeners[0]).toEqual(
-      jasmine.objectContaining({
+      expect.objectContaining({
         address: { name: 'removed-address', selfLink: 'projects/test/global/addresses/removed-address' },
         certificate: { name: 'removed-cert', selfLink: 'projects/test/global/sslCertificates/removed-cert' },
         protocol: 'SSL',
       }),
     );
     expect(command.backendServices[0]).toEqual(
-      jasmine.objectContaining({
+      expect.objectContaining({
         affinityCookieTtlSec: 120,
         connectionDrainingTimeoutSec: 30,
         healthCheck: {
@@ -71,7 +72,7 @@ describe('GceProxyLoadBalancerModal', () => {
       }),
     );
     expect(command.healthChecks[0]).toEqual(
-      jasmine.objectContaining({ healthCheckType: 'TCP', name: 'removed-check', port: 443, timeoutSec: 5 }),
+      expect.objectContaining({ healthCheckType: 'TCP', name: 'removed-check', port: 443, timeoutSec: 5 }),
     );
   });
 
@@ -114,10 +115,10 @@ describe('GceProxyLoadBalancerModal', () => {
 
     expect(command.listeners[0].protocol).toBe('SSL');
     expect(payload).toEqual(
-      jasmine.objectContaining({
-        backendService: jasmine.objectContaining({
+      expect.objectContaining({
+        backendService: expect.objectContaining({
           connectionDrainingTimeoutSec: 30,
-          healthCheck: jasmine.objectContaining({
+          healthCheck: expect.objectContaining({
             checkIntervalSec: 15,
             healthCheckType: 'HTTP',
             healthyThreshold: 2,
@@ -175,7 +176,7 @@ describe('GceProxyLoadBalancerModal', () => {
     const payload = serializeGceProxyLoadBalancerCommand(command);
 
     expect(payload).toEqual(
-      jasmine.objectContaining({
+      expect.objectContaining({
         ipProtocol: 'UDP',
         network: 'network-a',
         ports: ['80', '443'],
@@ -187,22 +188,22 @@ describe('GceProxyLoadBalancerModal', () => {
   });
 
   it('returns the operation payload through the modal in pipeline mode without starting a task', () => {
-    const closeModal = jasmine.createSpy('closeModal');
-    const taskMonitor = { submit: jasmine.createSpy('submit') } as any;
+    const closeModal = vi.fn();
+    const taskMonitor = { submit: vi.fn() } as any;
     const command = validCommand('pipeline');
 
     submitGceProxyLoadBalancerCommand(command, { application, closeModal, taskMonitor });
 
-    expect(closeModal).toHaveBeenCalledOnceWith(serializeGceProxyLoadBalancerCommand(command));
+    expect(closeModal).toHaveBeenCalledExactlyOnceWith(serializeGceProxyLoadBalancerCommand(command));
     expect(taskMonitor.submit).not.toHaveBeenCalled();
   });
 
   (['create', 'edit'] as const).forEach((mode) => {
     it(`submits the Clouddriver payload through LoadBalancerWriter in infrastructure ${mode} mode`, () => {
-      const upsert = spyOn(LoadBalancerWriter, 'upsertLoadBalancer').and.returnValue(new Promise(() => {}));
+      const upsert = vi.spyOn(LoadBalancerWriter, 'upsertLoadBalancer').mockReturnValue(new Promise(() => {}));
       let operation: (() => PromiseLike<any>) | undefined;
       const taskMonitor = {
-        submit: jasmine.createSpy('submit').and.callFake((submitOperation: () => PromiseLike<any>) => {
+        submit: vi.fn().mockImplementation((submitOperation: () => PromiseLike<any>) => {
           operation = submitOperation;
         }),
       } as any;
@@ -210,7 +211,7 @@ describe('GceProxyLoadBalancerModal', () => {
 
       submitGceProxyLoadBalancerCommand(command, {
         application,
-        closeModal: jasmine.createSpy('closeModal'),
+        closeModal: vi.fn(),
         taskMonitor,
       });
       operation?.();
@@ -227,11 +228,11 @@ describe('GceProxyLoadBalancerModal', () => {
   it('exposes pipeline support and locks infrastructure identity fields in edit mode', () => {
     expect(GceProxyLoadBalancerModal.supportsPipelineConfig).toBe(true);
     expect(typeof GceProxyLoadBalancerModal.show).toBe('function');
-    const wrapper = shallow(
+    const { container } = render(
       <GceProxyLoadBalancerModal
         app={application}
-        closeModal={jasmine.createSpy('closeModal')}
-        dismissModal={jasmine.createSpy('dismissModal')}
+        closeModal={vi.fn()}
+        dismissModal={vi.fn()}
         isNew={false}
         loadBalancer={
           {
@@ -243,56 +244,50 @@ describe('GceProxyLoadBalancerModal', () => {
           } as any
         }
         loadBalancerType="TCP"
+        readers={resolvedReaders()}
       />,
     );
 
-    expect(wrapper.find(GceProxyLoadBalancerEditor).prop('command').mode).toBe('edit');
-    expect(wrapper.find(GceProxyLoadBalancerEditor).prop('disabled')).toBe(true);
+    expect(screen.getByRole('heading', { name: 'Edit app-main' })).toBeInTheDocument();
+    ['name', 'credentials', 'region'].forEach((field) => expect(fieldControl(container, field)).toBeDisabled());
   });
 
-  it('owns its refresh subscription across replacement and unmount', () => {
-    const firstUnsubscribe = jasmine.createSpy('firstUnsubscribe');
-    const secondUnsubscribe = jasmine.createSpy('secondUnsubscribe');
+  it('owns its refresh subscription through public submission and unmount', async () => {
+    const unsubscribe = vi.fn();
     const callbacks: Array<() => void> = [];
-    const onNextRefresh = jasmine.createSpy('onNextRefresh').and.callFake((callback: () => void) => {
+    const onNextRefresh = vi.fn().mockImplementation((callback: () => void) => {
       callbacks.push(callback);
-      return callbacks.length === 1 ? firstUnsubscribe : secondUnsubscribe;
+      return unsubscribe;
     });
-    const refresh = jasmine.createSpy('refresh');
-    const closeModal = jasmine.createSpy('closeModal');
-    const pending = new Promise<any[]>(() => undefined);
-    const readers = {
-      accounts: () => pending,
-      addresses: () => pending,
-      backendServices: () => pending,
-      certificates: () => pending,
-      healthChecks: () => pending,
-      networks: () => pending,
-      regions: () => pending,
-      subnets: () => pending,
-    };
-    const wrapper = mount(
-      <GceProxyLoadBalancerModal
-        application={{ loadBalancers: { onNextRefresh, refresh }, name: 'app' } as any}
-        closeModal={closeModal}
-        loadBalancerType="TCP"
-        readers={readers}
-      />,
+    const refresh = vi.fn();
+    const closeModal = vi.fn();
+    const task = { id: 'task' } as any;
+    vi.spyOn(LoadBalancerWriter, 'upsertLoadBalancer').mockResolvedValue(task);
+    vi.spyOn(TaskReader, 'waitUntilTaskCompletes').mockResolvedValue(task);
+    const router = new UIRouterReact();
+    const rendered = render(
+      <UIRouterContext.Provider value={router}>
+        <GceProxyLoadBalancerModal
+          application={{ getDataSource: vi.fn(), loadBalancers: { onNextRefresh, refresh }, name: 'app' } as any}
+          closeModal={closeModal}
+          isNew={false}
+          loadBalancer={proxyLoadBalancer()}
+          loadBalancerType="TCP"
+          readers={resolvedReaders()}
+        />
+      </UIRouterContext.Provider>,
     );
-    const taskMonitor = wrapper.find(TaskMonitorWrapper).prop('monitor');
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Update' })).toBeEnabled());
 
-    taskMonitor.config.onTaskComplete();
+    fireEvent.click(screen.getByRole('button', { name: 'Update' }));
+    await waitFor(() => expect(refresh).toHaveBeenCalled());
 
-    expect(onNextRefresh.calls.first().invocationOrder).toBeLessThan(refresh.calls.first().invocationOrder);
+    expect(onNextRefresh.mock.invocationCallOrder[0]).toBeLessThan(refresh.mock.invocationCallOrder[0]);
 
-    taskMonitor.config.onTaskComplete();
+    rendered.unmount();
+    callbacks[0]();
 
-    expect(firstUnsubscribe).toHaveBeenCalledTimes(1);
-
-    wrapper.unmount();
-    callbacks[1]();
-
-    expect(secondUnsubscribe).toHaveBeenCalledTimes(1);
+    expect(unsubscribe).toHaveBeenCalledTimes(1);
     expect(closeModal).not.toHaveBeenCalled();
   });
 });
@@ -311,3 +306,36 @@ function validCommand(mode: 'create' | 'edit' | 'pipeline'): any {
     'TCP',
   );
 }
+
+function proxyLoadBalancer(): any {
+  return {
+    account: 'account-a',
+    backendService: { name: 'app-main', portName: 'tcp', sessionAffinity: 'NONE' },
+    healthChecks: [{ healthCheckType: 'TCP', name: 'check-a', port: 443 }],
+    loadBalancerType: 'TCP',
+    name: 'app-main',
+    portRange: '443',
+    region: 'global',
+  };
+}
+
+function fieldControl(container: HTMLElement, name: string): HTMLInputElement | HTMLSelectElement {
+  const control = container.querySelector(`[data-field="${name}"] input, [data-field="${name}"] select`);
+  if (!(control instanceof HTMLInputElement || control instanceof HTMLSelectElement)) {
+    throw new Error(`No control found for ${name}`);
+  }
+  return control;
+}
+
+function resolvedReaders(): any {
+  return {
+    accounts: () => Promise.resolve([]),
+    addresses: () => Promise.resolve([]),
+    backendServices: () => Promise.resolve([]),
+    certificates: () => Promise.resolve([]),
+    healthChecks: () => Promise.resolve([]),
+    networks: () => Promise.resolve([]),
+    regions: () => Promise.resolve([]),
+    subnets: () => Promise.resolve([]),
+  };
+}

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

@@ -1,3 +1,4 @@
+import type { Mocked } from 'vitest';
 import {
   GceLoadBalancerDataController,
   IGceLoadBalancerDataReaders,
@@ -39,7 +40,7 @@ describe('GCE load balancer data', () => {
     const first = deferred<unknown[]>();
     const second = deferred<unknown[]>();
     const readers = testReaders();
-    readers.regions.and.callFake((account: string) => (account === 'first' ? first.promise : second.promise));
+    readers.regions.mockImplementation((account: string) => (account === 'first' ? first.promise : second.promise));
     const controller = new GceLoadBalancerDataController(readers);
 
     const firstLoad = controller.load('first');
@@ -56,7 +57,7 @@ describe('GCE load balancer data', () => {
   it('reports an error from the latest request', async () => {
     const readers = testReaders();
     const failure = new Error('regions failed');
-    readers.regions.and.returnValue(Promise.reject(failure));
+    readers.regions.mockReturnValue(Promise.reject(failure));
     const controller = new GceLoadBalancerDataController(readers);
 
     await controller.load('test-account');
@@ -68,13 +69,13 @@ describe('GCE load balancer data', () => {
   it('does not publish responses after disposal', async () => {
     const pendingRegions = deferred<unknown[]>();
     const readers = testReaders();
-    readers.regions.and.returnValue(pendingRegions.promise);
+    readers.regions.mockReturnValue(pendingRegions.promise);
     const controller = new GceLoadBalancerDataController(readers);
-    const listener = jasmine.createSpy('listener');
+    const listener = vi.fn();
     controller.subscribe(listener);
 
     const loading = controller.load('test-account');
-    listener.calls.reset();
+    listener.mockClear();
     controller.dispose();
     pendingRegions.resolve([{ name: 'late-region' }]);
     await loading;
@@ -97,17 +98,17 @@ describe('GCE load balancer data', () => {
   });
 });
 
-function testReaders(): jasmine.SpyObj<IGceLoadBalancerDataReaders> {
-  return jasmine.createSpyObj<IGceLoadBalancerDataReaders>('readers', {
-    accounts: Promise.resolve([{ name: 'test-account' }]),
-    addresses: Promise.resolve([{ name: 'address' }]),
-    backendServices: Promise.resolve([{ name: 'backend' }]),
-    certificates: Promise.resolve([{ name: 'certificate' }]),
-    healthChecks: Promise.resolve([{ name: 'check' }]),
-    networks: Promise.resolve([{ name: 'network' }]),
-    regions: Promise.resolve([{ name: 'europe-west1' }]),
-    subnets: Promise.resolve([{ name: 'subnet' }]),
-  });
+function testReaders(): Mocked<IGceLoadBalancerDataReaders> {
+  return ({
+    accounts: vi.fn().mockReturnValue(Promise.resolve([{ name: 'test-account' }])),
+    addresses: vi.fn().mockReturnValue(Promise.resolve([{ name: 'address' }])),
+    backendServices: vi.fn().mockReturnValue(Promise.resolve([{ name: 'backend' }])),
+    certificates: vi.fn().mockReturnValue(Promise.resolve([{ name: 'certificate' }])),
+    healthChecks: vi.fn().mockReturnValue(Promise.resolve([{ name: 'check' }])),
+    networks: vi.fn().mockReturnValue(Promise.resolve([{ name: 'network' }])),
+    regions: vi.fn().mockReturnValue(Promise.resolve([{ name: 'europe-west1' }])),
+    subnets: vi.fn().mockReturnValue(Promise.resolve([{ name: 'subnet' }])),
+  } as unknown) as Mocked<IGceLoadBalancerDataReaders>;
 }
 
 function deferred<T>() {

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

@@ -19,14 +19,23 @@ describe('GCE load balancer models', () => {
     );
 
     expect(serializeGceLoadBalancerCommand(command)).toEqual(
-      jasmine.objectContaining({
-        healthChecks: [jasmine.objectContaining({ healthCheckType: 'GRPC', grpcServiceName: 'example.Health' })],
-        listeners: [jasmine.objectContaining({ certificateMap: 'shared-map' })],
+      expect.objectContaining({
+        healthChecks: [expect.objectContaining({ healthCheckType: 'GRPC', grpcServiceName: 'example.Health' })],
+        listeners: [expect.objectContaining({ certificateMap: 'shared-map' })],
       }),
     );
   });
   it('defines capabilities for every supported load balancer type', () => {
-    expect(GCE_LOAD_BALANCER_TYPES).toEqual(['NETWORK', 'INTERNAL', 'TCP', 'SSL', 'HTTP', 'INTERNAL_MANAGED']);
+    expect(GCE_LOAD_BALANCER_TYPES).toEqual([
+      'NETWORK',
+      'INTERNAL',
+      'TCP',
+      'SSL',
+      'HTTP',
+      'INTERNAL_MANAGED',
+      'EXTERNAL_MANAGED',
+      'REGIONAL_EXTERNAL_NETWORK',
+    ]);
     expect(Object.keys(GCE_LOAD_BALANCER_CAPABILITIES)).toEqual(GCE_LOAD_BALANCER_TYPES);
     expect(GCE_LOAD_BALANCER_CAPABILITIES.NETWORK).toEqual({
       address: true,
@@ -359,7 +368,7 @@ describe('GCE load balancer models', () => {
     );
 
     expect(command.healthChecks).toEqual([
-      jasmine.objectContaining({
+      expect.objectContaining({
         checkIntervalSec: 15,
         healthCheckType: 'HTTP',
         healthyThreshold: 2,
@@ -387,6 +396,222 @@ describe('GCE load balancer models', () => {
 
     expect(command.healthChecks).toEqual([{ healthCheckType: 'HTTP', port: 53, requestPath: '/health' }]);
   });
+
+  it('normalizes and serializes EXTERNAL_MANAGED with regional scope, network, address, tier, and certificate', () => {
+    const regionalCertUrl =
+      '//certificatemanager.googleapis.com/projects/test/locations/europe-west1/certificates/regional-cert';
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendServices: [
+          {
+            healthCheck: 'projects/test/regions/europe-west1/healthChecks/check-a',
+            name: 'backend-a',
+          },
+        ],
+        defaultService: 'backend-a',
+        healthChecks: [{ healthCheckType: 'HTTP', name: 'check-a', port: 80, requestPath: '/health' }],
+        listeners: [
+          {
+            certificate: regionalCertUrl,
+            ipAddress: '203.0.113.10',
+            name: 'app-https',
+            networkTier: 'STANDARD',
+            port: 443,
+            protocol: 'HTTPS',
+          },
+        ],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-main',
+        network: 'projects/test/global/networks/network-a',
+        region: 'europe-west1',
+        urlMapName: 'app-main',
+      },
+      'edit',
+    );
+
+    expect(command.loadBalancerType).toBe('EXTERNAL_MANAGED');
+    expect(command.region).toBe('europe-west1');
+    expect(command.network).toEqual({
+      name: 'network-a',
+      selfLink: 'projects/test/global/networks/network-a',
+    });
+    expect(command.listeners).toEqual([
+      {
+        address: { name: '203.0.113.10' },
+        certificate: { name: 'regional-cert', selfLink: regionalCertUrl },
+        name: 'app-https',
+        networkTier: 'STANDARD',
+        portRange: '443',
+        protocol: 'HTTPS',
+      },
+    ]);
+    expect(command.listeners[0].certificateMap).toBeUndefined();
+
+    const serialized = serializeGceLoadBalancerCommand(command);
+    expect(serialized).toEqual(
+      expect.objectContaining({
+        credentials: 'account-a',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        network: 'network-a',
+        region: 'europe-west1',
+      }),
+    );
+    expect(serialized.listeners).toEqual([
+      {
+        certificate: regionalCertUrl,
+        ipAddress: '203.0.113.10',
+        name: 'app-https',
+        networkTier: 'STANDARD',
+        portRange: '443',
+        protocol: 'HTTPS',
+      },
+    ]);
+    expect((serialized.listeners as any[])[0].certificateMap).toBeUndefined();
+  });
+
+  it('preserves EXTERNAL_MANAGED listener identity from a flat pipeline operation', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        certificate:
+          '//certificatemanager.googleapis.com/projects/test/locations/europe-west1/certificates/regional-cert',
+        credentials: 'account-a',
+        ipAddress: '203.0.113.10',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-https',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-https',
+        network: 'network-a',
+        networkTier: 'STANDARD',
+        portRange: '443',
+        region: 'europe-west1',
+        urlMapName: 'app-main',
+      },
+      'pipeline',
+    );
+
+    expect(command.name).toBe('app-main');
+    expect(command.listeners).toEqual([
+      {
+        address: { name: '203.0.113.10' },
+        certificate: {
+          name: 'regional-cert',
+          selfLink:
+            '//certificatemanager.googleapis.com/projects/test/locations/europe-west1/certificates/regional-cert',
+        },
+        name: 'app-https',
+        networkTier: 'STANDARD',
+        portRange: '443',
+        protocol: 'HTTPS',
+      },
+    ]);
+  });
+
+  it('preserves REGIONAL_EXTERNAL_NETWORK port text for validation and source immutability', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendService: {
+          healthCheck: { healthCheckType: 'TCP', name: 'tcp-check', port: 80 },
+          name: 'app-main',
+          sessionAffinity: 'CLIENT_IP',
+        },
+        ipAddress: '35.1.2.3',
+        ipProtocol: 'TCP',
+        loadBalancerName: 'app-main',
+        loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK',
+        networkTier: 'PREMIUM',
+        ports: ['80', ' 443 '],
+        region: 'europe-west1',
+      },
+      'edit',
+    );
+
+    expect(command.loadBalancerType).toBe('REGIONAL_EXTERNAL_NETWORK');
+    expect(command.listeners).toEqual([
+      {
+        address: { name: '35.1.2.3' },
+        name: 'app-main',
+        portRange: '80, 443 ',
+        protocol: 'TCP',
+      },
+    ]);
+    expect(command.networkTier).toBe('PREMIUM');
+    expect(command.backendServices).toEqual([
+      {
+        healthCheck: { healthCheckType: 'TCP', name: 'tcp-check', port: 80 },
+        name: 'app-main',
+        sessionAffinity: 'CLIENT_IP',
+      },
+    ]);
+    expect(command.original).toEqual({
+      backendServices: command.backendServices,
+      healthChecks: command.healthChecks,
+      listeners: command.listeners,
+    });
+
+    command.listeners[0].protocol = 'UDP';
+    command.backendServices[0].sessionAffinity = 'CLIENT_IP_PROTO';
+
+    expect(command.original?.listeners[0].protocol).toBe('TCP');
+    expect(command.original?.backendServices[0].sessionAffinity).toBe('CLIENT_IP');
+
+    const serialized = serializeGceLoadBalancerCommand(command);
+    expect(serialized).toEqual({
+      backendService: {
+        healthCheck: { healthCheckType: 'TCP', name: 'tcp-check', port: 80 },
+        name: 'app-main',
+        sessionAffinity: 'CLIENT_IP_PROTO',
+      },
+      cloudProvider: 'gce',
+      credentials: 'account-a',
+      ipAddress: '35.1.2.3',
+      ipProtocol: 'UDP',
+      loadBalancerName: 'app-main',
+      loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK',
+      name: 'app-main',
+      networkTier: 'PREMIUM',
+      ports: ['80', ' 443 '],
+      provider: 'gce',
+      region: 'europe-west1',
+      type: 'upsertLoadBalancer',
+    });
+    expect(serialized.portRange).toBeUndefined();
+    expect(serialized.backendServices).toBeUndefined();
+  });
+
+  (['HTTP', 'INTERNAL_MANAGED'] as const).forEach((loadBalancerType) => {
+    it(`normalizes and serializes ${loadBalancerType} without listener networkTier`, () => {
+      const command = normalizeGceLoadBalancerCommand(
+        {
+          account: 'account-a',
+          listeners: [
+            {
+              ipAddress: '203.0.113.10',
+              name: 'frontend',
+              networkTier: 'STANDARD',
+              port: 80,
+              protocol: 'HTTP',
+            },
+          ],
+          loadBalancerType,
+          name: 'web',
+          network: loadBalancerType === 'INTERNAL_MANAGED' ? 'network-a' : undefined,
+          networkTier: 'STANDARD',
+          region: loadBalancerType === 'INTERNAL_MANAGED' ? 'europe-west1' : 'global',
+          subnet: loadBalancerType === 'INTERNAL_MANAGED' ? 'subnet-a' : undefined,
+        },
+        'create',
+      );
+
+      expect(command.listeners[0].networkTier).toBeUndefined();
+      expect(command.networkTier).toBeUndefined();
+
+      const serialized = serializeGceLoadBalancerCommand(command);
+      expect(serialized.networkTier).toBeUndefined();
+      expect((serialized.listeners as any[])[0].networkTier).toBeUndefined();
+    });
+  });
 });
 
 function readerHealthCheck() {