This is an automated email from the ASF dual-hosted git repository. klund pushed a commit to branch develop in repository https://gitbox.apache.org/repos/asf/geode.git
commit fb21c24e4a4d0f6041a3032a3e4a38c448de9088 Author: Kirk Lund <[email protected]> AuthorDate: Fri Oct 5 11:15:39 2018 -0700 GEODE-2644: Cleanup logging tests --- .../logging/CacheLogRollingIntegrationTest.java | 10 +- .../DistributedSystemLogFileIntegrationTest.java | 2514 ++++++++------------ .../logging/LocatorLogFileIntegrationTest.java | 137 +- .../logging/LogServiceIntegrationTest.java | 20 +- .../internal/logging/log4j/FastLoggerTest.java | 128 +- .../log4j/HexThreadIdPatternConverterTest.java | 3 + 6 files changed, 1154 insertions(+), 1658 deletions(-) diff --git a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/CacheLogRollingIntegrationTest.java b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/CacheLogRollingIntegrationTest.java index 278a95f..5b2b77f 100644 --- a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/CacheLogRollingIntegrationTest.java +++ b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/CacheLogRollingIntegrationTest.java @@ -75,14 +75,14 @@ public class CacheLogRollingIntegrationTest { } @After - public void after() throws Exception { + public void after() { if (system != null) { system.disconnect(); } } @Test - public void testSimpleStartRestartWithRolling() throws Exception { + public void testSimpleStartRestartWithRolling() { Properties config = createConfig(); config.put(LOG_FILE, logFile.getAbsolutePath()); config.put(LOG_FILE_SIZE_LIMIT, "1"); @@ -160,7 +160,7 @@ public class CacheLogRollingIntegrationTest { } @Test - public void with_logFileSizeLimit_should_createMetaLogFile() throws Exception { + public void with_logFileSizeLimit_should_createMetaLogFile() { Properties config = createConfig(); config.put(LOG_FILE, logFile.getAbsolutePath()); config.put(LOG_FILE_SIZE_LIMIT, "1"); @@ -176,7 +176,7 @@ public class CacheLogRollingIntegrationTest { } @Test - public void without_logFileSizeLimit_shouldNot_createMetaLogFile() throws Exception { + public void without_logFileSizeLimit_shouldNot_createMetaLogFile() { Properties config = createConfig(); config.put(LOG_FILE, logFile.getAbsolutePath()); @@ -201,7 +201,7 @@ public class CacheLogRollingIntegrationTest { assertThat(file).exists(); BufferedReader reader = new BufferedReader(new FileReader(file)); - StringBuffer buffer = new StringBuffer(); + StringBuilder buffer = new StringBuilder(); int numRead; char[] chars = new char[1024]; diff --git a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/DistributedSystemLogFileIntegrationTest.java b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/DistributedSystemLogFileIntegrationTest.java index 07456ba..e03b0f4 100755 --- a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/DistributedSystemLogFileIntegrationTest.java +++ b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/DistributedSystemLogFileIntegrationTest.java @@ -14,26 +14,26 @@ */ package org.apache.geode.internal.logging; -import static org.apache.geode.distributed.ConfigurationProperties.DISABLE_AUTO_RECONNECT; -import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_CLUSTER_CONFIGURATION; -import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_NETWORK_PARTITION_DETECTION; +import static org.apache.commons.lang.SystemUtils.LINE_SEPARATOR; import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; import static org.apache.geode.distributed.ConfigurationProperties.LOG_FILE; import static org.apache.geode.distributed.ConfigurationProperties.LOG_LEVEL; import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT; -import static org.apache.geode.distributed.ConfigurationProperties.MEMBER_TIMEOUT; import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_LOG_FILE; import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_LOG_LEVEL; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.fail; +import static org.awaitility.Awaitility.await; import java.io.File; import java.io.FileInputStream; -import java.io.FileNotFoundException; +import java.io.IOException; +import java.nio.file.Files; +import java.util.List; import java.util.Properties; import java.util.Scanner; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.LogManager; @@ -44,15 +44,15 @@ import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; +import org.junit.rules.TemporaryFolder; import org.junit.rules.TestName; +import org.apache.geode.LogWriter; import org.apache.geode.distributed.DistributedSystem; import org.apache.geode.distributed.internal.DistributionConfig; import org.apache.geode.distributed.internal.InternalDistributedSystem; import org.apache.geode.internal.logging.log4j.FastLogger; import org.apache.geode.internal.logging.log4j.LogWriterLogger; -import org.apache.geode.test.dunit.Wait; -import org.apache.geode.test.dunit.WaitCriterion; import org.apache.geode.test.junit.categories.LoggingTest; /** @@ -61,22 +61,40 @@ import org.apache.geode.test.junit.categories.LoggingTest; @Category(LoggingTest.class) public class DistributedSystemLogFileIntegrationTest { - private static final int TIMEOUT_MILLISECONDS = 180 * 1000; // 2 minutes - private static final int INTERVAL_MILLISECONDS = 100; // 100 milliseconds + private static final AtomicInteger COUNTER = new AtomicInteger(); - private DistributedSystem system; + private File logFile; + private String logFileName; + private File securityLogFile; + private String securityLogFileName; + + private InternalDistributedSystem system; + + private String prefix; + + @Rule + public TemporaryFolder temporaryFolder = new TemporaryFolder(); @Rule - public TestName name = new TestName(); + public TestName testName = new TestName(); @Before - public void setUp() throws Exception {} + public void setUp() { + logFile = new File(temporaryFolder.getRoot(), + testName.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"); + logFileName = logFile.getAbsolutePath(); + + securityLogFile = new File(temporaryFolder.getRoot(), + "security-" + testName.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"); + securityLogFileName = securityLogFile.getAbsolutePath(); + + prefix = "ExpectedStrings: " + testName.getMethodName() + " message logged at "; + } @After public void tearDown() throws Exception { if (system != null) { system.disconnect(); - system = null; } // We will want to remove this at some point but right now the log context // does not clear out the security logconfig between tests @@ -85,1212 +103,829 @@ public class DistributedSystemLogFileIntegrationTest { } @Test - public void testDistributedSystemCreatesLogFile() throws Exception { - final String logFileName = name.getMethodName() + "-system-0.log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "config"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); + public void testDistributedSystemLogWritersWithFilesDetails() throws Exception { + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(SECURITY_LOG_FILE, securityLogFileName); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); + + system = (InternalDistributedSystem) DistributedSystem.connect(config); + + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> { + assertThat(logFile).exists(); + assertThat(securityLogFile).exists(); + }); + + // assertThat logFile is not empty + try (FileInputStream fis = new FileInputStream(logFile)) { + assertThat(fis.available()).isGreaterThan(0); } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.CONFIG_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.CONFIG_LEVEL, config.getLogLevel()); - - // CONFIG has been replaced with INFO -- all CONFIG statements are now logged at INFO as well - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(logWriter); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return logFile.exists(); - } - @Override - public String description() { - return "waiting for log file to exist: " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(logFile.exists()); - - // assert not empty - FileInputStream fis = new FileInputStream(logFile); - try { - assertTrue("log file is empty: " + logFile.getAbsoluteFile(), fis.available() > 0); - } finally { - fis.close(); - } + DistributionConfig distributionConfig = system.getConfig(); - final Logger logger = LogService.getLogger(); - final Logger appLogger = LogManager.getLogger("net.customer"); - assertEquals(Level.INFO, appLogger.getLevel()); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertTrue(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = - "ExpectedStrings: testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertFalse(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - - i++; - final String TRACE_STRING_A = "Message logged at TRACE level [" + i + "]"; - appLogger.trace(TRACE_STRING_A); - assertFalse(fileContainsString(logFile, TRACE_STRING_A)); - - i++; - final String DEBUG_STRING_A = "Message logged at DEBUG level [" + i + "]"; - appLogger.debug(DEBUG_STRING_A); - assertFalse(fileContainsString(logFile, DEBUG_STRING_A)); - - i++; - final String INFO_STRING_A = "Message logged at INFO level [" + i + "]"; - appLogger.info(INFO_STRING_A); - assertTrue(fileContainsString(logFile, INFO_STRING_A)); - - i++; - final String WARN_STRING_A = "ExpectedStrings: Message logged at WARN level [" + i + "]"; - appLogger.warn(WARN_STRING_A); - assertTrue(fileContainsString(logFile, WARN_STRING_A)); - - i++; - final String ERROR_STRING_A = "ExpectedStrings: Message logged at ERROR level [" + i + "]"; - appLogger.error(ERROR_STRING_A); - assertTrue(fileContainsString(logFile, ERROR_STRING_A)); - - i++; - final String FATAL_STRING_A = "ExpectedStrings: Message logged at FATAL level [" + i + "]"; - appLogger.fatal(FATAL_STRING_A); - assertTrue(fileContainsString(logFile, FATAL_STRING_A)); - } + assertThat(distributionConfig.getLogLevel()) + .isEqualTo(LogWriterLevel.CONFIG.getLogWriterLevel()); + assertThat(distributionConfig.getSecurityLogLevel()) + .isEqualTo(LogWriterLevel.CONFIG.getLogWriterLevel()); - // change log level to fine and verify - config.setLogLevel(InternalLogWriter.FINE_LEVEL); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel()); - - assertEquals(Level.DEBUG, appLogger.getLevel()); - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertTrue(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertTrue(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertTrue(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - - i++; - final String TRACE_STRING_A = "Message logged at TRACE level [" + i + "]"; - appLogger.trace(TRACE_STRING_A); - assertFalse(fileContainsString(logFile, TRACE_STRING_A)); - - i++; - final String DEBUG_STRING_A = "Message logged at DEBUG level [" + i + "]"; - appLogger.debug(DEBUG_STRING_A); - assertTrue(fileContainsString(logFile, DEBUG_STRING_A)); - - i++; - final String INFO_STRING_A = "Message logged at INFO level [" + i + "]"; - appLogger.info(INFO_STRING_A); - assertTrue(fileContainsString(logFile, INFO_STRING_A)); - - i++; - final String WARN_STRING_A = "ExpectedStrings: Message logged at WARN level [" + i + "]"; - appLogger.warn(WARN_STRING_A); - assertTrue(fileContainsString(logFile, WARN_STRING_A)); - - i++; - final String ERROR_STRING_A = "ExpectedStrings: Message logged at ERROR level [" + i + "]"; - appLogger.error(ERROR_STRING_A); - assertTrue(fileContainsString(logFile, ERROR_STRING_A)); - - i++; - final String FATAL_STRING_A = "ExpectedStrings: Message logged at FATAL level [" + i + "]"; - appLogger.fatal(FATAL_STRING_A); - assertTrue(fileContainsString(logFile, FATAL_STRING_A)); - } + assertThat(distributionConfig.getLogFile().getAbsolutePath()).isEqualTo(logFileName); + assertThat(distributionConfig.getSecurityLogFile().getAbsolutePath()) + .isEqualTo(securityLogFileName); + + assertThat(system.getLogWriter()).isInstanceOf(LogWriterLogger.class); + assertThat(system.getSecurityLogWriter()).isInstanceOf(LogWriterLogger.class); + + LogWriterLogger logWriterLogger = (LogWriterLogger) system.getLogWriter(); + LogWriterLogger securityLogWriterLogger = (LogWriterLogger) system.getSecurityLogWriter(); - // change log level to error and verify - config.setLogLevel(InternalLogWriter.ERROR_LEVEL); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.ERROR_LEVEL, config.getLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.ERROR_LEVEL, logWriter.getLogWriterLevel()); - - assertEquals(Level.ERROR, appLogger.getLevel()); - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertFalse(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertFalse(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertFalse(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertFalse(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertFalse(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertFalse(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - - i++; - final String TRACE_STRING_A = "Message logged at TRACE level [" + i + "]"; - appLogger.trace(TRACE_STRING_A); - assertFalse(fileContainsString(logFile, TRACE_STRING_A)); - - i++; - final String DEBUG_STRING_A = "Message logged at DEBUG level [" + i + "]"; - appLogger.debug(DEBUG_STRING_A); - assertFalse(fileContainsString(logFile, DEBUG_STRING_A)); - - i++; - final String INFO_STRING_A = "Message logged at INFO level [" + i + "]"; - appLogger.info(INFO_STRING_A); - assertFalse(fileContainsString(logFile, INFO_STRING_A)); - - i++; - final String WARN_STRING_A = "ExpectedStrings: Message logged at WARN level [" + i + "]"; - appLogger.warn(WARN_STRING_A); - assertFalse(fileContainsString(logFile, WARN_STRING_A)); - - i++; - final String ERROR_STRING_A = "ExpectedStrings: Message logged at ERROR level [" + i + "]"; - appLogger.error(ERROR_STRING_A); - assertTrue(fileContainsString(logFile, ERROR_STRING_A)); - - i++; - final String FATAL_STRING_A = "ExpectedStrings: Message logged at FATAL level [" + i + "]"; - appLogger.fatal(FATAL_STRING_A); - assertTrue(fileContainsString(logFile, FATAL_STRING_A)); + assertThat(logWriterLogger.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(securityLogWriterLogger.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + + securityLogWriterLogger.info("test: security log file created at info"); + + // assertThat securityLogFile is not empty + try (FileInputStream fis = new FileInputStream(securityLogFile)) { + assertThat(fis.available()).isGreaterThan(0); } - system.disconnect(); - system = null; + LogWriter logWriter = logWriterLogger; + assertThat(logWriter.finestEnabled()).isFalse(); + assertThat(logWriter.finerEnabled()).isFalse(); + assertThat(logWriter.fineEnabled()).isFalse(); + assertThat(logWriter.configEnabled()).isTrue(); + assertThat(logWriter.infoEnabled()).isTrue(); + assertThat(logWriter.warningEnabled()).isTrue(); + assertThat(logWriter.errorEnabled()).isTrue(); + assertThat(logWriter.severeEnabled()).isTrue(); + + FastLogger logWriterFastLogger = logWriterLogger; + // assertThat(logWriterFastLogger.isDelegating()).isTrue(); + assertThat(logWriterFastLogger.isTraceEnabled()).isFalse(); + assertThat(logWriterFastLogger.isDebugEnabled()).isFalse(); + assertThat(logWriterFastLogger.isInfoEnabled()).isTrue(); + assertThat(logWriterFastLogger.isWarnEnabled()).isTrue(); + assertThat(logWriterFastLogger.isErrorEnabled()).isTrue(); + assertThat(logWriterFastLogger.isFatalEnabled()).isTrue(); + + LogWriter securityLogWriter = securityLogWriterLogger; + assertThat(securityLogWriter.finestEnabled()).isFalse(); + assertThat(securityLogWriter.finerEnabled()).isFalse(); + assertThat(securityLogWriter.fineEnabled()).isFalse(); + assertThat(securityLogWriter.configEnabled()).isTrue(); + assertThat(securityLogWriter.infoEnabled()).isTrue(); + assertThat(securityLogWriter.warningEnabled()).isTrue(); + assertThat(securityLogWriter.errorEnabled()).isTrue(); + assertThat(securityLogWriter.severeEnabled()).isTrue(); + + FastLogger securityLogWriterFastLogger = logWriterLogger; + // assertThat(securityLogWriterFastLogger.isDelegating()).isFalse(); + assertThat(securityLogWriterFastLogger.isTraceEnabled()).isFalse(); + assertThat(securityLogWriterFastLogger.isDebugEnabled()).isFalse(); + assertThat(securityLogWriterFastLogger.isInfoEnabled()).isTrue(); + assertThat(securityLogWriterFastLogger.isWarnEnabled()).isTrue(); + assertThat(securityLogWriterFastLogger.isErrorEnabled()).isTrue(); + assertThat(securityLogWriterFastLogger.isFatalEnabled()).isTrue(); } @Test - public void testDistributedSystemWithFineLogLevel() throws Exception { - final String logFileName = - name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "fine"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); - } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getLogLevel()); - - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(logWriter); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel()); - assertTrue(logWriter.fineEnabled()); - assertTrue(((LogWriterLogger) logWriter).isDebugEnabled()); - assertTrue(logWriter instanceof FastLogger); - assertTrue(((FastLogger) logWriter).isDelegating()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return logFile.exists(); - } + public void testDistributedSystemCreatesLogFile() throws Exception { + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(LOG_LEVEL, "config"); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); - @Override - public String description() { - return "waiting for log file to exist: " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(logFile.exists()); - - // assert not empty - FileInputStream fis = new FileInputStream(logFile); - try { - assertTrue(fis.available() > 0); - } finally { - fis.close(); - } + system = (InternalDistributedSystem) DistributedSystem.connect(config); - final Logger logger = LogService.getLogger(); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertTrue(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertTrue(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertTrue(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - } + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> assertThat(logFile).exists()); - // change log level to error and verify - config.setLogLevel(InternalLogWriter.ERROR_LEVEL); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.ERROR_LEVEL, config.getLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.ERROR_LEVEL, logWriter.getLogWriterLevel()); - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertFalse(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertFalse(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertFalse(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertFalse(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertFalse(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertFalse(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - } + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + Logger geodeLogger = LogService.getLogger(); + Logger applicationLogger = LogManager.getLogger("net.customer"); - system.disconnect(); - system = null; - } + // ------------------------------------------------------------------------------------------- + // CONFIG level - @Test - public void testDistributedSystemWithDebugLogLevel() throws Exception { - final String logFileName = - name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "debug"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); - } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getLogLevel()); - - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(logWriter); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel()); - assertTrue(logWriter.fineEnabled()); - assertTrue(((LogWriterLogger) logWriter).isDebugEnabled()); - assertTrue(logWriter instanceof FastLogger); - assertTrue(((FastLogger) logWriter).isDelegating()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return logFile.exists(); - } + DistributionConfig distributionConfig = system.getConfig(); - @Override - public String description() { - return "waiting for log file to exist: " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(logFile.exists()); - - // assert not empty - FileInputStream fis = new FileInputStream(logFile); - try { - assertTrue(fis.available() > 0); - } finally { - fis.close(); - } + assertThat(distributionConfig.getLogLevel()) + .isEqualTo(LogWriterLevel.CONFIG.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.INFO); + assertThat(applicationLogger.getLevel()).isEqualTo(Level.INFO); - final Logger logger = LogService.getLogger(); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertTrue(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertTrue(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertTrue(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - } + String message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); - // change log level to error and verify - config.setLogLevel(InternalLogWriter.ERROR_LEVEL); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.ERROR_LEVEL, config.getLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.ERROR_LEVEL, logWriter.getLogWriterLevel()); - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - logWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - logWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - logWriter.fine(FINE_STRING); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - logWriter.config(CONFIG_STRING); - assertFalse(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - logWriter.info(INFO_STRING); - assertFalse(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - logWriter.warning(WARNING_STRING); - assertFalse(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - logWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertFalse(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertFalse(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertFalse(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - } + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + applicationLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + applicationLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + applicationLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + applicationLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + applicationLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + applicationLogger.fatal(message); + assertThatFileContains(logFile, message); + + // ------------------------------------------------------------------------------------------- + // FINE level + + distributionConfig.setLogLevel(LogWriterLevel.FINE.getLogWriterLevel()); + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); + assertThat(applicationLogger.getLevel()).isEqualTo(Level.DEBUG); + + message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileContains(logFile, message); - system.disconnect(); - system = null; + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + applicationLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + applicationLogger.debug(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.INFO); + applicationLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + applicationLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + applicationLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + applicationLogger.fatal(message); + assertThatFileContains(logFile, message); + + // ------------------------------------------------------------------------------------------- + // ERROR level + + distributionConfig.setLogLevel(LogWriterLevel.ERROR.getLogWriterLevel()); + + assertThat(distributionConfig.getLogLevel()) + .isEqualTo(LogWriterLevel.ERROR.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.ERROR.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.ERROR); + assertThat(applicationLogger.getLevel()).isEqualTo(Level.ERROR); + + message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + applicationLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + applicationLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + applicationLogger.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.WARN); + applicationLogger.warn(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.ERROR); + applicationLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + applicationLogger.fatal(message); + assertThatFileContains(logFile, message); } @Test - public void testDistributedSystemWithSecurityLogDefaultLevel() throws Exception { - final String logFileName = - name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - final String securityLogFileName = - "security" + name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "fine"); - properties.put(SECURITY_LOG_FILE, securityLogFileName); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File securityLogFile = new File(securityLogFileName); - if (securityLogFile.exists()) { - securityLogFile.delete(); - } - assertFalse(securityLogFile.exists()); + public void testDistributedSystemWithFineLogLevel() throws Exception { + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(LOG_LEVEL, "fine"); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); - } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.CONFIG_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.CONFIG_LEVEL, config.getSecurityLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getLogLevel()); - - InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter(); - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(securityLogWriter); - assertNotNull(logWriter); - assertTrue(securityLogWriter instanceof LogWriterLogger); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.INFO_LEVEL, securityLogWriter.getLogWriterLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel()); - assertFalse(securityLogWriter.fineEnabled()); - assertTrue(logWriter.fineEnabled()); - - assertFalse(((LogWriterLogger) securityLogWriter).isDebugEnabled()); - assertTrue(((LogWriterLogger) logWriter).isDebugEnabled()); - assertTrue(securityLogWriter instanceof FastLogger); - assertTrue(logWriter instanceof FastLogger); - // Because debug available is a static volatile, it is shared between the two writers - // However we should not see any debug level logging due to the config level set in - // the log writer itself - assertTrue(((FastLogger) securityLogWriter).isDelegating()); - assertTrue(((FastLogger) logWriter).isDelegating()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return securityLogFile.exists() && logFile.exists(); - } + system = (InternalDistributedSystem) DistributedSystem.connect(config); - @Override - public String description() { - return "waiting for log files to exist: " + securityLogFile + ", " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(securityLogFile.exists()); - assertTrue(logFile.exists()); - - securityLogWriter.info("test: security log file created at info"); - // assert not empty - FileInputStream fis = new FileInputStream(securityLogFile); - try { - assertTrue(fis.available() > 0); - } finally { - fis.close(); - } + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> assertThat(logFile).exists()); - final Logger logger = LogService.getLogger(); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - securityLogWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(securityLogFile, FINEST_STRING)); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - securityLogWriter.fine(FINE_STRING); - assertFalse(fileContainsString(securityLogFile, FINE_STRING)); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - securityLogWriter.info(INFO_STRING); - assertTrue(fileContainsString(securityLogFile, INFO_STRING)); - assertFalse(fileContainsString(logFile, INFO_STRING)); - - i++; - final String FINE_STRING_FOR_LOGGER = - "testLogLevels Message logged at FINE level [" + i + "]"; - logger.debug(FINE_STRING_FOR_LOGGER); - assertFalse(fileContainsString(securityLogFile, FINE_STRING_FOR_LOGGER)); - assertTrue(fileContainsString(logFile, FINE_STRING_FOR_LOGGER)); - } + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + Logger geodeLogger = LogService.getLogger(); + + DistributionConfig distributionConfig = system.getConfig(); + + // ------------------------------------------------------------------------------------------- + // FINE level + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); + + String message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileContains(logFile, message); - system.disconnect(); - system = null; + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + + // ------------------------------------------------------------------------------------------- + // ERROR level + + distributionConfig.setLogLevel(LogWriterLevel.ERROR.getLogWriterLevel()); + + assertThat(distributionConfig.getLogLevel()) + .isEqualTo(LogWriterLevel.ERROR.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.ERROR.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.ERROR); + + message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); } @Test - public void testDistributedSystemWithSecurityLogFineLevel() throws Exception { - final String logFileName = - name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - final String securityLogFileName = - "security" + name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "fine"); - properties.put(SECURITY_LOG_FILE, securityLogFileName); - properties.put(SECURITY_LOG_LEVEL, "fine"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File securityLogFile = new File(securityLogFileName); - if (securityLogFile.exists()) { - securityLogFile.delete(); - } - assertFalse(securityLogFile.exists()); + public void testDistributedSystemWithDebugLogLevel() throws Exception { + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(LOG_LEVEL, "debug"); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); - } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getSecurityLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getLogLevel()); - - InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter(); - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(securityLogWriter); - assertNotNull(logWriter); - assertTrue(securityLogWriter instanceof LogWriterLogger); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, securityLogWriter.getLogWriterLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel()); - assertTrue(securityLogWriter.fineEnabled()); - assertTrue(logWriter.fineEnabled()); - - assertTrue(((LogWriterLogger) securityLogWriter).isDebugEnabled()); - assertTrue(((LogWriterLogger) logWriter).isDebugEnabled()); - assertTrue(securityLogWriter instanceof FastLogger); - assertTrue(logWriter instanceof FastLogger); - assertTrue(((FastLogger) securityLogWriter).isDelegating()); - assertTrue(((FastLogger) logWriter).isDelegating()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return securityLogFile.exists() && logFile.exists(); - } + system = (InternalDistributedSystem) DistributedSystem.connect(config); - @Override - public String description() { - return "waiting for log files to exist: " + securityLogFile + ", " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(securityLogFile.exists()); - assertTrue(logFile.exists()); - - // assert not empty - FileInputStream fis = new FileInputStream(securityLogFile); - try { - assertTrue(fis.available() > 0); - } finally { - fis.close(); - } + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> assertThat(logFile).exists()); - final Logger logger = LogService.getLogger(); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - securityLogWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(securityLogFile, FINEST_STRING)); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - securityLogWriter.finer(FINER_STRING); - assertFalse(fileContainsString(securityLogFile, FINER_STRING)); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - securityLogWriter.fine(FINE_STRING); - assertTrue(fileContainsString(securityLogFile, FINE_STRING)); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - securityLogWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(securityLogFile, CONFIG_STRING)); - assertFalse(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - securityLogWriter.info(INFO_STRING); - assertTrue(fileContainsString(securityLogFile, INFO_STRING)); - assertFalse(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - securityLogWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(securityLogFile, WARNING_STRING)); - assertFalse(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - securityLogWriter.error(ERROR_STRING); - assertTrue(fileContainsString(securityLogFile, ERROR_STRING)); - assertFalse(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - securityLogWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(securityLogFile, SEVERE_STRING)); - assertFalse(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(securityLogFile, TRACE_STRING)); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertFalse(fileContainsString(securityLogFile, DEBUG_STRING)); - assertTrue(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertFalse(fileContainsString(securityLogFile, INFO_STRING_J)); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertFalse(fileContainsString(securityLogFile, WARN_STRING)); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertFalse(fileContainsString(securityLogFile, ERROR_STRING_J)); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertFalse(fileContainsString(securityLogFile, FATAL_STRING)); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - } + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + Logger geodeLogger = LogService.getLogger(); + + DistributionConfig distributionConfig = system.getConfig(); + + // ------------------------------------------------------------------------------------------- + // DEBUG LEVEL + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); + + String message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + + // ------------------------------------------------------------------------------------------- + // ERROR LEVEL + + distributionConfig.setLogLevel(LogWriterLevel.ERROR.getLogWriterLevel()); + + assertThat(distributionConfig.getLogLevel()) + .isEqualTo(LogWriterLevel.ERROR.getLogWriterLevel()); + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.ERROR.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.ERROR); + + message = createMessage(LogWriterLevel.FINEST); + logWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + logWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + logWriter.fine(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + logWriter.config(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + logWriter.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + logWriter.warning(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + logWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + logWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + } + + @Test + public void testDistributedSystemWithSecurityLogDefaultLevel() throws Exception { + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(LOG_LEVEL, "fine"); + config.put(SECURITY_LOG_FILE, securityLogFileName); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); + + system = (InternalDistributedSystem) DistributedSystem.connect(config); + + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> { + assertThat(logFile).exists(); + assertThat(securityLogFile).exists(); + }); + + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + LogWriterLogger securityLogWriter = (LogWriterLogger) system.getSecurityLogWriter(); + Logger geodeLogger = LogService.getLogger(); + + DistributionConfig distributionConfig = system.getConfig(); + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(distributionConfig.getSecurityLogLevel()) + .isEqualTo(LogWriterLevel.CONFIG.getLogWriterLevel()); + + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(securityLogWriter.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); + + String message = createMessage(LogWriterLevel.FINEST); + securityLogWriter.finest(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + securityLogWriter.fine(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + securityLogWriter.info(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + geodeLogger.debug(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileContains(logFile, message); + } - system.disconnect(); - system = null; + @Test + public void testDistributedSystemWithSecurityLogFineLevel() throws Exception { + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(LOG_LEVEL, "fine"); + config.put(SECURITY_LOG_FILE, securityLogFileName); + config.put(SECURITY_LOG_LEVEL, "fine"); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); + + system = (InternalDistributedSystem) DistributedSystem.connect(config); + + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> { + assertThat(logFile).exists(); + assertThat(securityLogFile).exists(); + }); + + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + LogWriterLogger securityLogWriter = (LogWriterLogger) system.getSecurityLogWriter(); + Logger geodeLogger = LogService.getLogger(); + + DistributionConfig distributionConfig = system.getConfig(); + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(distributionConfig.getSecurityLogLevel()) + .isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(securityLogWriter.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); + + String message = createMessage(LogWriterLevel.FINEST); + securityLogWriter.finest(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + securityLogWriter.finer(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + securityLogWriter.fine(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + securityLogWriter.config(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + securityLogWriter.info(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + securityLogWriter.warning(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + securityLogWriter.error(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + securityLogWriter.severe(message); + assertThatFileContains(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileDoesNotContain(securityLogFile, message); + assertThatFileContains(logFile, message); } /** @@ -1301,159 +936,87 @@ public class DistributedSystemLogFileIntegrationTest { @Test public void testDistributedSystemWithSecurityInfoLevelAndLogAtFineLevelButNoSecurityLog() throws Exception { - final String logFileName = - name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "fine"); - properties.put(SECURITY_LOG_LEVEL, "info"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); - } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.INFO_LEVEL, config.getSecurityLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getLogLevel()); - - InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter(); - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(securityLogWriter); - assertNotNull(logWriter); - assertTrue(securityLogWriter instanceof LogWriterLogger); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.INFO_LEVEL, securityLogWriter.getLogWriterLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel()); - assertFalse(securityLogWriter.fineEnabled()); - assertTrue(logWriter.fineEnabled()); - - assertFalse(((LogWriterLogger) securityLogWriter).isDebugEnabled()); - assertTrue(((LogWriterLogger) logWriter).isDebugEnabled()); - assertTrue(securityLogWriter instanceof FastLogger); - assertTrue(logWriter instanceof FastLogger); - assertTrue(((FastLogger) securityLogWriter).isDelegating()); - assertTrue(((FastLogger) logWriter).isDelegating()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return logFile.exists(); - } + Properties CONFIG = new Properties(); + CONFIG.put(LOG_FILE, logFileName); + CONFIG.put(LOG_LEVEL, "fine"); + CONFIG.put(SECURITY_LOG_LEVEL, "info"); + CONFIG.put(MCAST_PORT, "0"); + CONFIG.put(LOCATORS, ""); - @Override - public String description() { - return "waiting for log files to exist: " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(logFile.exists()); - - final Logger logger = LogService.getLogger(); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - securityLogWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - securityLogWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - securityLogWriter.fine(FINE_STRING); - assertFalse(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - securityLogWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - securityLogWriter.info(INFO_STRING); - assertTrue(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - securityLogWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - securityLogWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - securityLogWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertTrue(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); - } + system = (InternalDistributedSystem) DistributedSystem.connect(CONFIG); + + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> assertThat(logFile).exists()); + + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + LogWriterLogger securityLogWriter = (LogWriterLogger) system.getSecurityLogWriter(); + Logger geodeLogger = LogService.getLogger(); + + DistributionConfig distributionConfig = system.getConfig(); + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(distributionConfig.getSecurityLogLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); - system.disconnect(); - system = null; + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(securityLogWriter.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); + + String message = createMessage(LogWriterLevel.FINEST); + securityLogWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + securityLogWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + securityLogWriter.fine(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + securityLogWriter.config(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + securityLogWriter.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + securityLogWriter.warning(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + securityLogWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + securityLogWriter.severe(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); } /** @@ -1464,174 +1027,127 @@ public class DistributedSystemLogFileIntegrationTest { @Test public void testDistributedSystemWithSecurityFineLevelAndLogAtInfoLevelButNoSecurityLog() throws Exception { - final String logFileName = - name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"; - - final Properties properties = new Properties(); - properties.put(LOG_FILE, logFileName); - properties.put(LOG_LEVEL, "info"); - properties.put(SECURITY_LOG_LEVEL, "fine"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, ""); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File logFile = new File(logFileName); - if (logFile.exists()) { - logFile.delete(); - } - assertFalse(logFile.exists()); - - system = DistributedSystem.connect(properties); - assertNotNull(system); - - DistributionConfig config = ((InternalDistributedSystem) system).getConfig(); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.FINE_LEVEL, config.getSecurityLogLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.INFO_LEVEL, config.getLogLevel()); - - - InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter(); - InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter(); - assertNotNull(securityLogWriter); - assertNotNull(logWriter); - assertTrue(securityLogWriter instanceof LogWriterLogger); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.FINE_LEVEL, securityLogWriter.getLogWriterLevel()); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), - InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel()); - assertTrue(securityLogWriter.fineEnabled()); - assertFalse(logWriter.fineEnabled()); - - assertTrue(((LogWriterLogger) securityLogWriter).isDebugEnabled()); - assertFalse(((LogWriterLogger) logWriter).isDebugEnabled()); - assertTrue(securityLogWriter instanceof FastLogger); - assertTrue(logWriter instanceof FastLogger); - assertTrue(((FastLogger) securityLogWriter).isDelegating()); - assertTrue(((FastLogger) logWriter).isDelegating()); - - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return logFile.exists(); - } + Properties config = new Properties(); + config.put(LOG_FILE, logFileName); + config.put(LOG_LEVEL, "info"); + config.put(SECURITY_LOG_LEVEL, "fine"); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, ""); + + system = (InternalDistributedSystem) DistributedSystem.connect(config); + + await().atMost(5, TimeUnit.MINUTES).untilAsserted(() -> assertThat(logFile).exists()); + + LogWriterLogger logWriter = (LogWriterLogger) system.getLogWriter(); + LogWriterLogger securityLogWriter = (LogWriterLogger) system.getSecurityLogWriter(); + Logger geodeLogger = LogService.getLogger(); + + DistributionConfig distributionConfig = system.getConfig(); + + assertThat(distributionConfig.getLogLevel()).isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(distributionConfig.getSecurityLogLevel()) + .isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + + assertThat(logWriter.getLogWriterLevel()).isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(securityLogWriter.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.FINE.getLogWriterLevel()); + assertThat(geodeLogger.getLevel()).isEqualTo(Level.INFO); + + String message = createMessage(LogWriterLevel.FINEST); + securityLogWriter.finest(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINER); + securityLogWriter.finer(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(LogWriterLevel.FINE); + securityLogWriter.fine(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.CONFIG); + securityLogWriter.config(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.INFO); + securityLogWriter.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.WARNING); + securityLogWriter.warning(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.ERROR); + securityLogWriter.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(LogWriterLevel.SEVERE); + securityLogWriter.severe(message); + assertThatFileContains(logFile, message); - @Override - public String description() { - return "waiting for log files to exist: " + logFile; + message = createMessage(Level.TRACE); + geodeLogger.trace(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.DEBUG); + geodeLogger.debug(message); + assertThatFileDoesNotContain(logFile, message); + + message = createMessage(Level.INFO); + geodeLogger.info(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.WARN); + geodeLogger.warn(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.ERROR); + geodeLogger.error(message); + assertThatFileContains(logFile, message); + + message = createMessage(Level.FATAL); + geodeLogger.fatal(message); + assertThatFileContains(logFile, message); + } + + private String createMessage(LogWriterLevel logLevel) { + return prefix + logLevel.name() + " [" + COUNTER.incrementAndGet() + "]"; + } + + private String createMessage(Level level) { + return prefix + level.name() + " [" + COUNTER.incrementAndGet() + "]"; + } + + private void assertThatFileContains(final File file, final String string) + throws IOException { + try (Scanner scanner = new Scanner(file)) { + while (scanner.hasNextLine()) { + if (scanner.nextLine().trim().contains(string)) { + return; + } } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(logFile.exists()); - - final Logger logger = LogService.getLogger(); - int i = 0; - - { - i++; - final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]"; - securityLogWriter.finest(FINEST_STRING); - assertFalse(fileContainsString(logFile, FINEST_STRING)); - - i++; - final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]"; - securityLogWriter.finer(FINER_STRING); - assertFalse(fileContainsString(logFile, FINER_STRING)); - - i++; - final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]"; - securityLogWriter.fine(FINE_STRING); - assertTrue(fileContainsString(logFile, FINE_STRING)); - - i++; - final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]"; - securityLogWriter.config(CONFIG_STRING); - assertTrue(fileContainsString(logFile, CONFIG_STRING)); - - i++; - final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]"; - securityLogWriter.info(INFO_STRING); - assertTrue(fileContainsString(logFile, INFO_STRING)); - - i++; - final String WARNING_STRING = - "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]"; - securityLogWriter.warning(WARNING_STRING); - assertTrue(fileContainsString(logFile, WARNING_STRING)); - - i++; - final String ERROR_STRING = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - securityLogWriter.error(ERROR_STRING); - assertTrue(fileContainsString(logFile, ERROR_STRING)); - - i++; - final String SEVERE_STRING = - "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]"; - securityLogWriter.severe(SEVERE_STRING); - assertTrue(fileContainsString(logFile, SEVERE_STRING)); - - i++; - final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]"; - logger.trace(TRACE_STRING); - assertFalse(fileContainsString(logFile, TRACE_STRING)); - - i++; - final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]"; - logger.debug(DEBUG_STRING); - assertFalse(fileContainsString(logFile, DEBUG_STRING)); - - i++; - final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]"; - logger.info(INFO_STRING_J); - assertTrue(fileContainsString(logFile, INFO_STRING_J)); - - i++; - final String WARN_STRING = - "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]"; - logger.warn(WARN_STRING); - assertTrue(fileContainsString(logFile, WARN_STRING)); - - i++; - final String ERROR_STRING_J = - "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]"; - logger.error(ERROR_STRING_J); - assertTrue(fileContainsString(logFile, ERROR_STRING_J)); - - i++; - final String FATAL_STRING = - "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]"; - logger.fatal(FATAL_STRING); - assertTrue(fileContainsString(logFile, FATAL_STRING)); } - system.disconnect(); - system = null; + List<String> lines = Files.readAllLines(file.toPath()); + fail("Expected file " + file.getAbsolutePath() + " to contain " + string + LINE_SEPARATOR + + "Actual: " + lines); } - private static boolean fileContainsString(final File file, final String string) - throws FileNotFoundException { - Scanner scanner = new Scanner(file); - try { + private void assertThatFileDoesNotContain(final File file, final String string) + throws IOException { + boolean fail = false; + try (Scanner scanner = new Scanner(file)) { while (scanner.hasNextLine()) { if (scanner.nextLine().trim().contains(string)) { - return true; + fail = true; + break; } } - } finally { - scanner.close(); } - return false; + if (fail) { + List<String> lines = Files.readAllLines(file.toPath()); + fail("Expected file " + file.getAbsolutePath() + " to not contain " + string + LINE_SEPARATOR + + "Actual: " + lines); + } } } diff --git a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LocatorLogFileIntegrationTest.java b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LocatorLogFileIntegrationTest.java index e20db9c..5a88f1a 100644 --- a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LocatorLogFileIntegrationTest.java +++ b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LocatorLogFileIntegrationTest.java @@ -14,26 +14,24 @@ */ package org.apache.geode.internal.logging; -import static org.apache.geode.distributed.ConfigurationProperties.DISABLE_AUTO_RECONNECT; +import static java.util.concurrent.TimeUnit.MINUTES; import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_CLUSTER_CONFIGURATION; -import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_NETWORK_PARTITION_DETECTION; import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; import static org.apache.geode.distributed.ConfigurationProperties.LOG_LEVEL; import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT; -import static org.apache.geode.distributed.ConfigurationProperties.MEMBER_TIMEOUT; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; import java.io.File; import java.io.FileInputStream; import java.util.Properties; import org.junit.After; +import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; +import org.junit.rules.TemporaryFolder; import org.junit.rules.TestName; import org.apache.geode.distributed.Locator; @@ -41,8 +39,6 @@ import org.apache.geode.distributed.internal.DistributionConfig; import org.apache.geode.distributed.internal.InternalDistributedSystem; import org.apache.geode.internal.AvailablePort; import org.apache.geode.internal.logging.log4j.LogWriterLogger; -import org.apache.geode.test.dunit.Wait; -import org.apache.geode.test.dunit.WaitCriterion; import org.apache.geode.test.junit.categories.LoggingTest; /** @@ -51,85 +47,78 @@ import org.apache.geode.test.junit.categories.LoggingTest; @Category(LoggingTest.class) public class LocatorLogFileIntegrationTest { - private static final int TIMEOUT_MILLISECONDS = 180 * 1000; // 2 minutes - private static final int INTERVAL_MILLISECONDS = 100; // 100 milliseconds + private File logFile; + private String logFileName; + private File securityLogFile; + private int port; private Locator locator; - private FileInputStream fis; @Rule - public TestName name = new TestName(); + public TemporaryFolder temporaryFolder = new TemporaryFolder(); + + @Rule + public TestName testName = new TestName(); + + @Before + public void setUp() { + logFile = new File(temporaryFolder.getRoot(), + testName.getMethodName() + "-system-" + System.currentTimeMillis() + ".log"); + logFileName = logFile.getAbsolutePath(); + + securityLogFile = new File(""); + + port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET); + } @After public void tearDown() throws Exception { if (locator != null) { locator.stop(); - locator = null; - } - if (fis != null) { - fis.close(); } } @Test public void testLocatorCreatesLogFile() throws Exception { - final int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET); - final String locators = "localhost[" + port + "]"; - - final Properties properties = new Properties(); - properties.put(LOG_LEVEL, "config"); - properties.put(MCAST_PORT, "0"); - properties.put(LOCATORS, locators); - properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false"); - properties.put(DISABLE_AUTO_RECONNECT, "true"); - properties.put(MEMBER_TIMEOUT, "2000"); - properties.put(ENABLE_CLUSTER_CONFIGURATION, "false"); - - final File logFile = new File(name.getMethodName() + "-locator-" + port + ".log"); - if (logFile.exists()) { - logFile.delete(); + Properties config = new Properties(); + config.put(LOG_LEVEL, "config"); + config.put(MCAST_PORT, "0"); + config.put(LOCATORS, "localhost[" + port + "]"); + config.put(ENABLE_CLUSTER_CONFIGURATION, "false"); + + locator = Locator.startLocatorAndDS(port, logFile, config); + + InternalDistributedSystem system = (InternalDistributedSystem) locator.getDistributedSystem(); + + await().atMost(5, MINUTES).untilAsserted(() -> assertThat(logFile).exists()); + + // assertThat logFile is not empty + try (FileInputStream fis = new FileInputStream(logFile)) { + assertThat(fis.available()).isGreaterThan(0); } - assertFalse(logFile.exists()); - - locator = Locator.startLocatorAndDS(port, logFile, properties); - - InternalDistributedSystem ds = (InternalDistributedSystem) locator.getDistributedSystem(); - assertNotNull(ds); - DistributionConfig config = ds.getConfig(); - assertNotNull(config); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.CONFIG_LEVEL) + " but was " - + LogWriterImpl.levelToString(config.getLogLevel()), - InternalLogWriter.CONFIG_LEVEL, config.getLogLevel()); - - // CONFIG has been replaced with INFO -- all CONFIG statements are now logged at INFO as well - InternalLogWriter logWriter = (InternalLogWriter) ds.getLogWriter(); - assertNotNull(logWriter); - assertTrue(logWriter instanceof LogWriterLogger); - assertEquals( - "Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " - + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), - InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel()); - - assertNotNull(locator); - Wait.waitForCriterion(new WaitCriterion() { - @Override - public boolean done() { - return logFile.exists(); - } - - @Override - public String description() { - return "waiting for log file to exist: " + logFile; - } - }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true); - assertTrue(logFile.exists()); - // assert not empty - fis = new FileInputStream(logFile); - assertTrue(fis.available() > 0); - locator.stop(); - locator = null; - fis.close(); - fis = null; + + DistributionConfig distributionConfig = system.getConfig(); + + assertThat(distributionConfig.getLogLevel()) + .isEqualTo(LogWriterLevel.CONFIG.getLogWriterLevel()); + assertThat(distributionConfig.getSecurityLogLevel()) + .isEqualTo(LogWriterLevel.CONFIG.getLogWriterLevel()); + + assertThat(distributionConfig.getLogFile().getAbsolutePath()).isEqualTo(logFileName); + assertThat(distributionConfig.getSecurityLogFile().getAbsolutePath()) + .isEqualTo(securityLogFile.getAbsolutePath()); + + assertThat(system.getLogWriter()).isInstanceOf(LogWriterLogger.class); + assertThat(system.getSecurityLogWriter()).isInstanceOf(LogWriterLogger.class); + + LogWriterLogger logWriterLogger = (LogWriterLogger) system.getLogWriter(); + LogWriterLogger securityLogWriterLogger = (LogWriterLogger) system.getSecurityLogWriter(); + + assertThat(logWriterLogger.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + assertThat(securityLogWriterLogger.getLogWriterLevel()) + .isEqualTo(LogWriterLevel.INFO.getLogWriterLevel()); + + assertThat(securityLogFile).doesNotExist(); } } diff --git a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LogServiceIntegrationTest.java b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LogServiceIntegrationTest.java index 2f94dc3..33fbce5 100755 --- a/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LogServiceIntegrationTest.java +++ b/geode-core/src/integrationTest/java/org/apache/geode/internal/logging/LogServiceIntegrationTest.java @@ -48,16 +48,16 @@ public class LogServiceIntegrationTest { private static final String CLI_CONFIG_FILE_NAME = "log4j2-cli.xml"; @Rule - public final SystemErrRule systemErrRule = new SystemErrRule().enableLog(); + public SystemErrRule systemErrRule = new SystemErrRule().enableLog(); @Rule - public final SystemOutRule systemOutRule = new SystemOutRule().enableLog(); + public SystemOutRule systemOutRule = new SystemOutRule().enableLog(); @Rule - public final TemporaryFolder temporaryFolder = new TemporaryFolder(); + public TemporaryFolder temporaryFolder = new TemporaryFolder(); @Rule - public final ExternalResource externalResource = new ExternalResource() { + public ExternalResource externalResource = new ExternalResource() { @Override protected void before() { beforeConfigFileProp = System.getProperty(ConfigurationFactory.CONFIGURATION_FILE_PROPERTY); @@ -106,8 +106,8 @@ public class LogServiceIntegrationTest { @Test public void shouldPreferConfigurationFilePropertyIfSet() throws Exception { - final File configFile = temporaryFolder.newFile(DEFAULT_CONFIG_FILE_NAME); - final String configFileName = configFile.toURI().toString(); + File configFile = temporaryFolder.newFile(DEFAULT_CONFIG_FILE_NAME); + String configFileName = configFile.toURI().toString(); System.setProperty(ConfigurationFactory.CONFIGURATION_FILE_PROPERTY, configFileName); writeConfigFile(configFile, Level.DEBUG); @@ -133,7 +133,7 @@ public class LogServiceIntegrationTest { @Test public void defaultConfigShouldIncludeStdout() { LogService.reconfigure(); - final Logger rootLogger = (Logger) LogService.getRootLogger(); + Logger rootLogger = (Logger) LogService.getRootLogger(); assertThat(LogService.isUsingGemFireDefaultConfig()).as(LogService.getConfigurationInfo()) .isTrue(); @@ -143,7 +143,7 @@ public class LogServiceIntegrationTest { @Test public void removeConsoleAppenderShouldRemoveStdout() { LogService.reconfigure(); - final Logger rootLogger = (Logger) LogService.getRootLogger(); + Logger rootLogger = (Logger) LogService.getRootLogger(); LogService.removeConsoleAppender(); @@ -153,7 +153,7 @@ public class LogServiceIntegrationTest { @Test public void restoreConsoleAppenderShouldRestoreStdout() { LogService.reconfigure(); - final Logger rootLogger = (Logger) LogService.getRootLogger(); + Logger rootLogger = (Logger) LogService.getRootLogger(); LogService.removeConsoleAppender(); @@ -171,7 +171,7 @@ public class LogServiceIntegrationTest { assertThat(LogService.isUsingGemFireDefaultConfig()).as(LogService.getConfigurationInfo()) .isTrue(); - final Logger rootLogger = (Logger) LogService.getRootLogger(); + Logger rootLogger = (Logger) LogService.getRootLogger(); // assert "Console" is present for ROOT Appender appender = rootLogger.getAppenders().get(LogService.STDOUT); diff --git a/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/FastLoggerTest.java b/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/FastLoggerTest.java index 3ae40b8..699e651 100755 --- a/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/FastLoggerTest.java +++ b/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/FastLoggerTest.java @@ -14,13 +14,12 @@ */ package org.apache.geode.internal.logging.log4j; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.sameInstance; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.clearInvocations; import static org.mockito.Mockito.eq; import static org.mockito.Mockito.isNull; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -36,24 +35,38 @@ import org.junit.experimental.categories.Category; import org.apache.geode.test.junit.categories.LoggingTest; /** - * Unit tests the FastLogger class which wraps and delegates to an actual Logger with optimizations - * for isDebugEnabled and isTraceEnabled. + * Unit tests for {@link FastLogger} which wraps and delegates to an actual Logger with + * optimizations for isDebugEnabled and isTraceEnabled. */ @Category(LoggingTest.class) public class FastLoggerTest { - private MessageFactory messageFactory; + private static final String LOGGER_NAME = "LOGGER"; + private static final String MARKER_NAME = "MARKER"; + + private FastLogger fastLogger; private ExtendedLogger mockedLogger; private Marker mockedMarker; @Before public void setUp() { - messageFactory = new ParameterizedMessageFactory(); + MessageFactory messageFactory = new ParameterizedMessageFactory(); mockedLogger = mock(ExtendedLogger.class); mockedMarker = mock(Marker.class); when(mockedLogger.getMessageFactory()).thenReturn(messageFactory); - when(mockedMarker.getName()).thenReturn("MARKER"); + when(mockedLogger.getName()).thenReturn(LOGGER_NAME); + when(mockedLogger.getLevel()).thenReturn(Level.INFO); + + when(mockedMarker.getName()).thenReturn(MARKER_NAME); + + fastLogger = new FastLogger(mockedLogger); + + FastLogger.setDelegating(true); + + clearInvocations(mockedLogger); + + assertThat(mockedLogger.getLevel()).isEqualTo(Level.INFO); } /** @@ -61,15 +74,11 @@ public class FastLoggerTest { */ @Test public void returnIsDelegatingAfterSetDelegating() { - FastLogger.setDelegating(true); - - FastLogger fastLogger = new FastLogger(mockedLogger); - - assertThat(fastLogger.isDelegating(), is(true)); + assertThat(fastLogger.isDelegating()).isTrue(); FastLogger.setDelegating(false); - assertThat(fastLogger.isDelegating(), is(false)); + assertThat(fastLogger.isDelegating()).isFalse(); } /** @@ -77,13 +86,9 @@ public class FastLoggerTest { */ @Test public void delegateGetLevel() { - FastLogger.setDelegating(true); when(mockedLogger.getLevel()).thenReturn(Level.DEBUG); - FastLogger fastLogger = new FastLogger(mockedLogger); - - assertThat(fastLogger.getLevel(), is(Level.DEBUG)); - verify(mockedLogger, times(1)).getLevel(); + assertThat(fastLogger.getLevel()).isEqualTo(Level.DEBUG); } /** @@ -91,21 +96,16 @@ public class FastLoggerTest { */ @Test public void delegateIsDebugEnabledWhenIsDelegating() { - FastLogger.setDelegating(true); when(mockedLogger.getLevel()).thenReturn(Level.DEBUG); - when(mockedLogger.isEnabled(eq(Level.DEBUG), isNull(Marker.class), isNull(String.class))) + when(mockedLogger.isEnabled(eq(Level.DEBUG), isNull(), isNull())).thenReturn(true); + when(mockedLogger.isEnabled(eq(Level.DEBUG), eq(mockedMarker), (Object) isNull(), isNull())) .thenReturn(true); - when(mockedLogger.isEnabled(eq(Level.DEBUG), eq(mockedMarker), isNull(Object.class), - isNull(Throwable.class))).thenReturn(true); - FastLogger fastLogger = new FastLogger(mockedLogger); + assertThat(fastLogger.isDebugEnabled()).isTrue(); + assertThat(fastLogger.isDebugEnabled(mockedMarker)).isTrue(); - assertThat(fastLogger.isDebugEnabled(), is(true)); - assertThat(fastLogger.isDebugEnabled(mockedMarker), is(true)); - verify(mockedLogger, times(1)).isEnabled(eq(Level.DEBUG), isNull(Marker.class), - isNull(String.class)); - verify(mockedLogger, times(1)).isEnabled(eq(Level.DEBUG), eq(mockedMarker), - isNull(Object.class), isNull(Throwable.class)); + verify(mockedLogger).isEnabled(eq(Level.DEBUG), isNull(), isNull()); + verify(mockedLogger).isEnabled(eq(Level.DEBUG), eq(mockedMarker), (Object) isNull(), isNull()); } /** @@ -113,21 +113,17 @@ public class FastLoggerTest { */ @Test public void delegateIsTraceEnabledWhenIsDelegating() { - FastLogger.setDelegating(true); when(mockedLogger.getLevel()).thenReturn(Level.TRACE); - when(mockedLogger.isEnabled(eq(Level.TRACE), isNull(Marker.class), isNull(Object.class), - isNull(Throwable.class))).thenReturn(true); - when(mockedLogger.isEnabled(eq(Level.TRACE), eq(mockedMarker), isNull(Object.class), - isNull(Throwable.class))).thenReturn(true); - - FastLogger fastLogger = new FastLogger(mockedLogger); - - assertThat(fastLogger.isTraceEnabled(), is(true)); - assertThat(fastLogger.isTraceEnabled(mockedMarker), is(true)); - verify(mockedLogger, times(1)).isEnabled(eq(Level.TRACE), isNull(Marker.class), - isNull(Object.class), isNull(Throwable.class)); - verify(mockedLogger, times(1)).isEnabled(eq(Level.TRACE), eq(mockedMarker), - isNull(Object.class), isNull(Throwable.class)); + when(mockedLogger.isEnabled(eq(Level.TRACE), isNull(), (Object) isNull(), isNull())) + .thenReturn(true); + when(mockedLogger.isEnabled(eq(Level.TRACE), eq(mockedMarker), (Object) isNull(), isNull())) + .thenReturn(true); + + assertThat(fastLogger.isTraceEnabled()).isTrue(); + assertThat(fastLogger.isTraceEnabled(mockedMarker)).isTrue(); + + verify(mockedLogger).isEnabled(eq(Level.TRACE), isNull(), (Object) isNull(), isNull()); + verify(mockedLogger).isEnabled(eq(Level.TRACE), eq(mockedMarker), (Object) isNull(), isNull()); } /** @@ -136,17 +132,16 @@ public class FastLoggerTest { @Test public void notDelegateIsDebugEnabledWhenNotIsDelegating() { FastLogger.setDelegating(false); + when(mockedLogger.getLevel()).thenReturn(Level.INFO); - FastLogger fastLogger = new FastLogger(mockedLogger); + assertThat(fastLogger.getLevel()).isEqualTo(Level.INFO); + assertThat(fastLogger.isDebugEnabled()).isFalse(); + assertThat(fastLogger.isDebugEnabled(mockedMarker)).isFalse(); - assertThat(fastLogger.getLevel(), is(Level.INFO)); - assertThat(fastLogger.isDebugEnabled(), is(false)); - assertThat(fastLogger.isDebugEnabled(mockedMarker), is(false)); - verify(mockedLogger, times(0)).isEnabled(eq(Level.DEBUG), isNull(Marker.class), - isNull(String.class)); - verify(mockedLogger, times(0)).isEnabled(eq(Level.DEBUG), eq(mockedMarker), - isNull(Object.class), isNull(Throwable.class)); + verify(mockedLogger, never()).isEnabled(eq(Level.DEBUG), isNull(), isNull()); + verify(mockedLogger, never()).isEnabled(eq(Level.DEBUG), eq(mockedMarker), (Object) isNull(), + isNull()); } /** @@ -155,17 +150,15 @@ public class FastLoggerTest { @Test public void notDelegateIsTraceEnabledWhenNotIsDelegating() { FastLogger.setDelegating(false); - when(mockedLogger.getLevel()).thenReturn(Level.INFO); - FastLogger fastLogger = new FastLogger(mockedLogger); + assertThat(fastLogger.getLevel()).isEqualTo(Level.INFO); - assertThat(fastLogger.getLevel(), is(Level.INFO)); - assertThat(fastLogger.isTraceEnabled(), is(false)); - assertThat(fastLogger.isTraceEnabled(mockedMarker), is(false)); - verify(mockedLogger, times(0)).isEnabled(eq(Level.TRACE), isNull(Marker.class), - isNull(String.class)); - verify(mockedLogger, times(0)).isEnabled(eq(Level.TRACE), eq(mockedMarker), - isNull(Object.class), isNull(Throwable.class)); + assertThat(fastLogger.isTraceEnabled()).isFalse(); + verify(mockedLogger, never()).isEnabled(eq(Level.TRACE), isNull(), isNull()); + + assertThat(fastLogger.isTraceEnabled(mockedMarker)).isFalse(); + verify(mockedLogger, never()).isEnabled(eq(Level.TRACE), eq(mockedMarker), (Object) isNull(), + isNull()); } /** @@ -173,9 +166,7 @@ public class FastLoggerTest { */ @Test public void wrapDelegateAndReturnFromGetExtendedLogger() { - FastLogger fastLogger = new FastLogger(mockedLogger); - - assertThat(fastLogger.getExtendedLogger(), is(sameInstance(mockedLogger))); + assertThat(fastLogger.getExtendedLogger()).isSameAs(mockedLogger); } /** @@ -183,11 +174,8 @@ public class FastLoggerTest { */ @Test public void delegateGetName() { - when(mockedLogger.getName()).thenReturn("name"); - - FastLogger fastLogger = new FastLogger(mockedLogger); + assertThat(fastLogger.getName()).isEqualTo(LOGGER_NAME); - assertThat(fastLogger.getName(), is("name")); - verify(mockedLogger, times(1)).getName(); + verify(mockedLogger, never()).getName(); } } diff --git a/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/HexThreadIdPatternConverterTest.java b/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/HexThreadIdPatternConverterTest.java index 30335d2..e3d595e 100644 --- a/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/HexThreadIdPatternConverterTest.java +++ b/geode-core/src/test/java/org/apache/geode/internal/logging/log4j/HexThreadIdPatternConverterTest.java @@ -21,6 +21,9 @@ import static org.assertj.core.api.Assertions.assertThat; import org.junit.Before; import org.junit.Test; +/** + * Unit tests for {@link HexThreadIdPatternConverter}. + */ public class HexThreadIdPatternConverterTest { private HexThreadIdPatternConverter converter;
