Code cleanup in embedded runnable tests

- Special matcher
- Deleting temporary files
- Removed LONG_RUNNING tag from monitorngtest - finishes around 2 seconds.
  Instead I tried to stabilize the host resolution which seems to make problems
  on windows (looks like JDK bug?)


Signed-off-by: David Matějček <[email protected]>

Author: dmatej

appserver/tests/application/pom.xml

@@ -61,12 +61,6 @@
         <dependency>
             <groupId>org.jboss.shrinkwrap.resolver</groupId>
             <artifactId>shrinkwrap-resolver-impl-maven-archive</artifactId>
-            <exclusions>
-                <exclusion>
-                    <groupId>javax.*</groupId>
-                    <artifactId>*</artifactId>
-                </exclusion>
-            </exclusions>
         </dependency>
 
         <dependency>

appserver/tests/embedded/pom.xml

@@ -95,17 +95,4 @@
             </plugins>
         </pluginManagement>
     </build>
-
-    <profiles>
-        <profile>
-            <activation>
-                <property>
-                    <name>glassfish.test.excludedGroups</name>
-                </property>
-            </activation>
-            <properties>
-                <excludedGroups>${glassfish.test.excludedGroups}</excludedGroups>
-            </properties>
-        </profile>
-    </profiles>
 </project>

appserver/tests/embedded/runnable/pom.xml

@@ -29,6 +29,10 @@
     <artifactId>runnable</artifactId>
     <name>Tests for testing runnable GF Embedded</name>
     <dependencies>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
@@ -37,12 +41,6 @@
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-params</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.jboss.shrinkwrap</groupId>
-            <artifactId>shrinkwrap-depchain</artifactId>
-            <version>1.2.6</version>
-            <type>pom</type>
-        </dependency>
         <dependency>
             <groupId>org.glassfish.main.extras</groupId>
             <artifactId>glassfish-embedded-all</artifactId>
@@ -57,9 +55,8 @@
             <version>${project.version}</version>
         </dependency>
         <dependency>
-            <groupId>org.glassfish.main</groupId>
-            <artifactId>glassfish-itest-tools</artifactId>
-            <version>${project.version}</version>
+            <groupId>org.jboss.shrinkwrap.resolver</groupId>
+            <artifactId>shrinkwrap-resolver-impl-maven-archive</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>

appserver/tests/embedded/runnable/src/test/java/org/glassfish/tests/embedded/runnable/AddLibraryTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Contributors to the Eclipse Foundation.
+ * Copyright (c) 2024, 2025 Contributors to the Eclipse Foundation.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -15,104 +15,89 @@
  */
 package org.glassfish.tests.embedded.runnable;
 
-import java.io.File;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Logger;
+import java.lang.System.Logger;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 import org.glassfish.tests.embedded.runnable.TestArgumentProviders.GfEmbeddedJarNameProvider;
 import org.glassfish.tests.embedded.runnable.app.App;
 import org.glassfish.tests.embedded.runnable.library.MockExecutorService;
 import org.jboss.shrinkwrap.api.ShrinkWrap;
-import org.jboss.shrinkwrap.api.UnknownExtensionTypeException;
-import org.jboss.shrinkwrap.api.exporter.ArchiveExportException;
-import org.jboss.shrinkwrap.api.exporter.FileExistsException;
 import org.jboss.shrinkwrap.api.exporter.ZipExporter;
 import org.jboss.shrinkwrap.api.spec.JavaArchive;
 import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ArgumentsSource;
 
-import static java.lang.System.err;
-import static org.glassfish.tests.embedded.runnable.GfEmbeddedUtils.outputToStreamOfLines;
+import static java.lang.System.Logger.Level.INFO;
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.glassfish.tests.embedded.runnable.GfEmbeddedUtils.runGlassFishEmbedded;
-import static org.glassfish.tests.embedded.runnable.ShrinkwrapUtils.logArchiveContent;
+import static org.glassfish.tests.embedded.runnable.GfEmbeddedUtils.stderrContains;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.not;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * @author Ondro Mihalyi
  */
 public class AddLibraryTest {
 
-    private static final Logger LOG = Logger.getLogger(AddLibraryTest.class.getName());
+    private static final Logger LOG = System.getLogger(AddLibraryTest.class.getName());
+
+    @TempDir
+    private Path tmpDir;
+    private Path jarFile;
+    private Path warFile;
+
+    @AfterEach
+    void deleteFiles() throws Exception {
+        if (jarFile != null) {
+            Files.deleteIfExists(jarFile);
+        }
+        if (warFile != null) {
+            Files.deleteIfExists(warFile);
+        }
+    }
 
     @ParameterizedTest
     @ArgumentsSource(GfEmbeddedJarNameProvider.class)
     void testAddLibraryForApp(String gfEmbeddedJarName) throws Exception {
-
-        File jarFile = null;
-        File warFile = null;
-        try {
-            jarFile = testLibraryJavaArchive(jarFile);
-            warFile = warArchiveThatDependsOnTestLibrary(warFile);
-            Process gfEmbeddedProcess = runGlassFishEmbedded(gfEmbeddedJarName,
-                    "add-library " + jarFile.getAbsolutePath(),
-                    warFile.getAbsolutePath()
-            );
-            assertTrue(outputToStreamOfLines(gfEmbeddedProcess)
-                    .filter(line -> line.contains("App initialized"))
-                    .findAny().isPresent(),
-                    "A log from deployed application is present");
-            gfEmbeddedProcess
-                    .waitFor(30, TimeUnit.SECONDS);
-        } finally {
-            Optional.ofNullable(jarFile).ifPresent(File::delete);
-            Optional.ofNullable(warFile).ifPresent(File::delete);
-        }
+        jarFile = testLibraryJavaArchive();
+        warFile = warArchiveThatDependsOnTestLibrary();
+        Process gfEmbeddedProcess = runGlassFishEmbedded(gfEmbeddedJarName, "add-library " + jarFile,
+            warFile.toString());
+        assertThat(gfEmbeddedProcess.errorReader(), stderrContains("App initialized"));
+        assertTrue(gfEmbeddedProcess.waitFor(30, SECONDS), "Process finished.");
     }
 
     @ParameterizedTest
     @ArgumentsSource(GfEmbeddedJarNameProvider.class)
     void testAddLibraryForGrizzlyExecutor(String gfEmbeddedJarName) throws Exception {
-
-        File jarFile = null;
-        File warFile = null;
-        try {
-            jarFile = testLibraryJavaArchive(jarFile);
-            Process gfEmbeddedProcess = runGlassFishEmbedded(gfEmbeddedJarName,
-                    "add-library " + jarFile.getAbsolutePath(),
-                    "set configs.config.server-config.thread-pools.thread-pool.http-thread-pool.classname=" + MockExecutorService.class.getName()
-            );
-            assertTrue(! outputToStreamOfLines(gfEmbeddedProcess)
-                    .peek(err::println)
-                    .filter(line -> line.contains("ClassNotFoundException"))
-                    .findAny().isPresent(),
-                    "ClassNotFoundException should not be thrown for " + MockExecutorService.class.getSimpleName());
-            gfEmbeddedProcess
-                    .waitFor(30, TimeUnit.SECONDS);
-        } finally {
-            Optional.ofNullable(jarFile).ifPresent(File::delete);
-            Optional.ofNullable(warFile).ifPresent(File::delete);
-        }
+        jarFile = testLibraryJavaArchive();
+        Process gfEmbeddedProcess = runGlassFishEmbedded(gfEmbeddedJarName, "add-library " + jarFile,
+            "set configs.config.server-config.thread-pools.thread-pool.http-thread-pool.classname="
+                + MockExecutorService.class.getName());
+        assertThat(gfEmbeddedProcess.errorReader(), not(stderrContains("ClassNotFoundException")));
+        assertTrue(gfEmbeddedProcess.waitFor(30, SECONDS), "Process finished.");
     }
 
-    private File testLibraryJavaArchive(File jarFile) throws FileExistsException, ArchiveExportException, UnknownExtensionTypeException, IllegalArgumentException {
+    private Path testLibraryJavaArchive() throws Exception {
         String jarName = "testLibrary.jar";
-        JavaArchive javaArchive = ShrinkWrap.create(JavaArchive.class, jarName)
-                .addClass(MockExecutorService.class);
-        jarFile = new File(jarName);
-        javaArchive.as(ZipExporter.class).exportTo(jarFile);
-        logArchiveContent(javaArchive, jarName, LOG::info);
+        JavaArchive javaArchive = ShrinkWrap.create(JavaArchive.class, jarName).addClass(MockExecutorService.class);
+        jarFile = tmpDir.resolve(jarName).toAbsolutePath();
+        javaArchive.as(ZipExporter.class).exportTo(jarFile.toFile());
+        LOG.log(INFO, () -> "Java library:\n" + javaArchive.toString(true));
         return jarFile;
     }
 
-    private File warArchiveThatDependsOnTestLibrary(File warFile) throws FileExistsException, ArchiveExportException, IllegalArgumentException {
+    private Path warArchiveThatDependsOnTestLibrary() throws Exception {
         String warName = "testLibraryApp.war";
-        WebArchive warArchive = ShrinkWrap.create(WebArchive.class, warName)
-                .addPackage(App.class.getPackage());
-        warFile = new File(warName);
-        warArchive.as(ZipExporter.class).exportTo(warFile);
-        logArchiveContent(warArchive, warName, LOG::info);
+        WebArchive warArchive = ShrinkWrap.create(WebArchive.class, warName).addPackage(App.class.getPackage());
+        warFile = tmpDir.resolve(warName).toAbsolutePath();
+        warArchive.as(ZipExporter.class).exportTo(warFile.toFile());
+        LOG.log(INFO, () -> "WAR:\n" + warArchive.toString(true));
         return warFile;
     }
 

appserver/tests/embedded/runnable/src/test/java/org/glassfish/tests/embedded/runnable/ConfigFileTest.java

@@ -17,22 +17,20 @@
 
 import java.io.IOException;
 import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardCopyOption;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
+import java.nio.file.Path;
 
 import org.glassfish.tests.embedded.runnable.TestArgumentProviders.GfEmbeddedJarNameProvider;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.TestInfo;
+import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ArgumentsSource;
 
-import static org.glassfish.tests.embedded.runnable.GfEmbeddedUtils.outputToStreamOfLines;
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.glassfish.tests.embedded.runnable.GfEmbeddedUtils.runGlassFishEmbedded;
+import static org.glassfish.tests.embedded.runnable.GfEmbeddedUtils.stderrContains;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
@@ -41,84 +39,45 @@
  */
 public class ConfigFileTest {
 
-    String propertiesFile;
+    @TempDir
+    private Path tmpDir;
+    private Path propertiesFile;
 
     @BeforeEach
     void init(TestInfo testInfo) throws IOException {
-        propertiesFile = "glassfish-" + testInfo.getTestMethod().get().getName() + ".properties";
-        Files.copy(getClass().getClassLoader().getResourceAsStream(testInfo.getTestClass().get().getSimpleName() + "/" + propertiesFile),
-                Paths.get(propertiesFile),
-                StandardCopyOption.REPLACE_EXISTING);
-
+        String fileName = "glassfish-" + testInfo.getTestMethod().get().getName() + ".properties";
+        propertiesFile = tmpDir.resolve(fileName);
+        Files.copy(getClass().getClassLoader().getResourceAsStream(
+            testInfo.getTestClass().get().getSimpleName() + "/" + fileName), propertiesFile, REPLACE_EXISTING);
     }
 
     @ParameterizedTest
     @ArgumentsSource(GfEmbeddedJarNameProvider.class)
     void testExecuteCommandsInOrderDefinedInPropertiesFile(String gfEmbeddedJarName) throws Exception {
         Process gfEmbeddedProcess = runGlassFishEmbedded(gfEmbeddedJarName,
-                "--properties=" + propertiesFile,
-                "get server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size"
+            "--properties=" + propertiesFile,
+            "get server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size"
         );
-        assertTrue(outputToStreamOfLines(gfEmbeddedProcess)
-                .filter(new TwoLineMatcher(
-                        line -> line.contains("Description: get"),
-                        line -> line.contains("server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size=200")
-                ))
-                .findAny().isPresent(),
-                "Message about max-thread-pool-size=200 set is found");
-        gfEmbeddedProcess
-                .waitFor(30, TimeUnit.SECONDS);
+        assertThat(gfEmbeddedProcess.errorReader(),
+            stderrContains("server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size=200"));
+        assertTrue(gfEmbeddedProcess.waitFor(30, SECONDS), "Process finished.");
     }
 
     @ParameterizedTest
     @ArgumentsSource(GfEmbeddedJarNameProvider.class)
     void testPropertyNamesVariants(String gfEmbeddedJarName) throws Exception {
         Process gfEmbeddedProcess = runGlassFishEmbedded(gfEmbeddedJarName,
-                "--properties=" + propertiesFile,
-                "get server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size",
-                "get resources.jdbc-connection-pool.DerbyPool.connection-leak-timeout-in-seconds",
-                "get server.network-config.protocols.protocol.http-listener.http.max-connections",
-                "get security-configurations.authorization-service.authorizationService.default"
-
+            "--properties=" + propertiesFile,
+            "get server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size",
+            "get resources.jdbc-connection-pool.DerbyPool.connection-leak-timeout-in-seconds",
+            "get server.network-config.protocols.protocol.http-listener.http.max-connections",
+            "get security-configurations.authorization-service.authorizationService.default"
         );
-        gfEmbeddedProcess
-                .waitFor(30, TimeUnit.SECONDS);
-        List<String> appliedPropertyLogs = outputToStreamOfLines(gfEmbeddedProcess)
-                .filter(new TwoLineMatcher(
-                        line -> line.contains("Description: get"),
-                        line -> true
-                ))
-                .collect(Collectors.toList());
-        assertTrue(appliedPropertyLogs
-                .get(0).contains("server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size=200"));
-        assertTrue(appliedPropertyLogs
-                .get(1).contains("resources.jdbc-connection-pool.DerbyPool.connection-leak-timeout-in-seconds=5"));
-        assertTrue(appliedPropertyLogs
-                .get(2).contains("server.network-config.protocols.protocol.http-listener.http.max-connections=10000"));
-        assertTrue(appliedPropertyLogs
-                .get(3).contains("security-configurations.authorization-service.authorizationService.default=false"));
-        assertTrue(appliedPropertyLogs.size() == 4,"4 properties should be logged");
-    }
-
-    private class TwoLineMatcher implements Predicate<String> {
-
-        AtomicReference<String> previousLine = new AtomicReference<>();
-        Predicate<String> previousLinePredicate;
-        Predicate<String> currentLinePredicate;
-
-        public TwoLineMatcher(Predicate<String> previousLinePredicate, Predicate<String> currentLinePredicate) {
-            this.previousLinePredicate = previousLinePredicate;
-            this.currentLinePredicate = currentLinePredicate;
-        }
-
-        @Override
-        public boolean test(String line) {
-            boolean lineMatches = previousLine.get() != null
-                    && previousLinePredicate.test(previousLine.get())
-                    && currentLinePredicate.test(line);
-            previousLine.set(line);
-            return lineMatches;
-        }
+        assertThat(gfEmbeddedProcess.errorReader(),
+            stderrContains("server.thread-pools.thread-pool.http-thread-pool.max-thread-pool-size=200",
+                "resources.jdbc-connection-pool.DerbyPool.connection-leak-timeout-in-seconds=5",
+                "server.network-config.protocols.protocol.http-listener.http.max-connections=10000",
+                "security-configurations.authorization-service.authorizationService.default=false"));
+        assertTrue(gfEmbeddedProcess.waitFor(30, SECONDS), "Process finished.");
     }
-
 }