Function TestProcessWebhookWithReusedClient

webhooks_test.go:208–266

(t *testing.T)

}

func TestProcessWebhookWithReusedClient(t *testing.T) {
	// Track that the same client instance is used
	var clientUsed *http.Client
	var clientMutex sync.Mutex

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"status":"ok"}`))
	}))
	defer server.Close()

	// Setup miniredis
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("an error '%s' occurred when starting miniredis", err)
	}
	defer mr.Close()

	cnf := &config.Configuration{
		Redis: config.RedisConfig{
			Dns: mr.Addr(),
		},
		Queue: config.QueueConfig{
			WebhookQueue:   "webhook_queue",
			NumberOfQueues: 1,
		},
		Notification: config.Notification{
			Webhook: config.WebhookConfig{
				Url: server.URL,
			},
		},
	}
	config.ConfigStore.Store(cnf)

	ledgerforge, err := NewLedgerForge(nil)
	assert.NoError(t, err)
	defer func() { _ = ledgerforge.Close() }()

	// Store reference to the HTTP client
	clientMutex.Lock()
	clientUsed = ledgerforge.httpClient
	clientMutex.Unlock()

	// Create webhook payloads
	webhook1 := NewWebhook{Event: "test.event1", Payload: map[string]string{"id": "1"}}
	webhook2 := NewWebhook{Event: "test.event2", Payload: map[string]string{"id": "2"}}

	// Process webhooks using the same client
	err1 := processHTTP(webhook1, ledgerforge.httpClient)
	err2 := processHTTP(webhook2, ledgerforge.httpClient)

	assert.NoError(t, err1)
	assert.NoError(t, err2)

	// Verify the same client instance was used
	clientMutex.Lock()
	assert.Same(t, clientUsed, ledgerforge.httpClient, "Should use the same HTTP client instance")
	clientMutex.Unlock()