client tests

Author: maxdml

dbos/client.go

@@ -146,12 +146,12 @@ func (c *client) Enqueue(queueName, workflowName string, input any, opts ...Enqu
 
 	// Validate partition key is not provided without queue name
 	if len(params.queuePartitionKey) > 0 && len(queueName) == 0 {
-		return nil, newWorkflowExecutionError("", fmt.Errorf("partition key provided but queue name is missing"))
+		return nil, fmt.Errorf("partition key provided but queue name is missing")
 	}
 
 	// Validate partition key and deduplication ID are not both provided (they are incompatible)
 	if len(params.queuePartitionKey) > 0 && len(params.deduplicationID) > 0 {
-		return nil, newWorkflowExecutionError("", fmt.Errorf("partition key and deduplication ID cannot be used together"))
+		return nil, fmt.Errorf("partition key and deduplication ID cannot be used together")
 	}
 
 	workflowID := params.workflowID

dbos/client_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestEnqueue(t *testing.T) {
+func TestClientEnqueue(t *testing.T) {
 	// Setup server context - this will process tasks
 	serverCtx := setupDBOS(t, true, true)
 
@@ -23,6 +23,10 @@ func TestEnqueue(t *testing.T) {
 	// Must be created before Launch()
 	priorityQueue := NewWorkflowQueue(serverCtx, "priority-test-queue", WithGlobalConcurrency(1), WithPriorityEnabled())
 
+	// Create a partitioned queue for partition key test
+	// Must be created before Launch()
+	partitionedQueue := NewWorkflowQueue(serverCtx, "client-partitioned-queue", WithPartitionQueue())
+
 	// Track execution order for priority test
 	var executionOrder []string
 	var mu sync.Mutex
@@ -59,6 +63,12 @@ func TestEnqueue(t *testing.T) {
 	}
 	RegisterWorkflow(serverCtx, priorityWorkflow, WithWorkflowName("PriorityWorkflow"))
 
+	// Simple workflow for partitioned queue test
+	partitionedWorkflow := func(ctx DBOSContext, input string) (string, error) {
+		return "partitioned: " + input, nil
+	}
+	RegisterWorkflow(serverCtx, partitionedWorkflow, WithWorkflowName("PartitionedWorkflow"))
+
 	// Launch the server context to start processing tasks
 	err := Launch(serverCtx)
 	require.NoError(t, err)
@@ -257,6 +267,77 @@ func TestEnqueue(t *testing.T) {
 		assert.True(t, queueEntriesAreCleanedUp(serverCtx), "expected queue entries to be cleaned up after deduplication test")
 	})
 
+	t.Run("EnqueueToPartitionedQueue", func(t *testing.T) {
+		// Enqueue a workflow to a partitioned queue with a partition key
+		handle, err := Enqueue[string, string](client, partitionedQueue.Name, "PartitionedWorkflow", "test-input",
+			WithEnqueueQueuePartitionKey("partition-1"),
+			WithEnqueueApplicationVersion(serverCtx.GetApplicationVersion()))
+		require.NoError(t, err, "failed to enqueue workflow to partitioned queue")
+
+		// Verify we got a polling handle
+		_, ok := handle.(*workflowPollingHandle[string])
+		require.True(t, ok, "expected handle to be of type workflowPollingHandle, got %T", handle)
+
+		// Get the result
+		result, err := handle.GetResult()
+		require.NoError(t, err, "failed to get result from partitioned queue workflow")
+
+		expectedResult := "partitioned: test-input"
+		assert.Equal(t, expectedResult, result, "expected result to match")
+
+		// Verify the workflow status
+		status, err := handle.GetStatus()
+		require.NoError(t, err, "failed to get workflow status")
+
+		assert.Equal(t, WorkflowStatusSuccess, status.Status, "expected workflow status to be SUCCESS")
+		assert.Equal(t, "PartitionedWorkflow", status.Name, "expected workflow name to match")
+		assert.Equal(t, partitionedQueue.Name, status.QueueName, "expected queue name to match")
+
+		assert.True(t, queueEntriesAreCleanedUp(serverCtx), "expected queue entries to be cleaned up after partitioned queue test")
+	})
+
+	t.Run("EnqueueWithPartitionKeyWithoutQueue", func(t *testing.T) {
+		// Attempt to enqueue with a partition key but no queue name
+		_, err := Enqueue[string, string](client, "", "PartitionedWorkflow", "test-input",
+			WithEnqueueQueuePartitionKey("partition-1"))
+		require.Error(t, err, "expected error when enqueueing with partition key but no queue name")
+
+		// Verify the error message contains the expected text
+		assert.Contains(t, err.Error(), "queue name is required", "expected error message to contain 'queue name is required'")
+	})
+
+	t.Run("EnqueueWithPartitionKeyAndDeduplicationID", func(t *testing.T) {
+		// Attempt to enqueue with both partition key and deduplication ID
+		// This should return an error
+		_, err := Enqueue[string, string](client, partitionedQueue.Name, "PartitionedWorkflow", "test-input",
+			WithEnqueueQueuePartitionKey("partition-1"),
+			WithEnqueueDeduplicationID("dedup-id"))
+		require.Error(t, err, "expected error when enqueueing with both partition key and deduplication ID")
+
+		// Verify the error message contains the expected text
+		assert.Contains(t, err.Error(), "partition key and deduplication ID cannot be used together", "expected error message to contain validation message")
+	})
+
+	t.Run("EnqueueWithEmptyQueueName", func(t *testing.T) {
+		// Attempt to enqueue with empty queue name
+		// This should return an error
+		_, err := Enqueue[wfInput, string](client, "", "ServerWorkflow", wfInput{Input: "test-input"})
+		require.Error(t, err, "expected error when enqueueing with empty queue name")
+
+		// Verify the error message contains the expected text
+		assert.Contains(t, err.Error(), "queue name is required", "expected error message to contain 'queue name is required'")
+	})
+
+	t.Run("EnqueueWithEmptyWorkflowName", func(t *testing.T) {
+		// Attempt to enqueue with empty workflow name
+		// This should return an error
+		_, err := Enqueue[wfInput, string](client, queue.Name, "", wfInput{Input: "test-input"})
+		require.Error(t, err, "expected error when enqueueing with empty workflow name")
+
+		// Verify the error message contains the expected text
+		assert.Contains(t, err.Error(), "workflow name is required", "expected error message to contain 'workflow name is required'")
+	})
+
 	// Verify all queue entries are cleaned up
 	require.True(t, queueEntriesAreCleanedUp(serverCtx), "expected queue entries to be cleaned up after client tests")
 }