Migrating ITs to Testcontainers

sdk-tests/src/test/java/io/dapr/it/actors/ActivationDeactivationIT.java

@@ -14,40 +14,68 @@
 package io.dapr.it.actors;
 
 import io.dapr.actors.ActorId;
+import io.dapr.actors.client.ActorClient;
 import io.dapr.actors.client.ActorProxyBuilder;
-import io.dapr.it.BaseIT;
 import io.dapr.it.actors.services.springboot.DemoActor;
-import io.dapr.it.actors.services.springboot.DemoActorService;
+import io.dapr.actors.runtime.ActorRuntime;
+import io.dapr.it.actors.services.springboot.DaprApplication;
+import io.dapr.it.actors.services.springboot.DemoActorImpl;
+import io.dapr.it.testcontainers.actors.TestDaprActorsConfiguration;
+import io.dapr.testcontainers.Component;
+import io.dapr.testcontainers.DaprContainer;
+import io.dapr.testcontainers.DaprLogLevel;
+import io.dapr.testcontainers.internal.DaprContainerFactory;
+import io.dapr.testcontainers.internal.DaprSidecarContainer;
+import io.dapr.testcontainers.internal.spring.DaprSpringBootTest;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
 
+import java.time.Duration;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static io.dapr.it.Retry.callWithRetry;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-public class ActivationDeactivationIT extends BaseIT {
+@DaprSpringBootTest(classes = {DaprApplication.class, TestDaprActorsConfiguration.class})
+public class ActivationDeactivationIT {
 
-  private static Logger logger = LoggerFactory.getLogger(ActivationDeactivationIT.class);
+  private static final Logger logger = LoggerFactory.getLogger(ActivationDeactivationIT.class);
+
+  @DaprSidecarContainer
+  private static final DaprContainer DAPR_CONTAINER = DaprContainerFactory.createForSpringBootTest("activation-deactivation-it")
+      .withComponent(new Component("kvstore", "state.in-memory", "v1", Map.of("actorStateStore", "true")))
+      .withDaprLogLevel(DaprLogLevel.DEBUG)
+      .withLogConsumer(outputFrame -> logger.info(outputFrame.getUtf8String()));
+
+  @Autowired
+  private ActorClient actorClient;
+
+  @Autowired
+  private ActorRuntime actorRuntime;
+
+  @BeforeEach
+  void setUp() {
+    DemoActorImpl.ACTIVE_ACTOR.clear();
+    actorRuntime.getConfig().setActorIdleTimeout(Duration.ofSeconds(5));
+    actorRuntime.getConfig().setActorScanInterval(Duration.ofSeconds(2));
+    actorRuntime.getConfig().setDrainOngoingCallTimeout(Duration.ofSeconds(10));
+    actorRuntime.getConfig().setDrainBalancedActors(true);
+    actorRuntime.registerActor(DemoActorImpl.class);
+    ActorTestBootstrap.exposeHostPortAndWaitForActorType(DAPR_CONTAINER, "DemoActorTest");
+  }
 
   @Test
   public void activateInvokeDeactivate() throws Exception {
-    // The call below will fail if service cannot start successfully.
-    var run = startDaprApp(
-        ActivationDeactivationIT.class.getSimpleName(),
-        DemoActorService.SUCCESS_MESSAGE,
-        DemoActorService.class,
-        true,
-        60000);
-
     final AtomicInteger atomicInteger = new AtomicInteger(1);
     logger.debug("Creating proxy builder");
-    ActorProxyBuilder<DemoActor> proxyBuilder
-        = new ActorProxyBuilder(DemoActor.class, deferClose(run.newActorClient()));
+    ActorProxyBuilder<DemoActor> proxyBuilder = new ActorProxyBuilder<>(DemoActor.class, actorClient);
     logger.debug("Creating actorId");
     ActorId actorId1 = new ActorId(Integer.toString(atomicInteger.getAndIncrement()));
     logger.debug("Building proxy");

sdk-tests/src/test/java/io/dapr/it/actors/ActorExceptionIT.java

@@ -14,44 +14,62 @@
 package io.dapr.it.actors;
 
 import io.dapr.actors.ActorId;
+import io.dapr.actors.client.ActorClient;
 import io.dapr.actors.client.ActorProxyBuilder;
-import io.dapr.it.BaseIT;
-import io.dapr.it.DaprRun;
+import io.dapr.config.Properties;
 import io.dapr.it.actors.app.MyActor;
-import io.dapr.it.actors.app.MyActorService;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeAll;
+import io.dapr.it.actors.app.TestApplication;
+import io.dapr.it.testcontainers.actors.TestDaprActorsConfiguration;
+import io.dapr.testcontainers.Component;
+import io.dapr.testcontainers.DaprContainer;
+import io.dapr.testcontainers.DaprLogLevel;
+import io.dapr.testcontainers.internal.DaprContainerFactory;
+import io.dapr.testcontainers.internal.DaprSidecarContainer;
+import io.dapr.testcontainers.internal.spring.DaprSpringBootTest;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
 
 import java.util.Map;
 
 import static io.dapr.it.Retry.callWithRetry;
 import static io.dapr.it.TestUtils.assertThrowsDaprExceptionSubstring;
 
+@DaprSpringBootTest(classes = {
+    TestApplication.class,
+    TestDaprActorsConfiguration.class,
+    MyActorRuntimeRegistrationConfiguration.class
+})
+public class ActorExceptionIT {
 
-public class ActorExceptionIT extends BaseIT {
+  private static final Logger logger = LoggerFactory.getLogger(ActorExceptionIT.class);
 
-  private static Logger logger = LoggerFactory.getLogger(ActorExceptionIT.class);
+  @DaprSidecarContainer
+  private static final DaprContainer DAPR_CONTAINER = DaprContainerFactory.createForSpringBootTest("actor-exception-it")
+      .withComponent(new Component("kvstore", "state.in-memory", "v1", Map.of("actorStateStore", "true")))
+      .withDaprLogLevel(DaprLogLevel.DEBUG)
+      .withLogConsumer(outputFrame -> logger.info(outputFrame.getUtf8String()));
 
-  private static DaprRun run;
+  @Autowired
+  private ActorClient actorClient;
 
-  @BeforeAll
-  public static void start() throws Exception {
-    // The call below will fail if service cannot start successfully.
-    run = startDaprApp(
-        ActorExceptionIT.class.getSimpleName(),
-        MyActorService.SUCCESS_MESSAGE,
-        MyActorService.class,
-        true,
-        60000);
+  @BeforeEach
+  public void setUp() {
+    ActorTestBootstrap.exposeHostPortAndWaitForActorType(DAPR_CONTAINER, "MyActorTest");
+  }
+
+  private ActorClient newActorClient(Map<String, String> metadata) {
+    return new ActorClient(new Properties(Map.of(
+        "dapr.http.endpoint", "http://127.0.0.1:" + DAPR_CONTAINER.getHttpPort(),
+        "dapr.grpc.endpoint", "127.0.0.1:" + DAPR_CONTAINER.getGrpcPort())), metadata, null);
   }
 
   @Test
   public void exceptionTest() throws Exception {
     ActorProxyBuilder<MyActor> proxyBuilder =
-        new ActorProxyBuilder("MyActorTest", MyActor.class, deferClose(run.newActorClient()));
+        new ActorProxyBuilder<>("MyActorTest", MyActor.class, actorClient);
     MyActor proxy = proxyBuilder.build(new ActorId("1"));
 
     callWithRetry(() -> {
@@ -66,15 +84,17 @@ public void exceptionTest() throws Exception {
   public void exceptionDueToMetadataTest() throws Exception {
     // Setting this HTTP header via actor metadata will cause the Actor HTTP server to error.
     Map<String, String> metadata = Map.of("Content-Length", "9999");
-    ActorProxyBuilder<MyActor> proxyBuilderMetadataOverride =
-        new ActorProxyBuilder("MyActorTest", MyActor.class, deferClose(run.newActorClient(metadata)));
+    try (ActorClient actorClientWithMetadata = newActorClient(metadata)) {
+      ActorProxyBuilder<MyActor> proxyBuilderMetadataOverride =
+          new ActorProxyBuilder<>("MyActorTest", MyActor.class, actorClientWithMetadata);
 
-    MyActor proxyWithMetadata = proxyBuilderMetadataOverride.build(new ActorId("2"));
-    callWithRetry(() -> {
-      assertThrowsDaprExceptionSubstring(
-          "INTERNAL",
-          "ContentLength=9999 with Body length 13",
-          () -> proxyWithMetadata.say("hello world"));
-    }, 10000);
+      MyActor proxyWithMetadata = proxyBuilderMetadataOverride.build(new ActorId("2"));
+      callWithRetry(() -> {
+        assertThrowsDaprExceptionSubstring(
+            "INTERNAL",
+            "ContentLength=9999 with Body length 13",
+            () -> proxyWithMetadata.say("hello world"));
+      }, 10000);
+    }
   }
 }

sdk-tests/src/test/java/io/dapr/it/actors/ActorMethodNameIT.java

@@ -14,35 +14,57 @@
 package io.dapr.it.actors;
 
 import io.dapr.actors.ActorId;
+import io.dapr.actors.client.ActorClient;
 import io.dapr.actors.client.ActorProxy;
 import io.dapr.actors.client.ActorProxyBuilder;
-import io.dapr.it.BaseIT;
 import io.dapr.it.actors.app.MyActor;
-import io.dapr.it.actors.app.MyActorService;
+import io.dapr.it.actors.app.TestApplication;
+import io.dapr.it.testcontainers.actors.TestDaprActorsConfiguration;
+import io.dapr.testcontainers.Component;
+import io.dapr.testcontainers.DaprContainer;
+import io.dapr.testcontainers.DaprLogLevel;
+import io.dapr.testcontainers.internal.DaprContainerFactory;
+import io.dapr.testcontainers.internal.DaprSidecarContainer;
+import io.dapr.testcontainers.internal.spring.DaprSpringBootTest;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.Map;
 
 import static io.dapr.it.Retry.callWithRetry;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-public class ActorMethodNameIT extends BaseIT {
+@DaprSpringBootTest(classes = {
+    TestApplication.class,
+    TestDaprActorsConfiguration.class,
+    MyActorRuntimeRegistrationConfiguration.class
+})
+public class ActorMethodNameIT {
+
+  private static final Logger logger = LoggerFactory.getLogger(ActorMethodNameIT.class);
 
-  private static Logger logger = LoggerFactory.getLogger(ActorMethodNameIT.class);
+  @DaprSidecarContainer
+  private static final DaprContainer DAPR_CONTAINER = DaprContainerFactory.createForSpringBootTest("actor-method-name-it")
+      .withComponent(new Component("kvstore", "state.in-memory", "v1", Map.of("actorStateStore", "true")))
+      .withDaprLogLevel(DaprLogLevel.DEBUG)
+      .withLogConsumer(outputFrame -> logger.info(outputFrame.getUtf8String()));
+
+  @Autowired
+  private ActorClient actorClient;
+
+  @BeforeEach
+  void setUp() {
+    ActorTestBootstrap.exposeHostPortAndWaitForActorType(DAPR_CONTAINER, "MyActorTest");
+  }
 
   @Test
   public void actorMethodNameChange() throws Exception {
-    // The call below will fail if service cannot start successfully.
-    var run = startDaprApp(
-        ActorMethodNameIT.class.getSimpleName(),
-        MyActorService.SUCCESS_MESSAGE,
-        MyActorService.class,
-        true,
-        60000);
-
     logger.debug("Creating proxy builder");
     ActorProxyBuilder<MyActor> proxyBuilder =
-        new ActorProxyBuilder("MyActorTest", MyActor.class, deferClose(run.newActorClient()));
+        new ActorProxyBuilder<>("MyActorTest", MyActor.class, actorClient);
     logger.debug("Creating actorId");
     ActorId actorId1 = new ActorId("1");
     logger.debug("Building proxy");
@@ -57,7 +79,7 @@ public void actorMethodNameChange() throws Exception {
 
     logger.debug("Creating proxy builder 2");
     ActorProxyBuilder<ActorProxy> proxyBuilder2 =
-        new ActorProxyBuilder("MyActorTest", ActorProxy.class, deferClose(run.newActorClient()));
+        new ActorProxyBuilder<>("MyActorTest", ActorProxy.class, actorClient);
     logger.debug("Building proxy 2");
     ActorProxy proxy2 = proxyBuilder2.build(actorId1);
 
@@ -67,6 +89,5 @@ public void actorMethodNameChange() throws Exception {
       logger.debug("asserting true response 2: [" + response + "]");
       assertTrue(response);
     }, 60000);
-
   }
 }