tests: improve TestObjects.fill(...) to support interface params that have builder implementations

- For example, v3.GetApplicationResponse.Builder had a nested param of
  type LifecycleData. That's a method-less interface, with multiple
  possible implementations. Each implementation has a builder. We now
  pick whatever implementation we find, fill its builder, and use that
  in the root object.

Author: Kehrlann

cloudfoundry-operations/src/test/java/org/cloudfoundry/operations/ReflectionUtils.java

@@ -0,0 +1,88 @@
+package org.cloudfoundry.operations;
+
+import java.io.File;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class ReflectionUtils {
+
+    private ReflectionUtils() { // do not instantiate this class
+    }
+
+    /**
+     * Find implementations for a given interface type. Uses reflection.
+     */
+    public static <T> List<Class<? extends T>> findImplementations(Class<T> interfaceType) {
+        try {
+            // Get the class loader
+            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+
+            // Get the package path
+            String path = interfaceType.getPackage().getName().replace('.', '/');
+            Enumeration<URL> resources = classLoader.getResources(path);
+            return Collections.list(resources).stream()
+                    .map(URL::getFile)
+                    .map(File::new)
+                    .filter(File::exists)
+                    .flatMap(
+                            directory ->
+                                    scanDirectory(
+                                            directory,
+                                            interfaceType.getPackage().getName(),
+                                            interfaceType))
+                    .collect(Collectors.toList());
+        } catch (Exception ignored) {
+
+        }
+        return Collections.emptyList();
+    }
+
+    private static <T> Stream<Class<? extends T>> scanDirectory(
+            File directory, String packageName, Class<T> interfaceType) {
+        File[] files = directory.listFiles();
+        if (files == null) {
+            return Stream.empty();
+        }
+
+        Stream<Class<? extends T>> classes =
+                Arrays.stream(files)
+                        .filter(fileName -> fileName.getName().endsWith(".class"))
+                        .map(
+                                fileName ->
+                                        packageName
+                                                + '.'
+                                                + fileName.getName().replaceAll("\\.class$", ""))
+                        .map(
+                                className -> {
+                                    try {
+                                        Class<?> clazz = Class.forName(className);
+                                        if (interfaceType.isAssignableFrom(clazz)
+                                                && !clazz.isInterface()
+                                                && !Modifier.isAbstract(clazz.getModifiers())) {
+                                            Class<? extends T> subclass =
+                                                    clazz.asSubclass(interfaceType);
+                                            return subclass;
+                                        }
+                                    } catch (ClassNotFoundException ignored) {
+                                    }
+                                    return interfaceType;
+                                })
+                        .filter(clazz -> clazz != interfaceType);
+        Stream<Class<? extends T>> directories =
+                Arrays.stream(files)
+                        .filter(File::isDirectory)
+                        .flatMap(
+                                fileName ->
+                                        scanDirectory(
+                                                fileName,
+                                                packageName + "." + fileName.getName(),
+                                                interfaceType));
+        return Stream.concat(classes, directories);
+    }
+}

cloudfoundry-operations/src/test/java/org/cloudfoundry/operations/TestObjects.java

@@ -109,9 +109,12 @@ private static <T> T fill(T builder, Optional<String> modifier) {
         return getConfigurationMethods(builderType, builderMethods, builtGetters).stream()
                 .collect(
                         () -> builder,
-                        (b, method) ->
-                                ReflectionUtils.invokeMethod(
-                                        method, b, getConfiguredValue(method, modifier)),
+                        (b, method) -> {
+                            Object configuredValue = getConfiguredValue(method, modifier);
+                            if (configuredValue != null) {
+                                ReflectionUtils.invokeMethod(method, b, configuredValue);
+                            }
+                        },
                         (a, b) -> {});
     }
 
@@ -190,10 +193,19 @@ private static Object getConfiguredValue(
             return getConfiguredString(configurationMethod, modifier);
         } else if (parameterType.isArray()) {
             return Array.newInstance(parameterType.getComponentType(), 0);
+        } else if (parameterType == Map.Entry.class) {
+            return null;
         } else {
-            throw new IllegalStateException(
-                    String.format("Unable to configure %s", configurationMethod));
+            for (Class<?> implementation :
+                    org.cloudfoundry.operations.ReflectionUtils.findImplementations(
+                            parameterType)) {
+                if (isBuiltType(implementation)) {
+                    return getConfiguredBuilder(implementation, modifier);
+                }
+            }
         }
+        throw new IllegalStateException(
+                String.format("Unable to configure %s", configurationMethod));
     }
 
     private static List<Method> getMethods(Class<?> builderType) {