TypeScript IQService.when方法代码示例

 it('should put existing security groups in the front of the available list', () => {
   const availableSecurityGroups = {
     test: {
       aws: {
         'us-east-1': [
           {name: 'a', id: '1', vpcId: 'vpc-1'},
           {name: 'b', id: '2', vpcId: 'vpc-1'},
           {name: 'c', id: '3', vpcId: 'vpc-1'},
           {name: 'd', id: '4', vpcId: 'vpc-1'}]
       }
     }
   };
   const existingLoadBalancer = {
     name: 'elb-1',
     vpcId: 'vpc-1',
     credentials: 'test',
     region: 'us-east-1',
     securityGroups: ['4'],
     listeners: [],
   } as IAmazonClassicLoadBalancer;
   spyOn(securityGroupReader, 'getAllSecurityGroups').and.returnValue($q.when(availableSecurityGroups));
   spyOn(accountService, 'getAccountDetails').and.returnValue($q.when([{name: 'test'}]));
   spyOn(subnetReader, 'listSubnets').and.returnValue($q.when([{account: 'test', region: 'us-east-1', vpcId: 'vpc-1'}]));
   spyOn(amazonCertificateReader, 'listCertificates').and.returnValue($q.when([]));
   initialize(existingLoadBalancer);
   $scope.$digest();
   expect(controller.availableSecurityGroups.map(g => g.name)).toEqual(['d', 'a', 'b', 'c']);
 });

    return this.accountService.listProviders(application).then((providers) => {
      let provider;
      let reducedProviders: string[] = [];
      if (feature) {
        reducedProviders = providers.filter((p) => this.cloudProviderRegistry.hasValue(p, feature));
      }

      // reduce the providers to the smallest, unique collection taking into consideration the useProvider values
      reducedProviders = uniq(reducedProviders.map((providerName) => {
        const providerFeature = this.cloudProviderRegistry.getProvider(providerName)[feature] || {};
        return providerFeature.useProvider || providerName;
      }));

      if (reducedProviders.length > 1) {
        provider = this.$uibModal.open({
          templateUrl: require('./providerSelection.html'),
          controller: 'ProviderSelectCtrl as ctrl',
          resolve: {
            providerOptions: () =>  reducedProviders
          }
        }).result;
      } else if (reducedProviders.length === 1) {
        provider = this.$q.when(reducedProviders[0]);
      } else {
        provider = this.$q.when(SETTINGS.defaultProvider || 'aws');
      }
      return provider;
    });

    return this.accountService.applicationAccounts(application).then((accounts: IAccountDetails[]) => {
      let reducedAccounts: IAccountDetails[] = [];
      if (feature) {
        reducedAccounts = accounts.filter(a => this.cloudProviderRegistry.hasValue(a.cloudProvider, feature));
      }

      if (filterFn) {
        reducedAccounts = reducedAccounts.filter((acc: IAccountDetails) => {
          return filterFn(application, acc, this.cloudProviderRegistry.getProvider(acc.cloudProvider, acc.providerVersion));
        });
      }

      // reduce the accounts to the smallest, unique collection taking into consideration the useProvider values
      const reducedProviders = uniq(reducedAccounts.map(a => {
        const providerFeature = this.cloudProviderRegistry.getProvider(a.cloudProvider)[feature] || {};
        return providerFeature.useProvider || a.cloudProvider;
      }));

      let provider;
      if (reducedProviders.length > 1) {
        provider = this.$uibModal.open({
          templateUrl: require('./providerSelection.html'),
          controller: 'ProviderSelectCtrl as ctrl',
          resolve: {
            providerOptions: () =>  reducedProviders
          }
        }).result;
      } else if (reducedProviders.length === 1) {
        provider = this.$q.when(reducedProviders[0]);
      } else {
        provider = this.$q.when(SETTINGS.defaultProvider || 'aws');
      }
      return provider;
    });

 it('gets job config and adds parameters to scope, setting defaults if present and not overridden', () => {
   const params: IParameterDefinitionList[] = [
     { name: 'overridden', defaultValue: 'z' },
     { name: 'notSet', defaultValue: 'a' },
     { name: 'noDefault', defaultValue: null },
   ];
   const jobConfig = {
     parameterDefinitionList: params,
   } as IJobConfig;
   spyOn(IgorService, 'listJobsForMaster').and.returnValue($q.when(['a', 'b']));
   spyOn(IgorService, 'getJobConfig').and.returnValue($q.when(jobConfig));
   const stage = {
     master: 'not-parameterized',
     job: 'a',
     parameters: {
       overridden: 'f',
     },
   };
   const controller = initialize(stage);
   $scope.$digest();
   expect(controller.jobs).toEqual(['a', 'b']);
   expect(controller.viewState.jobsLoaded).toBe(true);
   expect(controller.stage.job).toBe('a');
   expect(controller.jobParams).toBe(params);
   expect(controller.useDefaultParameters.overridden).toBeUndefined();
   expect(controller.useDefaultParameters.notSet).toBe(true);
   expect(controller.useDefaultParameters.noDefault).toBeUndefined();
 });

 beforeEach(() => {
   initialized = false;
   spyOn(AccountService, 'listAllAccounts').and.returnValue($q.when(keys.account));
   spyOn(securityGroupReader, 'getAllSecurityGroups').and.returnValue($q.when(keys.sg));
   spyOn(ApplicationReader, 'listApplications').and.returnValue($q.when(keys.app));
   spyOn(IgorService, 'listMasters').and.returnValue($q.when(keys.bm));
   spyOn(AccountService, 'listProviders').and.returnValue($q.when([]));
 });

    it('gets list of jobs when initialized with a trigger with a master and sets loading states', () => {
      const jobs = ['some_job', 'some_other_job'],
        trigger = { master: 'travis', job: 'some_job' } as IBuildTrigger;

      spyOn(IgorService, 'listJobsForMaster').and.returnValue($q.when(jobs));
      spyOn(IgorService, 'listMasters').and.returnValue($q.when(['travis']));
      const controller = initializeController(trigger);
      expect(controller.viewState.jobsLoaded).toBe(false);
      expect(controller.viewState.mastersLoaded).toBe(false);
      $scope.$digest();
      expect(controller.jobs).toBe(jobs);
      expect(controller.masters).toEqual(['travis']);
      expect(controller.viewState.jobsLoaded).toBe(true);
      expect(controller.viewState.mastersLoaded).toBe(true);
    });

    it('gets list of jobs when initialized with a wercker master and sets loading states', () => {
      const jobs = ['type/org/app/p1', 'type/org/app/p2'],
        trigger = { master: 'wercker', job: 'type/org/app/some_job' } as IWerckerTrigger;

      spyOn(IgorService, 'listJobsForMaster').and.returnValue($q.when(jobs));
      spyOn(IgorService, 'listMasters').and.returnValue($q.when(['wercker']));
      const controller = initializeController(trigger);
      expect(controller.viewState.appsLoaded).toBe(false);
      expect(controller.viewState.mastersLoaded).toBe(false);
      $scope.$digest();
      expect(controller.jobs).toBe(jobs);
      expect(controller.masters).toEqual(['wercker']);
      expect(controller.viewState.appsLoaded).toBe(true);
      expect(controller.viewState.mastersLoaded).toBe(true);
    });

      .then((backingData: Partial<IEcsServerGroupCommandBackingData>) => {
        let loadBalancerReloader = this.$q.when();
        backingData.accounts = keys(backingData.credentialsKeyedByAccount);
        backingData.filtered = {} as IEcsServerGroupCommandBackingDataFiltered;
        cmd.backingData = backingData as IEcsServerGroupCommandBackingData;
        this.configureVpcId(cmd);
        this.configureAvailableIamRoles(cmd);
        this.configureAvailableSubnetTypes(cmd);
        this.configureAvailableSecurityGroups(cmd);
        this.configureAvailableMetricAlarms(cmd);
        this.configureAvailableEcsClusters(cmd);

        if (cmd.loadBalancers && cmd.loadBalancers.length) {
          // verify all load balancers are accounted for; otherwise, try refreshing load balancers cache
          const loadBalancerNames = this.getLoadBalancerNames(cmd);
          if (intersection(loadBalancerNames, cmd.loadBalancers).length < cmd.loadBalancers.length) {
            loadBalancerReloader = this.refreshLoadBalancers(cmd, true);
          }
        }

        return this.$q.all([loadBalancerReloader]).then(() => {
          this.applyOverrides('afterConfiguration', cmd);
          this.attachEventHandlers(cmd);
        });
      });