mirror of https://github.com/helm/helm
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
272 lines
6.7 KiB
272 lines
6.7 KiB
/*
|
|
Copyright The Helm 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 action
|
|
|
|
import (
|
|
"archive/tar"
|
|
"compress/gzip"
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"path"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/Masterminds/semver/v3"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"helm.sh/helm/v4/internal/test/ensure"
|
|
)
|
|
|
|
func TestPassphraseFileFetcher(t *testing.T) {
|
|
secret := "secret"
|
|
directory := ensure.TempFile(t, "passphrase-file", []byte(secret))
|
|
testPkg := NewPackage()
|
|
|
|
fetcher, err := testPkg.passphraseFileFetcher(path.Join(directory, "passphrase-file"), nil)
|
|
if err != nil {
|
|
t.Fatal("Unable to create passphraseFileFetcher", err)
|
|
}
|
|
|
|
passphrase, err := fetcher("key")
|
|
if err != nil {
|
|
t.Fatal("Unable to fetch passphrase")
|
|
}
|
|
|
|
if string(passphrase) != secret {
|
|
t.Errorf("Expected %s got %s", secret, string(passphrase))
|
|
}
|
|
}
|
|
|
|
func TestPassphraseFileFetcher_WithLineBreak(t *testing.T) {
|
|
secret := "secret"
|
|
directory := ensure.TempFile(t, "passphrase-file", []byte(secret+"\n\n."))
|
|
testPkg := NewPackage()
|
|
|
|
fetcher, err := testPkg.passphraseFileFetcher(path.Join(directory, "passphrase-file"), nil)
|
|
if err != nil {
|
|
t.Fatal("Unable to create passphraseFileFetcher", err)
|
|
}
|
|
|
|
passphrase, err := fetcher("key")
|
|
if err != nil {
|
|
t.Fatal("Unable to fetch passphrase")
|
|
}
|
|
|
|
if string(passphrase) != secret {
|
|
t.Errorf("Expected %s got %s", secret, string(passphrase))
|
|
}
|
|
}
|
|
|
|
func TestPassphraseFileFetcher_WithInvalidStdin(t *testing.T) {
|
|
directory := t.TempDir()
|
|
testPkg := NewPackage()
|
|
|
|
stdin, err := os.CreateTemp(directory, "non-existing")
|
|
if err != nil {
|
|
t.Fatal("Unable to create test file", err)
|
|
}
|
|
|
|
if _, err := testPkg.passphraseFileFetcher("-", stdin); err == nil {
|
|
t.Error("Expected passphraseFileFetcher returning an error")
|
|
}
|
|
}
|
|
|
|
func TestPassphraseFileFetcher_WithStdinAndMultipleFetches(t *testing.T) {
|
|
testPkg := NewPackage()
|
|
stdin, w, err := os.Pipe()
|
|
if err != nil {
|
|
t.Fatal("Unable to create pipe", err)
|
|
}
|
|
|
|
passphrase := "secret-from-stdin"
|
|
|
|
go func() {
|
|
_, err := w.WriteString(passphrase + "\n")
|
|
assert.NoError(t, err)
|
|
}()
|
|
|
|
for range 4 {
|
|
fetcher, err := testPkg.passphraseFileFetcher("-", stdin)
|
|
if err != nil {
|
|
t.Errorf("Expected passphraseFileFetcher to not return an error, but got %v", err)
|
|
}
|
|
|
|
pass, err := fetcher("key")
|
|
if err != nil {
|
|
t.Errorf("Expected passphraseFileFetcher invocation to succeed, failed with %v", err)
|
|
}
|
|
|
|
if string(pass) != string(passphrase) {
|
|
t.Errorf("Expected multiple passphrase fetch to return %q, got %q", passphrase, pass)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestValidateVersion(t *testing.T) {
|
|
type args struct {
|
|
ver string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
wantErr error
|
|
}{
|
|
{
|
|
"normal semver version",
|
|
args{
|
|
ver: "1.1.3-23658",
|
|
},
|
|
nil,
|
|
},
|
|
{
|
|
"Pre version number starting with 0",
|
|
args{
|
|
ver: "1.1.3-023658",
|
|
},
|
|
semver.ErrSegmentStartsZero,
|
|
},
|
|
{
|
|
"Invalid version number",
|
|
args{
|
|
ver: "1.1.3.sd.023658",
|
|
},
|
|
semver.ErrInvalidSemVer,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if err := validateVersion(tt.args.ver); err != nil {
|
|
if !errors.Is(err, tt.wantErr) {
|
|
t.Errorf("Expected {%v}, got {%v}", tt.wantErr, err)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRun_ErrorPath(t *testing.T) {
|
|
client := NewPackage()
|
|
_, err := client.Run("err-path", nil)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRun(t *testing.T) {
|
|
chartPath := "testdata/charts/chart-with-schema"
|
|
client := NewPackage()
|
|
filename, err := client.Run(chartPath, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "empty-0.1.0.tgz", filename)
|
|
require.NoError(t, os.Remove(filename))
|
|
}
|
|
|
|
func TestRunWithSourceDateEpoch(t *testing.T) {
|
|
chartPath := "testdata/charts/chart-with-schema"
|
|
// Use UTC so the comparison with tar header ModTime (always UTC) is straightforward.
|
|
epoch := time.Unix(1700000000, 0).UTC()
|
|
|
|
client := NewPackage()
|
|
client.SourceDateEpoch = &epoch
|
|
|
|
filename, err := client.Run(chartPath, nil)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() { os.Remove(filename) })
|
|
|
|
f, err := os.Open(filename)
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
// Check gzip header ModTime: helm leaves it at zero (deterministic by design).
|
|
gr, err := gzip.NewReader(f)
|
|
require.NoError(t, err)
|
|
require.True(t, gr.ModTime.IsZero(), "gzip header ModTime should be zero")
|
|
defer gr.Close()
|
|
|
|
// Use Equal() rather than require.Equal so that timezone differences between
|
|
// the stored epoch (UTC) and the value tar.Reader reconstructs do not cause
|
|
// a false failure on non-UTC machines.
|
|
tr := tar.NewReader(gr)
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
require.NoError(t, err)
|
|
require.True(t, epoch.Equal(hdr.ModTime), "entry %s: got ModTime %v, want %v", hdr.Name, hdr.ModTime, epoch)
|
|
}
|
|
}
|
|
|
|
func TestRunWithSourceDateEpochReproducible(t *testing.T) {
|
|
chartPath := "testdata/charts/chart-with-schema"
|
|
epoch := time.Unix(1700000000, 0)
|
|
|
|
build := func() []byte {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
client := NewPackage()
|
|
client.SourceDateEpoch = &epoch
|
|
client.Destination = dir
|
|
filename, err := client.Run(chartPath, nil)
|
|
require.NoError(t, err)
|
|
data, err := os.ReadFile(filename)
|
|
require.NoError(t, err)
|
|
return data
|
|
}
|
|
|
|
first := build()
|
|
second := build()
|
|
require.Equal(t, first, second, "two builds with the same SOURCE_DATE_EPOCH must be byte-identical")
|
|
}
|
|
|
|
func TestRunWithSourceDateEpochStampsLockGenerated(t *testing.T) {
|
|
chartPath := "testdata/charts/chart-with-lock"
|
|
epoch := time.Unix(1700000000, 0).UTC()
|
|
|
|
client := NewPackage()
|
|
client.SourceDateEpoch = &epoch
|
|
|
|
filename, err := client.Run(chartPath, nil)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() { os.Remove(filename) })
|
|
|
|
f, err := os.Open(filename)
|
|
require.NoError(t, err)
|
|
defer f.Close()
|
|
|
|
gr, err := gzip.NewReader(f)
|
|
require.NoError(t, err)
|
|
defer gr.Close()
|
|
|
|
found := false
|
|
tr := tar.NewReader(gr)
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
require.NoError(t, err)
|
|
if path.Base(hdr.Name) == "Chart.lock" {
|
|
found = true
|
|
// Without stamping Lock.Generated, this entry would keep the
|
|
// fixture's original 2016 timestamp instead of the epoch.
|
|
require.True(t, epoch.Equal(hdr.ModTime), "Chart.lock entry: got ModTime %v, want %v", hdr.ModTime, epoch)
|
|
}
|
|
}
|
|
require.True(t, found, "expected archive to contain a Chart.lock entry")
|
|
}
|