@spinnaker/amazon 0.11.1 → 0.12.3

package/src/serverGroup/configure/wizard/pages/ServerGroupInstanceType.tsx

@@ -1,11 +1,13 @@
 import type { FormikErrors, FormikProps } from 'formik';
+import { some } from 'lodash';
 import React from 'react';
+import { Subject } from 'rxjs';
 
 import type { IWizardPageComponent } from '@spinnaker/core';
-import { NgReact } from '@spinnaker/core';
-import { AWSProviderSettings } from '../../../../aws.settings';
 
-import { CpuCreditsToggle } from '../instanceType/CpuCreditsToggle';
+import type { IAmazonInstanceTypeCategory } from '../../../../instance/awsInstanceType.service';
+import { InstanceTypeSelector } from '../instanceType/InstanceTypeSelector';
+import { AwsReactInjector } from '../../../../reactShims';
 import type { IAmazonServerGroupCommand } from '../../serverGroupConfiguration.service';
 
 export interface IServerGroupInstanceTypeProps {
@@ -13,88 +15,131 @@ export interface IServerGroupInstanceTypeProps {
 }
 
 export interface IServerGroupInstanceTypeState {
-  newInstanceType?: string;
-  newProfileType?: string;
+  instanceTypeDetails: IAmazonInstanceTypeCategory[];
 }
 
 export class ServerGroupInstanceType
   extends React.Component<IServerGroupInstanceTypeProps, IServerGroupInstanceTypeState>
   implements IWizardPageComponent<IAmazonServerGroupCommand> {
-  constructor(props: IServerGroupInstanceTypeProps) {
-    super(props);
-    this.state = {
-      newInstanceType: undefined,
-      newProfileType: undefined,
-    };
-  }
+  public state: IServerGroupInstanceTypeState = {
+    instanceTypeDetails: [],
+  };
+  private props$ = new Subject<IServerGroupInstanceTypeProps>();
+  private destroy$ = new Subject<void>();
 
-  public validate(values: IAmazonServerGroupCommand) {
+  public validate(values: IAmazonServerGroupCommand): FormikErrors<IAmazonServerGroupCommand> {
     const errors: FormikErrors<IAmazonServerGroupCommand> = {};
 
-    if (!values.instanceType) {
-      errors.instanceType = 'Instance Type required.';
+    if (values.viewState.useSimpleInstanceTypeSelector) {
+      if (!values.instanceType) {
+        errors.instanceType = 'Instance Type required.';
+      }
+    } else {
+      const advancedModeErrors = this.validateAdvancedModeFields(values, errors);
+      Object.assign(errors, { ...advancedModeErrors });
     }
 
     return errors;
   }
 
-  private instanceProfileChanged = (_profile: string) => {
-    // Instance profile is already set on values.viewState, so just use that value.
-    // Once angular is gone from this component tree, we can move all the viewState stuff
-    // into react state
-    this.setState({ newProfileType: _profile, newInstanceType: undefined });
-  };
+  private validateAdvancedModeFields(
+    values: IAmazonServerGroupCommand,
+    errors: FormikErrors<IAmazonServerGroupCommand>,
+  ): FormikErrors<IAmazonServerGroupCommand> {
+    if (!values.launchTemplateOverridesForInstanceType.length) {
+      errors.instanceType = 'At least one instance type required.';
+    }
+    if (values.launchTemplateOverridesForInstanceType.length > 40) {
+      errors.instanceType = 'Maximum of 40 instance types are allowed.';
+    }
+    const weightsSpecified = values.launchTemplateOverridesForInstanceType.filter(
+      (it) => it.weightedCapacity !== undefined,
+    );
+    if (
+      !(
+        weightsSpecified.length === values.launchTemplateOverridesForInstanceType.length ||
+        weightsSpecified.length === 0
+      )
+    ) {
+      errors.instanceType = 'Weighted capacity must be specified for all instance types selected or none.';
+    }
+    if (
+      some(weightsSpecified, function (instanceType) {
+        const weightedCapacity = Number(instanceType.weightedCapacity);
+        return weightedCapacity < 1 || weightedCapacity > 999;
+      })
+    ) {
+      errors.instanceType = 'Weighted capacity must be a number between 1 and 999.';
+    }
 
-  private instanceTypeChanged = (type: string) => {
-    const { values } = this.props.formik;
-    values.instanceTypeChanged(values);
-    this.props.formik.setFieldValue('instanceType', type);
-    this.setState({ newInstanceType: type, newProfileType: undefined });
-  };
+    if (values.onDemandBaseCapacity < 0) {
+      errors.onDemandBaseCapacity = 'On-Demand base capacity must be non-negative.';
+    }
 
-  private setUnlimitedCpuCredits = (unlimitedCpuCredits: boolean | undefined) => {
-    if (this.props.formik.values.unlimitedCpuCredits !== unlimitedCpuCredits) {
-      this.props.formik.setFieldValue('unlimitedCpuCredits', unlimitedCpuCredits);
-      this.setState({});
+    if (values.onDemandBaseCapacity > values.capacity.max) {
+      errors.onDemandBaseCapacity = 'On-Demand base capacity must be less than or equal to max capacity.';
+    }
+
+    if (values.onDemandPercentageAboveBaseCapacity < 0 || values.onDemandPercentageAboveBaseCapacity > 100) {
+      errors.onDemandPercentageAboveBaseCapacity =
+        'On-Demand percentage above base capacity must be a number between 0 and 100.';
+    }
+
+    if (values.spotPrice) {
+      const spotPriceNum = Number(values.spotPrice);
+      if (Number.isNaN(spotPriceNum)) {
+        errors.spotPrice = 'Spot Max Price must be a number or empty string, used to unset previous max price.';
+      }
+      if (spotPriceNum <= 0) {
+        errors.spotPrice = 'Spot Max Price must be greater than 0, if specified.';
+      }
     }
-  };
+
+    if (values.spotInstancePools && values.spotAllocationStrategy !== 'lowest-price') {
+      errors.spotInstancePools = "Spot Instance Pools is only supported for 'lowest-price' Spot Allocation Strategy.";
+    }
+    if (values.spotInstancePools <= 0 || values.spotInstancePools > 20) {
+      errors.spotInstancePools = 'Spot Instance Pools count must be a number between 1 and 20, when applicable.';
+    }
+
+    return errors;
+  }
+
+  public componentDidMount(): void {
+    Promise.resolve(AwsReactInjector.awsInstanceTypeService.getCategories()).then(
+      (categories: IAmazonInstanceTypeCategory[]) => {
+        this.setState({ instanceTypeDetails: categories });
+      },
+    );
+  }
+
+  public componentDidUpdate() {
+    this.props$.next(this.props);
+  }
+
+  public componentWillUnmount() {
+    this.destroy$.next();
+  }
 
   public render() {
     const { values } = this.props.formik;
-
-    const { InstanceArchetypeSelector, InstanceTypeSelector } = NgReact;
     const showTypeSelector = !!(values.viewState.disableImageSelection || values.amiName);
 
-    const isLaunchTemplatesEnabled = AWSProviderSettings.serverGroups?.enableLaunchTemplates;
-    const isCpuCreditsEnabled = AWSProviderSettings.serverGroups?.enableCpuCredits;
+    // mark unavailable instance types for all profiles
+    const availableInstanceTypesForConfig: string[] = values.backingData?.filtered?.instanceTypes ?? [];
+    const markedInstanceTypeDetails: IAmazonInstanceTypeCategory[] = Array.from(this.state.instanceTypeDetails);
+    if (!values.viewState.disableImageSelection && availableInstanceTypesForConfig.length) {
+      markedInstanceTypeDetails.forEach((profile) => {
+        profile.families.forEach((family) => {
+          family.instanceTypes.forEach((instanceType) => {
+            instanceType.unavailable = !availableInstanceTypesForConfig.includes(instanceType.name);
+          });
+        });
+      });
+    }
 
     if (showTypeSelector && values) {
-      return (
-        <div className="container-fluid form-horizontal">
-          <div className="row">
-            <InstanceArchetypeSelector
-              command={values}
-              onTypeChanged={this.instanceTypeChanged}
-              onProfileChanged={this.instanceProfileChanged}
-            />
-            <div style={{ padding: '0 15px' }}>
-              {values.viewState.instanceProfile && values.viewState.instanceProfile !== 'custom' && (
-                <InstanceTypeSelector command={values} onTypeChanged={this.instanceTypeChanged} />
-              )}
-            </div>
-          </div>
-          {isLaunchTemplatesEnabled && isCpuCreditsEnabled && (
-            <div className="row">
-              <CpuCreditsToggle
-                command={values}
-                newInstanceType={this.state.newInstanceType}
-                newProfileType={this.state.newProfileType}
-                setUnlimitedCpuCredits={this.setUnlimitedCpuCredits}
-              />
-            </div>
-          )}
-        </div>
-      );
+      return <InstanceTypeSelector formik={this.props.formik} instanceTypeDetails={markedInstanceTypeDetails} />;
     }
 
     return <h5 className="text-center">Please select an image.</h5>;

package/src/serverGroup/configure/wizard/pages/advancedSettings/ServerGroupAdvancedSettingsCommon.tsx

@@ -222,7 +222,7 @@ export class ServerGroupAdvancedSettingsCommon extends React.Component<IServerGr
             </div>
           </div>
         )}
-        {!AWSProviderSettings.disableSpotPricing && (
+        {!AWSProviderSettings.disableSpotPricing && values.viewState.useSimpleInstanceTypeSelector && (
           <div className="form-group">
             <div className="col-md-5 sm-label-right">
               <b>Spot Instances Price (optional)</b> <HelpField id="aws.serverGroup.spotMaxPrice" />

package/src/serverGroup/details/scalingPolicy/scalingPolicySummary.component.ts

@@ -1,10 +1,14 @@
 import { module } from 'angular';
 import { react2angular } from 'react2angular';
 import { withErrorBoundary } from '@spinnaker/core';
-import { StepPolicySummary } from './StepPolicySummary';
+import { ScalingPolicySummary } from './ScalingPolicySummary';
 
 export const SCALING_POLICY_SUMMARY_COMPONENT = 'spinnaker.amazon.scalingPolicy.scalingPolicySummary.component';
 module(SCALING_POLICY_SUMMARY_COMPONENT, []).component(
   'scalingPolicySummary',
-  react2angular(withErrorBoundary(StepPolicySummary, 'scalingPolicySummary'), ['application', 'policy', 'serverGroup']),
+  react2angular(withErrorBoundary(ScalingPolicySummary, 'scalingPolicySummary'), [
+    'application',
+    'policy',
+    'serverGroup',
+  ]),
 );

package/src/serverGroup/details/scalingProcesses/AutoScalingProcessService.spec.ts

@@ -1,6 +1,5 @@
-import { IAmazonAsg, IAmazonServerGroup } from '../../../domain';
-
 import { AutoScalingProcessService } from './AutoScalingProcessService';
+import type { IAmazonAsg, IAmazonServerGroup } from '../../../domain';
 
 describe('AutoScalingProcessService', () => {
   describe('normalizeScalingProcesses', () => {

package/src/serverGroup/details/sections/InstancesDistributionDetailsSection.spec.tsx

@@ -1,9 +1,12 @@
-import React from 'react';
 import { shallow } from 'enzyme';
+import React from 'react';
+
+import type { Application } from '@spinnaker/core';
+import { ApplicationModelBuilder } from '@spinnaker/core';
 import { mockLaunchTemplate, mockServerGroup } from '@spinnaker/mocks';
-import { IAmazonMixedInstancesPolicy, IAmazonServerGroupView, IScalingPolicy } from '../../../domain';
+
+import type { IAmazonMixedInstancesPolicy, IAmazonServerGroupView, IScalingPolicy } from '../../../domain';
 import { InstancesDistributionDetailsSection } from '../../../index';
-import { Application, ApplicationModelBuilder } from '@spinnaker/core';
 
 describe('InstancesDistribution', () => {
   let app: Application;
@@ -50,7 +53,7 @@ describe('InstancesDistribution', () => {
     ]);
     let index = 0;
     expectedLabels.forEach((value, key) => {
-      let labeledValue = actualLabeledValues.at(index++);
+      const labeledValue = actualLabeledValues.at(index++);
       expect(labeledValue.prop('label')).toEqual(key);
       expect(labeledValue.prop('value')).toEqual(value);
     });
@@ -77,7 +80,7 @@ describe('InstancesDistribution', () => {
     ]);
     let index = 0;
     expectedLabels.forEach((value, key) => {
-      let labeledValue = actualLabeledValues.at(index++);
+      const labeledValue = actualLabeledValues.at(index++);
       expect(labeledValue.prop('label')).toEqual(key);
       expect(labeledValue.prop('value')).toEqual(value);
     });

package/src/serverGroup/details/sections/LaunchTemplateDetailsSection.spec.tsx

@@ -1,15 +1,18 @@
-import React from 'react';
 import { shallow } from 'enzyme';
+import React from 'react';
+
+import type { Application } from '@spinnaker/core';
+import { ApplicationModelBuilder } from '@spinnaker/core';
 import {
   createCustomMockLaunchTemplate,
   mockLaunchTemplate,
   mockLaunchTemplateData,
   mockServerGroup,
 } from '@spinnaker/mocks';
-import { Application, ApplicationModelBuilder } from '@spinnaker/core';
-import { IAmazonServerGroupView, IAmazonMixedInstancesPolicy, IScalingPolicy } from '../../../domain';
+
 import { LaunchTemplateDetailsSection } from './LaunchTemplateDetailsSection';
 import { MultipleInstanceTypesSubSection } from './MultipleInstanceTypesSubSection';
+import type { IAmazonMixedInstancesPolicy, IAmazonServerGroupView, IScalingPolicy } from '../../../domain';
 
 describe('Launch template details', () => {
   let app: Application;
@@ -144,7 +147,7 @@ describe('Launch template details', () => {
     ]);
     let index = 0;
     expectedLabels.forEach((value, key) => {
-      let labeledValue = actualLabeledValues.at(index++);
+      const labeledValue = actualLabeledValues.at(index++);
       expect(labeledValue.prop('label')).toEqual(key);
       value != '' && expect(labeledValue.prop('value')).toEqual(value);
     });
@@ -239,7 +242,7 @@ describe('Launch template details', () => {
   });
 
   it('should not render multiple instance types subsection when overrides are not specified', () => {
-    let testServerGroup = baseServerGroupWithMipOverrides;
+    const testServerGroup = baseServerGroupWithMipOverrides;
     testServerGroup.mixedInstancesPolicy.launchTemplateOverridesForInstanceType = null;
 
     const multipleInstanceTypes = shallow(

package/src/serverGroup/serverGroup.transformer.spec.ts

@@ -1,7 +1,9 @@
-import { mock, IQService, IRootScopeService, IScope } from 'angular';
+import type { IQService, IRootScopeService, IScope } from 'angular';
+import { mock } from 'angular';
 
-import { AWS_SERVER_GROUP_TRANSFORMER, AwsServerGroupTransformer } from './serverGroup.transformer';
-import { IScalingPolicyAlarmView, IAmazonServerGroup, IStepAdjustment } from '../domain';
+import type { IAmazonServerGroup, IScalingPolicyAlarmView, IStepAdjustment } from '../domain';
+import type { AwsServerGroupTransformer } from './serverGroup.transformer';
+import { AWS_SERVER_GROUP_TRANSFORMER } from './serverGroup.transformer';
 import { VpcReader } from '../vpc/VpcReader';
 
 describe('awsServerGroupTransformer', () => {

package/src/serverGroup/serverGroup.transformer.ts

@@ -1,8 +1,8 @@
 import { module } from 'angular';
-import { defaults } from 'lodash';
 
 import type { IVpc } from '@spinnaker/core';
 
+import type { IAmazonServerGroupCommand, IAmazonServerGroupDeployConfiguration } from './configure';
 import type {
   IAmazonServerGroup,
   IAmazonServerGroupView,
@@ -13,6 +13,7 @@ import type {
   IStepAdjustmentView,
   ITargetTrackingPolicy,
 } from '../domain';
+
 import { VpcReader } from '../vpc/VpcReader';
 
 export class AwsServerGroupTransformer {
@@ -84,31 +85,32 @@ export class AwsServerGroupTransformer {
     };
   }
 
-  public convertServerGroupCommandToDeployConfiguration(base: any): any {
-    // use _.defaults to avoid copying the backingData, which is huge and expensive to copy over
-    const command = defaults({ backingData: [], viewState: [] }, base);
-    command.cloudProvider = 'aws';
-    command.availabilityZones = {};
-    command.availabilityZones[command.region] = base.availabilityZones;
-    command.loadBalancers = (base.loadBalancers || []).concat(base.vpcLoadBalancers || []);
-    command.targetGroups = base.targetGroups || [];
-    command.account = command.credentials;
-    command.subnetType = command.subnetType || '';
+  public convertServerGroupCommandToDeployConfiguration(
+    base: IAmazonServerGroupCommand,
+  ): IAmazonServerGroupDeployConfiguration {
+    const deployConfig = ({ ...base } as any) as IAmazonServerGroupDeployConfiguration;
+
+    deployConfig.cloudProvider = 'aws';
+    deployConfig.availabilityZones = { [deployConfig.region]: base.availabilityZones };
+    deployConfig.loadBalancers = (base.loadBalancers || []).concat(base.vpcLoadBalancers || []);
+    deployConfig.targetGroups = base.targetGroups || [];
+    deployConfig.account = deployConfig.credentials;
+    deployConfig.subnetType = deployConfig.subnetType || '';
 
     if (base.viewState.mode !== 'clone') {
-      delete command.source;
+      delete deployConfig.source;
     }
-    if (!command.ramdiskId) {
-      delete command.ramdiskId; // TODO: clean up in kato? - should ignore if empty string
+
+    if (!deployConfig.ramdiskId) {
+      delete deployConfig.ramdiskId; // TODO: clean up in kato? - should ignore if empty string
     }
-    delete command.region;
-    delete command.viewState;
-    delete command.backingData;
-    delete command.selectedProvider;
-    delete command.instanceProfile;
-    delete command.vpcId;
-
-    return command;
+
+    const deleteFields = ['region', 'viewState', 'backingData', 'selectedProvider', 'instanceProfile', 'vpcId'];
+    deleteFields.forEach((key: keyof typeof deployConfig) => {
+      delete deployConfig[key];
+    });
+
+    return deployConfig;
   }
 
   public constructNewStepScalingPolicyTemplate(serverGroup: IAmazonServerGroup): IScalingPolicy {

package/src/subnet/SubnetSelectInput.spec.tsx

@@ -1,10 +1,13 @@
-import React from 'react';
-import { shallow, render } from 'enzyme';
 import { mock } from 'angular';
-import { SubnetSelectInput } from './SubnetSelectInput';
-import { Application, ApplicationModelBuilder } from '@spinnaker/core';
+import { render, shallow } from 'enzyme';
+import React from 'react';
+
+import type { Application } from '@spinnaker/core';
+import { ApplicationModelBuilder } from '@spinnaker/core';
 import { mockServerGroupDataSourceConfig, mockSubnet } from '@spinnaker/mocks';
 
+import { SubnetSelectInput } from './SubnetSelectInput';
+
 describe('SubnetSelectInput', () => {
   let application: Application;
 

package/src/vpc/{VpcReader.spec.js → VpcReader.spec.ts}

@@ -1,16 +1,8 @@
-'use strict';
-import { mockHttpClient } from 'core/api/mock/jasmine';
+// eslint-disable-next-line @spinnaker/import-from-npm-not-relative
+import { mockHttpClient } from '../../../core/src/api/mock/jasmine';
 import { VpcReader } from '../vpc/VpcReader';
 
 describe('VpcReader', function () {
-  var $scope;
-
-  beforeEach(
-    window.inject(function ($rootScope) {
-      $scope = $rootScope.$new();
-    }),
-  );
-
   afterEach(function () {
     VpcReader.resetCache();
   });

package/src/vpc/VpcTag.spec.tsx

@@ -0,0 +1,37 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { VpcTag } from './VpcTag';
+import { VpcReader } from '../vpc/VpcReader';
+
+const tick = () => new Promise((resolve) => setTimeout(resolve));
+
+describe('VpcTag', function () {
+  describe('vpc tag rendering - no VPC provided', function () {
+    it('displays default message when no vpcId supplied', function () {
+      const component = mount(<VpcTag vpcId={undefined} />);
+      expect(component.text()).toBe('None (EC2 Classic)');
+    });
+
+    it('displays default message when null vpcId supplied', function () {
+      const component = mount(<VpcTag vpcId={null} />);
+      expect(component.text()).toBe('None (EC2 Classic)');
+    });
+  });
+
+  describe('vpc tag rendering - VPC provided', function () {
+    it('displays vpc name when found', async function () {
+      spyOn(VpcReader, 'getVpcName').and.returnValue(Promise.resolve('Main VPC'));
+      const component = mount(<VpcTag vpcId="vpc-1" />);
+      await tick();
+      expect(component.text()).toBe('Main VPC (vpc-1)');
+    });
+
+    it('displays vpc id when not found', async function () {
+      spyOn(VpcReader, 'getVpcName').and.returnValue(Promise.resolve(null));
+      const component = mount(<VpcTag vpcId="vpc-2" />);
+      await tick();
+      expect(component.text()).toBe('(vpc-2)');
+    });
+  });
+});

package/src/vpc/vpc.module.ts

@@ -1,5 +1,9 @@
 import { module } from 'angular';
-import { AMAZON_VPC_VPCTAG_DIRECTIVE } from './vpcTag.directive';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { VpcTag } from './VpcTag';
 
 export const VPC_MODULE = 'spinnaker.amazon.vpc';
-module(VPC_MODULE, [AMAZON_VPC_VPCTAG_DIRECTIVE]);
+module(VPC_MODULE, []).component('vpcTag', react2angular(withErrorBoundary(VpcTag, 'vpcTag'), ['vpcId']));

package/dist/vpc/vpcTag.directive.d.ts

@@ -1,2 +0,0 @@
-export const AMAZON_VPC_VPCTAG_DIRECTIVE: "spinnaker.amazon.vpc.tag.directive";
-export const name: "spinnaker.amazon.vpc.tag.directive";

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

@@ -1,123 +0,0 @@
-'use strict';
-import { mockHttpClient } from 'core/api/mock/jasmine';
-import { AwsImageReader } from './image.reader';
-
-describe('Service: aws Image Reader', function () {
-  var service, scope;
-
-  beforeEach(
-    window.inject(function ($rootScope) {
-      service = new AwsImageReader();
-      scope = $rootScope.$new();
-    }),
-  );
-
-  describe('findImages', function () {
-    var query = 'abc',
-      region = 'us-west-1';
-
-    const buildQueryString = () => `/images/find?provider=aws&q=${query}&region=${region}`;
-
-    it('queries gate when 3 characters are supplied', async function () {
-      const http = mockHttpClient();
-      var result = null;
-
-      http.expectGET(buildQueryString()).respond(200, [{ success: true }]);
-
-      service.findImages({ provider: 'aws', q: query, region: region }).then(function (results) {
-        result = results;
-      });
-
-      await http.flush();
-
-      expect(result.length).toBe(1);
-      expect(result[0].success).toBe(true);
-    });
-
-    it('queries gate when more than 3 characters are supplied', async function () {
-      const http = mockHttpClient();
-      var result = null;
-
-      query = 'abcd';
-
-      http.expectGET(buildQueryString()).respond(200, [{ success: true }]);
-
-      var promise = service.findImages({ provider: 'aws', q: query, region: region });
-
-      promise.then(function (results) {
-        result = results;
-      });
-
-      await http.flush();
-
-      expect(result.length).toBe(1);
-      expect(result[0].success).toBe(true);
-    });
-
-    it('returns a message prompting user to enter more characters when less than 3 are supplied', function () {
-      query = 'ab';
-
-      var result = null;
-
-      service.findImages({ provider: 'aws', q: query, region: region }).then(function (results) {
-        result = results;
-      });
-
-      scope.$digest();
-
-      expect(result.length).toBe(1);
-      expect(result[0].message).toBe('Please enter at least 3 characters...');
-    });
-
-    it('returns an empty array when server errors', async function () {
-      const http = mockHttpClient();
-      query = 'abc';
-      var result = null;
-
-      http.expectGET(buildQueryString()).respond(404, {});
-
-      service.findImages({ provider: 'aws', q: query, region: region }).then(function (results) {
-        result = results;
-      });
-
-      await http.flush();
-
-      expect(result.length).toBe(0);
-    });
-  });
-
-  describe('getImage', function () {
-    var imageName = 'abc',
-      region = 'us-west-1',
-      credentials = 'test';
-
-    const buildQueryString = () => `/images/${credentials}/${region}/${imageName}?provider=aws`;
-
-    it('returns null if server returns 404 or an empty list', async function () {
-      const http = mockHttpClient();
-      var result = 'not null';
-
-      http.expectGET(buildQueryString()).respond(404, {});
-
-      service.getImage(imageName, region, credentials).then(function (results) {
-        result = results;
-      });
-
-      await http.flush();
-
-      expect(result).toBe(null);
-
-      result = 'not null';
-
-      http.expectGET(buildQueryString()).respond(200, []);
-
-      service.getImage(imageName, region, credentials).then(function (results) {
-        result = results;
-      });
-
-      await http.flush();
-
-      expect(result).toBe(null);
-    });
-  });
-});