Skip to content

Commit 06e1d5b

Browse files
ycombinatorycombinator
committed
Adding assertions
1 parent b23d50b commit 06e1d5b

File tree

3 files changed

+168
-73
lines changed

3 files changed

+168
-73
lines changed

‎internal/kibana/ingestmanager/client_packages.go

Lines changed: 4 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -9,22 +9,17 @@ import (
99
"github.com/elastic/elastic-package/internal/packages"
1010
)
1111

12-
type Asset struct {
13-
ID string `json:"id"`
14-
Type string `json:"type"`
15-
}
16-
1712
// InstallPackage installs the given package in Fleet.
18-
func (c *Client) InstallPackage(pkg packages.PackageManifest) ([]Asset, error) {
13+
func (c *Client) InstallPackage(pkg packages.PackageManifest) ([]packages.Asset, error) {
1914
return managePackage(pkg, "install", c.post)
2015
}
2116

2217
// RemovePackage removes the given package from Fleet.
23-
func (c *Client) RemovePackage(pkg packages.PackageManifest) ([]Asset, error) {
18+
func (c *Client) RemovePackage(pkg packages.PackageManifest) ([]packages.Asset, error) {
2419
return managePackage(pkg, "remove", c.delete)
2520
}
2621

27-
func managePackage(pkg packages.PackageManifest, action string, actionFunc func(string, []byte) (int, []byte, error)) ([]Asset, error) {
22+
func managePackage(pkg packages.PackageManifest, action string, actionFunc func(string, []byte) (int, []byte, error)) ([]packages.Asset, error) {
2823
path := fmt.Sprintf("epm/packages/%s-%s", pkg.Name, pkg.Version)
2924
statusCode, respBody, err := actionFunc(path, nil)
3025
if err != nil {
@@ -36,7 +31,7 @@ func managePackage(pkg packages.PackageManifest, action string, actionFunc func(
3631
}
3732

3833
var resp struct {
39-
Assets []Asset `json:"response"`
34+
Assets []packages.Asset `json:"response"`
4035
}
4136

4237
if err := json.Unmarshal(respBody, &resp); err != nil {

‎internal/packages/assets.go

Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1 +1,149 @@
11
package packages
2+
3+
import (
4+
"fmt"
5+
"io/ioutil"
6+
"os"
7+
"path/filepath"
8+
"strings"
9+
10+
"github.com/pkg/errors"
11+
)
12+
13+
type AssetType string
14+
15+
const (
16+
AssetTypeElasticsearchIndexTemplate AssetType = "index_template"
17+
AssetTypeElasticsearchIngestPipeline AssetType = "ingest_pipeline"
18+
19+
AssetTypeKibanaSavedSearch AssetType = "search"
20+
AssetTypeKibanaVisualization AssetType = "visualization"
21+
AssetTypeKibanaDashboard AssetType = "dashboard"
22+
AssetTypeKibanaMap AssetType = "map"
23+
)
24+
25+
type Asset struct {
26+
ID string `json:"id"`
27+
Type AssetType `json:"type"`
28+
}
29+
30+
func LoadPackageAssets(pkgRootPath string) ([]Asset, error) {
31+
assets, err := loadKibanaAssets(pkgRootPath)
32+
if err != nil {
33+
return nil, errors.Wrap(err, "could not load kibana assets")
34+
}
35+
36+
a, err := loadElasticsearchAssets(pkgRootPath)
37+
if err != nil {
38+
return a, errors.Wrap(err, "could not load elasticsearch assets")
39+
}
40+
assets = append(assets, a...)
41+
42+
return a, nil
43+
}
44+
45+
func loadKibanaAssets(pkgRootPath string) ([]Asset, error) {
46+
kibanaAssetsFolderPath := filepath.Join(pkgRootPath, "kibana")
47+
48+
assets, err := loadFileBasedAssets(kibanaAssetsFolderPath, AssetTypeKibanaDashboard)
49+
if err != nil {
50+
return nil, errors.Wrap(err, "could not load kibana dashboard assets")
51+
}
52+
53+
a, err := loadFileBasedAssets(kibanaAssetsFolderPath, AssetTypeKibanaVisualization)
54+
if err != nil {
55+
return nil, errors.Wrap(err, "could not load kibana visualization assets")
56+
}
57+
assets = append(assets, a...)
58+
59+
a, err = loadFileBasedAssets(kibanaAssetsFolderPath, AssetTypeKibanaSavedSearch)
60+
if err != nil {
61+
return nil, errors.Wrap(err, "could not load kibana saved search assets")
62+
}
63+
assets = append(assets, a...)
64+
65+
a, err = loadFileBasedAssets(kibanaAssetsFolderPath, AssetTypeKibanaMap)
66+
if err != nil {
67+
return nil, errors.Wrap(err, "could not load kibana map assets")
68+
}
69+
assets = append(assets, a...)
70+
71+
return assets, nil
72+
}
73+
74+
func loadElasticsearchAssets(pkgRootPath string) ([]Asset, error) {
75+
packageManifestPath := filepath.Join(pkgRootPath, PackageManifestFile)
76+
pkgManifest, err := ReadPackageManifest(packageManifestPath)
77+
if err != nil {
78+
return nil, errors.Wrap(err, "reading package manifest file failed")
79+
}
80+
81+
dataStreamManifestPaths, err := filepath.Glob(filepath.Join(pkgRootPath, "data_stream", "*", DataStreamManifestFile))
82+
if err != nil {
83+
return nil, errors.Wrap(err, "could not read data stream manifest file paths")
84+
}
85+
86+
assets := make([]Asset, 0)
87+
for _, dsManifestPath := range dataStreamManifestPaths {
88+
dsManifest, err := ReadDataStreamManifest(dsManifestPath)
89+
if err != nil {
90+
return nil, errors.Wrap(err, "reading data stream manifest failed")
91+
}
92+
93+
indexTemplateName := fmt.Sprintf("%s-%s.%s", dsManifest.Type, pkgManifest.Name, dsManifest.Name)
94+
asset := Asset{
95+
ID: indexTemplateName,
96+
Type: AssetTypeElasticsearchIndexTemplate,
97+
}
98+
assets = append(assets, asset)
99+
100+
if dsManifest.Type == "log" {
101+
ingestPipelineName := dsManifest.GetPipelineNameOrDefault()
102+
if ingestPipelineName == defaultPipelineName {
103+
ingestPipelineName = fmt.Sprintf("%s-%s.%s-%s", dsManifest.Type, pkgManifest.Name, dsManifest.Name, pkgManifest.Version)
104+
}
105+
asset = Asset{
106+
ID: ingestPipelineName,
107+
Type: AssetTypeElasticsearchIngestPipeline,
108+
}
109+
assets = append(assets, asset)
110+
}
111+
}
112+
113+
return assets, nil
114+
}
115+
116+
func loadFileBasedAssets(kibanaAssetsFolderPath string, assetType AssetType) ([]Asset, error) {
117+
assetsFolderPath := filepath.Join(kibanaAssetsFolderPath, string(assetType))
118+
_, err := os.Stat(assetsFolderPath)
119+
if err != nil && os.IsNotExist(err) {
120+
// No assets folder defined; nothing to load
121+
return nil, nil
122+
}
123+
if err != nil {
124+
return nil, errors.Wrapf(err, "error finding kibana %s assets folder", assetType)
125+
}
126+
127+
files, err := ioutil.ReadDir(assetsFolderPath)
128+
if err != nil {
129+
return nil, errors.Wrapf(err, "could not read %s files", assetType)
130+
}
131+
132+
assets := make([]Asset, 0)
133+
for _, f := range files {
134+
if f.IsDir() {
135+
continue
136+
}
137+
138+
name := f.Name()
139+
id := strings.TrimSuffix(name, ".json")
140+
141+
asset := Asset{
142+
ID: id,
143+
Type: assetType,
144+
}
145+
assets = append(assets, asset)
146+
}
147+
148+
return assets, nil
149+
}

‎internal/testrunner/runners/asset/runner.go

Lines changed: 16 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ func (r *runner) run() ([]testrunner.TestResult, error) {
9090
}
9191

9292
logger.Debug("installing package...")
93-
assets, err := im.InstallPackage(*pkgManifest)
93+
actualAssets, err := im.InstallPackage(*pkgManifest)
9494
if err != nil {
9595
return resultsWith(result, errors.Wrap(err, "could not install package"))
9696
}
@@ -101,11 +101,17 @@ func (r *runner) run() ([]testrunner.TestResult, error) {
101101
}
102102
}
103103

104-
// TODO: Verify that data stream assets are loaded as expected
105-
fmt.Println(assets)
106-
// index templates
107-
// kibana saved objects
104+
// TODO: Verify that package assets are loaded as expected
105+
expectedAssets, err := packages.LoadPackageAssets(r.packageRootPath)
106+
if err != nil {
107+
return resultsWith(result, errors.Wrap(err, "could not load expected package assets"))
108+
}
108109

110+
for _, e := range expectedAssets {
111+
if !findActualAsset(actualAssets, e) {
112+
return resultsWith(result, fmt.Errorf("could not find expected asset with ID = %s and type = %s", e.ID, e.Type))
113+
}
114+
}
109115
return resultsWith(result, nil)
110116
}
111117

@@ -123,66 +129,12 @@ func (r *runner) tearDown() {
123129
}
124130
}
125131

126-
func createPackageDatastream(
127-
p ingestmanager.Policy,
128-
pkg packages.PackageManifest,
129-
ds packages.DataStreamManifest,
130-
) ingestmanager.PackageDataStream {
131-
streamInput := ds.Streams[0].Input
132-
r := ingestmanager.PackageDataStream{
133-
Name: fmt.Sprintf("%s-%s", pkg.Name, ds.Name),
134-
Namespace: "ep",
135-
PolicyID: p.ID,
136-
Enabled: true,
137-
}
138-
139-
r.Package.Name = pkg.Name
140-
r.Package.Title = pkg.Title
141-
r.Package.Version = pkg.Version
142-
143-
r.Inputs = []ingestmanager.Input{
144-
{
145-
Type: streamInput,
146-
Enabled: true,
147-
},
148-
}
149-
150-
streams := []ingestmanager.Stream{
151-
{
152-
ID: fmt.Sprintf("%s-%s.%s", streamInput, pkg.Name, ds.Name),
153-
Enabled: true,
154-
DataStream: ingestmanager.DataStream{
155-
Type: ds.Type,
156-
Dataset: fmt.Sprintf("%s.%s", pkg.Name, ds.Name),
157-
},
158-
},
159-
}
160-
161-
// Add dataStream-level vars
162-
dsVars := ingestmanager.Vars{}
163-
for _, dsVar := range ds.Streams[0].Vars {
164-
val := dsVar.Default
165-
dsVars[dsVar.Name] = ingestmanager.Var{
166-
Type: dsVar.Type,
167-
Value: val,
168-
}
169-
}
170-
streams[0].Vars = dsVars
171-
r.Inputs[0].Streams = streams
172-
173-
// Add package-level vars
174-
pkgVars := ingestmanager.Vars{}
175-
input := pkg.PolicyTemplates[0].FindInputByType(streamInput)
176-
if input != nil {
177-
for _, pkgVar := range input.Vars {
178-
val := pkgVar.Default
179-
pkgVars[pkgVar.Name] = ingestmanager.Var{
180-
Type: pkgVar.Type,
181-
Value: val,
182-
}
132+
func findActualAsset(actualAssets []packages.Asset, expectedAsset packages.Asset) bool {
133+
for _, a := range actualAssets {
134+
if a.Type == expectedAsset.Type && a.ID == expectedAsset.ID {
135+
return true
183136
}
184137
}
185-
r.Inputs[0].Vars = pkgVars
186138

187-
return r
139+
return false
188140
}

0 commit comments

Comments
 (0)