@spinnaker/core 2026.2.2 → 2026.3.0

package/src/task/task.dataSource.spec.ts

@@ -1,52 +1,59 @@
-import type { IQService } from 'angular';
-import { mock } from 'angular';
-
 import type { Application } from '../application/application.model';
 import { ApplicationModelBuilder } from '../application/applicationModel.builder';
 import { ApplicationDataSourceRegistry } from '../application/service/ApplicationDataSourceRegistry';
+import { registerTaskDataSources } from './task.dataSource';
 import { TaskReader } from './task.read.service';
 
 describe('Task Data Source', function () {
-  let application: Application, $scope: any, $q: IQService;
+  const promiseService = { resolve: <T>(value: T | PromiseLike<T>) => Promise.resolve(value) };
+  let application: Application;
+
+  beforeEach(() => {
+    ApplicationDataSourceRegistry.clearDataSources();
+    registerTaskDataSources(promiseService, { addTasksToServerGroups: () => undefined });
+  });
 
-  beforeEach(() => ApplicationDataSourceRegistry.clearDataSources());
+  afterEach(() => ApplicationDataSourceRegistry.clearDataSources());
 
-  beforeEach(mock.module(require('./task.dataSource').name));
+  const waitForRefresh = (dataSource: any) =>
+    new Promise<void>((resolve) => dataSource.onNextRefresh(resolve, resolve));
 
-  beforeEach(
-    mock.inject(function (_$q_: any, $rootScope: any) {
-      $q = _$q_;
-      $scope = $rootScope.$new();
-    }),
-  );
+  async function refreshDataSource(dataSource: any) {
+    const refreshComplete = waitForRefresh(dataSource);
+    dataSource.refresh();
+    await refreshComplete;
+  }
 
-  function configureApplication() {
+  async function configureApplication() {
     ApplicationDataSourceRegistry.registerDataSource({ key: 'serverGroups', defaultData: [] });
     application = ApplicationModelBuilder.createApplicationForTests(
       'app',
       ...ApplicationDataSourceRegistry.getDataSources(),
     );
+    const refreshes = application.dataSources.map(waitForRefresh);
     application.refresh().catch(() => {});
+    await Promise.all(refreshes);
+    const tasksRefresh = waitForRefresh(application.getDataSource('tasks'));
     application.getDataSource('tasks').activate();
-    $scope.$digest();
+    await tasksRefresh;
   }
 
   describe('loading tasks', function () {
     beforeEach(function () {
-      spyOn(TaskReader, 'getRunningTasks').and.returnValue($q.when([]));
+      spyOn(TaskReader, 'getRunningTasks').and.returnValue(Promise.resolve([]));
     });
 
-    it('loads tasks and sets appropriate flags', function () {
-      spyOn(TaskReader, 'getTasks').and.returnValue($q.when([]));
-      configureApplication();
+    it('loads tasks and sets appropriate flags', async function () {
+      spyOn(TaskReader, 'getTasks').and.returnValue(Promise.resolve([]));
+      await configureApplication();
       expect(application.getDataSource('tasks').loaded).toBe(true);
       expect(application.getDataSource('tasks').loading).toBe(false);
       expect(application.getDataSource('tasks').loadFailure).toBe(false);
     });
 
-    it('sets appropriate flags when task load fails', function () {
-      spyOn(TaskReader, 'getTasks').and.callFake(() => $q.reject(null));
-      configureApplication();
+    it('sets appropriate flags when task load fails', async function () {
+      spyOn(TaskReader, 'getTasks').and.returnValue(Promise.reject(null));
+      await configureApplication();
       expect(application.getDataSource('tasks').loaded).toBe(false);
       expect(application.getDataSource('tasks').loading).toBe(false);
       expect(application.getDataSource('tasks').loadFailure).toBe(true);
@@ -55,22 +62,23 @@ describe('Task Data Source', function () {
 
   describe('reload tasks', function () {
     beforeEach(function () {
-      spyOn(TaskReader, 'getRunningTasks').and.returnValue($q.when([]));
+      spyOn(TaskReader, 'getRunningTasks').and.returnValue(Promise.resolve([]));
     });
 
-    it('reloads tasks and sets appropriate flags', function () {
+    it('reloads tasks and sets appropriate flags', async function () {
       let nextCalls = 0;
-      spyOn(TaskReader, 'getTasks').and.returnValue($q.when([]));
-      configureApplication();
-      application.getDataSource('tasks').onRefresh($scope, () => nextCalls++);
+      spyOn(TaskReader, 'getTasks').and.returnValue(Promise.resolve([]));
+      await configureApplication();
+      application.getDataSource('tasks').onRefresh(() => nextCalls++);
       expect(application.getDataSource('tasks').loaded).toBe(true);
       expect(application.getDataSource('tasks').loading).toBe(false);
       expect(application.getDataSource('tasks').loadFailure).toBe(false);
 
+      const refreshComplete = waitForRefresh(application.getDataSource('tasks'));
       application.getDataSource('tasks').refresh();
       expect(application.getDataSource('tasks').loading).toBe(true);
 
-      $scope.$digest();
+      await refreshComplete;
       expect(application.getDataSource('tasks').loaded).toBe(true);
       expect(application.getDataSource('tasks').loading).toBe(false);
       expect(application.getDataSource('tasks').loadFailure).toBe(false);
@@ -78,25 +86,22 @@ describe('Task Data Source', function () {
       expect(nextCalls).toBe(1);
     });
 
-    it('sets appropriate flags when task reload fails; subscriber is responsible for error checking', function () {
-      spyOn(TaskReader, 'getTasks').and.callFake(() => $q.reject(null));
+    it('sets appropriate flags when task reload fails; subscriber is responsible for error checking', async function () {
+      spyOn(TaskReader, 'getTasks').and.returnValue(Promise.reject(null));
       let errorsHandled = 0;
       let successesHandled = 0;
-      configureApplication();
+      await configureApplication();
       application.getDataSource('tasks').onRefresh(
-        $scope,
         () => successesHandled++,
         () => errorsHandled++,
       );
 
-      application.getDataSource('tasks').refresh();
-      $scope.$digest();
+      await refreshDataSource(application.getDataSource('tasks'));
 
       expect(application.getDataSource('tasks').loading).toBe(false);
       expect(application.getDataSource('tasks').loadFailure).toBe(true);
 
-      application.getDataSource('tasks').refresh();
-      $scope.$digest();
+      await refreshDataSource(application.getDataSource('tasks'));
 
       expect(errorsHandled).toBe(2);
       expect(successesHandled).toBe(0);

package/src/task/task.read.service.spec.js

@@ -3,14 +3,42 @@ import { mockHttpClient } from '../api/mock/jasmine';
 import { TaskReader } from './task.read.service';
 
 describe('Service: taskReader', function () {
-  let scope, timeout;
-
-  beforeEach(
-    window.inject(function ($rootScope, $timeout) {
-      timeout = $timeout;
-      scope = $rootScope.$new();
-    }),
-  );
+  let runNextPoll;
+  let cancelPoll;
+
+  beforeEach(() => {
+    const nativeSetTimeout = window.setTimeout;
+    const nativeClearTimeout = window.clearTimeout;
+    const pollCallbacks = [];
+    const pollsByHandle = new Map();
+    let nextHandle = -1;
+    spyOn(window, 'setTimeout').and.callFake((callback, delay, ...args) => {
+      if (delay !== 1000) {
+        return nativeSetTimeout.call(window, callback, delay, ...args);
+      }
+      const poll = { callback, cancelled: false, handle: nextHandle-- };
+      pollCallbacks.push(poll);
+      pollsByHandle.set(poll.handle, poll);
+      return poll.handle;
+    });
+    cancelPoll = jasmine.createSpy('cancelPoll');
+    spyOn(window, 'clearTimeout').and.callFake((handle) => {
+      const poll = pollsByHandle.get(handle);
+      if (poll) {
+        poll.cancelled = true;
+        cancelPoll(handle);
+      } else {
+        nativeClearTimeout.call(window, handle);
+      }
+    });
+    runNextPoll = () => {
+      const poll = pollCallbacks.shift();
+      if (!poll || poll.cancelled) {
+        throw new Error('No pending task poll');
+      }
+      poll.callback();
+    };
+  });
 
   async function getTask(http, taskDef) {
     http.expectGET(`/tasks/${taskDef.id}`).respond(200, taskDef);
@@ -25,8 +53,7 @@ describe('Service: taskReader', function () {
       const task = await getTask(http, { id: 1, foo: 3, status: 'SUCCEEDED' });
 
       let completed = false;
-      TaskReader.waitUntilTaskMatches(task, (task) => task.foo === 3).then(() => (completed = true));
-      scope.$digest();
+      await TaskReader.waitUntilTaskMatches(task, (task) => task.foo === 3).then(() => (completed = true));
 
       expect(completed).toBe(true);
     });
@@ -38,7 +65,7 @@ describe('Service: taskReader', function () {
       let completed = false,
         failed = false;
 
-      TaskReader.waitUntilTaskMatches(
+      await TaskReader.waitUntilTaskMatches(
         task,
         (task) => task.foo === 4,
         (task) => task.foo === 3,
@@ -46,8 +73,6 @@ describe('Service: taskReader', function () {
         () => (completed = true),
         () => (failed = true),
       );
-      scope.$digest();
-
       expect(completed).toBe(false);
       expect(failed).toBe(true);
     });
@@ -59,7 +84,7 @@ describe('Service: taskReader', function () {
       let completed = false,
         failed = false;
 
-      TaskReader.waitUntilTaskMatches(
+      const waitForMatch = TaskReader.waitUntilTaskMatches(
         task,
         (task) => task.isCompleted,
         (task) => task.isFailed,
@@ -74,7 +99,7 @@ describe('Service: taskReader', function () {
 
       // still running
       http.expectGET('/tasks/1').respond(200, { id: 1, status: 'RUNNING' });
-      timeout.flush();
+      runNextPoll();
       await http.flush();
 
       expect(completed).toBe(false);
@@ -82,8 +107,9 @@ describe('Service: taskReader', function () {
 
       // succeeds
       http.expectGET('/tasks/1').respond(200, { id: 1, status: 'SUCCEEDED' });
-      timeout.flush();
+      runNextPoll();
       await http.flush();
+      await waitForMatch;
 
       expect(completed).toBe(true);
       expect(failed).toBe(false);
@@ -96,7 +122,7 @@ describe('Service: taskReader', function () {
       let completed = false,
         failed = false;
 
-      TaskReader.waitUntilTaskMatches(
+      const waitForMatch = TaskReader.waitUntilTaskMatches(
         task,
         (task) => task.isCompleted,
         (task) => task.isFailed,
@@ -104,23 +130,22 @@ describe('Service: taskReader', function () {
         () => (completed = true),
         () => (failed = true),
       );
-      scope.$digest();
-
       // still running
       expect(completed).toBe(false);
       expect(failed).toBe(false);
 
       // still running
       http.expectGET('/tasks/1').respond(200, { id: 1, status: 'RUNNING' });
-      timeout.flush();
+      runNextPoll();
       await http.flush();
       expect(completed).toBe(false);
       expect(failed).toBe(false);
 
       // succeeds
       http.expectGET('/tasks/1').respond(200, { id: 1, status: 'TERMINAL' });
-      timeout.flush();
+      runNextPoll();
       await http.flush();
+      await waitForMatch.catch(() => undefined);
       expect(completed).toBe(false);
       expect(failed).toBe(true);
     });
@@ -133,7 +158,7 @@ describe('Service: taskReader', function () {
       let completed = false,
         failed = false;
 
-      TaskReader.waitUntilTaskMatches(
+      await TaskReader.waitUntilTaskMatches(
         task,
         (task) => task.isCompleted,
         (task) => task.isFailed,
@@ -141,11 +166,82 @@ describe('Service: taskReader', function () {
         () => (completed = true),
         () => (failed = true),
       );
-      scope.$digest();
-
       expect(completed).toBe(false);
       expect(failed).toBe(true);
     });
+
+    it('cancelPolling disposes the timer when polling reaches a terminal state', async function () {
+      const http = mockHttpClient();
+      const task = await getTask(http, { id: 1, status: 'RUNNING' });
+      const completed = TaskReader.waitUntilTaskCompletes(task);
+      const pendingPoll = task.poller;
+      http.expectGET('/tasks/1').respond(200, { id: 1, status: 'SUCCEEDED' });
+
+      runNextPoll();
+      await http.flush();
+      await completed;
+
+      expect(cancelPoll).toHaveBeenCalledOnceWith(pendingPoll);
+    });
+
+    it('cancelPolling stops a pending task poll', async function () {
+      const http = mockHttpClient();
+      const task = await getTask(http, { id: 1, status: 'RUNNING' });
+      cancelPoll.calls.reset();
+      TaskReader.waitUntilTaskCompletes(task);
+      const pendingPoll = task.poller;
+
+      expect(TaskReader.cancelPolling).toEqual(jasmine.any(Function));
+      if (!TaskReader.cancelPolling) {
+        return;
+      }
+
+      TaskReader.cancelPolling(task);
+      TaskReader.cancelPolling(task);
+
+      expect(cancelPoll).toHaveBeenCalledOnceWith(pendingPoll);
+      expect(task.poller).toBeUndefined();
+      expect(runNextPoll).toThrowError('No pending task poll');
+    });
+
+    it('replaces an existing poll for the same task', async function () {
+      const http = mockHttpClient();
+      const task = await getTask(http, { id: 1, status: 'RUNNING' });
+      cancelPoll.calls.reset();
+      TaskReader.waitUntilTaskCompletes(task);
+      const firstPoll = task.poller;
+
+      TaskReader.waitUntilTaskCompletes(task);
+
+      expect(cancelPoll).toHaveBeenCalledOnceWith(firstPoll);
+      expect(task.poller).not.toBe(firstPoll);
+    });
+
+    it('does not apply or restart an in-flight poll after cancellation', async function () {
+      const http = mockHttpClient();
+      const task = await getTask(http, { id: 1, status: 'RUNNING' });
+      const actualRequest = http.request.bind(http);
+      let notifyRequestStarted;
+      const requestStarted = new Promise((resolve) => (notifyRequestStarted = resolve));
+      spyOn(http, 'request').and.callFake((...args) => {
+        const response = actualRequest(...args);
+        notifyRequestStarted();
+        return response;
+      });
+      TaskReader.waitUntilTaskCompletes(task);
+      const pendingPoll = task.poller;
+      http.expectGET('/tasks/1').respond(200, { id: 1, status: 'SUCCEEDED' });
+
+      runNextPoll();
+      await requestStarted;
+      TaskReader.cancelPolling(task);
+      await http.flush();
+
+      expect(cancelPoll).toHaveBeenCalledOnceWith(pendingPoll);
+      expect(task.status).toBe('RUNNING');
+      expect(task.poller).toBeUndefined();
+      expect(runNextPoll).toThrowError('No pending task poll');
+    });
   });
 
   describe('task running time', function () {

package/src/task/task.read.service.ts

@@ -1,9 +1,10 @@
-import { $log, $q, $timeout } from 'ngimport';
 import type { Subject } from 'rxjs';
 
 import { REST } from '../api/ApiService';
 import type { ITask } from '../domain';
 import { OrchestratedItemTransformer } from '../orchestratedItem/orchestratedItem.transformer';
+import { createDeferred } from '../utils/deferred';
+import { diagnosticLogger } from '../utils/diagnosticLogger';
 
 export class TaskReader {
   private static activeStatuses: string[] = ['RUNNING', 'SUSPENDED', 'NOT_STARTED'];
@@ -13,7 +14,7 @@ export class TaskReader {
     statuses: string[] = [],
     limitPerPage: number = null,
     page: number = null,
-  ): PromiseLike<ITask[]> {
+  ): Promise<ITask[]> {
     return REST('/applications')
       .path(applicationName, 'tasks')
       .query({
@@ -28,11 +29,11 @@ export class TaskReader {
       });
   }
 
-  public static getRunningTasks(applicationName: string): PromiseLike<ITask[]> {
+  public static getRunningTasks(applicationName: string): Promise<ITask[]> {
     return this.getTasks(applicationName, this.activeStatuses);
   }
 
-  public static getTask(taskId: string): PromiseLike<ITask> {
+  public static getTask(taskId: string): Promise<ITask> {
     return REST('/tasks')
       .path(taskId)
       .get()
@@ -47,41 +48,74 @@ export class TaskReader {
         return task;
       })
       .catch((error: any): undefined => {
-        $log.warn('There was an issue retrieving taskId: ', taskId, error);
+        diagnosticLogger.warn('There was an issue retrieving taskId: ', taskId, error);
         return undefined;
       });
   }
 
+  public static cancelPolling(task?: ITask): void {
+    if (!task || task.poller === undefined) {
+      return;
+    }
+
+    const poller = task.poller;
+    clearTimeout(poller);
+    if (task.poller === poller) {
+      task.poller = undefined;
+    }
+  }
+
   public static waitUntilTaskMatches(
     task: ITask,
     closure: (task: ITask) => boolean,
     failureClosure?: (task: ITask) => boolean,
     interval = 1000,
     notifier?: Subject<void>,
-  ): PromiseLike<ITask> {
-    const deferred = $q.defer<ITask>();
+  ): Promise<ITask> {
+    const deferred = createDeferred<ITask>();
     if (!task) {
       deferred.reject(null);
     } else if (closure(task)) {
+      this.cancelPolling(task);
       deferred.resolve(task);
     } else if (failureClosure && failureClosure(task)) {
+      this.cancelPolling(task);
       deferred.reject(task);
     } else {
-      task.poller = $timeout(() => {
-        this.getTask(task.id).then((updated) => {
-          this.updateTask(task, updated);
-          notifier?.next();
-          this.waitUntilTaskMatches(task, closure, failureClosure, interval, notifier).then(
-            deferred.resolve,
-            deferred.reject,
-          );
-        });
+      this.cancelPolling(task);
+      const poller = setTimeout(() => {
+        if (task.poller !== poller) {
+          return;
+        }
+        void Promise.resolve()
+          .then(() => (task.poller === poller ? this.getTask(task.id) : undefined))
+          .then((updated) => {
+            if (task.poller !== poller) {
+              return;
+            }
+            this.updateTask(task, updated);
+            notifier?.next();
+            if (task.poller !== poller) {
+              return;
+            }
+            this.waitUntilTaskMatches(task, closure, failureClosure, interval, notifier).then(
+              deferred.resolve,
+              deferred.reject,
+            );
+          })
+          .catch((error) => {
+            if (task.poller === poller) {
+              this.cancelPolling(task);
+              deferred.reject(error);
+            }
+          });
       }, interval);
+      task.poller = poller;
     }
     return deferred.promise;
   }
 
-  public static waitUntilTaskCompletes(task: ITask, interval = 1000, notifier?: Subject<void>): PromiseLike<ITask> {
+  public static waitUntilTaskCompletes(task: ITask, interval = 1000, notifier?: Subject<void>): Promise<ITask> {
     return this.waitUntilTaskMatches(
       task,
       (t) => t.isCompleted,

package/src/task/task.states.spec.ts

@@ -0,0 +1,44 @@
+import { UIRouterReact } from '@uirouter/react';
+
+import { createDeckRuntime } from '../bootstrap/DeckRuntime';
+import { getTasksState } from './task.states';
+import { TaskReader } from './task.read.service';
+import { ApplicationReader } from '../application/service/ApplicationReader';
+import { setDirectRouter } from '../navigation/directRouter';
+import { configureRouter } from '../navigation/router';
+
+describe('task states', () => {
+  const routers: UIRouterReact[] = [];
+
+  afterEach(() => {
+    routers.splice(0).forEach((router) => router.dispose());
+    setDirectRouter(null);
+  });
+
+  it('uses a React component for the application tasks view', () => {
+    const state = getTasksState();
+
+    expect(state.views.insight).toEqual(
+      jasmine.objectContaining({
+        $type: 'react',
+      }),
+    );
+    expect(typeof state.views.insight.component).toBe('function');
+  });
+
+  it('resolves a task permalink through a real direct transition', async () => {
+    spyOn(TaskReader, 'getTask').and.resolveTo({ application: 'payments' } as any);
+    spyOn(ApplicationReader, 'getApplication').and.resolveTo({ name: 'payments', dataSources: [] } as any);
+    const router = new UIRouterReact();
+    const runtime = createDeckRuntime(router);
+    router.disposable(runtime);
+    configureRouter(router, runtime.services, runtime.routingState);
+    routers.push(router);
+
+    await router.stateService.go('home.taskLookup', { taskId: 'task-123' }, { location: false });
+
+    expect(TaskReader.getTask).toHaveBeenCalledOnceWith('task-123');
+    expect(router.stateService.current.name).toBe('home.applications.application.tasks.taskDetails');
+    expect(router.globals.params).toEqual(jasmine.objectContaining({ application: 'payments', taskId: 'task-123' }));
+  });
+});