Useful helper functions for Unstructured

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/BUILD

@@ -8,21 +8,29 @@ load(
 
 go_test(
     name = "go_default_test",
-    srcs = ["unstructured_test.go"],
+    srcs = [
+        "helpers_test.go",
+        "unstructured_list_test.go",
+    ],
     importpath = "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
     library = ":go_default_library",
-    deps = ["//vendor/github.com/stretchr/testify/assert:go_default_library"],
+    deps = [
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/github.com/stretchr/testify/require:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
 )
 
 go_library(
     name = "go_default_library",
     srcs = [
+        "helpers.go",
         "unstructured.go",
+        "unstructured_list.go",
         "zz_generated.deepcopy.go",
     ],
     importpath = "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
     deps = [
-        "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/conversion/unstructured:go_default_library",

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers_test.go

@@ -41,3 +41,20 @@ func TestCodecOfUnstructuredList(t *testing.T) {
 	}
 	wg.Wait()
 }
+
+func TestRemoveNestedField(t *testing.T) {
+	obj := map[string]interface{}{
+		"x": map[string]interface{}{
+			"y": 1,
+			"a": "foo",
+		},
+	}
+	RemoveNestedField(obj, "x", "a")
+	assert.Len(t, obj["x"], 1)
+	RemoveNestedField(obj, "x", "y")
+	assert.Empty(t, obj["x"])
+	RemoveNestedField(obj, "x")
+	assert.Empty(t, obj)
+	RemoveNestedField(obj, "x") // Remove of a non-existent field
+	assert.Empty(t, obj)
+}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go

@@ -20,8 +20,6 @@ import (
 	"bytes"
 	"fmt"
 
-	"github.com/golang/glog"
-
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/conversion/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -122,40 +120,48 @@ func (u *Unstructured) setNestedField(value interface{}, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedField(u.Object, value, fields...)
+	SetNestedField(u.Object, value, fields...)
 }
 
 func (u *Unstructured) setNestedSlice(value []string, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedSlice(u.Object, value, fields...)
+	SetNestedStringSlice(u.Object, value, fields...)
 }
 
 func (u *Unstructured) setNestedMap(value map[string]string, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedMap(u.Object, value, fields...)
+	SetNestedStringMap(u.Object, value, fields...)
 }
 
 func (u *Unstructured) GetOwnerReferences() []metav1.OwnerReference {
-	original, err := getOwnerReferences(u.Object)
-	if err != nil {
-		glog.V(6).Info(err)
+	field, ok := nestedFieldNoCopy(u.Object, "metadata", "ownerReferences")
+	if !ok {
+		return nil
+	}
+	original, ok := field.([]interface{})
+	if !ok {
 		return nil
 	}
 	ret := make([]metav1.OwnerReference, 0, len(original))
-	for i := 0; i < len(original); i++ {
-		ret = append(ret, extractOwnerReference(original[i]))
+	for _, obj := range original {
+		o, ok := obj.(map[string]interface{})
+		if !ok {
+			// expected map[string]interface{}, got something else
+			return nil
+		}
+		ret = append(ret, extractOwnerReference(o))
 	}
 	return ret
 }
 
 func (u *Unstructured) SetOwnerReferences(references []metav1.OwnerReference) {
-	var newReferences = make([]map[string]interface{}, 0, len(references))
-	for i := 0; i < len(references); i++ {
-		newReferences = append(newReferences, setOwnerReference(references[i]))
+	newReferences := make([]interface{}, 0, len(references))
+	for _, reference := range references {
+		newReferences = append(newReferences, setOwnerReference(reference))
 	}
 	u.setNestedField(newReferences, "metadata", "ownerReferences")
 }
@@ -217,7 +223,11 @@ func (u *Unstructured) SetResourceVersion(version string) {
 }
 
 func (u *Unstructured) GetGeneration() int64 {
-	return getNestedInt64(u.Object, "metadata", "generation")
+	val, ok := NestedInt64(u.Object, "metadata", "generation")
+	if !ok {
+		return 0
+	}
+	return val
 }
 
 func (u *Unstructured) SetGeneration(generation int64) {
@@ -262,7 +272,7 @@ func (u *Unstructured) GetDeletionTimestamp() *metav1.Time {
 
 func (u *Unstructured) SetDeletionTimestamp(timestamp *metav1.Time) {
 	if timestamp == nil {
-		u.setNestedField(nil, "metadata", "deletionTimestamp")
+		RemoveNestedField(u.Object, "metadata", "deletionTimestamp")
 		return
 	}
 	ts, _ := timestamp.MarshalQueryParameter()
@@ -270,15 +280,27 @@ func (u *Unstructured) SetDeletionTimestamp(timestamp *metav1.Time) {
 }
 
 func (u *Unstructured) GetDeletionGracePeriodSeconds() *int64 {
-	return getNestedInt64Pointer(u.Object, "metadata", "deletionGracePeriodSeconds")
+	val, ok := NestedInt64(u.Object, "metadata", "deletionGracePeriodSeconds")
+	if !ok {
+		return nil
+	}
+	return &val
 }
 
 func (u *Unstructured) SetDeletionGracePeriodSeconds(deletionGracePeriodSeconds *int64) {
-	u.setNestedField(deletionGracePeriodSeconds, "metadata", "deletionGracePeriodSeconds")
+	if deletionGracePeriodSeconds == nil {
+		RemoveNestedField(u.Object, "metadata", "deletionGracePeriodSeconds")
+		return
+	}
+	u.setNestedField(*deletionGracePeriodSeconds, "metadata", "deletionGracePeriodSeconds")
 }
 
 func (u *Unstructured) GetLabels() map[string]string {
-	return getNestedMap(u.Object, "metadata", "labels")
+	m, ok := NestedStringMap(u.Object, "metadata", "labels")
+	if !ok {
+		return nil
+	}
+	return m
 }
 
 func (u *Unstructured) SetLabels(labels map[string]string) {
@@ -286,7 +308,11 @@ func (u *Unstructured) SetLabels(labels map[string]string) {
 }
 
 func (u *Unstructured) GetAnnotations() map[string]string {
-	return getNestedMap(u.Object, "metadata", "annotations")
+	m, ok := NestedStringMap(u.Object, "metadata", "annotations")
+	if !ok {
+		return nil
+	}
+	return m
 }
 
 func (u *Unstructured) SetAnnotations(annotations map[string]string) {
@@ -308,12 +334,13 @@ func (u *Unstructured) GroupVersionKind() schema.GroupVersionKind {
 }
 
 func (u *Unstructured) GetInitializers() *metav1.Initializers {
-	field := getNestedField(u.Object, "metadata", "initializers")
-	if field == nil {
+	field, ok := nestedFieldNoCopy(u.Object, "metadata", "initializers")
+	if !ok {
 		return nil
 	}
 	obj, ok := field.(map[string]interface{})
 	if !ok {
+		// expected map[string]interface{}, got something else
 		return nil
 	}
 	out := &metav1.Initializers{}
@@ -324,22 +351,23 @@ func (u *Unstructured) GetInitializers() *metav1.Initializers {
 }
 
 func (u *Unstructured) SetInitializers(initializers *metav1.Initializers) {
-	if u.Object == nil {
-		u.Object = make(map[string]interface{})
-	}
 	if initializers == nil {
-		setNestedField(u.Object, nil, "metadata", "initializers")
+		RemoveNestedField(u.Object, "metadata", "initializers")
 		return
 	}
 	out, err := converter.ToUnstructured(initializers)
 	if err != nil {
 		utilruntime.HandleError(fmt.Errorf("unable to retrieve initializers for object: %v", err))
 	}
-	setNestedField(u.Object, out, "metadata", "initializers")
+	u.setNestedField(out, "metadata", "initializers")
 }
 
 func (u *Unstructured) GetFinalizers() []string {
-	return getNestedSlice(u.Object, "metadata", "finalizers")
+	val, ok := NestedStringSlice(u.Object, "metadata", "finalizers")
+	if !ok {
+		return nil
+	}
+	return val
 }
 
 func (u *Unstructured) SetFinalizers(finalizers []string) {

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured_list.go

@@ -161,5 +161,5 @@ func (u *UnstructuredList) setNestedField(value interface{}, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedField(u.Object, value, fields...)
+	SetNestedField(u.Object, value, fields...)
 }

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured_list_test.go

@@ -18,6 +18,11 @@ package unstructured
 
 import (
 	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestUnstructuredList(t *testing.T) {
@@ -29,12 +34,10 @@ func TestUnstructuredList(t *testing.T) {
 	}
 	content := list.UnstructuredContent()
 	items := content["items"].([]interface{})
-	if len(items) != 1 {
-		t.Fatalf("unexpected items: %#v", items)
-	}
-	if getNestedField(items[0].(map[string]interface{}), "metadata", "name") != "test" {
-		t.Fatalf("unexpected fields: %#v", items[0])
-	}
+	require.Len(t, items, 1)
+	val, ok := NestedFieldCopy(items[0].(map[string]interface{}), "metadata", "name")
+	require.True(t, ok)
+	assert.Equal(t, "test", val)
 }
 
 func TestNilDeletionTimestamp(t *testing.T) {
@@ -48,9 +51,14 @@ func TestNilDeletionTimestamp(t *testing.T) {
 	if del != nil {
 		t.Errorf("unexpected non-nil deletion timestamp: %v", del)
 	}
+	_, ok := u.Object["metadata"]
+	assert.False(t, ok)
+
+	now := metav1.Now()
+	u.SetDeletionTimestamp(&now)
+	assert.Equal(t, now.Unix(), u.GetDeletionTimestamp().Unix())
+	u.SetDeletionTimestamp(nil)
 	metadata := u.Object["metadata"].(map[string]interface{})
-	deletionTimestamp := metadata["deletionTimestamp"]
-	if deletionTimestamp != nil {
-		t.Errorf("unexpected deletion timestamp field: %q", deletionTimestamp)
-	}
+	_, ok = metadata["deletionTimestamp"]
+	assert.False(t, ok)
 }

staging/src/k8s.io/apimachinery/pkg/conversion/unstructured/converter.go

@@ -426,21 +426,23 @@ func (c *converterImpl) ToUnstructured(obj interface{}) (map[string]interface{},
 // DeepCopyJSON deep copies the passed value, assuming it is a valid JSON representation i.e. only contains
 // types produced by json.Unmarshal().
 func DeepCopyJSON(x map[string]interface{}) map[string]interface{} {
-	return deepCopyJSON(x).(map[string]interface{})
+	return DeepCopyJSONValue(x).(map[string]interface{})
 }
 
-func deepCopyJSON(x interface{}) interface{} {
+// DeepCopyJSONValue deep copies the passed value, assuming it is a valid JSON representation i.e. only contains
+// types produced by json.Unmarshal().
+func DeepCopyJSONValue(x interface{}) interface{} {
 	switch x := x.(type) {
 	case map[string]interface{}:
 		clone := make(map[string]interface{}, len(x))
 		for k, v := range x {
-			clone[k] = deepCopyJSON(v)
+			clone[k] = DeepCopyJSONValue(v)
 		}
 		return clone
 	case []interface{}:
 		clone := make([]interface{}, len(x))
 		for i, v := range x {
-			clone[i] = deepCopyJSON(v)
+			clone[i] = DeepCopyJSONValue(v)
 		}
 		return clone
 	case string, int64, bool, float64, nil, encodingjson.Number:

staging/src/k8s.io/apimachinery/pkg/test/apis_meta_v1_unstructed_unstructure_test.go

@@ -84,6 +84,7 @@ func TestDecode(t *testing.T) {
 			json: []byte(`{"apiVersion": "test", "kind": "test_list", "items": []}`),
 			want: &unstructured.UnstructuredList{
 				Object: map[string]interface{}{"apiVersion": "test", "kind": "test_list"},
+				Items:  []unstructured.Unstructured{},
 			},
 		},
 		{
@@ -147,14 +148,14 @@ func TestUnstructuredGetters(t *testing.T) {
 				"annotations": map[string]interface{}{
 					"test_annotation": "test_value",
 				},
-				"ownerReferences": []map[string]interface{}{
-					{
+				"ownerReferences": []interface{}{
+					map[string]interface{}{
 						"kind":       "Pod",
 						"name":       "poda",
 						"apiVersion": "v1",
 						"uid":        "1",
 					},
-					{
+					map[string]interface{}{
 						"kind":       "Pod",
 						"name":       "podb",
 						"apiVersion": "v1",
@@ -273,7 +274,7 @@ func TestUnstructuredSetters(t *testing.T) {
 				"selfLink":                   "test_selfLink",
 				"creationTimestamp":          "2009-11-10T23:00:00Z",
 				"deletionTimestamp":          "2010-11-10T23:00:00Z",
-				"deletionGracePeriodSeconds": &ten,
+				"deletionGracePeriodSeconds": ten,
 				"generation":                 ten,
 				"labels": map[string]interface{}{
 					"test_label": "test_value",
@@ -281,14 +282,14 @@ func TestUnstructuredSetters(t *testing.T) {
 				"annotations": map[string]interface{}{
 					"test_annotation": "test_value",
 				},
-				"ownerReferences": []map[string]interface{}{
-					{
+				"ownerReferences": []interface{}{
+					map[string]interface{}{
 						"kind":       "Pod",
 						"name":       "poda",
 						"apiVersion": "v1",
 						"uid":        "1",
 					},
-					{
+					map[string]interface{}{
 						"kind":               "Pod",
 						"name":               "podb",
 						"apiVersion":         "v1",