func testRunnerSystemCommandAction()

in cmd/testrunner.go [437:594]
135 lines of code
31 McCabe index (conditional complexity)

func testRunnerSystemCommandAction(cmd *cobra.Command, args []string) error {
	cmd.Printf("Run system tests for the package\n")

	profile, err := cobraext.GetProfileFlag(cmd)
	if err != nil {
		return err
	}

	failOnMissing, err := cmd.Flags().GetBool(cobraext.FailOnMissingFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.FailOnMissingFlagName)
	}

	generateTestResult, err := cmd.Flags().GetBool(cobraext.GenerateTestResultFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.GenerateTestResultFlagName)
	}

	reportFormat, err := cmd.Flags().GetString(cobraext.ReportFormatFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.ReportFormatFlagName)
	}

	reportOutput, err := cmd.Flags().GetString(cobraext.ReportOutputFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.ReportOutputFlagName)
	}

	testCoverage, err := cmd.Flags().GetBool(cobraext.TestCoverageFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.TestCoverageFlagName)
	}

	testCoverageFormat, err := cmd.Flags().GetString(cobraext.TestCoverageFormatFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.TestCoverageFormatFlagName)
	}

	if !slices.Contains(testrunner.CoverageFormatsList(), testCoverageFormat) {
		return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)
	}

	deferCleanup, err := cmd.Flags().GetDuration(cobraext.DeferCleanupFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.DeferCleanupFlagName)
	}

	variantFlag, err := cmd.Flags().GetString(cobraext.VariantFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.VariantFlagName)
	}

	packageRootPath, found, err := packages.FindPackageRoot()
	if !found {
		return errors.New("package root not found")
	}
	if err != nil {
		return fmt.Errorf("locating package root failed: %w", err)
	}

	runSetup, err := cmd.Flags().GetBool(cobraext.SetupFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.SetupFlagName)
	}
	runTearDown, err := cmd.Flags().GetBool(cobraext.TearDownFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.TearDownFlagName)
	}
	runTestsOnly, err := cmd.Flags().GetBool(cobraext.NoProvisionFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.NoProvisionFlagName)
	}

	configFileFlag, err := cmd.Flags().GetString(cobraext.ConfigFileFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.ConfigFileFlagName)
	}
	if configFileFlag != "" {
		absPath, err := filepath.Abs(configFileFlag)
		if err != nil {
			return fmt.Errorf("cannot obtain the absolute path for config file path: %s", configFileFlag)
		}
		if _, err := os.Stat(absPath); err != nil {
			return fmt.Errorf("can't find config file %s: %w", configFileFlag, err)
		}
		configFileFlag = absPath
	}

	dataStreams, err := getDataStreamsFlag(cmd, packageRootPath)
	if err != nil {
		return err
	}

	ctx, stop := signal.Enable(cmd.Context(), logger.Info)
	defer stop()

	kibanaClient, err := stack.NewKibanaClientFromProfile(profile)
	if err != nil {
		return fmt.Errorf("can't create Kibana client: %w", err)
	}

	esClient, err := stack.NewElasticsearchClientFromProfile(profile)
	if err != nil {
		return fmt.Errorf("can't create Elasticsearch client: %w", err)
	}
	err = esClient.CheckHealth(ctx)
	if err != nil {
		return err
	}

	if runTearDown || runTestsOnly {
		if variantFlag != "" {
			return fmt.Errorf("variant flag cannot be set with --tear-down or --no-provision")
		}
	}

	manifest, err := packages.ReadPackageManifestFromPackageRoot(packageRootPath)
	if err != nil {
		return fmt.Errorf("reading package manifest failed (path: %s): %w", packageRootPath, err)
	}

	globalTestConfig, err := testrunner.ReadGlobalTestConfig(packageRootPath)
	if err != nil {
		return fmt.Errorf("failed to read global config: %w", err)
	}

	runner := system.NewSystemTestRunner(system.SystemTestRunnerOptions{
		Profile:            profile,
		PackageRootPath:    packageRootPath,
		KibanaClient:       kibanaClient,
		API:                esClient.API,
		ESClient:           esClient,
		ConfigFilePath:     configFileFlag,
		RunSetup:           runSetup,
		RunTearDown:        runTearDown,
		RunTestsOnly:       runTestsOnly,
		DataStreams:        dataStreams,
		ServiceVariant:     variantFlag,
		FailOnMissingTests: failOnMissing,
		GenerateTestResult: generateTestResult,
		DeferCleanup:       deferCleanup,
		GlobalTestConfig:   globalTestConfig.System,
		WithCoverage:       testCoverage,
		CoverageType:       testCoverageFormat,
	})

	logger.Debugf("Running suite...")
	results, err := testrunner.RunSuite(ctx, runner)
	if err != nil {
		return err
	}

	err = processResults(results, runner.Type(), reportFormat, reportOutput, packageRootPath, manifest.Name, manifest.Type, testCoverageFormat, testCoverage)
	if err != nil {
		return fmt.Errorf("failed to process results: %w", err)
	}
	return nil
}