More tests/examples.

api/internal/target/kusttarget.go

@@ -1,8 +1,6 @@
 // Copyright 2019 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-// Package target implements state for the set of all
-// resources to customize.
 package target
 
 import (
@@ -36,38 +34,43 @@ type KustTarget struct {
 	pLdr          *loader.Loader
 }
 
-// NewKustTarget returns a new instance of KustTarget primed with a Loader.
+// NewKustTarget returns a new instance of KustTarget.
 func NewKustTarget(
 	ldr ifc.Loader,
 	validator ifc.Validator,
 	rFactory *resmap.Factory,
 	tFactory resmap.PatchFactory,
-	pLdr *loader.Loader) (*KustTarget, error) {
-	content, err := loadKustFile(ldr)
-	if err != nil {
-		return nil, err
-	}
-	content = types.FixKustomizationPreUnmarshalling(content)
-	var k types.Kustomization
-	err = unmarshal(content, &k)
-	if err != nil {
-		return nil, err
-	}
-	k.FixKustomizationPostUnmarshalling()
-	errs := k.EnforceFields()
-	if len(errs) > 0 {
-		return nil, fmt.Errorf(
-			"Failed to read kustomization file under %s:\n"+
-				strings.Join(errs, "\n"), ldr.Root())
-	}
+	pLdr *loader.Loader) *KustTarget {
 	return &KustTarget{
-		kustomization: &k,
 		ldr:       ldr,
 		validator: validator,
 		rFactory:  rFactory,
 		tFactory:  tFactory,
 		pLdr:      pLdr,
-	}, nil
+	}
+}
+
+// Load attempts to load the target's kustomization file.
+func (kt *KustTarget) Load() error {
+	content, err := loadKustFile(kt.ldr)
+	if err != nil {
+		return err
+	}
+	content = types.FixKustomizationPreUnmarshalling(content)
+	var k types.Kustomization
+	err = unmarshal(content, &k)
+	if err != nil {
+		return err
+	}
+	k.FixKustomizationPostUnmarshalling()
+	errs := k.EnforceFields()
+	if len(errs) > 0 {
+		return fmt.Errorf(
+			"Failed to read kustomization file under %s:\n"+
+				strings.Join(errs, "\n"), kt.ldr.Root())
+	}
+	kt.kustomization = &k
+	return nil
 }
 
 func loadKustFile(ldr ifc.Loader) ([]byte, error) {
@@ -101,8 +104,8 @@ func unmarshal(y []byte, o interface{}) error {
 	return dec.Decode(o)
 }
 
-// MakeCustomizedResMap creates a ResMap per kustomization instructions.
-// The Resources in the returned ResMap are fully customized.
+// MakeCustomizedResMap creates a fully customized ResMap
+// per the instructions contained in its kustomiztion instance.
 func (kt *KustTarget) MakeCustomizedResMap() (resmap.ResMap, error) {
 	return kt.makeCustomizedResMap(types.GarbageIgnore)
 }
@@ -320,8 +323,9 @@ func (kt *KustTarget) accumulateResources(
 func (kt *KustTarget) accumulateDirectory(
 	ra *accumulator.ResAccumulator, ldr ifc.Loader) error {
 	defer ldr.Cleanup()
-	subKt, err := NewKustTarget(
+	subKt := NewKustTarget(
 		ldr, kt.validator, kt.rFactory, kt.tFactory, kt.pLdr)
+	err := subKt.Load()
 	if err != nil {
 		return errors.Wrapf(
 			err, "couldn't make target for path '%s'", ldr.Root())

api/internal/target/kusttarget_test.go

@@ -5,23 +5,20 @@ package target_test
 
 import (
 	"encoding/base64"
-	"fmt"
-	"strings"
 	"testing"
 
 	"sigs.k8s.io/kustomize/api/ifc"
-	"sigs.k8s.io/kustomize/api/internal/loadertest"
-	. "sigs.k8s.io/kustomize/api/internal/target"
-	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
-	valtest_test "sigs.k8s.io/kustomize/api/testutils/valtest"
-	"sigs.k8s.io/kustomize/api/types"
 )
 
-const (
-	kustomizationContent = `
+// KustTarget is primarily tested in the krusty package with
+// high level tests.
+
+func TestMakeCustomizedResMap(t *testing.T) {
+	th := kusttest_test.NewKustTestHarness(t, "/whatever")
+	th.WriteK("/whatever", `
 apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
 namePrefix: foo-
@@ -54,30 +51,22 @@ patchesJson6902:
     kind: Deployment
     name: dply1
   path: jsonpatch.json
-`
-	deploymentContent = `
+`)
+	th.WriteF("/whatever/deployment.yaml", `
 apiVersion: apps/v1
 metadata:
   name: dply1
 kind: Deployment
-`
-	namespaceContent = `
+`)
+	th.WriteF("/whatever/namespace.yaml", `
 apiVersion: v1
 kind: Namespace
 metadata:
   name: ns1
-`
-	jsonpatchContent = `[
+`)
+	th.WriteF("/whatever/jsonpatch.json", `[
     {"op": "add", "path": "/spec/replica", "value": "3"}
-]`
-)
-
-func TestResources(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/whatever")
-	th.WriteK("/whatever/", kustomizationContent)
-	th.WriteF("/whatever/deployment.yaml", deploymentContent)
-	th.WriteF("/whatever/namespace.yaml", namespaceContent)
-	th.WriteF("/whatever/jsonpatch.json", jsonpatchContent)
+]`)
 
 	resources := []*resource.Resource{
 		th.RF().FromMapWithName("dply1", map[string]interface{}{
@@ -182,265 +171,3 @@ func TestResources(t *testing.T) {
 		t.Fatalf("unexpected inequality: %v", err)
 	}
 }
-
-func TestKustomizationNotFound(t *testing.T) {
-	_, err := NewKustTarget(
-		loadertest.NewFakeLoader("/foo"),
-		valtest_test.MakeFakeValidator(), nil, nil, nil)
-	if err == nil {
-		t.Fatalf("expected an error")
-	}
-	if err.Error() !=
-		`unable to find one of 'kustomization.yaml', 'kustomization.yml' or 'Kustomization' in directory '/foo'` {
-		t.Fatalf("unexpected error: %q", err)
-	}
-}
-
-func TestResourceNotFound(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/whatever")
-	th.WriteK("/whatever", kustomizationContent)
-	_, err := th.MakeKustTarget().MakeCustomizedResMap()
-	if err == nil {
-		t.Fatalf("Didn't get the expected error for an unknown resource")
-	}
-	if !strings.Contains(err.Error(), "'/whatever/deployment.yaml' doesn't exist") {
-		t.Fatalf("unexpected error: %q", err)
-	}
-}
-
-func findSecret(m resmap.ResMap) *resource.Resource {
-	for _, r := range m.Resources() {
-		if r.OrgId().Kind == "Secret" {
-			return r
-		}
-	}
-	return nil
-}
-
-func TestDisableNameSuffixHash(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/whatever")
-	th.WriteK("/whatever/", kustomizationContent)
-	th.WriteF("/whatever/deployment.yaml", deploymentContent)
-	th.WriteF("/whatever/namespace.yaml", namespaceContent)
-	th.WriteF("/whatever/jsonpatch.json", jsonpatchContent)
-
-	m, err := th.MakeKustTarget().MakeCustomizedResMap()
-	if err != nil {
-		t.Fatalf("unexpected Resources error %v", err)
-	}
-	secret := findSecret(m)
-	if secret == nil {
-		t.Errorf("Expected to find a Secret")
-	}
-	if secret.GetName() != "foo-secret-bar-9btc7bt4kb" {
-		t.Errorf("unexpected secret resource name: %s", secret.GetName())
-	}
-
-	th.WriteK("/whatever/",
-		strings.Replace(kustomizationContent,
-			"disableNameSuffixHash: false",
-			"disableNameSuffixHash: true", -1))
-	m, err = th.MakeKustTarget().MakeCustomizedResMap()
-	if err != nil {
-		t.Fatalf("unexpected Resources error %v", err)
-	}
-	secret = findSecret(m)
-	if secret == nil {
-		t.Errorf("Expected to find a Secret")
-	}
-	if secret.GetName() != "foo-secret-bar" { // No hash at end.
-		t.Errorf("unexpected secret resource name: %s", secret.GetName())
-	}
-}
-
-func TestIssue596AllowDirectoriesThatAreSubstringsOfEachOther(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/app/overlays/aws-sandbox2.us-east-1")
-	th.WriteK("/app/base", "")
-	th.WriteK("/app/overlays/aws", `
-resources:
-- ../../base
-`)
-	th.WriteK("/app/overlays/aws-nonprod", `
-resources:
-- ../aws
-`)
-	th.WriteK("/app/overlays/aws-sandbox2.us-east-1", `
-resources:
-- ../aws-nonprod
-`)
-	m, err := th.MakeKustTarget().MakeCustomizedResMap()
-	if err != nil {
-		t.Fatalf("Err: %v", err)
-	}
-	th.AssertActualEqualsExpected(m, "")
-}
-
-// To simplify tests, these vars specified in alphabetical order.
-var someVars = []types.Var{
-	{
-		Name: "AWARD",
-		ObjRef: types.Target{
-			APIVersion: "v7",
-			Gvk:        resid.Gvk{Kind: "Service"},
-			Name:       "nobelPrize"},
-		FieldRef: types.FieldSelector{FieldPath: "some.arbitrary.path"},
-	},
-	{
-		Name: "BIRD",
-		ObjRef: types.Target{
-			APIVersion: "v300",
-			Gvk:        resid.Gvk{Kind: "Service"},
-			Name:       "heron"},
-		FieldRef: types.FieldSelector{FieldPath: "metadata.name"},
-	},
-	{
-		Name: "FRUIT",
-		ObjRef: types.Target{
-			Gvk:  resid.Gvk{Kind: "Service"},
-			Name: "apple"},
-		FieldRef: types.FieldSelector{FieldPath: "metadata.name"},
-	},
-	{
-		Name: "VEGETABLE",
-		ObjRef: types.Target{
-			Gvk:  resid.Gvk{Kind: "Leafy"},
-			Name: "kale"},
-		FieldRef: types.FieldSelector{FieldPath: "metadata.name"},
-	},
-}
-
-func TestGetAllVarsSimple(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/app")
-	th.WriteK("/app", `
-vars:
-  - name: AWARD
-    objref:
-      kind: Service
-      name: nobelPrize
-      apiVersion: v7
-    fieldref:
-      fieldpath: some.arbitrary.path
-  - name: BIRD
-    objref:
-      kind: Service
-      name: heron
-      apiVersion: v300
-`)
-	ra, err := th.MakeKustTarget().AccumulateTarget()
-	if err != nil {
-		t.Fatalf("Err: %v", err)
-	}
-	vars := ra.Vars()
-	if len(vars) != 2 {
-		t.Fatalf("unexpected size %d", len(vars))
-	}
-	for i := range vars[:2] {
-		// By using Var.DeepEqual, we are protecting the code
-		// from a potential invocation of vars[i].ObjRef.GVK()
-		// during AccumulateTarget
-		if !vars[i].DeepEqual(someVars[i]) {
-			t.Fatalf("unexpected var[%d]:\n  %v\n  %v", i, vars[i], someVars[i])
-		}
-	}
-}
-
-func TestGetAllVarsNested(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/app/overlays/o2")
-	th.WriteK("/app/base", `
-vars:
-  - name: AWARD
-    objref:
-      kind: Service
-      name: nobelPrize
-      apiVersion: v7
-    fieldref:
-      fieldpath: some.arbitrary.path
-  - name: BIRD
-    objref:
-      kind: Service
-      name: heron
-      apiVersion: v300
-`)
-	th.WriteK("/app/overlays/o1", `
-vars:
-  - name: FRUIT
-    objref:
-      kind: Service
-      name: apple
-resources:
-- ../../base
-`)
-	th.WriteK("/app/overlays/o2", `
-vars:
-  - name: VEGETABLE
-    objref:
-      kind: Leafy
-      name: kale
-resources:
-- ../o1
-`)
-	ra, err := th.MakeKustTarget().AccumulateTarget()
-	if err != nil {
-		t.Fatalf("Err: %v", err)
-	}
-	vars := ra.Vars()
-	if len(vars) != 4 {
-		for i, v := range vars {
-			fmt.Printf("%v: %v\n", i, v)
-		}
-		t.Fatalf("expected 4 vars, got %d", len(vars))
-	}
-	for i := range vars {
-		// By using Var.DeepEqual, we are protecting the code
-		// from a potential invocation of vars[i].ObjRef.GVK()
-		// during AccumulateTarget
-		if !vars[i].DeepEqual(someVars[i]) {
-			t.Fatalf("unexpected var[%d]:\n  %v\n  %v", i, vars[i], someVars[i])
-		}
-	}
-}
-
-func TestVarCollisionsForbidden(t *testing.T) {
-	th := kusttest_test.NewKustTestHarness(t, "/app/overlays/o2")
-	th.WriteK("/app/base", `
-vars:
-  - name: AWARD
-    objref:
-      kind: Service
-      name: nobelPrize
-      apiVersion: v7
-    fieldref:
-      fieldpath: some.arbitrary.path
-  - name: BIRD
-    objref:
-      kind: Service
-      name: heron
-      apiVersion: v300
-`)
-	th.WriteK("/app/overlays/o1", `
-vars:
-  - name: AWARD
-    objref:
-      kind: Service
-      name: academy
-resources:
-- ../../base
-`)
-	th.WriteK("/app/overlays/o2", `
-vars:
-  - name: VEGETABLE
-    objref:
-      kind: Leafy
-      name: kale
-resources:
-- ../o1
-`)
-	_, err := th.MakeKustTarget().AccumulateTarget()
-	if err == nil {
-		t.Fatalf("expected var collision")
-	}
-	if !strings.Contains(err.Error(),
-		"var 'AWARD' already encountered") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}

api/internal/target/vars_test.go

@@ -0,0 +1,184 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package target_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"sigs.k8s.io/kustomize/api/resid"
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+	"sigs.k8s.io/kustomize/api/types"
+)
+
+// To simplify tests, these vars specified in alphabetical order.
+var someVars = []types.Var{
+	{
+		Name: "AWARD",
+		ObjRef: types.Target{
+			APIVersion: "v7",
+			Gvk:        resid.Gvk{Kind: "Service"},
+			Name:       "nobelPrize"},
+		FieldRef: types.FieldSelector{FieldPath: "some.arbitrary.path"},
+	},
+	{
+		Name: "BIRD",
+		ObjRef: types.Target{
+			APIVersion: "v300",
+			Gvk:        resid.Gvk{Kind: "Service"},
+			Name:       "heron"},
+		FieldRef: types.FieldSelector{FieldPath: "metadata.name"},
+	},
+	{
+		Name: "FRUIT",
+		ObjRef: types.Target{
+			Gvk:  resid.Gvk{Kind: "Service"},
+			Name: "apple"},
+		FieldRef: types.FieldSelector{FieldPath: "metadata.name"},
+	},
+	{
+		Name: "VEGETABLE",
+		ObjRef: types.Target{
+			Gvk:  resid.Gvk{Kind: "Leafy"},
+			Name: "kale"},
+		FieldRef: types.FieldSelector{FieldPath: "metadata.name"},
+	},
+}
+
+func TestGetAllVarsSimple(t *testing.T) {
+	th := kusttest_test.NewKustTestHarness(t, "/app")
+	th.WriteK("/app", `
+vars:
+  - name: AWARD
+    objref:
+      kind: Service
+      name: nobelPrize
+      apiVersion: v7
+    fieldref:
+      fieldpath: some.arbitrary.path
+  - name: BIRD
+    objref:
+      kind: Service
+      name: heron
+      apiVersion: v300
+`)
+	ra, err := th.MakeKustTarget().AccumulateTarget()
+	if err != nil {
+		t.Fatalf("Err: %v", err)
+	}
+	vars := ra.Vars()
+	if len(vars) != 2 {
+		t.Fatalf("unexpected size %d", len(vars))
+	}
+	for i := range vars[:2] {
+		// By using Var.DeepEqual, we are protecting the code
+		// from a potential invocation of vars[i].ObjRef.GVK()
+		// during accumulateTarget
+		if !vars[i].DeepEqual(someVars[i]) {
+			t.Fatalf("unexpected var[%d]:\n  %v\n  %v", i, vars[i], someVars[i])
+		}
+	}
+}
+
+func TestGetAllVarsNested(t *testing.T) {
+	th := kusttest_test.NewKustTestHarness(t, "/app/overlays/o2")
+	th.WriteK("/app/base", `
+vars:
+  - name: AWARD
+    objref:
+      kind: Service
+      name: nobelPrize
+      apiVersion: v7
+    fieldref:
+      fieldpath: some.arbitrary.path
+  - name: BIRD
+    objref:
+      kind: Service
+      name: heron
+      apiVersion: v300
+`)
+	th.WriteK("/app/overlays/o1", `
+vars:
+  - name: FRUIT
+    objref:
+      kind: Service
+      name: apple
+resources:
+- ../../base
+`)
+	th.WriteK("/app/overlays/o2", `
+vars:
+  - name: VEGETABLE
+    objref:
+      kind: Leafy
+      name: kale
+resources:
+- ../o1
+`)
+	ra, err := th.MakeKustTarget().AccumulateTarget()
+	if err != nil {
+		t.Fatalf("Err: %v", err)
+	}
+	vars := ra.Vars()
+	if len(vars) != 4 {
+		for i, v := range vars {
+			fmt.Printf("%v: %v\n", i, v)
+		}
+		t.Fatalf("expected 4 vars, got %d", len(vars))
+	}
+	for i := range vars {
+		// By using Var.DeepEqual, we are protecting the code
+		// from a potential invocation of vars[i].ObjRef.GVK()
+		// during accumulateTarget
+		if !vars[i].DeepEqual(someVars[i]) {
+			t.Fatalf("unexpected var[%d]:\n  %v\n  %v", i, vars[i], someVars[i])
+		}
+	}
+}
+
+func TestVarCollisionsForbidden(t *testing.T) {
+	th := kusttest_test.NewKustTestHarness(t, "/app/overlays/o2")
+	th.WriteK("/app/base", `
+vars:
+  - name: AWARD
+    objref:
+      kind: Service
+      name: nobelPrize
+      apiVersion: v7
+    fieldref:
+      fieldpath: some.arbitrary.path
+  - name: BIRD
+    objref:
+      kind: Service
+      name: heron
+      apiVersion: v300
+`)
+	th.WriteK("/app/overlays/o1", `
+vars:
+  - name: AWARD
+    objref:
+      kind: Service
+      name: academy
+resources:
+- ../../base
+`)
+	th.WriteK("/app/overlays/o2", `
+vars:
+  - name: VEGETABLE
+    objref:
+      kind: Leafy
+      name: kale
+resources:
+- ../o1
+`)
+	_, err := th.MakeKustTarget().AccumulateTarget()
+	if err == nil {
+		t.Fatalf("expected var collision")
+	}
+	if !strings.Contains(err.Error(),
+		"var 'AWARD' already encountered") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}

api/krusty/accumulation_test.go

@@ -4,8 +4,12 @@
 package krusty_test
 
 import (
+	"path/filepath"
+	"strings"
 	"testing"
 
+	"sigs.k8s.io/kustomize/api/konfig"
+
 	. "sigs.k8s.io/kustomize/api/internal/target"
 )
 
@@ -32,6 +36,23 @@ metadata:
 	}
 }
 
+func TestTargetMustHaveOnlyOneKustomizationFile(t *testing.T) {
+	th := makeTestHarness(t)
+	for _, n := range konfig.RecognizedKustomizationFileNames() {
+		th.WriteF(filepath.Join("/app", n), `
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+`)
+	}
+	err := th.RunWithErr("/app", th.MakeDefaultOptions())
+	if err == nil {
+		t.Fatalf("expected an error")
+	}
+	if !strings.Contains(err.Error(), "Found multiple kustomization files under: /app") {
+		t.Fatalf("unexpected error: %q", err)
+	}
+}
+
 func TestBaseMustHaveKustomizationFile(t *testing.T) {
 	th := makeTestHarness(t)
 	th.WriteK("/app", `
@@ -57,3 +78,18 @@ spec:
 		t.Fatalf("unexpected error: %q", err)
 	}
 }
+
+func TestResourceNotFound(t *testing.T) {
+	th := makeTestHarness(t)
+	th.WriteK("/app", `
+resources:
+- deployment.yaml
+`)
+	err := th.RunWithErr("/app", th.MakeDefaultOptions())
+	if err == nil {
+		t.Fatalf("expected an error")
+	}
+	if !strings.Contains(err.Error(), "'/app/deployment.yaml' doesn't exist") {
+		t.Fatalf("unexpected error: %q", err)
+	}
+}

api/krusty/directoryarrangement_test.go

@@ -0,0 +1,27 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+import (
+	"testing"
+)
+
+func TestIssue596AllowDirectoriesThatAreSubstringsOfEachOther(t *testing.T) {
+	th := makeTestHarness(t)
+	th.WriteK("/app/base", "")
+	th.WriteK("/app/overlays/aws", `
+resources:
+- ../../base
+`)
+	th.WriteK("/app/overlays/aws-nonprod", `
+resources:
+- ../aws
+`)
+	th.WriteK("/app/overlays/aws-sandbox2.us-east-1", `
+resources:
+- ../aws-nonprod
+`)
+	m := th.Run("/app/overlays/aws-sandbox2.us-east-1", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, "")
+}

api/krusty/disablenamesuffix_test.go

@@ -0,0 +1,99 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+import (
+	"strings"
+	"testing"
+
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
+)
+
+func findSecret(m resmap.ResMap) *resource.Resource {
+	for _, r := range m.Resources() {
+		if r.OrgId().Kind == "Secret" {
+			return r
+		}
+	}
+	return nil
+}
+
+func TestDisableNameSuffixHash(t *testing.T) {
+	th := makeTestHarness(t)
+	const kustomizationContent = `
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+namePrefix: foo-
+nameSuffix: -bar
+namespace: ns1
+commonLabels:
+  app: nginx
+commonAnnotations:
+  note: This is a test annotation
+resources:
+  - deployment.yaml
+  - namespace.yaml
+generatorOptions:
+  disableNameSuffixHash: false
+configMapGenerator:
+- name: literalConfigMap
+  literals:
+  - DB_USERNAME=admin
+  - DB_PASSWORD=somepw
+secretGenerator:
+- name: secret
+  literals:
+    - DB_USERNAME=admin
+    - DB_PASSWORD=somepw
+  type: Opaque
+patchesJson6902:
+- target:
+    group: apps
+    version: v1
+    kind: Deployment
+    name: dply1
+  path: jsonpatch.json
+`
+
+	th.WriteK("/whatever", kustomizationContent)
+	th.WriteF("/whatever/deployment.yaml", `
+apiVersion: apps/v1
+metadata:
+  name: dply1
+kind: Deployment
+`)
+	th.WriteF("/whatever/namespace.yaml", `
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: ns1
+`)
+	th.WriteF("/whatever/jsonpatch.json", `[
+    {"op": "add", "path": "/spec/replica", "value": "3"}
+]`)
+
+	m := th.Run("/whatever", th.MakeDefaultOptions())
+
+	secret := findSecret(m)
+	if secret == nil {
+		t.Errorf("Expected to find a Secret")
+	}
+	if secret.GetName() != "foo-secret-bar-9btc7bt4kb" {
+		t.Errorf("unexpected secret resource name: %s", secret.GetName())
+	}
+
+	th.WriteK("/whatever",
+		strings.Replace(kustomizationContent,
+			"disableNameSuffixHash: false",
+			"disableNameSuffixHash: true", -1))
+	m = th.Run("/whatever", th.MakeDefaultOptions())
+	secret = findSecret(m)
+	if secret == nil {
+		t.Errorf("Expected to find a Secret")
+	}
+	if secret.GetName() != "foo-secret-bar" { // No hash at end.
+		t.Errorf("unexpected secret resource name: %s", secret.GetName())
+	}
+}

api/krusty/kustomizer.go

@@ -59,13 +59,14 @@ func (b *Kustomizer) Run(path string) (resmap.ResMap, error) {
 		return nil, err
 	}
 	defer ldr.Cleanup()
-	kt, err := target.NewKustTarget(
+	kt := target.NewKustTarget(
 		ldr,
 		validator.NewKustValidator(),
 		rf,
 		pf,
 		pLdr.NewLoader(b.options.PluginConfig, rf),
 	)
+	err = kt.Load()
 	if err != nil {
 		return nil, err
 	}

api/testutils/kusttest/kusttestharness.go

@@ -65,19 +65,16 @@ func NewKustTestHarnessFull(
 }
 
 func (th *KustTestHarness) MakeKustTarget() *target.KustTarget {
-	kt, err := th.MakeKustTargetOrErr()
+	kt := target.NewKustTarget(
+		th.ldr, valtest_test.MakeFakeValidator(), th.rf,
+		transformer.NewFactoryImpl(), th.pl)
+	err := kt.Load()
 	if err != nil {
 		th.t.Fatalf("Unexpected construction error %v", err)
 	}
 	return kt
 }
 
-func (th *KustTestHarness) MakeKustTargetOrErr() (*target.KustTarget, error) {
-	return target.NewKustTarget(
-		th.ldr, valtest_test.MakeFakeValidator(), th.rf,
-		transformer.NewFactoryImpl(), th.pl)
-}
-
 func (th *KustTestHarness) WriteF(dir string, content string) {
 	err := th.ldr.AddFile(dir, []byte(content))
 	if err != nil {