func()

in internal/testrunner/runners/asset/tester.go [90:179]
72 lines of code
14 McCabe index (conditional complexity)

func (r *tester) run(ctx context.Context) ([]testrunner.TestResult, error) {
	result := testrunner.NewResultComposer(testrunner.TestResult{
		TestType: TestType,
		Package:  r.testFolder.Package,
	})

	if r.kibanaClient == nil {
		return result.WithError(errors.New("missing Kibana client"))
	}

	testConfig, err := newConfig(r.testFolder.Path)
	if err != nil {
		return result.WithError(fmt.Errorf("unable to load asset loading test config file: %w", err))
	}

	skipConfigs := []*testrunner.SkipConfig{r.globalTestConfig.Skip}
	if testConfig != nil {
		skipConfigs = append(skipConfigs, testConfig.Skip)
	}

	if skip := testrunner.AnySkipConfig(skipConfigs...); skip != nil {
		logger.Warnf("skipping %s test for %s/%s: %s (details: %s)",
			TestType, r.testFolder.Package, r.testFolder.DataStream,
			skip.Reason, skip.Link)
		return result.WithSkip(skip)
	}

	logger.Debug("installing package...")
	_, err = r.resourcesManager.ApplyCtx(ctx, r.resources(true))
	if err != nil {
		return result.WithError(fmt.Errorf("can't install the package: %w", err))
	}

	manifest, err := packages.ReadPackageManifestFromPackageRoot(r.packageRootPath)
	if err != nil {
		return result.WithError(fmt.Errorf("cannot read the package manifest from %s: %w", r.packageRootPath, err))
	}
	installedPackage, err := r.kibanaClient.GetPackage(ctx, manifest.Name)
	if err != nil {
		return result.WithError(fmt.Errorf("cannot get installed package %q: %w", manifest.Name, err))
	}
	installedAssets := installedPackage.Assets()

	// No Elasticsearch asset is created when an Input package is installed through the API.
	// This would require to create a Agent policy and add that input package to the Agent policy.
	// As those input packages could have some required fields, it would also require to add
	// configuration files as in system tests to fill those fields.
	// In these tests, mainly it is required to test Kibana assets, therefore it is not added
	// support for Elasticsearch assets in input packages.
	// Related issue: https://github.com/elastic/elastic-package/issues/1623
	expectedAssets, err := packages.LoadPackageAssets(r.packageRootPath)
	if err != nil {
		return result.WithError(fmt.Errorf("could not load expected package assets: %w", err))
	}

	results := make([]testrunner.TestResult, 0, len(expectedAssets))
	for _, e := range expectedAssets {
		rc := testrunner.NewResultComposer(testrunner.TestResult{
			Name:       fmt.Sprintf("%s %s is loaded", e.Type, e.ID),
			Package:    r.testFolder.Package,
			DataStream: e.DataStream,
			TestType:   TestType,
		})

		var tr []testrunner.TestResult
		if !findActualAsset(installedAssets, e) {
			tr, _ = rc.WithError(testrunner.ErrTestCaseFailed{
				Reason:  "could not find expected asset",
				Details: fmt.Sprintf("could not find %s asset \"%s\". Assets loaded:\n%s", e.Type, e.ID, formatAssetsAsString(installedAssets)),
			})
		} else {
			tr, _ = rc.WithSuccess()
		}
		result := tr[0]
		if r.withCoverage && e.SourcePath != "" {
			result.Coverage, err = testrunner.GenerateBaseFileCoverageReport(rc.CoveragePackageName(), e.SourcePath, r.coverageType, true)
			if err != nil {
				tr, _ = rc.WithError(testrunner.ErrTestCaseFailed{
					Reason:  "could not generate test coverage",
					Details: fmt.Sprintf("could not generate test coverage for asset in %s: %v", e.SourcePath, err),
				})
				result = tr[0]
			}
		}

		results = append(results, result)
	}

	return results, nil
}