From 0aa366c3ddb044f84b1901f626bae4ac0b5b0b0d Mon Sep 17 00:00:00 2001 From: pesse Date: Tue, 5 Feb 2019 22:23:48 +0100 Subject: [PATCH 01/14] Add simple and basic logging --- pom.xml | 67 ++++++++++--------- src/main/java/org/utplsql/cli/RunCommand.java | 12 ++-- 2 files changed, 43 insertions(+), 36 deletions(-) diff --git a/pom.xml b/pom.xml index edf96a2..df455d7 100644 --- a/pom.xml +++ b/pom.xml @@ -20,36 +20,43 @@ - - org.utplsql - java-api - 3.1.2 - compile - - - com.oracle.jdbc - ucp - - - - - com.beust - jcommander - 1.72 - compile - - - com.zaxxer - HikariCP - 2.7.2 - compile - - org.slf4j - slf4j-nop - 1.7.25 + org.utplsql + java-api + 3.1.3-SNAPSHOT compile + + + com.oracle.jdbc + ucp + + + + com.beust + jcommander + 1.72 + compile + + + com.zaxxer + HikariCP + 2.7.2 + compile + + + javax.xml.bind + jaxb-api + 2.3.0 + + + ch.qos.logback + logback-classic + 1.2.3 + test + + + org.junit.jupiter junit-jupiter-api @@ -62,11 +69,7 @@ ${junit.jupiter.version} test - - javax.xml.bind - jaxb-api - 2.3.0 - + diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index 01ecdbd..59b58a6 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -2,10 +2,9 @@ import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; -import org.utplsql.api.FileMapperOptions; -import org.utplsql.api.KeyValuePair; -import org.utplsql.api.TestRunner; -import org.utplsql.api.Version; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.utplsql.api.*; import org.utplsql.api.compatibility.CompatibilityProxy; import org.utplsql.api.exception.DatabaseNotCompatibleException; import org.utplsql.api.exception.SomeTestsFailedException; @@ -34,6 +33,8 @@ @Parameters(separators = "=", commandDescription = "run tests") public class RunCommand implements ICommand { + private static final Logger logger = LoggerFactory.getLogger(RunCommand.class); + @Parameter( required = true, converter = ConnectionInfo.ConnectionStringConverter.class, @@ -114,6 +115,9 @@ public List getTestPaths() { public int run() { + logger.info(CliVersionInfo.getInfo()); + logger.info(JavaApiVersionInfo.getInfo()); + try { final List reporterList; From 606aacb1d631e72826fa509f3b1aab1ca4dd52bd Mon Sep 17 00:00:00 2001 From: pesse Date: Wed, 6 Feb 2019 09:46:27 +0100 Subject: [PATCH 02/14] Add some useful information to output --- pom.xml | 1 - .../org/utplsql/cli/LoggerConfiguration.java | 41 +++++++++++++++++++ src/main/java/org/utplsql/cli/RunCommand.java | 18 +++++++- 3 files changed, 57 insertions(+), 3 deletions(-) create mode 100644 src/main/java/org/utplsql/cli/LoggerConfiguration.java diff --git a/pom.xml b/pom.xml index df455d7..cb09913 100644 --- a/pom.xml +++ b/pom.xml @@ -53,7 +53,6 @@ ch.qos.logback logback-classic 1.2.3 - test diff --git a/src/main/java/org/utplsql/cli/LoggerConfiguration.java b/src/main/java/org/utplsql/cli/LoggerConfiguration.java new file mode 100644 index 0000000..b1b8724 --- /dev/null +++ b/src/main/java/org/utplsql/cli/LoggerConfiguration.java @@ -0,0 +1,41 @@ +package org.utplsql.cli; + +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.LoggerContext; +import ch.qos.logback.classic.encoder.PatternLayoutEncoder; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.ConsoleAppender; +import com.zaxxer.hikari.HikariDataSource; +import org.slf4j.LoggerFactory; +import org.utplsql.api.TestRunner; + +public class LoggerConfiguration { + + static void configureDefault() { + Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + root.setLevel(Level.INFO); + + Logger hikariLogger = (Logger) LoggerFactory.getLogger(HikariDataSource.class); + hikariLogger.setLevel(Level.OFF); + + ((Logger) LoggerFactory.getLogger(TestRunner.class)).setLevel(Level.ERROR); + + LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); + + PatternLayoutEncoder ple = new PatternLayoutEncoder(); + ple.setPattern("%msg%n"); + + ple.setContext(lc); + ple.start(); + + ConsoleAppender consoleAppender = new ConsoleAppender(); + consoleAppender.setEncoder(ple); + consoleAppender.setContext(lc); + consoleAppender.start(); + + root.detachAndStopAllAppenders(); + root.setAdditive(false); + root.addAppender(consoleAppender); + } +} diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index 59b58a6..ab4ae24 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -115,8 +115,19 @@ public List getTestPaths() { public int run() { - logger.info(CliVersionInfo.getInfo()); - logger.info(JavaApiVersionInfo.getInfo()); + LoggerConfiguration.configureDefault(); + + logger.info("##################### utPLSQL cli ####################"); + logger.info("#"); + logger.info("# {} ", CliVersionInfo.getInfo()); + logger.info("# {} ", JavaApiVersionInfo.getInfo()); + logger.info("# Java-Version: {} ", System.getProperty("java.version")); + logger.info("# ORACLE_HOME: {} ", EnvironmentVariableUtil.getEnvValue("ORACLE_HOME")); + logger.info("# "); + logger.info("# Thank you for testing! "); + logger.info("#"); + logger.info("######################################################"); + logger.info(""); try { @@ -160,6 +171,9 @@ public int run() { // First of all do a compatibility check and fail-fast compatibilityProxy = checkFrameworkCompatibility(conn); + + logger.info("Successfully connected to database. UtPLSQL core: " + compatibilityProxy.getDatabaseVersion()); + reporterFactory = ReporterFactoryProvider.createReporterFactory(compatibilityProxy); reporterList = getReporterManager().initReporters(conn, reporterFactory, compatibilityProxy); From 9e572bda89464c31c913ead77ce05066e8ae29ff Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 12:51:12 +0100 Subject: [PATCH 03/14] StringBlock Formatter for nicer log output --- .../utplsql/cli/log/StringBlockFormatter.java | 77 +++++++++++++++++++ .../utplsql/cli/StringBlockFormatterTest.java | 53 +++++++++++++ 2 files changed, 130 insertions(+) create mode 100644 src/main/java/org/utplsql/cli/log/StringBlockFormatter.java create mode 100644 src/test/java/org/utplsql/cli/StringBlockFormatterTest.java diff --git a/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java b/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java new file mode 100644 index 0000000..e5de04d --- /dev/null +++ b/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java @@ -0,0 +1,77 @@ +package org.utplsql.cli.log; + +public class StringBlockFormatter { + + private String headline; + private StringBuilder content = new StringBuilder(); + + public StringBlockFormatter() {} + + public StringBlockFormatter(String headline) { + setHeadline(headline); + } + + public void setHeadline(String headline) { + this.headline = headline; + } + + public String getHeadline() { + return headline; + } + + public void append( CharSequence seq ) { + content.append(seq); + } + + private int getMaxLength( String[] lines ) { + int len = 0; + for ( String line : lines ) { + if (line.length() > len) + len = line.length(); + } + + if ( headline.length() > (len+6)) + len = headline.length(); + + return len; + } + + public static String getEncapsulatedLine( String line, int maxLength ) { + return String.format("# %-" + maxLength + "s #", line); + } + + public static String getEncapsulatedHeadline( String headline, int maxLength ) { + String content = new String(new char[maxLength+8]).replace("\0", "#"); + if ( headline == null || headline.isEmpty() ) + return content; + + headline = " " + headline + " "; + int start = (int)Math.floor( + (float)content.length()/2f + -(float)headline.length()/2f + ); + int end = start + headline.length(); + + return content.substring(0, start) + + headline + + content.substring(end); + } + + public String toString() { + + String[] lines = content.toString().split("\n"); + int maxLen = getMaxLength(lines); + + StringBuilder sb = new StringBuilder(); + + sb.append(getEncapsulatedHeadline(headline, maxLen)).append("\n"); + sb.append(getEncapsulatedLine("", maxLen)).append("\n"); + for ( String line : lines ) { + sb.append(getEncapsulatedLine(line, maxLen)).append("\n"); + } + sb.append(getEncapsulatedLine("", maxLen)).append("\n"); + sb.append(getEncapsulatedHeadline("", maxLen)); + + return sb.toString(); + } +} diff --git a/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java b/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java new file mode 100644 index 0000000..73f6177 --- /dev/null +++ b/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java @@ -0,0 +1,53 @@ +package org.utplsql.cli; + +import org.junit.jupiter.api.Test; +import org.utplsql.cli.log.StringBlockFormatter; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class StringBlockFormatterTest { + + @Test + void getBlockFormattedString() { + + String expected = + "#### Headline ####\n" + + "# #\n" + + "# My value 1 #\n" + + "# #\n" + + "##################"; + + StringBlockFormatter formatter = new StringBlockFormatter("Headline"); + formatter.append("My value 1"); + + assertEquals( expected, formatter.toString() ); + } + + @Test + void getEncapsulatedLine() { + + String line = StringBlockFormatter.getEncapsulatedLine("val 1", 20); + + assertEquals("# val 1 #", line); + } + + @Test + void getEncapsulatedHeadline() { + + assertEquals("######### headline #########", + StringBlockFormatter.getEncapsulatedHeadline("headline", 20)); + assertEquals("######### headline ##########", + StringBlockFormatter.getEncapsulatedHeadline("headline", 21)); + assertEquals("######### headline1 #########", + StringBlockFormatter.getEncapsulatedHeadline("headline1", 21)); + assertEquals("######## headline1 #########", + StringBlockFormatter.getEncapsulatedHeadline("headline1", 20)); + } + + @Test + void getEmptyEncapsulatedHeadline() { + + assertEquals("##################", + StringBlockFormatter.getEncapsulatedHeadline("", 10)); + } +} From 90147719e687735e1c14b714ad5c33b95edd7bd4 Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 14:12:29 +0100 Subject: [PATCH 04/14] AppendLine-function --- src/main/java/org/utplsql/cli/log/StringBlockFormatter.java | 4 ++++ src/test/java/org/utplsql/cli/StringBlockFormatterTest.java | 4 +++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java b/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java index e5de04d..d73656f 100644 --- a/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java +++ b/src/main/java/org/utplsql/cli/log/StringBlockFormatter.java @@ -23,6 +23,10 @@ public void append( CharSequence seq ) { content.append(seq); } + public void appendLine( CharSequence seq ) { + content.append(seq).append("\n"); + } + private int getMaxLength( String[] lines ) { int len = 0; for ( String line : lines ) { diff --git a/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java b/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java index 73f6177..62fc5f6 100644 --- a/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java +++ b/src/test/java/org/utplsql/cli/StringBlockFormatterTest.java @@ -14,11 +14,13 @@ void getBlockFormattedString() { "#### Headline ####\n" + "# #\n" + "# My value 1 #\n" + + "# My val 2 #\n" + "# #\n" + "##################"; StringBlockFormatter formatter = new StringBlockFormatter("Headline"); - formatter.append("My value 1"); + formatter.appendLine("My value 1"); + formatter.appendLine("My val 2"); assertEquals( expected, formatter.toString() ); } From 078b727bf49e13fb19aa80efa2cc9864a49bbc53 Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 14:19:40 +0100 Subject: [PATCH 05/14] Add useful information in RunCommand --- src/main/java/org/utplsql/cli/RunCommand.java | 35 +++++++++++++------ 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index ab4ae24..4004a46 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -6,12 +6,14 @@ import org.slf4j.LoggerFactory; import org.utplsql.api.*; import org.utplsql.api.compatibility.CompatibilityProxy; +import org.utplsql.api.db.DefaultDatabaseInformation; import org.utplsql.api.exception.DatabaseNotCompatibleException; import org.utplsql.api.exception.SomeTestsFailedException; import org.utplsql.api.exception.UtPLSQLNotInstalledException; import org.utplsql.api.reporter.Reporter; import org.utplsql.api.reporter.ReporterFactory; import org.utplsql.cli.exception.DatabaseConnectionFailed; +import org.utplsql.cli.log.StringBlockFormatter; import javax.sql.DataSource; import java.io.File; @@ -117,17 +119,7 @@ public int run() { LoggerConfiguration.configureDefault(); - logger.info("##################### utPLSQL cli ####################"); - logger.info("#"); - logger.info("# {} ", CliVersionInfo.getInfo()); - logger.info("# {} ", JavaApiVersionInfo.getInfo()); - logger.info("# Java-Version: {} ", System.getProperty("java.version")); - logger.info("# ORACLE_HOME: {} ", EnvironmentVariableUtil.getEnvValue("ORACLE_HOME")); - logger.info("# "); - logger.info("# Thank you for testing! "); - logger.info("#"); - logger.info("######################################################"); - logger.info(""); + outputMainInformation(); try { @@ -173,6 +165,7 @@ public int run() { compatibilityProxy = checkFrameworkCompatibility(conn); logger.info("Successfully connected to database. UtPLSQL core: " + compatibilityProxy.getDatabaseVersion()); + logger.info("Oracle-Version: {}", new DefaultDatabaseInformation().getOracleVersion(conn)); reporterFactory = ReporterFactoryProvider.createReporterFactory(compatibilityProxy); @@ -208,6 +201,8 @@ public int run() { .includeObjects(finalIncludeObjectsList) .excludeObjects(finalExcludeObjectsList); + logger.info("Running tests now."); + logger.info("--------------------------------------"); testRunner.run(conn); } catch (SomeTestsFailedException e) { returnCode[0] = this.failureExitCode; @@ -223,6 +218,10 @@ public int run() { executorService.shutdown(); executorService.awaitTermination(60, TimeUnit.MINUTES); + + logger.info("--------------------------------------"); + logger.info("All tests done."); + return returnCode[0]; } catch ( DatabaseNotCompatibleException | UtPLSQLNotInstalledException | DatabaseConnectionFailed e ) { @@ -239,6 +238,20 @@ public String getCommand() { } + private void outputMainInformation() { + + StringBlockFormatter formatter = new StringBlockFormatter("utPLCSL cli"); + formatter.appendLine(CliVersionInfo.getInfo()); + formatter.appendLine(JavaApiVersionInfo.getInfo()); + formatter.appendLine("Java-Version: " + System.getProperty("java.version")); + formatter.appendLine("ORACLE_HOME: " + EnvironmentVariableUtil.getEnvValue("ORACLE_HOME")); + formatter.appendLine(""); + formatter.appendLine("Thanks for testing!"); + + logger.info(formatter.toString()); + logger.info(""); + } + /** Returns FileMapperOptions for the first item of a given param list in a baseDir * * @param pathParams From 8bdaf0f9edde93f269ffad73127d7e0b337fd686 Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 21:50:34 +0100 Subject: [PATCH 06/14] Add quiet and debug flags and also a simple debug configuration --- .../org/utplsql/cli/LoggerConfiguration.java | 43 ++++++++++++++----- src/main/java/org/utplsql/cli/RunCommand.java | 17 ++++++-- .../java/org/utplsql/cli/RunCommandIT.java | 11 +++++ .../utplsql/cli/RunCommandLogLevelTest.java | 39 +++++++++++++++++ 4 files changed, 97 insertions(+), 13 deletions(-) create mode 100644 src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java diff --git a/src/main/java/org/utplsql/cli/LoggerConfiguration.java b/src/main/java/org/utplsql/cli/LoggerConfiguration.java index b1b8724..b18e6f2 100644 --- a/src/main/java/org/utplsql/cli/LoggerConfiguration.java +++ b/src/main/java/org/utplsql/cli/LoggerConfiguration.java @@ -10,32 +10,55 @@ import org.slf4j.LoggerFactory; import org.utplsql.api.TestRunner; -public class LoggerConfiguration { +class LoggerConfiguration { - static void configureDefault() { + static void configure(boolean silent, boolean debug) { + if ( silent ) + configureSilent(); + else if ( debug ) + configureDebug(); + else + configureDefault(); + } + + private static void configureSilent() { Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); - root.setLevel(Level.INFO); + root.setLevel(Level.OFF); + } - Logger hikariLogger = (Logger) LoggerFactory.getLogger(HikariDataSource.class); - hikariLogger.setLevel(Level.OFF); + private static void configureDefault() { + Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + root.setLevel(Level.INFO); + ((Logger) LoggerFactory.getLogger(HikariDataSource.class)).setLevel(Level.OFF); ((Logger) LoggerFactory.getLogger(TestRunner.class)).setLevel(Level.ERROR); + setSingleConsoleAppenderWithLayout(root, "%msg%n"); + } + + private static void configureDebug() { + Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + root.setLevel(Level.DEBUG); + + setSingleConsoleAppenderWithLayout(root, "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"); + } + + private static void setSingleConsoleAppenderWithLayout( Logger logger, String patternLayout ) { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); - ple.setPattern("%msg%n"); + ple.setPattern(patternLayout); ple.setContext(lc); ple.start(); - ConsoleAppender consoleAppender = new ConsoleAppender(); + ConsoleAppender consoleAppender = new ConsoleAppender<>(); consoleAppender.setEncoder(ple); consoleAppender.setContext(lc); consoleAppender.start(); - root.detachAndStopAllAppenders(); - root.setAdditive(false); - root.addAppender(consoleAppender); + logger.detachAndStopAllAppenders(); + logger.setAdditive(false); + logger.addAppender(consoleAppender); } } diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index 4004a46..5a28bc7 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -102,6 +102,15 @@ public class RunCommand implements ICommand { ) private String excludeObjects = null; + @Parameter( + names = {"-q", "--quiet"}, + description = "Does not output the informational messages normally printed to console") + private boolean logSilent = false; + + @Parameter( + names = {"-d", "--debug"}, + description = "Outputs a load of debug information to console") + private boolean logDebug = false; private CompatibilityProxy compatibilityProxy; private ReporterFactory reporterFactory; @@ -115,10 +124,12 @@ public List getTestPaths() { return testPaths; } - public int run() { - - LoggerConfiguration.configureDefault(); + public void init() { + LoggerConfiguration.configure(logSilent, logDebug); + } + public int run() { + init(); outputMainInformation(); try { diff --git a/src/test/java/org/utplsql/cli/RunCommandIT.java b/src/test/java/org/utplsql/cli/RunCommandIT.java index f03b4d2..fbf35e5 100644 --- a/src/test/java/org/utplsql/cli/RunCommandIT.java +++ b/src/test/java/org/utplsql/cli/RunCommandIT.java @@ -29,6 +29,17 @@ public void run_Default() throws Exception { else assertEquals(0, result); } + + @Test + public void run_Debug() throws Exception { + + int result = TestHelper.runApp("run", + TestHelper.getConnectionString(), + "--debug"); + + assertEquals(1, result); + } + @Test public void run_MultipleReporters() throws Exception { diff --git a/src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java b/src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java new file mode 100644 index 0000000..100e5ea --- /dev/null +++ b/src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java @@ -0,0 +1,39 @@ +package org.utplsql.cli; + +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import org.junit.jupiter.api.Test; +import org.slf4j.LoggerFactory; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class RunCommandLogLevelTest { + + private Logger getRootLogger() { + return (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + } + + @Test + void defaultIsInfo() { + TestHelper.createRunCommand(TestHelper.getConnectionString()) + .init(); + + assertEquals(Level.INFO, getRootLogger().getLevel()); + } + + @Test + void silentModeSetsLoggerToOff() { + TestHelper.createRunCommand(TestHelper.getConnectionString(), "-q") + .init(); + + assertEquals(Level.OFF, getRootLogger().getLevel()); + } + + @Test + void debugModeSetsLoggerToDebug() { + TestHelper.createRunCommand(TestHelper.getConnectionString(), "-d") + .init(); + + assertEquals(Level.DEBUG, getRootLogger().getLevel()); + } +} From 6a7d6507607b704b0f99a21553d177838b71912e Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 22:09:57 +0100 Subject: [PATCH 07/14] Refactoring --- src/main/java/org/utplsql/cli/RunCommand.java | 55 +++++++++++-------- .../utplsql/cli/TestRunCommandChecker.java | 2 +- 2 files changed, 32 insertions(+), 25 deletions(-) diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index 5a28bc7..8112f37 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -124,7 +124,7 @@ public List getTestPaths() { return testPaths; } - public void init() { + void init() { LoggerConfiguration.configure(logSilent, logDebug); } @@ -166,29 +166,8 @@ public int run() { final DataSource dataSource = DataSourceProvider.getDataSource(getConnectionInfo(), getReporterManager().getNumberOfReporters() + 1); - // Do the reporters initialization, so we can use the id to run and gather results. - try (Connection conn = dataSource.getConnection()) { - - // Check if orai18n exists if database version is 11g - RunCommandChecker.checkOracleI18nExists(conn); - - // First of all do a compatibility check and fail-fast - compatibilityProxy = checkFrameworkCompatibility(conn); - - logger.info("Successfully connected to database. UtPLSQL core: " + compatibilityProxy.getDatabaseVersion()); - logger.info("Oracle-Version: {}", new DefaultDatabaseInformation().getOracleVersion(conn)); - - reporterFactory = ReporterFactoryProvider.createReporterFactory(compatibilityProxy); - - reporterList = getReporterManager().initReporters(conn, reporterFactory, compatibilityProxy); - - } catch (SQLException e) { - if (e.getErrorCode() == 1017 || e.getErrorCode() == 12514) { - throw new DatabaseConnectionFailed(e); - } else { - throw e; - } - } + initDatabase(dataSource); + reporterList = initReporters(dataSource); // Output a message if --failureExitCode is set but database framework is not capable of String msg = RunCommandChecker.getCheckFailOnErrorMessage(failureExitCode, compatibilityProxy.getDatabaseVersion()); @@ -263,6 +242,34 @@ private void outputMainInformation() { logger.info(""); } + private void initDatabase(DataSource dataSource) throws SQLException { + try (Connection conn = dataSource.getConnection()) { + + // Check if orai18n exists if database version is 11g + RunCommandChecker.checkOracleI18nExists(conn); + + // First of all do a compatibility check and fail-fast + compatibilityProxy = checkFrameworkCompatibility(conn); + + logger.info("Successfully connected to database. UtPLSQL core: " + compatibilityProxy.getDatabaseVersion()); + logger.info("Oracle-Version: {}", new DefaultDatabaseInformation().getOracleVersion(conn)); + } + catch (SQLException e) { + if (e.getErrorCode() == 1017 || e.getErrorCode() == 12514) { + throw new DatabaseConnectionFailed(e); + } else { + throw e; + } + } + } + + private List initReporters(DataSource dataSource) throws SQLException { + try (Connection conn = dataSource.getConnection()) { + reporterFactory = ReporterFactoryProvider.createReporterFactory(compatibilityProxy); + return getReporterManager().initReporters(conn, reporterFactory, compatibilityProxy); + } + } + /** Returns FileMapperOptions for the first item of a given param list in a baseDir * * @param pathParams diff --git a/src/test/java/org/utplsql/cli/TestRunCommandChecker.java b/src/test/java/org/utplsql/cli/TestRunCommandChecker.java index fcf2d21..0b1a651 100644 --- a/src/test/java/org/utplsql/cli/TestRunCommandChecker.java +++ b/src/test/java/org/utplsql/cli/TestRunCommandChecker.java @@ -15,7 +15,7 @@ public void getCheckFailOnErrorMessage() assertNotNull(RunCommandChecker.getCheckFailOnErrorMessage(2, new Version("3.0.0"))); assertNotNull(RunCommandChecker.getCheckFailOnErrorMessage(2, new Version("3.0.1"))); assertNotNull(RunCommandChecker.getCheckFailOnErrorMessage(2, new Version("3.0.2"))); - assertNull(RunCommandChecker.getCheckFailOnErrorMessage(2, new Version("3.0.3"))); + assertNull(RunCommandChecker.getCheckFailOnErrorMessage(2, new Version("3.0.3.1266"))); assertNull(RunCommandChecker.getCheckFailOnErrorMessage(2, new Version("3.0.4"))); } } From 801484fe9e24c18de4a28dd86f63156271bc40ba Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 22:19:16 +0100 Subject: [PATCH 08/14] Update documentation --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 3e5c211..35a088d 100644 --- a/README.md +++ b/README.md @@ -123,6 +123,12 @@ The file tnsnames.ora must contain valid TNS entries. -exclude=pckg_list - Comma-separated object list to exclude from the coverage report. Format: [schema.]package[,[schema.]package ...]. See coverage reporting options in framework documentation. + +-q - Does not output the informational messages normally printed to console. + Default: false + +-d - Outputs a load of debug information to console + Default: false ``` Parameters -f, -o, -s are correlated. That is parameters -o and -s are controlling outputs for reporter specified by the preceding -f parameter. From 36ac26e729164fa72f2662903e4d2e7d1ad5fd17 Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 7 Feb 2019 22:21:57 +0100 Subject: [PATCH 09/14] Reporters- and VersionInfo-Command should not log atm --- src/main/java/org/utplsql/cli/ReportersCommand.java | 2 ++ src/main/java/org/utplsql/cli/VersionInfoCommand.java | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/main/java/org/utplsql/cli/ReportersCommand.java b/src/main/java/org/utplsql/cli/ReportersCommand.java index 6d297a4..f17de98 100644 --- a/src/main/java/org/utplsql/cli/ReportersCommand.java +++ b/src/main/java/org/utplsql/cli/ReportersCommand.java @@ -36,6 +36,8 @@ private ConnectionInfo getConnectionInfo() { @Override public int run() { + LoggerConfiguration.configure(true, false ); + try { DataSource ds = DataSourceProvider.getDataSource(getConnectionInfo(), 1); try (Connection con = ds.getConnection()) { diff --git a/src/main/java/org/utplsql/cli/VersionInfoCommand.java b/src/main/java/org/utplsql/cli/VersionInfoCommand.java index b391df8..8cc6c97 100644 --- a/src/main/java/org/utplsql/cli/VersionInfoCommand.java +++ b/src/main/java/org/utplsql/cli/VersionInfoCommand.java @@ -34,6 +34,8 @@ public ConnectionInfo getConnectionInfo() { public int run() { + LoggerConfiguration.configure(true, false ); + System.out.println(CliVersionInfo.getInfo()); System.out.println(JavaApiVersionInfo.getInfo()); From 00c712adaabd8b3d9f7e943fa7326e5c8eb9fa27 Mon Sep 17 00:00:00 2001 From: Pazus Date: Mon, 11 Feb 2019 09:34:31 +0100 Subject: [PATCH 10/14] Update src/main/java/org/utplsql/cli/LoggerConfiguration.java Co-Authored-By: pesse --- src/main/java/org/utplsql/cli/LoggerConfiguration.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/utplsql/cli/LoggerConfiguration.java b/src/main/java/org/utplsql/cli/LoggerConfiguration.java index b18e6f2..41c1c87 100644 --- a/src/main/java/org/utplsql/cli/LoggerConfiguration.java +++ b/src/main/java/org/utplsql/cli/LoggerConfiguration.java @@ -11,7 +11,9 @@ import org.utplsql.api.TestRunner; class LoggerConfiguration { - + private LoggerConfiguration() { + throw new UnsupportedOperationException(); + } static void configure(boolean silent, boolean debug) { if ( silent ) configureSilent(); From 053dfc9df81f18acd3826d2d3577919c617bf99e Mon Sep 17 00:00:00 2001 From: pesse Date: Tue, 12 Feb 2019 22:04:43 +0100 Subject: [PATCH 11/14] Refactoring according to Pazus suggestions --- src/main/java/org/utplsql/cli/Cli.java | 2 + .../org/utplsql/cli/LoggerConfiguration.java | 55 ++++++++++++------- .../org/utplsql/cli/ReportersCommand.java | 2 - src/main/java/org/utplsql/cli/RunCommand.java | 13 ++++- .../org/utplsql/cli/VersionInfoCommand.java | 2 - ...st.java => RunCommandConfigLevelTest.java} | 2 +- 6 files changed, 48 insertions(+), 28 deletions(-) rename src/test/java/org/utplsql/cli/{RunCommandLogLevelTest.java => RunCommandConfigLevelTest.java} (96%) diff --git a/src/main/java/org/utplsql/cli/Cli.java b/src/main/java/org/utplsql/cli/Cli.java index a2e9202..f82d80c 100644 --- a/src/main/java/org/utplsql/cli/Cli.java +++ b/src/main/java/org/utplsql/cli/Cli.java @@ -18,6 +18,8 @@ public static void main(String[] args) { } static int runWithExitCode( String[] args ) { + + LoggerConfiguration.configure(LoggerConfiguration.ConfigLevel.NONE); LocaleInitializer.initLocale(); JCommander jc = new JCommander(); diff --git a/src/main/java/org/utplsql/cli/LoggerConfiguration.java b/src/main/java/org/utplsql/cli/LoggerConfiguration.java index 41c1c87..a10d8e6 100644 --- a/src/main/java/org/utplsql/cli/LoggerConfiguration.java +++ b/src/main/java/org/utplsql/cli/LoggerConfiguration.java @@ -8,44 +8,57 @@ import ch.qos.logback.core.ConsoleAppender; import com.zaxxer.hikari.HikariDataSource; import org.slf4j.LoggerFactory; -import org.utplsql.api.TestRunner; class LoggerConfiguration { + + public enum ConfigLevel { + BASIC, NONE, DEBUG + } + private LoggerConfiguration() { throw new UnsupportedOperationException(); } - static void configure(boolean silent, boolean debug) { - if ( silent ) - configureSilent(); - else if ( debug ) - configureDebug(); - else - configureDefault(); + + static void configure(ConfigLevel level) { + switch ( level ) { + case BASIC: + configureInfo(); + break; + case NONE: + configureSilent(); + break; + case DEBUG: + configureDebug(); + break; + } } private static void configureSilent() { - Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); - root.setLevel(Level.OFF); + setRootLoggerLevel(Level.OFF); } - private static void configureDefault() { - Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); - root.setLevel(Level.INFO); - - ((Logger) LoggerFactory.getLogger(HikariDataSource.class)).setLevel(Level.OFF); - ((Logger) LoggerFactory.getLogger(TestRunner.class)).setLevel(Level.ERROR); - - setSingleConsoleAppenderWithLayout(root, "%msg%n"); + private static void configureInfo() { + setRootLoggerLevel(Level.INFO); + muteHikariLogger(); + setSingleConsoleAppenderWithLayout("%msg%n"); } private static void configureDebug() { + setRootLoggerLevel(Level.DEBUG); + setSingleConsoleAppenderWithLayout("%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"); + } + + private static void setRootLoggerLevel( Level level ) { Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); - root.setLevel(Level.DEBUG); + root.setLevel(level); + } - setSingleConsoleAppenderWithLayout(root, "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"); + private static void muteHikariLogger() { + ((Logger) LoggerFactory.getLogger(HikariDataSource.class)).setLevel(Level.OFF); } - private static void setSingleConsoleAppenderWithLayout( Logger logger, String patternLayout ) { + private static void setSingleConsoleAppenderWithLayout( String patternLayout ) { + Logger logger = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); diff --git a/src/main/java/org/utplsql/cli/ReportersCommand.java b/src/main/java/org/utplsql/cli/ReportersCommand.java index f17de98..6d297a4 100644 --- a/src/main/java/org/utplsql/cli/ReportersCommand.java +++ b/src/main/java/org/utplsql/cli/ReportersCommand.java @@ -36,8 +36,6 @@ private ConnectionInfo getConnectionInfo() { @Override public int run() { - LoggerConfiguration.configure(true, false ); - try { DataSource ds = DataSourceProvider.getDataSource(getConnectionInfo(), 1); try (Connection con = ds.getConnection()) { diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index 8112f37..576ea43 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -125,7 +125,16 @@ public List getTestPaths() { } void init() { - LoggerConfiguration.configure(logSilent, logDebug); + + LoggerConfiguration.ConfigLevel level = LoggerConfiguration.ConfigLevel.BASIC; + if ( logSilent ) { + level = LoggerConfiguration.ConfigLevel.NONE; + } + else if ( logDebug ) { + level = LoggerConfiguration.ConfigLevel.DEBUG; + } + + LoggerConfiguration.configure(level); } public int run() { @@ -251,7 +260,7 @@ private void initDatabase(DataSource dataSource) throws SQLException { // First of all do a compatibility check and fail-fast compatibilityProxy = checkFrameworkCompatibility(conn); - logger.info("Successfully connected to database. UtPLSQL core: " + compatibilityProxy.getDatabaseVersion()); + logger.info("Successfully connected to database. UtPLSQL core: {}", compatibilityProxy.getDatabaseVersion()); logger.info("Oracle-Version: {}", new DefaultDatabaseInformation().getOracleVersion(conn)); } catch (SQLException e) { diff --git a/src/main/java/org/utplsql/cli/VersionInfoCommand.java b/src/main/java/org/utplsql/cli/VersionInfoCommand.java index 8cc6c97..b391df8 100644 --- a/src/main/java/org/utplsql/cli/VersionInfoCommand.java +++ b/src/main/java/org/utplsql/cli/VersionInfoCommand.java @@ -34,8 +34,6 @@ public ConnectionInfo getConnectionInfo() { public int run() { - LoggerConfiguration.configure(true, false ); - System.out.println(CliVersionInfo.getInfo()); System.out.println(JavaApiVersionInfo.getInfo()); diff --git a/src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java b/src/test/java/org/utplsql/cli/RunCommandConfigLevelTest.java similarity index 96% rename from src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java rename to src/test/java/org/utplsql/cli/RunCommandConfigLevelTest.java index 100e5ea..411a0e3 100644 --- a/src/test/java/org/utplsql/cli/RunCommandLogLevelTest.java +++ b/src/test/java/org/utplsql/cli/RunCommandConfigLevelTest.java @@ -7,7 +7,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -public class RunCommandLogLevelTest { +public class RunCommandConfigLevelTest { private Logger getRootLogger() { return (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); From 351c76a15e20d440be83adb8e9075dd6e585400c Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 14 Feb 2019 08:15:10 +0100 Subject: [PATCH 12/14] Some more information around used connector and NLS --- src/main/java/org/utplsql/cli/RunCommand.java | 1 + .../org/utplsql/cli/datasource/TestedDataSourceProvider.java | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/src/main/java/org/utplsql/cli/RunCommand.java b/src/main/java/org/utplsql/cli/RunCommand.java index 576ea43..4142f9a 100644 --- a/src/main/java/org/utplsql/cli/RunCommand.java +++ b/src/main/java/org/utplsql/cli/RunCommand.java @@ -244,6 +244,7 @@ private void outputMainInformation() { formatter.appendLine(JavaApiVersionInfo.getInfo()); formatter.appendLine("Java-Version: " + System.getProperty("java.version")); formatter.appendLine("ORACLE_HOME: " + EnvironmentVariableUtil.getEnvValue("ORACLE_HOME")); + formatter.appendLine("NLS_LANG: " + EnvironmentVariableUtil.getEnvValue("NLS_LANG")); formatter.appendLine(""); formatter.appendLine("Thanks for testing!"); diff --git a/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java b/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java index f30cd91..6f33c34 100644 --- a/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java +++ b/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java @@ -1,6 +1,8 @@ package org.utplsql.cli.datasource; import com.zaxxer.hikari.HikariDataSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.utplsql.api.EnvironmentVariableUtil; import org.utplsql.cli.ConnectionConfig; import org.utplsql.cli.exception.DatabaseConnectionFailed; @@ -19,6 +21,7 @@ interface ConnectStringPossibility { String getMaskedConnectString(ConnectionConfig config); } + private static final Logger logger = LoggerFactory.getLogger(TestedDataSourceProvider.class); private final ConnectionConfig config; private List possibilities = new ArrayList<>(); @@ -46,6 +49,7 @@ private void setThickOrThinJdbcUrl(HikariDataSource ds ) throws SQLException for (ConnectStringPossibility possibility : possibilities) { ds.setJdbcUrl(possibility.getConnectString(config)); try (Connection con = ds.getConnection()) { + logger.info("Use connectstring {}", possibility.getMaskedConnectString(config)); return; } catch (UnsatisfiedLinkError | Exception e) { errors.add(possibility.getMaskedConnectString(config) + ": " + e.getMessage()); @@ -78,6 +82,7 @@ private void setInitSqlFrom_NLS_LANG(HikariDataSource ds ) { sb.append(String.format("EXECUTE IMMEDIATE q'[%s]';\n", command)); sb.append("END;"); + logger.debug("NLS settings: {}", sb.toString()); ds.setConnectionInitSql(sb.toString()); } } From 0733e11a7ced963d4097a3ca3e48ce8d41a26a87 Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 14 Feb 2019 08:36:20 +0100 Subject: [PATCH 13/14] Separate username/PW from connectstring so it's properly masked in logging --- .../utplsql/cli/datasource/TestedDataSourceProvider.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java b/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java index 6f33c34..a0bc3ab 100644 --- a/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java +++ b/src/main/java/org/utplsql/cli/datasource/TestedDataSourceProvider.java @@ -46,6 +46,10 @@ private void setThickOrThinJdbcUrl(HikariDataSource ds ) throws SQLException { List errors = new ArrayList<>(); Throwable lastException = null; + + ds.setUsername(config.getUser()); + ds.setPassword(config.getPassword()); + for (ConnectStringPossibility possibility : possibilities) { ds.setJdbcUrl(possibility.getConnectString(config)); try (Connection con = ds.getConnection()) { @@ -92,7 +96,7 @@ private void setInitSqlFrom_NLS_LANG(HikariDataSource ds ) { private static class ThickConnectStringPossibility implements ConnectStringPossibility { @Override public String getConnectString(ConnectionConfig config) { - return "jdbc:oracle:oci8:" + config.getConnectString(); + return "jdbc:oracle:oci8:@" + config.getConnect(); } @Override @@ -104,7 +108,7 @@ public String getMaskedConnectString(ConnectionConfig config) { private static class ThinConnectStringPossibility implements ConnectStringPossibility { @Override public String getConnectString(ConnectionConfig config) { - return "jdbc:oracle:thin:" + config.getConnectString(); + return "jdbc:oracle:thin:@" + config.getConnect(); } @Override From 2578f8ab5fe404c6f98ad5ee44e30d86f02b27b9 Mon Sep 17 00:00:00 2001 From: pesse Date: Thu, 14 Feb 2019 20:55:09 +0100 Subject: [PATCH 14/14] Reporters Command should abort when no connection is possible --- src/main/java/org/utplsql/cli/ReportersCommand.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/org/utplsql/cli/ReportersCommand.java b/src/main/java/org/utplsql/cli/ReportersCommand.java index 6d297a4..0c3560a 100644 --- a/src/main/java/org/utplsql/cli/ReportersCommand.java +++ b/src/main/java/org/utplsql/cli/ReportersCommand.java @@ -47,6 +47,7 @@ public int run() { } catch ( DatabaseNotCompatibleException | UtPLSQLNotInstalledException | DatabaseConnectionFailed | IllegalArgumentException e ) { System.out.println(e.getMessage()); + return 1; } catch (Exception e) { e.printStackTrace();