func()

in internal/testrunner/runners/system/runner.go [146:276]
119 lines of code
42 McCabe index (conditional complexity)

func (r *runner) GetTests(ctx context.Context) ([]testrunner.Tester, error) {
	var folders []testrunner.TestFolder
	manifest, err := packages.ReadPackageManifestFromPackageRoot(r.packageRootPath)
	if err != nil {
		return nil, fmt.Errorf("reading package manifest failed (path: %s): %w", r.packageRootPath, err)
	}

	hasDataStreams, err := testrunner.PackageHasDataStreams(manifest)
	if err != nil {
		return nil, fmt.Errorf("cannot determine if package has data streams: %w", err)
	}

	if r.runSetup || r.runTearDown || r.runTestsOnly {
		_, err := os.Stat(r.serviceStateFilePath)
		logger.Debugf("Service state data exists in %s: %v", r.serviceStateFilePath, !os.IsNotExist(err))
		if r.runSetup && !os.IsNotExist(err) {
			return nil, fmt.Errorf("failed to run --setup, required to tear down previous setup")
		}
		if r.runTestsOnly && os.IsNotExist(err) {
			return nil, fmt.Errorf("failed to run tests with --no-provision, setup first with --setup")
		}
		if r.runTearDown && os.IsNotExist(err) {
			return nil, fmt.Errorf("failed to run --tear-down, setup not found")
		}
	} else {
		if _, err = os.Stat(r.serviceStateFilePath); !os.IsNotExist(err) {
			return nil, fmt.Errorf("failed to run tests, required to tear down previous state run (path: %s)", r.serviceStateFilePath)
		}
	}

	var serviceState ServiceState
	if r.runTearDown || r.runTestsOnly {
		serviceState, err = readServiceStateData(r.serviceStateFilePath)
		if err != nil {
			return nil, fmt.Errorf("failed to read service state: %w", err)
		}
	}

	if hasDataStreams {
		var dataStreams []string
		if r.runSetup || r.runTearDown || r.runTestsOnly {
			configFilePath := r.configFilePath
			if r.runTearDown || r.runTestsOnly {
				configFilePath = serviceState.ConfigFilePath
			}
			dataStream := testrunner.ExtractDataStreamFromPath(configFilePath, r.packageRootPath)
			dataStreams = append(dataStreams, dataStream)
		} else if len(r.dataStreams) > 0 {
			dataStreams = r.dataStreams
		}

		folders, err = testrunner.FindTestFolders(r.packageRootPath, dataStreams, r.Type())
		if err != nil {
			return nil, fmt.Errorf("unable to determine test folder paths: %w", err)
		}

		if r.failOnMissingTests && len(folders) == 0 {
			if len(dataStreams) > 0 {
				return nil, fmt.Errorf("no %s tests found for %s data stream(s)", r.Type(), strings.Join(dataStreams, ","))
			}
			return nil, fmt.Errorf("no %s tests found", r.Type())
		}
	} else {
		folders, err = testrunner.FindTestFolders(r.packageRootPath, nil, r.Type())
		if err != nil {
			return nil, fmt.Errorf("unable to determine test folder paths: %w", err)
		}
		if r.failOnMissingTests && len(folders) == 0 {
			return nil, fmt.Errorf("no %s tests found", r.Type())
		}
	}

	if r.runSetup || r.runTearDown || r.runTestsOnly {
		// variant flag is not checked here since there are packages that do not have variants
		if len(folders) != 1 {
			return nil, fmt.Errorf("wrong number of test folders (expected 1): %d", len(folders))
		}
	}

	var testers []testrunner.Tester
	for _, t := range folders {
		var variants []string
		var cfgFiles []string

		if r.runTestsOnly || r.runTearDown {
			variants = []string{serviceState.VariantName}
			cfgFiles = []string{filepath.Base(serviceState.ConfigFilePath)}
		} else {
			variants, err = r.getAllVariants(t)
			if err != nil {
				return nil, fmt.Errorf("failed to retrieve variants from %s: %w", t.Path, err)
			}

			cfgFiles, err = r.getAllConfigFiles(t)
			if err != nil {
				return nil, fmt.Errorf("failed to retrieve config files from %s: %w", t.Path, err)
			}
		}

		for _, variant := range variants {
			for _, config := range cfgFiles {
				logger.Debugf("System runner: data stream %q config file %q variant %q", t.DataStream, config, variant)
				tester, err := NewSystemTester(SystemTesterOptions{
					Profile:            r.profile,
					PackageRootPath:    r.packageRootPath,
					KibanaClient:       r.kibanaClient,
					API:                r.esAPI,
					ESClient:           r.esClient,
					TestFolder:         t,
					ServiceVariant:     variant,
					GenerateTestResult: r.generateTestResult,
					DeferCleanup:       r.deferCleanup,
					RunSetup:           r.runSetup,
					RunTestsOnly:       r.runTestsOnly,
					RunTearDown:        r.runTearDown,
					ConfigFileName:     config,
					GlobalTestConfig:   r.globalTestConfig,
					WithCoverage:       r.withCoverage,
					CoverageType:       r.coverageType,
				})
				if err != nil {
					return nil, fmt.Errorf(
						"failed to create system runner for sdata stream %q variant %q config file %q: %w",
						t.DataStream, variant, config, err)
				}
				testers = append(testers, tester)
			}
		}
	}
	return testers, nil
}