@spinnaker/azure 2026.2.2 → 2026.3.0

package/src/azure.module.ts

@@ -1,95 +1,83 @@
-import { module } from 'angular';
-
 import { CloudProviderRegistry, DeploymentStrategyRegistry } from '@spinnaker/core';
 
 import './help/azure.help';
-import { AZURE_IMAGE_IMAGE_READER } from './image/image.reader';
-import { AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE } from './instance/azureInstanceType.service';
-import { AZURE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER } from './instance/details/instance.details.controller';
+import { AzureImageReader } from './image/image.reader';
+import { AzureInstanceTypeService } from './instance/azureInstanceType.service';
+import { AzureInstanceDetails } from './instance/details/AzureInstanceDetails';
 import { AzureLoadBalancerChoiceModal } from './loadBalancer/configure/AzureLoadBalancerChoiceModal';
-import { AZURE_LOADBALANCER_CONFIGURE_CREATELOADBALANCER_CONTROLLER } from './loadBalancer/configure/createLoadBalancer.controller';
-import { AZURE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER } from './loadBalancer/details/loadBalancerDetail.controller';
-import { AZURE_LOADBALANCER_LOADBALANCER_TRANSFORMER } from './loadBalancer/loadBalancer.transformer';
+import {
+  AzureLoadBalancerActions,
+  azureLoadBalancerDetailsSections,
+  useAzureLoadBalancerDetails,
+} from './loadBalancer/details/azureLoadBalancerDetails';
+import { AzureLoadBalancerTransformer } from './loadBalancer/loadBalancer.transformer';
 import logo from './logo/logo_azure.png';
-import { AZURE_PIPELINE_STAGES_BAKE_AZUREBAKESTAGE } from './pipeline/stages/bake/azureBakeStage';
-import { AZURE_PIPELINE_STAGES_DESTROYASG_AZUREDESTROYASGSTAGE } from './pipeline/stages/destroyAsg/azureDestroyAsgStage';
-import { AZURE_PIPELINE_STAGES_DISABLEASG_AZUREDISABLEASGSTAGE } from './pipeline/stages/disableAsg/azureDisableAsgStage';
-import { AZURE_PIPELINE_STAGES_ENABLEASG_AZUREENABLEASGSTAGE } from './pipeline/stages/enableAsg/azureEnableAsgStage';
-import { AZURE_SECURITYGROUP_CONFIGURE_CREATESECURITYGROUPCTRL } from './securityGroup/configure/CreateSecurityGroupCtrl';
-import { AZURE_SECURITYGROUP_CONFIGURE_EDITSECURITYGROUPCTRL } from './securityGroup/configure/EditSecurityGroupCtrl';
-import { AZURE_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER } from './securityGroup/details/securityGroupDetail.controller';
-import { AZURE_SECURITYGROUP_SECURITYGROUP_READER } from './securityGroup/securityGroup.reader';
-import { AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER } from './securityGroup/securityGroup.transformer';
-import { AZURE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_AZURE_MODULE } from './serverGroup/configure/serverGroup.configure.azure.module';
-import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_AZURE_CONTROLLER } from './serverGroup/configure/wizard/CloneServerGroup.azure.controller';
-import { AZURE_SERVERGROUP_DETAILS_SERVERGROUP_DETAILS_MODULE } from './serverGroup/details/serverGroup.details.module';
-import { AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER } from './serverGroup/serverGroup.transformer';
-import { AZURE_VALIDATION_APPLICATIONNAME_VALIDATOR } from './validation/applicationName.validator';
+import { registerAzureBakeStage } from './pipeline/stages/bake/azureBakeStage';
+import { registerAzureDestroyAsgStage } from './pipeline/stages/destroyAsg/azureDestroyAsgStage';
+import { registerAzureDisableAsgStage } from './pipeline/stages/disableAsg/azureDisableAsgStage';
+import { registerAzureEnableAsgStage } from './pipeline/stages/enableAsg/azureEnableAsgStage';
+import { AzureSecurityGroupModal } from './securityGroup/configure/AzureSecurityGroupModal';
+import { AzureSecurityGroupDetails } from './securityGroup/details/AzureSecurityGroupDetails';
+import { AzureSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { AzureSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { AzureServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { AzureServerGroupConfigurationService } from './serverGroup/configure/serverGroupConfiguration.service';
+import { AzureCloneServerGroupModal } from './serverGroup/configure/wizard/AzureCloneServerGroupModal';
+import {
+  AzureServerGroupActions,
+  azureServerGroupDetailsGetter,
+  azureServerGroupDetailsSections,
+} from './serverGroup/details/azureServerGroupDetails';
+import { AzureServerGroupTransformer } from './serverGroup/serverGroup.transformer';
+import './validation/applicationName.validator';
 
 import './logo/azure.logo.less';
 
-export const AZURE_MODULE = 'spinnaker.azure';
-module(AZURE_MODULE, [
-  AZURE_PIPELINE_STAGES_DESTROYASG_AZUREDESTROYASGSTAGE,
-  AZURE_PIPELINE_STAGES_ENABLEASG_AZUREENABLEASGSTAGE,
-  AZURE_PIPELINE_STAGES_DISABLEASG_AZUREDISABLEASGSTAGE,
-  AZURE_PIPELINE_STAGES_BAKE_AZUREBAKESTAGE,
-  AZURE_SERVERGROUP_DETAILS_SERVERGROUP_DETAILS_MODULE,
-  AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER,
-  AZURE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_AZURE_CONTROLLER,
-  AZURE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_AZURE_MODULE,
-  AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE,
-  AZURE_LOADBALANCER_LOADBALANCER_TRANSFORMER,
-  AZURE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER,
-  AZURE_LOADBALANCER_CONFIGURE_CREATELOADBALANCER_CONTROLLER,
-  AZURE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER,
-  AZURE_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER,
-  AZURE_SECURITYGROUP_CONFIGURE_CREATESECURITYGROUPCTRL,
-  AZURE_SECURITYGROUP_CONFIGURE_EDITSECURITYGROUPCTRL,
-  AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER,
-  AZURE_SECURITYGROUP_SECURITYGROUP_READER,
-  AZURE_IMAGE_IMAGE_READER,
-  AZURE_VALIDATION_APPLICATIONNAME_VALIDATOR,
-]).config(function () {
+export function registerAzureProvider(): void {
   CloudProviderRegistry.registerProvider('azure', {
     name: 'Azure',
     logo: {
       path: logo,
     },
     image: {
-      reader: 'azureImageReader',
+      reader: AzureImageReader,
     },
     serverGroup: {
-      transformer: 'azureServerGroupTransformer',
-      detailsTemplateUrl: require('./serverGroup/details/serverGroupDetails.html'),
-      detailsController: 'azureServerGroupDetailsCtrl',
-      cloneServerGroupTemplateUrl: require('./serverGroup/configure/wizard/serverGroupWizard.html'),
-      cloneServerGroupController: 'azureCloneServerGroupCtrl',
-      commandBuilder: 'azureServerGroupCommandBuilder',
-      configurationService: 'azureServerGroupConfigurationService',
+      transformer: AzureServerGroupTransformer,
+      commandBuilder: AzureServerGroupCommandBuilder,
+      configurationService: AzureServerGroupConfigurationService,
+      CloneServerGroupModal: AzureCloneServerGroupModal,
+      detailsGetter: azureServerGroupDetailsGetter,
+      detailsActions: AzureServerGroupActions,
+      detailsSections: azureServerGroupDetailsSections,
     },
     instance: {
-      instanceTypeService: 'azureInstanceTypeService',
-      detailsTemplateUrl: require('./instance/details/instanceDetails.html'),
-      detailsController: 'azureInstanceDetailsCtrl',
+      details: AzureInstanceDetails,
+      instanceTypeService: AzureInstanceTypeService,
     },
     loadBalancer: {
-      transformer: 'azureLoadBalancerTransformer',
-      detailsTemplateUrl: require('./loadBalancer/details/loadBalancerDetail.html'),
-      detailsController: 'azureLoadBalancerDetailsCtrl',
-      createLoadBalancerTemplateUrl: require('./loadBalancer/configure/createLoadBalancer.html'),
-      createLoadBalancerController: 'azureCreateLoadBalancerCtrl',
+      transformer: AzureLoadBalancerTransformer,
       CreateLoadBalancerModal: AzureLoadBalancerChoiceModal,
+      useDetailsHook: useAzureLoadBalancerDetails,
+      detailsActions: AzureLoadBalancerActions,
+      detailsSections: azureLoadBalancerDetailsSections,
     },
     securityGroup: {
-      transformer: 'azureSecurityGroupTransformer',
-      reader: 'azureSecurityGroupReader',
-      detailsTemplateUrl: require('./securityGroup/details/securityGroupDetail.html'),
-      detailsController: 'azureSecurityGroupDetailsCtrl',
-      createSecurityGroupTemplateUrl: require('./securityGroup/configure/createSecurityGroup.html'),
-      createSecurityGroupController: 'azureCreateSecurityGroupCtrl',
+      transformer: AzureSecurityGroupTransformer,
+      reader: AzureSecurityGroupReader,
+      CreateSecurityGroupModal: AzureSecurityGroupModal,
+      details: AzureSecurityGroupDetails,
     },
   });
-});
+}
+
+export function registerAzurePipelineStages(): void {
+  registerAzureDestroyAsgStage();
+  registerAzureEnableAsgStage();
+  registerAzureDisableAsgStage();
+  registerAzureBakeStage();
+}
 
+registerAzureProvider();
+registerAzurePipelineStages();
 DeploymentStrategyRegistry.registerProvider('azure', ['redblack']);

package/src/image/image.reader.js

@@ -1,13 +1,7 @@
-'use strict';
-
-import { module } from 'angular';
-
 import { REST } from '@spinnaker/core';
 
-export const AZURE_IMAGE_IMAGE_READER = 'spinnaker.azure.image.reader';
-export const name = AZURE_IMAGE_IMAGE_READER; // for backwards compatibility
-module(AZURE_IMAGE_IMAGE_READER, []).factory('azureImageReader', function () {
-  function findImages(params) {
+export class AzureImageReader {
+  findImages(params) {
     return REST('/images/find')
       .query(params)
       .get()
@@ -21,7 +15,7 @@ module(AZURE_IMAGE_IMAGE_READER, []).factory('azureImageReader', function () {
       );
   }
 
-  function getImage(amiName, region, credentials) {
+  getImage(amiName, region, credentials) {
     return REST('/images')
       .path(credentials, region, amiName)
       .query({ provider: 'azure' })
@@ -35,9 +29,4 @@ module(AZURE_IMAGE_IMAGE_READER, []).factory('azureImageReader', function () {
         },
       );
   }
-
-  return {
-    findImages: findImages,
-    getImage: getImage,
-  };
-});
+}

package/src/image/image.reader.spec.js

@@ -1,16 +1,13 @@
 'use strict';
 import { mockHttpClient } from 'core/api/mock/jasmine';
+import { AzureImageReader } from './image.reader';
 
 describe('Service: Azure Image Reader', function () {
   var service;
 
-  beforeEach(window.module(require('./image.reader').name));
-
-  beforeEach(
-    window.inject(function (azureImageReader) {
-      service = azureImageReader;
-    }),
-  );
+  beforeEach(function () {
+    service = new AzureImageReader();
+  });
 
   describe('findImages', function () {
     var query = 'abc',

package/src/instance/azureInstanceType.service.js

@@ -1,13 +1,7 @@
-'use strict';
-
-import { module } from 'angular';
 import _ from 'lodash';
 
-export const AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE = 'spinnaker.azure.instanceType.service';
-export const name = AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE; // for backwards compatibility
-module(AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE, []).factory('azureInstanceTypeService', [
-  '$q',
-  function ($q) {
+export class AzureInstanceTypeService {
+  constructor(promiseService) {
     const B = {
       type: 'B-series',
       description:
@@ -809,7 +803,7 @@ module(AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE, []).factory('azureInstanceTypeS
         }
         category.stats = buildStats(category);
       });
-      return $q.when(categories);
+      return promiseService.resolve(categories);
     }
 
     const getAllTypesByRegion = function getAllTypesByRegion() {
@@ -822,10 +816,8 @@ module(AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE, []).factory('azureInstanceTypeS
       return locationToInstanceTypesMap[location];
     }
 
-    return {
-      getCategories: getCategories,
-      getAvailableTypesForRegions: getAvailableTypesForRegions,
-      getAllTypesByRegion: getAllTypesByRegion,
-    };
-  },
-]);
+    this.getCategories = getCategories;
+    this.getAvailableTypesForRegions = getAvailableTypesForRegions;
+    this.getAllTypesByRegion = getAllTypesByRegion;
+  }
+}

package/src/instance/azureInstanceType.service.spec.js

@@ -1,17 +1,9 @@
-'use strict';
+import { nativePromiseService } from '@spinnaker/core';
 
-describe('Service: InstanceType', function () {
-  beforeEach(function () {
-    window.module(require('./azureInstanceType.service').name);
-  });
+import { AzureInstanceTypeService } from './azureInstanceType.service';
 
-  beforeEach(
-    window.inject(function (_azureInstanceTypeService_) {
-      this.azureInstanceTypeService = _azureInstanceTypeService_;
-    }),
-  );
-
-  it('should instantiate the controller', function () {
-    expect(this.azureInstanceTypeService).toBeDefined();
+describe('Service: InstanceType', function () {
+  it('instantiates the service directly', function () {
+    expect(new AzureInstanceTypeService(nativePromiseService)).toBeDefined();
   });
 });

package/src/instance/details/AzureInstanceDetails.spec.tsx

@@ -0,0 +1,364 @@
+import { shallow } from 'enzyme';
+import { UISref } from '@uirouter/react';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+
+import {
+  AccountTag,
+  CloudProviderRegistry,
+  CollapsibleSection,
+  ConfirmationModalService,
+  InstanceDetailsHeader,
+  InstanceReader,
+  InstanceWriter,
+} from '@spinnaker/core';
+
+import {
+  AzureInstanceActionsComponent as AzureInstanceActions,
+  AzureInstanceDetails as RoutedAzureInstanceDetails,
+  AzureInstanceDetailsComponent as AzureInstanceDetails,
+  AzureInstanceInformationSection,
+  loadAzureInstanceDetails,
+} from './AzureInstanceDetails';
+import { registerAzureProvider } from '../../azure.module';
+
+describe('AzureInstanceDetails', () => {
+  const stateService = { go: jasmine.createSpy('go'), includes: jasmine.createSpy('includes').and.returnValue(true) };
+  const routerProps = { router: {} as any, stateParams: {}, stateService: stateService as any };
+  const instanceParams = {
+    account: 'test-account',
+    instanceId: 'i-123',
+    provider: 'azure',
+    region: 'westus',
+  } as any;
+
+  function app(serverGroups: any[] = [], loadBalancers: any[] = []) {
+    return {
+      isStandalone: false,
+      loadBalancers: {
+        data: loadBalancers,
+        ready: () => Promise.resolve(),
+        onRefresh: () => jasmine.createSpy('unsubscribe'),
+      },
+      serverGroups: {
+        data: serverGroups,
+        ready: () => Promise.resolve(),
+        onRefresh: () => jasmine.createSpy('unsubscribe'),
+      },
+    } as any;
+  }
+
+  function details(overrides: any = {}) {
+    return {
+      instanceId: 'i-123',
+      instanceType: 'Standard_D2_v2',
+      launchTime: 1710000000000,
+      privateIpAddress: '10.0.0.4',
+      publicDnsName: 'i-123.example.com',
+      health: [{ type: 'Discovery', state: 'Up', vipAddress: 'vip-a,vip-b', extra: 'from details' }],
+      ...overrides,
+    } as any;
+  }
+
+  function serverGroup(overrides: any = {}) {
+    return {
+      account: 'test-account',
+      loadBalancers: ['lb-1'],
+      name: 'fnord-v001',
+      region: 'westus',
+      vpcId: 'vnet-1',
+      instances: [
+        {
+          id: 'i-123',
+          health: [{ type: 'Discovery', state: 'Down', reason: 'summary reason' }],
+          healthState: 'Down',
+          instanceType: 'summary-type',
+        },
+      ],
+      ...overrides,
+    } as any;
+  }
+
+  async function load(appFixture: any, params: any = instanceParams, fetchedDetails: any = details()) {
+    spyOn(InstanceReader, 'getInstanceDetails').and.returnValue(Promise.resolve(fetchedDetails));
+    return loadAzureInstanceDetails({ app: appFixture, instance: params });
+  }
+
+  function actionLabels(instance: any): string[] {
+    return shallow(<AzureInstanceActions {...routerProps} app={app()} instance={instance} />)
+      .find(MenuItem)
+      .map((item) => String(item.prop('children')).trim());
+  }
+
+  it('loads details for instances found in app.serverGroups.data', async () => {
+    const instance = await load(app([serverGroup()]));
+
+    expect(InstanceReader.getInstanceDetails).toHaveBeenCalledWith('test-account', 'westus', 'i-123');
+    expect(instance).toEqual(
+      jasmine.objectContaining({
+        account: 'test-account',
+        baseIpAddress: 'i-123.example.com',
+        instanceType: 'Standard_D2_v2',
+        loadBalancers: ['lb-1'],
+        region: 'westus',
+        serverGroup: 'fnord-v001',
+        vpcId: 'vnet-1',
+        vipAddress: ['vip-a', 'vip-b'],
+      }),
+    );
+    expect(instance.healthMetrics[0]).toEqual(
+      jasmine.objectContaining({ extra: 'from details', reason: 'summary reason', state: 'Down' }),
+    );
+  });
+
+  it('loads details for instances found directly in app.loadBalancers.data', async () => {
+    const loadBalancer = {
+      account: 'lb-account',
+      instances: [{ id: 'i-123', health: [{ type: 'LoadBalancer', state: 'OutOfService' }] }],
+      name: 'lb-1',
+      region: 'eastus',
+      vpcId: 'lb-vnet',
+    };
+
+    const instance = await load(app([], [loadBalancer]));
+
+    expect(InstanceReader.getInstanceDetails).toHaveBeenCalledWith('lb-account', 'eastus', 'i-123');
+    expect(instance).toEqual(
+      jasmine.objectContaining({ account: 'lb-account', loadBalancers: ['lb-1'], region: 'eastus' }),
+    );
+  });
+
+  it('loads details for instances found in app.loadBalancers.data server groups', async () => {
+    const loadBalancer = {
+      account: 'lb-account',
+      instances: [],
+      name: 'lb-server-groups',
+      region: 'eastus',
+      vpcId: 'lb-vnet',
+      serverGroups: [serverGroup({ account: 'other-account', isDisabled: false, region: 'centralus' })],
+    };
+
+    const instance = await load(app([], [loadBalancer]));
+
+    expect(InstanceReader.getInstanceDetails).toHaveBeenCalledWith('lb-account', 'eastus', 'i-123');
+    expect(instance).toEqual(
+      jasmine.objectContaining({ account: 'lb-account', loadBalancers: ['lb-server-groups'], region: 'eastus' }),
+    );
+  });
+
+  it('loads details for instances in disabled server groups through load balancers', async () => {
+    const disabledServerGroup = serverGroup({ account: 'disabled-account', isDisabled: true, region: 'centralus' });
+    const loadBalancer = {
+      account: 'lb-account',
+      instances: [],
+      name: 'lb-disabled',
+      region: 'eastus',
+      vpcId: 'lb-vnet',
+      serverGroups: [disabledServerGroup],
+    };
+
+    const instance = await load(app([], [loadBalancer]));
+
+    expect(InstanceReader.getInstanceDetails).toHaveBeenCalledWith('lb-account', 'eastus', 'i-123');
+    expect(instance).toEqual(
+      jasmine.objectContaining({ account: 'lb-account', loadBalancers: ['lb-disabled'], region: 'eastus' }),
+    );
+  });
+
+  it('loads standalone instance params without an app serverGroups data source', async () => {
+    const standaloneApp = { isStandalone: true } as any;
+    const instance = await load(
+      standaloneApp,
+      instanceParams,
+      details({ health: [{ type: 'LoadBalancer', state: 'Up' }] }),
+    );
+
+    expect(InstanceReader.getInstanceDetails).toHaveBeenCalledWith('test-account', 'westus', 'i-123');
+    expect(instance).toEqual(jasmine.objectContaining({ account: 'test-account', region: 'westus' }));
+    expect(instance.healthMetrics).toEqual([jasmine.objectContaining({ type: 'LoadBalancer', state: 'Up' })] as any);
+  });
+
+  it('returns not-found state when no summary exists', async () => {
+    spyOn(InstanceReader, 'getInstanceDetails');
+
+    const instance = await loadAzureInstanceDetails({ app: app(), instance: instanceParams });
+
+    expect(instance).toEqual({ instanceIdNotFound: 'i-123' } as any);
+    expect(InstanceReader.getInstanceDetails).not.toHaveBeenCalled();
+  });
+
+  it('renders legacy basic details and not-found content', () => {
+    const wrapper = shallow(
+      <AzureInstanceInformationSection
+        instance={
+          {
+            account: 'test-account',
+            instanceType: 'Standard_D2_v2',
+            launchTime: 1710000000000,
+            provider: 'azure',
+            region: 'westus',
+            serverGroup: 'fnord-v001',
+          } as any
+        }
+      />,
+    );
+    const content = shallow(<div>{wrapper.find(CollapsibleSection).prop('children')}</div>);
+    const text = content.text();
+
+    expect(text).toContain('Launched');
+    expect(content.find(AccountTag).prop('account')).toBe('test-account');
+    expect(text).toContain('westus');
+    expect(text).toContain('Standard_D2_v2');
+    expect(content.find(UISref).prop('to')).toBe('^.serverGroup');
+    expect(content.find(UISref).prop('params')).toEqual({
+      accountId: 'test-account',
+      provider: 'azure',
+      region: 'westus',
+      serverGroup: 'fnord-v001',
+    });
+  });
+
+  it('renders the instance header and not-found state', () => {
+    const loaded = shallow(
+      <AzureInstanceDetails {...routerProps} app={app()} instance={instanceParams} initialInstance={details()} />,
+    );
+    const notFound = shallow(
+      <AzureInstanceDetails
+        {...routerProps}
+        app={app()}
+        instance={instanceParams}
+        initialInstance={{ instanceIdNotFound: 'i-missing' } as any}
+      />,
+    );
+
+    expect(loaded.find(InstanceDetailsHeader).prop('instanceId')).toBe('i-123');
+    expect(loaded.find(AzureInstanceInformationSection).exists()).toBe(true);
+    expect(notFound.text()).toContain('Instance not found.');
+  });
+
+  it('loads the new instance and clears stale details when the mounted instance route changes', async () => {
+    const application = app([
+      serverGroup({
+        instances: [
+          { id: 'i-123', health: [], instanceType: 'old-summary-type' },
+          { id: 'i-456', health: [], instanceType: 'new-summary-type' },
+        ],
+      }),
+    ]);
+    spyOn(InstanceReader, 'getInstanceDetails').and.callFake((_account: string, _region: string, instanceId: string) =>
+      Promise.resolve(details({ instanceId, instanceType: instanceId === 'i-456' ? 'new-type' : 'old-type' })),
+    );
+    const wrapper = shallow(
+      <AzureInstanceDetails
+        {...routerProps}
+        app={application}
+        instance={instanceParams}
+        initialInstance={details({ instanceId: 'i-123', instanceType: 'old-type' })}
+      />,
+    );
+
+    wrapper.setProps({ instance: { ...instanceParams, instanceId: 'i-456' } });
+
+    expect(InstanceReader.getInstanceDetails).toHaveBeenCalledWith('test-account', 'westus', 'i-456');
+    expect(wrapper.find(InstanceDetailsHeader).prop('instanceId')).toBe('i-456');
+    expect(wrapper.find(AzureInstanceInformationSection).exists()).toBe(false);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    wrapper.update();
+
+    expect(wrapper.find(AzureInstanceInformationSection).prop('instance').instanceType).toBe('new-type');
+  });
+
+  it('preserves supported instance actions', () => {
+    spyOn(ConfirmationModalService, 'confirm');
+    spyOn(InstanceWriter, 'terminateInstance').and.returnValue(Promise.resolve({} as any));
+    spyOn(InstanceWriter, 'terminateInstanceAndShrinkServerGroup').and.returnValue(Promise.resolve({} as any));
+    spyOn(InstanceWriter, 'rebootInstance').and.returnValue(Promise.resolve({} as any));
+    spyOn(InstanceWriter, 'registerInstanceWithLoadBalancer').and.returnValue(Promise.resolve({} as any));
+    spyOn(InstanceWriter, 'deregisterInstanceFromLoadBalancer').and.returnValue(Promise.resolve({} as any));
+    spyOn(InstanceWriter, 'enableInstanceInDiscovery').and.returnValue(Promise.resolve({} as any));
+    spyOn(InstanceWriter, 'disableInstanceInDiscovery').and.returnValue(Promise.resolve({} as any));
+    const application = app();
+    const instance = {
+      account: 'test-account',
+      health: [
+        { type: 'LoadBalancer', state: 'OutOfService' },
+        { type: 'Discovery', state: 'OutOfService' },
+      ],
+      instanceId: 'i-123',
+      loadBalancers: ['lb-1'],
+      serverGroup: 'fnord-v001',
+    } as any;
+    const wrapper = shallow(<AzureInstanceActions {...routerProps} app={application} instance={instance} />);
+
+    wrapper.find(MenuItem).forEach((item) => item.prop('onClick')({} as any));
+
+    expect(ConfirmationModalService.confirm).toHaveBeenCalledTimes(7);
+    (ConfirmationModalService.confirm as jasmine.Spy).calls.all().forEach((call) => call.args[0].submitMethod());
+    expect(InstanceWriter.terminateInstance).toHaveBeenCalledWith(instance, application);
+    expect(InstanceWriter.terminateInstanceAndShrinkServerGroup).toHaveBeenCalledWith(instance, application);
+    expect(InstanceWriter.rebootInstance).toHaveBeenCalledWith(instance, application);
+    expect(InstanceWriter.registerInstanceWithLoadBalancer).toHaveBeenCalledWith(instance, application);
+    expect(InstanceWriter.deregisterInstanceFromLoadBalancer).toHaveBeenCalledWith(instance, application);
+    expect(InstanceWriter.enableInstanceInDiscovery).toHaveBeenCalledWith(instance, application);
+    expect(InstanceWriter.disableInstanceInDiscovery).toHaveBeenCalledWith(instance, application);
+    (ConfirmationModalService.confirm as jasmine.Spy).calls.first().args[0].taskMonitorConfig.onTaskComplete();
+    expect(stateService.includes).toHaveBeenCalledWith('**.instanceDetails', { instanceId: 'i-123' });
+    expect(stateService.go).toHaveBeenCalledWith('^');
+  });
+
+  it('renders load balancer actions based on load balancer health', () => {
+    expect(
+      actionLabels({
+        health: [{ type: 'LoadBalancer', state: 'OutOfService' }],
+        instanceId: 'i-123',
+        loadBalancers: ['lb-1'],
+      } as any),
+    ).toEqual(['Terminate', 'Reboot', 'Register with Load Balancer', 'Deregister from Load Balancer']);
+
+    expect(
+      actionLabels({
+        health: [{ type: 'LoadBalancer', state: 'InService' }],
+        instanceId: 'i-123',
+        loadBalancers: ['lb-1'],
+      } as any),
+    ).toEqual(['Terminate', 'Reboot', 'Deregister from Load Balancer']);
+
+    expect(
+      actionLabels({
+        health: [],
+        instanceId: 'i-123',
+        loadBalancers: ['lb-1'],
+      } as any),
+    ).toEqual(['Terminate', 'Reboot', 'Register with Load Balancer']);
+  });
+
+  it('renders discovery actions based on discovery health', () => {
+    expect(
+      actionLabels({
+        health: [{ type: 'Discovery', state: 'OutOfService' }],
+        instanceId: 'i-123',
+      } as any),
+    ).toEqual(['Terminate', 'Reboot', 'Enable in Discovery', 'Disable in Discovery']);
+
+    expect(
+      actionLabels({
+        health: [{ type: 'Discovery', state: 'Up' }],
+        instanceId: 'i-123',
+      } as any),
+    ).toEqual(['Terminate', 'Reboot', 'Disable in Discovery']);
+
+    expect(actionLabels({ health: [], instanceId: 'i-123' } as any)).toEqual(['Terminate', 'Reboot']);
+  });
+
+  it('registers Azure React instance details with the provider registry', () => {
+    registerAzureProvider();
+
+    expect(CloudProviderRegistry.getValue('azure', 'instance.details').render).toBe(
+      (RoutedAzureInstanceDetails as any).render,
+    );
+    expect(CloudProviderRegistry.getValue('azure', 'instance.detailsController')).toBeNull();
+    expect(CloudProviderRegistry.getValue('azure', 'instance.detailsTemplateUrl')).toBeNull();
+  });
+});