nexarch/connect/internal/webhookclient/webhookclient_test.go

package webhookclient

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"
)

// newFakeCoreWebhookAPI steht fuer Core API-07s echten Vertrag (POST
// /webhooks/subscriptions, DELETE /webhooks/subscriptions/{id}) -- testet
// die echte HTTP-Kette (Client -> echter Server -> Antwort-Dekodierung),
// nicht nur eine wirkungslose lokale Struktur.
func newFakeCoreWebhookAPI(t *testing.T) (*httptest.Server, *[]string) {
	t.Helper()
	var calls []string
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		calls = append(calls, r.Method+" "+r.URL.String())
		if r.Header.Get("X-Service-Token") == "" {
			t.Fatalf("Service-Token fehlt bei %s %s", r.Method, r.URL.Path)
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/webhooks/subscriptions":
			var in subscribeRequest
			if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
				t.Fatalf("body dekodieren: %v", err)
			}
			w.WriteHeader(http.StatusCreated)
			_ = json.NewEncoder(w).Encode(Subscription{
				ID: "core-sub-1", EventType: in.EventType, TargetURL: in.TargetURL, CreatedAt: time.Now().UTC(),
			})
		case r.Method == http.MethodDelete:
			w.WriteHeader(http.StatusNoContent)
		default:
			w.WriteHeader(http.StatusNotFound)
		}
	}))
	return srv, &calls
}

func TestSubscribe_SendsRequestFields_ReturnsSubscription(t *testing.T) {
	srv, _ := newFakeCoreWebhookAPI(t)
	defer srv.Close()

	c := New(srv.URL, "svc-token-123")
	sub, err := c.Subscribe(context.Background(), "acme", "dms.document.archived", "https://connect.example/d/abc", "shh-secret")
	if err != nil {
		t.Fatalf("Subscribe: %v", err)
	}
	if sub.ID != "core-sub-1" {
		t.Fatalf("erwartete core-vergebene id, bekam %q", sub.ID)
	}
	if sub.EventType != "dms.document.archived" {
		t.Fatalf("event_type nicht wie gesendet: %q", sub.EventType)
	}
}

func TestSubscribe_UnexpectedStatus_ReturnsError(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	defer srv.Close()

	c := New(srv.URL, "svc-token-123")
	if _, err := c.Subscribe(context.Background(), "acme", "dms.document.archived", "https://connect.example/d/abc", "shh"); err == nil {
		t.Fatal("erwarteter Fehler bei Status 500 blieb aus")
	}
}

func TestSubscribe_TransportError_ReturnsError(t *testing.T) {
	c := New("http://127.0.0.1:1", "svc-token-123")
	if _, err := c.Subscribe(context.Background(), "acme", "dms.document.archived", "https://connect.example/d/abc", "shh"); err == nil {
		t.Fatal("erwarteter Transport-Fehler blieb aus")
	}
}

func TestUnsubscribe_SendsServiceTokenAndTenant_Succeeds(t *testing.T) {
	srv, calls := newFakeCoreWebhookAPI(t)
	defer srv.Close()

	c := New(srv.URL, "svc-token-123")
	if err := c.Unsubscribe(context.Background(), "acme", "core-sub-1"); err != nil {
		t.Fatalf("Unsubscribe: %v", err)
	}
	if len(*calls) != 1 || (*calls)[0] != "DELETE /webhooks/subscriptions/core-sub-1?tenant_slug=acme" {
		t.Fatalf("unerwartete aufrufe: %v", *calls)
	}
}

func TestUnsubscribe_UnexpectedStatus_ReturnsError(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	defer srv.Close()

	c := New(srv.URL, "svc-token-123")
	if err := c.Unsubscribe(context.Background(), "acme", "core-sub-1"); err == nil {
		t.Fatal("erwarteter Fehler bei Status 500 blieb aus")
	}
}

func TestUnsubscribe_TransportError_ReturnsError(t *testing.T) {
	c := New("http://127.0.0.1:1", "svc-token-123")
	if err := c.Unsubscribe(context.Background(), "acme", "core-sub-1"); err == nil {
		t.Fatal("erwarteter Transport-Fehler blieb aus")
	}
}