@spinnaker/core 2026.2.2 → 2026.3.0

package/src/instance/instance.write.service.spec.ts

@@ -1,32 +1,18 @@
-import { mock } from 'angular';
-
 import type { Application } from '../application/application.model';
 import { ApplicationModelBuilder } from '../application/applicationModel.builder';
-import { PROVIDER_SERVICE_DELEGATE } from '../cloudProvider';
 import type { IInstance, IServerGroup } from '../domain';
 import type { IMultiInstanceGroup } from './instance.write.service';
 import { InstanceWriter } from './instance.write.service';
-import { REACT_MODULE } from '../reactShims';
 import { ServerGroupReader } from '../serverGroup/serverGroupReader.service';
 import * as State from '../state';
 import type { IJob, ITaskCommand } from '../task/taskExecutor';
 import { TaskExecutor } from '../task/taskExecutor';
 
 describe('Service: instance writer', function () {
-  let $q: ng.IQService;
-  let $scope: ng.IScope;
-
-  beforeEach(mock.module(REACT_MODULE, PROVIDER_SERVICE_DELEGATE));
-  beforeEach(
-    mock.inject((_$q_: ng.IQService, $rootScope: ng.IRootScopeService) => {
-      $q = _$q_;
-      $scope = $rootScope.$new();
-      State.initialize();
-    }),
-  );
+  beforeEach(() => State.initialize());
 
   describe('terminate and decrement server group', () => {
-    it('should set setMaxToNewDesired flag based on current server group capacity', function () {
+    it('should set setMaxToNewDesired flag based on current server group capacity', async function () {
       const serverGroup = {
         asg: {
           minSize: 4,
@@ -55,19 +41,77 @@ describe('Service: instance writer', function () {
         executedTask = task.job[0];
         return undefined;
       });
-      spyOn(ServerGroupReader, 'getServerGroup').and.returnValue($q.when(serverGroup as any));
+      spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(Promise.resolve(serverGroup as any));
 
-      InstanceWriter.terminateInstanceAndShrinkServerGroup(instance, application, {});
-      $scope.$digest();
-      $scope.$digest();
+      await InstanceWriter.terminateInstanceAndShrinkServerGroup(instance, application, {});
 
       expect(TaskExecutor.executeTask).toHaveBeenCalled();
       expect(executedTask['setMaxToNewDesired']).toBe(true);
     });
   });
 
+  describe('single-instance discovery operations', () => {
+    const instance: IInstance = {
+      account: 'test',
+      cloudProvider: 'gce',
+      health: [],
+      healthState: 'Up',
+      id: 'instance-1',
+      launchTime: 1,
+      name: 'instance-1',
+      region: 'us-central1',
+      serverGroup: 'fnord-v001',
+      zone: 'us-central1-a',
+    };
+    const application: Application = ApplicationModelBuilder.createApplicationForTests('app');
+    let task: ITaskCommand;
+
+    beforeEach(() => {
+      task = null;
+      spyOn(TaskExecutor, 'executeTask').and.callFake((command: ITaskCommand) => {
+        task = command;
+        return undefined;
+      });
+    });
+
+    it('includes confirmation params in the enable task payload', () => {
+      InstanceWriter.enableInstanceInDiscovery(instance, application, { reason: 'operator requested' });
+
+      expect(task.job).toEqual([
+        {
+          asgName: 'fnord-v001',
+          cloudProvider: 'gce',
+          credentials: 'test',
+          instanceIds: ['instance-1'],
+          reason: 'operator requested',
+          region: 'us-central1',
+          serverGroupName: 'fnord-v001',
+          type: 'enableInstancesInDiscovery',
+        },
+      ]);
+    });
+
+    it('includes confirmation params in the disable task payload', () => {
+      InstanceWriter.disableInstanceInDiscovery(instance, application, { reason: 'operator requested' });
+
+      expect(task.job).toEqual([
+        {
+          asgName: 'fnord-v001',
+          cloudProvider: 'gce',
+          credentials: 'test',
+          instanceIds: ['instance-1'],
+          reason: 'operator requested',
+          region: 'us-central1',
+          serverGroupName: 'fnord-v001',
+          type: 'disableInstancesInDiscovery',
+        },
+      ]);
+    });
+  });
+
   describe('multi-instance operations', () => {
     let task: ITaskCommand, serverGroupA: IServerGroup, serverGroupB: IServerGroup;
+    const providerServiceDelegate = { hasDelegate: () => false } as any;
 
     function getInstanceGroup(serverGroup: IServerGroup): IMultiInstanceGroup {
       return State.ClusterState.multiselectModel.getOrCreateInstanceGroup(serverGroup);
@@ -126,7 +170,11 @@ describe('Service: instance writer', function () {
         zone: 'a',
         launchTime: 2,
       });
-      InstanceWriter.terminateInstances([getInstanceGroup(serverGroupA), getInstanceGroup(serverGroupB)], application);
+      InstanceWriter.terminateInstances(
+        [getInstanceGroup(serverGroupA), getInstanceGroup(serverGroupB)],
+        application,
+        providerServiceDelegate,
+      );
 
       expect(task.job.length).toBe(1);
 
@@ -158,7 +206,11 @@ describe('Service: instance writer', function () {
         zone: 'a',
         launchTime: 2,
       });
-      InstanceWriter.terminateInstancesAndShrinkServerGroups([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.terminateInstancesAndShrinkServerGroups(
+        [getInstanceGroup(serverGroupA)],
+        application,
+        providerServiceDelegate,
+      );
 
       expect(task.job.length).toBe(1);
 
@@ -185,7 +237,7 @@ describe('Service: instance writer', function () {
         launchTime: 2,
       });
 
-      InstanceWriter.terminateInstances([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.terminateInstances([getInstanceGroup(serverGroupA)], application, providerServiceDelegate);
       expect(task.description).toBe('Terminate 1 instance');
 
       addInstance(serverGroupA, {
@@ -196,7 +248,7 @@ describe('Service: instance writer', function () {
         zone: 'a',
         launchTime: 1,
       });
-      InstanceWriter.terminateInstances([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.terminateInstances([getInstanceGroup(serverGroupA)], application, providerServiceDelegate);
       expect(task.description).toBe('Terminate 2 instances');
     });
 
@@ -211,7 +263,7 @@ describe('Service: instance writer', function () {
         launchTime: 2,
       });
 
-      InstanceWriter.rebootInstances([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.rebootInstances([getInstanceGroup(serverGroupA)], application, providerServiceDelegate);
       expect(task.description).toBe('Reboot 1 instance');
 
       addInstance(serverGroupA, {
@@ -222,7 +274,7 @@ describe('Service: instance writer', function () {
         zone: 'a',
         launchTime: 1,
       });
-      InstanceWriter.rebootInstances([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.rebootInstances([getInstanceGroup(serverGroupA)], application, providerServiceDelegate);
       expect(task.description).toBe('Reboot 2 instances');
     });
 
@@ -237,7 +289,11 @@ describe('Service: instance writer', function () {
         launchTime: 2,
       });
 
-      InstanceWriter.disableInstancesInDiscovery([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.disableInstancesInDiscovery(
+        [getInstanceGroup(serverGroupA)],
+        application,
+        providerServiceDelegate,
+      );
       expect(task.description).toBe('Disable 1 instance in discovery');
 
       addInstance(serverGroupA, {
@@ -248,7 +304,11 @@ describe('Service: instance writer', function () {
         zone: 'a',
         launchTime: 1,
       });
-      InstanceWriter.disableInstancesInDiscovery([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.disableInstancesInDiscovery(
+        [getInstanceGroup(serverGroupA)],
+        application,
+        providerServiceDelegate,
+      );
       expect(task.description).toBe('Disable 2 instances in discovery');
     });
 
@@ -263,7 +323,7 @@ describe('Service: instance writer', function () {
         launchTime: 2,
       });
 
-      InstanceWriter.enableInstancesInDiscovery([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.enableInstancesInDiscovery([getInstanceGroup(serverGroupA)], application, providerServiceDelegate);
       expect(task.description).toBe('Enable 1 instance in discovery');
 
       addInstance(serverGroupA, {
@@ -274,7 +334,7 @@ describe('Service: instance writer', function () {
         zone: 'a',
         launchTime: 1,
       });
-      InstanceWriter.enableInstancesInDiscovery([getInstanceGroup(serverGroupA)], application);
+      InstanceWriter.enableInstancesInDiscovery([getInstanceGroup(serverGroupA)], application, providerServiceDelegate);
       expect(task.description).toBe('Enable 2 instances in discovery');
     });
   });

package/src/instance/instance.write.service.ts

@@ -1,6 +1,6 @@
 import type { Application } from '../application/application.model';
+import type { ProviderServiceDelegate } from '../cloudProvider/providerService.delegate';
 import type { IInstance, IServerGroup, ITask } from '../domain';
-import { ReactInjector } from '../reactShims';
 import { ServerGroupReader } from '../serverGroup/serverGroupReader.service';
 import type { IJob } from '../task/taskExecutor';
 import { TaskExecutor } from '../task/taskExecutor';
@@ -28,11 +28,7 @@ export interface IMultiInstanceJob {
 }
 
 export class InstanceWriter {
-  public static terminateInstance(
-    instance: IInstance,
-    application: Application,
-    params: IJob = {},
-  ): PromiseLike<ITask> {
+  public static terminateInstance(instance: IInstance, application: Application, params: IJob = {}): Promise<ITask> {
     params.type = 'terminateInstances';
     params['instanceIds'] = [instance.id];
     params['region'] = instance.region;
@@ -49,19 +45,32 @@ export class InstanceWriter {
   public static terminateInstances(
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
-  ): PromiseLike<ITask> {
-    return InstanceWriter.executeMultiInstanceTask(instanceGroups, application, 'terminateInstances', 'Terminate');
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
+    return InstanceWriter.executeMultiInstanceTask(
+      instanceGroups,
+      application,
+      providerServiceDelegate,
+      'terminateInstances',
+      'Terminate',
+    );
   }
 
   private static executeMultiInstanceTask(
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
+    providerServiceDelegate: ProviderServiceDelegate,
     type: string,
     baseDescriptor: string,
     descriptorSuffix?: string,
     additionalJobProperties: any = {},
-  ): PromiseLike<ITask> {
-    const jobs = InstanceWriter.buildMultiInstanceJob(instanceGroups, type, additionalJobProperties);
+  ): Promise<ITask> {
+    const jobs = InstanceWriter.buildMultiInstanceJob(
+      instanceGroups,
+      providerServiceDelegate,
+      type,
+      additionalJobProperties,
+    );
     const descriptor = InstanceWriter.buildMultiInstanceDescriptor(jobs, baseDescriptor, descriptorSuffix);
     return TaskExecutor.executeTask({
       job: jobs,
@@ -70,11 +79,21 @@ export class InstanceWriter {
     });
   }
 
-  public static rebootInstances(instanceGroups: IMultiInstanceGroup[], application: Application): PromiseLike<ITask> {
-    return InstanceWriter.executeMultiInstanceTask(instanceGroups, application, 'rebootInstances', 'Reboot');
+  public static rebootInstances(
+    instanceGroups: IMultiInstanceGroup[],
+    application: Application,
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
+    return InstanceWriter.executeMultiInstanceTask(
+      instanceGroups,
+      application,
+      providerServiceDelegate,
+      'rebootInstances',
+      'Reboot',
+    );
   }
 
-  public static rebootInstance(instance: IInstance, application: Application, params: any = {}): PromiseLike<ITask> {
+  public static rebootInstance(instance: IInstance, application: Application, params: any = {}): Promise<ITask> {
     params.type = 'rebootInstances';
     params.instanceIds = [instance.id];
     params.region = instance.region;
@@ -94,8 +113,13 @@ export class InstanceWriter {
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
     loadBalancerNames: string[],
-  ): PromiseLike<ITask> {
-    const jobs = InstanceWriter.buildMultiInstanceJob(instanceGroups, 'deregisterInstancesFromLoadBalancer');
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
+    const jobs = InstanceWriter.buildMultiInstanceJob(
+      instanceGroups,
+      providerServiceDelegate,
+      'deregisterInstancesFromLoadBalancer',
+    );
     jobs.forEach((job) => (job.loadBalancerNames = loadBalancerNames));
     const descriptor = InstanceWriter.buildMultiInstanceDescriptor(
       jobs,
@@ -113,7 +137,7 @@ export class InstanceWriter {
     instance: IInstance,
     application: Application,
     params: any = {},
-  ): PromiseLike<ITask> {
+  ): Promise<ITask> {
     params.type = 'deregisterInstancesFromLoadBalancer';
     params.instanceIds = [instance.id];
     params.loadBalancerNames = instance.loadBalancers;
@@ -131,8 +155,13 @@ export class InstanceWriter {
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
     loadBalancerNames: string[],
-  ): PromiseLike<ITask> {
-    const jobs = InstanceWriter.buildMultiInstanceJob(instanceGroups, 'registerInstancesWithLoadBalancer');
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
+    const jobs = InstanceWriter.buildMultiInstanceJob(
+      instanceGroups,
+      providerServiceDelegate,
+      'registerInstancesWithLoadBalancer',
+    );
     jobs.forEach((job) => (job.loadBalancerNames = loadBalancerNames));
     const descriptor = InstanceWriter.buildMultiInstanceDescriptor(
       jobs,
@@ -150,7 +179,7 @@ export class InstanceWriter {
     instance: IInstance,
     application: Application,
     params: any = {},
-  ): PromiseLike<ITask> {
+  ): Promise<ITask> {
     params.type = 'registerInstancesWithLoadBalancer';
     params.instanceIds = [instance.id];
     params.loadBalancerNames = instance.loadBalancers;
@@ -167,20 +196,27 @@ export class InstanceWriter {
   public static enableInstancesInDiscovery(
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
-  ): PromiseLike<ITask> {
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
     return InstanceWriter.executeMultiInstanceTask(
       instanceGroups,
       application,
+      providerServiceDelegate,
       'enableInstancesInDiscovery',
       'Enable',
       'in discovery',
     );
   }
 
-  public static enableInstanceInDiscovery(instance: IInstance, application: Application): PromiseLike<ITask> {
+  public static enableInstanceInDiscovery(
+    instance: IInstance,
+    application: Application,
+    params: IJob = {},
+  ): Promise<ITask> {
     return TaskExecutor.executeTask({
       job: [
         {
+          ...params,
           type: 'enableInstancesInDiscovery',
           instanceIds: [instance.id],
           region: instance.region,
@@ -198,20 +234,27 @@ export class InstanceWriter {
   public static disableInstancesInDiscovery(
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
-  ): PromiseLike<ITask> {
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
     return InstanceWriter.executeMultiInstanceTask(
       instanceGroups,
       application,
+      providerServiceDelegate,
       'disableInstancesInDiscovery',
       'Disable',
       'in discovery',
     );
   }
 
-  public static disableInstanceInDiscovery(instance: IInstance, application: Application): PromiseLike<ITask> {
+  public static disableInstanceInDiscovery(
+    instance: IInstance,
+    application: Application,
+    params: IJob = {},
+  ): Promise<ITask> {
     return TaskExecutor.executeTask({
       job: [
         {
+          ...params,
           type: 'disableInstancesInDiscovery',
           instanceIds: [instance.id],
           region: instance.region,
@@ -229,10 +272,12 @@ export class InstanceWriter {
   public static terminateInstancesAndShrinkServerGroups(
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
-  ): PromiseLike<ITask> {
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
     return InstanceWriter.executeMultiInstanceTask(
       instanceGroups,
       application,
+      providerServiceDelegate,
       'detachInstances',
       'Terminate',
       'and shrink server groups',
@@ -248,7 +293,7 @@ export class InstanceWriter {
     instance: IInstance,
     application: Application,
     params: any = {},
-  ): PromiseLike<ITask> {
+  ): Promise<ITask> {
     return ServerGroupReader.getServerGroup(
       application.name,
       instance.account,
@@ -275,12 +320,15 @@ export class InstanceWriter {
 
   protected static buildMultiInstanceJob(
     instanceGroups: IMultiInstanceGroup[],
+    providerServiceDelegate: ProviderServiceDelegate,
     type: string,
     additionalJobProperties = {},
   ) {
     return instanceGroups
       .filter((instanceGroup) => instanceGroup.instances.length > 0)
-      .map((instanceGroup) => InstanceWriter.convertGroupToJob(instanceGroup, type, additionalJobProperties));
+      .map((instanceGroup) =>
+        InstanceWriter.convertGroupToJob(instanceGroup, providerServiceDelegate, type, additionalJobProperties),
+      );
   }
 
   protected static buildMultiInstanceDescriptor(jobs: IMultiInstanceJob[], base: string, suffix: string): string {
@@ -298,6 +346,7 @@ export class InstanceWriter {
 
   private static convertGroupToJob(
     instanceGroup: IMultiInstanceGroup,
+    providerServiceDelegate: ProviderServiceDelegate,
     type: string,
     additionalJobProperties: any = {},
   ): IMultiInstanceJob {
@@ -313,14 +362,17 @@ export class InstanceWriter {
 
     Object.assign(job, additionalJobProperties);
 
-    InstanceWriter.transform(instanceGroup, job);
+    InstanceWriter.transform(instanceGroup, job, providerServiceDelegate);
 
     return job;
   }
 
-  private static transform(instanceGroup: IMultiInstanceGroup, job: IMultiInstanceJob) {
+  private static transform(
+    instanceGroup: IMultiInstanceGroup,
+    job: IMultiInstanceJob,
+    providerServiceDelegate: ProviderServiceDelegate,
+  ) {
     const serviceKey = 'instance.multiInstanceTaskTransformer';
-    const { providerServiceDelegate } = ReactInjector;
     if (providerServiceDelegate.hasDelegate(instanceGroup.cloudProvider, serviceKey)) {
       const transformer: any = providerServiceDelegate.getDelegate(instanceGroup.cloudProvider, serviceKey);
       transformer.transform(instanceGroup, job);

package/src/instance/instanceSelection.less

@@ -5,9 +5,7 @@
   border-bottom: 0;
 }
 
-instance-archetype-selector,
-v2-instance-archetype-selector,
-v-2-instance-archetype-selector {
+.instance-archetype-selector {
   .archetype-columns {
     display: inline-block;
     button {

package/src/instance/instanceType.service.ts

@@ -1,7 +1,5 @@
-import { module } from 'angular';
 import { uniq } from 'lodash';
 import type { ProviderServiceDelegate } from '../cloudProvider/providerService.delegate';
-import { PROVIDER_SERVICE_DELEGATE } from '../cloudProvider/providerService.delegate';
 
 export interface IInstanceType {
   account: string;
@@ -46,6 +44,14 @@ export interface IInstanceTypeCategory {
   label?: string;
   families: IInstanceTypeFamily[];
   icon?: string;
+  description?: string;
+  stats?: {
+    families: string[];
+    cpu: { min: number; max: number };
+    memory: { min: number; max: number };
+    storage: { min: number; max: number };
+    costFactor?: number;
+  };
 }
 
 export interface IInstanceTypeService {
@@ -57,23 +63,22 @@ export interface IInstanceTypeService {
 }
 
 export class InstanceTypeService {
-  public static $inject = ['providerServiceDelegate'];
   public constructor(private providerServiceDelegate: ProviderServiceDelegate) {}
 
-  public getCategories(cloudProvider: string): PromiseLike<IInstanceTypeCategory[]> {
-    return this.getDelegate(cloudProvider).getCategories();
+  public getCategories(cloudProvider: string): Promise<IInstanceTypeCategory[]> {
+    return Promise.resolve(this.getDelegate(cloudProvider).getCategories());
   }
 
-  public getAllTypesByRegion(cloudProvider: string): PromiseLike<IInstanceTypesByRegion> {
-    return this.getDelegate(cloudProvider).getAllTypesByRegion();
+  public getAllTypesByRegion(cloudProvider: string): Promise<IInstanceTypesByRegion> {
+    return Promise.resolve(this.getDelegate(cloudProvider).getAllTypesByRegion());
   }
 
   public getAvailableTypesForRegions(
     cloudProvider: string,
     instanceTypes: string[],
     regions: string[],
-  ): PromiseLike<string[]> {
-    return this.getDelegate(cloudProvider).getAvailableTypesForRegions(instanceTypes, regions);
+  ): Promise<string[]> {
+    return Promise.resolve(this.getDelegate(cloudProvider).getAvailableTypesForRegions(instanceTypes, regions));
   }
 
   public getCategoryForInstanceType(cloudProvider: string, instanceType: string) {
@@ -91,7 +96,7 @@ export class InstanceTypeService {
     });
   }
 
-  public getInstanceTypeDetails(cloudProvider: string, instanceType: string): PromiseLike<IPreferredInstanceType> {
+  public getInstanceTypeDetails(cloudProvider: string, instanceType: string): Promise<IPreferredInstanceType> {
     return this.getInstanceTypeCategory(cloudProvider, instanceType).then((category: IInstanceTypeCategory) => {
       if (category && category.families && category.families.length && category.families[0].instanceTypes) {
         return category.families[0].instanceTypes.find((i) => i.name === instanceType);
@@ -104,7 +109,7 @@ export class InstanceTypeService {
     });
   }
 
-  private getInstanceTypeCategory(cloudProvider: string, instanceType: string): PromiseLike<IInstanceTypeCategory> {
+  private getInstanceTypeCategory(cloudProvider: string, instanceType: string): Promise<IInstanceTypeCategory> {
     return this.getCategories(cloudProvider).then((categories: IInstanceTypeCategory[]) => {
       return (categories || []).find((c) =>
         c.families.some((f) =>
@@ -121,6 +126,3 @@ export class InstanceTypeService {
     );
   }
 }
-
-export const INSTANCE_TYPE_SERVICE = 'spinnaker.core.instanceType.service';
-module(INSTANCE_TYPE_SERVICE, [PROVIDER_SERVICE_DELEGATE]).service('instanceTypeService', InstanceTypeService);

package/src/instance/instanceTypeService.spec.ts

@@ -1,10 +1,8 @@
-import { mock } from 'angular';
-
-import type { IInstanceTypeCategory, InstanceTypeService } from './instanceType.service';
-import { INSTANCE_TYPE_SERVICE } from './instanceType.service';
+import type { IInstanceTypeCategory } from './instanceType.service';
+import { InstanceTypeService } from './instanceType.service';
 
 describe('Service: instanceTypeService', function () {
-  let instanceTypeService: InstanceTypeService, $q: ng.IQService, $scope: ng.IScope;
+  let instanceTypeService: InstanceTypeService;
 
   const m3Category: IInstanceTypeCategory = {
     type: 'general',
@@ -48,85 +46,46 @@ describe('Service: instanceTypeService', function () {
 
   const categories: IInstanceTypeCategory[] = [m3Category, r3Category, t2Category, gceCustomInstanceCategory];
 
-  beforeEach(mock.module(INSTANCE_TYPE_SERVICE));
-
-  beforeEach(
-    mock.inject(function (
-      _instanceTypeService_: InstanceTypeService,
-      _$q_: ng.IQService,
-      $rootScope: ng.IRootScopeService,
-      providerServiceDelegate: any,
-    ) {
-      instanceTypeService = _instanceTypeService_;
-      $q = _$q_;
-      $scope = $rootScope.$new();
-
-      spyOn(providerServiceDelegate, 'getDelegate').and.returnValue({
-        getCategories: () => {
-          return $q.when(categories);
-        },
-      });
-    }),
-  );
+  beforeEach(() => {
+    instanceTypeService = new InstanceTypeService({
+      getDelegate: () => ({ getCategories: () => Promise.resolve(categories) }),
+    } as any);
+  });
 
   describe('find profile name for instance type', function () {
-    beforeEach(function () {
-      spyOn(instanceTypeService, 'getCategories').and.returnValue($q.when(categories));
-    });
-
     m3Category.families[0].instanceTypes.forEach(function (instanceType) {
-      it('should return "general" if the ' + instanceType.name + ' is in the "general" category', function () {
-        let result: string = null;
-        instanceTypeService.getCategoryForInstanceType('aws', instanceType.name).then(function (category) {
-          result = category;
-        });
-        $scope.$digest();
+      it('should return "general" if the ' + instanceType.name + ' is in the "general" category', async function () {
+        const result = await instanceTypeService.getCategoryForInstanceType('aws', instanceType.name);
         expect(result).toBe('general');
       });
     });
 
     r3Category.families[0].instanceTypes.forEach(function (instanceType) {
-      it('should return "memory" if the ' + instanceType.name + ' is in the "memory" category', function () {
-        let result: string = null;
-        instanceTypeService.getCategoryForInstanceType('aws', instanceType.name).then(function (category) {
-          result = category;
-        });
-        $scope.$digest();
+      it('should return "memory" if the ' + instanceType.name + ' is in the "memory" category', async function () {
+        const result = await instanceTypeService.getCategoryForInstanceType('aws', instanceType.name);
         expect(result).toBe('memory');
       });
     });
 
     t2Category.families[0].instanceTypes.forEach(function (instanceType) {
-      it('should return "micro" if the ' + instanceType.name + ' is in the "micro" category', function () {
-        let result: string = null;
-        instanceTypeService.getCategoryForInstanceType('aws', instanceType.name).then(function (category) {
-          result = category;
-        });
-        $scope.$digest();
+      it('should return "micro" if the ' + instanceType.name + ' is in the "micro" category', async function () {
+        const result = await instanceTypeService.getCategoryForInstanceType('aws', instanceType.name);
         expect(result).toBe('micro');
       });
     });
 
     const customTypes = ['c1.large', 'c3.large', 'c4.large', 'm2.large'];
     customTypes.forEach(function (instanceType) {
-      it('should return "custom" if the ' + instanceType + ' is not in a category', function () {
-        let result: string = null;
-        instanceTypeService.getCategoryForInstanceType('aws', instanceType).then(function (category) {
-          result = category;
-        });
-        $scope.$digest();
+      it('should return "custom" if the ' + instanceType + ' is not in a category', async function () {
+        const result = await instanceTypeService.getCategoryForInstanceType('aws', instanceType);
         expect(result).toBe('custom');
       });
     });
 
     const gceBuildCustomTypes = ['custom-1-2816', 'custom-6-9984'];
     gceBuildCustomTypes.forEach(function (instanceType) {
-      it('should return "buildCustom" for ' + instanceType, function () {
-        let result: string = null;
-        instanceTypeService.getCategoryForInstanceType('gce', instanceType).then(function (category) {
-          result = category;
-        });
-        $scope.$digest();
+      it('should return "buildCustom" for ' + instanceType, async function () {
+        const result = await instanceTypeService.getCategoryForInstanceType('gce', instanceType);
         expect(result).toBe('buildCustom');
       });
     });