Function TestConnectionReuse

webhooks_test.go:82–174

(t *testing.T)

}

func TestConnectionReuse(t *testing.T) {
	// Track unique connections
	var connectionsMutex sync.Mutex
	connections := make(map[string]bool)
	requestCount := 0

	// Create test server that tracks connections
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		connectionsMutex.Lock()
		defer connectionsMutex.Unlock()

		// Track unique remote addresses (connections)
		remoteAddr := r.RemoteAddr
		connections[remoteAddr] = true
		requestCount++

		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"status":"ok"}`))
	}))
	defer server.Close()

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

	// Configure with test server URL
	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)

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

	// Send multiple webhook requests directly (bypass queue for immediate testing)
	numRequests := 10
	testWebhook := NewWebhook{
		Event:   "transaction.applied",
		Payload: map[string]interface{}{"test": "data"},
	}

	// Send multiple requests concurrently to test connection reuse