@spinnaker/core 2026.2.2 → 2026.3.0

package/src/application/modal/validation/ApplicationNameValidator.spec.ts

@@ -1,5 +1,3 @@
-import { mock } from 'angular';
-
 import type { IApplicationNameValidationResult } from './ApplicationNameValidator';
 import { ApplicationNameValidator } from './ApplicationNameValidator';
 import { ExampleApplicationNameValidator, ExampleApplicationNameValidator2 } from './ExampleApplicationNameValidator';
@@ -8,45 +6,41 @@ import { AccountService } from '../../../account/AccountService';
 describe('Validator: applicationName', () => {
   const validator1 = new ExampleApplicationNameValidator();
   const validator2 = new ExampleApplicationNameValidator2();
-  let $scope: ng.IScope;
 
-  beforeEach(
-    mock.inject(($rootScope: ng.IRootScopeService, $q: ng.IQService) => {
-      $scope = $rootScope;
-      spyOn(AccountService, 'listProviders').and.returnValue($q.when([validator1.provider, validator2.provider]));
-    }),
-  );
+  beforeEach(() => {
+    spyOn(AccountService, 'listProviders').and.returnValue(Promise.resolve([validator1.provider, validator2.provider]));
+  });
 
   describe('warning messages', () => {
-    it('aggregates warning messages when multiple or no providers are specified', () => {
-      let result: IApplicationNameValidationResult = null;
-      ApplicationNameValidator.validate(validator1.COMMON_WARNING_CONDITION, []).then((r) => (result = r));
-      $scope.$digest();
+    it('aggregates warning messages when multiple or no providers are specified', async () => {
+      let result: IApplicationNameValidationResult = await ApplicationNameValidator.validate(
+        validator1.COMMON_WARNING_CONDITION,
+        [],
+      );
       expect(result.warnings.length).toBe(2);
       expect(result.warnings[0].cloudProvider).toEqual(validator1.provider);
       expect(result.warnings[0].message).toEqual(validator1.COMMON_WARNING_MESSAGE);
       expect(result.warnings[1].cloudProvider).toEqual(validator2.provider);
       expect(result.warnings[1].message).toEqual(validator2.COMMON_WARNING_MESSAGE);
 
-      ApplicationNameValidator.validate(validator1.COMMON_WARNING_CONDITION, [
+      result = await ApplicationNameValidator.validate(validator1.COMMON_WARNING_CONDITION, [
         validator1.provider,
         validator2.provider,
-      ]).then((r) => (result = r));
-      $scope.$digest();
+      ]);
       expect(result.warnings[0].message).toEqual(validator1.COMMON_WARNING_MESSAGE);
       expect(result.warnings[0].cloudProvider).toEqual(validator1.provider);
       expect(result.warnings[1].cloudProvider).toEqual(validator2.provider);
       expect(result.warnings[1].message).toEqual(validator2.COMMON_WARNING_MESSAGE);
     });
 
-    it('provides warnings only from provider when specified', () => {
-      let result: IApplicationNameValidationResult = null;
-      ApplicationNameValidator.validate(validator1.WARNING_CONDITION, [validator2.provider]).then((r) => (result = r));
-      $scope.$digest();
+    it('provides warnings only from provider when specified', async () => {
+      let result: IApplicationNameValidationResult = await ApplicationNameValidator.validate(
+        validator1.WARNING_CONDITION,
+        [validator2.provider],
+      );
       expect(result.warnings.length).toBe(0);
 
-      ApplicationNameValidator.validate(validator1.WARNING_CONDITION, [validator1.provider]).then((r) => (result = r));
-      $scope.$digest();
+      result = await ApplicationNameValidator.validate(validator1.WARNING_CONDITION, [validator1.provider]);
       expect(result.warnings.length).toBe(1);
       expect(result.warnings[0].cloudProvider).toEqual(validator1.provider);
       expect(result.warnings[0].message).toEqual(validator1.WARNING_MESSAGE);
@@ -54,35 +48,35 @@ describe('Validator: applicationName', () => {
   });
 
   describe('error messages', () => {
-    it('aggregates error messages when multiple or no providers are specified', () => {
-      let result: IApplicationNameValidationResult = null;
-      ApplicationNameValidator.validate(validator1.COMMON_ERROR_CONDITION, []).then((r) => (result = r));
-      $scope.$digest();
+    it('aggregates error messages when multiple or no providers are specified', async () => {
+      let result: IApplicationNameValidationResult = await ApplicationNameValidator.validate(
+        validator1.COMMON_ERROR_CONDITION,
+        [],
+      );
       expect(result.errors.length).toBe(2);
       expect(result.errors[0].cloudProvider).toEqual(validator1.provider);
       expect(result.errors[0].message).toEqual(validator1.COMMON_ERROR_MESSAGE);
       expect(result.errors[1].cloudProvider).toEqual(validator2.provider);
       expect(result.errors[1].message).toEqual(validator2.COMMON_ERROR_MESSAGE);
 
-      ApplicationNameValidator.validate(validator1.COMMON_ERROR_CONDITION, [
+      result = await ApplicationNameValidator.validate(validator1.COMMON_ERROR_CONDITION, [
         validator1.provider,
         validator2.provider,
-      ]).then((r) => (result = r));
-      $scope.$digest();
+      ]);
       expect(result.errors[0].message).toEqual(validator1.COMMON_ERROR_MESSAGE);
       expect(result.errors[0].cloudProvider).toEqual(validator1.provider);
       expect(result.errors[1].cloudProvider).toEqual(validator2.provider);
       expect(result.errors[1].message).toEqual(validator2.COMMON_ERROR_MESSAGE);
     });
 
-    it('provides errors only from provider when specified', () => {
-      let result: IApplicationNameValidationResult = null;
-      ApplicationNameValidator.validate(validator1.ERROR_CONDITION, [validator2.provider]).then((r) => (result = r));
-      $scope.$digest();
+    it('provides errors only from provider when specified', async () => {
+      let result: IApplicationNameValidationResult = await ApplicationNameValidator.validate(
+        validator1.ERROR_CONDITION,
+        [validator2.provider],
+      );
       expect(result.errors.length).toBe(0);
 
-      ApplicationNameValidator.validate(validator1.ERROR_CONDITION, [validator1.provider]).then((r) => (result = r));
-      $scope.$digest();
+      result = await ApplicationNameValidator.validate(validator1.ERROR_CONDITION, [validator1.provider]);
       expect(result.errors.length).toBe(1);
       expect(result.errors[0].cloudProvider).toEqual(validator1.provider);
       expect(result.errors[0].message).toEqual(validator1.ERROR_MESSAGE);

package/src/application/modal/validation/ApplicationNameValidator.ts

@@ -57,7 +57,7 @@ export class ApplicationNameValidator {
   public static validate(
     applicationName: string,
     providersToTest: string[],
-  ): PromiseLike<IApplicationNameValidationResult> {
+  ): Promise<IApplicationNameValidationResult> {
     return AccountService.listProviders().then((availableProviders: string[]) => {
       const toCheck = providersToTest && providersToTest.length ? providersToTest : availableProviders;
 

package/src/application/nav/AppRefresherIcon.tsx

@@ -1,4 +1,3 @@
-import { $window } from 'ngimport';
 import React from 'react';
 
 import { Illustration } from '@spinnaker/presentation';
@@ -55,7 +54,7 @@ export const AppRefresherIcon = ({ appName, lastRefresh, refresh, refreshing }:
   const isRefreshing = iconPulsing || refreshing;
 
   return (
-    <Tooltip template={RefresherTooltip} placement={$window.innerWidth < 1100 ? 'bottom' : 'right'}>
+    <Tooltip template={RefresherTooltip} placement={window.innerWidth < 1100 ? 'bottom' : 'right'}>
       <div className={`application-header-icon${isRefreshing ? ' header-icon-pulsing' : ''}`} onClick={refreshApp}>
         {!isStale && !isRefreshing && <ApplicationFreshIcon />}
         {(isStale || isRefreshing) && <Illustration className="app-fresh-icon horizontal middle" name="appUnsynced" />}

package/src/application/nav/ApplicationNavigation.spec.tsx

@@ -1,7 +1,5 @@
 import { StateMatcher } from '@uirouter/core';
-import type { UIRouterReact } from '@uirouter/react';
-import { UIRouterContext } from '@uirouter/react';
-import { mock } from 'angular';
+import { hashLocationPlugin, servicesPlugin, UIRouterContext, UIRouterReact } from '@uirouter/react';
 import { mount } from 'enzyme';
 import React from 'react';
 import { RecoilRoot } from 'recoil';
@@ -18,26 +16,23 @@ import { ApplicationNavigation } from './ApplicationNavigation';
 import { ApplicationModelBuilder } from '../../application';
 import { SETTINGS } from '../../config';
 import type { IPipeline } from '../../domain';
-import { OVERRIDE_REGISTRY } from '../../overrideRegistry';
-import { REACT_MODULE } from '../../reactShims';
 import type { ApplicationDataSource } from '../service/applicationDataSource';
 
 describe('ApplicationNavigation', () => {
-  let $uiRouter: UIRouterReact;
+  let router: UIRouterReact;
   const currentStates = ['**.pipelines.**', '**.tasks.**'];
 
-  beforeEach(mock.module(REACT_MODULE, OVERRIDE_REGISTRY));
-  beforeEach(
-    mock.inject((_$uiRouter_: UIRouterReact) => {
-      $uiRouter = _$uiRouter_;
-    }),
-  );
   beforeEach(() => {
+    router = new UIRouterReact();
+    router.plugin(servicesPlugin);
+    router.plugin(hashLocationPlugin);
     // Initialize current route
-    spyOn($uiRouter.stateService, 'includes').and.callFake((substate: any) => currentStates.includes(substate));
+    spyOn(router.stateService, 'includes').and.callFake((substate: any) => currentStates.includes(substate));
     spyOn(StateMatcher.prototype, 'find').and.callFake(() => undefined as any);
   });
 
+  afterEach(() => router.dispose());
+
   it('should render header, categories', () => {
     const app = ApplicationModelBuilder.createApplicationForTests(
       'testapp',
@@ -60,7 +55,7 @@ describe('ApplicationNavigation', () => {
 
     const wrapper = mount(
       <RecoilRoot>
-        <UIRouterContext.Provider value={$uiRouter}>
+        <UIRouterContext.Provider value={router}>
           <ApplicationNavigation app={app} />
         </UIRouterContext.Provider>
       </RecoilRoot>,
@@ -76,6 +71,24 @@ describe('ApplicationNavigation', () => {
     expect(pagerDutyButton.length).toEqual(0);
   });
 
+  it('renders nav routes with shared flex row classes', () => {
+    const app = ApplicationModelBuilder.createApplicationForTests('testapp', mockServerGroupDataSourceConfig);
+    app.attributes.dataSources = app.dataSources;
+
+    const wrapper = mount(
+      <RecoilRoot>
+        <UIRouterContext.Provider value={router}>
+          <ApplicationNavigation app={app} />
+        </UIRouterContext.Provider>
+      </RecoilRoot>,
+    );
+
+    const firstNavRoute = wrapper.find('a.nav-category').first();
+
+    expect(firstNavRoute.hasClass('flex-container-h')).toBe(true);
+    expect(firstNavRoute.hasClass('middle')).toBe(true);
+  });
+
   it('should render pager button', () => {
     SETTINGS.feature.pagerDuty = true;
     const app = ApplicationModelBuilder.createApplicationForTests('testapp');
@@ -83,7 +96,7 @@ describe('ApplicationNavigation', () => {
 
     const wrapper = mount(
       <RecoilRoot>
-        <UIRouterContext.Provider value={$uiRouter}>
+        <UIRouterContext.Provider value={router}>
           <ApplicationNavigation app={app} />
         </UIRouterContext.Provider>
       </RecoilRoot>,
@@ -98,7 +111,7 @@ describe('ApplicationNavigation', () => {
 
     const wrapper = mount(
       <RecoilRoot>
-        <UIRouterContext.Provider value={$uiRouter}>
+        <UIRouterContext.Provider value={router}>
           <ApplicationNavigation app={app} />
         </UIRouterContext.Provider>
       </RecoilRoot>,
@@ -130,7 +143,7 @@ describe('ApplicationNavigation', () => {
 
     const wrapper = mount(
       <RecoilRoot>
-        <UIRouterContext.Provider value={$uiRouter}>
+        <UIRouterContext.Provider value={router}>
           <ApplicationNavigation app={app} />
         </UIRouterContext.Provider>
       </RecoilRoot>,

package/src/application/nav/ApplicationNavigation.tsx

@@ -43,15 +43,13 @@ export const ApplicationNavigation = ({ app }: IApplicationNavigationProps) => {
   const initialCategories = getNavigationCategories(app.dataSources);
   const [navSections, setNavSections] = React.useState(initialCategories);
 
-  const appRefreshSubscription = app.onRefresh(null, () => {
-    if (!isEqual(app.attributes.dataSources, prevDataSourceAttr)) {
-      const categories = getNavigationCategories(app.dataSources);
-      setNavSections(categories);
-    }
-  });
-
   React.useEffect(() => {
-    const unsubscribe = appRefreshSubscription();
+    const unsubscribe = app.onRefresh(() => {
+      if (!isEqual(app.attributes.dataSources, prevDataSourceAttr)) {
+        const categories = getNavigationCategories(app.dataSources);
+        setNavSections(categories);
+      }
+    });
     return unsubscribe;
   }, []);
 

package/src/application/nav/navigationCategory.registry.ts

@@ -43,6 +43,11 @@ export class NavigationCategoryRegistry {
     const { key, order } = category;
     return this.orderOverrides.has(key) ? this.orderOverrides.get(key) : order;
   }
+
+  public clearCategories(): void {
+    this.categories.length = 0;
+    this.orderOverrides.clear();
+  }
 }
 
 export const navigationCategoryRegistry = new NavigationCategoryRegistry();

package/src/application/search/Applications.spec.tsx

@@ -0,0 +1,40 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { ApplicationsComponent } from './Applications';
+import { CreateApplicationModal } from '../modal/CreateApplicationModal';
+import { ApplicationReader } from '../service/ApplicationReader';
+
+describe('Applications create deep link', () => {
+  const renderApplications = (stateParams: Record<string, any>, go = jasmine.createSpy('go')) => ({
+    go,
+    wrapper: shallow(
+      <ApplicationsComponent router={{} as any} stateParams={stateParams} stateService={{ go } as any} />,
+    ),
+  });
+
+  it('opens the direct modal and routes to the created application', async () => {
+    spyOn(ApplicationReader, 'listApplications').and.returnValue(Promise.resolve([]));
+    spyOn(CreateApplicationModal, 'show').and.returnValue(Promise.resolve({ name: 'myapp' }) as any);
+
+    const { go, wrapper } = renderApplications({ create: 'myapp' });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(CreateApplicationModal.show).toHaveBeenCalledWith('myapp');
+    expect(go).toHaveBeenCalledWith('home.applications.application', { application: 'myapp', create: null });
+    wrapper.unmount();
+  });
+
+  it('clears the create query parameter when the direct modal is dismissed', async () => {
+    spyOn(ApplicationReader, 'listApplications').and.returnValue(Promise.resolve([]));
+    spyOn(CreateApplicationModal, 'show').and.returnValue(Promise.reject('cancel'));
+
+    const { go, wrapper } = renderApplications({ create: 'myapp' });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(go).toHaveBeenCalledWith('home.applications', { create: null });
+    wrapper.unmount();
+  });
+});

package/src/application/search/Applications.tsx

@@ -8,11 +8,12 @@ import { distinctUntilChanged, map, takeUntil } from 'rxjs/operators';
 import { ApplicationTable } from './ApplicationsTable';
 import { PaginationControls } from './PaginationControls';
 import type { IAccount } from '../../account';
-import type { Application } from '../../application';
 import type { ICache } from '../../cache';
 import { ViewStateCache } from '../../cache';
 import { InsightMenu } from '../../insight/InsightMenu';
-import { ModalInjector, ReactInjector } from '../../reactShims';
+import { CreateApplicationModal } from '../modal/CreateApplicationModal';
+import type { IRouterInjectedProps } from '../../navigation/routerContext';
+import { withRouter } from '../../navigation/routerContext';
 import type { IApplicationSummary } from '../service/ApplicationReader';
 import { ApplicationReader } from '../service/ApplicationReader';
 import { Spinner } from '../../widgets';
@@ -41,7 +42,7 @@ export interface IApplicationsState {
   pagination: IApplicationPagination;
 }
 
-export class Applications extends React.Component<{}, IApplicationsState> {
+export class ApplicationsComponent extends React.Component<IRouterInjectedProps, IApplicationsState> {
   private applicationsCache: ICache;
 
   private filter$ = new BehaviorSubject<string>(null);
@@ -49,7 +50,7 @@ export class Applications extends React.Component<{}, IApplicationsState> {
   private pagination$ = new BehaviorSubject<IApplicationPagination>(this.getDefaultPagination());
   private destroy$ = new Subject();
 
-  constructor(props: {}) {
+  constructor(props: IRouterInjectedProps) {
     super(props);
     this.applyCachedViewState();
     const pagination = this.getDefaultPagination();
@@ -120,44 +121,29 @@ export class Applications extends React.Component<{}, IApplicationsState> {
         },
       );
 
-    const { $stateParams, $state, $rootScope, overrideRegistry } = ReactInjector;
-    const { create } = $stateParams as IApplicationsStateParams;
+    const { stateParams, stateService } = this.props;
+    const { create } = stateParams as IApplicationsStateParams;
     applicationSummaries$.subscribe((applications: IApplicationSummary[]) => {
       if (create) {
         const found = applications.find((app) => app.name === create);
         if (found) {
           if (found.email) {
             // Application already exists - redirect to app
-            $state.go('home.applications.application', { application: create, create: null });
+            stateService.go('home.applications.application', { application: create, create: null });
           } else {
             // Inferred application - redirect to config
-            $state.go('home.applications.application.config', { application: create, create: null });
+            stateService.go('home.applications.application.config', { application: create, create: null });
           }
         } else {
-          // Nonexistant application - open create modal
-          ModalInjector.modalService
-            .open({
-              scope: $rootScope.$new(),
-              templateUrl: overrideRegistry.getTemplate(
-                'createApplicationModal',
-                require('../modal/newapplication.html'),
-              ),
-              resolve: {
-                name: () => create,
-              },
-              controller: overrideRegistry.getController('CreateApplicationModalCtrl'),
-              controllerAs: 'newAppModal',
-            })
-            .result.then(
-              (app: Application) => {
-                $state.go('home.applications.application', { application: app.name, create: null });
-              },
-              () => {
-                // Clear out the query parameter if the dialog is dismissed
-                $state.go('home.applications', { create: null });
-              },
-            )
-            .catch(() => {});
+          CreateApplicationModal.show(create).then(
+            (app) => {
+              stateService.go('home.applications.application', { application: app.name, create: null });
+            },
+            () => {
+              // Clear out the query parameter if the dialog is dismissed
+              stateService.go('home.applications', { create: null });
+            },
+          );
         }
       }
     });
@@ -265,3 +251,6 @@ export class Applications extends React.Component<{}, IApplicationsState> {
     );
   }
 }
+
+export const Applications = withRouter(ApplicationsComponent);
+Applications.displayName = 'Applications';

package/src/application/service/ApplicationDataSourceRegistry.ts

@@ -42,6 +42,10 @@ export class ApplicationDataSourceRegistry {
     return cloneDeep(this.dataSources);
   }
 
+  public static hasDataSource(config: IDataSourceConfig<any>): boolean {
+    return this.dataSources.includes(config);
+  }
+
   public static removeDataSource(key: string): void {
     this.dataSources = this.dataSources.filter((data) => {
       return data.key !== key;

package/src/application/service/ApplicationReader.spec.ts

@@ -1,54 +1,46 @@
-import { mock } from 'angular';
-
 import { ApplicationDataSourceRegistry } from './ApplicationDataSourceRegistry';
 import type { IApplicationDataSourceAttribute } from './ApplicationReader';
 import { ApplicationReader } from './ApplicationReader';
 import { mockHttpClient } from '../../api/mock/jasmine';
 import type { Application } from '../application.model';
 import type { ClusterService } from '../../cluster/cluster.service';
-import { CLUSTER_SERVICE } from '../../cluster/cluster.service';
-import { LOAD_BALANCER_DATA_SOURCE } from '../../loadBalancer/loadBalancer.dataSource';
+import { registerLoadBalancerDataSource } from '../../loadBalancer/loadBalancer.dataSource';
 import type { LoadBalancerReader } from '../../loadBalancer/loadBalancer.read.service';
-import { LOAD_BALANCER_READ_SERVICE } from '../../loadBalancer/loadBalancer.read.service';
-import { SECURITY_GROUP_DATA_SOURCE } from '../../securityGroup/securityGroup.dataSource';
+import { registerSecurityGroupDataSource } from '../../securityGroup/securityGroup.dataSource';
 import type { SecurityGroupReader } from '../../securityGroup/securityGroupReader.service';
-import { SECURITY_GROUP_READER } from '../../securityGroup/securityGroupReader.service';
-import { SERVER_GROUP_DATA_SOURCE } from '../../serverGroup/serverGroup.dataSource';
+import { registerServerGroupDataSource } from '../../serverGroup/serverGroup.dataSource';
+import { nativePromiseService } from '../../utils/nativePromiseService';
 
 import Spy = jasmine.Spy;
 
 describe('ApplicationReader', function () {
   let securityGroupReader: SecurityGroupReader;
-  let loadBalancerReader: any;
+  let loadBalancerReader: LoadBalancerReader;
   let clusterService: ClusterService;
-  let $q: ng.IQService;
-
-  beforeEach(() => ApplicationDataSourceRegistry.clearDataSources());
 
-  beforeEach(
-    mock.module(
-      SECURITY_GROUP_DATA_SOURCE,
-      SERVER_GROUP_DATA_SOURCE,
-      LOAD_BALANCER_DATA_SOURCE,
-      SECURITY_GROUP_READER,
-      CLUSTER_SERVICE,
-      LOAD_BALANCER_READ_SERVICE,
-    ),
-  );
+  beforeEach(() => {
+    ApplicationDataSourceRegistry.clearDataSources();
+    securityGroupReader = {
+      loadSecurityGroupsByApplicationName: () => Promise.resolve([]),
+      loadSecurityGroups: () => Promise.resolve([]),
+      getApplicationSecurityGroups: () => Promise.resolve([]),
+    } as any;
+    loadBalancerReader = { loadLoadBalancers: () => Promise.resolve([]) } as any;
+    clusterService = {
+      loadServerGroups: () => Promise.resolve([]),
+      createServerGroupClusters: () => [],
+      addServerGroupsToApplication: (_application: Application, serverGroups: any[]) => serverGroups,
+      addTasksToServerGroups: () => undefined,
+      addExecutionsToServerGroups: () => undefined,
+    } as any;
+    registerSecurityGroupDataSource(securityGroupReader);
+    registerServerGroupDataSource(clusterService);
+    registerLoadBalancerDataSource(nativePromiseService, loadBalancerReader);
+  });
 
-  beforeEach(
-    mock.inject(function (
-      _securityGroupReader_: SecurityGroupReader,
-      _clusterService_: ClusterService,
-      _$q_: ng.IQService,
-      _loadBalancerReader_: LoadBalancerReader,
-    ) {
-      securityGroupReader = _securityGroupReader_;
-      clusterService = _clusterService_;
-      loadBalancerReader = _loadBalancerReader_;
-      $q = _$q_;
-    }),
-  );
+  afterEach(() => {
+    ApplicationDataSourceRegistry.clearDataSources();
+  });
 
   describe('load application', function () {
     let application: Application = null;
@@ -60,21 +52,20 @@ describe('ApplicationReader', function () {
         response.attributes['dataSources'] = dataSources;
       }
       http.expectGET('/applications/deck').respond(200, response);
-      spyOn(securityGroupReader, 'loadSecurityGroupsByApplicationName').and.returnValue($q.when([]));
-      spyOn(loadBalancerReader, 'loadLoadBalancers').and.returnValue($q.when([]));
-      spyOn(clusterService, 'loadServerGroups').and.returnValue($q.when([]));
-      spyOn(securityGroupReader, 'loadSecurityGroups').and.returnValue($q.when([] as any));
+      spyOn(securityGroupReader, 'loadSecurityGroupsByApplicationName').and.returnValue(Promise.resolve([]));
+      spyOn(loadBalancerReader, 'loadLoadBalancers').and.returnValue(Promise.resolve([]));
+      spyOn(clusterService, 'loadServerGroups').and.returnValue(Promise.resolve([]));
+      spyOn(securityGroupReader, 'loadSecurityGroups').and.returnValue(Promise.resolve([] as any));
       spyOn(securityGroupReader, 'getApplicationSecurityGroups').and.callFake(function (
         _app: Application,
         groupsByName: any,
       ) {
-        return $q.when(groupsByName || []);
+        return Promise.resolve(groupsByName || []);
       });
 
-      ApplicationReader.getApplication('deck').then((app) => {
-        application = app;
-      });
+      const applicationPromise = ApplicationReader.getApplication('deck');
       await http.flush();
+      application = await applicationPromise;
     }
 
     it('loads all data sources if dataSource attribute is missing', async function () {

package/src/application/service/ApplicationReader.ts

@@ -24,11 +24,11 @@ export interface IApplicationSummary {
 }
 
 export class ApplicationReader {
-  public static listApplications(): PromiseLike<IApplicationSummary[]> {
+  public static listApplications(): Promise<IApplicationSummary[]> {
     return REST('/applications').useCache().get();
   }
 
-  public static getApplicationAttributes(name: string): PromiseLike<any> {
+  public static getApplicationAttributes(name: string): Promise<any> {
     return REST('/applications')
       .path(name)
       .query({ expand: false })
@@ -39,7 +39,7 @@ export class ApplicationReader {
       });
   }
 
-  public static getApplicationPermissions(applicationName: string): PromiseLike<any> {
+  public static getApplicationPermissions(applicationName: string): Promise<any> {
     return REST('/applications')
       .path(applicationName)
       .query({
@@ -51,7 +51,7 @@ export class ApplicationReader {
       });
   }
 
-  public static getApplication(name: string, expand = true): PromiseLike<Application> {
+  public static getApplication(name: string, expand = true): Promise<Application> {
     return REST('/applications')
       .path(name)
       .query({ expand: expand })

package/src/application/service/ApplicationWriter.spec.ts

@@ -1,5 +1,3 @@
-import { mock } from 'angular';
-
 import type { IApplicationAttributes } from './ApplicationWriter';
 import { ApplicationWriter } from './ApplicationWriter';
 import type { IJob } from '../../task/taskExecutor';
@@ -7,14 +5,6 @@ import { TaskExecutor } from '../../task/taskExecutor';
 import Spy = jasmine.Spy;
 
 describe('ApplicationWriter', function () {
-  let $q: ng.IQService;
-
-  beforeEach(
-    mock.inject(function (_$q_: ng.IQService) {
-      $q = _$q_;
-    }),
-  );
-
   describe('update an application', function () {
     it('should execute task', function () {
       spyOn(TaskExecutor, 'executeTask');
@@ -47,7 +37,7 @@ describe('ApplicationWriter', function () {
 
   describe('delete an application', function () {
     it('should execute task', function () {
-      spyOn(TaskExecutor, 'executeTask').and.returnValue($q.when({} as any));
+      spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({} as any));
 
       const application: IApplicationAttributes = {
         name: 'foo',

package/src/application/service/ApplicationWriter.ts

@@ -13,7 +13,7 @@ export interface IApplicationAttributes {
 }
 
 export class ApplicationWriter {
-  public static createApplication(application: IApplicationAttributes): PromiseLike<ITask> {
+  public static createApplication(application: IApplicationAttributes): Promise<ITask> {
     const jobs: IJob[] = this.buildJobs(application, 'createApplication', cloneDeep);
     return TaskExecutor.executeTask({
       job: jobs,
@@ -22,7 +22,7 @@ export class ApplicationWriter {
     });
   }
 
-  public static updateApplication(application: IApplicationAttributes): PromiseLike<ITask> {
+  public static updateApplication(application: IApplicationAttributes): Promise<ITask> {
     const jobs: IJob[] = this.buildJobs(application, 'updateApplication', cloneDeep);
     return TaskExecutor.executeTask({
       job: jobs,
@@ -31,7 +31,7 @@ export class ApplicationWriter {
     });
   }
 
-  public static deleteApplication(application: IApplicationAttributes): PromiseLike<ITask> {
+  public static deleteApplication(application: IApplicationAttributes): Promise<ITask> {
     const jobs: IJob[] = this.buildJobs(application, 'deleteApplication', (app: IApplicationAttributes): any => {
       return { name: app.name };
     });