First simple version of ReporterInspector working

Author: pesse

src/main/java/org/utplsql/api/reporter/ReporterFactory.java

@@ -6,34 +6,37 @@
 import oracle.sql.STRUCT;
 import org.utplsql.api.compatibility.CompatibilityProxy;
 
-import java.sql.Connection;
 import java.sql.SQLException;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.BiFunction;
 
 /** This class manages the instantiation of reporters.
  * One can register a supplier method for a specific name which will then be callable via createReporter(name)
  *
+ * Use the static createEmpty or createDefault methods to get a new instance.
+ * We don't allow direct instantiation because we want
+ * <ul>
+ *     <li>Register default ReporterFactoryMethods for Core-Reporters</li>
+ *     <li>Be able to add more than one ReporterFactory implementation due to backwards-compatibility in future</li>
+ * </ul>
+ *
  * @author pesse
  */
 public final class ReporterFactory implements ORADataFactory {
 
-    public static class ReporterInfo {
-        public ReporterInfo(BiFunction<String, Object[], ? extends Reporter> factoryMethod, String description) {
+    public static class ReporterFactoryMethodInfo {
+        public ReporterFactoryMethodInfo(BiFunction<String, Object[], ? extends Reporter> factoryMethod, String description) {
             this.factoryMethod = factoryMethod;
             this.description = description;
         }
         public BiFunction<String, Object[], ? extends Reporter> factoryMethod;
         public String description;
     }
 
-    private Map<String, ReporterInfo> reportFactoryMethodMap = new HashMap<>();
-    
-    ReporterFactory() {
+    private Map<String, ReporterFactoryMethodInfo> reportFactoryMethodMap = new HashMap<>();
 
-    }
+    ReporterFactory() { }
 
     /** Registers a creation method for a specified reporter name. Overrides eventually existing creation method
      *
@@ -42,19 +45,28 @@ public ReporterInfo(BiFunction<String, Object[], ? extends Reporter> factoryMeth
      * @param description the description of the reporter
      * @return Object with information about the registered reporter
      */
-    public synchronized ReporterInfo registerReporterFactoryMethod( String reporterName, BiFunction<String, Object[], ? extends Reporter> factoryMethod, String description) {
-        return reportFactoryMethodMap.put(reporterName.toUpperCase(), new ReporterInfo(factoryMethod, description));
+    public synchronized ReporterFactoryMethodInfo registerReporterFactoryMethod(String reporterName, BiFunction<String, Object[], ? extends Reporter> factoryMethod, String description) {
+        return reportFactoryMethodMap.put(reporterName.toUpperCase(), new ReporterFactoryMethodInfo(factoryMethod, description));
     }
 
     /** Unregisters a specified reporter name.
      *
      * @param reporterName the reporter's name to unregister
      * @return information about the reporter which was previously registered or null
      */
-    public synchronized ReporterInfo unregisterReporterFactoryMethod( String reporterName ) {
+    public synchronized ReporterFactoryMethodInfo unregisterReporterFactoryMethod(String reporterName ) {
         return reportFactoryMethodMap.remove(reporterName.toUpperCase());
     }
 
+    /** Checks whether a given reporter has a registered FactoryMethod or not
+     *
+     * @param reporterName the reporter's name
+     * @return true or false
+     */
+    public synchronized boolean hasRegisteredFactoryMethodFor( String reporterName ) {
+        return reportFactoryMethodMap.containsKey(reporterName.toUpperCase());
+    }
+
     /** Returns a new reporter of the given name.
      * If no specific ReporterFactoryMethod is registered, returns a default {Reporter}
      *
@@ -69,9 +81,9 @@ public Reporter createReporter(String reporterName, Object[] attributes) {
 
         if ( reportFactoryMethodMap.containsKey(reporterName)) {
 
-            ReporterInfo ri = reportFactoryMethodMap.get(reporterName);
+            ReporterFactoryMethodInfo ri = reportFactoryMethodMap.get(reporterName);
             if (ri == null)
-                throw new RuntimeException("ReporterInfo for " + reporterName + " was null");
+                throw new RuntimeException("ReporterFactoryMethodInfo for " + reporterName + " was null");
 
             supplier = ri.factoryMethod;
         }
@@ -89,23 +101,14 @@ public Reporter createReporter( String reporterName ) {
         return createReporter(reporterName, null);
     }
 
-    /** Returns a new reporter of the given DefaultReporter type
-     *
-     * @param reporter
-     * @return
-     */
-    public Reporter createReporter( CoreReporters reporter ) {
-        return createReporter(reporter.name());
-    }
-
     /** Returns a set of all registered reporter's names
      *
      * @return Set of reporter names
      */
     public Map<String, String> getRegisteredReporterInfo() {
         Map<String, String> descMap = new HashMap<>(reportFactoryMethodMap.size());
 
-        for (Map.Entry<String, ReporterInfo> entry : reportFactoryMethodMap.entrySet()) {
+        for (Map.Entry<String, ReporterFactoryMethodInfo> entry : reportFactoryMethodMap.entrySet()) {
             descMap.put(entry.getKey(), entry.getValue().description);
         }
         return descMap;
@@ -132,7 +135,7 @@ public static ReporterFactory createEmpty() {
     }
 
     /** Returns a new instance of a ReporterFactory with the default ReporterFactoryMethods registered.
-     * This can depend upon the version of utPLSQL, therefore you have to provide a CompatibilityProxy
+     * This can depend on the version of utPLSQL, therefore you have to provide a CompatibilityProxy
      *
      * @param proxy Compatibility proxy
      * @return a new ReporterFactory instance with all default ReporterFactoryMethods registered

src/main/java/org/utplsql/api/reporter/ReporterInspector.java

@@ -0,0 +1,38 @@
+package org.utplsql.api.reporter.inspect;
+
+import org.utplsql.api.reporter.ReporterFactory;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+abstract class AbstractReporterInspector implements ReporterInspector  {
+
+    protected ReporterFactory reporterFactory;
+    protected Connection connection;
+    protected Set<ReporterInfo> infos;
+
+    AbstractReporterInspector(ReporterFactory reporterFactory, Connection conn ) throws SQLException {
+        this.reporterFactory = reporterFactory;
+        this.connection = conn;
+
+        load();
+    }
+
+    protected abstract void load() throws SQLException;
+
+    @Override
+    public Map<String, ReporterInfo> getReporterInfoMap() {
+        return infos.stream().collect(Collectors.toMap(ReporterInfo::getName, i -> i));
+    }
+
+    @Override
+    public List<ReporterInfo> getReporterInfos() {
+        return new ArrayList<>(infos);
+    }
+
+}

src/main/java/org/utplsql/api/reporter/inspect/AbstractReporterInspector.java

@@ -0,0 +1,34 @@
+package org.utplsql.api.reporter.inspect;
+
+/** Holds information about utPLSQL Reporter-Types
+ *
+ * @author pesse
+ */
+public class ReporterInfo {
+
+    public enum Type {
+        SQL, JAVA, SQL_WITH_JAVA
+    }
+
+    private String name;
+    private Type type;
+    private String description;
+
+    ReporterInfo( String name, Type type, String description ) {
+        this.name = name;
+        this.type = type;
+        this.description = description;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+}

src/main/java/org/utplsql/api/reporter/inspect/ReporterInfo.java

@@ -0,0 +1,42 @@
+package org.utplsql.api.reporter.inspect;
+
+import org.utplsql.api.Version;
+import org.utplsql.api.compatibility.CompatibilityProxy;
+import org.utplsql.api.exception.InvalidVersionException;
+import org.utplsql.api.reporter.ReporterFactory;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Gives information about available reporters
+ *
+ * @author pesse
+ */
+public interface ReporterInspector {
+
+    List<ReporterInfo> getReporterInfos();
+
+    Map<String, ReporterInfo> getReporterInfoMap();
+
+    /**
+     * Returns a new instance of a ReporterInspector, based on the utPLSQL version used in the connection
+     *
+     * @param reporterFactory
+     * @param conn
+     * @return
+     * @throws SQLException
+     */
+    static ReporterInspector create(ReporterFactory reporterFactory, Connection conn) throws SQLException, InvalidVersionException {
+
+        CompatibilityProxy proxy = new CompatibilityProxy(conn);
+
+        if (proxy.getDatabaseVersion().isGreaterOrEqualThan(new Version("3.1.0")))
+            return new ReporterInspector310(reporterFactory, conn);
+        else
+            return new ReporterInspectorPre310(reporterFactory, conn);
+    }
+
+}

src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java

@@ -0,0 +1,75 @@
+package org.utplsql.api.reporter.inspect;
+
+import oracle.jdbc.OracleCallableStatement;
+import oracle.jdbc.OracleConnection;
+import oracle.jdbc.OracleType;
+import org.utplsql.api.compatibility.CompatibilityProxy;
+import org.utplsql.api.reporter.CoreReporters;
+import org.utplsql.api.reporter.Reporter;
+import org.utplsql.api.reporter.ReporterFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/** ReporterInspector for v3.1.0 upwards
+ *
+ * @author pesse
+ */
+class ReporterInspector310 extends AbstractReporterInspector {
+
+
+    private Map<String, String> registeredReporterFactoryMethods;
+    private CompatibilityProxy compatibilityProxy;
+
+    ReporterInspector310(ReporterFactory reporterFactory, Connection conn ) throws SQLException {
+        super(reporterFactory, conn);
+    }
+
+    @Override
+    protected void load() throws SQLException {
+
+        registeredReporterFactoryMethods = reporterFactory.getRegisteredReporterInfo();
+        compatibilityProxy = new CompatibilityProxy(connection);
+
+        infos = new HashSet<>();
+
+        try (PreparedStatement stmt = connection.prepareStatement("select * from table(ut_runner.get_reporters_list) order by 1")) {
+            try (ResultSet rs = stmt.executeQuery() ) {
+                while (rs.next())
+                    infos.add(getReporterInfo(rs.getString(1)));
+            }
+        }
+    }
+
+    private ReporterInfo getReporterInfo( String reporterNameWithOwner ) throws SQLException {
+        String reporterName = reporterNameWithOwner.substring(reporterNameWithOwner.indexOf(".")+1).toUpperCase();
+
+        ReporterInfo.Type type = ReporterInfo.Type.SQL;
+        String description = getDescription(reporterName);
+
+        if ( registeredReporterFactoryMethods.containsKey(reporterName) ) {
+            type = ReporterInfo.Type.SQL_WITH_JAVA;
+            description += "\n" + registeredReporterFactoryMethods.get(reporterName);
+        }
+
+        return new ReporterInfo(reporterName, type, description);
+    }
+
+    private String getDescription( String reporterName ) throws SQLException {
+        Reporter reporter = reporterFactory.createReporter(reporterName).init(connection, compatibilityProxy, reporterFactory);
+        OracleConnection oraCon = connection.unwrap(OracleConnection.class);
+
+        try (OracleCallableStatement stmt = (OracleCallableStatement) oraCon.prepareCall("{ ? = call ?.get_description() }")) {
+            stmt.registerOutParameter(1, OracleType.VARCHAR2);
+            stmt.setORAData(2, reporter);
+            stmt.execute();
+
+            return stmt.getString(1);
+        }
+    }
+
+}

src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector310.java

@@ -0,0 +1,59 @@
+package org.utplsql.api.reporter.inspect;
+
+import org.utplsql.api.Version;
+import org.utplsql.api.compatibility.CompatibilityProxy;
+import org.utplsql.api.reporter.CoreReporters;
+import org.utplsql.api.reporter.ReporterFactory;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+class ReporterInspectorPre310 extends AbstractReporterInspector {
+
+    private Map<String, String> registeredReporterFactoryMethods;
+    private Map<CoreReporters, String> descriptions;
+
+    ReporterInspectorPre310(ReporterFactory reporterFactory, Connection conn ) throws SQLException {
+        super(reporterFactory, conn);
+    }
+
+    private void initDefaultDescriptions() {
+        descriptions = new HashMap<>();
+        descriptions.put(CoreReporters.UT_COVERAGE_HTML_REPORTER, "");
+        descriptions.put(CoreReporters.UT_COVERAGE_SONAR_REPORTER, "");
+        descriptions.put(CoreReporters.UT_COVERALLS_REPORTER, "");
+        descriptions.put(CoreReporters.UT_DOCUMENTATION_REPORTER, "");
+        descriptions.put(CoreReporters.UT_SONAR_TEST_REPORTER, "");
+        descriptions.put(CoreReporters.UT_TEAMCITY_REPORTER, "");
+        descriptions.put(CoreReporters.UT_XUNIT_REPORTER, "");
+    }
+
+    @Override
+    protected void load() throws SQLException {
+        initDefaultDescriptions();
+        Version databaseVersion = new CompatibilityProxy(connection).getDatabaseVersion();
+        registeredReporterFactoryMethods = reporterFactory.getRegisteredReporterInfo();
+        infos = Arrays.stream(CoreReporters.values())
+                .filter(r -> r.isAvailableFor(databaseVersion))
+                .map(this::getReporterInfo)
+                .collect(Collectors.toSet());
+    }
+
+    private ReporterInfo getReporterInfo( CoreReporters reporter ) {
+
+        ReporterInfo.Type type = ReporterInfo.Type.SQL;
+        String description = descriptions.get(reporter);
+
+        if ( registeredReporterFactoryMethods.containsKey(reporter.name()) ) {
+            type = ReporterInfo.Type.SQL_WITH_JAVA;
+            description += "\n" + registeredReporterFactoryMethods.get(reporter.name());
+        }
+
+        return new ReporterInfo( reporter.name(), type, description);
+    }
+}