@spinnaker/amazon 2026.2.3 → 2026.3.0

package/src/function/CreateLambdaFunction.tsx

@@ -1,8 +1,8 @@
 import { cloneDeep } from 'lodash';
 import React from 'react';
 
-import type { IFunctionModalProps } from '@spinnaker/core';
-import { FunctionWriter, noop, ReactInjector, ReactModal, TaskMonitor, WizardModal, WizardPage } from '@spinnaker/core';
+import type { DeckRuntimeServices, IFunctionModalProps, IRouterInjectedProps } from '@spinnaker/core';
+import { FunctionWriter, noop, ReactModal, TaskMonitor, withRouter, WizardModal, WizardPage } from '@spinnaker/core';
 
 import { ExecutionRole } from './configure/ExecutionRole';
 import { FunctionBasicInformation } from './configure/FunctionBasicInformation';
@@ -23,13 +23,16 @@ export interface IAmazonCreateFunctionState {
   taskMonitor: TaskMonitor;
 }
 
-export class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionProps, IAmazonCreateFunctionState> {
+export class CreateLambdaFunctionComponent extends React.Component<
+  IAmazonCreateFunctionProps & IRouterInjectedProps,
+  IAmazonCreateFunctionState
+> {
   public static defaultProps: Partial<IAmazonCreateFunctionProps> = {
     closeModal: noop,
     dismissModal: noop,
   };
 
-  constructor(props: IAmazonCreateFunctionProps) {
+  constructor(props: IAmazonCreateFunctionProps & IRouterInjectedProps) {
     super(props);
     const functionTransformer = new AwsFunctionTransformer();
     const funcCommand = props.functionDef
@@ -43,26 +46,29 @@ export class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionP
   }
 
   private _isUnmounted = false;
-  private refreshUnsubscribe: () => void;
+  private refreshUnsubscribe?: () => void;
 
-  public static show(props: IAmazonCreateFunctionProps): Promise<IAmazonFunctionUpsertCommand> {
+  public static show(
+    props: IAmazonCreateFunctionProps,
+    runtimeServices: DeckRuntimeServices,
+  ): Promise<IAmazonFunctionUpsertCommand> {
     const modalProps = { dialogClassName: 'wizard-modal modal-lg' };
-    return ReactModal.show(CreateLambdaFunction, props, modalProps);
+    return ReactModal.show(CreateLambdaFunction, props, modalProps, runtimeServices);
   }
 
   public componentWillUnmount(): void {
     this._isUnmounted = true;
-    if (this.refreshUnsubscribe) {
-      this.refreshUnsubscribe();
-    }
+    this.refreshUnsubscribe?.();
+    this.refreshUnsubscribe = undefined;
   }
 
   protected onApplicationRefresh(values: IAmazonFunctionUpsertCommand): void {
+    this.refreshUnsubscribe?.();
+    this.refreshUnsubscribe = undefined;
     if (this._isUnmounted) {
       return;
     }
 
-    this.refreshUnsubscribe = undefined;
     this.props.dismissModal();
     this.setState({ taskMonitor: undefined });
     const newStateParams = {
@@ -73,16 +79,18 @@ export class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionP
       provider: 'aws',
     };
 
-    if (!ReactInjector.$state.includes('**.functionDetails')) {
-      ReactInjector.$state.go('.functionDetails', newStateParams);
+    if (!this.props.stateService.includes('**.functionDetails')) {
+      this.props.stateService.go('.functionDetails', newStateParams);
     } else {
-      ReactInjector.$state.go('^.functionDetails', newStateParams);
+      this.props.stateService.go('^.functionDetails', newStateParams);
     }
   }
 
   private onTaskComplete(values: IAmazonFunctionUpsertCommand): void {
+    this.refreshUnsubscribe?.();
+    this.refreshUnsubscribe = undefined;
+    this.refreshUnsubscribe = this.props.app.functions.onNextRefresh(() => this.onApplicationRefresh(values));
     this.props.app.functions.refresh();
-    this.refreshUnsubscribe = this.props.app.functions.onNextRefresh(null, () => this.onApplicationRefresh(values));
   }
 
   private checkForS3Update(functionCommandFormatted: IAmazonFunctionUpsertCommand, descriptor: string): void {
@@ -105,7 +113,7 @@ export class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionP
     const taskMonitor = new TaskMonitor({
       application: app,
       title: `${isNew ? 'Creating' : 'Updating'} your function`,
-      modalInstance: TaskMonitor.modalInstanceEmulation(() => this.props.dismissModal()),
+      onDismiss: () => this.props.dismissModal(),
       onTaskComplete: () => {
         this.checkForS3Update(functionCommandFormatted, descriptor);
       },
@@ -226,3 +234,8 @@ export class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionP
     );
   }
 }
+
+export const CreateLambdaFunction = Object.assign(
+  withRouter<IAmazonCreateFunctionProps & IRouterInjectedProps>(CreateLambdaFunctionComponent),
+  { show: CreateLambdaFunctionComponent.show },
+);

package/src/function/configure/Network.tsx

@@ -15,13 +15,14 @@ import type {
   IWizardPageComponent,
 } from '@spinnaker/core';
 import {
+  DeckRuntimeContext,
   FormikFormField,
   HelpField,
-  ReactInjector,
   ReactSelectInput,
   SubnetReader,
   TetheredSelect,
 } from '@spinnaker/core';
+
 import type { IAmazonFunctionUpsertCommand } from '../../index';
 import { VpcReader } from '../../vpc';
 
@@ -48,6 +49,9 @@ export interface INetworkState {
 export class Network
   extends React.Component<INetworkProps, INetworkState>
   implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   constructor(props: INetworkProps) {
     super(props);
     this.getAllVpcs();
@@ -76,12 +80,12 @@ export class Network
     return {};
   }
 
-  private getAvailableSubnets(): PromiseLike<ISubnet[]> {
+  private getAvailableSubnets(): Promise<ISubnet[]> {
     return SubnetReader.listSubnetsByProvider('aws');
   }
 
-  private getAvailableSecurityGroups(): PromiseLike<ISecurityGroupsByAccountSourceData> {
-    return ReactInjector.securityGroupReader.getAllSecurityGroups();
+  private getAvailableSecurityGroups(): Promise<ISecurityGroupsByAccountSourceData> {
+    return this.context.services.securityGroupReader.getAllSecurityGroups();
   }
   private makeSubnetOptions(availableSubnets: ISubnet[]): ISubnetOption[] {
     const subOptions: ISubnetOption[] = availableSubnets.map((s) => ({ subnetId: s.id, vpcId: s.vpcId }));

package/src/function/details/AmazonFunctionDetails.tsx

@@ -4,11 +4,11 @@ import { from as observableFrom, Subject } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
 
 import type { Application, IFunction, IOverridableProps } from '@spinnaker/core';
-import { AccountTag, CollapsibleSection, Details, Overrides } from '@spinnaker/core';
+import { AccountTag, CollapsibleSection, Details } from '@spinnaker/core';
 
 import { FunctionActions } from './FunctionActions';
+import { AwsServices } from '../../aws.services';
 import type { IAmazonFunction, IAmazonFunctionSourceData } from '../../domain';
-import { AwsReactInjector } from '../../reactShims';
 
 export interface IFunctionFromStateParams {
   account: string;
@@ -21,7 +21,6 @@ export interface IAmazonFunctionDetailsProps extends IOverridableProps {
   functionObj: IFunction;
 }
 
-@Overrides('function.details', 'aws')
 export class AmazonFunctionDetails extends React.Component<IAmazonFunctionDetailsProps, any> {
   private destroy$ = new Subject();
   constructor(props: IAmazonFunctionDetailsProps) {
@@ -43,7 +42,7 @@ export class AmazonFunctionDetails extends React.Component<IAmazonFunctionDetail
 
     if (functionDef) {
       observableFrom(
-        AwsReactInjector.functionReader.getFunctionDetails(
+        AwsServices.functionReader.getFunctionDetails(
           'aws',
           functionFromProps.account,
           functionFromProps.region,
@@ -73,7 +72,7 @@ export class AmazonFunctionDetails extends React.Component<IAmazonFunctionDetail
     observableFrom(dataSource.ready())
       .pipe(takeUntil(this.destroy$))
       .subscribe(() => {
-        const dataSourceUnsubscribe = dataSource.onRefresh(null, () => this.extractFunction());
+        const dataSourceUnsubscribe = dataSource.onRefresh(() => this.extractFunction());
         this.setState({ dataSourceUnsubscribe });
         this.extractFunction();
       });

package/src/function/details/FunctionActions.tsx

@@ -6,6 +6,7 @@ import {
   AddEntityTagLinks,
   ApplicationReader,
   ConfirmationModalService,
+  DeckRuntimeContext,
   FunctionWriter,
   SETTINGS,
 } from '@spinnaker/core';
@@ -26,6 +27,9 @@ export interface IFunctionActionsState {
 }
 
 export class FunctionActions extends React.Component<IFunctionActionsProps, IFunctionActionsState> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   constructor(props: IFunctionActionsProps) {
     super(props);
     this.state = { application: props.app };
@@ -60,7 +64,7 @@ export class FunctionActions extends React.Component<IFunctionActionsProps, IFun
     const { functionDef } = this.props;
     const { application } = this.state;
     const FunctionModal = CreateLambdaFunction;
-    FunctionModal.show({ app: application, functionDef });
+    FunctionModal.show({ app: application, functionDef }, this.context.services);
   };
 
   public deleteFunction = (): void => {

package/src/function/function.transformer.ts

@@ -11,6 +11,10 @@ export class AwsFunctionTransformer {
     return normalizedFunctionDef;
   }
 
+  public normalizeFunctionSet(functions: IAmazonFunction[]): IAmazonFunction[] {
+    return functions.map((functionDef) => this.normalizeFunction(functionDef));
+  }
+
   public convertFunctionForEditing = (functionDef: IAmazonFunction): IAmazonFunctionUpsertCommand => ({
     ...functionDef,
     envVariables: functionDef.environment ? functionDef.environment.variables : {},

package/src/image/image.reader.ts

@@ -1,5 +1,3 @@
-import { $q } from 'ngimport';
-
 import { REST } from '@spinnaker/core';
 
 export interface IAmazonImage {
@@ -22,9 +20,9 @@ export interface IAmazonImage {
 }
 
 export class AwsImageReader {
-  public findImages(params: { q: string; region?: string }): PromiseLike<IAmazonImage[]> {
+  public findImages(params: { q: string; region?: string }): Promise<IAmazonImage[]> {
     if (!params.q || params.q.length < 3) {
-      return $q.when([{ message: 'Please enter at least 3 characters...', disabled: true }]) as any;
+      return Promise.resolve([{ message: 'Please enter at least 3 characters...', disabled: true }]) as any;
     }
 
     return REST('/images/find')
@@ -33,7 +31,7 @@ export class AwsImageReader {
       .catch(() => [] as IAmazonImage[]);
   }
 
-  public getImage(amiName: string, region: string, credentials: string): PromiseLike<IAmazonImage> {
+  public getImage(amiName: string, region: string, credentials: string): Promise<IAmazonImage> {
     return REST('/images')
       .path(credentials, region, amiName)
       .query({ provider: 'aws' })

package/src/index.ts

@@ -1,4 +1,4 @@
-export { AMAZON_MODULE } from './aws.module';
+import './aws.module';
 
 export * from './aws.settings';
 export * from './certificates';
@@ -7,7 +7,7 @@ export * from './domain';
 export * from './keyPairs';
 export * from './loadBalancer';
 export * from './function';
-export * from './reactShims';
+export * from './aws.services';
 export * from './serverGroup';
 export * from './subnet';
 export * from './vpc';

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

@@ -1,5 +1,12 @@
-import type { Application, IMultiInstanceGroup, IMultiInstanceJob, ITask } from '@spinnaker/core';
+import type {
+  Application,
+  IMultiInstanceGroup,
+  IMultiInstanceJob,
+  ITask,
+  ProviderServiceDelegate,
+} from '@spinnaker/core';
 import { InstanceWriter, TaskExecutor } from '@spinnaker/core';
+
 import type { IAmazonInstance } from '../domain';
 
 export interface IAmazonMultiInstanceGroup extends IMultiInstanceGroup {
@@ -15,9 +22,11 @@ export class AmazonInstanceWriter extends InstanceWriter {
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
     targetGroupNames: string[],
-  ): PromiseLike<ITask> {
+    providerServiceDelegate: ProviderServiceDelegate,
+  ): Promise<ITask> {
     const jobs = super.buildMultiInstanceJob(
       instanceGroups,
+      providerServiceDelegate,
       'deregisterInstancesFromLoadBalancer',
     ) as IAmazonMultiInstanceJob[];
     jobs.forEach((job) => (job.targetGroupNames = targetGroupNames));
@@ -33,7 +42,7 @@ export class AmazonInstanceWriter extends InstanceWriter {
     instance: IAmazonInstance,
     application: Application,
     params: any = {},
-  ): PromiseLike<ITask> {
+  ): Promise<ITask> {
     params.type = 'deregisterInstancesFromLoadBalancer';
     params.instanceIds = [instance.id];
     params.targetGroupNames = instance.targetGroups;
@@ -51,9 +60,11 @@ export class AmazonInstanceWriter extends InstanceWriter {
     instanceGroups: IMultiInstanceGroup[],
     application: Application,
     targetGroupNames: string[],
+    providerServiceDelegate: ProviderServiceDelegate,
   ) {
     const jobs = super.buildMultiInstanceJob(
       instanceGroups,
+      providerServiceDelegate,
       'registerInstancesWithLoadBalancer',
     ) as IAmazonMultiInstanceJob[];
     jobs.forEach((job) => (job.targetGroupNames = targetGroupNames));
@@ -69,7 +80,7 @@ export class AmazonInstanceWriter extends InstanceWriter {
     instance: IAmazonInstance,
     application: Application,
     params: any = {},
-  ): PromiseLike<ITask> {
+  ): Promise<ITask> {
     params.type = 'registerInstancesWithLoadBalancer';
     params.instanceIds = [instance.id];
     params.targetGroupNames = instance.targetGroups;

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

@@ -2,145 +2,141 @@
 import { map } from 'lodash';
 import { mockHttpClient } from 'core/api/mock/jasmine';
 
+import { AwsInstanceTypeService } from './awsInstanceType.service';
+
 describe('Service: InstanceType', function () {
   beforeEach(function () {
-    window.module(require('./awsInstanceType.service').name);
-  });
+    this.awsInstanceTypeService = new AwsInstanceTypeService();
 
-  beforeEach(
-    window.inject(function (_awsInstanceTypeService_) {
-      this.awsInstanceTypeService = _awsInstanceTypeService_;
-
-      this.allTypes = [
-        {
-          account: 'test',
-          region: 'us-west-2',
-          name: 'm1.small',
-          defaultVCpus: 1,
-          memoryInGiB: 1,
-          supportedArchitectures: ['i386', 'x86_64'],
-          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
-        },
-        {
-          account: 'test',
-          region: 'us-west-2',
-          name: 'm2.xlarge',
-          defaultVCpus: 2,
-          memoryInGiB: 17,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
-        },
-        {
-          account: 'test',
-          region: 'eu-west-1',
-          name: 'hs1.8xlarge',
-          defaultVCpus: 32,
-          memoryInGiB: 256,
-          supportedArchitectures: ['i386', 'x86_64'],
-          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
-        },
-        {
-          account: 'test',
-          region: 'eu-west-1',
-          name: 'm2.xlarge',
-          defaultVCpus: 2,
-          memoryInGiB: 17,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 'm4.2xlarge',
-          defaultVCpus: 8,
-          memoryInGiB: 32,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 't2.nano',
-          defaultVCpus: 1,
-          memoryInGiB: 0,
-          supportedArchitectures: ['i386', 'x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 't2.micro',
-          defaultVCpus: 1,
-          memoryInGiB: 1,
-          supportedArchitectures: ['i386', 'x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 'm4.xlarge',
-          defaultVCpus: 4,
-          memoryInGiB: 16,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 'm4.4xlarge',
-          defaultVCpus: 16,
-          memoryInGiB: 64,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 't2.medium',
-          defaultVCpus: 2,
-          memoryInGiB: 4,
-          supportedArchitectures: ['i386', 'x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 'm4.large',
-          defaultVCpus: 2,
-          memoryInGiB: 8,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 'm4.16xlarge',
-          defaultVCpus: 64,
-          memoryInGiB: 256,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 'm4.10xlarge',
-          defaultVCpus: 40,
-          memoryInGiB: 160,
-          supportedArchitectures: ['x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-        {
-          account: 'test',
-          region: 'us-east-1',
-          name: 't2.loltiny',
-          defaultVCpus: 1,
-          memoryInGiB: 0,
-          supportedArchitectures: ['i386', 'x86_64'],
-          supportedVirtualizationTypes: ['hvm'],
-        },
-      ];
-    }),
-  );
+    this.allTypes = [
+      {
+        account: 'test',
+        region: 'us-west-2',
+        name: 'm1.small',
+        defaultVCpus: 1,
+        memoryInGiB: 1,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'us-west-2',
+        name: 'm2.xlarge',
+        defaultVCpus: 2,
+        memoryInGiB: 17,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'eu-west-1',
+        name: 'hs1.8xlarge',
+        defaultVCpus: 32,
+        memoryInGiB: 256,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'eu-west-1',
+        name: 'm2.xlarge',
+        defaultVCpus: 2,
+        memoryInGiB: 17,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.2xlarge',
+        defaultVCpus: 8,
+        memoryInGiB: 32,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 't2.nano',
+        defaultVCpus: 1,
+        memoryInGiB: 0,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 't2.micro',
+        defaultVCpus: 1,
+        memoryInGiB: 1,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.xlarge',
+        defaultVCpus: 4,
+        memoryInGiB: 16,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.4xlarge',
+        defaultVCpus: 16,
+        memoryInGiB: 64,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 't2.medium',
+        defaultVCpus: 2,
+        memoryInGiB: 4,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.large',
+        defaultVCpus: 2,
+        memoryInGiB: 8,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.16xlarge',
+        defaultVCpus: 64,
+        memoryInGiB: 256,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.10xlarge',
+        defaultVCpus: 40,
+        memoryInGiB: 160,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 't2.loltiny',
+        defaultVCpus: 1,
+        memoryInGiB: 0,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+    ];
+  });
 
   describe('getAllTypesByRegion', function () {
     it('returns types, indexed by region', async function () {
@@ -333,6 +329,46 @@ describe('Service: InstanceType', function () {
         'hs1.8xlarge',
       ]);
     });
+
+    it('matches architecture case-insensitively', function () {
+      const service = this.awsInstanceTypeService;
+      const armInstanceTypes = [
+        {
+          account: 'test',
+          region: 'eu-central-1',
+          name: 'm9gd.metal-48xl',
+          defaultVCpus: 192,
+          memoryInGiB: 768,
+          supportedArchitectures: ['ARM64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+      ];
+
+      expect(map(service.filterInstanceTypes(armInstanceTypes, 'hvm', true, 'arm64'), 'name')).toEqual([
+        'm9gd.metal-48xl',
+      ]);
+    });
+
+    it('matches virtualization type case-insensitively when the AMI attribute is uppercase', function () {
+      const service = this.awsInstanceTypeService;
+      const armInstanceTypes = [
+        {
+          account: 'test',
+          region: 'us-west-2',
+          name: 'x8i.metal-48xl',
+          defaultVCpus: 192,
+          memoryInGiB: 3072,
+          supportedArchitectures: ['X86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+      ];
+
+      // AMI attributes (e.g. command.virtualizationType / command.amiArchitecture) can come back
+      // uppercase (e.g. 'HVM', 'ARM64') while the instance types API reports lowercase values.
+      expect(map(service.filterInstanceTypes(armInstanceTypes, 'HVM', true, 'X86_64'), 'name')).toEqual([
+        'x8i.metal-48xl',
+      ]);
+    });
   });
 
   describe('isBurstingSupportedForAllTypes', function () {