Fix rendering of external groups in READMEs (#3088)

Swap source and build package roots when updating READMEs, so the
generator looks for fields in the source directory. In the build directory the
external fields have been already resolved and they don't include the
external key.

For legacy reasons, elastic-package only renders groups in READMEs
when they are external, so these fields were not being rendered.

Naming of related variables is reviewed for consistency, so it is harder to
misuse them.

Fix also related tests, and introduce new ones that reproduce the issue.

Author: jsoriano

cmd/benchmark.go

@@ -142,7 +142,7 @@ func pipelineCommandAction(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("locating repository root failed: %w", err)
 	}
 
-	packageRootPath, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -155,21 +155,21 @@ func pipelineCommandAction(cmd *cobra.Command, args []string) error {
 	if len(dataStreams) > 0 {
 		common.TrimStringSlice(dataStreams)
 
-		if err := validateDataStreamsFlag(packageRootPath, dataStreams); err != nil {
+		if err := validateDataStreamsFlag(packageRoot, dataStreams); err != nil {
 			return cobraext.FlagParsingError(err, cobraext.DataStreamsFlagName)
 		}
 	}
 
 	ctx, stop := signal.Enable(cmd.Context(), logger.Info)
 	defer stop()
 
-	benchFolders, err := pipeline.FindBenchmarkFolders(packageRootPath, dataStreams)
+	benchFolders, err := pipeline.FindBenchmarkFolders(packageRoot, dataStreams)
 	if err != nil {
 		return fmt.Errorf("unable to determine benchmark folder paths: %w", err)
 	}
 
 	if useTestSamples {
-		testFolders, err := testrunner.FindTestFolders(packageRootPath, dataStreams, testrunner.TestType(pipeline.BenchType))
+		testFolders, err := testrunner.FindTestFolders(packageRoot, dataStreams, testrunner.TestType(pipeline.BenchType))
 		if err != nil {
 			return fmt.Errorf("unable to determine test folder paths: %w", err)
 		}
@@ -202,7 +202,7 @@ func pipelineCommandAction(cmd *cobra.Command, args []string) error {
 		opts := pipeline.NewOptions(
 			pipeline.WithBenchmarkName(fmt.Sprintf("%s-%d", folder.Package, idx+1)),
 			pipeline.WithFolder(folder),
-			pipeline.WithPackageRootPath(packageRootPath),
+			pipeline.WithPackageRoot(packageRoot),
 			pipeline.WithESAPI(esClient.API),
 			pipeline.WithNumTopProcs(numTopProcs),
 			pipeline.WithFormat(reportFormat),
@@ -294,9 +294,9 @@ func rallyCommandAction(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("getting package name and version failed, expected format: <package>-<version>: %w", err)
 	}
 
-	var packageRootPath string
+	var packageRoot string
 	if len(packageName) == 0 {
-		packageRootPath, err = packages.FindPackageRoot()
+		packageRoot, err = packages.FindPackageRoot()
 		if err != nil {
 			return fmt.Errorf("locating package root failed: %w", err)
 		}
@@ -333,7 +333,7 @@ func rallyCommandAction(cmd *cobra.Command, args []string) error {
 		rally.WithVariant(variant),
 		rally.WithBenchmarkName(benchName),
 		rally.WithDataReindexing(dataReindex),
-		rally.WithPackageRootPath(packageRootPath),
+		rally.WithPackageRoot(packageRoot),
 		rally.WithESAPI(esClient.API),
 		rally.WithKibanaClient(kc),
 		rally.WithProfile(profile),
@@ -471,7 +471,7 @@ func streamCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.BenchStreamTimestampFieldFlagName)
 	}
 
-	packageRootPath, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -511,7 +511,7 @@ func streamCommandAction(cmd *cobra.Command, args []string) error {
 		stream.WithPeriodDuration(periodDuration),
 		stream.WithPerformCleanup(performCleanup),
 		stream.WithTimestampField(timestampField),
-		stream.WithPackageRootPath(packageRootPath),
+		stream.WithPackageRoot(packageRoot),
 		stream.WithESAPI(esClient.API),
 		stream.WithKibanaClient(kc),
 		stream.WithProfile(profile),
@@ -581,7 +581,7 @@ func systemCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.BenchReindexToMetricstoreFlagName)
 	}
 
-	packageRootPath, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -615,7 +615,7 @@ func systemCommandAction(cmd *cobra.Command, args []string) error {
 		system.WithDeferCleanup(deferCleanup),
 		system.WithMetricsInterval(metricsInterval),
 		system.WithDataReindexing(dataReindex),
-		system.WithPackageRootPath(packageRootPath),
+		system.WithPackageRoot(packageRoot),
 		system.WithESAPI(esClient.API),
 		system.WithKibanaClient(kc),
 		system.WithProfile(profile),

cmd/build.go

@@ -79,13 +79,13 @@ func buildCommandAction(cmd *cobra.Command, args []string) error {
 	logger.Debugf("Use build directory: %s", buildDir)
 
 	target, err := builder.BuildPackage(builder.BuildOptions{
-		PackageRootPath: packageRoot,
-		BuildDir:        buildDir,
-		CreateZip:       createZip,
-		SignPackage:     signPackage,
-		SkipValidation:  skipValidation,
-		RepositoryRoot:  repositoryRoot,
-		UpdateReadmes:   true,
+		PackageRoot:    packageRoot,
+		BuildDir:       buildDir,
+		CreateZip:      createZip,
+		SignPackage:    signPackage,
+		SkipValidation: skipValidation,
+		RepositoryRoot: repositoryRoot,
+		UpdateReadmes:  true,
 	})
 	if err != nil {
 		return fmt.Errorf("building package failed: %w", err)

cmd/install.go

@@ -45,7 +45,7 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return cobraext.FlagParsingError(err, cobraext.ZipPackageFilePathFlagName)
 	}
-	packageRootPath, err := cmd.Flags().GetString(cobraext.PackageRootFlagName)
+	packageRoot, err := cmd.Flags().GetString(cobraext.PackageRootFlagName)
 	if err != nil {
 		return cobraext.FlagParsingError(err, cobraext.PackageRootFlagName)
 	}
@@ -73,9 +73,9 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("could not create kibana client: %w", err)
 	}
 
-	if zipPathFile == "" && packageRootPath == "" {
+	if zipPathFile == "" && packageRoot == "" {
 		var err error
-		packageRootPath, err = packages.FindPackageRoot()
+		packageRoot, err = packages.FindPackageRoot()
 		if err != nil {
 			return fmt.Errorf("locating package root failed: %w", err)
 		}
@@ -87,11 +87,11 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 	}
 
 	installer, err := installer.NewForPackage(installer.Options{
-		Kibana:          kibanaClient,
-		PackageRootPath: packageRootPath,
-		SkipValidation:  skipValidation,
-		ZipPath:         zipPathFile,
-		RepositoryRoot:  repositoryRoot,
+		Kibana:         kibanaClient,
+		PackageRoot:    packageRoot,
+		SkipValidation: skipValidation,
+		ZipPath:        zipPathFile,
+		RepositoryRoot: repositoryRoot,
 	})
 	if err != nil {
 		return fmt.Errorf("package installation failed: %w", err)

cmd/lint.go

@@ -73,11 +73,11 @@ func lintCommandAction(cmd *cobra.Command, args []string) error {
 }
 
 func validateSourceCommandAction(cmd *cobra.Command, args []string) error {
-	packageRootPath, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
-	errs, skipped := validation.ValidateAndFilterFromPath(packageRootPath)
+	errs, skipped := validation.ValidateAndFilterFromPath(packageRoot)
 	if skipped != nil {
 		logger.Infof("Skipped errors: %v", skipped)
 	}

cmd/service.go

@@ -51,10 +51,10 @@ func upCommandAction(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
 
-	var dataStreamPath string
+	var dataStreamRoot string
 	dataStreamFlag, _ := cmd.Flags().GetString(cobraext.DataStreamFlagName)
 	if dataStreamFlag != "" {
-		dataStreamPath = filepath.Join(packageRoot, "data_stream", dataStreamFlag)
+		dataStreamRoot = filepath.Join(packageRoot, "data_stream", dataStreamFlag)
 	}
 
 	variantFlag, _ := cmd.Flags().GetString(cobraext.VariantFlagName)
@@ -75,13 +75,13 @@ func upCommandAction(cmd *cobra.Command, args []string) error {
 
 	_, serviceName := filepath.Split(packageRoot)
 	err = service.BootUp(cmd.Context(), service.Options{
-		Profile:            profile,
-		ServiceName:        serviceName,
-		PackageRootPath:    packageRoot,
-		DevDeployDir:       system.DevDeployDir,
-		DataStreamRootPath: dataStreamPath,
-		Variant:            variantFlag,
-		StackVersion:       stackVersion.Version(),
+		Profile:        profile,
+		ServiceName:    serviceName,
+		PackageRoot:    packageRoot,
+		DevDeployDir:   system.DevDeployDir,
+		DataStreamRoot: dataStreamRoot,
+		Variant:        variantFlag,
+		StackVersion:   stackVersion.Version(),
 	})
 	if err != nil {
 		return fmt.Errorf("up command failed: %w", err)

cmd/status.go

@@ -163,14 +163,14 @@ func getPackageStatus(packageName string, options registry.SearchOptions) (*stat
 	if packageName != "" {
 		return status.RemotePackage(packageName, options)
 	}
-	packageRootPath, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		if errors.Is(err, packages.ErrPackageRootNotFound) {
 			return nil, errors.New("no package specified and package root not found")
 		}
 		return nil, fmt.Errorf("locating package root failed: %w", err)
 	}
-	return status.LocalPackage(packageRootPath, options)
+	return status.LocalPackage(packageRoot, options)
 }
 
 func getServerlessManifests(packageName string, options registry.SearchOptions) ([]status.ServerlessManifests, error) {