Explicitly install packages on system tests (#1281)

This will allow to earlier detect if one is not testing the version they
currently have in the working copy.

From 8.7.0 version, it builds and install the zip package. On older
versions it installs whatever is in the configured package registry. In
that case, if the version of the package is not available in the
repository, test execution will fail.

Author: jsoriano

cmd/install.go

@@ -5,18 +5,11 @@
 package cmd
 
 import (
-	"fmt"
-
-	"github.com/Masterminds/semver/v3"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 
-	"github.com/elastic/package-spec/v2/code/go/pkg/validator"
-
-	"github.com/elastic/elastic-package/internal/builder"
 	"github.com/elastic/elastic-package/internal/cobraext"
 	"github.com/elastic/elastic-package/internal/kibana"
-	"github.com/elastic/elastic-package/internal/logger"
 	"github.com/elastic/elastic-package/internal/packages"
 	"github.com/elastic/elastic-package/internal/packages/installer"
 )
@@ -25,8 +18,6 @@ const installLongDescription = `Use this command to install the package in Kiban
 
 The command uses Kibana API to install the package in Kibana. The package must be exposed via the Package Registry or built locally in zip format so they can be installed using --zip parameter. Zip packages can be installed directly in Kibana >= 8.7.0. More details in this [HOWTO guide](https://github.com/elastic/elastic-package/blob/main/docs/howto/install_package.md).`
 
-var semver8_7_0 = semver.MustParse("8.7.0")
-
 func setupInstallCommand() *cobraext.Command {
 	cmd := &cobra.Command{
 		Use:   "install",
@@ -60,23 +51,27 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return errors.Wrap(err, "could not create kibana client")
 	}
-	kibanaVersion, err := kibanaClient.Version()
-	if err != nil {
-		return err
-	}
-	v, err := semver.NewVersion(kibanaVersion.Number)
-	if err != nil {
-		return fmt.Errorf("invalid Kibana version")
-	}
 
-	installer, err := newInstaller(zipPathFile, packageRootPath, v, skipValidation)
-	if err != nil {
-		return err
+	if zipPathFile == "" && packageRootPath == "" {
+		var found bool
+		var err error
+		packageRootPath, found, err = packages.FindPackageRoot()
+		if !found {
+			return errors.New("package root not found")
+		}
+		if err != nil {
+			return errors.Wrap(err, "locating package root failed")
+		}
 	}
 
-	manifest, err := installer.manifest()
+	installer, err := installer.NewForPackage(installer.Options{
+		Kibana:         kibanaClient,
+		RootPath:       packageRootPath,
+		SkipValidation: skipValidation,
+		ZipPath:        zipPathFile,
+	})
 	if err != nil {
-		return err
+		return errors.Wrap(err, "package installation failed")
 	}
 
 	// Check conditions
@@ -85,6 +80,11 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 		return errors.Wrap(err, "can't process check-condition flag")
 	}
 	if len(keyValuePairs) > 0 {
+		manifest, err := installer.Manifest()
+		if err != nil {
+			return err
+		}
+
 		cmd.Println("Check conditions for package")
 		err = packages.CheckConditions(*manifest, keyValuePairs)
 		if err != nil {
@@ -95,116 +95,6 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 		return nil
 	}
 
-	return installer.install(cmd, manifest.Name, manifest.Version)
-}
-
-type packageInstaller interface {
-	manifest() (*packages.PackageManifest, error)
-	install(cmd *cobra.Command, name, version string) error
-}
-
-func newInstaller(zipPath, packageRootPath string, kibanaVersion *semver.Version, skipValidation bool) (packageInstaller, error) {
-	if zipPath != "" {
-		if kibanaVersion.LessThan(semver8_7_0) {
-			return nil, fmt.Errorf("not supported uploading zip packages in Kibana %s", kibanaVersion)
-		}
-		if !skipValidation {
-			logger.Debugf("Validating built .zip package (path: %s)", zipPath)
-			err := validator.ValidateFromZip(zipPath)
-			if err != nil {
-				return nil, errors.Wrapf(err, "invalid content found in built zip package")
-			}
-		}
-		logger.Debug("Skip validation of the built .zip package")
-		return zipPackage{zipPath: zipPath}, nil
-	}
-	if packageRootPath == "" {
-		var found bool
-		var err error
-		packageRootPath, found, err = packages.FindPackageRoot()
-		if !found {
-			return nil, errors.New("package root not found")
-		}
-		if err != nil {
-			return nil, errors.Wrap(err, "locating package root failed")
-		}
-	}
-
-	if kibanaVersion.LessThan(semver8_7_0) {
-		return localPackage{rootPath: packageRootPath}, nil
-	}
-
-	// build and install
-	target, err := builder.BuildPackage(builder.BuildOptions{
-		PackageRoot:    packageRootPath,
-		CreateZip:      true,
-		SignPackage:    false,
-		SkipValidation: skipValidation,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "building package failed")
-	}
-	logger.Infof("Built package path: %s", target)
-
-	return zipPackage{zipPath: target}, nil
-}
-
-type localPackage struct {
-	rootPath string
-}
-
-func (l localPackage) manifest() (*packages.PackageManifest, error) {
-	logger.Debugf("Reading package manifest from %s", l.rootPath)
-	manifest, err := packages.ReadPackageManifestFromPackageRoot(l.rootPath)
-	if err != nil {
-		return nil, errors.Wrapf(err, "reading package manifest failed (path: %s)", l.rootPath)
-	}
-	return manifest, nil
-}
-
-func (l localPackage) install(cmd *cobra.Command, name, version string) error {
-	aInstaller, err := installer.CreateForManifest(name, version)
-	if err != nil {
-		return errors.Wrap(err, "can't create the package installer")
-	}
-
-	cmd.Println("Install the package")
-	return installPackage(cmd, aInstaller)
-}
-
-type zipPackage struct {
-	zipPath string
-}
-
-func (z zipPackage) manifest() (*packages.PackageManifest, error) {
-	logger.Debugf("Reading package manifest from %s", z.zipPath)
-	manifest, err := packages.ReadPackageManifestFromZipPackage(z.zipPath)
-	if err != nil {
-		return nil, errors.Wrapf(err, "reading package manifest failed (path: %s)", z.zipPath)
-	}
-	return manifest, nil
-}
-
-func (z zipPackage) install(cmd *cobra.Command, name, version string) error {
-	aInstaller, err := installer.CreateForZip(z.zipPath, name, version)
-	if err != nil {
-		return errors.Wrap(err, "can't create the package installer")
-	}
-
-	cmd.Printf("Install zip package: %s\n", z.zipPath)
-	return installPackage(cmd, aInstaller)
-}
-
-func installPackage(cmd *cobra.Command, packageInstaller installer.Installer) error {
-	installedPackage, err := packageInstaller.Install()
-	if err != nil {
-		return errors.Wrap(err, "can't install the package")
-	}
-
-	cmd.Println("Installed assets:")
-	for _, asset := range installedPackage.Assets {
-		cmd.Printf("- %s (type: %s)\n", asset.ID, asset.Type)
-	}
-	cmd.Println("Done")
-	return nil
+	_, err = installer.Install()
+	return err
 }

cmd/uninstall.go

@@ -9,6 +9,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/elastic/elastic-package/internal/cobraext"
+	"github.com/elastic/elastic-package/internal/kibana"
 	"github.com/elastic/elastic-package/internal/packages"
 	"github.com/elastic/elastic-package/internal/packages/installer"
 )
@@ -37,12 +38,11 @@ func uninstallCommandAction(cmd *cobra.Command, args []string) error {
 		return errors.Wrap(err, "locating package root failed")
 	}
 
-	m, err := packages.ReadPackageManifestFromPackageRoot(packageRootPath)
+	kibanaClient, err := kibana.NewClient()
 	if err != nil {
-		return errors.Wrapf(err, "reading package manifest failed (path: %s)", packageRootPath)
+		return errors.Wrap(err, "could not create kibana client")
 	}
-
-	packageInstaller, err := installer.CreateForManifest(m.Name, m.Version)
+	packageInstaller, err := installer.CreateForManifest(kibanaClient, packageRootPath)
 	if err != nil {
 		return errors.Wrap(err, "can't create the package installer")
 	}

internal/packages/installer/factory.go

@@ -0,0 +1,99 @@
+// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+// or more contributor license agreements. Licensed under the Elastic License;
+// you may not use this file except in compliance with the Elastic License.
+
+package installer
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/Masterminds/semver/v3"
+
+	"github.com/elastic/package-spec/v2/code/go/pkg/validator"
+
+	"github.com/elastic/elastic-package/internal/builder"
+	"github.com/elastic/elastic-package/internal/kibana"
+	"github.com/elastic/elastic-package/internal/logger"
+	"github.com/elastic/elastic-package/internal/packages"
+)
+
+var semver8_7_0 = semver.MustParse("8.7.0")
+
+// Installer is responsible for installation/uninstallation of the package.
+type Installer interface {
+	Install() (*InstalledPackage, error)
+	Uninstall() error
+
+	Manifest() (*packages.PackageManifest, error)
+}
+
+// Options are the parameters used to build an installer.
+type Options struct {
+	Kibana         *kibana.Client
+	RootPath       string
+	ZipPath        string
+	SkipValidation bool
+}
+
+// NewForPackage creates a new installer for a package, given its root path, or its prebuilt zip.
+// If a zip path is given, this package is validated and installed as is. This fails on versions
+// of Kibana lower than 8.7.0.
+// When no zip is given, package is built as zip and installed if version is at least 8.7.0,
+// or from the package registry otherwise.
+func NewForPackage(options Options) (Installer, error) {
+	if options.Kibana == nil {
+		return nil, errors.New("missing kibana client")
+	}
+	if options.RootPath == "" && options.ZipPath == "" {
+		return nil, errors.New("missing package root path or pre-built zip package")
+	}
+
+	version, err := kibanaVersion(options.Kibana)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get kibana version: %w", err)
+	}
+
+	supportsZip := !version.LessThan(semver8_7_0)
+	if options.ZipPath != "" {
+		if !supportsZip {
+			return nil, fmt.Errorf("not supported uploading zip packages in Kibana %s (%s required)", version, semver8_7_0)
+		}
+		if !options.SkipValidation {
+			logger.Debugf("Validating built .zip package (path: %s)", options.ZipPath)
+			err := validator.ValidateFromZip(options.ZipPath)
+			if err != nil {
+				return nil, fmt.Errorf("invalid content found in built zip package: %w", err)
+			}
+		}
+		logger.Debug("Skip validation of the built .zip package")
+		return CreateForZip(options.Kibana, options.ZipPath)
+	}
+
+	target, err := builder.BuildPackage(builder.BuildOptions{
+		PackageRoot:    options.RootPath,
+		CreateZip:      supportsZip,
+		SignPackage:    false,
+		SkipValidation: options.SkipValidation,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to build package: %v", err)
+	}
+
+	if supportsZip {
+		return CreateForZip(options.Kibana, target)
+	}
+	return CreateForManifest(options.Kibana, target)
+}
+
+func kibanaVersion(kibana *kibana.Client) (*semver.Version, error) {
+	version, err := kibana.Version()
+	if err != nil {
+		return nil, err
+	}
+	sv, err := semver.NewVersion(version.Number)
+	if err != nil {
+		return nil, fmt.Errorf("invalid kibana version: %w", err)
+	}
+	return sv, nil
+}