mirror of
https://github.com/GoogleContainerTools/kaniko
synced 2026-10-19 02:33:44 +02:00
Andreas Fleig
0d925dd651
If a non-empty directory gets replaced with something other than a directory (e.g. file or symlink), the files in that directory also get deleted. However, there should not be any whiteout files for them in the layer. If there were, the resulting tar file would not be extractable. Fixes #2308
695 lines
18 KiB
Go
695 lines
18 KiB
Go
/*
|
|
Copyright 2018 Google LLC
|
|
|
|
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 snapshot
|
|
|
|
import (
|
|
"archive/tar"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/GoogleContainerTools/kaniko/pkg/config"
|
|
"github.com/GoogleContainerTools/kaniko/pkg/util"
|
|
"github.com/GoogleContainerTools/kaniko/testutil"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
func TestSnapshotFSFileChange(t *testing.T) {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Make some changes to the filesystem
|
|
newFiles := map[string]string{
|
|
"foo": "newbaz1",
|
|
"bar/bat": "baz",
|
|
}
|
|
if err := testutil.SetupFiles(testDir, newFiles); err != nil {
|
|
t.Fatalf("Error setting up fs: %s", err)
|
|
}
|
|
// Take another snapshot
|
|
tarPath, err := snapshotter.TakeSnapshotFS()
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
f, err := os.Open(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Check contents of the snapshot, make sure contents is equivalent to snapshotFiles
|
|
tr := tar.NewReader(f)
|
|
fooPath := filepath.Join(testDirWithoutLeadingSlash, "foo")
|
|
batPath := filepath.Join(testDirWithoutLeadingSlash, "bar/bat")
|
|
snapshotFiles := map[string]string{
|
|
fooPath: "newbaz1",
|
|
batPath: "baz",
|
|
}
|
|
for _, path := range util.ParentDirectoriesWithoutLeadingSlash(batPath) {
|
|
if path == "/" {
|
|
snapshotFiles["/"] = ""
|
|
continue
|
|
}
|
|
snapshotFiles[path+"/"] = ""
|
|
}
|
|
|
|
actualFiles := []string{}
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
|
|
actualFiles = append(actualFiles, hdr.Name)
|
|
|
|
if _, isFile := snapshotFiles[hdr.Name]; !isFile {
|
|
t.Fatalf("File %s unexpectedly in tar", hdr.Name)
|
|
}
|
|
if hdr.Typeflag == tar.TypeDir {
|
|
continue
|
|
}
|
|
contents, _ := ioutil.ReadAll(tr)
|
|
if string(contents) != snapshotFiles[hdr.Name] {
|
|
t.Fatalf("Contents of %s incorrect, expected: %s, actual: %s", hdr.Name, snapshotFiles[hdr.Name], string(contents))
|
|
}
|
|
}
|
|
if len(actualFiles) != len(snapshotFiles) {
|
|
t.Fatalf("Incorrect number of files were added, expected: %d, actual: %d", len(snapshotFiles), len(actualFiles))
|
|
}
|
|
}
|
|
|
|
func TestSnapshotFSIsReproducible(t *testing.T) {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Make some changes to the filesystem
|
|
newFiles := map[string]string{
|
|
"foo": "newbaz1",
|
|
"bar/bat": "baz",
|
|
}
|
|
if err := testutil.SetupFiles(testDir, newFiles); err != nil {
|
|
t.Fatalf("Error setting up fs: %s", err)
|
|
}
|
|
// Take another snapshot
|
|
tarPath, err := snapshotter.TakeSnapshotFS()
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
// Check contents of the snapshot, make sure contents are sorted by name
|
|
filesInTar, err := listFilesInTar(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !sort.StringsAreSorted(filesInTar) {
|
|
t.Fatalf("Expected the file in the tar archive were sorted, actual list was not sorted: %v", filesInTar)
|
|
}
|
|
}
|
|
|
|
func TestSnapshotFSChangePermissions(t *testing.T) {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Change permissions on a file
|
|
batPath := filepath.Join(testDir, "bar/bat")
|
|
batPathWithoutLeadingSlash := filepath.Join(testDirWithoutLeadingSlash, "bar/bat")
|
|
if err := os.Chmod(batPath, 0600); err != nil {
|
|
t.Fatalf("Error changing permissions on %s: %v", batPath, err)
|
|
}
|
|
// Take another snapshot
|
|
tarPath, err := snapshotter.TakeSnapshotFS()
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
f, err := os.Open(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Check contents of the snapshot, make sure contents is equivalent to snapshotFiles
|
|
tr := tar.NewReader(f)
|
|
snapshotFiles := map[string]string{
|
|
batPathWithoutLeadingSlash: "baz2",
|
|
}
|
|
for _, path := range util.ParentDirectoriesWithoutLeadingSlash(batPathWithoutLeadingSlash) {
|
|
if path == "/" {
|
|
snapshotFiles["/"] = ""
|
|
continue
|
|
}
|
|
snapshotFiles[path+"/"] = ""
|
|
}
|
|
|
|
foundFiles := []string{}
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
foundFiles = append(foundFiles, hdr.Name)
|
|
if _, isFile := snapshotFiles[hdr.Name]; !isFile {
|
|
t.Fatalf("File %s unexpectedly in tar", hdr.Name)
|
|
}
|
|
if hdr.Typeflag == tar.TypeDir {
|
|
continue
|
|
}
|
|
contents, _ := ioutil.ReadAll(tr)
|
|
if string(contents) != snapshotFiles[hdr.Name] {
|
|
t.Fatalf("Contents of %s incorrect, expected: %s, actual: %s", hdr.Name, snapshotFiles[hdr.Name], string(contents))
|
|
}
|
|
}
|
|
if len(foundFiles) != len(snapshotFiles) {
|
|
t.Logf("expected\n%v\not equal\n%v", foundFiles, snapshotFiles)
|
|
t.Fatalf("Incorrect number of files were added, expected: %d, got: %d",
|
|
len(snapshotFiles),
|
|
len(foundFiles))
|
|
}
|
|
}
|
|
|
|
func TestSnapshotFSReplaceDirWithLink(t *testing.T) {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// replace non-empty directory "bar" with link to file "foo"
|
|
bar := filepath.Join(testDir, "bar")
|
|
err = os.RemoveAll(bar)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
foo := filepath.Join(testDir, "foo")
|
|
err = os.Symlink(foo, bar)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tarPath, err := snapshotter.TakeSnapshotFS()
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
actualFiles, err := listFilesInTar(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Expect "bar", which used to be a non-empty directory but now is a symlink. We don't want whiteout files for
|
|
// the deleted files in bar, because without a parent directory for them the tar cannot be extracted.
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
expectedFiles := []string{
|
|
filepath.Join(testDirWithoutLeadingSlash, "bar"),
|
|
filepath.Join(testDirWithoutLeadingSlash, "foo"),
|
|
}
|
|
for _, path := range util.ParentDirectoriesWithoutLeadingSlash(filepath.Join(testDir, "foo")) {
|
|
expectedFiles = append(expectedFiles, strings.TrimRight(path, "/")+"/")
|
|
}
|
|
|
|
sort.Strings(expectedFiles)
|
|
sort.Strings(actualFiles)
|
|
testutil.CheckErrorAndDeepEqual(t, false, nil, expectedFiles, actualFiles)
|
|
}
|
|
|
|
func TestSnapshotFiles(t *testing.T) {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Make some changes to the filesystem
|
|
newFiles := map[string]string{
|
|
"foo": "newbaz1",
|
|
}
|
|
if err := testutil.SetupFiles(testDir, newFiles); err != nil {
|
|
t.Fatalf("Error setting up fs: %s", err)
|
|
}
|
|
filesToSnapshot := []string{
|
|
filepath.Join(testDir, "foo"),
|
|
}
|
|
tarPath, err := snapshotter.TakeSnapshot(filesToSnapshot, false, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.Remove(tarPath)
|
|
|
|
expectedFiles := []string{
|
|
filepath.Join(testDirWithoutLeadingSlash, "foo"),
|
|
}
|
|
for _, path := range util.ParentDirectoriesWithoutLeadingSlash(filepath.Join(testDir, "foo")) {
|
|
expectedFiles = append(expectedFiles, strings.TrimRight(path, "/")+"/")
|
|
}
|
|
|
|
// Check contents of the snapshot, make sure contents is equivalent to snapshotFiles
|
|
actualFiles, err := listFilesInTar(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sort.Strings(expectedFiles)
|
|
sort.Strings(actualFiles)
|
|
testutil.CheckErrorAndDeepEqual(t, false, nil, expectedFiles, actualFiles)
|
|
}
|
|
|
|
func TestEmptySnapshotFS(t *testing.T) {
|
|
_, snapshotter, cleanup, err := setUpTest(t)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer cleanup()
|
|
|
|
// Take snapshot with no changes
|
|
tarPath, err := snapshotter.TakeSnapshotFS()
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
f, err := os.Open(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tr := tar.NewReader(f)
|
|
|
|
if _, err := tr.Next(); !errors.Is(err, io.EOF) {
|
|
t.Fatal("no files expected in tar, found files.")
|
|
}
|
|
}
|
|
|
|
func TestFileWithLinks(t *testing.T) {
|
|
|
|
link := "baz/link"
|
|
tcs := []struct {
|
|
name string
|
|
path string
|
|
linkFileTarget string
|
|
expected []string
|
|
shouldErr bool
|
|
}{
|
|
{
|
|
name: "given path is a symlink that points to a valid target",
|
|
path: link,
|
|
linkFileTarget: "file",
|
|
expected: []string{link, "baz/file"},
|
|
},
|
|
{
|
|
name: "given path is a symlink points to non existing path",
|
|
path: link,
|
|
linkFileTarget: "does-not-exists",
|
|
expected: []string{link},
|
|
},
|
|
{
|
|
name: "given path is a regular file",
|
|
path: "kaniko/file",
|
|
linkFileTarget: "file",
|
|
expected: []string{"kaniko/file"},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tcs {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
testDir, err := setUpTestDir(t)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := setupSymlink(testDir, link, tt.linkFileTarget); err != nil {
|
|
t.Fatalf("could not set up symlink due to %s", err)
|
|
}
|
|
actual, err := filesWithLinks(filepath.Join(testDir, tt.path))
|
|
if err != nil {
|
|
t.Fatalf("unexpected error %s", err)
|
|
}
|
|
sortAndCompareFilepaths(t, testDir, tt.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSnapshotPreservesFileOrder(t *testing.T) {
|
|
newFiles := map[string]string{
|
|
"foo": "newbaz1",
|
|
"bar/bat": "baz",
|
|
"bar/qux": "quuz",
|
|
"qux": "quuz",
|
|
"corge": "grault",
|
|
"garply": "waldo",
|
|
"fred": "plugh",
|
|
"xyzzy": "thud",
|
|
}
|
|
|
|
newFileNames := []string{}
|
|
|
|
for fileName := range newFiles {
|
|
newFileNames = append(newFileNames, fileName)
|
|
}
|
|
|
|
filesInTars := [][]string{}
|
|
|
|
for i := 0; i <= 2; i++ {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
defer cleanup()
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Make some changes to the filesystem
|
|
if err := testutil.SetupFiles(testDir, newFiles); err != nil {
|
|
t.Fatalf("Error setting up fs: %s", err)
|
|
}
|
|
|
|
filesToSnapshot := []string{}
|
|
for _, file := range newFileNames {
|
|
filesToSnapshot = append(filesToSnapshot, filepath.Join(testDir, file))
|
|
}
|
|
|
|
// Take a snapshot
|
|
tarPath, err := snapshotter.TakeSnapshot(filesToSnapshot, false, false)
|
|
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
filesInTar, err := listFilesInTar(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
filesInTars = append(filesInTars, []string{})
|
|
for _, fn := range filesInTar {
|
|
filesInTars[i] = append(filesInTars[i], strings.TrimPrefix(fn, testDirWithoutLeadingSlash))
|
|
}
|
|
}
|
|
|
|
// Check contents of all snapshots, make sure files appear in consistent order
|
|
for i := 1; i < len(filesInTars); i++ {
|
|
testutil.CheckErrorAndDeepEqual(t, false, nil, filesInTars[0], filesInTars[i])
|
|
}
|
|
}
|
|
|
|
func TestSnapshotWithForceBuildMetadataSet(t *testing.T) {
|
|
_, snapshotter, cleanup, err := setUpTest(t)
|
|
defer cleanup()
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
filesToSnapshot := []string{}
|
|
|
|
// snapshot should be taken regardless, if forceBuildMetadata flag is set
|
|
filename, err := snapshotter.TakeSnapshot(filesToSnapshot, false, true)
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
if filename == "" {
|
|
t.Fatalf("Filename returned from snapshot is empty.")
|
|
}
|
|
}
|
|
|
|
func TestSnapshotWithForceBuildMetadataIsNotSet(t *testing.T) {
|
|
_, snapshotter, cleanup, err := setUpTest(t)
|
|
defer cleanup()
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
filesToSnapshot := []string{}
|
|
|
|
// snapshot should not be taken
|
|
filename, err := snapshotter.TakeSnapshot(filesToSnapshot, false, false)
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
if filename != "" {
|
|
t.Fatalf("Filename returned is expected to be empty.")
|
|
}
|
|
}
|
|
|
|
func TestSnapshotIncludesParentDirBeforeWhiteoutFile(t *testing.T) {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Take a snapshot
|
|
filesToSnapshot := []string{filepath.Join(testDir, "kaniko/file", "bar/bat")}
|
|
_, err = snapshotter.TakeSnapshot(filesToSnapshot, false, false)
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
// Add a file
|
|
newFiles := map[string]string{
|
|
"kaniko/new-file": "baz",
|
|
}
|
|
if err := testutil.SetupFiles(testDir, newFiles); err != nil {
|
|
t.Fatalf("Error setting up fs: %s", err)
|
|
}
|
|
filesToSnapshot = append(filesToSnapshot, filepath.Join(testDir, "kaniko/new-file"))
|
|
|
|
// Delete files
|
|
filesToDelete := []string{"kaniko/file", "bar"}
|
|
for _, fn := range filesToDelete {
|
|
err = os.RemoveAll(filepath.Join(testDir, fn))
|
|
if err != nil {
|
|
t.Fatalf("Error deleting file: %s", err)
|
|
}
|
|
}
|
|
|
|
// Take a snapshot again
|
|
tarPath, err := snapshotter.TakeSnapshot(filesToSnapshot, true, false)
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
actualFiles, err := listFilesInTar(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
expectedFiles := []string{
|
|
filepath.Join(testDirWithoutLeadingSlash, "kaniko/.wh.file"),
|
|
filepath.Join(testDirWithoutLeadingSlash, "kaniko/new-file"),
|
|
filepath.Join(testDirWithoutLeadingSlash, ".wh.bar"),
|
|
"/",
|
|
}
|
|
for parentDir := filepath.Dir(expectedFiles[0]); parentDir != "."; parentDir = filepath.Dir(parentDir) {
|
|
expectedFiles = append(expectedFiles, parentDir+"/")
|
|
}
|
|
|
|
// Sorting does the right thing in this case. The expected order for a directory is:
|
|
// Parent dirs first, then whiteout files in the directory, then other files in that directory
|
|
sort.Strings(expectedFiles)
|
|
|
|
testutil.CheckErrorAndDeepEqual(t, false, nil, expectedFiles, actualFiles)
|
|
}
|
|
|
|
func TestSnapshotPreservesWhiteoutOrder(t *testing.T) {
|
|
newFiles := map[string]string{
|
|
"foo": "newbaz1",
|
|
"bar/bat": "baz",
|
|
"bar/qux": "quuz",
|
|
"qux": "quuz",
|
|
"corge": "grault",
|
|
"garply": "waldo",
|
|
"fred": "plugh",
|
|
"xyzzy": "thud",
|
|
}
|
|
|
|
newFileNames := []string{}
|
|
|
|
for fileName := range newFiles {
|
|
newFileNames = append(newFileNames, fileName)
|
|
}
|
|
|
|
filesInTars := [][]string{}
|
|
|
|
for i := 0; i <= 2; i++ {
|
|
testDir, snapshotter, cleanup, err := setUpTest(t)
|
|
testDirWithoutLeadingSlash := strings.TrimLeft(testDir, "/")
|
|
defer cleanup()
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Make some changes to the filesystem
|
|
if err := testutil.SetupFiles(testDir, newFiles); err != nil {
|
|
t.Fatalf("Error setting up fs: %s", err)
|
|
}
|
|
|
|
filesToSnapshot := []string{}
|
|
for _, file := range newFileNames {
|
|
filesToSnapshot = append(filesToSnapshot, filepath.Join(testDir, file))
|
|
}
|
|
|
|
// Take a snapshot
|
|
_, err = snapshotter.TakeSnapshot(filesToSnapshot, false, false)
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
// Delete all files
|
|
for p := range newFiles {
|
|
err := os.Remove(filepath.Join(testDir, p))
|
|
if err != nil {
|
|
t.Fatalf("Error deleting file: %s", err)
|
|
}
|
|
}
|
|
|
|
// Take a snapshot again
|
|
tarPath, err := snapshotter.TakeSnapshot(filesToSnapshot, true, false)
|
|
if err != nil {
|
|
t.Fatalf("Error taking snapshot of fs: %s", err)
|
|
}
|
|
|
|
filesInTar, err := listFilesInTar(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
filesInTars = append(filesInTars, []string{})
|
|
for _, fn := range filesInTar {
|
|
filesInTars[i] = append(filesInTars[i], strings.TrimPrefix(fn, testDirWithoutLeadingSlash))
|
|
}
|
|
}
|
|
|
|
// Check contents of all snapshots, make sure files appear in consistent order
|
|
for i := 1; i < len(filesInTars); i++ {
|
|
testutil.CheckErrorAndDeepEqual(t, false, nil, filesInTars[0], filesInTars[i])
|
|
}
|
|
}
|
|
|
|
func TestSnapshotOmitsUnameGname(t *testing.T) {
|
|
_, snapshotter, cleanup, err := setUpTest(t)
|
|
|
|
defer cleanup()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tarPath, err := snapshotter.TakeSnapshotFS()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
f, err := os.Open(tarPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tr := tar.NewReader(f)
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if hdr.Uname != "" || hdr.Gname != "" {
|
|
t.Fatalf("Expected Uname/Gname for %s to be empty: Uname = '%s', Gname = '%s'", hdr.Name, hdr.Uname, hdr.Gname)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func setupSymlink(dir string, link string, target string) error {
|
|
return os.Symlink(target, filepath.Join(dir, link))
|
|
}
|
|
|
|
func sortAndCompareFilepaths(t *testing.T, testDir string, expected []string, actual []string) {
|
|
expectedFullPaths := make([]string, len(expected))
|
|
for i, file := range expected {
|
|
expectedFullPaths[i] = filepath.Join(testDir, file)
|
|
}
|
|
sort.Strings(expectedFullPaths)
|
|
sort.Strings(actual)
|
|
testutil.CheckDeepEqual(t, expectedFullPaths, actual)
|
|
}
|
|
|
|
func setUpTestDir(t *testing.T) (string, error) {
|
|
testDir := t.TempDir()
|
|
files := map[string]string{
|
|
"foo": "baz1",
|
|
"bar/bat": "baz2",
|
|
"kaniko/file": "file",
|
|
"baz/file": "testfile",
|
|
}
|
|
// Set up initial files
|
|
if err := testutil.SetupFiles(testDir, files); err != nil {
|
|
return "", errors.Wrap(err, "setting up file system")
|
|
}
|
|
|
|
return testDir, nil
|
|
}
|
|
|
|
func setUpTest(t *testing.T) (string, *Snapshotter, func(), error) {
|
|
testDir, err := setUpTestDir(t)
|
|
if err != nil {
|
|
return "", nil, nil, err
|
|
}
|
|
|
|
snapshotPath := t.TempDir()
|
|
snapshotPathPrefix = snapshotPath
|
|
|
|
// Take the initial snapshot
|
|
l := NewLayeredMap(util.Hasher())
|
|
snapshotter := NewSnapshotter(l, testDir)
|
|
if err := snapshotter.Init(); err != nil {
|
|
return "", nil, nil, errors.Wrap(err, "initializing snapshotter")
|
|
}
|
|
|
|
original := config.KanikoDir
|
|
config.KanikoDir = testDir
|
|
cleanup := func() {
|
|
config.KanikoDir = original
|
|
}
|
|
|
|
return testDir, snapshotter, cleanup, nil
|
|
}
|
|
|
|
func listFilesInTar(path string) ([]string, error) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tr := tar.NewReader(f)
|
|
var files []string
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
files = append(files, hdr.Name)
|
|
}
|
|
return files, nil
|
|
}
|