TypeScript core.ApplicationModelBuilder类代码示例

 (
   $controller: IControllerService,
   $rootScope: IRootScopeService,
   _$state_: StateService,
   _securityGroupReader_: SecurityGroupReader,
   _confirmationModalService_: ConfirmationModalService,
   _loadBalancerReader_: LoadBalancerReader,
 ) => {
   $scope = $rootScope.$new();
   $state = _$state_;
   const app = ApplicationModelBuilder.createApplicationForTests('app', { key: 'loadBalancers', lazy: true });
   app.loadBalancers.data.push(loadBalancer);
   securityGroupReader = _securityGroupReader_;
   confirmationModalService = _confirmationModalService_;
   loadBalancerReader = _loadBalancerReader_;
   controller = $controller('oracleLoadBalancerDetailCtrl', {
     $scope: $scope,
     loadBalancer: loadBalancer,
     app: app,
     $state: $state,
     securityGroupReader: securityGroupReader,
     loadBalancerReader: loadBalancerReader,
     confirmationModalService: confirmationModalService,
   });
 },

 mock.inject(($controller: IControllerService, $rootScope: IRootScopeService, _$state_: StateService) => {
   $scope = $rootScope.$new();
   $state = _$state_;
   const app = ApplicationModelBuilder.createApplicationForTests('app', { key: 'loadBalancers', lazy: true });
   app.loadBalancers.data.push(loadBalancer);
   controller = $controller(AwsLoadBalancerDetailsController, {
     $scope,
     loadBalancer,
     app,
     $state,
   });
 }),

    mock.inject(($controller: IControllerService, $rootScope: IRootScopeService, _$state_: StateService) => {
      $scope = $rootScope.$new();
      $state = _$state_;
      const application = ApplicationModelBuilder.createApplicationForTests('app', {
        key: 'loadBalancers',
        lazy: true,
      });

      const isNew = true;
      controller = $controller(OracleLoadBalancerController, {
        $scope,
        $uibModalInstance: { dismiss: noop, result: { then: noop } },
        loadBalancer,
        application,
        $state,
        isNew,
      });
      controller.addBackendSet();
      controller.addListener();
      controller.addCert();

      controller.listeners[0].defaultBackendSetName = controller.backendSets[0].name;
    }),

 beforeEach(mock.inject(($controller: IControllerService,
                         $rootScope: IRootScopeService,
                         _$q_: IQService,
                         _accountService_: AccountService,
                         _subnetReader_: SubnetReader,
                         _amazonCertificateReader_: AmazonCertificateReader,
                         applicationModelBuilder: ApplicationModelBuilder,
                         _securityGroupReader_: SecurityGroupReader,
                         awsLoadBalancerTransformer: AwsLoadBalancerTransformer) => {
   $scope = $rootScope.$new();
   $q = _$q_;
   securityGroupReader = _securityGroupReader_;
   accountService = _accountService_;
   subnetReader = _subnetReader_;
   amazonCertificateReader = _amazonCertificateReader_;
   const app = applicationModelBuilder.createApplication('app', {key: 'loadBalancers', lazy: true});
   initialize = (loadBalancer: IAmazonClassicLoadBalancer = null) => {
     if (loadBalancer) {
       spyOn(awsLoadBalancerTransformer, 'convertClassicLoadBalancerForEditing').and.returnValue(loadBalancer);
     }
     controller = $controller<CreateClassicLoadBalancerCtrl>('awsCreateClassicLoadBalancerCtrl', {
       $scope: $scope,
       $uibModalInstance: {dismiss: noop, result: {then: noop}},
       infrastructureCaches: { get: () => { return {getStats: () => {return {}; } }; } },
       application: app,
       loadBalancer: loadBalancer,
       isNew: loadBalancer === null,
       forPipelineConfig: false,
       securityGroupReader: securityGroupReader,
       accountService: accountService,
       subnetReader: subnetReader,
       amazonCertificateReader: amazonCertificateReader,
       awsLoadBalancerTransformer: awsLoadBalancerTransformer,
     });
     controller.$onInit();
   };
 }));

describe('Service: awsServerGroupConfiguration', function() {
  let service: AwsServerGroupConfigurationService,
    $q: IQService,
    securityGroupReader: SecurityGroupReader,
    awsInstanceTypeService: any,
    cacheInitializer: CacheInitializerService,
    loadBalancerReader: LoadBalancerReader,
    applicationModelBuilder: ApplicationModelBuilder,
    $scope: IScope;

  beforeEach(mock.module(APPLICATION_MODEL_BUILDER, AWS_SERVER_GROUP_CONFIGURATION_SERVICE));

  beforeEach(
    mock.inject(function(
      _awsServerGroupConfigurationService_: AwsServerGroupConfigurationService,
      _$q_: IQService,
      _securityGroupReader_: SecurityGroupReader,
      _awsInstanceTypeService_: any,
      _cacheInitializer_: CacheInitializerService,
      _loadBalancerReader_: LoadBalancerReader,
      _applicationModelBuilder_: ApplicationModelBuilder,
      $rootScope: IRootScopeService,
    ) {
      service = _awsServerGroupConfigurationService_;
      $q = _$q_;
      securityGroupReader = _securityGroupReader_;
      awsInstanceTypeService = _awsInstanceTypeService_;
      cacheInitializer = _cacheInitializer_;
      loadBalancerReader = _loadBalancerReader_;
      applicationModelBuilder = _applicationModelBuilder_;
      $scope = $rootScope.$new();

      this.allLoadBalancers = [
        {
          name: 'elb-1',
          accounts: [
            {
              name: 'test',
              regions: [
                {
                  name: 'us-east-1',
                  loadBalancers: [{ region: 'us-east-1', vpcId: 'vpc-1', name: 'elb-1', targetGroups: [] }],
                },
              ],
            },
          ],
        },
        {
          name: 'elb-2',
          accounts: [
            {
              name: 'test',
              regions: [
                {
                  name: 'us-east-1',
                  loadBalancers: [{ region: 'us-east-1', vpcId: 'vpc-2', name: 'elb-2', targetGroups: [] }],
                },
                {
                  name: 'us-west-1',
                  loadBalancers: [{ region: 'us-west-1', vpcId: null, name: 'elb-2', targetGroups: [] }],
                },
              ],
            },
          ],
        },
      ];
    }),
  );

  describe('configureCommand', function() {
    it('attempts to reload load balancers if some are not found on initialization, but does not set dirty flag', function() {
      spyOn(AccountService, 'getCredentialsKeyedByAccount').and.returnValue($q.when([]));
      spyOn(securityGroupReader, 'getAllSecurityGroups').and.returnValue($q.when([]));
      const listLoadBalancersSpy = spyOn(loadBalancerReader, 'listLoadBalancers').and.returnValue(
        $q.when(this.allLoadBalancers),
      );
      spyOn(SubnetReader, 'listSubnets').and.returnValue($q.when([]));
      spyOn(AccountService, 'getPreferredZonesByAccount').and.returnValue($q.when([]));
      spyOn(KeyPairsReader, 'listKeyPairs').and.returnValue($q.when([]));
      spyOn(awsInstanceTypeService, 'getAllTypesByRegion').and.returnValue($q.when([]));
      const refreshCacheSpy = spyOn(cacheInitializer, 'refreshCache').and.returnValue($q.when(null));

      const command = {
        credentials: 'test',
        region: 'us-east-1',
        loadBalancers: ['elb-1', 'elb-3'],
        vpcId: null,
        viewState: {
          disableImageSelection: true,
          dirty: {},
        },
      } as any;

      service.configureCommand(
        applicationModelBuilder.createApplication('name', { key: 'loadBalancers', lazy: true }),
        command,
      );
      $scope.$digest();

      expect(cacheInitializer.refreshCache).toHaveBeenCalledWith('loadBalancers');
//.........这里部分代码省略.........

 mock.inject(($q: IQService, $rootScope: IScope) => {
   const $scope = $rootScope.$new();
   // The application model implicitly depends on a bunch of Angular things, which is why
   // we need the Angular mock environment (even though we're testing a React component).
   application = ApplicationModelBuilder.createApplicationForTests(
     'app',
     {
       key: 'serverGroups',
       loader: () =>
         $q.resolve([
           // Replica sets in same cluster, no manager.
           {
             name: 'replicaSet my-replicaSet-v002',
             region: 'default',
             category: 'serverGroup',
             account: 'my-k8s-account',
             cloudProvider: 'kubernetes',
             cluster: 'replicaSet my-replicaSet',
           },
           {
             name: 'replicaSet my-replicaSet-v001',
             region: 'default',
             category: 'serverGroup',
             account: 'my-k8s-account',
             cloudProvider: 'kubernetes',
             cluster: 'replicaSet my-replicaSet',
           },
           // Replica set managed by deployment.
           {
             name: 'replicaSet my-managed-replicaSet-v001',
             region: 'default',
             category: 'serverGroup',
             account: 'my-k8s-account',
             cloudProvider: 'kubernetes',
             cluster: 'deployment my-deployment',
             serverGroupManagers: [{ name: 'deployment my-deployment' }],
           },
         ]),
       onLoad: (_app: Application, data: any) => $q.resolve(data),
     },
     {
       key: 'serverGroupManagers',
       loader: () =>
         $q.resolve([
           {
             name: 'deployment my-deployment',
             region: 'default',
             account: 'my-k8s-account',
             cloudProvider: 'kubernetes',
           },
         ]),
       onLoad: (_app: Application, data: any) => $q.resolve(data),
     },
     {
       key: 'securityGroups',
       loader: () => $q.resolve([]),
       onLoad: (_app: Application, data: any) => $q.resolve(data),
     },
     {
       key: 'loadBalancers',
       loader: () => $q.resolve([]),
       onLoad: (_app: Application, data: any) => $q.resolve(data),
     },
   );
   application.refresh();
   $scope.$digest();
 }),

    it('attempts to reload load balancers if some are not found on initialization, but does not set dirty flag', function() {
      spyOn(AccountService, 'getCredentialsKeyedByAccount').and.returnValue($q.when([]));
      spyOn(securityGroupReader, 'getAllSecurityGroups').and.returnValue($q.when([]));
      const listLoadBalancersSpy = spyOn(loadBalancerReader, 'listLoadBalancers').and.returnValue(
        $q.when(this.allLoadBalancers),
      );
      spyOn(SubnetReader, 'listSubnets').and.returnValue($q.when([]));
      spyOn(AccountService, 'getPreferredZonesByAccount').and.returnValue($q.when([]));
      spyOn(KeyPairsReader, 'listKeyPairs').and.returnValue($q.when([]));
      spyOn(awsInstanceTypeService, 'getAllTypesByRegion').and.returnValue($q.when([]));
      const refreshCacheSpy = spyOn(cacheInitializer, 'refreshCache').and.returnValue($q.when(null));

      const command = {
        credentials: 'test',
        region: 'us-east-1',
        loadBalancers: ['elb-1', 'elb-3'],
        vpcId: null,
        viewState: {
          disableImageSelection: true,
          dirty: {},
        },
      } as any;

      service.configureCommand(
        applicationModelBuilder.createApplication('name', { key: 'loadBalancers', lazy: true }),
        command,
      );
      $scope.$digest();

      expect(cacheInitializer.refreshCache).toHaveBeenCalledWith('loadBalancers');
      expect(refreshCacheSpy.calls.count()).toBe(1);
      expect(listLoadBalancersSpy.calls.count()).toBe(1);
      expect(command.dirty).toBeUndefined();
    });