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.go

@@ -31,171 +31,263 @@ import (
 	"k8s.io/apimachinery/pkg/util/json"
 )
 
-func getNestedField(obj map[string]interface{}, fields ...string) interface{} {
+// NestedFieldCopy returns a deep copy of the value of a nested field.
+// false is returned if the value is missing.
+// nil, true is returned for a nil field.
+func NestedFieldCopy(obj map[string]interface{}, fields ...string) (interface{}, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	return unstructured.DeepCopyJSONValue(val), true
+}
+
+func nestedFieldNoCopy(obj map[string]interface{}, fields ...string) (interface{}, bool) {
 	var val interface{} = obj
 	for _, field := range fields {
-		if _, ok := val.(map[string]interface{}); !ok {
-			return nil
+		if m, ok := val.(map[string]interface{}); ok {
+			val, ok = m[field]
+			if !ok {
+				return nil, false
+			}
+		} else {
+			// Expected map[string]interface{}, got something else
+			return nil, false
 		}
-		val = val.(map[string]interface{})[field]
 	}
-	return val
+	return val, true
 }
 
-func getNestedString(obj map[string]interface{}, fields ...string) string {
-	if str, ok := getNestedField(obj, fields...).(string); ok {
-		return str
+// NestedString returns the string value of a nested field.
+// Returns false if value is not found or is not a string.
+func NestedString(obj map[string]interface{}, fields ...string) (string, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return "", false
 	}
-	return ""
+	s, ok := val.(string)
+	return s, ok
 }
 
-func getNestedInt64(obj map[string]interface{}, fields ...string) int64 {
-	if str, ok := getNestedField(obj, fields...).(int64); ok {
-		return str
+// NestedBool returns the bool value of a nested field.
+// Returns false if value is not found or is not a bool.
+func NestedBool(obj map[string]interface{}, fields ...string) (bool, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return false, false
 	}
-	return 0
+	b, ok := val.(bool)
+	return b, ok
 }
 
-func getNestedInt64Pointer(obj map[string]interface{}, fields ...string) *int64 {
-	nested := getNestedField(obj, fields...)
-	switch n := nested.(type) {
-	case int64:
-		return &n
-	case *int64:
-		return n
-	default:
-		return nil
+// NestedFloat64 returns the bool value of a nested field.
+// Returns false if value is not found or is not a float64.
+func NestedFloat64(obj map[string]interface{}, fields ...string) (float64, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return 0, false
 	}
+	f, ok := val.(float64)
+	return f, ok
 }
 
-func getNestedSlice(obj map[string]interface{}, fields ...string) []string {
-	if m, ok := getNestedField(obj, fields...).([]interface{}); ok {
+// NestedInt64 returns the int64 value of a nested field.
+// Returns false if value is not found or is not an int64.
+func NestedInt64(obj map[string]interface{}, fields ...string) (int64, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return 0, false
+	}
+	i, ok := val.(int64)
+	return i, ok
+}
+
+// NestedStringSlice returns a copy of []string value of a nested field.
+// Returns false if value is not found, is not a []interface{} or contains non-string items in the slice.
+func NestedStringSlice(obj map[string]interface{}, fields ...string) ([]string, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if m, ok := val.([]interface{}); ok {
 		strSlice := make([]string, 0, len(m))
 		for _, v := range m {
 			if str, ok := v.(string); ok {
 				strSlice = append(strSlice, str)
+			} else {
+				return nil, false
 			}
 		}
-		return strSlice
+		return strSlice, true
 	}
-	return nil
+	return nil, false
 }
 
-func getNestedMap(obj map[string]interface{}, fields ...string) map[string]string {
-	if m, ok := getNestedField(obj, fields...).(map[string]interface{}); ok {
+// NestedSlice returns a deep copy of []interface{} value of a nested field.
+// Returns false if value is not found or is not a []interface{}.
+func NestedSlice(obj map[string]interface{}, fields ...string) ([]interface{}, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if _, ok := val.([]interface{}); ok {
+		return unstructured.DeepCopyJSONValue(val).([]interface{}), true
+	}
+	return nil, false
+}
+
+// NestedStringMap returns a copy of map[string]string value of a nested field.
+// Returns false if value is not found, is not a map[string]interface{} or contains non-string values in the map.
+func NestedStringMap(obj map[string]interface{}, fields ...string) (map[string]string, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if m, ok := val.(map[string]interface{}); ok {
 		strMap := make(map[string]string, len(m))
 		for k, v := range m {
 			if str, ok := v.(string); ok {
 				strMap[k] = str
+			} else {
+				return nil, false
 			}
 		}
-		return strMap
+		return strMap, true
 	}
-	return nil
+	return nil, false
 }
 
-func setNestedField(obj map[string]interface{}, value interface{}, fields ...string) {
+// NestedMap returns a deep copy of map[string]interface{} value of a nested field.
+// Returns false if value is not found or is not a map[string]interface{}.
+func NestedMap(obj map[string]interface{}, fields ...string) (map[string]interface{}, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if m, ok := val.(map[string]interface{}); ok {
+		return unstructured.DeepCopyJSON(m), true
+	}
+	return nil, false
+}
+
+// SetNestedField sets the value of a nested field to a deep copy of the value provided.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedField(obj map[string]interface{}, value interface{}, fields ...string) bool {
+	return setNestedFieldNoCopy(obj, unstructured.DeepCopyJSONValue(value), fields...)
+}
+
+func setNestedFieldNoCopy(obj map[string]interface{}, value interface{}, fields ...string) bool {
 	m := obj
-	if len(fields) > 1 {
-		for _, field := range fields[0 : len(fields)-1] {
-			if _, ok := m[field].(map[string]interface{}); !ok {
-				m[field] = make(map[string]interface{})
+	for _, field := range fields[:len(fields)-1] {
+		if val, ok := m[field]; ok {
+			if valMap, ok := val.(map[string]interface{}); ok {
+				m = valMap
+			} else {
+				return false
 			}
-			m = m[field].(map[string]interface{})
+		} else {
+			newVal := make(map[string]interface{})
+			m[field] = newVal
+			m = newVal
 		}
 	}
 	m[fields[len(fields)-1]] = value
+	return true
 }
 
-func setNestedSlice(obj map[string]interface{}, value []string, fields ...string) {
-	m := make([]interface{}, 0, len(value))
+// SetNestedStringSlice sets the string slice value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedStringSlice(obj map[string]interface{}, value []string, fields ...string) bool {
+	m := make([]interface{}, 0, len(value)) // convert []string into []interface{}
 	for _, v := range value {
 		m = append(m, v)
 	}
-	setNestedField(obj, m, fields...)
+	return setNestedFieldNoCopy(obj, m, fields...)
 }
 
-func setNestedMap(obj map[string]interface{}, value map[string]string, fields ...string) {
-	m := make(map[string]interface{}, len(value))
+// SetNestedSlice sets the slice value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedSlice(obj map[string]interface{}, value []interface{}, fields ...string) bool {
+	return SetNestedField(obj, value, fields...)
+}
+
+// SetNestedStringMap sets the map[string]string value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedStringMap(obj map[string]interface{}, value map[string]string, fields ...string) bool {
+	m := make(map[string]interface{}, len(value)) // convert map[string]string into map[string]interface{}
 	for k, v := range value {
 		m[k] = v
 	}
-	setNestedField(obj, m, fields...)
+	return setNestedFieldNoCopy(obj, m, fields...)
 }
 
-func extractOwnerReference(src interface{}) metav1.OwnerReference {
-	v := src.(map[string]interface{})
+// SetNestedMap sets the map[string]interface{} value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedMap(obj map[string]interface{}, value map[string]interface{}, fields ...string) bool {
+	return SetNestedField(obj, value, fields...)
+}
+
+// RemoveNestedField removes the nested field from the obj.
+func RemoveNestedField(obj map[string]interface{}, fields ...string) {
+	m := obj
+	for _, field := range fields[:len(fields)-1] {
+		if x, ok := m[field].(map[string]interface{}); ok {
+			m = x
+		} else {
+			return
+		}
+	}
+	delete(m, fields[len(fields)-1])
+}
+
+func getNestedString(obj map[string]interface{}, fields ...string) string {
+	val, ok := NestedString(obj, fields...)
+	if !ok {
+		return ""
+	}
+	return val
+}
+
+func extractOwnerReference(v map[string]interface{}) metav1.OwnerReference {
 	// though this field is a *bool, but when decoded from JSON, it's
 	// unmarshalled as bool.
 	var controllerPtr *bool
-	controller, ok := (getNestedField(v, "controller")).(bool)
-	if !ok {
-		controllerPtr = nil
-	} else {
-		controllerCopy := controller
-		controllerPtr = &controllerCopy
+	if controller, ok := NestedBool(v, "controller"); ok {
+		controllerPtr = &controller
 	}
 	var blockOwnerDeletionPtr *bool
-	blockOwnerDeletion, ok := (getNestedField(v, "blockOwnerDeletion")).(bool)
-	if !ok {
-		blockOwnerDeletionPtr = nil
-	} else {
-		blockOwnerDeletionCopy := blockOwnerDeletion
-		blockOwnerDeletionPtr = &blockOwnerDeletionCopy
+	if blockOwnerDeletion, ok := NestedBool(v, "blockOwnerDeletion"); ok {
+		blockOwnerDeletionPtr = &blockOwnerDeletion
 	}
 	return metav1.OwnerReference{
 		Kind:               getNestedString(v, "kind"),
 		Name:               getNestedString(v, "name"),
 		APIVersion:         getNestedString(v, "apiVersion"),
-		UID:                (types.UID)(getNestedString(v, "uid")),
+		UID:                types.UID(getNestedString(v, "uid")),
 		Controller:         controllerPtr,
 		BlockOwnerDeletion: blockOwnerDeletionPtr,
 	}
 }
 
 func setOwnerReference(src metav1.OwnerReference) map[string]interface{} {
-	ret := make(map[string]interface{})
-	setNestedField(ret, src.Kind, "kind")
-	setNestedField(ret, src.Name, "name")
-	setNestedField(ret, src.APIVersion, "apiVersion")
-	setNestedField(ret, string(src.UID), "uid")
+	ret := map[string]interface{}{
+		"kind":       src.Kind,
+		"name":       src.Name,
+		"apiVersion": src.APIVersion,
+		"uid":        string(src.UID),
+	}
 	// json.Unmarshal() extracts boolean json fields as bool, not as *bool and hence extractOwnerReference()
 	// expects bool or a missing field, not *bool. So if pointer is nil, fields are omitted from the ret object.
 	// If pointer is non-nil, they are set to the referenced value.
 	if src.Controller != nil {
-		setNestedField(ret, *src.Controller, "controller")
+		ret["controller"] = *src.Controller
 	}
 	if src.BlockOwnerDeletion != nil {
-		setNestedField(ret, *src.BlockOwnerDeletion, "blockOwnerDeletion")
+		ret["blockOwnerDeletion"] = *src.BlockOwnerDeletion
 	}
 	return ret
 }
 
-func getOwnerReferences(object map[string]interface{}) ([]map[string]interface{}, error) {
-	field := getNestedField(object, "metadata", "ownerReferences")
-	if field == nil {
-		return nil, fmt.Errorf("cannot find field metadata.ownerReferences in %v", object)
-	}
-	ownerReferences, ok := field.([]map[string]interface{})
-	if ok {
-		return ownerReferences, nil
-	}
-	// TODO: This is hacky...
-	interfaces, ok := field.([]interface{})
-	if !ok {
-		return nil, fmt.Errorf("expect metadata.ownerReferences to be a slice in %#v", object)
-	}
-	ownerReferences = make([]map[string]interface{}, 0, len(interfaces))
-	for i := 0; i < len(interfaces); i++ {
-		r, ok := interfaces[i].(map[string]interface{})
-		if !ok {
-			return nil, fmt.Errorf("expect element metadata.ownerReferences to be a map[string]interface{} in %#v", object)
-		}
-		ownerReferences = append(ownerReferences, r)
-	}
-	return ownerReferences, nil
-}
-
 var converter = unstructured.NewConverter(false)
 
 // UnstructuredJSONScheme is capable of converting JSON data into the Unstructured
@@ -230,7 +322,7 @@ func (unstructuredJSONScheme) Encode(obj runtime.Object, w io.Writer) error {
 	case *Unstructured:
 		return json.NewEncoder(w).Encode(t.Object)
 	case *UnstructuredList:
-		items := make([]map[string]interface{}, 0, len(t.Items))
+		items := make([]interface{}, 0, len(t.Items))
 		for _, i := range t.Items {
 			items = append(items, i.Object)
 		}
@@ -319,7 +411,7 @@ func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList
 	itemKind := strings.TrimSuffix(listKind, "List")
 
 	delete(list.Object, "items")
-	list.Items = nil
+	list.Items = make([]Unstructured, 0, len(dList.Items))
 	for _, i := range dList.Items {
 		unstruct := &Unstructured{}
 		if err := s.decodeToUnstructured([]byte(i), unstruct); err != nil {

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",