GetWorkflowStateAsync should always return WorkflowState

src/Dapr.Workflow/Client/WorkflowGrpcClient.cs

@@ -73,17 +73,26 @@ public override async Task<string> ScheduleNewWorkflowAsync(string workflowName,
             var grpcCallOptions = CreateCallOptions(cancellationToken);
             var response = await grpcClient.GetInstanceAsync(request, grpcCallOptions);
 
-            if (!response.Exists)
+            if (response is null)
             {
                 logger.LogGetWorkflowMetadataInstanceNotFound(instanceId);
                 return null;
             }
 
+            if (!response.Exists)
+            {
+                return null;
+            }
+
             return ProtoConverters.ToWorkflowMetadata(response.WorkflowState, serializer);
         }
         catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
         {
-            logger.LogGetWorkflowMetadataInstanceNotFound(ex, instanceId);
+            return null;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error getting workflow metadata for instance '{InstanceId}'", instanceId);
             return null;
         }
     }

src/Dapr.Workflow/DaprWorkflowClient.cs

@@ -128,7 +128,7 @@ public Task<string> ScheduleNewWorkflowAsync(
     /// exist or an error occurs retrieving the metadata.
     /// This method never throws.
     /// </returns>
-    public async Task<WorkflowState?> GetWorkflowStateAsync(
+    public async Task<WorkflowState> GetWorkflowStateAsync(
         string instanceId,
         bool getInputsAndOutputs = true,
         CancellationToken cancellation = default)
@@ -138,12 +138,12 @@ public Task<string> ScheduleNewWorkflowAsync(
         try
         {
             var metadata = await _innerClient.GetWorkflowMetadataAsync(instanceId, getInputsAndOutputs, cancellation);
-            return metadata is null ? null : new WorkflowState(metadata);    
+            return new WorkflowState(metadata);    
         }
         catch (RpcException)
         {
             // If the state doesn't exist, we typically get an `RpcException`, so this wraps this and just returns null
-            return null;
+            return new WorkflowState(null);
         }
     }
 

src/Dapr.Workflow/IDaprWorkflowClient.cs

@@ -91,7 +91,7 @@ Task<string> ScheduleNewWorkflowAsync(
     /// A <see cref="WorkflowMetadata"/> object, or <c>null</c> if the workflow instance does not exist.
     /// </returns>
     /// <exception cref="ArgumentException">Thrown if <paramref name="instanceId"/> is null or empty.</exception>
-    Task<WorkflowState?> GetWorkflowStateAsync(
+    Task<WorkflowState> GetWorkflowStateAsync(
         string instanceId,
         bool getInputsAndOutputs = true,
         CancellationToken cancellation = default);

test/Dapr.IntegrationTest.Workflow/PurgeTests.cs

@@ -66,7 +66,8 @@ public async Task ShouldPurgeCompletedWorkflowInstance()
 
         // Verify workflow state no longer exists after purge
         var stateAfterPurge = await daprWorkflowClient.GetWorkflowStateAsync(workflowInstanceId, cancellation: TestContext.Current.CancellationToken);
-        Assert.Null(stateAfterPurge);
+        Assert.NotNull(stateAfterPurge);
+        Assert.False(stateAfterPurge.Exists);
     }
 
     [MinimumDaprRuntimeFact("1.17")]
@@ -153,15 +154,13 @@ public async Task ShouldPurgeTerminatedWorkflowInstance()
         Assert.True(purged);
 
         var stateAfterPurge = await daprWorkflowClient.GetWorkflowStateAsync(workflowInstanceId, cancellation: TestContext.Current.CancellationToken);
-        Assert.Null(stateAfterPurge);
+        Assert.NotNull(stateAfterPurge);
+        Assert.False(stateAfterPurge.Exists);
     }
 
     private sealed class SimpleWorkflow : Workflow<string, string>
     {
-        public override Task<string> RunAsync(WorkflowContext context, string input)
-        {
-            return Task.FromResult($"Processed: {input}");
-        }
+        public override Task<string> RunAsync(WorkflowContext context, string input) => Task.FromResult($"Processed: {input}");
     }
 
     private sealed class LongRunningWorkflow : Workflow<object?, string>

test/Dapr.Workflow.Test/DaprWorkflowClientTests.cs

@@ -85,20 +85,21 @@ public async Task GetWorkflowStateAsync_ShouldThrowArgumentException_WhenInstanc
     }
 
     [Fact]
-    public async Task GetWorkflowStateAsync_ShouldReturnNull_WhenInnerReturnsNullMetadata()
+    public async Task GetWorkflowStateAsync_ShouldReflectNotExists_WhenInnerReturnsNullMetadata()
     {
         var inner = new CapturingWorkflowClient { GetWorkflowMetadataResult = null };
         var client = new DaprWorkflowClient(inner);
 
         var state = await client.GetWorkflowStateAsync("missing", cancellation: TestContext.Current.CancellationToken);
 
-        Assert.Null(state);
+        Assert.NotNull(state);
+        Assert.False(state.Exists);
         Assert.Equal("missing", inner.LastGetMetadataInstanceId);
         Assert.True(inner.LastGetMetadataGetInputsAndOutputs);
     }
 
     [Fact]
-    public async Task GetWorkflowStateAsync_ShouldReturnNull_WhenInnerThrowsRpcException()
+    public async Task GetWorkflowStateAsync_ShouldReflectNotExists_WhenInnerThrowsRpcException()
     {
         var inner = new CapturingWorkflowClient
         {
@@ -108,7 +109,8 @@ public async Task GetWorkflowStateAsync_ShouldReturnNull_WhenInnerThrowsRpcExcep
 
         var state = await client.GetWorkflowStateAsync("i", cancellation: TestContext.Current.CancellationToken);
 
-        Assert.Null(state);
+        Assert.NotNull(state);
+        Assert.False(state.Exists);
     }
 
     [Fact]