snapshot of https://github.com/centrifugal/centrifugo.git (master, 2026-09-16; blobs > 131072B omitted)

internal/consuming/google_pub_sub_test.go

@@ -0,0 +1,110 @@
+//go:build integration
+
+package consuming
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
+	"google.golang.org/protobuf/types/known/durationpb"
+
+	"cloud.google.com/go/pubsub/v2"
+	"github.com/google/uuid"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+func TestGooglePubSubConsumer(t *testing.T) {
+	// Point the Pub/Sub client to the emulator.
+	_ = os.Setenv("PUBSUB_EMULATOR_HOST", "localhost:8085")
+	defer func() {
+		_ = os.Unsetenv("PUBSUB_EMULATOR_HOST")
+	}()
+
+	ctx := context.Background()
+
+	// Setup project, topic, and subscription IDs for testing.
+	projectID := "test-project-" + uuid.NewString()
+	topicID := "test-topic-" + uuid.NewString()
+	subscriptionID := "test-subscription-" + uuid.NewString()
+
+	// Create a Pub/Sub client (will connect to the emulator).
+	client, err := pubsub.NewClient(ctx, projectID)
+	if err != nil {
+		t.Fatalf("failed to create pubsub client: %v", err)
+	}
+
+	topic := &pubsubpb.Topic{
+		Name: fmt.Sprintf("projects/%s/topics/%s", projectID, topicID),
+	}
+	_, err = client.TopicAdminClient.CreateTopic(ctx, topic)
+	if err != nil {
+		t.Fatalf("failed to create topic: %v", err)
+	}
+
+	s := &pubsubpb.Subscription{
+		Name:                          fmt.Sprintf("projects/%s/subscriptions/%s", projectID, subscriptionID),
+		Topic:                         topic.Name,
+		TopicMessageRetentionDuration: durationpb.New(1 * time.Hour),
+		EnableMessageOrdering:         true,
+		AckDeadlineSeconds:            20,
+	}
+	_, err = client.SubscriptionAdminClient.CreateSubscription(ctx, s)
+	if err != nil {
+		t.Fatalf("failed to create subscription: %v", err)
+	}
+
+	publisher := client.Publisher(topic.Name)
+	publisher.EnableMessageOrdering = true
+
+	// Publish a message with an ordering key.
+	orderingKey := "order-1"
+	result := publisher.Publish(ctx, &pubsub.Message{
+		Data:        []byte("Hello, Pub/Sub with ordering!"),
+		OrderingKey: orderingKey,
+		Attributes: map[string]string{
+			"example": "value",
+		},
+	})
+	id, err := result.Get(ctx)
+	if err != nil {
+		t.Fatalf("failed to publish message: %v", err)
+	}
+	t.Logf("Published a message with ID: %s", id)
+
+	config := GooglePubSubConsumerConfig{
+		ProjectID:              projectID,
+		Subscriptions:          []string{subscriptionID},
+		MaxOutstandingMessages: 10,
+	}
+
+	done := make(chan struct{})
+	// Ensure done is closed only once. PUB/SUB emulator we use in tests is a bit aggressive
+	// in sending duplicate messages.
+	var closeDoneOnce sync.Once
+
+	dispatcher := &MockDispatcher{
+		onDispatchCommand: func(ctx context.Context, method string, data []byte) error {
+			closeDoneOnce.Do(func() {
+				close(done)
+			})
+			return nil
+		},
+	}
+	consumer, err := NewGooglePubSubConsumer(config, dispatcher, testCommon(prometheus.NewRegistry()))
+	if err != nil {
+		t.Fatalf("failed to create consumer: %v", err)
+	}
+
+	go func() {
+		if err := consumer.Run(ctx); err != nil {
+			t.Errorf("consumer error: %v", err)
+		}
+	}()
+
+	waitCh(t, done, 5*time.Second, "timeout waiting for message processing")
+}