Test annotation processor works correctly when an intermediary class exists.

Author: Soroosh Sarabadani

operator-framework/src/main/java/io/javaoperatorsdk/operator/processing/ControllerAnnotationProcessor.java

@@ -18,6 +18,8 @@
 import javax.tools.JavaFileObject;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 
 @SupportedAnnotationTypes(
@@ -32,40 +34,36 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
                     = roundEnv.getElementsAnnotatedWith(annotation);
             annotatedElements.stream().filter(element -> element instanceof Symbol.ClassSymbol)
                     .map(e -> (Symbol.ClassSymbol) e)
-                    .forEach(controllerClassSymbol -> generateDoneableClass(controllerClassSymbol));
+                    .forEach(this::generateDoneableClass);
         }
         return false;
     }
 
     private void generateDoneableClass(Symbol.ClassSymbol controllerClassSymbol) {
         try {
-            // TODO: the resourceType retrieval logic is currently very fragile, done for testing purposes and need to be improved to cover all possible conditions
-            final Type controllerType = controllerClassSymbol
-                    .getInterfaces()
-                    .stream()
-                    .filter(i -> i.toString()
-                            .startsWith(ResourceController.class.getCanonicalName())
-                    )
-                    .findFirst()
-                    .orElseThrow(() -> new Exception("ResourceController is not implemented by " + controllerClassSymbol.toString()));
+            final TypeMirror resourceType = findResourceType(controllerClassSymbol);
+            Symbol.ClassSymbol customerResourceSymbol = (Symbol.ClassSymbol) processingEnv
+                    .getElementUtils()
+                    .getTypeElement(resourceType.toString());
 
-            final TypeMirror resourceType = controllerType.getTypeArguments().get(0);
-            Symbol.ClassSymbol customerResourceSymbol = (Symbol.ClassSymbol) processingEnv.getElementUtils().getTypeElement(resourceType.toString());
             JavaFileObject builderFile = processingEnv.getFiler()
                     .createSourceFile(customerResourceSymbol.className() + "Doneable");
+
             try (PrintWriter out = new PrintWriter(builderFile.openWriter())) {
                 final MethodSpec constructor = MethodSpec.constructorBuilder()
                         .addModifiers(Modifier.PUBLIC)
                         .addParameter(TypeName.get(resourceType), "resource")
                         .addParameter(Function.class, "function")
                         .addStatement("super(resource,function)")
                         .build();
+
                 final TypeSpec typeSpec = TypeSpec.classBuilder(customerResourceSymbol.name + "Doneable")
                         .addAnnotation(RegisterForReflection.class)
                         .superclass(ParameterizedTypeName.get(ClassName.get(CustomResourceDoneable.class), TypeName.get(resourceType)))
                         .addModifiers(Modifier.PUBLIC)
                         .addMethod(constructor)
                         .build();
+
                 JavaFile file = JavaFile.builder(customerResourceSymbol.packge().fullname.toString(), typeSpec)
                         .build();
                 file.writeTo(out);
@@ -76,4 +74,29 @@ private void generateDoneableClass(Symbol.ClassSymbol controllerClassSymbol) {
             ex.printStackTrace();
         }
     }
+
+    private TypeMirror findResourceType(Symbol.ClassSymbol controllerClassSymbol) throws Exception {
+        final Type controllerType = collectAllInterfaces(controllerClassSymbol)
+                .stream()
+                .filter(i -> i.toString()
+                        .startsWith(ResourceController.class.getCanonicalName())
+                )
+                .findFirst()
+                .orElseThrow(() -> new Exception("ResourceController is not implemented by " + controllerClassSymbol.toString()));
+
+        final TypeMirror resourceType = controllerType.getTypeArguments().get(0);
+        return resourceType;
+    }
+
+    private List<Type> collectAllInterfaces(Symbol.ClassSymbol classSymbol) {
+        List<Type> interfaces = new ArrayList<>(classSymbol.getInterfaces());
+        Symbol.ClassSymbol superclass = (Symbol.ClassSymbol) processingEnv.getTypeUtils().asElement(classSymbol.getSuperclass());
+
+        while (superclass != null) {
+            interfaces.addAll(superclass.getInterfaces());
+            superclass = (Symbol.ClassSymbol) processingEnv.getTypeUtils().asElement(superclass.getSuperclass());
+        }
+
+        return interfaces;
+    }
 }

operator-framework/src/test/java/io/javaoperatorsdk/operator/processing/ControllerAnnotationProcessorTest.java

@@ -17,4 +17,20 @@ public void generateCorrectDoneableClassIfInterfaceIsSecond() {
         final JavaFileObject expectedResource = JavaFileObjects.forResource("ControllerImplemented2InterfacesExpected.java");
         JavaFileObjectSubject.assertThat(compilation.generatedSourceFiles().get(0)).hasSourceEquivalentTo(expectedResource);
     }
+
+    @Test
+    public void generateCorrectDoneableClassIfThereIsAbstractBaseController() {
+
+        Compilation compilation = Compiler.javac()
+                .withProcessors(new ControllerAnnotationProcessor())
+                .compile(
+                        JavaFileObjects.forResource("AbstractController.java"),
+                        JavaFileObjects.forResource("ControllerImplementedIntermediateAbstractClass.java")
+                );
+        CompilationSubject.assertThat(compilation).succeeded();
+
+        final JavaFileObject expectedResource = JavaFileObjects.forResource("ControllerImplementedIntermediateAbstractClassExpected.java");
+        JavaFileObjectSubject.assertThat(compilation.generatedSourceFiles().get(0)).hasSourceEquivalentTo(expectedResource);
+
+    }
 }

operator-framework/src/test/resources/AbstractController.java

@@ -0,0 +1,26 @@
+package io;
+
+import io.fabric8.kubernetes.client.CustomResource;
+import io.fabric8.kubernetes.client.CustomResourceDoneable;
+import io.javaoperatorsdk.operator.api.Context;
+import io.javaoperatorsdk.operator.api.Controller;
+import io.javaoperatorsdk.operator.api.ResourceController;
+import io.javaoperatorsdk.operator.api.UpdateControl;
+import io.fabric8.kubernetes.api.model.Secret;
+import io.fabric8.kubernetes.api.model.SecretBuilder;
+import io.fabric8.kubernetes.client.KubernetesClient;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+import java.io.Serializable;
+
+import static java.lang.String.format;
+
+
+public abstract class AbstractController implements Serializable, ResourceController<AbstractController.MyCustomResource> {
+    public static class MyCustomResource extends CustomResource {
+
+    }
+}

operator-framework/src/test/resources/ControllerImplemented2Interfaces.java

@@ -18,11 +18,10 @@
 
 import static java.lang.String.format;
 
-@Controller(crdName = "schemas.mysql.sample.javaoperatorsdk")
+@Controller(crdName = "test.crd")
 public class ControllerImplemented2Interfaces implements Serializable, ResourceController<ControllerImplemented2Interfaces.MyCustomResource> {
 
     public static class MyCustomResource extends CustomResource {
-
     }
 
     @Override

operator-framework/src/test/resources/ControllerImplementedIntermediateAbstractClass.java

@@ -0,0 +1,31 @@
+package io;
+
+import io.fabric8.kubernetes.client.CustomResource;
+import io.fabric8.kubernetes.client.CustomResourceDoneable;
+import io.javaoperatorsdk.operator.api.Context;
+import io.javaoperatorsdk.operator.api.Controller;
+import io.javaoperatorsdk.operator.api.ResourceController;
+import io.javaoperatorsdk.operator.api.UpdateControl;
+import io.fabric8.kubernetes.api.model.Secret;
+import io.fabric8.kubernetes.api.model.SecretBuilder;
+import io.fabric8.kubernetes.client.KubernetesClient;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+import java.io.Serializable;
+
+import static java.lang.String.format;
+
+@Controller(crdName = "test.crd")
+public class ControllerImplementedIntermediateAbstractClass extends AbstractController implements Serializable {
+
+    public UpdateControl<AbstractController.MyCustomResource> createOrUpdateResource(AbstractController.MyCustomResource customResource, Context<AbstractController.MyCustomResource> context) {
+        return UpdateControl.updateCustomResource(null);
+    }
+
+    public boolean deleteResource(AbstractController.MyCustomResource customResource, Context<AbstractController.MyCustomResource> context) {
+        return false;
+    }
+}

operator-framework/src/test/resources/ControllerImplementedIntermediateAbstractClassExpected.java

@@ -0,0 +1,12 @@
+package io;
+
+import io.fabric8.kubernetes.api.builder.Function;
+import io.fabric8.kubernetes.client.CustomResourceDoneable;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection
+public class MyCustomResourceDoneable extends CustomResourceDoneable<AbstractController.MyCustomResource> {
+    public MyCustomResourceDoneable(AbstractController.MyCustomResource resource, Function function) {
+        super(resource, function);
+    }
+}