TypeScript PipelineConfigService.PipelineConfigService類代碼示例

    it('should fix sort order of pipelines on initialization: 0..n, index collisions sorted alphabetically', () => {
      const fromServer: IPipeline[] = [
        buildPipeline({ name: 'second', index: 1, stages: [] }),
        buildPipeline({ name: 'last', index: 5, stages: [] }),
        buildPipeline({ name: 'first', index: -3, stages: [] }),
        buildPipeline({ name: 'duplicateIndex', index: 5, stages: [] }),
      ];

      const posted: any[] = [];
      $http.expectGET(API.baseUrl + '/applications/app/pipelineConfigs').respond(200, fromServer);
      $http
        .whenPOST(API.baseUrl + '/pipelines', (data: string) => {
          const json: any = JSON.parse(data);
          posted.push({ index: json.index, name: json.name });
          return true;
        })
        .respond(200, {});

      PipelineConfigService.getPipelinesForApplication('app');
      $scope.$digest();
      $http.flush();

      expect(posted).toEqual([
        { name: 'first', index: 0 },
        { name: 'duplicateIndex', index: 2 },
        { name: 'last', index: 3 },
      ]);
    });

  public validate(
    pipeline: IPipeline,
    stage: IStage,
    validator: ITargetImpedanceValidationConfig,
    _config: IStageOrTriggerTypeConfig,
  ): string {
    const stagesToTest: IStage[] = PipelineConfigService.getAllUpstreamDependencies(pipeline, stage),
      regions: string[] = stage['regions'] || [];
    let allRegionsFound = true;

    regions.forEach(region => {
      let regionFound = false;
      stagesToTest.forEach(toTest => {
        if (toTest.type === 'deploy' && toTest['clusters'] && toTest['clusters'].length) {
          toTest['clusters'].forEach((cluster: any) => {
            const clusterName: string = NameUtils.getClusterName(
              cluster.application,
              cluster.stack,
              cluster.freeFormDetails,
            );
            if (
              clusterName === stage['cluster'] &&
              cluster.account === stage['credentials'] &&
              cluster.availabilityZones &&
              cluster.availabilityZones.hasOwnProperty(region)
            ) {
              regionFound = true;
            }
          });
        } else if (
          toTest.type === 'cloneServerGroup' &&
          NameUtils.getClusterName(toTest['application'], toTest['stack'], toTest['freeFormDetails']) ===
            stage['cluster'] &&
          toTest['region'] === region
        ) {
          regionFound = true;
        }
      });
      if (!regionFound) {
        allRegionsFound = false;
      }
    });
    if (!allRegionsFound) {
      return validator.message;
    }
    return null;
  }

  public validate(
    pipeline: IPipeline,
    stage: IStage,
    validator: IStageBeforeTypeValidationConfig,
    _config: IStageOrTriggerTypeConfig,
  ): string {
    if (pipeline.strategy === true && stage.type === 'deploy') {
      return null;
    }

    const stageTypes: string[] = validator.stageTypes || [validator.stageType];
    const stagesToTest = PipelineConfigService.getAllUpstreamDependencies(pipeline, stage);
    if (stagesToTest.every(test => !stageTypes.includes(test.type))) {
      return validator.message;
    }
    return null;
  }

  public static getExpectedArtifactsAvailableToStage(stage: IStage, pipeline: IPipeline): IExpectedArtifact[] {
    if (!stage || !pipeline) {
      return [];
    }
    let result = pipeline.expectedArtifacts || [];
    PipelineConfigService.getAllUpstreamDependencies(pipeline, stage).forEach(s => {
      const expectedArtifact = (s as any).expectedArtifact;
      if (expectedArtifact) {
        result = result.concat(expectedArtifact);
      }

      const expectedArtifacts = (s as any).expectedArtifacts;
      if (expectedArtifacts) {
        result = result.concat(expectedArtifacts);
      }
    });
    return result;
  }

    it('clears isNew flags, stage name if not present', () => {
      const pipeline: IPipeline = buildPipeline({
        stages: [
          { name: 'explicit name', type: 'bake', isNew: true },
          { name: null, type: 'bake', isNew: true },
          { name: '', type: 'bake', isNew: true },
        ],
      });

      $http.expectPOST(API.baseUrl + '/pipelines').respond(200, '');

      PipelineConfigService.savePipeline(pipeline);
      $scope.$digest();

      expect(pipeline.stages[0].name).toBe('explicit name');
      expect(pipeline.stages[1].name).toBeUndefined();
      expect(pipeline.stages[2].name).toBeUndefined();

      expect(pipeline.stages[0].isNew).toBeUndefined();
      expect(pipeline.stages[1].isNew).toBeUndefined();
      expect(pipeline.stages[2].isNew).toBeUndefined();
    });

 expect(() => {
   PipelineConfigService.getAllUpstreamDependencies(null, null);
 }).not.toThrow();