wip

Signed-off-by: Attila Mészáros <a_meszaros@apple.com>

Author: csviri

operator-framework/src/test/java/io/javaoperatorsdk/operator/config/runtime/ControllerConfigurationAnnotationProcessorTest.java

@@ -15,6 +15,9 @@
  */
 package io.javaoperatorsdk.operator.config.runtime;
 
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
 import javax.tools.StandardLocation;
 
 import org.junit.jupiter.api.Test;
@@ -25,6 +28,7 @@
 import com.google.testing.compile.JavaFileObjects;
 
 import static io.javaoperatorsdk.operator.config.runtime.RuntimeControllerMetadata.RECONCILERS_RESOURCE_PATH;
+import static org.assertj.core.api.Assertions.assertThat;
 
 class ControllerConfigurationAnnotationProcessorTest {
 
@@ -70,6 +74,26 @@ public void generateDoneableClassWithMultilevelHierarchy() {
     assertMapping(compilation, "io.MultilevelReconciler,io.MultilevelReconciler.MyCustomResource");
   }
 
+  /**
+   * When the reconciled resource is itself generic, the resolved type is a parameterized {@code
+   * DeclaredType}. Only its erasure may be written to the mapping resource: {@link
+   * ClassMappingProvider} loads the recorded name with {@code ClassUtils.getClass(String)}, which
+   * cannot parse type arguments.
+   */
+  @Test
+  public void writesErasureOfGenericResourceType() {
+    Compilation compilation =
+        Compiler.javac()
+            .withProcessors(new ControllerConfigurationAnnotationProcessor())
+            .compile(
+                JavaFileObjects.forResource("compile-fixtures/GenericResourceReconciler.java"));
+    CompilationSubject.assertThat(compilation).succeeded();
+    assertMapping(
+        compilation,
+        "io.GenericResourceReconciler,io.GenericResourceReconciler.MyGenericCustomResource");
+    assertLoadableMapping(compilation);
+  }
+
   /**
    * Checks that the generated mapping resource contains the expected {@code
    * reconciler,resource-class} line, using the same fully qualified, dot separated names that
@@ -81,4 +105,40 @@ private static void assertMapping(Compilation compilation, String expectedMappin
         .contentsAsUtf8String()
         .contains(expectedMapping);
   }
+
+  /**
+   * Checks that every recorded name in the generated mapping resource is a plain binary-ish class
+   * name, i.e. one that {@code ClassUtils.getClass(String)} can actually resolve, rather than a
+   * generic type signature such as {@code io.Foo<java.lang.String>}.
+   */
+  private static void assertLoadableMapping(Compilation compilation) {
+    final var contents =
+        compilation
+            .generatedFile(StandardLocation.CLASS_OUTPUT, RECONCILERS_RESOURCE_PATH)
+            .map(
+                file -> {
+                  try {
+                    return file.getCharContent(true).toString();
+                  } catch (IOException e) {
+                    throw new UncheckedIOException(e);
+                  }
+                })
+            .orElseThrow(() -> new AssertionError("no mapping resource was generated"));
+    contents
+        .lines()
+        .filter(line -> !line.isBlank())
+        .forEach(
+            line -> {
+              final var names = line.split(",");
+              assertThat(names).as("mapping line '%s'", line).hasSize(2);
+              for (String name : names) {
+                assertThat(name)
+                    .as("recorded class name '%s' must be loadable at runtime", name)
+                    .doesNotContain("<")
+                    .doesNotContain(">")
+                    .doesNotContain(" ")
+                    .matches("[\\p{L}_$][\\p{L}\\p{N}_$]*(\\.[\\p{L}_$][\\p{L}\\p{N}_$]*)*");
+              }
+            });
+  }
 }