Get rid of the fake loader.

api/internal/accumulator/loadconfigfromcrds_test.go

@@ -7,9 +7,10 @@ import (
 	"reflect"
 	"testing"
 
-	"sigs.k8s.io/kustomize/api/ifc"
+	"sigs.k8s.io/kustomize/api/filesys"
+	"sigs.k8s.io/kustomize/api/loader"
+
 	. "sigs.k8s.io/kustomize/api/internal/accumulator"
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/types"
@@ -135,15 +136,6 @@ If it is not set we generate a secret dynamically",
 `
 )
 
-func makeLoader(t *testing.T) ifc.Loader {
-	ldr := loadertest.NewFakeLoader("/testpath")
-	err := ldr.AddFile("/testpath/crd.json", []byte(crdContent))
-	if err != nil {
-		t.Fatalf("Failed to setup fake ldr.")
-	}
-	return ldr
-}
-
 func TestLoadCRDs(t *testing.T) {
 	nbrs := []builtinconfig.NameBackReferences{
 		{
@@ -172,7 +164,14 @@ func TestLoadCRDs(t *testing.T) {
 		NameReference: nbrs,
 	}
 
-	actualTc, err := LoadConfigFromCRDs(makeLoader(t), []string{"crd.json"})
+	fSys := filesys.MakeFsInMemory()
+	fSys.WriteFile("/testpath/crd.json", []byte(crdContent))
+	ldr, err := loader.NewLoader(loader.RestrictionRootOnly, "/testpath", fSys)
+	if err != nil {
+		t.Fatalf("unexpected error:%v", err)
+	}
+
+	actualTc, err := LoadConfigFromCRDs(ldr, []string{"crd.json"})
 	if err != nil {
 		t.Fatalf("unexpected error:%v", err)
 	}

api/internal/loadertest/fakeloader.go

@@ -1,76 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-// Package loadertest holds a fake for the Loader interface.
-package loadertest
-
-import (
-	"log"
-
-	"sigs.k8s.io/kustomize/api/filesys"
-	"sigs.k8s.io/kustomize/api/ifc"
-	"sigs.k8s.io/kustomize/api/loader"
-)
-
-// FakeLoader encapsulates the delegate Loader and the fake file system.
-type FakeLoader struct {
-	fs       filesys.FileSystem
-	delegate ifc.Loader
-}
-
-// NewFakeLoader returns a Loader that uses a fake filesystem.
-// The loader will be restricted to root only.
-// The root argument should be an absolute file path.
-func NewFakeLoader(root string) FakeLoader {
-	return NewFakeLoaderWithRestrictor(
-		loader.RestrictionRootOnly, filesys.MakeFsInMemory(), root)
-}
-
-// NewFakeLoaderWithRestrictor returns a Loader that
-// uses a fake filesystem.
-// The initialDir argument should be an absolute file path.
-func NewFakeLoaderWithRestrictor(
-	lr loader.LoadRestrictorFunc,
-	fSys filesys.FileSystem,
-	initialDir string) FakeLoader {
-	fSys.Mkdir(initialDir)
-	ldr, err := loader.NewLoader(lr, initialDir, fSys)
-	if err != nil {
-		log.Fatalf("Unable to make loader: %v", err)
-	}
-	return FakeLoader{fs: fSys, delegate: ldr}
-}
-
-// AddFile adds a fake file to the file system.
-func (f FakeLoader) AddFile(fullFilePath string, content []byte) error {
-	return f.fs.WriteFile(fullFilePath, content)
-}
-
-// AddDirectory adds a fake directory to the file system.
-func (f FakeLoader) AddDirectory(fullDirPath string) error {
-	return f.fs.Mkdir(fullDirPath)
-}
-
-// Root delegates.
-func (f FakeLoader) Root() string {
-	return f.delegate.Root()
-}
-
-// New creates a new loader from a new root.
-func (f FakeLoader) New(newRoot string) (ifc.Loader, error) {
-	l, err := f.delegate.New(newRoot)
-	if err != nil {
-		return nil, err
-	}
-	return FakeLoader{fs: f.fs, delegate: l}, nil
-}
-
-// Load delegates.
-func (f FakeLoader) Load(location string) ([]byte, error) {
-	return f.delegate.Load(location)
-}
-
-// Cleanup delegates.
-func (f FakeLoader) Cleanup() error {
-	return f.delegate.Cleanup()
-}

api/internal/plugins/builtinconfig/loaddefaultconfig_test.go

@@ -7,21 +7,30 @@ import (
 	"reflect"
 	"testing"
 
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
+	"sigs.k8s.io/kustomize/api/filesys"
+	"sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/types"
 )
 
 func TestLoadDefaultConfigsFromFiles(t *testing.T) {
-	ldr := loadertest.NewFakeLoader("/app")
+	fSys := filesys.MakeFsInMemory()
-	ldr.AddFile("/app/config.yaml", []byte(`
+	err := fSys.WriteFile("config.yaml", []byte(`
 namePrefix:
 - path: nameprefix/path
   kind: SomeKind
 `))
-	tcfg, err := loadDefaultConfig(ldr, []string{"/app/config.yaml"})
 	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatal(err)
+	}
+	ldr, err := loader.NewLoader(
+		loader.RestrictionRootOnly, filesys.Separator, fSys)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tCfg, err := loadDefaultConfig(ldr, []string{"config.yaml"})
+	if err != nil {
+		t.Fatal(err)
 	}
 	expected := &TransformerConfig{
 		NamePrefix: []types.FieldSpec{
@@ -31,7 +40,7 @@ namePrefix:
 			},
 		},
 	}
-	if !reflect.DeepEqual(tcfg, expected) {
+	if !reflect.DeepEqual(tCfg, expected) {
-		t.Fatalf("expected %v\n but go6t %v\n", expected, tcfg)
+		t.Fatalf("expected %v\n but go6t %v\n", expected, tCfg)
 	}
 }

api/internal/plugins/execplugin/execplugin_test.go

@@ -8,11 +8,12 @@ import (
 	"strings"
 	"testing"
 
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
+	"sigs.k8s.io/kustomize/api/filesys"
 	. "sigs.k8s.io/kustomize/api/internal/plugins/execplugin"
-	"sigs.k8s.io/kustomize/api/internal/plugins/loader"
+	pLdr "sigs.k8s.io/kustomize/api/internal/plugins/loader"
 	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
 	"sigs.k8s.io/kustomize/api/konfig"
+	fLdr "sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	valtest_test "sigs.k8s.io/kustomize/api/testutils/valtest"
@@ -20,11 +21,20 @@ import (
 )
 
 func TestExecPluginConfig(t *testing.T) {
-	path := "/app"
+	fSys := filesys.MakeFsInMemory()
+	fSys.WriteFile("sed-input.txt", []byte(`
+s/$FOO/foo/g
+s/$BAR/bar/g
+ \ \ \ 
+`))
+	ldr, err := fLdr.NewLoader(
+		fLdr.RestrictionRootOnly, filesys.Separator, fSys)
+	if err != nil {
+		t.Fatal(err)
+	}
 	rf := resmap.NewFactory(
 		resource.NewFactory(
 			kunstruct.NewKunstructuredFactoryImpl()), nil)
-	ldr := loadertest.NewFakeLoader(path)
 	v := valtest_test.MakeFakeValidator()
 	pluginConfig := rf.RF().FromMap(
 		map[string]interface{}{
@@ -36,15 +46,8 @@ func TestExecPluginConfig(t *testing.T) {
 			"argsOneLiner": "one two",
 			"argsFromFile": "sed-input.txt",
 		})
-
-	ldr.AddFile("/app/sed-input.txt", []byte(`
-s/$FOO/foo/g
-s/$BAR/bar/g
- \ \ \ 
-`))
-
 	p := NewExecPlugin(
-		loader.AbsolutePluginPath(
+		pLdr.AbsolutePluginPath(
 			konfig.DisabledPluginConfig(),
 			pluginConfig.OrgId()))
 	// Not checking to see if the plugin is executable,

api/internal/plugins/loader/loader_test.go

@@ -6,10 +6,11 @@ package loader_test
 import (
 	"testing"
 
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
+	"sigs.k8s.io/kustomize/api/filesys"
 	. "sigs.k8s.io/kustomize/api/internal/plugins/loader"
 	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
 	"sigs.k8s.io/kustomize/api/konfig"
+	"sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
@@ -49,29 +50,29 @@ func TestLoader(t *testing.T) {
 		BuildGoPlugin("builtin", "", "SecretGenerator").
 		BuildGoPlugin("someteam.example.com", "v1", "SomeServiceGenerator")
 	defer th.Reset()
-
 	rmF := resmap.NewFactory(resource.NewFactory(
 		kunstruct.NewKunstructuredFactoryImpl()), nil)
-
+	fLdr, err := loader.NewLoader(
-	ldr := loadertest.NewFakeLoader("/foo")
+		loader.RestrictionRootOnly,
-
+		filesys.Separator, filesys.MakeFsInMemory())
+	if err != nil {
+		t.Fatal(err)
+	}
 	c, err := konfig.EnabledPluginConfig()
 	if err != nil {
 		t.Fatal(err)
 	}
-
 	pLdr := NewLoader(c, rmF)
 	if pLdr == nil {
 		t.Fatal("expect non-nil loader")
 	}
-
 	m, err := rmF.NewResMapFromBytes([]byte(
 		someServiceGenerator + "---\n" + secretGenerator))
 	if err != nil {
 		t.Fatal(err)
 	}
-
+	_, err = pLdr.LoadGenerators(
-	_, err = pLdr.LoadGenerators(ldr, valtest_test.MakeFakeValidator(), m)
+		fLdr, valtest_test.MakeFakeValidator(), m)
 	if err != nil {
 		t.Fatal(err)
 	}

api/internal/target/maker_test.go

@@ -8,12 +8,11 @@ import (
 
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/internal/k8sdeps/transformer"
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
 	pLdr "sigs.k8s.io/kustomize/api/internal/plugins/loader"
 	"sigs.k8s.io/kustomize/api/internal/target"
 	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
 	"sigs.k8s.io/kustomize/api/konfig"
-	"sigs.k8s.io/kustomize/api/loader"
+	fLdr "sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	valtest_test "sigs.k8s.io/kustomize/api/testutils/valtest"
@@ -35,15 +34,17 @@ func makeKustTargetWithRf(
 	resFact *resource.Factory) *target.KustTarget {
 	rf := resmap.NewFactory(resFact, transformer.NewFactoryImpl())
 	pc := konfig.DisabledPluginConfig()
+	ldr, err := fLdr.NewLoader(fLdr.RestrictionRootOnly, root, fSys)
+	if err != nil {
+		t.Fatal(err)
+	}
 	kt := target.NewKustTarget(
-		loadertest.NewFakeLoaderWithRestrictor(
+		ldr,
-			loader.RestrictionRootOnly, fSys, root),
 		valtest_test.MakeFakeValidator(),
 		rf,
 		transformer.NewFactoryImpl(),
 		pLdr.NewLoader(pc, rf))
-	err := kt.Load()
+	if err = kt.Load(); err != nil {
-	if err != nil {
 		t.Fatalf("Unexpected construction error %v", err)
 	}
 	return kt

api/resmap/factory_test.go

@@ -10,7 +10,6 @@ import (
 
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/ifc"
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
 	"sigs.k8s.io/kustomize/api/kv"
 	"sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resid"
@@ -21,7 +20,6 @@ import (
 )
 
 func TestFromFile(t *testing.T) {
-
 	resourceStr := `apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -41,10 +39,6 @@ metadata:
   namespace: test
 ---
 `
-	l := loadertest.NewFakeLoader("/whatever/project")
-	if ferr := l.AddFile("/whatever/project/deployment.yaml", []byte(resourceStr)); ferr != nil {
-		t.Fatalf("Error adding fake file: %v\n", ferr)
-	}
 	expected := resmaptest_test.NewRmBuilder(t, rf).
 		Add(map[string]interface{}{
 			"apiVersion": "apps/v1",
@@ -66,7 +60,22 @@ metadata:
 				"namespace": "test",
 			}}).ResMap()
 
-	m, _ := rmF.FromFile(l, "deployment.yaml")
+	fSys := filesys.MakeFsInMemory()
+	err := fSys.WriteFile("deployment.yaml", []byte(resourceStr))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ldr, err := loader.NewLoader(
+		loader.RestrictionRootOnly, filesys.Separator, fSys)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	m, err := rmF.FromFile(ldr, "deployment.yaml")
+	if err != nil {
+		t.Fatal(err)
+	}
 	if m.Size() != 3 {
 		t.Fatalf("result should contain 3, but got %d", m.Size())
 	}
@@ -119,8 +128,13 @@ func TestNewFromConfigMaps(t *testing.T) {
 		expected    ResMap
 	}
 
-	l := loadertest.NewFakeLoader("/whatever/project")
+	fSys := filesys.MakeFsInMemory()
-	kvLdr := kv.NewLoader(l, valtest_test.MakeFakeValidator())
+	ldr, err := loader.NewLoader(
+		loader.RestrictionRootOnly, filesys.Separator, fSys)
+	if err != nil {
+		t.Fatal(err)
+	}
+	kvLdr := kv.NewLoader(ldr, valtest_test.MakeFakeValidator())
 	testCases := []testCase{
 		{
 			description: "construct config map from env",
@@ -134,7 +148,7 @@ func TestNewFromConfigMaps(t *testing.T) {
 					},
 				},
 			},
-			filepath: "/whatever/project/app.env",
+			filepath: "app.env",
 			content:  "DB_USERNAME=admin\nDB_PASSWORD=somepw",
 			expected: resmaptest_test.NewRmBuilder(t, rf).Add(
 				map[string]interface{}{
@@ -160,7 +174,7 @@ func TestNewFromConfigMaps(t *testing.T) {
 				},
 			},
 			},
-			filepath: "/whatever/project/app-init.ini",
+			filepath: "app-init.ini",
 			content:  "FOO=bar\nBAR=baz\n",
 			expected: resmaptest_test.NewRmBuilder(t, rf).Add(
 				map[string]interface{}{
@@ -209,8 +223,7 @@ BAR=baz
 	}
 	for _, tc := range testCases {
 		if tc.filepath != "" {
-			if fErr := l.AddFile(
+			if fErr := fSys.WriteFile(tc.filepath, []byte(tc.content)); fErr != nil {
-				tc.filepath, []byte(tc.content)); fErr != nil {
 				t.Fatalf("error adding file '%s': %v\n", tc.filepath, fErr)
 			}
 		}

api/resource/factory_test.go

@@ -1,18 +1,5 @@
-/*
+// Copyright 2019 The Kubernetes Authors.
-Copyright 2018 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
-
-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 resource_test
 
@@ -20,13 +7,13 @@ import (
 	"reflect"
 	"testing"
 
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
+	"sigs.k8s.io/kustomize/api/filesys"
+	"sigs.k8s.io/kustomize/api/loader"
 	. "sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
 )
 
 func TestSliceFromPatches(t *testing.T) {
-
 	patchGood1 := types.PatchStrategicMerge("patch1.yaml")
 	patch1 := `
 apiVersion: apps/v1
@@ -131,14 +118,21 @@ kind: List
 			},
 			"spec": testDeploymentSpec,
 		})
-	l := loadertest.NewFakeLoader("/")
+
-	l.AddFile("/"+string(patchGood1), []byte(patch1))
+	fSys := filesys.MakeFsInMemory()
-	l.AddFile("/"+string(patchGood2), []byte(patch2))
+	fSys.WriteFile(string(patchGood1), []byte(patch1))
-	l.AddFile("/"+string(patchBad), []byte(patch3))
+	fSys.WriteFile(string(patchGood2), []byte(patch2))
-	l.AddFile("/"+string(patchList), []byte(patch4))
+	fSys.WriteFile(string(patchBad), []byte(patch3))
-	l.AddFile("/"+string(patchList2), []byte(patch5))
+	fSys.WriteFile(string(patchList), []byte(patch4))
-	l.AddFile("/"+string(patchList3), []byte(patch6))
+	fSys.WriteFile(string(patchList2), []byte(patch5))
-	l.AddFile("/"+string(patchList4), []byte(patch7))
+	fSys.WriteFile(string(patchList3), []byte(patch6))
+	fSys.WriteFile(string(patchList4), []byte(patch7))
+
+	ldr, err := loader.NewLoader(
+		loader.RestrictionRootOnly, filesys.Separator, fSys)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	tests := []struct {
 		name        string
@@ -190,7 +184,7 @@ kind: List
 		},
 	}
 	for _, test := range tests {
-		rs, err := factory.SliceFromPatches(l, test.input)
+		rs, err := factory.SliceFromPatches(ldr, test.input)
 		if test.expectedErr && err == nil {
 			t.Fatalf("%v: should return error", test.name)
 		}

api/testutils/kusttest/harnessenhanced.go

@@ -7,9 +7,8 @@ import (
 	"testing"
 
 	"sigs.k8s.io/kustomize/api/filesys"
-
+	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/internal/k8sdeps/transformer"
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
 	pLdr "sigs.k8s.io/kustomize/api/internal/plugins/loader"
 	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
 	"sigs.k8s.io/kustomize/api/konfig"
@@ -24,7 +23,7 @@ type HarnessEnhanced struct {
 	Harness
 	pte *pluginTestEnv
 	rf  *resmap.Factory
-	ldr loadertest.FakeLoader
+	ldr ifc.Loader
 	pl  *pLdr.Loader
 }
 
@@ -72,8 +71,15 @@ func (th *HarnessEnhanced) PrepBuiltin(k string) *HarnessEnhanced {
 }
 
 func (th *HarnessEnhanced) ResetLoaderRoot(root string) {
-	th.ldr = loadertest.NewFakeLoaderWithRestrictor(
+	if err := th.fSys.Mkdir(root); err != nil {
-		fLdr.RestrictionRootOnly, th.fSys, root)
+		th.t.Fatal(err)
+	}
+	ldr, err := fLdr.NewLoader(
+		fLdr.RestrictionRootOnly, root, th.fSys)
+	if err != nil {
+		th.t.Fatalf("Unable to make loader: %v", err)
+	}
+	th.ldr = ldr
 }
 
 func (th *HarnessEnhanced) LoadAndRunGenerator(