390 lines
11 KiB
Go
390 lines
11 KiB
Go
/*
|
|
Copyright 2021 The Flux authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package chart
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"testing"
|
|
|
|
. "github.com/onsi/gomega"
|
|
"github.com/otiai10/copy"
|
|
helmchart "helm.sh/helm/v3/pkg/chart"
|
|
"helm.sh/helm/v3/pkg/chartutil"
|
|
"helm.sh/helm/v3/pkg/repo"
|
|
|
|
"github.com/fluxcd/source-controller/internal/helm/chart/secureloader"
|
|
"github.com/fluxcd/source-controller/internal/helm/repository"
|
|
)
|
|
|
|
func TestLocalBuilder_Build(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
// Prepare chart repositories to be used for charts with remote dependency.
|
|
chartB, err := os.ReadFile("./../testdata/charts/helmchart-0.1.0.tgz")
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(chartB).ToNot(BeEmpty())
|
|
mockRepo := func() *repository.ChartRepository {
|
|
return &repository.ChartRepository{
|
|
Client: &mockGetter{
|
|
Response: chartB,
|
|
},
|
|
Index: &repo.IndexFile{
|
|
Entries: map[string]repo.ChartVersions{
|
|
"grafana": {
|
|
&repo.ChartVersion{
|
|
Metadata: &helmchart.Metadata{
|
|
Name: "grafana",
|
|
Version: "6.17.4",
|
|
},
|
|
URLs: []string{"https://example.com/grafana.tgz"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
RWMutex: &sync.RWMutex{},
|
|
}
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
reference Reference
|
|
buildOpts BuildOptions
|
|
valuesFiles []helmchart.File
|
|
repositories map[string]*repository.ChartRepository
|
|
dependentChartPaths []string
|
|
wantValues chartutil.Values
|
|
wantVersion string
|
|
wantPackaged bool
|
|
wantErr string
|
|
}{
|
|
{
|
|
name: "invalid reference",
|
|
reference: RemoteReference{},
|
|
wantErr: "expected local chart reference",
|
|
},
|
|
{
|
|
name: "invalid local reference - no path",
|
|
reference: LocalReference{},
|
|
wantErr: "no path set for local chart reference",
|
|
},
|
|
{
|
|
name: "invalid local reference - no file",
|
|
reference: LocalReference{WorkDir: "/tmp", Path: "non-existent-path.xyz"},
|
|
wantErr: "no such file or directory",
|
|
},
|
|
{
|
|
name: "invalid version metadata",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchart"},
|
|
buildOpts: BuildOptions{VersionMetadata: "^"},
|
|
wantErr: "Invalid Metadata string",
|
|
},
|
|
{
|
|
name: "with version metadata",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchart"},
|
|
buildOpts: BuildOptions{VersionMetadata: "foo"},
|
|
wantVersion: "0.1.0+foo",
|
|
wantPackaged: true,
|
|
},
|
|
{
|
|
name: "already packaged chart",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchart-0.1.0.tgz"},
|
|
wantVersion: "0.1.0",
|
|
wantPackaged: false,
|
|
},
|
|
{
|
|
name: "default values",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchart"},
|
|
wantValues: chartutil.Values{
|
|
"replicaCount": float64(1),
|
|
},
|
|
wantVersion: "0.1.0",
|
|
wantPackaged: true,
|
|
},
|
|
{
|
|
name: "with values files",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchart"},
|
|
buildOpts: BuildOptions{
|
|
ValuesFiles: []string{"custom-values1.yaml", "custom-values2.yaml"},
|
|
},
|
|
valuesFiles: []helmchart.File{
|
|
{
|
|
Name: "custom-values1.yaml",
|
|
Data: []byte(`replicaCount: 11
|
|
nameOverride: "foo-name-override"`),
|
|
},
|
|
{
|
|
Name: "custom-values2.yaml",
|
|
Data: []byte(`replicaCount: 20
|
|
fullnameOverride: "full-foo-name-override"`),
|
|
},
|
|
},
|
|
wantValues: chartutil.Values{
|
|
"replicaCount": float64(20),
|
|
"nameOverride": "foo-name-override",
|
|
"fullnameOverride": "full-foo-name-override",
|
|
},
|
|
wantVersion: "0.1.0",
|
|
wantPackaged: true,
|
|
},
|
|
{
|
|
name: "chart with dependencies",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchartwithdeps"},
|
|
repositories: map[string]*repository.ChartRepository{
|
|
"https://grafana.github.io/helm-charts/": mockRepo(),
|
|
},
|
|
dependentChartPaths: []string{"./../testdata/charts/helmchart"},
|
|
wantVersion: "0.1.0",
|
|
wantPackaged: true,
|
|
},
|
|
{
|
|
name: "v1 chart",
|
|
reference: LocalReference{Path: "./../testdata/charts/helmchart-v1"},
|
|
wantValues: chartutil.Values{
|
|
"replicaCount": float64(1),
|
|
},
|
|
wantVersion: "0.2.0",
|
|
wantPackaged: true,
|
|
},
|
|
{
|
|
name: "v1 chart with dependencies",
|
|
reference: LocalReference{Path: "../testdata/charts/helmchartwithdeps-v1"},
|
|
repositories: map[string]*repository.ChartRepository{
|
|
"https://grafana.github.io/helm-charts/": mockRepo(),
|
|
},
|
|
dependentChartPaths: []string{"../testdata/charts/helmchart-v1"},
|
|
wantVersion: "0.3.0",
|
|
wantPackaged: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
workDir := t.TempDir()
|
|
|
|
// Only if the reference is a LocalReference, set the WorkDir.
|
|
localRef, ok := tt.reference.(LocalReference)
|
|
if ok {
|
|
// If the source chart path is valid, copy it into the workdir
|
|
// and update the localRef.Path with the copied local chart
|
|
// path.
|
|
if localRef.Path != "" {
|
|
_, err := os.Lstat(localRef.Path)
|
|
if err == nil {
|
|
helmchartDir := filepath.Join(workDir, "testdata", "charts", filepath.Base(localRef.Path))
|
|
g.Expect(copy.Copy(localRef.Path, helmchartDir)).ToNot(HaveOccurred())
|
|
}
|
|
}
|
|
localRef.WorkDir = workDir
|
|
tt.reference = localRef
|
|
}
|
|
|
|
// Write value file in the base dir.
|
|
for _, f := range tt.valuesFiles {
|
|
vPath := filepath.Join(localRef.WorkDir, f.Name)
|
|
g.Expect(os.WriteFile(vPath, f.Data, 0o640)).ToNot(HaveOccurred())
|
|
}
|
|
|
|
// Write chart dependencies in the base dir.
|
|
for _, dcp := range tt.dependentChartPaths {
|
|
// Construct the chart path relative to the testdata chart.
|
|
helmchartDir := filepath.Join(workDir, "testdata", "charts", filepath.Base(dcp))
|
|
g.Expect(copy.Copy(dcp, helmchartDir)).ToNot(HaveOccurred())
|
|
}
|
|
|
|
// Target path with name similar to the workDir.
|
|
targetPath := workDir + ".tgz"
|
|
|
|
dm := NewDependencyManager(
|
|
WithRepositories(tt.repositories),
|
|
)
|
|
|
|
b := NewLocalBuilder(dm)
|
|
cb, err := b.Build(context.TODO(), tt.reference, targetPath, tt.buildOpts)
|
|
|
|
if tt.wantErr != "" {
|
|
g.Expect(err).To(HaveOccurred())
|
|
g.Expect(err.Error()).To(ContainSubstring(tt.wantErr))
|
|
g.Expect(cb).To(BeZero())
|
|
return
|
|
}
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cb.Packaged).To(Equal(tt.wantPackaged), "unexpected Build.Packaged value")
|
|
g.Expect(cb.Path).ToNot(BeEmpty(), "empty Build.Path")
|
|
|
|
// Load the resulting chart and verify the values.
|
|
resultChart, err := secureloader.LoadFile(cb.Path)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(resultChart.Metadata.Version).To(Equal(tt.wantVersion))
|
|
|
|
for k, v := range tt.wantValues {
|
|
g.Expect(v).To(Equal(resultChart.Values[k]))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLocalBuilder_Build_CachedChart(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
workDir := t.TempDir()
|
|
|
|
testChartPath := "./../testdata/charts/helmchart"
|
|
|
|
dm := NewDependencyManager()
|
|
b := NewLocalBuilder(dm)
|
|
|
|
tmpDir := t.TempDir()
|
|
|
|
// Copy the source chart into the workdir.
|
|
g.Expect(copy.Copy(testChartPath, filepath.Join(workDir, "testdata", "charts", filepath.Base("helmchart")))).ToNot(HaveOccurred())
|
|
|
|
reference := LocalReference{WorkDir: workDir, Path: testChartPath}
|
|
|
|
// Build first time.
|
|
targetPath := filepath.Join(tmpDir, "chart1.tgz")
|
|
buildOpts := BuildOptions{}
|
|
cb, err := b.Build(context.TODO(), reference, targetPath, buildOpts)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Set the result as the CachedChart for second build.
|
|
buildOpts.CachedChart = cb.Path
|
|
|
|
targetPath2 := filepath.Join(tmpDir, "chart2.tgz")
|
|
cb, err = b.Build(context.TODO(), reference, targetPath2, buildOpts)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cb.Path).To(Equal(targetPath))
|
|
|
|
// Rebuild with build option Force.
|
|
buildOpts.Force = true
|
|
cb, err = b.Build(context.TODO(), reference, targetPath2, buildOpts)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cb.Path).To(Equal(targetPath2))
|
|
}
|
|
|
|
func Test_mergeFileValues(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
files []*helmchart.File
|
|
paths []string
|
|
want map[string]interface{}
|
|
wantErr string
|
|
}{
|
|
{
|
|
name: "merges values from files",
|
|
files: []*helmchart.File{
|
|
{Name: "a.yaml", Data: []byte("a: b")},
|
|
{Name: "b.yaml", Data: []byte("b: c")},
|
|
{Name: "c.yaml", Data: []byte("b: d")},
|
|
},
|
|
paths: []string{"a.yaml", "b.yaml", "c.yaml"},
|
|
want: map[string]interface{}{
|
|
"a": "b",
|
|
"b": "d",
|
|
},
|
|
},
|
|
{
|
|
name: "illegal traverse",
|
|
paths: []string{"../../../traversing/illegally/a/p/a/b"},
|
|
wantErr: "no values file found at path '/traversing/illegally/a/p/a/b'",
|
|
},
|
|
{
|
|
name: "unmarshal error",
|
|
files: []*helmchart.File{
|
|
{Name: "invalid", Data: []byte("abcd")},
|
|
},
|
|
paths: []string{"invalid"},
|
|
wantErr: "unmarshaling values from 'invalid' failed",
|
|
},
|
|
{
|
|
name: "error on invalid path",
|
|
paths: []string{"a.yaml"},
|
|
wantErr: "no values file found at path '/a.yaml'",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
baseDir := t.TempDir()
|
|
|
|
for _, f := range tt.files {
|
|
g.Expect(os.WriteFile(filepath.Join(baseDir, f.Name), f.Data, 0o640)).To(Succeed())
|
|
}
|
|
|
|
got, err := mergeFileValues(baseDir, tt.paths)
|
|
if tt.wantErr != "" {
|
|
g.Expect(err).To(HaveOccurred())
|
|
g.Expect(err.Error()).To(ContainSubstring(tt.wantErr))
|
|
g.Expect(got).To(BeNil())
|
|
return
|
|
}
|
|
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(got).To(Equal(tt.want))
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_copyFileToPath(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
in string
|
|
wantErr string
|
|
}{
|
|
{
|
|
name: "copies input file",
|
|
in: "../testdata/local-index.yaml",
|
|
},
|
|
{
|
|
name: "invalid input file",
|
|
in: "../testdata/invalid.tgz",
|
|
wantErr: "failed to open file to copy from",
|
|
},
|
|
{
|
|
name: "invalid input directory",
|
|
in: "../testdata/charts",
|
|
wantErr: "failed to read from source during copy",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
out := tmpFile("copy-0.1.0", ".tgz")
|
|
defer os.RemoveAll(out)
|
|
err := copyFileToPath(tt.in, out)
|
|
if tt.wantErr != "" {
|
|
g.Expect(err).To(HaveOccurred())
|
|
g.Expect(err.Error()).To(ContainSubstring(tt.wantErr))
|
|
return
|
|
}
|
|
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(out).To(BeARegularFile())
|
|
f1, err := os.ReadFile(tt.in)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
f2, err := os.ReadFile(out)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(f2).To(Equal(f1))
|
|
})
|
|
}
|
|
}
|