This is an automated email from the ASF dual-hosted git repository. mattsicker pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 61dae9f05f0af59b9e54b75e7e989b77051b5a9b Author: Matt Sicker <[email protected]> AuthorDate: Sat Oct 29 21:20:49 2022 -0500 Create AllocatePorts JUnit annotation This makes it easier to use dynamically chosen ports in configuration files. Signed-off-by: Matt Sicker <[email protected]> --- .../appender/SocketAppenderSocketOptionsTest.java | 119 +++++++++------------ .../log4j/core/test/junit/AllocatePorts.java | 39 +++++++ .../core/test/junit/PortAllocatorCallback.java | 71 ++++++++++++ 3 files changed, 162 insertions(+), 67 deletions(-) diff --git a/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderSocketOptionsTest.java b/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderSocketOptionsTest.java index f33f623135..2b550023a8 100644 --- a/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderSocketOptionsTest.java +++ b/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderSocketOptionsTest.java @@ -16,94 +16,79 @@ */ package org.apache.logging.log4j.core.appender; -import java.io.IOException; -import java.io.OutputStream; -import java.net.Socket; - import org.apache.logging.log4j.core.appender.SocketAppenderTest.TcpSocketTestServer; +import org.apache.logging.log4j.core.net.AbstractSocketManager; import org.apache.logging.log4j.core.net.Rfc1349TrafficClass; import org.apache.logging.log4j.core.net.SocketOptions; import org.apache.logging.log4j.core.net.TcpSocketManager; +import org.apache.logging.log4j.core.test.junit.AllocatePorts; +import org.apache.logging.log4j.core.test.junit.LoggerContextSource; import org.apache.logging.log4j.core.util.NullOutputStream; -import org.apache.logging.log4j.core.test.junit.LoggerContextRule; -import org.apache.logging.log4j.core.test.AvailablePortFinder; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.Assume; -import org.junit.ClassRule; -import org.junit.Test; +import org.apache.logging.log4j.plugins.Named; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.net.Socket; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; +@AllocatePorts("SocketAppenderSocketOptionsTest.port") public class SocketAppenderSocketOptionsTest { - private static final int PORT; - private static TcpSocketTestServer tcpSocketTestServer; + private TcpSocketTestServer server; - static { - PORT = AvailablePortFinder.getNextAvailable(); - System.setProperty("SocketAppenderSocketOptionsTest.port", Integer.toString(PORT)); - try { - tcpSocketTestServer = new TcpSocketTestServer(PORT); - } catch (final IOException e) { - throw new IllegalStateException(e); - } - tcpSocketTestServer.start(); - loggerContextRule = new LoggerContextRule("log4j-socket-options.xml"); + @BeforeEach + void setUp() throws IOException { + int port = Integer.getInteger("SocketAppenderSocketOptionsTest.port"); + server = new TcpSocketTestServer(port); + server.start(); } - @ClassRule - public static final LoggerContextRule loggerContextRule; - - @AfterClass - public static void afterClass() { - if (tcpSocketTestServer != null) { - tcpSocketTestServer.shutdown(); + @AfterEach + void tearDown() { + if (server != null) { + server.shutdown(); + server = null; } } @Test - public void testSocketOptions() throws IOException { - Assert.assertNotNull(loggerContextRule); - Assert.assertNotNull(loggerContextRule.getConfiguration()); - final SocketAppender appender = loggerContextRule.getAppender("socket", SocketAppender.class); - Assert.assertNotNull(appender); - final TcpSocketManager manager = (TcpSocketManager) appender.getManager(); - Assert.assertNotNull(manager); - final OutputStream outputStream = manager.getOutputStream(); - Assert.assertFalse(outputStream instanceof NullOutputStream); + @LoggerContextSource("log4j-socket-options.xml") + public void testSocketOptions(@Named("socket") final SocketAppender appender) throws IOException { + final AbstractSocketManager abstractSocketManager = appender.getManager(); + assertThat(abstractSocketManager) + .isNotNull() + .isInstanceOf(TcpSocketManager.class); + final TcpSocketManager manager = (TcpSocketManager) abstractSocketManager; + assertThat(manager.getOutputStream()) + .isNotNull() + .isInstanceOf(NullOutputStream.class); final SocketOptions socketOptions = manager.getSocketOptions(); - Assert.assertNotNull(socketOptions); + assertNotNull(socketOptions); final Socket socket = manager.getSocket(); - Assert.assertNotNull(socket); + assertNotNull(socket); // Test config request - Assert.assertEquals(false, socketOptions.isKeepAlive()); - Assert.assertEquals(false, socketOptions.isOobInline()); - Assert.assertEquals(false, socketOptions.isReuseAddress()); - Assert.assertEquals(false, socketOptions.isTcpNoDelay()); - Assert.assertEquals(Rfc1349TrafficClass.IPTOS_LOWCOST.value(), - socketOptions.getActualTrafficClass().intValue()); - Assert.assertEquals(10000, socketOptions.getReceiveBufferSize().intValue()); - Assert.assertEquals(8000, socketOptions.getSendBufferSize().intValue()); - Assert.assertEquals(12345, socketOptions.getSoLinger().intValue()); - Assert.assertEquals(54321, socketOptions.getSoTimeout().intValue()); + assertEquals(false, socketOptions.isKeepAlive()); + assertEquals(false, socketOptions.isOobInline()); + assertEquals(false, socketOptions.isReuseAddress()); + assertEquals(false, socketOptions.isTcpNoDelay()); + assertEquals(Rfc1349TrafficClass.IPTOS_LOWCOST.value(), socketOptions.getActualTrafficClass().intValue()); + assertEquals(10000, socketOptions.getReceiveBufferSize().intValue()); + assertEquals(8000, socketOptions.getSendBufferSize().intValue()); + assertEquals(12345, socketOptions.getSoLinger().intValue()); + assertEquals(54321, socketOptions.getSoTimeout().intValue()); // Test live socket - Assert.assertEquals(false, socket.getKeepAlive()); - Assert.assertEquals(false, socket.getOOBInline()); - Assert.assertEquals(false, socket.getReuseAddress()); - Assert.assertEquals(false, socket.getTcpNoDelay()); + assertFalse(socket.getKeepAlive()); + assertFalse(socket.getOOBInline()); + assertFalse(socket.getReuseAddress()); + assertFalse(socket.getTcpNoDelay()); // Assert.assertEquals(10000, socket.getReceiveBufferSize()); // This settings changes while we are running, so we cannot assert it. // Assert.assertEquals(8000, socket.getSendBufferSize()); - Assert.assertEquals(12345, socket.getSoLinger()); - Assert.assertEquals(54321, socket.getSoTimeout()); - } - - @Test - public void testSocketTrafficClass() throws IOException { - Assume.assumeTrue("Run only on Java 7", System.getProperty("java.specification.version").equals("1.7")); - Assume.assumeFalse("Do not run on Travis CI", "true".equals(System.getenv("TRAVIS"))); - final SocketAppender appender = loggerContextRule.getAppender("socket", SocketAppender.class); - final TcpSocketManager manager = (TcpSocketManager) appender.getManager(); - final Socket socket = manager.getSocket(); - Assert.assertEquals(Rfc1349TrafficClass.IPTOS_LOWCOST.value(), socket.getTrafficClass()); + assertEquals(12345, socket.getSoLinger()); + assertEquals(54321, socket.getSoTimeout()); } } diff --git a/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/AllocatePorts.java b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/AllocatePorts.java new file mode 100644 index 0000000000..d807ca18f4 --- /dev/null +++ b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/AllocatePorts.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache license, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the license for the specific language governing permissions and + * limitations under the license. + */ + +package org.apache.logging.log4j.core.test.junit; + +import org.junit.jupiter.api.extension.ExtendWith; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Sets system properties to free port numbers. These properties are refreshed for each test method. + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.TYPE, ElementType.METHOD}) +@ExtendWith(PortAllocatorCallback.class) +public @interface AllocatePorts { + /** + * Names of system properties to set with one or more allocated ports via + * {@link org.apache.logging.log4j.core.test.AvailablePortFinder}. + */ + String[] value(); +} diff --git a/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/PortAllocatorCallback.java b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/PortAllocatorCallback.java new file mode 100644 index 0000000000..c9b04bc979 --- /dev/null +++ b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/PortAllocatorCallback.java @@ -0,0 +1,71 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache license, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the license for the specific language governing permissions and + * limitations under the license. + */ + +package org.apache.logging.log4j.core.test.junit; + +import org.apache.logging.log4j.core.test.AvailablePortFinder; +import org.junit.jupiter.api.extension.AfterAllCallback; +import org.junit.jupiter.api.extension.AfterEachCallback; +import org.junit.jupiter.api.extension.BeforeAllCallback; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; + +import java.util.stream.Stream; + +class PortAllocatorCallback implements BeforeEachCallback, AfterEachCallback, BeforeAllCallback, AfterAllCallback { + @Override + public void beforeAll(final ExtensionContext context) throws Exception { + AnnotationSupport.findAnnotation(context.getTestClass(), AllocatePorts.class) + .map(AllocatePorts::value) + .stream() + .flatMap(Stream::of) + .forEach(PortAllocatorCallback::setSystemPropertyToAllocatedPort); + } + + @Override + public void beforeEach(final ExtensionContext context) throws Exception { + AnnotationSupport.findAnnotation(context.getTestMethod(), AllocatePorts.class) + .map(AllocatePorts::value) + .stream() + .flatMap(Stream::of) + .forEach(PortAllocatorCallback::setSystemPropertyToAllocatedPort); + } + + @Override + public void afterEach(final ExtensionContext context) throws Exception { + AnnotationSupport.findAnnotation(context.getTestMethod(), AllocatePorts.class) + .map(AllocatePorts::value) + .stream() + .flatMap(Stream::of) + .forEach(System::clearProperty); + } + + @Override + public void afterAll(final ExtensionContext context) throws Exception { + AnnotationSupport.findAnnotation(context.getTestClass(), AllocatePorts.class) + .map(AllocatePorts::value) + .stream() + .flatMap(Stream::of) + .forEach(System::clearProperty); + } + + private static void setSystemPropertyToAllocatedPort(final String key) { + int port = AvailablePortFinder.getNextAvailable(); + System.setProperty(key, Integer.toString(port)); + } +}
