Add a simple test for the Invoker main class.

This currently just command-line arguments and environment variables.

PiperOrigin-RevId: 293497402

Author: eamonnmcmanus

invoker/core/src/main/java/com/google/cloud/functions/invoker/runner/Invoker.java

@@ -35,6 +35,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.logging.Level;
@@ -105,6 +106,17 @@ private static class Options {
   }
 
   public static void main(String[] args) throws Exception {
+    Optional<Invoker> invoker = makeInvoker(args);
+    if (invoker.isPresent()) {
+      invoker.get().startServer();
+    }
+  }
+
+  static Optional<Invoker> makeInvoker(String... args) {
+    return makeInvoker(System.getenv(), args);
+  }
+
+  static Optional<Invoker> makeInvoker(Map<String, String> environment, String... args) {
     Options options = new Options();
     JCommander jCommander = JCommander.newBuilder()
         .addObject(options)
@@ -118,7 +130,7 @@ public static void main(String[] args) throws Exception {
 
     if (options.help) {
       jCommander.usage();
-      return;
+      return Optional.empty();
     }
 
     int port;
@@ -134,7 +146,7 @@ public static void main(String[] args) throws Exception {
     Optional<String> functionJarPath =
         Arrays.asList(
             options.jar,
-            System.getenv("FUNCTION_JAR"),
+            environment.get("FUNCTION_JAR"),
             Files.exists(standardFunctionJarPath) ? standardFunctionJarPath.toString() : null)
             .stream()
             .filter(Objects::nonNull)
@@ -143,10 +155,9 @@ public static void main(String[] args) throws Exception {
         new Invoker(
             port,
             functionTarget,
-            // TODO: remove once function signature type is inferred from the method signature.
-            System.getenv("FUNCTION_SIGNATURE_TYPE"),
+            environment.get("FUNCTION_SIGNATURE_TYPE"),
             functionJarPath);
-    invoker.startServer();
+    return Optional.of(invoker);
   }
 
   private static boolean isLocalRun() {
@@ -169,6 +180,22 @@ public Invoker(
     this.functionJarPath = functionJarPath;
   }
 
+  Integer getPort() {
+    return port;
+  }
+
+  String getFunctionTarget() {
+    return functionTarget;
+  }
+
+  String getFunctionSignatureType() {
+    return functionSignatureType;
+  }
+
+  Optional<String> getFunctionJarPath() {
+    return functionJarPath;
+  }
+
   public void startServer() throws Exception {
     Server server = new Server(port);
 

invoker/core/src/test/java/com/google/cloud/functions/invoker/runner/InvokerTest.java

@@ -0,0 +1,99 @@
+package com.google.cloud.functions.invoker.runner;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth8.assertThat;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InvokerTest {
+  @Test
+  public void help() throws IOException {
+    String help = captureOutput(() -> {
+      Optional<Invoker> invoker = Invoker.makeInvoker("--help");
+      assertThat(invoker).isEmpty();
+    });
+    assertThat(help).contains("Usage:");
+    assertThat(help).contains("--target");
+  }
+
+  @Test
+  public void defaultPort() {
+    Optional<Invoker> invoker = Invoker.makeInvoker();
+    assertThat(invoker.get().getPort()).isEqualTo(8080);
+  }
+
+  @Test
+  public void explicitPort() {
+    Optional<Invoker> invoker = Invoker.makeInvoker("--port", "1234");
+    assertThat(invoker.get().getPort()).isEqualTo(1234);
+  }
+
+  @Test
+  public void defaultTarget() {
+    Optional<Invoker> invoker = Invoker.makeInvoker();
+    assertThat(invoker.get().getFunctionTarget()).isEqualTo("TestFunction.function");
+  }
+
+  @Test
+  public void explicitTarget() {
+    Optional<Invoker> invoker = Invoker.makeInvoker("--target", "com.example.MyFunction");
+    assertThat(invoker.get().getFunctionTarget()).isEqualTo("com.example.MyFunction");
+  }
+
+  @Test
+  public void defaultSignatureType() {
+    Optional<Invoker> invoker = Invoker.makeInvoker();
+    assertThat(invoker.get().getFunctionSignatureType()).isNull();
+  }
+
+  @Test
+  public void explicitSignatureType() {
+    Map<String, String> env = Collections.singletonMap("FUNCTION_SIGNATURE_TYPE", "http");
+    Optional<Invoker> invoker = Invoker.makeInvoker(env);
+    assertThat(invoker.get().getFunctionSignatureType()).isEqualTo("http");
+  }
+
+  @Test
+  public void defaultJar() {
+    Optional<Invoker> invoker = Invoker.makeInvoker();
+    assertThat(invoker.get().getFunctionJarPath()).isEmpty();
+  }
+
+  @Test
+  public void explicitJarViaEnvironment() {
+    Map<String, String> env = Collections.singletonMap("FUNCTION_JAR", "/foo/bar/baz.jar");
+    Optional<Invoker> invoker = Invoker.makeInvoker(env);
+    assertThat(invoker.get().getFunctionJarPath()).hasValue("/foo/bar/baz.jar");
+  }
+
+  @Test
+  public void explicitJarViaOption() {
+    Optional<Invoker> invoker = Invoker.makeInvoker("--jar", "/foo/bar/baz.jar");
+    assertThat(invoker.get().getFunctionJarPath()).hasValue("/foo/bar/baz.jar");
+  }
+
+  private static String captureOutput(Runnable operation) throws IOException {
+    PrintStream originalOut = System.out;
+    PrintStream originalErr = System.err;
+    ByteArrayOutputStream byteCapture = new ByteArrayOutputStream();
+    try (PrintStream capture = new PrintStream(byteCapture)) {
+      System.setOut(capture);
+      System.setErr(capture);
+      operation.run();
+    } finally {
+      System.setOut(originalOut);
+      System.setErr(originalErr);
+    }
+    return new String(byteCapture.toByteArray(), StandardCharsets.UTF_8);
+  }
+}