Further isolate unstructured with factories.

2026-06-12 01:14:22 +00:00 · 2018-10-06 10:44:34 -07:00
parent 3cdfbd843b
commit 4eb2757847
31 changed files with 525 additions and 348 deletions
--- a/internal/k8sdeps/kunstructuredfactory.go
+++ b/internal/k8sdeps/kunstructuredfactory.go
@@ -0,0 +1,60 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+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 k8sdeps
+
+import (
+	"io"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"sigs.k8s.io/kustomize/pkg/ifc"
+)
+
+// KustKunstructuredFactory hides construction using apimachinery types.
+type KustKunstructuredFactory struct {
+	decoder ifc.Decoder
+}
+
+var _ ifc.KunstructuredFactory = &KustKunstructuredFactory{}
+
+// NewKustKunstructuredFactory returns a factory.
+func NewKustKunstructuredFactory(d ifc.Decoder) ifc.KunstructuredFactory {
+	return &KustKunstructuredFactory{decoder: d}
+}
+
+// SliceFromBytes returns a slice of Kunstructured.
+func (kf *KustKunstructuredFactory) SliceFromBytes(
+	in []byte) ([]ifc.Kunstructured, error) {
+	kf.decoder.SetInput(in)
+	var result []ifc.Kunstructured
+	var err error
+	for err == nil || isEmptyYamlError(err) {
+		var out unstructured.Unstructured
+		err = kf.decoder.Decode(&out)
+		if err == nil {
+			result = append(result, &UnstructAdapter{Unstructured: out})
+		}
+	}
+	if err != io.EOF {
+		return nil, err
+	}
+	return result, nil
+}
+
+// FromMap returns an instance of Kunstructured.
+func (kf *KustKunstructuredFactory) FromMap(
+	m map[string]interface{}) ifc.Kunstructured {
+	return &UnstructAdapter{Unstructured: unstructured.Unstructured{Object: m}}
+}
--- a/internal/k8sdeps/kunstructuredfactory_test.go
+++ b/internal/k8sdeps/kunstructuredfactory_test.go
@@ -0,0 +1,124 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+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 k8sdeps
+
+import (
+	"reflect"
+	"testing"
+
+	"sigs.k8s.io/kustomize/pkg/ifc"
+)
+
+func TestSliceFromBytes(t *testing.T) {
+	factory := NewKustKunstructuredFactory(NewKustDecoder())
+	testConfigMap := factory.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "winnie",
+			},
+		})
+
+	tests := []struct {
+		name        string
+		input       []byte
+		expectedOut []ifc.Kunstructured
+		expectedErr bool
+	}{
+		{
+			name:        "garbage",
+			input:       []byte("garbageIn: garbageOut"),
+			expectedOut: []ifc.Kunstructured{},
+			expectedErr: true,
+		},
+		{
+			name:        "noBytes",
+			input:       []byte{},
+			expectedOut: []ifc.Kunstructured{},
+			expectedErr: false,
+		},
+		{
+			name: "goodJson",
+			input: []byte(`
+{"apiVersion":"v1","kind":"ConfigMap","metadata":{"name":"winnie"}}
+`),
+			expectedOut: []ifc.Kunstructured{testConfigMap},
+			expectedErr: false,
+		},
+		{
+			name: "goodYaml1",
+			input: []byte(`
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: winnie
+`),
+			expectedOut: []ifc.Kunstructured{testConfigMap},
+			expectedErr: false,
+		},
+		{
+			name: "goodYaml2",
+			input: []byte(`
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: winnie
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: winnie
+`),
+			expectedOut: []ifc.Kunstructured{testConfigMap, testConfigMap},
+			expectedErr: false,
+		},
+		{
+			name: "garbageInOneOfTwoObjects",
+			input: []byte(`
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: winnie
+---
+WOOOOOOOOOOOOOOOOOOOOOOOOT:  woot
+`),
+			expectedOut: []ifc.Kunstructured{},
+			expectedErr: true,
+		},
+	}
+
+	for _, test := range tests {
+		rs, err := factory.SliceFromBytes(test.input)
+		if test.expectedErr && err == nil {
+			t.Fatalf("%v: should return error", test.name)
+		}
+		if !test.expectedErr && err != nil {
+			t.Fatalf("%v: unexpected error: %s", test.name, err)
+		}
+		if len(rs) != len(test.expectedOut) {
+			t.Fatalf("%s: length mismatch %d != %d",
+				test.name, len(rs), len(test.expectedOut))
+		}
+		for i := range rs {
+			if !reflect.DeepEqual(test.expectedOut[i], rs[i]) {
+				t.Fatalf("%s: Got: %v\nexpected:%v",
+					test.name, test.expectedOut[i], rs[i])
+			}
+		}
+	}
+}
--- a/internal/k8sdeps/unstructadapter.go
+++ b/internal/k8sdeps/unstructadapter.go
@@ -1,9 +1,24 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+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 k8sdeps

 import (
 	"encoding/json"
 	"fmt"
-	"io"
 	"strings"

 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -37,35 +52,6 @@ func NewKunstructuredFromObject(obj runtime.Object) (ifc.Kunstructured, error) {
 	return &UnstructAdapter{Unstructured: u}, err
 }

-// NewKunstructuredFromMap returns a new instance of Kunstructured.
-func NewKunstructuredFromMap(m map[string]interface{}) ifc.Kunstructured {
-	return NewKunstructuredFromUnstruct(unstructured.Unstructured{Object: m})
-}
-
-// NewKunstructuredFromUnstruct returns a new instance of Kunstructured.
-func NewKunstructuredFromUnstruct(u unstructured.Unstructured) ifc.Kunstructured {
-	return &UnstructAdapter{Unstructured: u}
-}
-
-// NewKunstructuredSliceFromBytes unmarshalls bytes into a Kunstructured slice.
-func NewKunstructuredSliceFromBytes(
-	in []byte, decoder ifc.Decoder) ([]ifc.Kunstructured, error) {
-	decoder.SetInput(in)
-	var result []ifc.Kunstructured
-	var err error
-	for err == nil || isEmptyYamlError(err) {
-		var out unstructured.Unstructured
-		err = decoder.Decode(&out)
-		if err == nil {
-			result = append(result, &UnstructAdapter{Unstructured: out})
-		}
-	}
-	if err != io.EOF {
-		return nil, err
-	}
-	return result, nil
-}
-
 // GetGvk returns the Gvk name of the object.
 func (fs *UnstructAdapter) GetGvk() gvk.Gvk {
 	return gvk.FromSchemaGvk(fs.GroupVersionKind())
--- a/internal/k8sdeps/unstructadapter_test.go
+++ b/internal/k8sdeps/unstructadapter_test.go
@@ -1,113 +1,28 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+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 k8sdeps

 import (
-	"reflect"
-	"sigs.k8s.io/kustomize/pkg/ifc"
 	"testing"
 )

-var testConfigMap = NewKunstructuredFromMap(
-	map[string]interface{}{
-		"apiVersion": "v1",
-		"kind":       "ConfigMap",
-		"metadata": map[string]interface{}{
-			"name": "winnie",
-		},
-	})
-
-func TestNewKunstructuredSliceFromBytes(t *testing.T) {
-	tests := []struct {
-		name        string
-		input       []byte
-		expectedOut []ifc.Kunstructured
-		expectedErr bool
-	}{
-		{
-			name:        "garbage",
-			input:       []byte("garbageIn: garbageOut"),
-			expectedOut: []ifc.Kunstructured{},
-			expectedErr: true,
-		},
-		{
-			name:        "noBytes",
-			input:       []byte{},
-			expectedOut: []ifc.Kunstructured{},
-			expectedErr: false,
-		},
-		{
-			name: "goodJson",
-			input: []byte(`
-{"apiVersion":"v1","kind":"ConfigMap","metadata":{"name":"winnie"}}
-`),
-			expectedOut: []ifc.Kunstructured{testConfigMap},
-			expectedErr: false,
-		},
-		{
-			name: "goodYaml1",
-			input: []byte(`
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: winnie
-`),
-			expectedOut: []ifc.Kunstructured{testConfigMap},
-			expectedErr: false,
-		},
-		{
-			name: "goodYaml2",
-			input: []byte(`
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: winnie
---
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: winnie
-`),
-			expectedOut: []ifc.Kunstructured{testConfigMap, testConfigMap},
-			expectedErr: false,
-		},
-		{
-			name: "garbageInOneOfTwoObjects",
-			input: []byte(`
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: winnie
---
-WOOOOOOOOOOOOOOOOOOOOOOOOT:  woot
-`),
-			expectedOut: []ifc.Kunstructured{},
-			expectedErr: true,
-		},
-	}
-
-	for _, test := range tests {
-		rs, err := NewKunstructuredSliceFromBytes(
-			test.input, NewKustDecoder())
-		if test.expectedErr && err == nil {
-			t.Fatalf("%v: should return error", test.name)
-		}
-		if !test.expectedErr && err != nil {
-			t.Fatalf("%v: unexpected error: %s", test.name, err)
-		}
-		if len(rs) != len(test.expectedOut) {
-			t.Fatalf("%s: length mismatch %d != %d",
-				test.name, len(rs), len(test.expectedOut))
-		}
-		for i := range rs {
-			if !reflect.DeepEqual(test.expectedOut[i], rs[i]) {
-				t.Fatalf("%s: Got: %v\nexpected:%v",
-					test.name, test.expectedOut[i], rs[i])
-			}
-		}
-	}
-}
-
 func TestGetFieldValue(t *testing.T) {
-	funStruct := NewKunstructuredFromMap(map[string]interface{}{
+	factory := NewKustKunstructuredFactory(NewKustDecoder())
+	kunstructured := factory.FromMap(map[string]interface{}{
 		"Kind": "Service",
 		"metadata": map[string]interface{}{
 			"labels": map[string]string{
@@ -150,7 +65,7 @@ func TestGetFieldValue(t *testing.T) {
 	}

 	for _, test := range tests {
-		s, err := funStruct.GetFieldValue(test.pathToField)
+		s, err := kunstructured.GetFieldValue(test.pathToField)
 		if test.errorExpected && err == nil {
 			t.Fatalf("should return error, but no error returned")
 		} else {