Skip to content

Modern Docker Management, Designed for Everyone

31.3 KB
Raw Blame
package webhook

import (
	"context"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"

	"github.com/getarcaneapp/arcane/types/v2"
	"github.com/getarcaneapp/arcane/types/v2/user"
	"github.com/labstack/echo/v5"
	"github.com/libtnb/sqlite"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/kit/pkg"
	"go.getarcane.app/sys/crypto"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
)

// setupWebhookServiceTestDB creates an isolated in-memory SQLite DB for each test.
func setupWebhookServiceTestDB(t *testing.T) *database.DB {
	t.Helper()
	initWebhookTokenCryptoForTests()

	dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()))
	db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&Webhook{}))

	sqlDB, err := db.DB()
	require.NoError(t, err)
	sqlDB.SetMaxOpenConns(1)
	sqlDB.SetMaxIdleConns(1)

	return &database.DB{DB: db}
}

func initWebhookTokenCryptoForTests() {
	crypto.InitEncryption(&crypto.Config{
		EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
		Environment:   "test",
	})
}

// newTestWebhookService returns a WebhookService with nil updater/project/gitops services,
// sufficient for all tests that exercise lookup, hashing, and CRUD logic.
// Tests that exercise the dispatch path use an unknown target type to avoid a nil dereference.
func newTestWebhookService(db *database.DB) *WebhookService {
	return &WebhookService{db: db}
}

// fetchWebhook loads a webhook directly from the DB to inspect stored fields.
func fetchWebhook(t *testing.T, db *database.DB, id string) Webhook {
	t.Helper()
	var wh Webhook
	require.NoError(t, db.WithContext(t.Context()).Where("id = ?", id).First(&wh).Error)
	return wh
}

func defaultTestWebhookActionType(targetType string) string {
	switch targetType {
	case WebhookTargetTypeContainer, WebhookTargetTypeProject:
		return WebhookActionTypeUpdate
	case WebhookTargetTypeUpdater:
		return WebhookActionTypeRun
	case WebhookTargetTypeGitOps:
		return WebhookActionTypeSync
	default:
		return WebhookActionTypeUpdate
	}
}

func TestWebhookTokenFormat(t *testing.T) {
	initWebhookTokenCryptoForTests()

	raw, hash, prefix, err := generateWebhookTokenInternal()
	require.NoError(t, err)

	assert.True(t, strings.HasPrefix(raw, webhookTokenPrefix), "token must start with %q", webhookTokenPrefix)
	tokenHex := strings.TrimPrefix(raw, webhookTokenPrefix)
	encryptedBytes, err := hex.DecodeString(tokenHex)
	require.NoError(t, err)
	assert.Equal(t, webhookTokenPrefix+tokenHex[:webhookTokenPrefixLen], prefix, "prefix must be arc_wh_ + first %d chars of token hex", webhookTokenPrefixLen)

	encrypted := base64.StdEncoding.EncodeToString(encryptedBytes)
	decrypted, err := crypto.Decrypt(encrypted)
	require.NoError(t, err)
	assert.Len(t, decrypted, webhookTokenLength*2, "decrypted token payload must be 64 hex chars (32 bytes)")

	expected := sha256.Sum256([]byte(raw))
	assert.Equal(t, hex.EncodeToString(expected[:]), hash, "stored hash must be SHA-256 of the raw token")
}

func TestHashWebhookTokenIsDeterministic(t *testing.T) {
	raw := "arc_wh_0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
	first := kit.SHA256Hex(raw)
	second := kit.SHA256Hex(raw)
	assert.Equal(t, first, second)
}

func TestParseWebhookPrefix_ValidToken(t *testing.T) {
	raw := "arc_wh_0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
	prefix, err := parseWebhookPrefixInternal(raw)
	require.NoError(t, err)
	assert.Equal(t, "arc_wh_01020304", prefix)
}

func TestParseWebhookPrefix_MissingPrefix(t *testing.T) {
	_, err := parseWebhookPrefixInternal("notawebhooktoken")
	assert.ErrorIs(t, err, ErrWebhookInvalid)
}

func TestParseWebhookPrefix_TooShort(t *testing.T) {
	_, err := parseWebhookPrefixInternal("arc_wh_0102030") // 7 chars after prefix — too short
	assert.ErrorIs(t, err, ErrWebhookInvalid)
}

func TestParseWebhookPrefix_LeadingWhitespaceStripped(t *testing.T) {
	raw := "  arc_wh_0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20  "
	prefix, err := parseWebhookPrefixInternal(raw)
	require.NoError(t, err)
	assert.Equal(t, "arc_wh_01020304", prefix)
}

func TestIsKnownToken_StoredIdentity(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)
	wh, raw, err := svc.CreateWebhook(ctx, "known", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	require.True(t, svc.IsKnownToken(raw))

	unstored, _, _, err := generateWebhookTokenInternal()
	require.NoError(t, err)
	for _, token := range []string{unstored, "", "arc_wh_bad", " " + raw, raw + " ", strings.ToUpper(raw), raw[:len(raw)-1], webhookTokenPrefix + strings.Repeat("ab", 512*1024)} {
		require.False(t, svc.IsKnownToken(token))
	}
	var unavailable *WebhookService
	require.False(t, unavailable.IsKnownToken(raw))

	restarted := newTestWebhookService(db)
	require.NoError(t, restarted.LoadTokenHashes(ctx))
	require.True(t, restarted.IsKnownToken(raw), "existing tokens must be recognized before their first request after restart")
	_, err = restarted.UpdateWebhook(ctx, wh.ID, "env-1", false, user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	require.True(t, restarted.IsKnownToken(raw), "disabled tokens retain their independent abuse budget")
	require.ErrorIs(t, restarted.TriggerByToken(ctx, raw), ErrWebhookDisabled)
	require.ErrorIs(t, restarted.DeleteWebhook(ctx, wh.ID, "wrong-environment", user.Actor{}), ErrWebhookNotFound)
	require.True(t, restarted.IsKnownToken(raw))
	require.NoError(t, restarted.DeleteWebhook(ctx, wh.ID, "env-1", user.Actor{}))
	require.False(t, restarted.IsKnownToken(raw))
	require.ErrorIs(t, restarted.TriggerByToken(ctx, raw), ErrWebhookNotFound)
}

func TestKnownTokenRateLimit_ExhaustedIPDoesNotBlockFirstUse(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)
	_, first, err := svc.CreateWebhook(ctx, "first", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	_, second, err := svc.CreateWebhook(ctx, "second", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p2", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	svc = newTestWebhookService(db)
	require.NoError(t, svc.LoadTokenHashes(ctx))

	// Closing the database proves admission never queries it, even for unknown tokens.
	sqlDB, err := db.DB.DB()
	require.NoError(t, err)
	require.NoError(t, sqlDB.Close())
	router := echo.New()
	router.IPExtractor = echo.ExtractIPDirect()
	router.Use(middleware.PerTokenRateLimitForPaths([]string{"/trigger/:token"}, 1, 1, func(c *echo.Context) string { return c.Param("token") }, svc.IsKnownToken))
	router.POST("/trigger/:token", func(c *echo.Context) error { return c.NoContent(http.StatusAccepted) })
	request := func(token string) int {
		req := httptest.NewRequest(http.MethodPost, "/trigger/"+token, http.NoBody)
		req.RemoteAddr = "192.0.2.10:4000"
		rec := httptest.NewRecorder()
		router.ServeHTTP(rec, req)
		if rec.Code == http.StatusTooManyRequests {
			require.Equal(t, "60", rec.Header().Get("Retry-After"))
		}
		return rec.Code
	}
	require.Equal(t, http.StatusAccepted, request(webhookTokenPrefix+strings.Repeat("0", webhookTokenHexLen)))
	for i := range 200 {
		require.Equal(t, http.StatusTooManyRequests, request(fmt.Sprintf("%s%0184x", webhookTokenPrefix, i+1)))
	}
	require.Equal(t, http.StatusAccepted, request(first))
	require.Equal(t, http.StatusTooManyRequests, request(first))
	require.Equal(t, http.StatusAccepted, request(second))
}

func TestLoadTokenHashes_FailurePreservesIndex(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)
	_, raw, err := svc.CreateWebhook(ctx, "known", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	require.NoError(t, db.Migrator().DropTable(&Webhook{}))
	require.Error(t, svc.LoadTokenHashes(ctx))
	require.True(t, svc.IsKnownToken(raw))
	_, failed, err := svc.CreateWebhook(ctx, "failed", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.Error(t, err)
	require.Empty(t, failed)
	require.Len(t, svc.tokenHashes, 1)
}

func TestKnownTokenIndex_ConcurrentReloadAndCRUD(t *testing.T) {
	ctx := t.Context()
	svc := newTestWebhookService(setupWebhookServiceTestDB(t))
	var workers sync.WaitGroup
	workers.Go(func() {
		for range 30 {
			if err := svc.LoadTokenHashes(ctx); err != nil {
				t.Errorf("reload token hashes: %v", err)
				return
			}
			svc.IsKnownToken("arc_wh_unknown")
		}
	})
	for range 30 {
		wh, raw, err := svc.CreateWebhook(ctx, "known", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
		require.NoError(t, err)
		require.True(t, svc.IsKnownToken(raw))
		require.NoError(t, svc.DeleteWebhook(ctx, wh.ID, "env-1", user.Actor{}))
		require.False(t, svc.IsKnownToken(raw))
	}
	workers.Wait()
}

func TestCreateWebhook_TokenNotStoredInPlaintext(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, rawToken, err := svc.CreateWebhook(ctx, "my-hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "project-id", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	require.NotEmpty(t, rawToken)

	stored := fetchWebhook(t, db, wh.ID)
	assert.NotEqual(t, rawToken, stored.TokenHash, "raw token must not be stored as-is")
	assert.Equal(t, kit.SHA256Hex(rawToken), stored.TokenHash, "stored hash must match SHA-256 of raw token")
}

func TestCreateWebhook_PrefixMatchesToken(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, rawToken, err := svc.CreateWebhook(ctx, "  cafe\u0301 hook  ", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	hexPart := strings.TrimPrefix(rawToken, webhookTokenPrefix)
	expectedPrefix := webhookTokenPrefix + hexPart[:webhookTokenPrefixLen]
	assert.Equal(t, expectedPrefix, wh.TokenPrefix)
	assert.Equal(t, "café hook", wh.Name)

	stored := fetchWebhook(t, db, wh.ID)
	assert.Equal(t, expectedPrefix, stored.TokenPrefix)
}

func TestCreateWebhook_InvalidTargetTypeRejected(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, _, err := svc.CreateWebhook(ctx, "bad", "invalid-type", WebhookActionTypeUpdate, "c1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	assert.ErrorIs(t, err, ErrWebhookInvalidType)
}

func TestCreateWebhook_EmptyTargetIDRejectedForNonUpdaterTypes(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	for _, targetType := range []string{
		WebhookTargetTypeContainer,
		WebhookTargetTypeProject,
		WebhookTargetTypeGitOps,
	} {
		_, _, err := svc.CreateWebhook(ctx, "hook", targetType, defaultTestWebhookActionType(targetType), "", "env-1", user.Actor{}, authz.SudoPermissionSet())
		assert.ErrorIs(t, err, ErrWebhookMissingTarget, "expected ErrWebhookMissingTarget for type %s with empty targetID", targetType)
	}
}

func TestCreateWebhook_InvalidActionTypeRejected(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, _, err := svc.CreateWebhook(ctx, "bad-action", WebhookTargetTypeContainer, WebhookActionTypeDown, "container-id", "env-1", user.Actor{}, authz.SudoPermissionSet())
	assert.ErrorIs(t, err, ErrWebhookInvalidAction)
}

func TestCreateWebhook_EmptyActionTypeDefaultsPerTarget(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	projectWebhook, _, err := svc.CreateWebhook(ctx, "project-hook", WebhookTargetTypeProject, "", "project-id", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Equal(t, WebhookActionTypeUpdate, projectWebhook.ActionType)

	updaterWebhook, _, err := svc.CreateWebhook(ctx, "updater-hook", WebhookTargetTypeUpdater, "", "", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Equal(t, WebhookActionTypeRun, updaterWebhook.ActionType)
}

func TestCreateWebhook_EmptyTargetIDAcceptedForUpdaterType(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "updater-hook", WebhookTargetTypeUpdater, WebhookActionTypeRun, "", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Empty(t, wh.TargetID)
}

func TestCreateWebhook_ContainerTypeAccepted(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "container-hook", WebhookTargetTypeContainer, WebhookActionTypeUpdate, "container-id", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Equal(t, WebhookTargetTypeContainer, wh.TargetType)
	assert.Equal(t, WebhookActionTypeUpdate, wh.ActionType)
}

func TestCreateWebhook_ProjectTypeAccepted(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "stack-hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "project-id", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Equal(t, WebhookTargetTypeProject, wh.TargetType)
	assert.Equal(t, WebhookActionTypeUpdate, wh.ActionType)
}

func TestCreateWebhook_UpdaterTypeAccepted(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "updater-hook", WebhookTargetTypeUpdater, WebhookActionTypeRun, "", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Equal(t, WebhookTargetTypeUpdater, wh.TargetType)
	assert.Equal(t, WebhookActionTypeRun, wh.ActionType)
}

func TestCreateWebhook_GitOpsTypeAccepted(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "gitops-hook", WebhookTargetTypeGitOps, WebhookActionTypeSync, "sync-id", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.Equal(t, WebhookTargetTypeGitOps, wh.TargetType)
	assert.Equal(t, WebhookActionTypeSync, wh.ActionType)
}

func TestCreateWebhook_EnabledByDefault(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "enabled", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.True(t, wh.Enabled)
}

func TestCreateWebhook_UniqueTokensEachCall(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, token1, err := svc.CreateWebhook(ctx, "h1", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	_, token2, err := svc.CreateWebhook(ctx, "h2", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p2", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	assert.NotEqual(t, token1, token2)
}

func TestListWebhooks_ScopedToEnvironment(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, _, err := svc.CreateWebhook(ctx, "env1-hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	_, _, err = svc.CreateWebhook(ctx, "env2-hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p2", "env-2", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	list, err := svc.ListWebhooks(ctx, "env-1")
	require.NoError(t, err)
	require.Len(t, list, 1)
	assert.Equal(t, "env1-hook", list[0].Name)
}

func TestListWebhooks_EmptyForUnknownEnvironment(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	list, err := svc.ListWebhooks(ctx, "no-such-env")
	require.NoError(t, err)
	assert.Empty(t, list)
}

func TestListWebhookSummaries_ResolvesTargetNames(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	require.NoError(t, db.WithContext(ctx).Exec(`CREATE TABLE projects (id TEXT PRIMARY KEY, name TEXT NOT NULL)`).Error)
	require.NoError(t, db.WithContext(ctx).Exec(`CREATE TABLE gitops_syncs (id TEXT PRIMARY KEY, environment_id TEXT NOT NULL, name TEXT NOT NULL)`).Error)
	require.NoError(t, db.WithContext(ctx).Exec(`INSERT INTO projects (id, name) VALUES (?, ?)`, "project-1", "Main Project").Error)
	require.NoError(t, db.WithContext(ctx).Exec(`INSERT INTO gitops_syncs (id, environment_id, name) VALUES (?, ?, ?)`, "sync-1", types.LocalDockerEnvironmentID, "Deploy Sync").Error)

	_, _, err := svc.CreateWebhook(ctx, "project-hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "project-1", types.LocalDockerEnvironmentID, user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	_, _, err = svc.CreateWebhook(ctx, "updater-hook", WebhookTargetTypeUpdater, WebhookActionTypeRun, "", types.LocalDockerEnvironmentID, user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	_, _, err = svc.CreateWebhook(ctx, "gitops-hook", WebhookTargetTypeGitOps, WebhookActionTypeSync, "sync-1", types.LocalDockerEnvironmentID, user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	summaries, err := svc.ListWebhookSummaries(ctx, types.LocalDockerEnvironmentID)
	require.NoError(t, err)
	require.Len(t, summaries, 3)

	targetNamesByType := make(map[string]string, len(summaries))
	for _, summary := range summaries {
		targetNamesByType[summary.TargetType] = summary.TargetName
		assert.Equal(t, defaultTestWebhookActionType(summary.TargetType), summary.ActionType)
	}

	assert.Equal(t, "Main Project", targetNamesByType[WebhookTargetTypeProject])
	assert.Equal(t, "Environment updater", targetNamesByType[WebhookTargetTypeUpdater])
	assert.Equal(t, "Deploy Sync", targetNamesByType[WebhookTargetTypeGitOps])
}

func TestListWebhookSummaries_DefaultsLegacyActionType(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	legacyWebhook := &Webhook{
		Name:          "legacy-hook",
		TokenHash:     "hash",
		TokenPrefix:   "arc_wh_deadbeef",
		TargetType:    WebhookTargetTypeProject,
		ActionType:    "",
		TargetID:      "project-1",
		EnvironmentID: types.LocalDockerEnvironmentID,
		Enabled:       true,
	}
	require.NoError(t, db.WithContext(ctx).Create(legacyWebhook).Error)

	summaries, err := svc.ListWebhookSummaries(ctx, types.LocalDockerEnvironmentID)
	require.NoError(t, err)
	require.Len(t, summaries, 1)
	assert.Equal(t, WebhookActionTypeUpdate, summaries[0].ActionType)
}

func TestGetWebhookByID_ReturnsCorrectWebhook(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	created, _, err := svc.CreateWebhook(ctx, "get-me", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	got, err := svc.GetWebhookByID(ctx, created.ID, "env-1")
	require.NoError(t, err)
	assert.Equal(t, created.ID, got.ID)
}

func TestGetWebhookByID_NotFoundForWrongEnvironment(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	created, _, err := svc.CreateWebhook(ctx, "env-scoped", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	_, err = svc.GetWebhookByID(ctx, created.ID, "env-2")
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestGetWebhookByID_NotFoundForUnknownID(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, err := svc.GetWebhookByID(ctx, "does-not-exist", "env-1")
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestDeleteWebhook_RemovesRecord(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	created, _, err := svc.CreateWebhook(ctx, "delete-me", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	require.NoError(t, svc.DeleteWebhook(ctx, created.ID, "env-1", user.Actor{}))

	_, err = svc.GetWebhookByID(ctx, created.ID, "env-1")
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestDeleteWebhook_NotFoundForWrongEnvironment(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	created, _, err := svc.CreateWebhook(ctx, "env-scoped-delete", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	err = svc.DeleteWebhook(ctx, created.ID, "env-2", user.Actor{})
	require.ErrorIs(t, err, ErrWebhookNotFound)

	// Webhook must still exist in the correct environment
	_, err = svc.GetWebhookByID(ctx, created.ID, "env-1")
	assert.NoError(t, err)
}

func TestDeleteWebhook_NotFoundForUnknownID(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	err := svc.DeleteWebhook(ctx, "does-not-exist", "env-1", user.Actor{})
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestUpdateWebhook_DisableAndEnable(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "proj-1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.True(t, wh.Enabled)

	updated, err := svc.UpdateWebhook(ctx, wh.ID, "env-1", false, user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.False(t, updated.Enabled)

	updated, err = svc.UpdateWebhook(ctx, wh.ID, "env-1", true, user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)
	assert.True(t, updated.Enabled)
}

func TestUpdateWebhook_NotFoundForWrongEnvironment(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	wh, _, err := svc.CreateWebhook(ctx, "hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "proj-1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	_, err = svc.UpdateWebhook(ctx, wh.ID, "env-other", false, user.Actor{}, authz.SudoPermissionSet())
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestCreateWebhook_RequiresTargetActionPermission(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	webhookOnly := authz.NewPermissionSet()
	webhookOnly.AddEnv("env-1", authz.PermWebhooksCreate, authz.PermWebhooksUpdate)
	_, _, err := svc.CreateWebhook(ctx, "down", WebhookTargetTypeProject, WebhookActionTypeDown, "p1", "env-1", user.Actor{}, webhookOnly)
	require.ErrorIs(t, err, ErrWebhookForbidden)

	otherEnv := authz.NewPermissionSet()
	otherEnv.AddEnv("env-2", authz.PermProjectsDown)
	_, _, err = svc.CreateWebhook(ctx, "down", WebhookTargetTypeProject, WebhookActionTypeDown, "p1", "env-1", user.Actor{}, otherEnv)
	require.ErrorIs(t, err, ErrWebhookForbidden)

	allowed := authz.NewPermissionSet()
	allowed.AddEnv("env-1", authz.PermProjectsDown)
	wh, _, err := svc.CreateWebhook(ctx, "down", WebhookTargetTypeProject, WebhookActionTypeDown, "p1", "env-1", user.Actor{}, allowed)
	require.NoError(t, err)

	_, err = svc.UpdateWebhook(ctx, wh.ID, "env-1", false, user.Actor{}, webhookOnly)
	require.ErrorIs(t, err, ErrWebhookForbidden)
	_, err = svc.UpdateWebhook(ctx, wh.ID, "env-1", false, user.Actor{}, allowed)
	require.NoError(t, err)
}

func TestUpdateWebhook_NotFoundForUnknownID(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, err := svc.UpdateWebhook(ctx, "does-not-exist", "env-1", false, user.Actor{}, authz.SudoPermissionSet())
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestTriggerByToken_InvalidFormat(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	err := svc.TriggerByToken(ctx, "not-a-webhook-token")
	assert.ErrorIs(t, err, ErrWebhookInvalid)
}

func TestTriggerByToken_NotFound(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	// Well-formatted token but not in the DB
	raw := "arc_wh_0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
	err := svc.TriggerByToken(ctx, raw)
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestTriggerByToken_WrongHash_NotFound(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	_, rawToken, err := svc.CreateWebhook(ctx, "hash-check", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	// Flip the last character of the token
	tampered := rawToken[:len(rawToken)-1]
	if rawToken[len(rawToken)-1] == 'a' {
		tampered += "b"
	} else {
		tampered += "a"
	}

	err = svc.TriggerByToken(ctx, tampered)
	assert.ErrorIs(t, err, ErrWebhookNotFound)
}

func TestTriggerByToken_DisabledWebhook(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	created, rawToken, err := svc.CreateWebhook(ctx, "disabled-hook", WebhookTargetTypeProject, WebhookActionTypeUpdate, "p1", "env-1", user.Actor{}, authz.SudoPermissionSet())
	require.NoError(t, err)

	require.NoError(t, db.WithContext(ctx).Model(&Webhook{}).Where("id = ?", created.ID).Update("enabled", false).Error)

	err = svc.TriggerByToken(ctx, rawToken)
	assert.ErrorIs(t, err, ErrWebhookDisabled)
}

func TestTriggerByToken_UnknownTargetType_ReturnsInvalidType(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	rawToken := "arc_wh_aabbccdd0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c"
	hash := kit.SHA256Hex(rawToken)
	hexPart := strings.TrimPrefix(rawToken, webhookTokenPrefix)
	prefix := webhookTokenPrefix + hexPart[:webhookTokenPrefixLen]

	wh := &Webhook{
		Name:          "bad-type",
		TokenHash:     hash,
		TokenPrefix:   prefix,
		TargetType:    "unknown-type",
		TargetID:      "some-id",
		EnvironmentID: "env-1",
		Enabled:       true,
	}
	require.NoError(t, db.WithContext(ctx).Create(wh).Error)

	err := svc.TriggerByToken(ctx, rawToken)
	assert.ErrorIs(t, err, ErrWebhookInvalidType)
}

// insertWebhookDirect inserts a webhook record directly, bypassing CreateWebhook validation,
// so dispatch tests can use known target types without needing real service dependencies.
func insertWebhookDirect(t *testing.T, ctx context.Context, db *database.DB, rawToken, targetType, actionType, targetID, envID string) *Webhook {
	t.Helper()
	hash := kit.SHA256Hex(rawToken)
	hexPart := strings.TrimPrefix(rawToken, webhookTokenPrefix)
	wh := &Webhook{
		Name:          "test-hook",
		TokenHash:     hash,
		TokenPrefix:   webhookTokenPrefix + hexPart[:webhookTokenPrefixLen],
		TargetType:    targetType,
		ActionType:    actionType,
		TargetID:      targetID,
		EnvironmentID: envID,
		Enabled:       true,
	}
	require.NoError(t, db.WithContext(ctx).Create(wh).Error)
	return wh
}

func TestTriggerByToken_AcceptsImmediatelyAndRecordsTriggerTime(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db) // action services are nil; the async action fails, acceptance must not

	rawToken := "arc_wh_ccddeeff01020304aabbccdd0102030405060708090a0b0c0d0e0f1011121314"
	wh := insertWebhookDirect(t, ctx, db, rawToken, WebhookTargetTypeContainer, WebhookActionTypeUpdate, "container-id", types.LocalDockerEnvironmentID)

	// Valid token is accepted synchronously; the action itself runs (and here
	// fails against nil services) in the background without surfacing.
	require.NoError(t, svc.TriggerByToken(ctx, rawToken))

	stored := fetchWebhook(t, db, wh.ID)
	assert.NotNil(t, stored.LastTriggeredAt, "last_triggered_at must be set once the trigger is accepted")
}

func TestTriggerByToken_DoesNotUpdateLastTriggeredAtOnError(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	rawToken := "arc_wh_1122334401020304aabbccdd0102030405060708090a0b0c0d0e0f1011121315"
	wh := insertWebhookDirect(t, ctx, db, rawToken, "unknown-type", WebhookActionTypeUpdate, "some-id", "env-1")

	err := svc.TriggerByToken(ctx, rawToken)
	require.Error(t, err)

	stored := fetchWebhook(t, db, wh.ID)
	assert.Nil(t, stored.LastTriggeredAt, "last_triggered_at must not be set when trigger fails")
}

func TestTriggerByToken_UnknownActionType_ReturnsInvalidAction(t *testing.T) {
	ctx := t.Context()
	db := setupWebhookServiceTestDB(t)
	svc := newTestWebhookService(db)

	rawToken := "arc_wh_0011223344556677aabbccdd0102030405060708090a0b0c0d0e0f1011121314"
	insertWebhookDirect(t, ctx, db, rawToken, WebhookTargetTypeProject, "bogus", "project-id", "env-1")

	err := svc.TriggerByToken(ctx, rawToken)
	assert.ErrorIs(t, err, ErrWebhookInvalidAction)
}

func TestRemoteWebhookRequestInternal(t *testing.T) {
	tests := []struct {
		name       string
		wh         Webhook
		actionType string
		wantMethod string
		wantPath   string
		wantResult bool
		wantErr    error
	}{
		{
			name:       "container update prefers target ref",
			wh:         Webhook{TargetType: WebhookTargetTypeContainer, TargetID: "abc123", TargetRef: "my-app"},
			actionType: WebhookActionTypeUpdate,
			wantMethod: "POST",
			wantPath:   "/api/environments/0/containers/my-app/update",
			wantResult: true,
		},
		{
			name:       "container start falls back to target id",
			wh:         Webhook{TargetType: WebhookTargetTypeContainer, TargetID: "abc123"},
			actionType: WebhookActionTypeStart,
			wantMethod: "POST",
			wantPath:   "/api/environments/0/containers/abc123/start",
		},
		{
			name:       "project update maps to update-services",
			wh:         Webhook{TargetType: WebhookTargetTypeProject, TargetID: "p1"},
			actionType: WebhookActionTypeUpdate,
			wantMethod: "POST",
			wantPath:   "/api/environments/0/projects/p1/update-services",
		},
		{
			name:       "gitops sync",
			wh:         Webhook{TargetType: WebhookTargetTypeGitOps, TargetID: "sync-1"},
			actionType: WebhookActionTypeSync,
			wantMethod: "POST",
			wantPath:   "/api/environments/0/gitops-syncs/sync-1/sync",
		},
		{
			name:       "updater run carries result",
			wh:         Webhook{TargetType: WebhookTargetTypeUpdater},
			actionType: WebhookActionTypeRun,
			wantMethod: "POST",
			wantPath:   "/api/environments/0/updater/run?automatic=true",
			wantResult: true,
		},
		{
			name:       "invalid action rejected",
			wh:         Webhook{TargetType: WebhookTargetTypeContainer, TargetID: "abc"},
			actionType: WebhookActionTypeSync,
			wantErr:    ErrWebhookInvalidAction,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			method, path, wantResult, err := remoteWebhookRequestInternal(&tt.wh, tt.actionType)
			if tt.wantErr != nil {
				assert.ErrorIs(t, err, tt.wantErr)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, tt.wantMethod, method)
			assert.Equal(t, tt.wantPath, path)
			assert.Equal(t, tt.wantResult, wantResult)
		})
	}
}