async run()

in lib/apiScenario/gen/ApiTestRuleBasedGenerator.ts [456:515]
58 lines of code
10 McCabe index (conditional complexity)

  async run(outputDir: string, platFormType: PlatFormType) {
    const swaggerSpecs = await Promise.all(
      this.swaggerFiles.map((f) => this.swaggerLoader.load(f))
    );
    const analyzer = new ArmResourceAnalyzer(swaggerSpecs, this.jsonLoader);
    const trackedResources = analyzer.getTrackedResource();
    const proxyResources = analyzer.getProxyResource();
    const extensionResources = analyzer.getExtensionResource();
    const generateForResources = async (
      resources: ArmResourceManipulator[],
      kind: ArmResourceKind
    ) => {
      let base: RawScenario = { steps: [] };
      let dependency = this.dependencyFile
        ? new ArmResourceDependencyGenerator(
            this.swaggerFiles,
            this.dependencyFile,
            outputDir,
            this.basicScenarioFile
          )
        : undefined;

      for (const resource of resources) {
        const definition: RawScenarioDefinition = {
          scope: "ResourceGroup",
          variables: undefined,
          prepareSteps: undefined,
          scenarios: [],
          cleanUpSteps: undefined,
        };
        for (const rule of this.rules.filter(
          (rule) => rule.resourceKinds?.includes(kind) && rule.appliesTo.includes(platFormType)
        )) {
          // what if no dependency ??
          base = (await dependency?.generate(resource, rule.useExample)) || base;
          if (base) {
            const apiSenarios = rule.generator(resource, base);
            if (apiSenarios) {
              apiSenarios.description = "[This scenario is auto-generated]" + rule.description;
              dependency?.updateExampleFile(resource, apiSenarios);
              dependency?.generateResourceCleanup(resource, apiSenarios);
              definition.scenarios.push({ scenario: rule.name, ...apiSenarios });
            }
          }
        }
        if (definition.scenarios.length > 0) {
          const [prepare, cleanup] = dependency?.getPrepareAndCleanUp(resource) || [
            undefined,
            undefined,
          ];
          definition.prepareSteps = prepare;
          definition.cleanUpSteps = cleanup;
          this.writeFile(resource.resourceType, definition, outputDir);
        }
      }
    };
    await generateForResources(trackedResources, "Tracked");
    await generateForResources(proxyResources, "Proxy");
    await generateForResources(extensionResources, "Extension");
  }