fix: allow to deserialize multi-resource json documents (#855)

Signed-off-by: Andre Dietisheim <[email protected]>

Author: adietish

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/editor/EditorResourceSerialization.kt

@@ -10,6 +10,8 @@
  ******************************************************************************/
 package com.redhat.devtools.intellij.kubernetes.editor
 
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.node.ArrayNode
 import com.intellij.json.JsonFileType
 import com.intellij.openapi.fileTypes.FileType
 import com.redhat.devtools.intellij.kubernetes.model.util.ResourceException
@@ -22,7 +24,6 @@ import org.jetbrains.yaml.YAMLFileType
 object EditorResourceSerialization {
 
     const val RESOURCE_SEPARATOR_YAML = "\n---"
-    private const val RESOURCE_SEPARATOR_JSON = ",\n"
 
     /**
      * Returns a list of [HasMetadata] for a given yaml or json string.
@@ -41,32 +42,62 @@ object EditorResourceSerialization {
      * @see JsonFileType.INSTANCE
      */
     fun deserialize(jsonYaml: String?, fileType: FileType?, currentNamespace: String?): List<HasMetadata> {
-        return if (jsonYaml == null
-            || !isSupported(fileType)) {
-            emptyList()
-        } else {
-            val resources = jsonYaml
-                .split(RESOURCE_SEPARATOR_YAML)
-                .filter { jsonYaml -> jsonYaml.isNotBlank() }
-            if (resources.size > 1
-                && YAMLFileType.YML != fileType) {
-                throw ResourceException(
-                    "${fileType?.name ?: "File type"} is not supported for multi-resource documents. Only ${YAMLFileType.YML.name} is.")
+        return try {
+            when {
+                jsonYaml == null ->
+                    emptyList()
+
+                YAMLFileType.YML == fileType ->
+                    yaml2Resources(jsonYaml, currentNamespace)
+
+                JsonFileType.INSTANCE == fileType ->
+                    json2Resources(jsonYaml, currentNamespace)
+
+                else ->
+                    emptyList()
+            }
+        } catch (e: RuntimeException) {
+            throw ResourceException("Invalid kubernetes yaml/json", e.cause ?: e)
+        }
+    }
+
+    private fun yaml2Resources(yaml: String, currentNamespace: String?): List<HasMetadata> {
+        val resources = yaml
+            .split(RESOURCE_SEPARATOR_YAML)
+            .filter { yaml ->
+                yaml.isNotBlank()
+            }
+        return resources
+            .map { yaml ->
+                setMissingNamespace(currentNamespace, createResource<GenericKubernetesResource>(yaml))
             }
-            try {
-                resources
-                    .map { jsonYaml ->
-                        setMissingNamespace(currentNamespace, createResource<GenericKubernetesResource>(jsonYaml))
+            .toList()
+    }
+
+    private fun json2Resources(json: String?, currentNamespace: String?): List<HasMetadata> {
+        val mapper = ObjectMapper()
+        val rootNode = mapper.readTree(json)
+        return when {
+            rootNode.isArray ->
+                (rootNode as ArrayNode)
+                    .mapNotNull { node ->
+                        setMissingNamespace(currentNamespace, mapper.treeToValue(node, GenericKubernetesResource::class.java))
                     }
                     .toList()
-            } catch (e: RuntimeException) {
-                throw ResourceException("Invalid kubernetes yaml/json", e.cause ?: e)
-            }
+            rootNode.isObject ->
+                listOf(
+                    setMissingNamespace(currentNamespace,
+                        mapper.treeToValue(rootNode, GenericKubernetesResource::class.java)
+                    )
+                )
+            else ->
+                emptyList()
         }
     }
 
     private fun setMissingNamespace(namespace: String?, resource: HasMetadata): HasMetadata {
-        if (resource.metadata.namespace.isNullOrEmpty()
+        if (resource.metadata != null
+            && resource.metadata.namespace.isNullOrEmpty()
             && namespace != null) {
             resource.metadata.namespace = namespace
         }

src/test/kotlin/com/redhat/devtools/intellij/kubernetes/editor/EditorResourceSerializationTest.kt

@@ -14,10 +14,12 @@ import com.intellij.json.JsonFileType
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.redhat.devtools.intellij.kubernetes.model.mocks.ClientMocks.resource
 import com.redhat.devtools.intellij.kubernetes.model.util.ResourceException
+import io.fabric8.kubernetes.api.model.HasMetadata
 import io.fabric8.kubernetes.api.model.Pod
 import io.fabric8.kubernetes.client.utils.Serialization
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.assertj.core.api.Assertions.tuple
 import org.jetbrains.yaml.YAMLFileType
 import org.junit.Test
 
@@ -57,19 +59,20 @@ class EditorResourceSerializationTest {
     }
 
     @Test
-    fun `#deserialize throws if given multiple json resources`() {
+    fun `#deserialize returns list of resources if given multiple JSON resources`() {
         // given
         val json = """
-            {"apiVersion": "v1", "kind": "Pod"}
-            ---
-            {"apiVersion": "v1", "kind": "Service"}
+            [
+                {"apiVersion": "v1", "kind": "Pod"},
+                {"apiVersion": "v1", "kind": "Service"}
+            ]
         """.trimIndent()
-
-        assertThatThrownBy {
-            // when
-            EditorResourceSerialization.deserialize(json, JsonFileType.INSTANCE, null)
-            // then
-        }.isInstanceOf(ResourceException::class.java)
+        val deserialized = EditorResourceSerialization.deserialize(json, JsonFileType.INSTANCE, null)
+        assertThat(deserialized)
+            .extracting(HasMetadata::getKind, HasMetadata::getApiVersion)
+            .containsExactlyInAnyOrder(
+                tuple("Pod", "v1"),
+                tuple("Service", "v1"))
     }
 
     @Test