@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/service/execution.service.spec.ts

@@ -1,56 +1,76 @@
-import type { IQProvider, IQService, ITimeoutService } from 'angular';
-import { mock, noop } from 'angular';
+import type { StateService } from '@uirouter/core';
 
 import { mockHttpClient } from '../../api/mock/jasmine';
 import type { Application } from '../../application';
 import type { IExecution } from '../../domain';
-import type { ExecutionService } from './execution.service';
-import { EXECUTION_SERVICE } from './execution.service';
-import { REACT_MODULE } from '../../reactShims';
+import { ExecutionService } from './execution.service';
 import * as State from '../../state';
+import type { CancellableTimeout, CancellableTimeoutPromise } from '../../utils/cancellableTimeout';
+
+const noop = (): void => undefined;
+
+type ControlledTimeout = CancellableTimeout & { flush: () => void };
+
+function createControlledTimeout(): ControlledTimeout {
+  const pending: Array<{ promise: CancellableTimeoutPromise<unknown>; run: () => void }> = [];
+  const timeout = (<T>(callback: () => T | PromiseLike<T>) => {
+    let run: () => void;
+    const promise = new Promise<T>((resolve, reject) => {
+      run = () => Promise.resolve().then(callback).then(resolve, reject);
+    }) as CancellableTimeoutPromise<T>;
+    pending.push({ promise, run });
+    return promise;
+  }) as ControlledTimeout;
+
+  timeout.cancel = (promise) => {
+    const index = pending.findIndex((scheduled) => scheduled.promise === promise);
+    if (index === -1) {
+      return false;
+    }
+    pending.splice(index, 1);
+    return true;
+  };
+  timeout.flush = () => {
+    if (!pending.length) {
+      throw new Error('No pending timeouts');
+    }
+    pending.splice(0).forEach(({ run }) => run());
+  };
+  timeout.dispose = () => pending.splice(0);
+
+  return timeout;
+}
 
 describe('Service: executionService', () => {
   let executionService: ExecutionService;
-  let timeout: ITimeoutService;
-  let $q: IQService;
-
-  beforeEach(mock.module(REACT_MODULE, EXECUTION_SERVICE, 'ui.router'));
-
-  // https://docs.angularjs.org/guide/migration#migrate1.5to1.6-ng-services-$q
-  beforeEach(
-    mock.module(($qProvider: IQProvider) => {
-      $qProvider.errorOnUnhandledRejections(false);
-    }),
-  );
-
-  beforeEach(
-    mock.inject((_executionService_: ExecutionService, _$timeout_: ITimeoutService, _$q_: IQService) => {
-      executionService = _executionService_;
-      timeout = _$timeout_;
-      $q = _$q_;
-      State.initialize();
-      State.ExecutionState.filterModel.asFilterModel.sortFilter.count = 3;
-    }),
-  );
+  let timeout: ControlledTimeout;
+
+  beforeEach(() => {
+    timeout = createControlledTimeout();
+    executionService = new ExecutionService({} as StateService, timeout);
+    State.initialize();
+    State.ExecutionState.filterModel.asFilterModel.sortFilter.count = 3;
+  });
 
   describe('cancelling pipeline', () => {
     it('should wait until pipeline is not running, then resolve', async () => {
       const http = mockHttpClient();
       const executionId = 'abc';
-      const application: Application = { name: 'deck', executions: { refresh: () => $q.when(null) } } as any;
+      const application: Application = { name: 'deck', executions: { refresh: () => Promise.resolve(null) } } as any;
 
       let completed = false;
 
       http.expectPUT(`/pipelines/${executionId}/cancel`).respond(200, []);
       http.expectGET(`/pipelines/${executionId}`).respond(200, { id: executionId, status: 'RUNNING' });
 
-      executionService.cancelExecution(application, executionId).then(() => (completed = true));
+      const cancellation = executionService.cancelExecution(application, executionId).then(() => (completed = true));
       await http.flush();
       expect(completed).toBe(false);
 
       http.expectGET(`/pipelines/${executionId}`).respond(200, { id: executionId, status: 'CANCELED' });
       timeout.flush();
       await http.flush();
+      await cancellation;
       expect(completed).toBe(true);
     });
 
@@ -58,7 +78,7 @@ describe('Service: executionService', () => {
       const http = mockHttpClient();
       let failed = false;
       const executionId = 'abc';
-      const application: Application = { name: 'deck', executions: { refresh: () => $q.when(null) } } as any;
+      const application: Application = { name: 'deck', executions: { refresh: () => Promise.resolve(null) } } as any;
 
       http.expectPUT(`/pipelines/${executionId}/cancel`).respond(500, []);
 
@@ -73,18 +93,19 @@ describe('Service: executionService', () => {
       const http = mockHttpClient();
       let completed = false;
       const executionId = 'abc';
-      const application: Application = { name: 'deck', executions: { refresh: () => $q.when(null) } } as any;
+      const application: Application = { name: 'deck', executions: { refresh: () => Promise.resolve(null) } } as any;
 
       http.expectDELETE(`/pipelines/${executionId}`).respond(200, []);
       http.expectGET(`/pipelines/${executionId}`).respond(200, { id: executionId });
 
-      executionService.deleteExecution(application, executionId).then(() => (completed = true));
+      const deletion = executionService.deleteExecution(application, executionId).then(() => (completed = true));
       await http.flush();
       expect(completed).toBe(false);
 
       http.expectGET(`/pipelines/${executionId}`).respond(404, null);
       timeout.flush();
       await http.flush();
+      await deletion;
       expect(completed).toBe(true);
     });
 
@@ -93,7 +114,7 @@ describe('Service: executionService', () => {
       let failed = false;
       const executionId = 'abc';
       const deleteUrl = `/pipelines/${executionId}`;
-      const application: Application = { name: 'deck', executions: { refresh: () => $q.when(null) } } as any;
+      const application: Application = { name: 'deck', executions: { refresh: () => Promise.resolve(null) } } as any;
 
       http.expectDELETE(deleteUrl).respond(500, []);
 
@@ -110,18 +131,19 @@ describe('Service: executionService', () => {
       const executionId = 'abc';
       const pauseUrl = `/pipelines/${executionId}/pause`;
       const singleExecutionUrl = `/pipelines/${executionId}`;
-      const application: Application = { name: 'deck', executions: { refresh: () => $q.when(null) } } as any;
+      const application: Application = { name: 'deck', executions: { refresh: () => Promise.resolve(null) } } as any;
 
       http.expectPUT(pauseUrl).respond(200, []);
       http.expectGET(singleExecutionUrl).respond(200, { id: executionId, status: 'RUNNING' });
 
-      executionService.pauseExecution(application, executionId).then(() => (completed = true));
+      const pause = executionService.pauseExecution(application, executionId).then(() => (completed = true));
       await http.flush();
       expect(completed).toBe(false);
 
       http.expectGET(singleExecutionUrl).respond(200, { id: executionId, status: 'PAUSED' });
       timeout.flush();
       await http.flush();
+      await pause;
 
       expect(completed).toBe(true);
     });
@@ -134,18 +156,19 @@ describe('Service: executionService', () => {
       const executionId = 'abc';
       const pauseUrl = `/pipelines/${executionId}/resume`;
       const singleExecutionUrl = `/pipelines/${executionId}`;
-      const application: Application = { name: 'deck', executions: { refresh: () => $q.when(null) } } as any;
+      const application: Application = { name: 'deck', executions: { refresh: () => Promise.resolve(null) } } as any;
 
       http.expectPUT(pauseUrl).respond(200, []);
       http.expectGET(singleExecutionUrl).respond(200, { id: executionId, status: 'PAUSED' });
 
-      executionService.resumeExecution(application, executionId).then(() => (completed = true));
+      const resume = executionService.resumeExecution(application, executionId).then(() => (completed = true));
       await http.flush();
       expect(completed).toBe(false);
 
       http.expectGET(singleExecutionUrl).respond(200, { id: executionId, status: 'RUNNING' });
       timeout.flush();
       await http.flush();
+      await resume;
 
       expect(completed).toBe(true);
     });
@@ -184,13 +207,14 @@ describe('Service: executionService', () => {
 
       http.expectGET(url).respond(200, { thingToMatch: true });
 
-      executionService
+      const match = executionService
         .waitUntilExecutionMatches(executionId, (execution) => (execution as any).thingToMatch)
         .then(() => (succeeded = true));
 
       expect(succeeded).toBe(false);
 
       await http.flush();
+      await match;
       expect(succeeded).toBe(true);
     });
 
@@ -202,7 +226,7 @@ describe('Service: executionService', () => {
 
       http.expectGET(url).respond(200, { thingToMatch: false });
 
-      executionService
+      const match = executionService
         .waitUntilExecutionMatches(executionId, (execution) => (execution as any).thingToMatch)
         .then(() => (succeeded = true));
 
@@ -222,6 +246,7 @@ describe('Service: executionService', () => {
       http.expectGET(url).respond(200, { thingToMatch: true });
       timeout.flush();
       await http.flush();
+      await match;
 
       expect(succeeded).toBe(true);
     });
@@ -235,7 +260,7 @@ describe('Service: executionService', () => {
 
       http.expectGET(url).respond(200, { thingToMatch: false });
 
-      executionService
+      const match = executionService
         .waitUntilExecutionMatches(executionId, (execution) => (execution as any).thingToMatch)
         .then(
           () => (succeeded = true),
@@ -253,6 +278,7 @@ describe('Service: executionService', () => {
       http.expectGET(url).respond(500, '');
       timeout.flush();
       await http.flush();
+      await match;
       expect(succeeded).toBe(false);
       expect(failed).toBe(true);
     });
@@ -427,7 +453,10 @@ describe('Service: executionService', () => {
 
   describe('waitUntilTriggeredPipelineAppears', () => {
     const applicationName = 'deck';
-    const application: Application = { name: applicationName, executions: { refresh: () => $q.when(null) } } as any;
+    const application: Application = {
+      name: applicationName,
+      executions: { refresh: () => Promise.resolve(null) },
+    } as any;
     const pipelineId = '01DC2VMFBZ5PFW5G6SMKWW5CZC';
     const url = `/pipelines/${pipelineId}`;
     const execution: any = {}; // Stub execution
@@ -438,13 +467,13 @@ describe('Service: executionService', () => {
 
       http.expectGET(url).respond(200, execution);
 
-      executionService
-        .waitUntilTriggeredPipelineAppears(application, pipelineId)
-        .promise.then(() => (succeeded = true));
+      const pipelineAppeared = executionService.waitUntilTriggeredPipelineAppears(application, pipelineId);
+      pipelineAppeared.promise.then(() => (succeeded = true));
 
       expect(succeeded).toBe(false);
 
       await http.flush();
+      await pipelineAppeared.promise;
       expect(succeeded).toBe(true);
     });
 
@@ -454,14 +483,14 @@ describe('Service: executionService', () => {
 
       http.expectGET(url).respond(404, null);
 
-      executionService
-        .waitUntilTriggeredPipelineAppears(application, pipelineId)
-        .promise.then(() => (succeeded = true));
+      const pipelineAppeared = executionService.waitUntilTriggeredPipelineAppears(application, pipelineId);
+      pipelineAppeared.promise.then(() => (succeeded = true));
 
       expect(succeeded).toBe(false);
 
       await http.flush();
       expect(succeeded).toBe(false);
+      pipelineAppeared.cancel();
     });
 
     it('resolves when the pipeline exists on a later poll', async () => {
@@ -470,9 +499,8 @@ describe('Service: executionService', () => {
 
       http.expectGET(url).respond(404, null);
 
-      executionService
-        .waitUntilTriggeredPipelineAppears(application, pipelineId)
-        .promise.then(() => (succeeded = true));
+      const pipelineAppeared = executionService.waitUntilTriggeredPipelineAppears(application, pipelineId);
+      pipelineAppeared.promise.then(() => (succeeded = true));
 
       expect(succeeded).toBe(false);
 
@@ -484,6 +512,7 @@ describe('Service: executionService', () => {
       http.expectGET(url).respond(200, execution);
       timeout.flush();
       await http.flush();
+      await pipelineAppeared.promise;
 
       expect(succeeded).toBe(true);
     });

package/src/pipeline/service/execution.service.ts

@@ -1,7 +1,4 @@
-import UIROUTER_ANGULARJS from '@uirouter/angularjs';
 import type { StateService } from '@uirouter/core';
-import type { IQService, ITimeoutService } from 'angular';
-import { module } from 'angular';
 import { get, identity, pickBy, uniq } from 'lodash';
 
 import { ExecutionsTransformer } from './ExecutionsTransformer';
@@ -15,10 +12,10 @@ import type { IPipeline } from '../../domain/IPipeline';
 import { ExecutionFilterService } from '../filter/executionFilter.service';
 import type { ISortFilter } from '../../filterModel';
 import { FilterModelService } from '../../filterModel';
-import { ReactInjector } from '../../reactShims';
 import { ExecutionState } from '../../state';
 import { JsonUtils } from '../../utils';
-import { DebugWindow } from '../../utils/consoleDebug';
+import type { CancellableTimeout } from '../../utils/cancellableTimeout';
+import { createDeferred } from '../../utils/deferred';
 import type { IRetryablePromise } from '../../utils/retryablePromise';
 import { retryablePromise } from '../../utils/retryablePromise';
 
@@ -35,14 +32,17 @@ export class ExecutionService {
     'hydrator',
     'hydrated',
     'instances',
+    'durationString',
+    'lastModifiedBy',
     'requisiteIds',
     'requisiteStageRefIds',
+    'updateTs',
     '$$hashKey',
   ];
 
-  constructor(private $q: IQService, private $state: StateService, private $timeout: ITimeoutService) {}
+  constructor(private $state: StateService, private timeout: CancellableTimeout) {}
 
-  public getRunningExecutions(applicationName: string): PromiseLike<IExecution[]> {
+  public getRunningExecutions(applicationName: string): Promise<IExecution[]> {
     return this.getFilteredExecutions(applicationName, this.activeStatuses, this.runningLimit, null, true);
   }
 
@@ -52,7 +52,7 @@ export class ExecutionService {
     limit: number,
     pipelineConfigIds: string[] = null,
     expand = false,
-  ): PromiseLike<IExecution[]> {
+  ): Promise<IExecution[]> {
     const statusString = statuses.map((status) => status.toUpperCase()).join(',') || null;
     const call = pipelineConfigIds
       ? REST('/executions').query({ limit, pipelineConfigIds, statuses }).get()
@@ -86,7 +86,7 @@ export class ExecutionService {
     applicationName: string,
     application: Application = null,
     expand = false,
-  ): PromiseLike<IExecution[]> {
+  ): Promise<IExecution[]> {
     const sortFilter: ISortFilter = ExecutionState.filterModel.asFilterModel.sortFilter;
     const tags = FilterModelService.getCheckValues(sortFilter.tags);
     const pipelines = Object.keys(sortFilter.pipeline);
@@ -100,7 +100,7 @@ export class ExecutionService {
     return this.getFilteredExecutions(applicationName, statuses, limit, null, expand);
   }
 
-  public getExecution(executionId: string, pipelineConfigs: IPipeline[] = []): PromiseLike<IExecution> {
+  public getExecution(executionId: string, pipelineConfigs: IPipeline[] = []): Promise<IExecution> {
     return REST('/pipelines')
       .path(executionId)
       .get()
@@ -142,7 +142,7 @@ export class ExecutionService {
     });
   }
 
-  private getConfigIdsFromFilterModel(application: Application): PromiseLike<string[]> {
+  private getConfigIdsFromFilterModel(application: Application): Promise<string[]> {
     const sortFilter = ExecutionState.filterModel.asFilterModel.sortFilter;
     const tags = FilterModelService.getCheckValues(sortFilter.tags);
     const pipelines = Object.keys(sortFilter.pipeline);
@@ -231,14 +231,9 @@ export class ExecutionService {
     }
   }
 
-  public startAndMonitorPipeline(
-    app: Application,
-    pipeline: string,
-    trigger: any,
-  ): PromiseLike<IRetryablePromise<void>> {
-    const { executionService } = ReactInjector;
+  public startAndMonitorPipeline(app: Application, pipeline: string, trigger: any): Promise<IRetryablePromise<void>> {
     return PipelineConfigService.triggerPipeline(app.name, pipeline, trigger).then((triggerResult) =>
-      executionService.waitUntilTriggeredPipelineAppears(app, triggerResult),
+      this.waitUntilTriggeredPipelineAppears(app, triggerResult),
     );
   }
 
@@ -247,20 +242,20 @@ export class ExecutionService {
     triggeredPipelineId: string,
   ): IRetryablePromise<any> {
     const closure = () => this.getExecution(triggeredPipelineId).then(() => application.executions.refresh());
-    return retryablePromise(closure, 1000, 10);
+    return retryablePromise(closure, 1000, 10, this.timeout);
   }
 
-  private waitUntilPipelineIsCancelled(application: Application, executionId: string): PromiseLike<any> {
+  private waitUntilPipelineIsCancelled(application: Application, executionId: string): Promise<any> {
     return this.waitUntilExecutionMatches(
       executionId,
       (execution: IExecution) => execution.status === 'CANCELED',
     ).then(() => application.executions.refresh());
   }
 
-  private waitUntilPipelineIsDeleted(application: Application, executionId: string): PromiseLike<any> {
-    const deferred = this.$q.defer();
+  private waitUntilPipelineIsDeleted(application: Application, executionId: string): Promise<any> {
+    const deferred = createDeferred<void>();
     this.getExecution(executionId).then(
-      () => this.$timeout(() => this.waitUntilPipelineIsDeleted(application, executionId).then(deferred.resolve), 1000),
+      () => this.timeout(() => this.waitUntilPipelineIsDeleted(application, executionId).then(deferred.resolve), 1000),
       () => deferred.resolve(),
     );
     deferred.promise.then(() => application.executions.refresh());
@@ -272,7 +267,7 @@ export class ExecutionService {
     executionId: string,
     force?: boolean,
     reason?: string,
-  ): PromiseLike<any> {
+  ): Promise<any> {
     return REST('/pipelines')
       .path(executionId, 'cancel')
       .query({ force, reason })
@@ -283,7 +278,7 @@ export class ExecutionService {
       });
   }
 
-  public pauseExecution(application: Application, executionId: string): PromiseLike<any> {
+  public pauseExecution(application: Application, executionId: string): Promise<any> {
     return REST('/pipelines')
       .path(executionId, 'pause')
       .put()
@@ -294,7 +289,7 @@ export class ExecutionService {
       });
   }
 
-  public resumeExecution(application: Application, executionId: string): PromiseLike<any> {
+  public resumeExecution(application: Application, executionId: string): Promise<any> {
     return REST('/pipelines')
       .path(executionId, 'resume')
       .put()
@@ -305,7 +300,7 @@ export class ExecutionService {
       });
   }
 
-  public deleteExecution(application: Application, executionId: string): PromiseLike<any> {
+  public deleteExecution(application: Application, executionId: string): Promise<any> {
     const promiseLike = REST('/pipelines')
       .path(executionId)
       .delete()
@@ -320,12 +315,12 @@ export class ExecutionService {
   public waitUntilExecutionMatches(
     executionId: string,
     matchPredicate: (execution: IExecution) => boolean,
-  ): PromiseLike<IExecution> {
+  ): Promise<IExecution> {
     return this.getExecution(executionId).then((execution) => {
       if (matchPredicate(execution)) {
         return execution;
       }
-      return this.$timeout(() => this.waitUntilExecutionMatches(executionId, matchPredicate), 1000);
+      return this.timeout(() => this.waitUntilExecutionMatches(executionId, matchPredicate), 1000);
     });
   }
 
@@ -333,7 +328,7 @@ export class ExecutionService {
     return ['pipeline', groupBy, application, heading].join('#');
   }
 
-  public getProjectExecutions(project: string, limit = 1): PromiseLike<IExecution[]> {
+  public getProjectExecutions(project: string, limit = 1): Promise<IExecution[]> {
     return REST('/projects')
       .path(project, 'pipelines')
       .query({ limit })
@@ -499,7 +494,7 @@ export class ExecutionService {
     return unhydrated.hydrator;
   }
 
-  public getLastExecutionForApplicationByConfigId(appName: string, configId: string): PromiseLike<IExecution> {
+  public getLastExecutionForApplicationByConfigId(appName: string, configId: string): Promise<IExecution> {
     return this.getFilteredExecutions(appName, [], 1)
       .then((executions: IExecution[]) => {
         return executions.filter((execution) => {
@@ -519,12 +514,12 @@ export class ExecutionService {
    *  application: if transform is true, the application to use when transforming the executions (default: null)
    *  limit: the number of executions per config ID to retrieve (default: whatever Gate sets)
    *  statuses: an optional set of execution statuses (default: all)
-   * @return {PromiseLike<IExecution[]>}
+   * @return {Promise<IExecution[]>}
    */
   public getExecutionsForConfigIds(
     pipelineConfigIds: string[],
     options: { limit?: number; statuses?: string; transform?: boolean; application?: Application } = {},
-  ): PromiseLike<IExecution[]> {
+  ): Promise<IExecution[]> {
     const { limit, statuses, transform, application } = options;
     return REST('/executions')
       .query({ limit, pipelineConfigIds: (pipelineConfigIds || []).join(','), statuses })
@@ -541,7 +536,7 @@ export class ExecutionService {
       .catch(() => [] as IExecution[]);
   }
 
-  public patchExecution(executionId: string, stageId: string, data: any): PromiseLike<any> {
+  public patchExecution(executionId: string, stageId: string, data: any): Promise<any> {
     return REST('/pipelines').path(executionId, 'stages', stageId).patch(data);
   }
 
@@ -552,16 +547,6 @@ export class ExecutionService {
   }
 
   private stringify(object: IExecution | IExecutionStageSummary): string {
-    return JsonUtils.makeSortedStringFromAngularObject({ ...object }, this.ignoredStringValFields);
+    return JsonUtils.makeSortedString({ ...object }, this.ignoredStringValFields);
   }
 }
-
-export const EXECUTION_SERVICE = 'spinnaker.core.pipeline.executions.service';
-module(EXECUTION_SERVICE, [UIROUTER_ANGULARJS]).factory('executionService', [
-  '$q',
-  '$state',
-  '$timeout',
-  ($q: IQService, $state: StateService, $timeout: ITimeoutService) => new ExecutionService($q, $state, $timeout),
-]);
-
-DebugWindow.addInjectable('executionService');

package/src/pipeline/status/Artifact.spec.tsx

@@ -1,4 +1,3 @@
-import { mock } from 'angular';
 import type { ShallowWrapper } from 'enzyme';
 import { shallow } from 'enzyme';
 import React from 'react';
@@ -6,7 +5,6 @@ import React from 'react';
 import type { IArtifactProps } from './Artifact';
 import { Artifact } from './Artifact';
 import type { IArtifact } from '../../domain';
-import { REACT_MODULE } from '../../reactShims';
 
 const ARTIFACT_TYPE = 'docker/image';
 const ARTIFACT_NAME = 'example.com/container';
@@ -15,9 +13,6 @@ const ARTIFACT_REFERENCE = 'docker.io/example.com/container:latest';
 describe('<Artifact/>', () => {
   let component: ShallowWrapper<IArtifactProps>;
 
-  beforeEach(mock.module(REACT_MODULE));
-  beforeEach(mock.inject(() => {})); // Angular is lazy.
-
   it("renders an artifact's name", function () {
     const artifact: IArtifact = {
       id: 'abcd',

package/src/pipeline/status/ArtifactList.spec.tsx

@@ -1,4 +1,3 @@
-import { mock } from 'angular';
 import type { ShallowWrapper } from 'enzyme';
 import { shallow } from 'enzyme';
 import React from 'react';
@@ -7,7 +6,6 @@ import { Artifact } from './Artifact';
 import type { IArtifactListProps } from './ArtifactList';
 import { ArtifactList } from './ArtifactList';
 import type { IArtifact } from '../../domain';
-import { REACT_MODULE } from '../../reactShims';
 
 const ARTIFACT_TYPE = 'docker/image';
 const ARTIFACT_NAME = 'example.com/container';
@@ -15,9 +13,6 @@ const ARTIFACT_NAME = 'example.com/container';
 describe('<ArtifactList/>', () => {
   let component: ShallowWrapper<IArtifactListProps>;
 
-  beforeEach(mock.module(REACT_MODULE));
-  beforeEach(mock.inject(() => {})); // Angular is lazy.
-
   it('renders null when null artifacts are passed in', function () {
     const artifacts: IArtifact[] = null;
     component = shallow(<ArtifactList artifacts={artifacts} />);

package/src/pipeline/status/ExecutionParameters.spec.tsx

@@ -1,18 +1,13 @@
-import { mock } from 'angular';
 import type { ShallowWrapper } from 'enzyme';
 import { shallow } from 'enzyme';
 import React from 'react';
 
 import type { IDisplayableParameter, IExecutionParametersProps } from './ExecutionParameters';
 import { ExecutionParameters } from './ExecutionParameters';
-import { REACT_MODULE } from '../../reactShims';
 
 describe('<ExecutionParameters/>', () => {
   let component: ShallowWrapper<IExecutionParametersProps>;
 
-  beforeEach(mock.module(REACT_MODULE));
-  beforeEach(mock.inject(() => {})); // Angular is lazy.
-
   it(`show only pin params, but there's no pinnedDisplayableParameters should return null`, function () {
     const parameters: IDisplayableParameter[] = [{ key: '1', value: 'a' }];
 

package/src/pipeline/status/ResolvedArtifactList.spec.tsx

@@ -1,4 +1,3 @@
-import { mock } from 'angular';
 import type { ShallowWrapper } from 'enzyme';
 import { shallow } from 'enzyme';
 import React from 'react';
@@ -7,7 +6,6 @@ import { Artifact } from './Artifact';
 import type { IResolvedArtifactListProps } from './ResolvedArtifactList';
 import { ResolvedArtifactList } from './ResolvedArtifactList';
 import type { IArtifact, IExpectedArtifact } from '../../domain';
-import { REACT_MODULE } from '../../reactShims';
 
 const ARTIFACT_TYPE = 'docker/image';
 const ARTIFACT_NAME = 'example.com/container';
@@ -15,9 +13,6 @@ const ARTIFACT_NAME = 'example.com/container';
 describe('<ResolvedArtifactList/>', () => {
   let component: ShallowWrapper<IResolvedArtifactListProps>;
 
-  beforeEach(mock.module(REACT_MODULE));
-  beforeEach(mock.inject(() => {})); // Angular is lazy.
-
   it('renders null when null artifacts are passed in', function () {
     const artifacts: IArtifact[] = null;
     component = shallow(<ResolvedArtifactList artifacts={artifacts} showingExpandedArtifacts={true} />);

package/src/pipeline/triggers/useQuietPeriod.hook.ts

@@ -11,7 +11,7 @@ interface IQuietPeriodConfig {
 }
 
 class QuietPeriodService {
-  private static _quietPeriodConfig: PromiseLike<IQuietPeriodConfig>;
+  private static _quietPeriodConfig: Promise<IQuietPeriodConfig>;
   static async quietPeriodConfig(): Promise<IQuietPeriodConfig> {
     this._quietPeriodConfig = this._quietPeriodConfig ?? REST('/capabilities/quietPeriod').get<IQuietPeriodConfig>();
     return await this._quietPeriodConfig;