chore: Codecov

Signed-off-by: Javier Aliaga <javier@diagrid.io>

Author: javier-aliaga

sdk-workflows/src/test/java/io/dapr/workflows/runtime/WorkflowClassWrapperTest.java

@@ -18,8 +18,10 @@
 import io.dapr.workflows.WorkflowContext;
 import io.dapr.workflows.WorkflowStub;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -33,6 +35,14 @@ public WorkflowStub create() {
     }
   }
 
+  public static abstract class TestErrorWorkflow implements Workflow {
+    public TestErrorWorkflow(String s){}
+    @Override
+    public WorkflowStub create() {
+      return WorkflowContext::getInstanceId;
+    }
+  }
+
   @Test
   public void getName() {
     WorkflowClassWrapper<TestWorkflow> wrapper = new WorkflowClassWrapper<>(TestWorkflow.class);
@@ -53,4 +63,19 @@ public void createWithClass() {
     verify(mockContext, times(1)).getInstanceId();
   }
 
+  @Test
+  public void createWithClassAndVersion() {
+    TaskOrchestrationContext mockContext = mock(TaskOrchestrationContext.class);
+    WorkflowClassWrapper<TestWorkflow> wrapper = new WorkflowClassWrapper<>(TestWorkflow.class, "TestWorkflowV1",false);
+    when(mockContext.getInstanceId()).thenReturn("uuid");
+    wrapper.create().run(mockContext);
+    verify(mockContext, times(1)).getInstanceId();
+  }
+
+  @Test
+  public void createErrorClassAndVersion() {
+      Executable as  = () -> new WorkflowClassWrapper<>(TestErrorWorkflow.class, "TestWorkflowV1",false);
+      assertThrowsExactly(RuntimeException.class, as);
+  }
+
 }

sdk-workflows/src/test/java/io/dapr/workflows/runtime/WorkflowRuntimeBuilderTest.java

@@ -47,11 +47,24 @@ public void registerValidWorkflowClass() {
     assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(TestWorkflow.class));
   }
 
+  @Test
+  public void registerValidVersionWorkflowClass() {
+    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(TestWorkflow.class,"testWorkflowV1", false));
+    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(TestWorkflow.class,"testWorkflowV2", true));
+  }
+
   @Test
   public void registerValidWorkflowInstance() {
     assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(new TestWorkflow()));
   }
 
+  @Test
+  public void registerValidVersionWorkflowInstance() {
+    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(new TestWorkflow(),"testWorkflowV1", false));
+    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerWorkflow(new TestWorkflow(),"testWorkflowV2", true));
+  }
+
+
   @Test
   public void registerValidWorkflowActivityClass() {
     assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerActivity(TestActivity.class));
@@ -62,12 +75,15 @@ public void registerValidWorkflowActivityInstance() {
     assertDoesNotThrow(() -> new WorkflowRuntimeBuilder().registerActivity(new TestActivity()));
   }
 
+
+
   @Test
   public void buildTest() {
     assertDoesNotThrow(() -> {
       try {
         WorkflowRuntime runtime = new WorkflowRuntimeBuilder().build();
         System.out.println("WorkflowRuntime created");
+        runtime.close();
       } catch (Exception e) {
         throw new RuntimeException(e);
       }
@@ -82,16 +98,18 @@ public void loggingOutputTest() {
 
     Logger testLogger = mock(Logger.class);
 
-    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder(testLogger).registerWorkflow(TestWorkflow.class));
-    assertDoesNotThrow(() -> new WorkflowRuntimeBuilder(testLogger).registerActivity(TestActivity.class));
+var runtimeBuilder =    new WorkflowRuntimeBuilder(testLogger);
+    assertDoesNotThrow(() -> runtimeBuilder.registerWorkflow(TestWorkflow.class));
+    assertDoesNotThrow(() -> runtimeBuilder.registerActivity(TestActivity.class));
 
-    WorkflowRuntimeBuilder workflowRuntimeBuilder = new WorkflowRuntimeBuilder();
+    var runtime = runtimeBuilder.build();
 
-    WorkflowRuntime runtime = workflowRuntimeBuilder.build();
     verify(testLogger, times(1))
         .info(eq("Registered Workflow: {}"), eq("TestWorkflow"));
 
     verify(testLogger, times(1))
         .info(eq("Registered Activity: {}"), eq("TestActivity"));
+
+    runtime.close();
   }
 }

sdk-workflows/src/test/java/io/dapr/workflows/runtime/WorkflowVersionWrapperTest.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2026 The Dapr Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package io.dapr.workflows.runtime;
+
+import io.dapr.durabletask.TaskOrchestration;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class WorkflowVersionWrapperTest {
+
+  @Test
+  void getVersionProperties() {
+   var versionWrapper = new WorkflowVersionWrapper("A",true) {
+      @Override
+      public String getName() {
+       return "demo";
+      }
+
+      @Override
+      public TaskOrchestration create() {
+        return null;
+      }
+    };
+
+   assertEquals("A",versionWrapper.getVersionName());
+   assertEquals(true, versionWrapper.isLatestVersion());
+  }
+}