Remove more type assertions

Some of these may be bordering on paranoia, and my search was not
totally exhaustive... but this should make me feel a little bit safer.

Signed-off-by: Justin Kulikauskas <jkulikau@redhat.com>

controllers/configurationpolicy_controller.go

@@ -1978,7 +1978,7 @@ func buildNameList(
 		}
 
 		if match {
-			kindNameList = append(kindNameList, uObj.Object["metadata"].(map[string]interface{})["name"].(string))
+			kindNameList = append(kindNameList, uObj.GetName())
 		}
 	}
 
@@ -2594,10 +2594,15 @@ func (r *ConfigurationPolicyReconciler) checkAndUpdateResource(
 
 		// only look at labels and annotations for metadata - configurationPolicies do not update other metadata fields
 		if key == "metadata" {
-			mergedAnnotations := mergedObj.(map[string]interface{})["annotations"]
-			mergedLabels := mergedObj.(map[string]interface{})["labels"]
-			obj.object.UnstructuredContent()["metadata"].(map[string]interface{})["annotations"] = mergedAnnotations
-			obj.object.UnstructuredContent()["metadata"].(map[string]interface{})["labels"] = mergedLabels
+			// if it's not the right type, the map will be empty
+			mdMap, _ := mergedObj.(map[string]interface{})
+
+			// if either isn't found, they'll just be empty
+			mergedAnnotations, _, _ := unstructured.NestedStringMap(mdMap, "annotations")
+			mergedLabels, _, _ := unstructured.NestedStringMap(mdMap, "labels")
+
+			obj.object.SetAnnotations(mergedAnnotations)
+			obj.object.SetLabels(mergedLabels)
 		} else {
 			obj.object.UnstructuredContent()[key] = mergedObj
 		}

controllers/configurationpolicy_utils.go

@@ -68,17 +68,13 @@ func addRelatedObjects(
 // unmarshalFromJSON unmarshals raw JSON data into an object
 func unmarshalFromJSON(rawData []byte) (unstructured.Unstructured, error) {
 	var unstruct unstructured.Unstructured
-	var blob interface{}
 
-	if jsonErr := json.Unmarshal(rawData, &blob); jsonErr != nil {
+	if jsonErr := json.Unmarshal(rawData, &unstruct.Object); jsonErr != nil {
 		log.Error(jsonErr, "Could not unmarshal data from JSON")
 
 		return unstruct, jsonErr
 	}
 
-	unstruct.Object = make(map[string]interface{})
-	unstruct.Object = blob.(map[string]interface{})
-
 	return unstruct, nil
 }
 
@@ -113,13 +109,17 @@ func updateRelatedObjectsStatus(
 func equalObjWithSort(mergedObj interface{}, oldObj interface{}) (areEqual bool) {
 	switch mergedObj := mergedObj.(type) {
 	case map[string]interface{}:
-		if oldObj == nil || !checkFieldsWithSort(mergedObj, oldObj.(map[string]interface{})) {
-			return false
+		if oldObjMap, ok := oldObj.(map[string]interface{}); ok {
+			return checkFieldsWithSort(mergedObj, oldObjMap)
 		}
+		// this includes the case where oldObj is nil
+		return false
 	case []interface{}:
-		if oldObj == nil || !checkListsMatch(mergedObj, oldObj.([]interface{})) {
-			return false
+		if oldObjList, ok := oldObj.([]interface{}); ok {
+			return checkListsMatch(mergedObj, oldObjList)
 		}
+
+		return false
 	default:
 		// NOTE: when type is string, int, bool
 		var oVal interface{}
@@ -243,15 +243,18 @@ func checkListFieldsWithSort(mergedObj []map[string]interface{}, oldObj []map[st
 			switch mVal := mVal.(type) {
 			case []interface{}:
 				// if a map in the list contains a nested list, sort and check for equality
-				oVal, ok := oldItem[i].([]interface{})
-				if !ok || len(mVal) != len(oVal) || !checkListsMatch(oVal, mVal) {
-					return false
+				if oVal, ok := oldItem[i].([]interface{}); ok {
+					return len(mVal) == len(oVal) && checkListsMatch(oVal, mVal)
 				}
+
+				return false
 			case map[string]interface{}:
 				// if a map in the list contains another map, check fields for equality
-				if !checkFieldsWithSort(mVal, oldItem[i].(map[string]interface{})) {
-					return false
+				if oVal, ok := oldItem[i].(map[string]interface{}); ok {
+					return len(mVal) == len(oVal) && checkFieldsWithSort(mVal, oVal)
 				}
+
+				return false
 			case string:
 				// extra check to see if value is a byte value
 				mQty, err := apiRes.ParseQuantity(mVal)
@@ -308,9 +311,11 @@ func checkListsMatch(oldVal []interface{}, mergedVal []interface{}) (m bool) {
 		switch oNestedVal := oNestedVal.(type) {
 		case map[string]interface{}:
 			// if list contains maps, recurse on those maps to check for a match
-			if !checkFieldsWithSort(mVal[idx].(map[string]interface{}), oNestedVal) {
-				return false
+			if mVal, ok := mVal[idx].(map[string]interface{}); ok {
+				return len(mVal) == len(oNestedVal) && checkFieldsWithSort(mVal, oNestedVal)
 			}
+
+			return false
 		default:
 			// otherwise, just do a generic check
 			if fmt.Sprint(oNestedVal) != fmt.Sprint(mVal[idx]) {
@@ -338,8 +343,10 @@ func filterUnwantedAnnotations(input map[string]interface{}) map[string]interfac
 // formatTemplate returns the value of the input key in a manner that the controller can use for comparisons.
 func formatTemplate(unstruct unstructured.Unstructured, key string) (obj interface{}) {
 	if key == "metadata" {
-		//nolint:forcetypeassert
-		metadata := unstruct.Object[key].(map[string]interface{})
+		metadata, ok := unstruct.Object[key].(map[string]interface{})
+		if !ok {
+			return metadata // it will just be empty
+		}
 
 		return formatMetadata(metadata)
 	}