test: added IT test for integrations

Also included a minor fixes for setting the main class from integrations
and correctly closing integration class loaders.

Author: quintesse

itests/integrations/integration.java

@@ -0,0 +1,51 @@
+
+//FILES META-INF/jbang-integration.list=jbang-integration.list
+
+import java.nio.file.Path;
+import java.util.*;
+
+public class integration {
+    /**
+     *
+     * @param temporaryJar temporary JAR file path
+     * @param pomFile location of pom.xml representing the projects dependencies
+     * @param repositories list of the used repositories
+     * @param dependencies list of GAV to Path of artifact/classpath dependencies
+     * @param comments comments from the source file
+     * @param nativeImage true if --native been requested
+     * @return Map<String, Object> map of returns; special keys are "native-image" which is a and "files" to
+     *          return native-image to be run and list of files to get written to the output directory.
+     *
+     */
+    public static Map<String, Object> postBuild(
+            Path temporaryJar,
+            Path pomFile,
+            List<Map.Entry<String, String>> repositories,
+            List<Map.Entry<String, Path>> dependencies,
+            List<String> comments,
+    boolean nativeImage) {
+        System.out.println("Integration called!");
+        System.out.println("TMPJAR: " + temporaryJar);
+        System.out.println("POM: " + pomFile);
+        for (Map.Entry<String, String> r : repositories) {
+            System.out.println("REPO: " + r.getKey() + " -> " + r.getValue());
+        }
+        for (Map.Entry<String, Path> d : dependencies) {
+            System.out.println("DEP: " + d.getKey() + " -> " + d.getValue());
+        }
+        for (String c : comments) {
+            System.out.println("COMMENT: " + c);
+        }
+
+        String myTest = comments.stream()
+                .filter(s -> s.startsWith("//MY:TEST "))
+                .findFirst()
+                .map(s -> s.substring("//MY:TEST ".length()))
+                .orElse("default");
+        Map<String, Object> result = new HashMap<>();
+        result.put("java-args", Arrays.asList("-Dbar=" + myTest));
+        result.put("main-class", "altmain");
+        return result;
+    }
+
+}

itests/integrations/jbang-integration.list

@@ -0,0 +1 @@
+integration

itests/integrations/main.java

@@ -0,0 +1,21 @@
+///usr/bin/env jbang "$0" "$@" ; exit $?
+
+//DEPS integration.java
+//RUNTIME_OPTIONS -Dfoo=fubar
+//MY:TEST aap
+
+public class main {
+
+    public static void main(String... args) {
+        System.out.println("Wrong main!!!");
+    }
+}
+
+class altmain {
+
+    public static void main(String... args) {
+        System.out.println("Hello World!");
+        System.out.println("foo: " + System.getProperty("foo"));
+        System.out.println("bar: " + System.getProperty("bar"));
+    }
+}

src/it/java/dev/jbang/it/IntegrationIT.java

@@ -0,0 +1,21 @@
+package dev.jbang.it;
+
+import static dev.jbang.it.CommandResultAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+public class IntegrationIT extends BaseIT {
+	@Test
+	void testIntegration() {
+		assertThat(shell("jbang --fresh integrations/main.java"))
+			.outContains("Hello World")
+			.outContains("foo: fubar")
+			.outContains("bar: aap");
+	}
+
+	@Test
+	void testNoIntegration() {
+		assertThat(shell("jbang --fresh --no-integrations integrations/main.java"))
+			.outContains("Wrong main!!!");
+	}
+}

src/main/java/dev/jbang/source/buildsteps/IntegrationBuildStep.java

@@ -37,11 +37,13 @@ public IntegrationResult build() throws IOException {
 		try {
 			IntegrationResult integrationResult = IntegrationManager.runIntegrations(ctx);
 
-			if (project.getMainClass() == null) { // if non-null user forced set main
-				if (integrationResult.mainClass != null) {
-					project.setMainClass(integrationResult.mainClass);
-				}
+			// TODO the compile step always sets the main class if it can find one
+			// so this check is no longer valid. Figure out if we can make this work
+			// if (project.getMainClass() == null) { // if non-null user forced set main
+			if (integrationResult.mainClass != null) {
+				project.setMainClass(integrationResult.mainClass);
 			}
+			// }
 			if (integrationResult.javaArgs != null && !integrationResult.javaArgs.isEmpty()) {
 				// Add integration options to the java options
 				project.addRuntimeOptions(integrationResult.javaArgs);

src/main/java/dev/jbang/spi/IntegrationManager.java

@@ -78,15 +78,14 @@ public static IntegrationResult runIntegrations(BuildContext ctx) {
 		for (ArtifactInfo art : ctx.resolveClassPath().getArtifacts()) {
 			if (art.getCoordinate() != null) { // skipping dependencies that does not have a GAV
 				deps.put(art.getCoordinate().toCanonicalForm(), art.getFile());
+			} else {
+				deps.put(art.getFile().getFileName().toString(), art.getFile());
 			}
 		}
 
 		List<String> comments = source.getTags().map(s -> "//" + s).collect(Collectors.toList());
-		ClassLoader old = Thread.currentThread().getContextClassLoader();
 		PrintStream oldout = System.out;
-		try {
-			URLClassLoader integrationCl = getClassLoader(deps.values());
-			Thread.currentThread().setContextClassLoader(integrationCl);
+		try (URLClassLoader integrationCl = getClassLoader(deps.values())) {
 			String requestedJavaVersion = prj.getJavaVersion();
 			Set<String> classNames = loadIntegrationClassNames(integrationCl);
 			for (String className : classNames) {
@@ -95,10 +94,12 @@ public static IntegrationResult runIntegrations(BuildContext ctx) {
 						: null;
 				IntegrationInput input = new IntegrationInput(className, srcPath, compileDir, pomPath, repos, deps,
 						comments, prj.isNativeImage(), Util.isVerbose());
-				IntegrationResult ir = requestedJavaVersion == null || JavaUtil.satisfiesRequestedVersion(
-						requestedJavaVersion, JavaUtil.getCurrentMajorJavaVersion())
-								? runIntegrationEmbedded(input, integrationCl)
-								: runIntegrationExternal(input, prj.getProperties(), prj.projectJdk());
+				boolean embedded = (requestedJavaVersion == null || JavaUtil.satisfiesRequestedVersion(
+						requestedJavaVersion, JavaUtil.getCurrentMajorJavaVersion()))
+						&& !"true".equals(System.getProperty("jbang.build.integration.forceExternal"));
+				IntegrationResult ir = embedded
+						? runIntegrationEmbedded(input, integrationCl)
+						: runIntegrationExternal(input, prj.getProperties(), prj.projectJdk());
 				result = result.merged(ir);
 			}
 		} catch (ClassNotFoundException e) {
@@ -111,7 +112,6 @@ public static IntegrationResult runIntegrations(BuildContext ctx) {
 		} catch (Exception e) {
 			throw new ExitException(EXIT_GENERIC_ERROR, "Issue running postBuild()", e);
 		} finally {
-			Thread.currentThread().setContextClassLoader(old);
 			System.setOut(oldout);
 		}
 		return result;
@@ -157,6 +157,17 @@ private static Set<String> loadIntegrationClassNames(URLClassLoader integrationC
 
 	private static IntegrationResult runIntegrationEmbedded(IntegrationInput input, URLClassLoader integrationCl)
 			throws Exception {
+		ClassLoader old = Thread.currentThread().getContextClassLoader();
+		try {
+			Thread.currentThread().setContextClassLoader(integrationCl);
+			return runIntegrationEmbedded_(input, integrationCl);
+		} finally {
+			Thread.currentThread().setContextClassLoader(old);
+		}
+	}
+
+	private static IntegrationResult runIntegrationEmbedded_(IntegrationInput input, URLClassLoader integrationCl)
+			throws Exception {
 		Util.infoMsg("Post build with " + input.integrationClassName);
 
 		if (input.source != null) {

src/test/java/dev/jbang/BaseTest.java

@@ -67,6 +67,7 @@ void initEnv(@TempDir Path tempPath) throws IOException {
 		Util.setCwd(cwdDir);
 		System.setProperty("user.home", tempPath.toString());
 		System.setProperty("maven.repo.local", mavenTempDir.toString());
+		// System.setProperty("jbang.build.integration.forceExternal", "true");
 		// Each test gets a fresh JBang config folder
 		environmentVariables.set(Settings.JBANG_DIR, jbangTempDir.toString());
 		// Each test gets a fresh cache folder