Add more test coverage for RawResources.

pkg/app/application.go

@@ -33,6 +33,7 @@ import (
 	"github.com/kubernetes-sigs/kustomize/pkg/resource"
 	"github.com/kubernetes-sigs/kustomize/pkg/transformers"
 	"github.com/kubernetes-sigs/kustomize/pkg/types"
+	"github.com/pkg/errors"
 )
 
 // Application interface exposes methods to get resources of the application.
@@ -97,20 +98,20 @@ func (a *applicationImpl) SemiResources() (resmap.ResMap, error) {
 	errs := &interror.KustomizationErrors{}
 	raw, err := a.rawResources()
 	if err != nil {
-		errs.Append(err)
+		errs.Append(errors.Wrap(err, "rawResources"))
 	}
 
 	cms, err := resmap.NewResMapFromConfigMapArgs(a.loader, a.kustomization.ConfigMapGenerator)
 	if err != nil {
-		errs.Append(err)
+		errs.Append(errors.Wrap(err, "NewResMapFromConfigMapArgs"))
 	}
 	secrets, err := resmap.NewResMapFromSecretArgs(a.loader.Root(), a.kustomization.SecretGenerator)
 	if err != nil {
-		errs.Append(err)
+		errs.Append(errors.Wrap(err, "NewResMapFromSecretArgs"))
 	}
 	res, err := resmap.Merge(cms, secrets)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "Merge")
 	}
 
 	allRes, err := resmap.MergeWithOverride(raw, res)
@@ -120,7 +121,7 @@ func (a *applicationImpl) SemiResources() (resmap.ResMap, error) {
 
 	patches, err := resmap.NewResourceSliceFromPatches(a.loader, a.kustomization.Patches)
 	if err != nil {
-		errs.Append(err)
+		errs.Append(errors.Wrap(err, "NewResourceSliceFromPatches"))
 	}
 
 	if len(errs.Get()) > 0 {
@@ -144,7 +145,7 @@ func (a *applicationImpl) SemiResources() (resmap.ResMap, error) {
 func (a *applicationImpl) RawResources() (resmap.ResMap, error) {
 	res, err := a.rawResources()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "RawResources")
 	}
 	t, err := a.newHashAndReferenceTransformer(res)
 	if err != nil {
@@ -161,7 +162,7 @@ func (a *applicationImpl) rawResources() (resmap.ResMap, error) {
 	subAppResources, errs := a.subAppResources()
 	resources, err := resmap.NewResMapFromFiles(a.loader, a.kustomization.Resources)
 	if err != nil {
-		errs.Append(err)
+		errs.Append(errors.Wrap(err, "rawResources failed to read Resources"))
 	}
 
 	if len(errs.Get()) > 0 {
@@ -177,25 +178,25 @@ func (a *applicationImpl) subAppResources() (resmap.ResMap, *interror.Kustomizat
 	for _, pkgPath := range a.kustomization.Bases {
 		subloader, err := a.loader.New(pkgPath)
 		if err != nil {
-			errs.Append(err)
+			errs.Append(errors.Wrap(err, "couldn't make loader for "+pkgPath))
 			continue
 		}
 		subapp, err := New(subloader)
 		if err != nil {
-			errs.Append(err)
+			errs.Append(errors.Wrap(err, "couldn't make app for "+pkgPath))
 			continue
 		}
 		// Gather all transformed resources from subpackages.
 		subAppResources, err := subapp.SemiResources()
 		if err != nil {
-			errs.Append(err)
+			errs.Append(errors.Wrap(err, "SemiResources"))
 			continue
 		}
 		sliceOfSubAppResources = append(sliceOfSubAppResources, subAppResources)
 	}
 	allResources, err := resmap.Merge(sliceOfSubAppResources...)
 	if err != nil {
-		errs.Append(err)
+		errs.Append(errors.Wrap(err, "Merge failed"))
 	}
 	return allResources, errs
 }

pkg/app/application_test.go

@@ -18,6 +18,7 @@ package app
 
 import (
 	"encoding/base64"
+	"os"
 	"reflect"
 	"testing"
 
@@ -30,8 +31,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
-func setupTest(t *testing.T) loader.Loader {
-	kustomizationContent := []byte(`
+const (
+	kustomizationContent1 = `
 namePrefix: foo-
 namespace: ns1
 commonLabels:
@@ -52,28 +53,30 @@ secretGenerator:
     DB_USERNAME: "printf admin"
     DB_PASSWORD: "printf somepw"
   type: Opaque
-`)
-	deploymentContent := []byte(`apiVersion: apps/v1
-kind: Deployment
+`
+	deploymentContent = `apiVersion: apps/v1
 metadata:
   name: dply1
-`)
-	namespaceContent := []byte(`apiVersion: v1
+kind: Deployment
+`
+	namespaceContent = `apiVersion: v1
 kind: Namespace
 metadata:
   name: ns1
-  `)
+`
+)
 
+func makeLoader1(t *testing.T) loader.Loader {
 	loader := loadertest.NewFakeLoader("/testpath")
-	err := loader.AddFile("/testpath/"+constants.KustomizationFileName, kustomizationContent)
+	err := loader.AddFile("/testpath/"+constants.KustomizationFileName, []byte(kustomizationContent1))
 	if err != nil {
 		t.Fatalf("Failed to setup fake loader.")
 	}
-	err = loader.AddFile("/testpath/deployment.yaml", deploymentContent)
+	err = loader.AddFile("/testpath/deployment.yaml", []byte(deploymentContent))
 	if err != nil {
 		t.Fatalf("Failed to setup fake loader.")
 	}
-	err = loader.AddFile("/testpath/namespace.yaml", namespaceContent)
+	err = loader.AddFile("/testpath/namespace.yaml", []byte(namespaceContent))
 	if err != nil {
 		t.Fatalf("Failed to setup fake loader.")
 	}
@@ -84,8 +87,9 @@ var deploy = schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "Deploy
 var cmap = schema.GroupVersionKind{Version: "v1", Kind: "ConfigMap"}
 var secret = schema.GroupVersionKind{Version: "v1", Kind: "Secret"}
 var ns = schema.GroupVersionKind{Version: "v1", Kind: "Namespace"}
+var svc = schema.GroupVersionKind{Version: "v1", Kind: "Service"}
 
-func TestResources(t *testing.T) {
+func TestResources1(t *testing.T) {
 	expected := resmap.ResMap{
 		resource.NewResId(deploy, "dply1"): resource.NewResourceFromMap(
 			map[string]interface{}{
@@ -176,23 +180,23 @@ func TestResources(t *testing.T) {
 				},
 			}),
 	}
-	l := setupTest(t)
+	l := makeLoader1(t)
 	app, err := New(l)
 	if err != nil {
-		t.Fatalf("Unexpected error %v", err)
+		t.Fatalf("Unexpected construction error %v", err)
 	}
 	actual, err := app.Resources()
 	if err != nil {
-		t.Fatalf("Unexpected error %v", err)
+		t.Fatalf("Unexpected Resources error %v", err)
 	}
 
 	if !reflect.DeepEqual(actual, expected) {
 		err = expected.ErrorIfNotEqual(actual)
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatalf("unexpected inequality: %v", err)
 	}
 }
 
-func TestRawResources(t *testing.T) {
+func TestRawResources1(t *testing.T) {
 	expected := resmap.ResMap{
 		resource.NewResId(deploy, "dply1"): resource.NewResourceFromMap(
 			map[string]interface{}{
@@ -211,17 +215,127 @@ func TestRawResources(t *testing.T) {
 				},
 			}),
 	}
-	l := setupTest(t)
+	l := makeLoader1(t)
 	app, err := New(l)
 	if err != nil {
-		t.Fatalf("Unexpected error %v", err)
+		t.Fatalf("Unexpected construction error %v", err)
 	}
 	actual, err := app.RawResources()
 	if err != nil {
-		t.Fatalf("Unexpected error %v", err)
+		t.Fatalf("Unexpected RawResources error %v", err)
 	}
 
 	if err := expected.ErrorIfNotEqual(actual); err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatalf("unexpected inequality: %v", err)
+	}
+}
+
+const (
+	kustomizationContentBase = `
+namePrefix: foo-
+commonLabels:
+  app: banana
+resources:
+  - deployment.yaml
+`
+	kustomizationContentOverlay = `
+commonLabels:
+  env: staging
+resources:
+  - service.yaml
+bases:
+  - base
+`
+	serviceContent = `apiVersion: v1
+kind: Service
+metadata:
+  name: svc
+spec:
+  type: LoadBalancer
+`
+)
+
+func makeLoader2(t *testing.T) loader.Loader {
+	loader := loadertest.NewFakeLoader("/testpath")
+	err := loader.AddFile("/testpath/"+constants.KustomizationFileName, []byte(kustomizationContentOverlay))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = loader.AddFile("/testpath/service.yaml", []byte(serviceContent))
+	if err != nil {
+		t.Fatalf("Failed to setup fake loader.")
+	}
+	err = loader.AddDirectory("/testpath/base", os.ModeDir)
+	if err != nil {
+		t.Fatalf("Failed to setup fake loader.")
+	}
+	err = loader.AddFile("/testpath/base/"+constants.KustomizationFileName, []byte(kustomizationContentBase))
+	if err != nil {
+		t.Fatalf("Failed to setup fake loader.")
+	}
+	err = loader.AddFile("/testpath/base/deployment.yaml", []byte(deploymentContent))
+	if err != nil {
+		t.Fatalf("Failed to setup fake loader.")
+	}
+	return loader
+}
+
+// TODO: This test covers incorrect behavior; it should not pass.
+// It asks for raw resources.  The Service resource is returned in raw form,
+// but the resources in the base are modified to have the banana label,
+// the 'foo' name prefix, etc.  This method exists only to support the
+// diff command comparing customized to non-customized resources;
+// perhaps it's not worth supporting the command.
+func TestRawResources2(t *testing.T) {
+	expected := resmap.ResMap{
+		resource.NewResId(deploy, "dply1"): resource.NewResourceFromMap(
+			map[string]interface{}{
+				"apiVersion": "apps/v1",
+				"kind":       "Deployment",
+				"metadata": map[string]interface{}{
+					"name": "foo-dply1",
+					"labels": map[string]interface{}{
+						"app": "banana",
+					},
+				},
+				"spec": map[string]interface{}{
+					"selector": map[string]interface{}{
+						"matchLabels": map[string]interface{}{
+							"app": "banana",
+						},
+					},
+					"template": map[string]interface{}{
+						"metadata": map[string]interface{}{
+							"labels": map[string]interface{}{
+								"app": "banana",
+							},
+						},
+					},
+				},
+			}),
+		resource.NewResId(svc, "svc"): resource.NewResourceFromMap(
+			map[string]interface{}{
+				"apiVersion": "v1",
+				"kind":       "Service",
+				"metadata": map[string]interface{}{
+					"name": "svc",
+				},
+				"spec": map[string]interface{}{
+					"type": "LoadBalancer",
+				},
+			}),
+	}
+	l := makeLoader2(t)
+	app, err := New(l)
+	if err != nil {
+		t.Fatalf("Unexpected construction error %v", err)
+	}
+	actual, err := app.RawResources()
+	if err != nil {
+		t.Fatalf("Unexpected RawResources error %v", err)
+	}
+
+	if err := expected.ErrorIfNotEqual(actual); err != nil {
+		t.Fatalf("unexpected inequality: %v", err)
 	}
 }

pkg/resmap/resmap.go

@@ -28,6 +28,7 @@ import (
 	"github.com/golang/glog"
 	"github.com/kubernetes-sigs/kustomize/pkg/loader"
 	"github.com/kubernetes-sigs/kustomize/pkg/resource"
+	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	k8syaml "k8s.io/apimachinery/pkg/util/yaml"
 )
@@ -87,7 +88,7 @@ func (m ResMap) ErrorIfNotEqual(m2 ResMap) error {
 			return fmt.Errorf("%#v doesn't exist in %#v", id, m2)
 		}
 		if !reflect.DeepEqual(obj1, obj2) {
-			return fmt.Errorf("%#v doesn't match %#v", obj1, obj2)
+			return fmt.Errorf("%#v doesn't deep equal %#v", obj1, obj2)
 		}
 	}
 	return nil
@@ -131,9 +132,8 @@ func NewResMapFromFiles(loader loader.Loader, paths []string) (ResMap, error) {
 	for _, path := range paths {
 		content, err := loader.Load(path)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "Load from path "+path+" failed")
 		}
-
 		res, err := newResMapFromBytes(content)
 		if err != nil {
 			return nil, err

pkg/resmap/secret.go

@@ -25,13 +25,14 @@ import (
 
 	"github.com/kubernetes-sigs/kustomize/pkg/resource"
 	"github.com/kubernetes-sigs/kustomize/pkg/types"
+	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
 )
 
 func newResourceFromSecretGenerator(p string, sArgs types.SecretArgs) (*resource.Resource, error) {
 	s, err := makeSecret(p, sArgs)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "makeSecret")
 	}
 	return resource.NewResourceWithBehavior(
 		s, resource.NewGenerationBehavior(sArgs.Behavior))
@@ -51,7 +52,7 @@ func makeSecret(p string, sArgs types.SecretArgs) (*corev1.Secret, error) {
 	for k, v := range sArgs.Commands {
 		out, err := createSecretKey(p, v)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "createSecretKey")
 		}
 		s.Data[k] = out
 	}
@@ -77,7 +78,7 @@ func NewResMapFromSecretArgs(p string, secretList []types.SecretArgs) (ResMap, e
 	for _, secret := range secretList {
 		res, err := newResourceFromSecretGenerator(p, secret)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "newResourceFromSecretGenerator")
 		}
 		allResources = append(allResources, res)
 	}