func testRunnerPipelineCommandAction()

in cmd/testrunner.go [297:399]
85 lines of code
18 McCabe index (conditional complexity)

func testRunnerPipelineCommandAction(cmd *cobra.Command, args []string) error {
	cmd.Printf("Run pipeline tests for the package\n")
	testType := testrunner.TestType("pipeline")

	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)
	}

	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)
	}

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

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

	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
	}

	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 := pipeline.NewPipelineTestRunner(pipeline.PipelineTestRunnerOptions{
		Profile:            profile,
		PackageRootPath:    packageRootPath,
		API:                esClient.API,
		DataStreams:        dataStreams,
		FailOnMissingTests: failOnMissing,
		GenerateTestResult: generateTestResult,
		WithCoverage:       testCoverage,
		CoverageType:       testCoverageFormat,
		DeferCleanup:       deferCleanup,
		GlobalTestConfig:   globalTestConfig.Pipeline,
	})

	results, err := testrunner.RunSuite(ctx, runner)
	if err != nil {
		return err
	}

	return processResults(results, testType, reportFormat, reportOutput, packageRootPath, manifest.Name, manifest.Type, testCoverageFormat, testCoverage)
}