func testRunnerPolicyCommandAction()

in cmd/testrunner.go [611:702]
75 lines of code
16 McCabe index (conditional complexity)

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

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

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

	kibanaClient, err := stack.NewKibanaClientFromProfile(profile)
	if err != nil {
		return fmt.Errorf("can't create Kibana client: %w", 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 := policy.NewPolicyTestRunner(policy.PolicyTestRunnerOptions{
		PackageRootPath:    packageRootPath,
		KibanaClient:       kibanaClient,
		DataStreams:        dataStreams,
		FailOnMissingTests: failOnMissing,
		GenerateTestResult: generateTestResult,
		GlobalTestConfig:   globalTestConfig.Policy,
		WithCoverage:       testCoverage,
		CoverageType:       testCoverageFormat,
	})

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

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