Adapt tests to new FileSystem field

kyaml/kio/pkgio_writer_test.go

@@ -5,14 +5,16 @@ package kio_test
 
 import (
 	"fmt"
-	"io/ioutil"
+	"math/rand"
-	"os"
 	"path/filepath"
 	"testing"
+	"time"
 
+	"sigs.k8s.io/kustomize/kyaml/filesys"
 	"sigs.k8s.io/kustomize/kyaml/testutil"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	. "sigs.k8s.io/kustomize/kyaml/kio"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
@@ -20,53 +22,53 @@ import (
 // TestLocalPackageWriter_Write tests:
 // - ReaderAnnotations are cleared when writing the Resources
 func TestLocalPackageWriter_Write(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	w := LocalPackageWriter{PackagePath: d}
+		w := LocalPackageWriter{
-	err := w.Write([]*yaml.RNode{node2, node1, node3})
+			PackagePath: d,
-	if !assert.NoError(t, err) {
+			FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: fs},
-		assert.FailNow(t, err.Error())
+		}
-	}
+		err := w.Write([]*yaml.RNode{node2, node1, node3})
+		require.NoError(t, err)
 
-	b, err := ioutil.ReadFile(filepath.Join(d, "a", "b", "a_test.yaml"))
+		b, err := fs.ReadFile(filepath.Join(d, "a", "b", "a_test.yaml"))
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
+		require.Equal(t, `a: b #first
-	}
-	assert.Equal(t, `a: b #first
 ---
 c: d # second
 `, string(b))
 
-	b, err = ioutil.ReadFile(filepath.Join(d, "a", "b", "b_test.yaml"))
+		b, err = fs.ReadFile(filepath.Join(d, "a", "b", "b_test.yaml"))
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
+		require.Equal(t, `e: f
-	}
-	assert.Equal(t, `e: f
 g:
   h:
   - i # has a list
   - j
 `, string(b))
+	})
 }
 
 // TestLocalPackageWriter_Write_keepReaderAnnotations tests:
 // - ReaderAnnotations are kept when writing the Resources
 func TestLocalPackageWriter_Write_keepReaderAnnotations(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	w := LocalPackageWriter{PackagePath: d, KeepReaderAnnotations: true}
+		w := LocalPackageWriter{
-	err := w.Write([]*yaml.RNode{node2, node1, node3})
+			PackagePath:           d,
-	if !assert.NoError(t, err) {
+			KeepReaderAnnotations: true,
-		return
+			FileSystem:            filesys.FileSystemOrOnDisk{FileSystem: fs},
-	}
+		}
+		err := w.Write([]*yaml.RNode{node2, node1, node3})
+		require.NoError(t, err)
 
-	b, err := ioutil.ReadFile(filepath.Join(d, "a", "b", "a_test.yaml"))
+		b, err := fs.ReadFile(filepath.Join(d, "a", "b", "a_test.yaml"))
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		return
+		require.Equal(t, `a: b #first
-	}
-	assert.Equal(t, `a: b #first
 metadata:
   annotations:
     config.kubernetes.io/index: 0
@@ -79,11 +81,9 @@ metadata:
     config.kubernetes.io/path: "a/b/a_test.yaml"
 `, string(b))
 
-	b, err = ioutil.ReadFile(filepath.Join(d, "a", "b", "b_test.yaml"))
+		b, err = fs.ReadFile(filepath.Join(d, "a", "b", "b_test.yaml"))
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		return
+		require.Equal(t, `e: f
-	}
-	assert.Equal(t, `e: f
 g:
   h:
   - i # has a list
@@ -93,48 +93,50 @@ metadata:
     config.kubernetes.io/index: 0
     config.kubernetes.io/path: "a/b/b_test.yaml"
 `, string(b))
+	})
 }
 
 // TestLocalPackageWriter_Write_clearAnnotations tests:
 // - ClearAnnotations are removed from Resources
 func TestLocalPackageWriter_Write_clearAnnotations(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	w := LocalPackageWriter{PackagePath: d, ClearAnnotations: []string{"config.kubernetes.io/mode"}}
+		w := LocalPackageWriter{
-	err := w.Write([]*yaml.RNode{node2, node1, node3})
+			PackagePath:      d,
-	if !assert.NoError(t, err) {
+			ClearAnnotations: []string{"config.kubernetes.io/mode"},
-		assert.FailNow(t, err.Error())
+			FileSystem:       filesys.FileSystemOrOnDisk{FileSystem: fs},
-	}
+		}
+		err := w.Write([]*yaml.RNode{node2, node1, node3})
+		require.NoError(t, err)
 
-	b, err := ioutil.ReadFile(filepath.Join(d, "a", "b", "a_test.yaml"))
+		b, err := fs.ReadFile(filepath.Join(d, "a", "b", "a_test.yaml"))
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
+		require.Equal(t, `a: b #first
-	}
-	assert.Equal(t, `a: b #first
 ---
 c: d # second
 `, string(b))
 
-	b, err = ioutil.ReadFile(filepath.Join(d, "a", "b", "b_test.yaml"))
+		b, err = fs.ReadFile(filepath.Join(d, "a", "b", "b_test.yaml"))
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
+		require.Equal(t, `e: f
-	}
-	assert.Equal(t, `e: f
 g:
   h:
   - i # has a list
   - j
 `, string(b))
+	})
 }
 
 // TestLocalPackageWriter_Write_failRelativePath tests:
 // - If a relative path above the package is defined, write fails
 func TestLocalPackageWriter_Write_failRelativePath(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	node4, err := yaml.Parse(`e: f
+		node4, err := yaml.Parse(`e: f
 g:
   h:
   - i # has a list
@@ -144,24 +146,27 @@ metadata:
     config.kubernetes.io/index: 0
     config.kubernetes.io/path: "a/b/../../../b_test.yaml"
 `)
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 
-	w := LocalPackageWriter{PackagePath: d}
+		w := LocalPackageWriter{
-	err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+			PackagePath: d,
-	if assert.Error(t, err) {
+			FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: fs},
-		assert.Contains(t, err.Error(), "resource must be written under package")
+		}
-	}
+		err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+		if assert.Error(t, err) {
+			assert.Contains(t, err.Error(), "resource must be written under package")
+		}
+	})
 }
 
 // TestLocalPackageWriter_Write_invalidIndex tests:
 // - If a non-int index is given, fail
 func TestLocalPackageWriter_Write_invalidIndex(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	node4, err := yaml.Parse(`e: f
+		node4, err := yaml.Parse(`e: f
 g:
   h:
   - i # has a list
@@ -171,26 +176,29 @@ metadata:
     config.kubernetes.io/index: a
     config.kubernetes.io/path: "a/b/b_test.yaml" # use a different path, should still collide
 `)
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 
-	w := LocalPackageWriter{PackagePath: d}
+		w := LocalPackageWriter{
-	err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+			PackagePath: d,
-	if assert.Error(t, err) {
+			FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: fs},
-		assert.Contains(t, err.Error(), "unable to parse config.kubernetes.io/index")
+		}
-	}
+		err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+		if assert.Error(t, err) {
+			assert.Contains(t, err.Error(), "unable to parse config.kubernetes.io/index")
+		}
+	})
 }
 
 // TestLocalPackageWriter_Write_absPath tests:
 // - If config.kubernetes.io/path is absolute, fail
 func TestLocalPackageWriter_Write_absPath(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	d = filepath.ToSlash(d)
+		d = filepath.ToSlash(d)
 
-	n4 := fmt.Sprintf(`e: f
+		n4 := fmt.Sprintf(`e: f
 g:
   h:
   - i # has a list
@@ -200,21 +208,26 @@ metadata:
     config.kubernetes.io/index: a
     config.kubernetes.io/path: "%s/a/b/b_test.yaml" # use a different path, should still collide
 `, d)
-	node4, err := yaml.Parse(n4)
+		node4, err := yaml.Parse(n4)
-	testutil.AssertNoError(t, err, n4)
+		testutil.AssertNoError(t, err, n4)
 
-	w := LocalPackageWriter{PackagePath: d}
+		w := LocalPackageWriter{
-	err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+			PackagePath: d,
-	testutil.AssertErrorContains(t, err, "package paths may not be absolute paths")
+			FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: fs},
+		}
+		err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+		testutil.AssertErrorContains(t, err, "package paths may not be absolute paths")
+	})
 }
 
 // TestLocalPackageWriter_Write_missingPath tests:
 // - If config.kubernetes.io/path or index are missing, then default them
 func TestLocalPackageWriter_Write_missingAnnotations(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	node4String := `e: f
+		node4String := `e: f
 g:
   h:
   - i # has a list
@@ -223,32 +236,29 @@ kind: Foo
 metadata:
   name: bar
 `
-	node4, err := yaml.Parse(node4String)
+		node4, err := yaml.Parse(node4String)
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 
-	w := LocalPackageWriter{PackagePath: d}
+		w := LocalPackageWriter{
-	err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+			PackagePath: d,
-	if !assert.NoError(t, err) {
+			FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: fs},
-		t.FailNow()
+		}
-	}
+		err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
-	b, err := ioutil.ReadFile(filepath.Join(d, "foo_bar.yaml"))
+		require.NoError(t, err)
-	if !assert.NoError(t, err) {
+		b, err := fs.ReadFile(filepath.Join(d, "foo_bar.yaml"))
-		t.FailNow()
+		require.NoError(t, err)
-	}
+		require.Equal(t, node4String, string(b))
-	if !assert.Equal(t, node4String, string(b)) {
+	})
-		t.FailNow()
-	}
 }
 
 // TestLocalPackageWriter_Write_pathIsDir tests:
 // - If  config.kubernetes.io/path is a directory, fail
 func TestLocalPackageWriter_Write_pathIsDir(t *testing.T) {
-	d, node1, node2, node3 := getWriterInputs(t)
+	testWriterOnDiskAndOnMem(t, func(t *testing.T, fs filesys.FileSystem) {
-	defer os.RemoveAll(d)
+		d, node1, node2, node3, cleanup := getWriterInputs(t, fs)
+		defer cleanup()
 
-	node4, err := yaml.Parse(`e: f
+		node4, err := yaml.Parse(`e: f
 g:
   h:
   - i # has a list
@@ -258,36 +268,38 @@ metadata:
     config.kubernetes.io/path: a/
     config.kubernetes.io/index: 0
 `)
-	if !assert.NoError(t, err) {
+		require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 
-	w := LocalPackageWriter{PackagePath: d}
+		w := LocalPackageWriter{
-	err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+			PackagePath: d,
-	if assert.Error(t, err) {
+			FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: fs},
-		assert.Contains(t, err.Error(), "config.kubernetes.io/path cannot be a directory")
+		}
-	}
+		err = w.Write([]*yaml.RNode{node2, node1, node3, node4})
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "config.kubernetes.io/path cannot be a directory")
+	})
 }
 
-func getWriterInputs(t *testing.T) (string, *yaml.RNode, *yaml.RNode, *yaml.RNode) {
+func testWriterOnDiskAndOnMem(t *testing.T, f func(t *testing.T, fs filesys.FileSystem)) {
+	t.Run("on_disk", func(t *testing.T) { f(t, filesys.MakeFsOnDisk()) })
+	t.Run("on_mem", func(t *testing.T) { f(t, filesys.MakeFsInMemory()) })
+}
+
+func getWriterInputs(t *testing.T, mockFS filesys.FileSystem) (string, *yaml.RNode, *yaml.RNode, *yaml.RNode, func()) {
 	node1, err := yaml.Parse(`a: b #first
 metadata:
   annotations:
     config.kubernetes.io/index: 0
     config.kubernetes.io/path: "a/b/a_test.yaml"
 `)
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 	node2, err := yaml.Parse(`c: d # second
 metadata:
   annotations:
     config.kubernetes.io/index: 1
     config.kubernetes.io/path: "a/b/a_test.yaml"
 `)
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 	node3, err := yaml.Parse(`e: f
 g:
   h:
@@ -298,15 +310,10 @@ metadata:
     config.kubernetes.io/index: 0
     config.kubernetes.io/path: "a/b/b_test.yaml"
 `)
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
+
-	}
+	rand.Seed(time.Now().Unix())
-	d, err := ioutil.TempDir("", "kyaml-test")
+	path := fmt.Sprintf("/tmp/kyaml-test%d", rand.Int31())
-	if !assert.NoError(t, err) {
+	require.NoError(t, mockFS.MkdirAll(filepath.Join(path, "a")))
-		assert.FailNow(t, err.Error())
+	return path, node1, node2, node3, func() { require.NoError(t, mockFS.RemoveAll(path)) }
-	}
-	if !assert.NoError(t, os.MkdirAll(filepath.Join(d, "a"), 0700)) {
-		assert.FailNow(t, "")
-	}
-	return d, node1, node2, node3
 }

kyaml/kio/testing.go

@@ -9,7 +9,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // Setup creates directories and files for testing
@@ -21,18 +21,12 @@ type Setup struct {
 // setupDirectories creates directories for reading test configuration from
 func SetupDirectories(t *testing.T, dirs ...string) Setup {
 	d, err := ioutil.TempDir("", "kyaml-test")
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 	err = os.Chdir(d)
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 	for _, s := range dirs {
 		err = os.MkdirAll(s, 0700)
-		if !assert.NoError(t, err) {
+		require.NoError(t, err)
-			assert.FailNow(t, err.Error())
-		}
 	}
 	return Setup{Root: d}
 }
@@ -40,13 +34,9 @@ func SetupDirectories(t *testing.T, dirs ...string) Setup {
 // writeFile writes a file under the test directory
 func (s Setup) WriteFile(t *testing.T, path string, value []byte) {
 	err := os.MkdirAll(filepath.Dir(filepath.Join(s.Root, path)), 0700)
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 	err = ioutil.WriteFile(filepath.Join(s.Root, path), value, 0600)
-	if !assert.NoError(t, err) {
+	require.NoError(t, err)
-		assert.FailNow(t, err.Error())
-	}
 }
 
 // clean deletes the test config