tests

Author: maxdml

dbos/serialization_test.go

@@ -2,8 +2,10 @@ package dbos
 
 import (
 	"context"
+	"encoding/gob"
 	"errors"
 	"fmt"
+	"strings"
 	"testing"
 	"time"
 
@@ -44,6 +46,11 @@ type SimpleStruct struct {
 	B int
 }
 
+type PointerResultStruct struct {
+	Value string
+	Count int
+}
+
 func encodingWorkflowStruct(ctx DBOSContext, input WorkflowInputStruct) (StepOutputStruct, error) {
 	return RunAsStep(ctx, func(context context.Context) (StepOutputStruct, error) {
 		return encodingStepStruct(context, StepInputStruct{
@@ -60,12 +67,76 @@ func encodingStepStruct(_ context.Context, input StepInputStruct) (StepOutputStr
 	}, nil
 }
 
+// Test nil pointer is ignored during encode
+func encodingWorkflowNilReturn(ctx DBOSContext, shouldReturnNil bool) (string, error) {
+	pointerResult, err := RunAsStep(ctx, func(context context.Context) (*PointerResultStruct, error) {
+		if shouldReturnNil {
+			return nil, nil
+		}
+		return &PointerResultStruct{
+			Value: "pointer result",
+			Count: 42,
+		}, nil
+	})
+	if err != nil {
+		return "", fmt.Errorf("pointer step failed: %w", err)
+	}
+	// Build result summary
+	var summary []string
+	if shouldReturnNil {
+		summary = append(summary, "All nil types handled successfully")
+	} else {
+		if pointerResult != nil {
+			summary = append(summary, fmt.Sprintf("ptr:%s", pointerResult.Value))
+		}
+	}
+	return strings.Join(summary, ", "), nil
+}
+
+// Interface types for testing manual interface registration
+type ResponseInterface interface {
+	GetMessage() string
+	GetCode() int
+}
+
+type ConcreteResponse struct {
+	Message string
+	Code    int
+}
+
+func (c ConcreteResponse) GetMessage() string {
+	return c.Message
+}
+
+func (c ConcreteResponse) GetCode() int {
+	return c.Code
+}
+
+func encodingWorkflowInterface(ctx DBOSContext, input string) (ResponseInterface, error) {
+	result, err := RunAsStep(ctx, func(context context.Context) (ResponseInterface, error) {
+		return encodingStepInterface(context, input)
+	})
+	if err != nil {
+		return nil, fmt.Errorf("interface step failed: %w", err)
+	}
+	return result, nil
+}
+
+func encodingStepInterface(_ context.Context, input string) (ResponseInterface, error) {
+	return ConcreteResponse{
+		Message: fmt.Sprintf("Processed: %s", input),
+		Code:    200,
+	}, nil
+}
+
 func TestWorkflowEncoding(t *testing.T) {
 	executor := setupDBOS(t, true, true)
 
 	// Register workflows with executor
 	RegisterWorkflow(executor, encodingWorkflowBuiltinTypes)
 	RegisterWorkflow(executor, encodingWorkflowStruct)
+	RegisterWorkflow(executor, encodingWorkflowNilReturn)
+	RegisterWorkflow(executor, encodingWorkflowInterface)
 
 	err := Launch(executor)
 	require.NoError(t, err)
@@ -188,6 +259,109 @@ func TestWorkflowEncoding(t *testing.T) {
 		assert.Equal(t, "processed by encodingStepStruct", stepOutput.B)
 		assert.Nil(t, step.Error)
 	})
+
+	t.Run("NilableTypes", func(t *testing.T) {
+		// Test with non-nil values for all types
+		directHandle, err := RunWorkflow(executor, encodingWorkflowNilReturn, false)
+		require.NoError(t, err)
+
+		// Test result from direct handle
+		directResult, err := directHandle.GetResult()
+		require.NoError(t, err)
+		require.NotNil(t, directResult)
+		// Verify that we got results for all types
+		assert.Contains(t, directResult, "ptr:pointer result")
+
+		// Test result from polling handle
+		retrieveHandler, err := RetrieveWorkflow[string](executor.(*dbosContext), directHandle.GetWorkflowID())
+		require.NoError(t, err)
+		retrievedResult, err := retrieveHandler.GetResult()
+		require.NoError(t, err)
+		assert.Contains(t, retrievedResult, "ptr:pointer result")
+
+		// Test with nil values for all types
+		nilHandle, err := RunWorkflow(executor, encodingWorkflowNilReturn, true)
+		require.NoError(t, err)
+
+		// Test nil result from direct handle
+		nilDirectResult, err := nilHandle.GetResult()
+		require.NoError(t, err)
+		assert.Equal(t, "All nil types handled successfully", nilDirectResult)
+
+		// Test nil result from polling handle
+		nilRetrieveHandler, err := RetrieveWorkflow[string](executor.(*dbosContext), nilHandle.GetWorkflowID())
+		require.NoError(t, err)
+		nilRetrievedResult, err := nilRetrieveHandler.GetResult()
+		require.NoError(t, err)
+		assert.Equal(t, "All nil types handled successfully", nilRetrievedResult)
+
+		// Test results from GetWorkflowSteps to ensure all steps executed
+		steps, err := GetWorkflowSteps(executor, directHandle.GetWorkflowID())
+		require.NoError(t, err)
+		assert.Equal(t, 1, len(steps), "Expected 1 step for nil-able types")
+		for _, step := range steps {
+			assert.Nil(t, step.Error, "No step should have errors")
+		}
+	})
+
+	t.Run("ManualInterfaceRegistration", func(t *testing.T) {
+		// Manually register the concrete type for interface testing
+		gob.Register(ConcreteResponse{})
+
+		// Test a workflow that returns an interface with manually registered concrete type
+		directHandle, err := RunWorkflow(executor, encodingWorkflowInterface, "test-interface")
+		require.NoError(t, err)
+
+		// Test result from direct handle
+		directResult, err := directHandle.GetResult()
+		require.NoError(t, err)
+		require.NotNil(t, directResult)
+		assert.Equal(t, "Processed: test-interface", directResult.GetMessage())
+		assert.Equal(t, 200, directResult.GetCode())
+
+		// Test result from polling handle
+		retrieveHandler, err := RetrieveWorkflow[ResponseInterface](executor.(*dbosContext), directHandle.GetWorkflowID())
+		require.NoError(t, err)
+		retrievedResult, err := retrieveHandler.GetResult()
+		require.NoError(t, err)
+		require.NotNil(t, retrievedResult)
+		assert.Equal(t, "Processed: test-interface", retrievedResult.GetMessage())
+		assert.Equal(t, 200, retrievedResult.GetCode())
+
+		// Test results from ListWorkflows
+		workflows, err := ListWorkflows(
+			executor,
+			WithWorkflowIDs([]string{directHandle.GetWorkflowID()}),
+			WithLoadInput(true),
+			WithLoadOutput(true),
+		)
+		require.NoError(t, err)
+		require.Len(t, workflows, 1)
+		workflow := workflows[0]
+		require.NotNil(t, workflow.Input)
+		workflowInput, ok := workflow.Input.(string)
+		require.True(t, ok, "expected workflow input to be of type string, got %T", workflow.Input)
+		assert.Equal(t, "test-interface", workflowInput)
+		require.NotNil(t, workflow.Output)
+		// The output should be deserialized as ConcreteResponse since we registered it
+		workflowOutput, ok := workflow.Output.(ConcreteResponse)
+		require.True(t, ok, "expected workflow output to be of type ConcreteResponse, got %T", workflow.Output)
+		assert.Equal(t, "Processed: test-interface", workflowOutput.Message)
+		assert.Equal(t, 200, workflowOutput.Code)
+
+		// Test results from GetWorkflowSteps
+		steps, err := GetWorkflowSteps(executor, directHandle.GetWorkflowID())
+		require.NoError(t, err)
+		require.Len(t, steps, 1)
+		step := steps[0]
+		require.NotNil(t, step.Output)
+		// The step output should also be ConcreteResponse
+		stepOutput, ok := step.Output.(ConcreteResponse)
+		require.True(t, ok, "expected step output to be of type ConcreteResponse, got %T", step.Output)
+		assert.Equal(t, "Processed: test-interface", stepOutput.Message)
+		assert.Equal(t, 200, stepOutput.Code)
+		assert.Nil(t, step.Error)
+	})
 }
 
 type UserDefinedEventData struct {