func NewSystemTester()

in internal/testrunner/runners/system/tester.go [222:300]
65 lines of code
11 McCabe index (conditional complexity)

func NewSystemTester(options SystemTesterOptions) (*tester, error) {
	r := tester{
		profile:                    options.Profile,
		testFolder:                 options.TestFolder,
		packageRootPath:            options.PackageRootPath,
		generateTestResult:         options.GenerateTestResult,
		esAPI:                      options.API,
		esClient:                   options.ESClient,
		kibanaClient:               options.KibanaClient,
		deferCleanup:               options.DeferCleanup,
		serviceVariant:             options.ServiceVariant,
		configFileName:             options.ConfigFileName,
		runSetup:                   options.RunSetup,
		runTestsOnly:               options.RunTestsOnly,
		runTearDown:                options.RunTearDown,
		globalTestConfig:           options.GlobalTestConfig,
		withCoverage:               options.WithCoverage,
		coverageType:               options.CoverageType,
		runIndependentElasticAgent: true,
	}
	r.resourcesManager = resources.NewManager()
	r.resourcesManager.RegisterProvider(resources.DefaultKibanaProviderName, &resources.KibanaProvider{Client: r.kibanaClient})

	r.serviceStateFilePath = filepath.Join(stateFolderPath(r.profile.ProfilePath), serviceStateFileName)

	var err error

	r.locationManager, err = locations.NewLocationManager()
	if err != nil {
		return nil, fmt.Errorf("reading service logs directory failed: %w", err)
	}

	r.dataStreamPath, _, err = packages.FindDataStreamRootForPath(r.testFolder.Path)
	if err != nil {
		return nil, fmt.Errorf("locating data stream root failed: %w", err)
	}

	if r.esAPI == nil {
		return nil, errors.New("missing Elasticsearch client")
	}
	if r.kibanaClient == nil {
		return nil, errors.New("missing Kibana client")
	}

	r.stackVersion, err = r.kibanaClient.Version()
	if err != nil {
		return nil, fmt.Errorf("cannot request Kibana version: %w", err)
	}

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

	r.dataStreamManifest, err = packages.ReadDataStreamManifest(filepath.Join(r.dataStreamPath, packages.DataStreamManifestFile))
	if err != nil {
		return nil, fmt.Errorf("reading data stream manifest failed: %w", err)
	}

	// If the environment variable is present, it always has preference over the root
	// privileges value (if any) defined in the manifest file
	v, ok := os.LookupEnv(enableIndependentAgentsEnv)
	if ok {
		r.runIndependentElasticAgent = strings.ToLower(v) == "true"
	}

	// default method to validate using mappings (along with fields)
	r.fieldValidationMethod = mappingsMethod
	v, ok = os.LookupEnv(fieldValidationTestMethodEnv)
	if ok {
		method, ok := validationMethods[v]
		if !ok {
			return nil, fmt.Errorf("invalid field method option: %s", v)
		}
		r.fieldValidationMethod = method
	}

	return &r, nil
}