Refactoring: merging packages API into Kibana client

Author: ycombinator

internal/kibana/client.go

@@ -53,6 +53,10 @@ func (c *Client) put(resourcePath string, body []byte) (int, []byte, error) {
 	return c.sendRequest(http.MethodPut, resourcePath, body)
 }
 
+func (c *Client) delete(resourcePath string) (int, []byte, error) {
+	return c.sendRequest(http.MethodDelete, resourcePath, nil)
+}
+
 func (c *Client) sendRequest(method, resourcePath string, body []byte) (int, []byte, error) {
 	reqBody := bytes.NewReader(body)
 	base, err := url.Parse(c.host)

internal/kibana/ingestmanager/client_packages.go renamed to internal/kibana/packages.go

@@ -2,7 +2,7 @@
 // or more contributor license agreements. Licensed under the Elastic License;
 // you may not use this file except in compliance with the Elastic License.
 
-package ingestmanager
+package kibana
 
 import (
 	"encoding/json"
@@ -15,21 +15,27 @@ import (
 
 // InstallPackage installs the given package in Fleet.
 func (c *Client) InstallPackage(pkg packages.PackageManifest) ([]packages.Asset, error) {
-	return managePackage(pkg, "install", c.post)
+	path := fmt.Sprintf("epm/packages/%s-%s", pkg.Name, pkg.Version)
+	statusCode, respBody, err := c.post(path, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not install package")
+	}
+
+	return processResults("install", statusCode, respBody)
 }
 
 // RemovePackage removes the given package from Fleet.
 func (c *Client) RemovePackage(pkg packages.PackageManifest) ([]packages.Asset, error) {
-	return managePackage(pkg, "remove", c.delete)
-}
-
-func managePackage(pkg packages.PackageManifest, action string, actionFunc func(string, []byte) (int, []byte, error)) ([]packages.Asset, error) {
 	path := fmt.Sprintf("epm/packages/%s-%s", pkg.Name, pkg.Version)
-	statusCode, respBody, err := actionFunc(path, nil)
+	statusCode, respBody, err := c.delete(path)
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not %s package", action)
+		return nil, errors.Wrap(err, "could not delete package")
 	}
 
+	return processResults("remove", statusCode, respBody)
+}
+
+func processResults(action string, statusCode int, respBody []byte) ([]packages.Asset, error) {
 	if statusCode != 200 {
 		return nil, fmt.Errorf("could not %s package; API status code = %d; response body = %s", action, statusCode, respBody)
 	}

internal/testrunner/runners/asset/runner.go

@@ -12,7 +12,7 @@ import (
 	es "github.com/elastic/go-elasticsearch/v7"
 	"github.com/pkg/errors"
 
-	"github.com/elastic/elastic-package/internal/kibana/ingestmanager"
+	"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/stack"
@@ -98,19 +98,19 @@ func (r *runner) run() ([]testrunner.TestResult, error) {
 	}
 
 	// Install package
-	im, err := ingestmanager.NewClient(r.stackSettings.Kibana.Host, r.stackSettings.Elasticsearch.Username, r.stackSettings.Elasticsearch.Password)
+	kib, err := kibana.NewClient()
 	if err != nil {
-		return resultsWith(result, errors.Wrap(err, "could not create ingest manager client"))
+		return resultsWith(result, errors.Wrap(err, "could not create kibana client"))
 	}
 
 	logger.Debug("installing package...")
-	actualAssets, err := im.InstallPackage(*pkgManifest)
+	actualAssets, err := kib.InstallPackage(*pkgManifest)
 	if err != nil {
 		return resultsWith(result, errors.Wrap(err, "could not install package"))
 	}
 	r.removePackageHandler = func() error {
 		logger.Debug("removing package...")
-		if _, err := im.RemovePackage(*pkgManifest); err != nil {
+		if _, err := kib.RemovePackage(*pkgManifest); err != nil {
 			return errors.Wrap(err, "error cleaning up package")
 		}
 		return nil

internal/testrunner/runners/system/runner.go

@@ -294,7 +294,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext
 	// Configure package (single data stream) via Ingest Manager APIs.
 	kib, err := kibana.NewClient()
 	if err != nil {
-		return result.withError(errors.Wrap(err, "could not create ingest manager client"))
+		return result.withError(errors.Wrap(err, "could not create kibana client"))
 	}
 
 	logger.Debug("creating test policy...")