feat: initial java <-> go integration test (#2339)

Initial PR that tests simple interop. This will be expanded to cover as many different types and features as possible.
TBD54566975 · Aug 13, 2024 · 907731e · 907731e
1 parent 9e82265
commit 907731e
Show file tree

Hide file tree

Showing 15 changed files with 364 additions and 16 deletions.
diff --git a/go-runtime/compile/build.go b/go-runtime/compile/build.go
@@ -289,7 +289,7 @@ func GenerateStubsForModules(ctx context.Context, projectRoot string, moduleConf
 		var moduleConfig *moduleconfig.ModuleConfig
 		for _, mc := range moduleConfigs {
 			mcCopy := mc
-			if mc.Module == module.Name {
+			if mc.Module == module.Name && mc.Language == "go" {
 				moduleConfig = &mcCopy
 				break
 			}
@@ -362,6 +362,9 @@ func SyncGeneratedStubReferences(ctx context.Context, projectRootDir string, stu
 			}
 			sharedModulesPaths = append(sharedModulesPaths, filepath.Join(projectRootDir, buildDirName, "go", "modules", mod))
 		}
+		if moduleConfig.Language != "go" {
+			continue
+		}
 
 		_, goModVersion, err := updateGoModule(filepath.Join(moduleConfig.Dir, "go.mod"))
 		if err != nil {

diff --git a/integration/harness.go b/integration/harness.go
@@ -51,7 +51,18 @@ var buildOnce sync.Once
 //	"database/ftl-project.toml" would set FTL_CONFIG to
 //	"integration/testdata/go/database/ftl-project.toml").
 func Run(t *testing.T, ftlConfigPath string, actions ...Action) {
-	run(t, ftlConfigPath, true, actions...)
+	run(t, ftlConfigPath, true, false, actions...)
+}
+
+// RunWithJava runs an integration test after building the Java runtime.
+// ftlConfigPath: if FTL_CONFIG should be set for this test, then pass in the relative
+//
+//	path based on ./testdata/go/ where "." denotes the directory containing the
+//	integration test (e.g. for "integration/harness_test.go" supplying
+//	"database/ftl-project.toml" would set FTL_CONFIG to
+//	"integration/testdata/go/database/ftl-project.toml").
+func RunWithJava(t *testing.T, ftlConfigPath string, actions ...Action) {
+	run(t, ftlConfigPath, true, true, actions...)
 }
 
 // RunWithoutController runs an integration test without starting the controller.
@@ -62,7 +73,7 @@ func Run(t *testing.T, ftlConfigPath string, actions ...Action) {
 //	"database/ftl-project.toml" would set FTL_CONFIG to
 //	"integration/testdata/go/database/ftl-project.toml").
 func RunWithoutController(t *testing.T, ftlConfigPath string, actions ...Action) {
-	run(t, ftlConfigPath, false, actions...)
+	run(t, ftlConfigPath, false, false, actions...)
 }
 
 func RunWithEncryption(t *testing.T, ftlConfigPath string, actions ...Action) {
@@ -72,10 +83,10 @@ func RunWithEncryption(t *testing.T, ftlConfigPath string, actions ...Action) {
 	t.Setenv("FTL_LOG_ENCRYPTION_KEY", logKey)
 	t.Setenv("FTL_ASYNC_ENCRYPTION_KEY", asyncKey)
 
-	run(t, ftlConfigPath, true, actions...)
+	run(t, ftlConfigPath, true, false, actions...)
 }
 
-func run(t *testing.T, ftlConfigPath string, startController bool, actions ...Action) {
+func run(t *testing.T, ftlConfigPath string, startController bool, requireJava bool, actions ...Action) {
 	tmpDir := t.TempDir()
 
 	cwd, err := os.Getwd()
@@ -116,6 +127,10 @@ func run(t *testing.T, ftlConfigPath string, startController bool, actions ...Ac
 		Infof("Building ftl")
 		err = ftlexec.Command(ctx, log.Debug, rootDir, "just", "build", "ftl").RunBuffered(ctx)
 		assert.NoError(t, err)
+		if requireJava {
+			err = ftlexec.Command(ctx, log.Debug, rootDir, "just", "build-java").RunBuffered(ctx)
+			assert.NoError(t, err)
+		}
 	})
 
 	verbs := rpc.Dial(ftlv1connect.NewVerbServiceClient, "http://localhost:8892", log.Debug)

diff --git a/...ntime/ftl-runtime/deployment/src/main/java/xyz/block/ftl/deployment/FTLCodeGenerator.java b/...ntime/ftl-runtime/deployment/src/main/java/xyz/block/ftl/deployment/FTLCodeGenerator.java
@@ -113,7 +113,7 @@ public boolean trigger(CodeGenContext context) throws CodeGenException {
                                         .build())
                                 .addModifiers(Modifier.PUBLIC);
                         if (verb.getRequest().hasUnit() && verb.getResponse().hasUnit()) {
-                            typeBuilder.addSuperinterface(ParameterizedTypeName.get(ClassName.get(VerbClientEmpty.class)));
+                            typeBuilder.addSuperinterface(ClassName.get(VerbClientEmpty.class));
                         } else if (verb.getRequest().hasUnit()) {
                             typeBuilder.addSuperinterface(ParameterizedTypeName.get(ClassName.get(VerbClientSource.class),
                                     toJavaTypeName(verb.getResponse(), typeAliasMap)));

diff --git a/java-runtime/ftl-runtime/deployment/src/main/java/xyz/block/ftl/deployment/FtlProcessor.java b/java-runtime/ftl-runtime/deployment/src/main/java/xyz/block/ftl/deployment/FtlProcessor.java
@@ -75,6 +75,7 @@
 import xyz.block.ftl.runtime.FTLController;
 import xyz.block.ftl.runtime.FTLHttpHandler;
 import xyz.block.ftl.runtime.FTLRecorder;
+import xyz.block.ftl.runtime.JsonSerializationConfig;
 import xyz.block.ftl.runtime.TopicHelper;
 import xyz.block.ftl.runtime.VerbClientHelper;
 import xyz.block.ftl.runtime.VerbHandler;
@@ -149,8 +150,9 @@ BindableServiceBuildItem verbService() {
     @BuildStep
     AdditionalBeanBuildItem beans() {
         return AdditionalBeanBuildItem.builder()
-                .addBeanClasses(VerbHandler.class, VerbRegistry.class, FTLHttpHandler.class, FTLController.class,
-                        TopicHelper.class, VerbClientHelper.class)
+                .addBeanClasses(VerbHandler.class,
+                        VerbRegistry.class, FTLHttpHandler.class, FTLController.class,
+                        TopicHelper.class, VerbClientHelper.class, JsonSerializationConfig.class)
                 .setUnremovable().build();
     }
 
@@ -477,8 +479,10 @@ private void handleVerbMethod(ExtractionContext context, MethodInfo method, Stri
                 verbBuilder.addMetadata(Metadata.newBuilder().setCalls(callsMetadata));
             }
 
+            //TODO: we need better handling around Optional
             context.recorder.registerVerb(context.moduleName(), verbName, method.name(), parameterTypes,
-                    Class.forName(className, false, Thread.currentThread().getContextClassLoader()), paramMappers);
+                    Class.forName(className, false, Thread.currentThread().getContextClassLoader()), paramMappers,
+                    method.returnType() == VoidType.VOID);
             verbBuilder
                     .setName(verbName)
                     .setExport(exported)

diff --git a/java-runtime/ftl-runtime/runtime/src/main/java/xyz/block/ftl/runtime/FTLRecorder.java b/java-runtime/ftl-runtime/runtime/src/main/java/xyz/block/ftl/runtime/FTLRecorder.java
@@ -21,13 +21,14 @@ public class FTLRecorder {
     public static final String X_FTL_VERB = "X-ftl-verb";
 
     public void registerVerb(String module, String verbName, String methodName, List<Class<?>> parameterTypes,
-            Class<?> verbHandlerClass, List<BiFunction<ObjectMapper, CallRequest, Object>> paramMappers) {
+            Class<?> verbHandlerClass, List<BiFunction<ObjectMapper, CallRequest, Object>> paramMappers,
+            boolean allowNullReturn) {
         //TODO: this sucks
         try {
             var method = verbHandlerClass.getDeclaredMethod(methodName, parameterTypes.toArray(new Class[0]));
             var handlerInstance = Arc.container().instance(verbHandlerClass);
             Arc.container().instance(VerbRegistry.class).get().register(module, verbName, handlerInstance, method,
-                    paramMappers);
+                    paramMappers, allowNullReturn);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

diff --git a/...time/ftl-runtime/runtime/src/main/java/xyz/block/ftl/runtime/JsonSerializationConfig.java b/...time/ftl-runtime/runtime/src/main/java/xyz/block/ftl/runtime/JsonSerializationConfig.java
@@ -0,0 +1,18 @@
+package xyz.block.ftl.runtime;
+
+import jakarta.enterprise.event.Observes;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+
+import io.quarkus.runtime.StartupEvent;
+
+/**
+ * This class configures the FTL serialization
+ */
+public class JsonSerializationConfig {
+
+    void startup(@Observes StartupEvent event, ObjectMapper mapper) {
+        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+    }
+}
diff --git a/java-runtime/ftl-runtime/runtime/src/main/java/xyz/block/ftl/runtime/VerbRegistry.java b/java-runtime/ftl-runtime/runtime/src/main/java/xyz/block/ftl/runtime/VerbRegistry.java
@@ -2,6 +2,7 @@
 
 import java.io.IOException;
 import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -35,8 +36,8 @@ public VerbRegistry(ObjectMapper mapper) {
     }
 
     public void register(String module, String name, InstanceHandle<?> verbHandlerClass, Method method,
-            List<BiFunction<ObjectMapper, CallRequest, Object>> paramMappers) {
-        verbs.put(new Key(module, name), new AnnotatedEndpointHandler(verbHandlerClass, method, paramMappers));
+            List<BiFunction<ObjectMapper, CallRequest, Object>> paramMappers, boolean allowNullReturn) {
+        verbs.put(new Key(module, name), new AnnotatedEndpointHandler(verbHandlerClass, method, paramMappers, allowNullReturn));
     }
 
     public void register(String module, String name, VerbInvoker verbInvoker) {
@@ -60,12 +61,14 @@ private class AnnotatedEndpointHandler implements VerbInvoker {
         final InstanceHandle<?> verbHandlerClass;
         final Method method;
         final List<BiFunction<ObjectMapper, CallRequest, Object>> parameterSuppliers;
+        final boolean allowNull;
 
         private AnnotatedEndpointHandler(InstanceHandle<?> verbHandlerClass, Method method,
-                List<BiFunction<ObjectMapper, CallRequest, Object>> parameterSuppliers) {
+                List<BiFunction<ObjectMapper, CallRequest, Object>> parameterSuppliers, boolean allowNull) {
             this.verbHandlerClass = verbHandlerClass;
             this.method = method;
             this.parameterSuppliers = parameterSuppliers;
+            this.allowNull = allowNull;
         }
 
         public CallResponse handle(CallRequest in) {
@@ -76,8 +79,18 @@ public CallResponse handle(CallRequest in) {
                 }
                 Object ret;
                 ret = method.invoke(verbHandlerClass.get(), params);
-                var mappedResponse = mapper.writer().writeValueAsBytes(ret);
-                return CallResponse.newBuilder().setBody(ByteString.copyFrom(mappedResponse)).build();
+                if (ret == null) {
+                    if (allowNull) {
+                        return CallResponse.newBuilder().setBody(ByteString.copyFrom("{}", StandardCharsets.UTF_8)).build();
+                    } else {
+                        return CallResponse.newBuilder().setError(
+                                CallResponse.Error.newBuilder().setMessage("Verb returned an unexpected null response").build())
+                                .build();
+                    }
+                } else {
+                    var mappedResponse = mapper.writer().writeValueAsBytes(ret);
+                    return CallResponse.newBuilder().setBody(ByteString.copyFrom(mappedResponse)).build();
+                }
             } catch (Exception e) {
                 log.errorf(e, "Failed to invoke verb %s.%s", in.getVerb().getModule(), in.getVerb().getName());
                 return CallResponse.newBuilder().setError(CallResponse.Error.newBuilder().setMessage(e.getMessage()).build())

diff --git a/java-runtime/java_integration_test.go b/java-runtime/java_integration_test.go
@@ -0,0 +1,58 @@
+//go:build integration
+
+package ftl_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/alecthomas/assert/v2"
+
+	in "github.com/TBD54566975/ftl/integration"
+
+	"github.com/alecthomas/repr"
+)
+
+func TestJavaToGoCall(t *testing.T) {
+	in.RunWithJava(t, "",
+		in.CopyModule("gomodule"),
+		in.CopyDir("javamodule", "javamodule"),
+		in.Deploy("gomodule"),
+		in.Deploy("javamodule"),
+		in.Call("javamodule", "timeVerb", in.Obj{}, func(t testing.TB, response in.Obj) {
+			message, ok := response["time"].(string)
+			assert.True(t, ok, "time is not a string: %s", repr.String(response))
+			result, err := time.Parse(time.RFC3339, message)
+			assert.NoError(t, err, "time is not a valid RFC3339 time: %s", message)
+			assert.True(t, result.After(time.Now().Add(-time.Minute)), "time is not recent: %s", message)
+		}),
+		// We call both the go and pass through Java versions
+		// To make sure the response is the same
+		in.Call("gomodule", "emptyVerb", in.Obj{}, func(t testing.TB, response in.Obj) {
+			assert.Equal(t, map[string]any{}, response, "expecting empty response, got %s", repr.String(response))
+		}),
+		in.Call("javamodule", "emptyVerb", in.Obj{}, func(t testing.TB, response in.Obj) {
+			assert.Equal(t, map[string]any{}, response, "expecting empty response, got %s", repr.String(response))
+		}),
+		in.Call("gomodule", "sinkVerb", "ignored", func(t testing.TB, response in.Obj) {
+			assert.Equal(t, map[string]any{}, response, "expecting empty response, got %s", repr.String(response))
+		}),
+		in.Call("javamodule", "sinkVerb", "ignored", func(t testing.TB, response in.Obj) {
+			assert.Equal(t, map[string]any{}, response, "expecting empty response, got %s", repr.String(response))
+		}),
+		in.Call("gomodule", "sourceVerb", in.Obj{}, func(t testing.TB, response string) {
+			assert.Equal(t, "Source Verb", response, "expecting empty response, got %s", response)
+		}),
+		in.Call("javamodule", "sourceVerb", in.Obj{}, func(t testing.TB, response string) {
+			assert.Equal(t, "Source Verb", response, "expecting empty response, got %s", response)
+		}),
+		in.Fail(
+			in.Call("gomodule", "errorEmptyVerb", in.Obj{}, func(t testing.TB, response in.Obj) {
+				assert.Equal(t, map[string]any{}, response, "expecting empty response, got %s", repr.String(response))
+			}), "verb failed"),
+		in.Fail(
+			in.Call("gomodule", "errorEmptyVerb", in.Obj{}, func(t testing.TB, response in.Obj) {
+				assert.Equal(t, map[string]any{}, response, "expecting empty response, got %s", repr.String(response))
+			}), "verb failed"),
+	)
+}
diff --git a/java-runtime/testdata/go/gomodule/ftl.toml b/java-runtime/testdata/go/gomodule/ftl.toml
@@ -0,0 +1,5 @@
+module = "gomodule"
+language = "go"
+
+[go.replace]
+"github.com/TBD54566975/ftl" = "../.."
diff --git a/java-runtime/testdata/go/gomodule/go.mod b/java-runtime/testdata/go/gomodule/go.mod
@@ -0,0 +1,5 @@
+module ftl/gomodule
+
+go 1.22.2
+
+replace github.com/TBD54566975/ftl => ./../../../..
diff --git a/java-runtime/testdata/go/gomodule/go.sum b/java-runtime/testdata/go/gomodule/go.sum
diff --git a/java-runtime/testdata/go/gomodule/server.go b/java-runtime/testdata/go/gomodule/server.go
@@ -0,0 +1,38 @@
+package gomodule
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+type TimeRequest struct {
+}
+type TimeResponse struct {
+	Time time.Time
+}
+
+//ftl:verb export
+func SourceVerb(ctx context.Context) (string, error) {
+	return "Source Verb", nil
+}
+
+//ftl:verb export
+func SinkVerb(ctx context.Context, req string) error {
+	return nil
+}
+
+//ftl:verb export
+func EmptyVerb(ctx context.Context) error {
+	return nil
+}
+
+//ftl:verb export
+func ErrorEmptyVerb(ctx context.Context) error {
+	return fmt.Errorf("verb failed")
+}
+
+//ftl:verb export
+func Time(ctx context.Context, req TimeRequest) (TimeResponse, error) {
+	return TimeResponse{Time: time.Now()}, nil
+}
diff --git a/java-runtime/testdata/go/javamodule/ftl.toml b/java-runtime/testdata/go/javamodule/ftl.toml
@@ -0,0 +1,2 @@
+module = "echoclient"
+language = "java"