@spinnaker/core 2026.2.2 → 2026.3.0

package/src/managed/ManagedReader.ts

@@ -81,11 +81,11 @@ export class ManagedReader {
     return response;
   }
 
-  public static getApplicationSummary(app: string): PromiseLike<IManagedApplicationSummary<'resources'>> {
+  public static getApplicationSummary(app: string): Promise<IManagedApplicationSummary<'resources'>> {
     return REST('/managed/application').path(app).query({ entities: 'resources' }).get().then(this.decorateResources);
   }
 
-  public static getResourceHistory(resourceId: string): PromiseLike<IManagedResourceEventHistory> {
+  public static getResourceHistory(resourceId: string): Promise<IManagedResourceEventHistory> {
     return REST('/history')
       .path(resourceId)
       .query({ limit: 100 })

package/src/managed/ManagedWriter.ts

@@ -1,10 +1,10 @@
 import { REST } from '../api';
 export class ManagedWriter {
-  public static pauseResourceManagement(resourceId: string): PromiseLike<void> {
+  public static pauseResourceManagement(resourceId: string): Promise<void> {
     return REST('/managed/resources').path(resourceId, 'pause').post();
   }
 
-  public static resumeResourceManagement(resourceId: string): PromiseLike<void> {
+  public static resumeResourceManagement(resourceId: string): Promise<void> {
     return REST('/managed/resources').path(resourceId, 'pause').delete();
   }
 }

package/src/managed/externals/ManagedMenuItem.tsx

@@ -1,4 +1,3 @@
-import { $q } from 'ngimport';
 import React from 'react';
 import { MenuItem } from 'react-bootstrap';
 
@@ -23,7 +22,7 @@ export const ManagedMenuItem = ({ resource, application, onClick, children }: IM
   const appIsPaused = application.isManagementPaused;
   const showInterstitial = resource.isManaged && !resourceIsPaused && !appIsPaused;
   const interstitial: () => PromiseLike<boolean> = () =>
-    showInterstitial ? confirmNotManaged(resource, application) : $q.when(true);
+    showInterstitial ? confirmNotManaged(resource, application) : Promise.resolve(true);
   const handleClick: () => void = () =>
     interstitial().then((isNotManaged) => {
       isNotManaged && onClick?.();

package/src/managed/externals/ManagedResourceConfig.tsx

@@ -1,8 +1,6 @@
 import { ApolloProvider } from '@apollo/client';
-import { module } from 'angular';
 import classNames from 'classnames';
 import React from 'react';
-import { react2angular } from 'react2angular';
 
 import type { Application } from '../../application';
 import { createApolloClient } from '../graphql/client';
@@ -11,7 +9,6 @@ import {
   useFetchApplicationManagementStatusQuery,
   useToggleManagementMutation,
 } from '../graphql/graphql-sdk';
-import { withErrorBoundary } from '../../presentation/SpinErrorBoundary';
 import { ValidationMessage } from '../../presentation/forms/validation';
 import { logger } from '../../utils';
 import { getDocsUrl } from '../utils/defaults';
@@ -104,7 +101,7 @@ const ManagedResourceConfigInternal = ({ application }: IManagedResourceConfigPr
   );
 };
 
-const ManagedResourceConfig = (props: IManagedResourceConfigProps) => {
+export const ManagedResourceConfig = (props: IManagedResourceConfigProps) => {
   const { client } = React.useMemo(createApolloClient, []);
 
   return (
@@ -113,9 +110,3 @@ const ManagedResourceConfig = (props: IManagedResourceConfigProps) => {
     </ApolloProvider>
   );
 };
-
-export const MANAGED_RESOURCE_CONFIG = 'spinnaker.core.managedResourceConfig.component';
-module(MANAGED_RESOURCE_CONFIG, []).component(
-  'managedResourceConfig',
-  react2angular(withErrorBoundary(ManagedResourceConfig, 'managedResourceConfig'), ['application']),
-);

package/src/managed/externals/ManagedResourceDetailsIndicator.tsx

@@ -1,3 +1,4 @@
+import { useRouter } from '@uirouter/react';
 import React from 'react';
 import { Dropdown, MenuItem } from 'react-bootstrap';
 
@@ -7,7 +8,6 @@ import type { IManagedResourceSummary } from '../../domain';
 import { HelpField } from '../../help';
 import managedDeliveryLogo from '../icons/md-logo-color.svg';
 import { HoverablePopover } from '../../presentation';
-import { ReactInjector } from '../../reactShims';
 import { showManagedResourceHistoryModal } from '../resourceHistory/ManagedResourceHistoryModal';
 import { toggleResourcePause } from './toggleResourceManagement';
 import { logger } from '../../utils/Logger';
@@ -31,6 +31,7 @@ export const ManagedResourceDetailsIndicator = ({
   resourceSummary,
   application,
 }: IManagedResourceDetailsIndicatorProps) => {
+  const { stateService } = useRouter();
   if (!resourceSummary) {
     return null;
   }
@@ -63,7 +64,7 @@ export const ManagedResourceDetailsIndicator = ({
   const appPausedHelpContent = `
     <p>Resource management is currently disabled for the entire application.
     <a
-      href=${ReactInjector.$state.href('home.applications.application.config', {
+      href=${stateService.href('home.applications.application.config', {
         section: 'managed-resources',
       })}
     >

package/src/managed/externals/toggleResourceManagement.tsx

@@ -1,4 +1,3 @@
-import { $q } from 'ngimport';
 import React from 'react';
 
 import { ManagedWriter } from '../ManagedWriter';
@@ -17,10 +16,10 @@ import './ManagedResourceStatusIndicator.less';
  * @param resource
  * @param application
  */
-export const confirmNotManaged = (resource: IManagedResource, application: Application): PromiseLike<boolean> => {
+export const confirmNotManaged = (resource: IManagedResource, application: Application): Promise<boolean> => {
   const { managedResourceSummary, isManaged } = resource;
   if (!isManaged || !managedResourceSummary || managedResourceSummary.isPaused) {
-    return $q.when(true);
+    return Promise.resolve(true);
   }
   const submitMethod = () => {
     return ManagedWriter.pauseResourceManagement(managedResourceSummary.id).then(() =>

package/src/managed/index.ts

@@ -2,11 +2,9 @@ export * from './externals/DeployingIntoManagedClusterWarning';
 export * from './externals/ManagedMenuItem';
 export * from './externals/managedResourceDecorators';
 export * from './externals/ManagedResourceDetailsIndicator';
-export * from './externals/managedResourceDetailsIndicator.component';
 export * from './externals/ManagedResourceStatusIndicator';
 export * from './externals/toggleResourceManagement';
 export * from './managed.dataSource';
-export * from './managed.module';
 export * from './ManagedReader';
 export * from './ManagedWriter';
 export * from './plugins/index';

package/src/managed/managed.dataSource.ts

@@ -1,6 +1,3 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
-
 import { ManagedReader } from './ManagedReader';
 import type { Application } from '../application';
 import { DELIVERY_KEY } from '../application';
@@ -14,54 +11,52 @@ import {
 } from './externals/managedResourceDecorators';
 import { noop } from '../utils';
 
-export const MANAGED_RESOURCES_DATA_SOURCE = 'spinnaker.core.managed.dataSource';
-module(MANAGED_RESOURCES_DATA_SOURCE, []).run([
-  '$q',
-  ($q: IQService) => {
-    if (!SETTINGS.feature.managedResources) {
-      return;
-    }
-    const loadManagedResources = (application: Application) => {
-      return ManagedReader.getApplicationSummary(application.name);
-    };
+export function registerManagedResourcesDataSources(): void {
+  if (!SETTINGS.feature.managedResources) {
+    return;
+  }
+  const loadManagedResources = (application: Application) => {
+    return ManagedReader.getApplicationSummary(application.name);
+  };
+
+  const addManagedResources = (application: Application, data: IManagedApplicationSummary) => {
+    application.isManagementPaused = data.applicationPaused;
+    return Promise.resolve(data);
+  };
 
-    const addManagedResources = (application: Application, data: IManagedApplicationSummary) => {
-      application.isManagementPaused = data.applicationPaused;
-      return $q.when(data);
-    };
+  const addManagedMetadataToResources = (application: Application) => {
+    application.serverGroups.ready().then(() => addManagedResourceMetadataToServerGroups(application), noop);
+    application.loadBalancers.ready().then(() => addManagedResourceMetadataToLoadBalancers(application), noop);
+    application.securityGroups.ready().then(() => addManagedResourceMetadataToSecurityGroups(application), noop);
+  };
 
-    const addManagedMetadataToResources = (application: Application) => {
-      application.serverGroups.ready().then(() => addManagedResourceMetadataToServerGroups(application), noop);
-      application.loadBalancers.ready().then(() => addManagedResourceMetadataToLoadBalancers(application), noop);
-      application.securityGroups.ready().then(() => addManagedResourceMetadataToSecurityGroups(application), noop);
-    };
+  ApplicationDataSourceRegistry.registerDataSource({
+    key: 'managedResources',
+    visible: false,
+    loader: loadManagedResources,
+    onLoad: addManagedResources,
+    afterLoad: addManagedMetadataToResources,
+    defaultData: { applicationPaused: false, hasManagedResources: false, resources: [] },
+  });
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'managedResources',
-      visible: false,
-      loader: loadManagedResources,
-      onLoad: addManagedResources,
-      afterLoad: addManagedMetadataToResources,
-      defaultData: { applicationPaused: false, hasManagedResources: false, resources: [] },
-    });
+  ApplicationDataSourceRegistry.registerDataSource({
+    key: 'environments',
+    sref: '.environments',
+    category: DELIVERY_KEY,
+    optional: true,
+    optIn: true,
+    label: 'Environments',
+    icon: 'fa fa-fw fa-xs fa-code-branch',
+    iconName: 'spEnvironments',
+    description: 'Artifacts and environments managed by Spinnaker',
+    defaultData: {
+      applicationPaused: false,
+      hasManagedResources: false,
+      environments: [],
+      artifacts: [],
+      resources: [],
+    },
+  });
+}
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'environments',
-      sref: '.environments',
-      category: DELIVERY_KEY,
-      optional: true,
-      optIn: true,
-      label: 'Environments',
-      icon: 'fa fa-fw fa-xs fa-code-branch',
-      iconName: 'spEnvironments',
-      description: 'Artifacts and environments managed by Spinnaker',
-      defaultData: {
-        applicationPaused: false,
-        hasManagedResources: false,
-        environments: [],
-        artifacts: [],
-        resources: [],
-      },
-    });
-  },
-]);
+registerManagedResourcesDataSources();

package/src/managed/managed.states.ts

@@ -1,8 +1,6 @@
-import { module } from 'angular';
-
 import { Environments } from './Environments';
 import type { ApplicationStateProvider } from '../application/application.state.provider';
-import { APPLICATION_STATE_PROVIDER } from '../application/application.state.provider';
+import { registerApplicationState } from '../application/applicationState.registration';
 import { SETTINGS } from '../config';
 import { Configuration } from './config/Configuration';
 import type { INestedState } from '../navigation/state.provider';
@@ -54,44 +52,40 @@ const routes: Array<INestedState & { name: Routes }> = [
   },
 ];
 
-export const MANAGED_STATES = 'spinnaker.core.managed.states';
-module(MANAGED_STATES, [APPLICATION_STATE_PROVIDER]).config([
-  'applicationStateProvider',
-  (applicationStateProvider: ApplicationStateProvider) => {
-    if (SETTINGS.feature.managedDelivery) {
-      const artifactVersion: INestedState = {
-        name: 'artifactVersion',
-        url: `/{reference}/{version}`,
-        params: {
-          reference: { dynamic: true },
-          version: { dynamic: true },
-        },
-        children: [],
-        redirectTo: (transition) => {
-          // This is needed for links to the old UI
-          return transition.targetState().withState('home.applications.application.environments.history');
-        },
-      };
+registerApplicationState((applicationStateProvider: ApplicationStateProvider) => {
+  if (SETTINGS.feature.managedDelivery) {
+    const artifactVersion: INestedState = {
+      name: 'artifactVersion',
+      url: `/{reference}/{version}`,
+      params: {
+        reference: { dynamic: true },
+        version: { dynamic: true },
+      },
+      children: [],
+      redirectTo: (transition) => {
+        // This is needed for links to the old UI
+        return transition.targetState().withState('home.applications.application.environments.history');
+      },
+    };
 
-      const environments: INestedState = {
-        name: 'environments',
-        url: `/environments?{md_debug:query}`,
-        views: {
-          insight: { component: Environments, $type: 'react' },
-        },
-        data: {
-          pageTitleSection: {
-            title: 'Environments',
-          },
-        },
-        children: [artifactVersion, ...routes],
-        redirectTo: (transition) => {
-          // This is needed for links to the old UI
-          return transition.targetState().withState('home.applications.application.environments.overview');
+    const environments: INestedState = {
+      name: 'environments',
+      url: `/environments?{md_debug:query}`,
+      views: {
+        insight: { component: Environments, $type: 'react' },
+      },
+      data: {
+        pageTitleSection: {
+          title: 'Environments',
         },
-      };
+      },
+      children: [artifactVersion, ...routes],
+      redirectTo: (transition) => {
+        // This is needed for links to the old UI
+        return transition.targetState().withState('home.applications.application.environments.overview');
+      },
+    };
 
-      applicationStateProvider.addChildState(environments);
-    }
-  },
-]);
+    applicationStateProvider.addChildState(environments);
+  }
+});

package/src/managed/useEnvironmentTypeFromResources.hooks.ts

@@ -1,5 +1,4 @@
 import { uniq } from 'lodash';
-import { $q } from 'ngimport';
 
 import { AccountService } from '../account';
 import type { IManagedResourceSummary } from '../domain';
@@ -9,9 +8,9 @@ export const useEnvironmentTypeFromResources = (resources: IManagedResourceSumma
   const accountNames = uniq(resources.map((resource) => resource?.locations?.account).filter(Boolean));
   return useData<boolean>(
     () =>
-      $q
-        .all(accountNames.map((accountName) => AccountService.challengeDestructiveActions(accountName)))
-        .then((result) => result.some((value) => !!value)),
+      Promise.all(
+        accountNames.map((accountName) => AccountService.challengeDestructiveActions(accountName)),
+      ).then((result) => result.some((value) => !!value)),
     false,
     [accountNames.sort().join()],
   ).result;

package/src/manifest/ManifestReader.ts

@@ -2,7 +2,7 @@ import { REST } from '../api/ApiService';
 import type { IManifest } from '../domain';
 
 export class ManifestReader {
-  public static getManifest(account: string, location: string, name: string): PromiseLike<IManifest> {
+  public static getManifest(account: string, location: string, name: string): Promise<IManifest> {
     return REST('/manifests').path(account, location, name).get();
   }
 }

package/src/manifest/ManifestWriter.ts

@@ -3,7 +3,7 @@ import type { ITask } from '../domain';
 import { TaskExecutor } from '../task/taskExecutor';
 
 export class ManifestWriter {
-  public static deployManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static deployManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Deploy manifest';
     command.type = 'deployManifest';
     return TaskExecutor.executeTask({
@@ -13,7 +13,7 @@ export class ManifestWriter {
     });
   }
 
-  public static deleteManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static deleteManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Delete manifest';
     command.type = 'deleteManifest';
     return TaskExecutor.executeTask({
@@ -23,7 +23,7 @@ export class ManifestWriter {
     });
   }
 
-  public static scaleManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static scaleManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Scale manifest';
     command.type = 'scaleManifest';
     return TaskExecutor.executeTask({
@@ -33,7 +33,7 @@ export class ManifestWriter {
     });
   }
 
-  public static undoRolloutManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static undoRolloutManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Undo rollout of manifest';
     command.type = 'undoRolloutManifest';
     return TaskExecutor.executeTask({
@@ -43,7 +43,7 @@ export class ManifestWriter {
     });
   }
 
-  public static resumeRolloutManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static resumeRolloutManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Resume rollout of manifest';
     command.type = 'resumeRolloutManifest';
     return TaskExecutor.executeTask({
@@ -53,7 +53,7 @@ export class ManifestWriter {
     });
   }
 
-  public static pauseRolloutManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static pauseRolloutManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Pause rollout of manifest';
     command.type = 'pauseRolloutManifest';
     return TaskExecutor.executeTask({
@@ -63,7 +63,7 @@ export class ManifestWriter {
     });
   }
 
-  public static rollingRestartManifest(command: any, application: Application): PromiseLike<ITask> {
+  public static rollingRestartManifest(command: any, application: Application): Promise<ITask> {
     const description = 'Rolling restart of manifest';
     command.type = 'rollingRestartManifest';
     return TaskExecutor.executeTask({

package/src/manifest/stage/JobManifestPodLogs.spec.tsx

@@ -0,0 +1,197 @@
+import { mount, shallow } from 'enzyme';
+import React from 'react';
+
+import { JobManifestPodLogs } from './JobManifestPodLogs';
+import { InstanceReader } from '../../instance/InstanceReader';
+import { SETTINGS } from '../../config/settings';
+import type { IPodNameProvider } from '../PodNameProvider';
+
+const makeProvider = (name: string): IPodNameProvider => ({ getPodName: () => name });
+
+const mockConsoleOutput = {
+  output: [
+    { name: 'main', output: 'log line 1' },
+    { name: 'sidecar', output: 'log line 2' },
+  ],
+};
+
+const defaultProps = {
+  account: 'test-account',
+  location: 'test-namespace',
+  linkName: 'Console Output',
+  podNamesProviders: [makeProvider('test-pod')],
+};
+
+// Flush promise queue including chained .then() callbacks
+const flushPromises = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe('JobManifestPodLogs', () => {
+  let getConsoleOutputSpy: jasmine.Spy;
+
+  beforeEach(() => {
+    getConsoleOutputSpy = spyOn(InstanceReader, 'getConsoleOutput').and.returnValue(Promise.resolve(mockConsoleOutput));
+    SETTINGS.consoleLogRefreshIntervalMs = 30000;
+  });
+
+  afterEach(() => {
+    SETTINGS.resetToOriginal();
+    try {
+      jasmine.clock().uninstall();
+    } catch (_) {}
+  });
+
+  describe('rendering', () => {
+    it('renders the link when all pod names are available', () => {
+      const wrapper = shallow(<JobManifestPodLogs {...defaultProps} />);
+      expect(wrapper.find('a.clickable').text()).toBe('Console Output');
+    });
+
+    it('renders nothing when a pod name is empty', () => {
+      const wrapper = shallow(<JobManifestPodLogs {...defaultProps} podNamesProviders={[makeProvider('')]} />);
+      expect(wrapper.isEmptyRender()).toBe(true);
+    });
+  });
+
+  describe('manual refresh', () => {
+    it('fetches logs when the link is clicked', () => {
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      expect(getConsoleOutputSpy).toHaveBeenCalledWith('test-account', 'test-namespace', 'pod test-pod', 'kubernetes');
+      wrapper.unmount();
+    });
+
+    it('stores container logs in state after logs load', async () => {
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      const instance = wrapper.instance() as JobManifestPodLogs;
+      expect(instance.state.containerLogs.length).toBe(2);
+      expect(instance.state.containerLogs[0].name).toBe('main');
+      expect(instance.state.containerLogs[1].name).toBe('sidecar');
+      wrapper.unmount();
+    });
+
+    it('re-fetches logs when refresh() is called directly', async () => {
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      getConsoleOutputSpy.calls.reset();
+      (wrapper.instance() as JobManifestPodLogs).refresh();
+      expect(getConsoleOutputSpy).toHaveBeenCalledTimes(1);
+      wrapper.unmount();
+    });
+
+    it('preserves the selected tab across refreshes', async () => {
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      const instance = wrapper.instance() as JobManifestPodLogs;
+      // Select second tab
+      instance.selectLog(instance.state.containerLogs[1]);
+      wrapper.update();
+      expect(instance.state.selectedContainerLog.name).toBe('sidecar');
+
+      // Refresh — selected tab should be preserved
+      instance.refresh();
+      await flushPromises();
+      wrapper.update();
+      expect(instance.state.selectedContainerLog.name).toBe('sidecar');
+      wrapper.unmount();
+    });
+  });
+
+  describe('auto-refresh toggle', () => {
+    it('sets autoRefresh state to true when toggleAutoRefresh is called', async () => {
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      const instance = wrapper.instance() as JobManifestPodLogs;
+      expect(instance.state.autoRefresh).toBe(false);
+      instance.toggleAutoRefresh();
+      wrapper.update();
+      expect(instance.state.autoRefresh).toBe(true);
+      instance.toggleAutoRefresh(); // clean up timer
+      wrapper.unmount();
+    });
+
+    it('registers a setInterval with the configured refresh interval when auto-refresh is enabled', async () => {
+      const setIntervalSpy = spyOn(window, 'setInterval').and.callThrough();
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      (wrapper.instance() as JobManifestPodLogs).toggleAutoRefresh();
+
+      expect(setIntervalSpy).toHaveBeenCalledWith(jasmine.any(Function), 30000);
+      (wrapper.instance() as JobManifestPodLogs).toggleAutoRefresh(); // clean up
+      wrapper.unmount();
+    });
+
+    it('clears interval when auto-refresh is toggled off', async () => {
+      const clearIntervalSpy = spyOn(window, 'clearInterval').and.callThrough();
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      const instance = wrapper.instance() as JobManifestPodLogs;
+      instance.toggleAutoRefresh(); // on
+      instance.toggleAutoRefresh(); // off
+
+      expect(clearIntervalSpy).toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('clears interval when modal is closed', async () => {
+      const clearIntervalSpy = spyOn(window, 'clearInterval').and.callThrough();
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      const instance = wrapper.instance() as JobManifestPodLogs;
+      instance.toggleAutoRefresh();
+      instance.close();
+
+      expect(clearIntervalSpy).toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('clears interval on unmount', async () => {
+      const clearIntervalSpy = spyOn(window, 'clearInterval').and.callThrough();
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      (wrapper.instance() as JobManifestPodLogs).toggleAutoRefresh();
+      wrapper.unmount();
+
+      expect(clearIntervalSpy).toHaveBeenCalled();
+    });
+
+    it('respects consoleLogRefreshIntervalMs setting', async () => {
+      SETTINGS.consoleLogRefreshIntervalMs = 5000;
+      const setIntervalSpy = spyOn(window, 'setInterval').and.callThrough();
+      const wrapper = mount(<JobManifestPodLogs {...defaultProps} />);
+      wrapper.find('a.clickable').simulate('click');
+      await flushPromises();
+      wrapper.update();
+
+      (wrapper.instance() as JobManifestPodLogs).toggleAutoRefresh();
+
+      expect(setIntervalSpy).toHaveBeenCalledWith(jasmine.any(Function), 5000);
+      (wrapper.instance() as JobManifestPodLogs).toggleAutoRefresh(); // clean up
+      wrapper.unmount();
+    });
+  });
+});