feat: support multiple concurrent Sentry instances (#1469)

This commit is contained in:
Clément Fiere
2026-07-11 00:32:18 +02:00
committed by GitHub
parent 05b550e122
commit fe392e60f5
56 changed files with 7006 additions and 2143 deletions
@@ -26,3 +26,4 @@ This file covers both halves of the playbook (backend + frontend) so the pattern
- **Issue model:** Jira uses transitions + JQL; Linear uses state IDs + structured filters. Don't merge these schemas — the upstream APIs are genuinely different.
- **Watch filter persistence:** Jira stores the JQL string verbatim; Linear stores the structured `SearchFilter` as JSON in `filter_json` (Linear has no JQL equivalent). The orchestrator emits `NewJiraIssueEvent` / `NewLinearIssueEvent` respectively and dedups by issue key (Jira) vs identifier (Linear).
- **Health column extras:** Linear's `linear_configs` row carries an `org_slug` captured from successful probes; Jira's row does not.
- **Sentry — multiple instances per workspace:** unlike the one-config-per-workspace integrations, `sentry_configs` is keyed by an instance `id` (UUID) with a `workspace_id` column + `UNIQUE(workspace_id, name)`, so a workspace holds several named instances. Secrets are keyed `sentry:instance:<id>:token`. Issue watches carry a nullable `sentry_instance_id` FK (`ON DELETE RESTRICT`); the bound instance is immutable. The HTTP surface is instance CRUD under `/api/v1/sentry/instances?workspace_id=` (no install-wide `/config`); deleting an in-use instance is 409 `SENTRY_INSTANCE_IN_USE`. See ADR-0030.
@@ -106,6 +106,7 @@ func (s *SentryWatcherSource) BuildTaskRequest(evt any) (*IssueTaskRequest, erro
Description: interpolateSentryPrompt(e.Prompt, e.Issue),
Metadata: map[string]interface{}{
sentryWatchMetadataKey: e.IssueWatchID,
"sentry_issue_instance_id": e.SentryInstanceID,
"sentry_issue_short_id": e.Issue.ShortID,
"sentry_issue_url": e.Issue.Permalink,
"sentry_issue_level": e.Issue.Level,
+161 -50
View File
@@ -4,69 +4,180 @@ import (
"context"
"errors"
"fmt"
"time"
"go.uber.org/zap"
)
// ErrSameWorkspace is returned when a copy targets the same workspace it reads
// from.
var ErrSameWorkspace = errors.New("sentry: source and target workspaces are the same")
// ErrNothingToCopy is returned when the source workspace has no Sentry config.
var ErrNothingToCopy = errors.New("sentry: source workspace has no configuration to copy")
// ErrNothingToCopy is returned when the source workspace has no Sentry
// instances.
var ErrNothingToCopy = errors.New("sentry: source workspace has no Sentry instances to copy")
// CopyConfigToWorkspace copies the Sentry provider config and credential (auth
// token) from sourceWorkspaceID to targetWorkspaceID. Watchers are
// intentionally out of scope — only the connection settings and secret are
// duplicated.
func (s *Service) CopyConfigToWorkspace(ctx context.Context, sourceWorkspaceID, targetWorkspaceID string) (*SentryConfig, error) {
sourceWorkspaceID, err := s.normalizeWorkspaceID(sourceWorkspaceID)
type copyInput struct {
config *SentryConfig
secret string
hasSecret bool
}
// CopyConfigToWorkspace copies every Sentry instance from sourceWorkspaceID
// into targetWorkspaceID: fresh instance IDs, secrets duplicated under the new
// per-instance keys, and names deduped against the target's existing instances.
// Issue watches are intentionally out of scope — only the connection settings
// and secrets are duplicated. Returns the newly created instances.
func (s *Service) CopyConfigToWorkspace(ctx context.Context, sourceWorkspaceID, targetWorkspaceID string) ([]*SentryConfig, error) {
if err := validateCopyWorkspaces(sourceWorkspaceID, targetWorkspaceID); err != nil {
return nil, err
}
prepared, used, err := s.prepareCopyInputs(ctx, sourceWorkspaceID, targetWorkspaceID)
if err != nil {
return nil, err
}
targetWorkspaceID, err = s.normalizeWorkspaceID(targetWorkspaceID)
copied, err := s.createCopiedInstances(ctx, targetWorkspaceID, prepared, used)
if err != nil {
return nil, err
}
s.finalizeCopiedInstances(copied)
return copied, nil
}
// validateCopyWorkspaces rejects empty or identical source/target workspace
// IDs before any store access.
func validateCopyWorkspaces(sourceWorkspaceID, targetWorkspaceID string) error {
if sourceWorkspaceID == "" || targetWorkspaceID == "" {
return fmt.Errorf("%w: source and target workspace IDs are required", ErrInvalidConfig)
}
if sourceWorkspaceID == targetWorkspaceID {
return nil, ErrSameWorkspace
return ErrSameWorkspace
}
cfg, err := s.store.GetConfigForWorkspace(ctx, sourceWorkspaceID)
if err != nil {
return nil, fmt.Errorf("read source sentry config: %w", err)
}
if cfg == nil {
return nil, ErrNothingToCopy
}
secret, err := s.revealSecret(ctx, sourceWorkspaceID)
if err != nil {
return nil, fmt.Errorf("read source sentry secret: %w", err)
}
// An empty Secret means "keep existing" in SetConfigForWorkspace, so copying
// from a workspace without a stored token would leave the target on its old
// credential paired with the copied settings. Treat that as nothing to copy.
if secret == "" {
return nil, ErrNothingToCopy
}
req := &SetConfigRequest{
AuthMethod: cfg.AuthMethod,
URL: cfg.URL,
Secret: secret,
}
// Mark the target unhealthy before the write so the UI doesn't briefly flash
// a stale "connected" state from the target's previous credential while the
// async probe kicked off by SetConfigForWorkspace validates the copied one.
if err := s.store.UpdateAuthHealthForWorkspace(ctx, targetWorkspaceID, false, "", time.Now().UTC()); err != nil {
return nil, fmt.Errorf("reset target sentry health: %w", err)
}
cfgOut, err := s.SetConfigForWorkspace(ctx, targetWorkspaceID, req)
if err != nil {
// The write failed, so the target's config is unchanged but we already
// flipped its health row. Re-probe asynchronously (best effort) so the row
// reflects the target's real state again rather than a spurious
// "unhealthy", without delaying the error response by the probe timeout.
// Detach from the request context, which may already be cancelled.
go s.RecordAuthHealthForWorkspace(context.Background(), targetWorkspaceID)
return nil, err
}
return cfgOut, nil
return nil
}
// prepareCopyInputs reads every source instance and, for each, reveals its
// secret before any target-workspace mutation, plus the target's existing
// instance names to dedupe against. Aborting here means no partial target
// state to roll back.
func (s *Service) prepareCopyInputs(ctx context.Context, sourceWorkspaceID, targetWorkspaceID string) ([]copyInput, map[string]struct{}, error) {
sources, err := s.store.ListInstances(ctx, sourceWorkspaceID)
if err != nil {
return nil, nil, fmt.Errorf("read source sentry instances: %w", err)
}
if len(sources) == 0 {
return nil, nil, ErrNothingToCopy
}
existing, err := s.store.ListInstances(ctx, targetWorkspaceID)
if err != nil {
return nil, nil, fmt.Errorf("read target sentry instances: %w", err)
}
used := make(map[string]struct{}, len(existing))
for _, inst := range existing {
used[inst.Name] = struct{}{}
}
prepared := make([]copyInput, 0, len(sources))
for _, src := range sources {
input := copyInput{config: src}
if s.secrets != nil {
secret, ok, err := s.revealInstanceSecret(ctx, src.ID)
if err != nil {
return nil, nil, fmt.Errorf("read source sentry secret: %w", err)
}
input.secret = secret
input.hasSecret = ok
}
prepared = append(prepared, input)
}
return prepared, used, nil
}
// createCopiedInstances copies every prepared input into the target
// workspace, rolling back all instances created by this request if any copy
// fails.
func (s *Service) createCopiedInstances(ctx context.Context, targetWorkspaceID string, prepared []copyInput, used map[string]struct{}) ([]*SentryConfig, error) {
copied := make([]*SentryConfig, 0, len(prepared))
for _, input := range prepared {
out, err := s.copyInstance(ctx, targetWorkspaceID, input, used)
if out != nil {
copied = append(copied, out)
}
if err != nil {
return nil, s.rollbackCopiedInstances(ctx, copied, err)
}
}
return copied, nil
}
// finalizeCopiedInstances invalidates the cached clients for the freshly copied
// instances. It deliberately fires no per-instance auth-health probe here: a
// workspace may hold arbitrarily many instances, so probing each copy inline
// would burst an unbounded number of goroutines and outbound Sentry calls.
// The copied instances instead get their first health check from the bounded
// background auth-health poller (RecordAuthHealth, concurrency-capped) on its
// next cycle.
func (s *Service) finalizeCopiedInstances(copied []*SentryConfig) {
for _, cfg := range copied {
s.invalidateClient(cfg.ID)
}
}
// copyInstance duplicates a prepared source instance into the target workspace
// with a name deduped against used (which it updates) and a rekeyed secret.
// Health probing is left to the bounded background poller (see
// finalizeCopiedInstances).
func (s *Service) copyInstance(ctx context.Context, targetWorkspaceID string, input copyInput, used map[string]struct{}) (*SentryConfig, error) {
cfg := &SentryConfig{
WorkspaceID: targetWorkspaceID,
Name: uniqueInstanceName(used, input.config.Name),
AuthMethod: input.config.AuthMethod,
URL: input.config.URL,
}
if err := s.store.CreateInstance(ctx, cfg); err != nil {
return nil, fmt.Errorf("create copied sentry instance: %w", err)
}
if input.hasSecret && s.secrets != nil {
if err := s.secrets.Set(ctx, secretKeyForInstance(cfg.ID), "Sentry auth token", input.secret); err != nil {
return cfg, fmt.Errorf("store copied sentry secret: %w", err)
}
cfg.HasSecret = true
}
return cfg, nil
}
// rollbackCopiedInstances removes only instances created by the current copy
// request. It continues after cleanup errors so every created row is
// attempted, and only deletes a copied secret once its row delete actually
// succeeded — if DeleteInstance fails (e.g. the instance became referenced by
// a watch created concurrently, returning ErrInstanceInUse), that instance's
// row and secret are left fully intact rather than orphaning a live row.
func (s *Service) rollbackCopiedInstances(ctx context.Context, copied []*SentryConfig, cause error) error {
cleanupCtx := context.WithoutCancel(ctx)
var rollbackErrs []error
for i := len(copied) - 1; i >= 0; i-- {
cfg := copied[i]
if cfg == nil || cfg.ID == "" {
continue
}
if err := s.store.DeleteInstance(cleanupCtx, cfg.ID); err != nil {
rollbackErrs = append(rollbackErrs, fmt.Errorf("rollback copied sentry instance %q: %w", cfg.ID, err))
continue
}
if s.secrets != nil {
key := secretKeyForInstance(cfg.ID)
exists, err := s.secrets.Exists(cleanupCtx, key)
if err != nil {
rollbackErrs = append(rollbackErrs, fmt.Errorf("check copied sentry secret %q during rollback: %w", cfg.ID, err))
} else if exists {
if err := s.secrets.Delete(cleanupCtx, key); err != nil {
rollbackErrs = append(rollbackErrs, fmt.Errorf("rollback copied sentry secret %q: %w", cfg.ID, err))
}
}
}
}
if len(rollbackErrs) == 0 {
return cause
}
cleanupErr := errors.Join(rollbackErrs...)
s.log.Warn("sentry: copy rollback cleanup failed", zap.Error(cleanupErr))
return errors.Join(cause, cleanupErr)
}
+295 -32
View File
@@ -4,59 +4,322 @@ import (
"context"
"errors"
"testing"
"time"
"go.uber.org/zap"
"go.uber.org/zap/zaptest/observer"
"github.com/kandev/kandev/internal/common/logger"
)
// drainProbe waits for the async auth-health probe fired by a config write.
func drainProbe(t *testing.T, f *svcFixture) {
t.Helper()
select {
case <-f.probed:
case <-time.After(2 * time.Second):
t.Fatalf("async probe hook did not fire within 2s")
}
}
func TestCopyConfigToWorkspace_CopiesConfigAndSecret(t *testing.T) {
func TestCopyConfig_CopiesInstancesAndSecrets(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
a := f.seedInstance(t, src, "SaaS", "sec-a")
f.seedInstance(t, src, "Self", "sec-b")
if _, err := f.svc.SetConfigForWorkspace(ctx, src, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken,
URL: "https://sentry.example.com",
Secret: "sen-src",
}); err != nil {
t.Fatalf("seed source: %v", err)
}
drainProbe(t, f)
got, err := f.svc.CopyConfigToWorkspace(ctx, src, dst)
copied, err := f.svc.CopyConfigToWorkspace(ctx, src, dst)
if err != nil {
t.Fatalf("copy: %v", err)
}
drainProbe(t, f)
if got.URL != "https://sentry.example.com" || got.AuthMethod != AuthMethodAuthToken {
t.Errorf("copied config mismatch: %+v", got)
if len(copied) != 2 {
t.Fatalf("expected 2 copied instances, got %d", len(copied))
}
v, err := f.secrets.Reveal(ctx, SecretKeyForWorkspace(dst))
if err != nil {
t.Fatalf("reveal copied secret: %v", err)
names := map[string]bool{}
for _, c := range copied {
if c.WorkspaceID != dst {
t.Errorf("copied instance in wrong workspace: %+v", c)
}
if c.ID == a.ID {
t.Errorf("copied instance reused source ID %q", c.ID)
}
names[c.Name] = true
v, err := f.secrets.Reveal(ctx, secretKeyForInstance(c.ID))
if err != nil || v == "" {
t.Errorf("secret not copied for %q: %v / %q", c.Name, err, v)
}
}
if v != "sen-src" {
t.Errorf("secret not copied: %q", v)
if !names["SaaS"] || !names["Self"] {
t.Errorf("expected names preserved, got %v", names)
}
}
func TestCopyConfigToWorkspace_SameWorkspace(t *testing.T) {
func TestCopyConfig_SecretSetFailureRollsBackAllCreatedInstances(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
f.seedInstance(t, src, "First", "sec-first")
f.seedInstance(t, src, "Second", "sec-second")
existing := f.seedInstance(t, dst, "Existing", "sec-existing")
watch := newTestIssueWatch(dst)
watch.SentryInstanceID = existing.ID
if err := f.store.CreateIssueWatch(ctx, watch); err != nil {
t.Fatalf("seed target watch: %v", err)
}
injected := errors.New("secret store unavailable")
missingDelete := errors.New("secret not found during rollback")
f.secrets.setErr = injected
f.secrets.setErrAfter = 1 // Let the first copied secret succeed; fail the second.
f.secrets.deleteMissingErr = missingDelete
_, err := f.svc.CopyConfigToWorkspace(ctx, src, dst)
if !errors.Is(err, injected) {
t.Fatalf("expected injected secret error, got %v", err)
}
if errors.Is(err, missingDelete) {
t.Fatalf("rollback attempted to delete an unstored copied secret: %v", err)
}
target, err := f.svc.ListInstances(ctx, dst)
if err != nil {
t.Fatalf("list target after failed copy: %v", err)
}
if len(target) != 1 || target[0].ID != existing.ID {
t.Fatalf("failed copy changed target instances: %+v", target)
}
if secret, err := f.secrets.Reveal(ctx, secretKeyForInstance(existing.ID)); err != nil || secret != "sec-existing" {
t.Errorf("failed copy changed target secret: secret=%q err=%v", secret, err)
}
if watches, err := f.store.CountWatchesForInstance(ctx, existing.ID); err != nil || watches != 1 {
t.Errorf("failed copy changed target watch count: count=%d err=%v", watches, err)
}
if got := f.secrets.count(); got != 3 {
t.Errorf("failed copy left copied secrets: count=%d, want 3", got)
}
}
func TestCopyConfig_PartialSecretSetFailureRollsBackAllCopiedSecrets(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
f.seedInstance(t, src, "First", "sec-first")
f.seedInstance(t, src, "Second", "sec-second")
existing := f.seedInstance(t, dst, "Existing", "sec-existing")
injected := errors.New("secret store partially wrote then failed")
f.secrets.setErr = injected
f.secrets.setErrAfter = 1 // Let the first copied secret succeed; partially write the second.
f.secrets.setErrAfterWrite = true
if _, err := f.svc.CopyConfigToWorkspace(ctx, src, dst); !errors.Is(err, injected) {
t.Fatalf("expected injected secret error, got %v", err)
}
target, err := f.svc.ListInstances(ctx, dst)
if err != nil {
t.Fatalf("list target after partial secret failure: %v", err)
}
if len(target) != 1 || target[0].ID != existing.ID {
t.Fatalf("partial secret failure changed target instances: %+v", target)
}
if got := f.secrets.count(); got != 3 {
t.Errorf("partial secret failure left copied secrets: count=%d, want 3", got)
}
}
// TestCopyConfig_RollbackKeepsInUseInstanceIntact pins the fix: rollback must
// only delete a copied instance's secret when that instance's row delete
// actually succeeded. Here the first copied instance becomes referenced by a
// watch created concurrently (mid-copy), so its DeleteInstance call fails
// with ErrInstanceInUse during rollback; its row and secret must survive
// untouched while the still-cleanly-deletable second instance is fully
// removed.
func TestCopyConfig_RollbackKeepsInUseInstanceIntact(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
f.seedInstance(t, src, "First", "sec-first")
f.seedInstance(t, src, "Second", "sec-second")
injected := errors.New("secret store unavailable")
f.secrets.setErr = injected
f.secrets.setErrAfter = 1 // Let the first copied secret succeed; fail the second.
var (
watchAttached bool
firstCopiedID string
)
f.secrets.setHook = func() {
if watchAttached {
return
}
watchAttached = true
targets, err := f.store.ListInstances(ctx, dst)
if err != nil || len(targets) != 1 {
t.Fatalf("expected exactly 1 copied instance before concurrent watch injection, got %d err=%v", len(targets), err)
}
firstCopiedID = targets[0].ID
watch := newTestIssueWatch(dst)
watch.SentryInstanceID = firstCopiedID
if err := f.store.CreateIssueWatch(ctx, watch); err != nil {
t.Fatalf("attach concurrent watch to first copied instance: %v", err)
}
}
_, err := f.svc.CopyConfigToWorkspace(ctx, src, dst)
if !errors.Is(err, injected) {
t.Fatalf("expected injected secret error, got %v", err)
}
var inUse ErrInstanceInUse
if !errors.As(err, &inUse) {
t.Fatalf("expected joined ErrInstanceInUse from rollback row-delete failure, got %v", err)
}
target, err := f.svc.ListInstances(ctx, dst)
if err != nil {
t.Fatalf("list target after failed copy: %v", err)
}
if len(target) != 1 || target[0].ID != firstCopiedID {
t.Fatalf("expected only the in-use first copied instance to survive rollback, got %+v", target)
}
if secret, err := f.secrets.Reveal(ctx, secretKeyForInstance(firstCopiedID)); err != nil || secret != "sec-first" {
t.Errorf("expected first copied instance's secret intact after row-delete failure, got secret=%q err=%v", secret, err)
}
if got := f.secrets.count(); got != 3 {
t.Errorf("expected 3 secrets to survive rollback (2 source + first copied instance's), got %d", got)
}
}
// TestRollbackCopiedInstances_KeepsRowAndSecretIntactAfterRowDeleteFailure pins
// the fix: when a copied instance's row delete fails (e.g. it became
// referenced by a watch created concurrently, tripping ErrInstanceInUse),
// rollback must leave that instance's row AND secret fully intact rather than
// deleting the secret out from under a still-live row.
func TestRollbackCopiedInstances_KeepsRowAndSecretIntactAfterRowDeleteFailure(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created := f.seedInstance(t, "ws-dst", "Copied", "sec-copied")
watch := newTestIssueWatch("ws-dst")
watch.SentryInstanceID = created.ID
if err := f.store.CreateIssueWatch(ctx, watch); err != nil {
t.Fatalf("seed watch: %v", err)
}
core, observed := observer.New(zap.WarnLevel)
testLogger, err := logger.NewFromZap(zap.New(core))
if err != nil {
t.Fatalf("create test logger: %v", err)
}
f.svc.log = testLogger
cause := errors.New("copy failed")
err = f.svc.rollbackCopiedInstances(ctx, []*SentryConfig{created}, cause)
if !errors.Is(err, cause) {
t.Fatalf("expected original copy error, got %v", err)
}
var inUse ErrInstanceInUse
if !errors.As(err, &inUse) {
t.Fatalf("expected joined row cleanup error, got %v", err)
}
if _, err := f.store.GetInstance(ctx, created.ID); err != nil {
t.Errorf("row deleted despite failed row cleanup: %v", err)
}
if secret, err := f.secrets.Reveal(ctx, secretKeyForInstance(created.ID)); err != nil || secret != "sec-copied" {
t.Errorf("secret not intact after row cleanup failure: secret=%q err=%v", secret, err)
}
entries := observed.All()
if len(entries) != 1 || entries[0].Message != "sentry: copy rollback cleanup failed" {
t.Fatalf("expected one rollback cleanup warning, got %+v", entries)
}
}
func TestCopyConfig_SourceSecretReadFailureRollsBackAllCreatedInstances(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
f.seedInstance(t, src, "First", "sec-first")
second := f.seedInstance(t, src, "Second", "sec-second")
existing := f.seedInstance(t, dst, "Existing", "sec-existing")
injected := errors.New("source secret unavailable")
f.secrets.revealErr = injected
f.secrets.revealErrForID = secretKeyForInstance(second.ID)
if _, err := f.svc.CopyConfigToWorkspace(ctx, src, dst); !errors.Is(err, injected) {
t.Fatalf("expected injected source secret error, got %v", err)
}
target, err := f.svc.ListInstances(ctx, dst)
if err != nil {
t.Fatalf("list target after failed copy: %v", err)
}
if len(target) != 1 || target[0].ID != existing.ID {
t.Fatalf("failed copy changed target instances: %+v", target)
}
if got := f.secrets.count(); got != 3 {
t.Errorf("failed copy left copied secrets: count=%d, want 3", got)
}
}
func TestCopyConfig_SourceSecretReadFailurePrecedesTargetMutations(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
f.seedInstance(t, src, "First", "sec-first")
second := f.seedInstance(t, src, "Second", "sec-second")
existing := f.seedInstance(t, dst, "Existing", "sec-existing")
sourceReadErr := errors.New("source secret unavailable")
targetSetErr := errors.New("target secret should not be stored")
f.secrets.revealErr = sourceReadErr
f.secrets.revealErrForID = secretKeyForInstance(second.ID)
f.secrets.setErr = targetSetErr
_, err := f.svc.CopyConfigToWorkspace(ctx, src, dst)
if !errors.Is(err, sourceReadErr) {
t.Fatalf("expected source read error before target mutation, got %v", err)
}
if errors.Is(err, targetSetErr) {
t.Fatalf("copy attempted target secret storage before reading all sources: %v", err)
}
target, err := f.svc.ListInstances(ctx, dst)
if err != nil {
t.Fatalf("list target after failed source preflight: %v", err)
}
if len(target) != 1 || target[0].ID != existing.ID {
t.Fatalf("source preflight changed target instances: %+v", target)
}
}
// TestCopyConfig_DedupNamesWithInUseTarget pins acceptance (i): copying into a
// target that already holds an instance (referenced by a watch) appends a
// name-deduped copy and leaves the target's existing instance + watch intact.
func TestCopyConfig_DedupNamesWithInUseTarget(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
const src, dst = "ws-src", "ws-dst"
f.seedInstance(t, src, "SaaS", "sec-src")
targetExisting := f.seedInstance(t, dst, "SaaS", "sec-dst")
// Target instance is in use by a watch.
w := newTestIssueWatch(dst)
w.SentryInstanceID = targetExisting.ID
if err := f.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("seed target watch: %v", err)
}
copied, err := f.svc.CopyConfigToWorkspace(ctx, src, dst)
if err != nil {
t.Fatalf("copy: %v", err)
}
if len(copied) != 1 || copied[0].Name != "SaaS (2)" {
t.Fatalf("expected one deduped copy 'SaaS (2)', got %+v", copied)
}
// Target now has both instances; the original + its watch survive.
all, _ := f.svc.ListInstances(ctx, dst)
if len(all) != 2 {
t.Fatalf("expected 2 instances in target, got %d", len(all))
}
if n, _ := f.store.CountWatchesForInstance(ctx, targetExisting.ID); n != 1 {
t.Errorf("expected target's existing watch untouched, got count %d", n)
}
}
func TestCopyConfig_SameWorkspace(t *testing.T) {
f := newSvcFixture(t)
if _, err := f.svc.CopyConfigToWorkspace(context.Background(), "ws-1", "ws-1"); !errors.Is(err, ErrSameWorkspace) {
t.Fatalf("expected ErrSameWorkspace, got %v", err)
}
}
func TestCopyConfigToWorkspace_NothingToCopy(t *testing.T) {
func TestCopyConfig_NothingToCopy(t *testing.T) {
f := newSvcFixture(t)
if _, err := f.svc.CopyConfigToWorkspace(context.Background(), "ws-empty", "ws-dst"); !errors.Is(err, ErrNothingToCopy) {
t.Fatalf("expected ErrNothingToCopy, got %v", err)
+215 -96
View File
@@ -13,8 +13,8 @@ import (
)
// RegisterRoutes wires the Sentry HTTP handlers. The dispatcher parameter is
// accepted for signature parity with other integrations; Phase 1 has no
// WebSocket surface, so it is intentionally unused.
// accepted for signature parity with other integrations; there is no WebSocket
// surface, so it is intentionally unused.
func RegisterRoutes(router *gin.Engine, _ *ws.Dispatcher, svc *Service, log *logger.Logger) {
ctrl := &Controller{service: svc, logger: log}
ctrl.RegisterHTTPRoutes(router)
@@ -26,13 +26,18 @@ type Controller struct {
logger *logger.Logger
}
// RegisterHTTPRoutes attaches the Sentry HTTP endpoints to router.
// RegisterHTTPRoutes attaches the Sentry HTTP endpoints to router. Every route
// is scoped to an authoritative `?workspace_id=` query param; instance routes
// additionally 404 when the instance does not belong to that workspace.
func (c *Controller) RegisterHTTPRoutes(router *gin.Engine) {
api := router.Group("/api/v1/sentry")
api.GET("/config", c.httpGetConfig)
api.PUT("/config", c.httpSetConfig)
api.DELETE("/config", c.httpDeleteConfig)
api.POST("/config/test", c.httpTestConfig)
api.GET("/instances", c.httpListInstances)
api.POST("/instances", c.httpCreateInstance)
api.GET("/instances/:id", c.httpGetInstance)
api.PUT("/instances/:id", c.httpUpdateInstance)
api.DELETE("/instances/:id", c.httpDeleteInstance)
api.POST("/instances/:id/test", c.httpTestInstance)
api.POST("/test-connection", c.httpTestConnection)
api.POST("/config/copy", c.httpCopyConfig)
api.GET("/organizations", c.httpListOrganizations)
api.GET("/projects", c.httpListProjects)
@@ -41,88 +46,176 @@ func (c *Controller) RegisterHTTPRoutes(router *gin.Engine) {
c.registerIssueWatchRoutes(api)
}
func (c *Controller) httpGetConfig(ctx *gin.Context) {
cfg, err := c.service.GetConfigForWorkspace(ctx.Request.Context(), c.workspaceID(ctx))
func (c *Controller) httpListInstances(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
instances, err := c.service.ListInstances(ctx.Request.Context(), workspaceID)
if err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
writeErr(ctx, http.StatusInternalServerError, err.Error())
return
}
if cfg == nil {
ctx.Status(http.StatusNoContent)
return
}
ctx.JSON(http.StatusOK, cfg)
ctx.JSON(http.StatusOK, gin.H{"instances": instances})
}
func (c *Controller) httpSetConfig(ctx *gin.Context) {
var req SetConfigRequest
func (c *Controller) httpCreateInstance(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
var req CreateConfigRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
cfg, err := c.service.SetConfigForWorkspace(ctx.Request.Context(), c.workspaceID(ctx), &req)
if strings.TrimSpace(req.WorkspaceID) != "" && req.WorkspaceID != workspaceID {
writeErr(ctx, http.StatusBadRequest, "workspaceId does not match workspace_id query")
return
}
cfg, err := c.service.CreateInstance(ctx.Request.Context(), workspaceID, &req)
if err != nil {
status := http.StatusInternalServerError
if errors.Is(err, ErrInvalidConfig) {
status = http.StatusBadRequest
}
ctx.JSON(status, gin.H{"error": err.Error()})
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, cfg)
}
func (c *Controller) httpDeleteConfig(ctx *gin.Context) {
if err := c.service.DeleteConfigForWorkspace(ctx.Request.Context(), c.workspaceID(ctx)); err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
func (c *Controller) httpGetInstance(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
cfg, err := c.service.GetInstance(ctx.Request.Context(), workspaceID, ctx.Param("id"))
if err != nil {
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, cfg)
}
func (c *Controller) httpUpdateInstance(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
var req UpdateConfigRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
writeBadPayload(ctx)
return
}
cfg, err := c.service.UpdateInstance(ctx.Request.Context(), workspaceID, ctx.Param("id"), &req)
if err != nil {
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, cfg)
}
func (c *Controller) httpDeleteInstance(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
if err := c.service.DeleteInstance(ctx.Request.Context(), workspaceID, ctx.Param("id")); err != nil {
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, gin.H{"deleted": true})
}
func (c *Controller) httpTestConfig(ctx *gin.Context) {
var req SetConfigRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
func (c *Controller) httpTestInstance(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
result, err := c.service.TestConnectionForWorkspace(ctx.Request.Context(), c.workspaceID(ctx), &req)
result, err := c.service.TestInstance(ctx.Request.Context(), workspaceID, ctx.Param("id"))
if err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, result)
}
func (c *Controller) httpListOrganizations(ctx *gin.Context) {
client, err := c.service.clientFor(ctx.Request.Context(), c.workspaceID(ctx))
if err != nil {
c.writeClientError(ctx, err)
func (c *Controller) httpTestConnection(ctx *gin.Context) {
if _, ok := c.requireWorkspace(ctx); !ok {
return
}
organizations, err := client.ListOrganizations(ctx.Request.Context())
var req CreateConfigRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
writeBadPayload(ctx)
return
}
result, err := c.service.TestConnectionCandidate(ctx.Request.Context(), &req)
if err != nil {
c.writeClientError(ctx, err)
writeErr(ctx, http.StatusInternalServerError, err.Error())
return
}
ctx.JSON(http.StatusOK, result)
}
func (c *Controller) httpCopyConfig(ctx *gin.Context) {
source, ok := c.requireWorkspace(ctx)
if !ok {
return
}
var req CopyConfigRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
writeBadPayload(ctx)
return
}
target := strings.TrimSpace(req.TargetWorkspaceID)
if target == "" {
writeErr(ctx, http.StatusBadRequest, "targetWorkspaceId is required")
return
}
copied, err := c.service.CopyConfigToWorkspace(ctx.Request.Context(), source, target)
if err != nil {
status := http.StatusInternalServerError
switch {
case errors.Is(err, ErrSameWorkspace), errors.Is(err, ErrNothingToCopy), errors.Is(err, ErrInvalidConfig):
status = http.StatusBadRequest
case errors.Is(err, ErrDuplicateInstanceName):
writeCoded(ctx, http.StatusConflict, err.Error(), errCodeSentryInstanceNameTaken)
return
}
writeErr(ctx, status, err.Error())
return
}
ctx.JSON(http.StatusOK, gin.H{"instances": copied})
}
func (c *Controller) httpListOrganizations(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
organizations, err := c.service.ListOrganizations(ctx.Request.Context(), workspaceID, c.instanceID(ctx))
if err != nil {
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, gin.H{"organizations": organizations})
}
func (c *Controller) httpListProjects(ctx *gin.Context) {
client, err := c.service.clientFor(ctx.Request.Context(), c.workspaceID(ctx))
if err != nil {
c.writeClientError(ctx, err)
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
projects, err := client.ListProjects(ctx.Request.Context())
projects, err := c.service.ListProjects(ctx.Request.Context(), workspaceID, c.instanceID(ctx))
if err != nil {
c.writeClientError(ctx, err)
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, gin.H{"projects": projects})
}
func (c *Controller) httpSearchIssues(ctx *gin.Context) {
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
q := ctx.Request.URL.Query()
filter := SearchFilter{
OrgSlug: q.Get("orgSlug"),
@@ -133,80 +226,106 @@ func (c *Controller) httpSearchIssues(ctx *gin.Context) {
Levels: trimAll(q["level"]),
Statuses: trimAll(q["status"]),
}
cursor := q.Get("cursor")
result, err := c.service.SearchIssuesForWorkspace(ctx.Request.Context(), c.workspaceID(ctx), filter, cursor)
result, err := c.service.SearchIssues(ctx.Request.Context(), workspaceID, c.instanceID(ctx), filter, q.Get("cursor"))
if err != nil {
c.writeClientError(ctx, err)
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, result)
}
func (c *Controller) httpGetIssue(ctx *gin.Context) {
id := ctx.Param("id")
client, err := c.service.clientFor(ctx.Request.Context(), c.workspaceID(ctx))
if err != nil {
c.writeClientError(ctx, err)
workspaceID, ok := c.requireWorkspace(ctx)
if !ok {
return
}
issue, err := client.GetIssue(ctx.Request.Context(), id)
issue, err := c.service.GetIssue(ctx.Request.Context(), workspaceID, c.instanceID(ctx), ctx.Param("id"))
if err != nil {
c.writeClientError(ctx, err)
c.writeInstanceError(ctx, err)
return
}
ctx.JSON(http.StatusOK, issue)
}
func (c *Controller) workspaceID(ctx *gin.Context) string {
return strings.TrimSpace(ctx.Query("workspace_id"))
// requireWorkspace reads the authoritative `?workspace_id=` query param,
// writing a 400 and returning false when it is absent.
func (c *Controller) requireWorkspace(ctx *gin.Context) (string, bool) {
workspaceID := strings.TrimSpace(ctx.Query("workspace_id"))
if workspaceID == "" {
writeErr(ctx, http.StatusBadRequest, "workspace_id query parameter required")
return "", false
}
return workspaceID, true
}
// copyConfigRequest is the payload for the copy-config endpoint. The source
// workspace comes from the workspace_id query param; the body carries the
// target.
type copyConfigRequest struct {
TargetWorkspaceID string `json:"targetWorkspaceId"`
func (c *Controller) instanceID(ctx *gin.Context) string {
return strings.TrimSpace(ctx.Query("instanceId"))
}
func (c *Controller) httpCopyConfig(ctx *gin.Context) {
sourceWorkspaceID := c.workspaceID(ctx)
if sourceWorkspaceID == "" {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "workspace_id query parameter required"})
return
}
var req copyConfigRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
return
}
targetWorkspaceID := strings.TrimSpace(req.TargetWorkspaceID)
if targetWorkspaceID == "" {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "targetWorkspaceId required"})
return
}
cfg, err := c.service.CopyConfigToWorkspace(ctx.Request.Context(), sourceWorkspaceID, targetWorkspaceID)
if err != nil {
status := http.StatusInternalServerError
switch {
case errors.Is(err, ErrSameWorkspace), errors.Is(err, ErrNothingToCopy), errors.Is(err, ErrInvalidConfig):
status = http.StatusBadRequest
}
ctx.JSON(status, gin.H{"error": err.Error()})
return
}
ctx.JSON(http.StatusOK, cfg)
// Wire-level error codes surfaced to the UI.
const (
errCodeSentryNotConfigured = "SENTRY_NOT_CONFIGURED"
errCodeSentryInstanceRequired = "SENTRY_INSTANCE_REQUIRED"
errCodeSentryInstanceNotFound = "SENTRY_INSTANCE_NOT_FOUND"
errCodeSentryInstanceInUse = "SENTRY_INSTANCE_IN_USE"
errCodeSentryInstanceNameTaken = "SENTRY_INSTANCE_NAME_TAKEN"
)
// Repeated gin.H keys / messages, centralized to satisfy goconst.
const (
jsonKeyError = "error"
jsonKeyCode = "code"
badPayloadMsg = "invalid payload"
)
// writeErr responds with a bare error message at the given status.
func writeErr(ctx *gin.Context, status int, msg string) {
ctx.JSON(status, gin.H{jsonKeyError: msg})
}
// errCodeSentryNotConfigured is the wire-level code surfaced to the UI when
// Sentry has no saved credentials.
const errCodeSentryNotConfigured = "SENTRY_NOT_CONFIGURED"
// writeBadPayload responds with a 400 for an unparseable JSON body.
func writeBadPayload(ctx *gin.Context) {
writeErr(ctx, http.StatusBadRequest, badPayloadMsg)
}
// writeCoded responds with an error message + wire code at the given status.
func writeCoded(ctx *gin.Context, status int, msg, code string) {
ctx.JSON(status, gin.H{jsonKeyError: msg, jsonKeyCode: code})
}
// writeInstanceError maps the instance-scoped service errors onto HTTP status
// codes + wire codes, falling back to writeClientError for connection/API
// errors (ErrNotConfigured, APIError, generic).
func (c *Controller) writeInstanceError(ctx *gin.Context, err error) {
switch {
case errors.Is(err, ErrInstanceRequired):
writeCoded(ctx, http.StatusBadRequest, err.Error(), errCodeSentryInstanceRequired)
return
case errors.Is(err, ErrInstanceNotFound):
writeCoded(ctx, http.StatusNotFound, err.Error(), errCodeSentryInstanceNotFound)
return
case errors.Is(err, ErrDuplicateInstanceName):
writeCoded(ctx, http.StatusConflict, err.Error(), errCodeSentryInstanceNameTaken)
return
case errors.Is(err, ErrInvalidConfig):
writeErr(ctx, http.StatusBadRequest, err.Error())
return
}
var inUse ErrInstanceInUse
if errors.As(err, &inUse) {
ctx.JSON(http.StatusConflict, gin.H{
jsonKeyError: inUse.Error(),
jsonKeyCode: errCodeSentryInstanceInUse,
"watchCount": inUse.WatchCount,
})
return
}
c.writeClientError(ctx, err)
}
func (c *Controller) writeClientError(ctx *gin.Context, err error) {
if errors.Is(err, ErrNotConfigured) {
ctx.JSON(http.StatusServiceUnavailable, gin.H{
"error": "Sentry is not configured",
"code": errCodeSentryNotConfigured,
})
writeCoded(ctx, http.StatusServiceUnavailable, "Sentry is not configured", errCodeSentryNotConfigured)
return
}
var apiErr *APIError
@@ -216,11 +335,11 @@ func (c *Controller) writeClientError(ctx *gin.Context, err error) {
case http.StatusNotFound, http.StatusUnauthorized, http.StatusForbidden, http.StatusBadRequest:
status = apiErr.StatusCode
}
ctx.JSON(status, gin.H{"error": apiErr.Error()})
writeErr(ctx, status, apiErr.Error())
return
}
c.logger.Warn("sentry handler error", zap.Error(err))
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
writeErr(ctx, http.StatusInternalServerError, err.Error())
}
func trimAll(xs []string) []string {
@@ -35,7 +35,7 @@ func (c *Controller) httpListIssueWatches(ctx *gin.Context) {
watches, err = c.service.ListIssueWatches(ctx.Request.Context(), workspaceID)
}
if err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
writeErr(ctx, http.StatusInternalServerError, err.Error())
return
}
ctx.JSON(http.StatusOK, gin.H{"watches": watches})
@@ -44,7 +44,11 @@ func (c *Controller) httpListIssueWatches(ctx *gin.Context) {
func (c *Controller) httpCreateIssueWatch(ctx *gin.Context) {
var req CreateIssueWatchRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
if !workspaceMatches(ctx, req.WorkspaceID) {
writeErr(ctx, http.StatusBadRequest, "workspace_id query must match body workspaceId")
return
}
w, err := c.service.CreateIssueWatch(ctx.Request.Context(), &req)
@@ -63,7 +67,7 @@ func (c *Controller) httpGetIssueWatch(ctx *gin.Context) {
return
}
if !workspaceMatches(ctx, w.WorkspaceID) {
ctx.JSON(http.StatusNotFound, gin.H{"error": ErrIssueWatchNotFound.Error()})
writeErr(ctx, http.StatusNotFound, ErrIssueWatchNotFound.Error())
return
}
ctx.JSON(http.StatusOK, w)
@@ -76,7 +80,7 @@ func (c *Controller) httpUpdateIssueWatch(ctx *gin.Context) {
}
var req UpdateIssueWatchRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
w, err := c.service.UpdateIssueWatch(ctx.Request.Context(), id, &req)
@@ -93,7 +97,7 @@ func (c *Controller) httpDeleteIssueWatch(ctx *gin.Context) {
return
}
if err := c.service.DeleteIssueWatch(ctx.Request.Context(), id); err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
writeErr(ctx, http.StatusInternalServerError, err.Error())
return
}
ctx.JSON(http.StatusOK, gin.H{"deleted": true})
@@ -111,16 +115,16 @@ func (c *Controller) httpTriggerIssueWatch(ctx *gin.Context) {
return
}
if !workspaceMatches(ctx, w.WorkspaceID) {
ctx.JSON(http.StatusNotFound, gin.H{"error": ErrIssueWatchNotFound.Error()})
writeErr(ctx, http.StatusNotFound, ErrIssueWatchNotFound.Error())
return
}
issues, err := c.service.CheckIssueWatch(ctx.Request.Context(), w)
instanceID, issues, err := c.service.CheckIssueWatch(ctx.Request.Context(), w)
if err != nil {
c.writeClientError(ctx, err)
c.writeIssueWatchError(ctx, err)
return
}
for _, issue := range issues {
c.service.publishNewSentryIssueEvent(ctx.Request.Context(), w, issue)
c.service.publishNewSentryIssueEvent(ctx.Request.Context(), w, instanceID, issue)
}
ctx.JSON(http.StatusOK, gin.H{"published": len(issues)})
}
@@ -168,7 +172,7 @@ func (c *Controller) assertWatchInWorkspace(ctx *gin.Context, id string) bool {
return false
}
if !workspaceMatches(ctx, w.WorkspaceID) {
ctx.JSON(http.StatusNotFound, gin.H{"error": ErrIssueWatchNotFound.Error()})
writeErr(ctx, http.StatusNotFound, ErrIssueWatchNotFound.Error())
return false
}
return true
@@ -184,11 +188,19 @@ func workspaceMatches(ctx *gin.Context, resourceWorkspace string) bool {
func (c *Controller) writeIssueWatchError(ctx *gin.Context, err error) {
if errors.Is(err, ErrIssueWatchNotFound) {
ctx.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
writeErr(ctx, http.StatusNotFound, err.Error())
return
}
if errors.Is(err, ErrInstanceNotFound) {
writeCoded(ctx, http.StatusNotFound, err.Error(), errCodeSentryInstanceNotFound)
return
}
if errors.Is(err, ErrInstanceRequired) {
writeCoded(ctx, http.StatusBadRequest, err.Error(), errCodeSentryInstanceRequired)
return
}
if errors.Is(err, ErrInvalidConfig) {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
writeErr(ctx, http.StatusBadRequest, err.Error())
return
}
c.writeClientError(ctx, err)
+350 -74
View File
@@ -8,6 +8,7 @@ import (
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/gin-gonic/gin"
@@ -30,63 +31,209 @@ func newTestController(t *testing.T) (*Controller, *gin.Engine, *fakeClient) {
return ctrl, router, client
}
// seedConfig persists a singleton config + secret without going through
// Service.SetConfig (which fires an async probe we'd have to drain).
func seedConfig(t *testing.T, ctrl *Controller) {
// seedInstance persists an instance (+ optional secret) directly via the store.
func seedInstance(t *testing.T, ctrl *Controller, workspaceID, name, secret string) *SentryConfig {
t.Helper()
ctx := context.Background()
if err := ctrl.service.store.UpsertConfig(ctx, &SentryConfig{
AuthMethod: AuthMethodAuthToken,
}); err != nil {
t.Fatalf("upsert: %v", err)
cfg := &SentryConfig{WorkspaceID: workspaceID, Name: name, AuthMethod: AuthMethodAuthToken, URL: DefaultSentryURL}
if err := ctrl.service.store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("seed instance: %v", err)
}
if err := ctrl.service.secrets.Set(ctx, SecretKey, "sentry", "tok"); err != nil {
t.Fatalf("set secret: %v", err)
if secret != "" {
if err := ctrl.service.secrets.Set(ctx, secretKeyForInstance(cfg.ID), "sentry", secret); err != nil {
t.Fatalf("seed secret: %v", err)
}
}
return cfg
}
func TestHTTPGetConfig_NoConfig_Returns204(t *testing.T) {
func do(router *gin.Engine, method, target, body string) *httptest.ResponseRecorder {
var r *http.Request
if body == "" {
r = httptest.NewRequest(method, target, nil)
} else {
r = httptest.NewRequest(method, target, strings.NewReader(body))
r.Header.Set("Content-Type", "application/json")
}
w := httptest.NewRecorder()
router.ServeHTTP(w, r)
return w
}
func TestHTTP_ListInstances_RequiresWorkspace(t *testing.T) {
_, router, _ := newTestController(t)
req := httptest.NewRequest(http.MethodGet, "/api/v1/sentry/config", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusNoContent {
t.Errorf("status = %d, want 204", w.Code)
if w := do(router, http.MethodGet, "/api/v1/sentry/instances", ""); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 without workspace_id, got %d", w.Code)
}
}
func TestHTTPGetConfig_ReturnsConfig(t *testing.T) {
func TestHTTP_ListInstances_Wrapped(t *testing.T) {
ctrl, router, _ := newTestController(t)
seedConfig(t, ctrl)
req := httptest.NewRequest(http.MethodGet, "/api/v1/sentry/config", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
seedInstance(t, ctrl, "ws-1", "A", "tok")
seedInstance(t, ctrl, "ws-2", "B", "tok")
w := do(router, http.MethodGet, "/api/v1/sentry/instances?workspace_id=ws-1", "")
if w.Code != http.StatusOK {
t.Errorf("status = %d, want 200", w.Code)
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
var resp struct {
Instances []SentryConfig `json:"instances"`
}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
if len(resp.Instances) != 1 || resp.Instances[0].Name != "A" {
t.Errorf("expected only ws-1's instance, got %+v", resp.Instances)
}
}
func TestHTTP_CreateInstance_MismatchedWorkspaceRejected(t *testing.T) {
_, router, _ := newTestController(t)
// Body workspaceId mismatches the query → 400 (acceptance e).
body := `{"workspaceId":"ws-2","name":"A","secret":"t"}`
if w := do(router, http.MethodPost, "/api/v1/sentry/instances?workspace_id=ws-1", body); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 for mismatched workspaceId, got %d body=%s", w.Code, w.Body.String())
}
// Missing workspace_id query → 400.
if w := do(router, http.MethodPost, "/api/v1/sentry/instances", `{"name":"A"}`); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 without workspace_id, got %d", w.Code)
}
}
func TestHTTP_CreateInstance_OK(t *testing.T) {
ctrl, router, _ := newTestController(t)
probed := make(chan struct{}, 4)
ctrl.service.SetProbeHook(func() {
select {
case probed <- struct{}{}:
default:
}
})
w := do(router, http.MethodPost, "/api/v1/sentry/instances?workspace_id=ws-1",
`{"workspaceId":"ws-1","name":"SaaS","secret":"tok"}`)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
var cfg SentryConfig
if err := json.Unmarshal(w.Body.Bytes(), &cfg); err != nil {
t.Fatalf("decode: %v", err)
}
if cfg.AuthMethod != AuthMethodAuthToken || !cfg.HasSecret {
t.Errorf("config = %+v", cfg)
if cfg.ID == "" || cfg.Name != "SaaS" || !cfg.HasSecret {
t.Errorf("unexpected created instance: %+v", cfg)
}
select {
case <-probed:
case <-time.After(2 * time.Second):
t.Fatal("async probe did not fire")
}
}
func TestHTTPSearchIssues_MultiValueLevelsAndStatuses(t *testing.T) {
func TestHTTP_CreateInstance_BadJSON(t *testing.T) {
_, router, _ := newTestController(t)
if w := do(router, http.MethodPost, "/api/v1/sentry/instances?workspace_id=ws-1", "not-json"); w.Code != http.StatusBadRequest {
t.Errorf("status = %d, want 400", w.Code)
}
}
func TestHTTP_GetInstance_CrossWorkspace404(t *testing.T) {
ctrl, router, _ := newTestController(t)
inst := seedInstance(t, ctrl, "ws-1", "A", "tok")
w := do(router, http.MethodGet, "/api/v1/sentry/instances/"+inst.ID+"?workspace_id=ws-2", "")
if w.Code != http.StatusNotFound {
t.Fatalf("expected 404 cross-workspace, got %d", w.Code)
}
if !strings.Contains(w.Body.String(), `"code":"SENTRY_INSTANCE_NOT_FOUND"`) {
t.Errorf("missing code in body: %s", w.Body.String())
}
}
func TestHTTP_UpdateInstance_UpdatesAndRejectsCrossWorkspace(t *testing.T) {
ctrl, router, _ := newTestController(t)
inst := seedInstance(t, ctrl, "ws-1", "Original", "tok")
body := `{"name":"Renamed","authMethod":"auth_token","url":"https://sentry.example.com"}`
updated := do(router, http.MethodPut, "/api/v1/sentry/instances/"+inst.ID+"?workspace_id=ws-1", body)
if updated.Code != http.StatusOK {
t.Fatalf("update status = %d, body=%s", updated.Code, updated.Body.String())
}
var cfg SentryConfig
if err := json.Unmarshal(updated.Body.Bytes(), &cfg); err != nil {
t.Fatalf("decode update: %v", err)
}
if cfg.Name != "Renamed" || cfg.URL != "https://sentry.example.com" {
t.Errorf("updated instance = %+v", cfg)
}
crossWorkspace := do(router, http.MethodPut, "/api/v1/sentry/instances/"+inst.ID+"?workspace_id=ws-2", body)
if crossWorkspace.Code != http.StatusNotFound {
t.Fatalf("cross-workspace update status = %d, want 404; body=%s", crossWorkspace.Code, crossWorkspace.Body.String())
}
if !strings.Contains(crossWorkspace.Body.String(), `"code":"SENTRY_INSTANCE_NOT_FOUND"`) {
t.Errorf("missing cross-workspace not-found code: %s", crossWorkspace.Body.String())
}
}
func TestHTTP_DeleteInstance_InUse409(t *testing.T) {
ctrl, router, _ := newTestController(t)
inst := seedInstance(t, ctrl, "ws-1", "A", "tok")
w := newTestIssueWatch("ws-1")
w.SentryInstanceID = inst.ID
if err := ctrl.service.store.CreateIssueWatch(context.Background(), w); err != nil {
t.Fatalf("seed watch: %v", err)
}
resp := do(router, http.MethodDelete, "/api/v1/sentry/instances/"+inst.ID+"?workspace_id=ws-1", "")
if resp.Code != http.StatusConflict {
t.Fatalf("expected 409, got %d body=%s", resp.Code, resp.Body.String())
}
var body struct {
Code string `json:"code"`
WatchCount int `json:"watchCount"`
}
if err := json.Unmarshal(resp.Body.Bytes(), &body); err != nil {
t.Fatalf("decode: %v", err)
}
if body.Code != "SENTRY_INSTANCE_IN_USE" || body.WatchCount != 1 {
t.Errorf("unexpected 409 body: %+v", body)
}
}
func TestHTTP_Browse_RequiresWorkspaceAndInstance(t *testing.T) {
ctrl, router, _ := newTestController(t)
seedInstance(t, ctrl, "ws-1", "A", "tok")
// Missing workspace_id → 400.
if w := do(router, http.MethodGet, "/api/v1/sentry/projects", ""); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 without workspace_id, got %d", w.Code)
}
// Missing instanceId → 400 SENTRY_INSTANCE_REQUIRED.
w := do(router, http.MethodGet, "/api/v1/sentry/projects?workspace_id=ws-1", "")
if w.Code != http.StatusBadRequest || !strings.Contains(w.Body.String(), `"code":"SENTRY_INSTANCE_REQUIRED"`) {
t.Errorf("expected 400 SENTRY_INSTANCE_REQUIRED, got %d body=%s", w.Code, w.Body.String())
}
}
func TestHTTP_Browse_NotConfigured503(t *testing.T) {
ctrl, router, _ := newTestController(t)
// Instance with no secret → 503 SENTRY_NOT_CONFIGURED.
inst := seedInstance(t, ctrl, "ws-1", "A", "")
w := do(router, http.MethodGet, "/api/v1/sentry/projects?workspace_id=ws-1&instanceId="+inst.ID, "")
if w.Code != http.StatusServiceUnavailable {
t.Fatalf("expected 503, got %d body=%s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), `"code":"SENTRY_NOT_CONFIGURED"`) {
t.Errorf("missing code in body: %s", w.Body.String())
}
}
func TestHTTP_SearchIssues_ForwardsFilter(t *testing.T) {
ctrl, router, client := newTestController(t)
seedConfig(t, ctrl)
inst := seedInstance(t, ctrl, "ws-1", "A", "tok")
var seen SearchFilter
client.searchIssuesFn = func(filter SearchFilter, _ string) (*SearchResult, error) {
seen = filter
return &SearchResult{IsLast: true}, nil
}
req := httptest.NewRequest(http.MethodGet,
"/api/v1/sentry/issues?orgSlug=acme&projectSlug=fe&level=error&level=fatal&status=unresolved&query=boom&statsPeriod=24h",
nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
target := "/api/v1/sentry/issues?workspace_id=ws-1&instanceId=" + inst.ID +
"&orgSlug=acme&projectSlug=fe&level=error&level=fatal&status=unresolved&query=boom&statsPeriod=24h"
if w := do(router, http.MethodGet, target, ""); w.Code != http.StatusOK {
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
if seen.OrgSlug != "acme" || seen.ProjectSlug != "fe" || seen.Query != "boom" || seen.StatsPeriod != "24h" {
@@ -100,47 +247,30 @@ func TestHTTPSearchIssues_MultiValueLevelsAndStatuses(t *testing.T) {
}
}
func TestHTTPGetIssue_ForwardsID(t *testing.T) {
func TestHTTP_GetIssue_ForwardsID(t *testing.T) {
ctrl, router, client := newTestController(t)
seedConfig(t, ctrl)
inst := seedInstance(t, ctrl, "ws-1", "A", "tok")
var seenID string
client.getIssueFn = func(id string) (*SentryIssue, error) {
seenID = id
return &SentryIssue{ID: "99", ShortID: id}, nil
}
req := httptest.NewRequest(http.MethodGet, "/api/v1/sentry/issues/PROJ-7", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("status = %d", w.Code)
target := "/api/v1/sentry/issues/PROJ-7?workspace_id=ws-1&instanceId=" + inst.ID
if w := do(router, http.MethodGet, target, ""); w.Code != http.StatusOK {
t.Fatalf("status = %d", w.Code)
}
if seenID != "PROJ-7" {
t.Errorf("id forwarded = %q", seenID)
}
}
func TestHTTPListProjects_NotConfigured_Returns503(t *testing.T) {
_, router, _ := newTestController(t)
req := httptest.NewRequest(http.MethodGet, "/api/v1/sentry/projects", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusServiceUnavailable {
t.Errorf("status = %d, want 503", w.Code)
}
if !strings.Contains(w.Body.String(), `"code":"SENTRY_NOT_CONFIGURED"`) {
t.Errorf("missing code in body: %s", w.Body.String())
}
}
func TestHTTPListOrganizations_ReturnsOrganizations(t *testing.T) {
func TestHTTP_ListOrganizations_ReturnsWrapped(t *testing.T) {
ctrl, router, client := newTestController(t)
seedConfig(t, ctrl)
inst := seedInstance(t, ctrl, "ws-1", "A", "tok")
client.listOrganizationsFn = func() ([]SentryOrganization, error) {
return []SentryOrganization{{ID: "1", Slug: "acme", Name: "Acme"}}, nil
}
req := httptest.NewRequest(http.MethodGet, "/api/v1/sentry/organizations", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
w := do(router, http.MethodGet, "/api/v1/sentry/organizations?workspace_id=ws-1&instanceId="+inst.ID, "")
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
@@ -155,27 +285,148 @@ func TestHTTPListOrganizations_ReturnsOrganizations(t *testing.T) {
}
}
func TestHTTPListOrganizations_NotConfigured_Returns503(t *testing.T) {
func TestHTTP_TestConnection_RequiresWorkspace(t *testing.T) {
_, router, _ := newTestController(t)
req := httptest.NewRequest(http.MethodGet, "/api/v1/sentry/organizations", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusServiceUnavailable {
t.Errorf("status = %d, want 503", w.Code)
}
if !strings.Contains(w.Body.String(), `"code":"SENTRY_NOT_CONFIGURED"`) {
t.Errorf("missing code in body: %s", w.Body.String())
if w := do(router, http.MethodPost, "/api/v1/sentry/test-connection", `{"secret":"t"}`); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 without workspace_id, got %d", w.Code)
}
}
func TestHTTPSetConfig_BadJSON(t *testing.T) {
_, router, _ := newTestController(t)
req := httptest.NewRequest(http.MethodPut, "/api/v1/sentry/config", strings.NewReader("not-json"))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
func TestHTTP_TestConnection_OK(t *testing.T) {
ctrl, router, client := newTestController(t)
client.testAuthFn = func() (*TestConnectionResult, error) {
return &TestConnectionResult{OK: true, DisplayName: "Alice"}, nil
}
_ = ctrl
w := do(router, http.MethodPost, "/api/v1/sentry/test-connection?workspace_id=ws-1",
`{"authMethod":"auth_token","secret":"tok","url":"https://sentry.example.com"}`)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
var res TestConnectionResult
if err := json.Unmarshal(w.Body.Bytes(), &res); err != nil {
t.Fatalf("decode: %v", err)
}
if !res.OK {
t.Errorf("expected OK result, got %+v", res)
}
}
func TestHTTP_CopyConfig_ReturnsWrappedList(t *testing.T) {
ctrl, router, _ := newTestController(t)
seedInstance(t, ctrl, "ws-src", "SaaS", "sec")
w := do(router, http.MethodPost, "/api/v1/sentry/config/copy?workspace_id=ws-src",
`{"targetWorkspaceId":"ws-dst"}`)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
var resp struct {
Instances []SentryConfig `json:"instances"`
}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
if len(resp.Instances) != 1 || resp.Instances[0].WorkspaceID != "ws-dst" {
t.Errorf("copied = %+v", resp.Instances)
}
}
func TestHTTP_CopyConfig_IgnoresBodySourceWorkspace(t *testing.T) {
ctrl, router, _ := newTestController(t)
seedInstance(t, ctrl, "ws-query", "Authoritative", "sec")
w := do(router, http.MethodPost, "/api/v1/sentry/config/copy?workspace_id=ws-query",
`{"sourceWorkspaceId":"ws-body","targetWorkspaceId":"ws-dst"}`)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body=%s", w.Code, w.Body.String())
}
var resp struct {
Instances []SentryConfig `json:"instances"`
}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
if len(resp.Instances) != 1 || resp.Instances[0].Name != "Authoritative" {
t.Errorf("copied = %+v", resp.Instances)
}
}
func TestHTTP_CopyConfig_RejectsBodyOnlySourceWorkspace(t *testing.T) {
ctrl, router, _ := newTestController(t)
seedInstance(t, ctrl, "ws-src", "SaaS", "sec")
w := do(router, http.MethodPost, "/api/v1/sentry/config/copy",
`{"sourceWorkspaceId":"ws-src","targetWorkspaceId":"ws-dst"}`)
if w.Code != http.StatusBadRequest {
t.Errorf("status = %d, want 400", w.Code)
t.Fatalf("status = %d, want 400; body=%s", w.Code, w.Body.String())
}
}
func TestHTTP_CopyConfig_DuplicateNameReturnsCodedConflict(t *testing.T) {
ctrl, router, _ := newTestController(t)
seedInstance(t, ctrl, "ws-src", "SaaS", "sec")
if _, err := ctrl.service.store.db.Exec(`
CREATE TRIGGER copy_duplicate_name
BEFORE INSERT ON sentry_configs
WHEN NEW.workspace_id = 'ws-dst'
BEGIN
SELECT RAISE(ABORT, 'UNIQUE constraint failed: sentry_configs.workspace_id, sentry_configs.name');
END`); err != nil {
t.Fatalf("create duplicate trigger: %v", err)
}
w := do(router, http.MethodPost, "/api/v1/sentry/config/copy?workspace_id=ws-src",
`{"targetWorkspaceId":"ws-dst"}`)
if w.Code != http.StatusConflict {
t.Fatalf("status = %d, want 409; body=%s", w.Code, w.Body.String())
}
var response struct {
Code string `json:"code"`
}
if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
t.Fatalf("decode: %v", err)
}
if response.Code != errCodeSentryInstanceNameTaken {
t.Errorf("code = %q, want %q", response.Code, errCodeSentryInstanceNameTaken)
}
}
// TestHTTP_CreateIssueWatch_RejectsMismatchedWorkspace pins acceptance (e) for
// watch-create.
func TestHTTP_CreateIssueWatch_RejectsMismatchedWorkspace(t *testing.T) {
ctrl, router, _ := newTestController(t)
inst := seedInstance(t, ctrl, "ws-1", "A", "tok")
body := `{"workspaceId":"ws-1","sentryInstanceId":"` + inst.ID + `","workflowId":"wf","workflowStepId":"step","filter":{"orgSlug":"acme","projectSlug":"fe"}}`
// Missing workspace_id query → 400.
if w := do(router, http.MethodPost, "/api/v1/sentry/watches/issue", body); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 without workspace_id, got %d body=%s", w.Code, w.Body.String())
}
// Mismatched workspace_id query → 400.
if w := do(router, http.MethodPost, "/api/v1/sentry/watches/issue?workspace_id=ws-2", body); w.Code != http.StatusBadRequest {
t.Errorf("expected 400 for mismatched workspace_id, got %d", w.Code)
}
// Matching → created (200).
if w := do(router, http.MethodPost, "/api/v1/sentry/watches/issue?workspace_id=ws-1", body); w.Code != http.StatusOK {
t.Errorf("expected 200 for matching workspace_id, got %d body=%s", w.Code, w.Body.String())
}
}
func TestHTTP_CreateIssueWatch_RequiresInstance(t *testing.T) {
_, router, _ := newTestController(t)
body := `{"workspaceId":"ws-1","workflowId":"wf","workflowStepId":"step","filter":{"orgSlug":"acme","projectSlug":"fe"}}`
resp := do(router, http.MethodPost, "/api/v1/sentry/watches/issue?workspace_id=ws-1", body)
if resp.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400; body=%s", resp.Code, resp.Body.String())
}
var response struct {
Code string `json:"code"`
}
if err := json.Unmarshal(resp.Body.Bytes(), &response); err != nil {
t.Fatalf("decode response: %v", err)
}
if response.Code != errCodeSentryInstanceRequired {
t.Errorf("error code = %q, want %q", response.Code, errCodeSentryInstanceRequired)
}
}
@@ -212,8 +463,6 @@ func TestWriteClientError_GenericError(t *testing.T) {
}
func TestRegisterRoutes_AcceptsNilDispatcher(t *testing.T) {
// Sanity check that RegisterRoutes can be called with a real dispatcher
// without registering any WS handlers (Phase 1 has no WS surface).
gin.SetMode(gin.TestMode)
router := gin.New()
store := newTestStore(t)
@@ -223,3 +472,30 @@ func TestRegisterRoutes_AcceptsNilDispatcher(t *testing.T) {
dispatcher := ws.NewDispatcher()
RegisterRoutes(router, dispatcher, svc, logger.Default())
}
// TestHTTP_TriggerIssueWatch_AmbiguousUnboundIs4xx pins the P2 fix: a manual
// trigger of an unbound watch that resolves ambiguously (multiple healthy
// instances) is routed through the issue-watch error mapper, yielding a 4xx
// (ErrInvalidConfig → 400) rather than a bare 500.
func TestHTTP_TriggerIssueWatch_AmbiguousUnboundIs4xx(t *testing.T) {
ctrl, router, _ := newTestController(t)
ctx := context.Background()
a := seedInstance(t, ctrl, "ws-1", "A", "tok")
b := seedInstance(t, ctrl, "ws-1", "B", "tok")
now := time.Now().UTC()
for _, id := range []string{a.ID, b.ID} {
if err := ctrl.service.store.UpdateAuthHealthForInstance(ctx, id, true, "", now); err != nil {
t.Fatalf("mark healthy: %v", err)
}
}
// Unbound watch: no SentryInstanceID → resolves ambiguously across the two
// healthy instances.
w := newTestIssueWatch("ws-1")
if err := ctrl.service.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("seed unbound watch: %v", err)
}
resp := do(router, http.MethodPost, "/api/v1/sentry/watches/issue/"+w.ID+"/trigger?workspace_id=ws-1", "")
if resp.Code < 400 || resp.Code >= 500 {
t.Fatalf("expected 4xx for ambiguous unbound-watch trigger, got %d body=%s", resp.Code, resp.Body.String())
}
}
@@ -0,0 +1,590 @@
package sentry
import (
"context"
"errors"
"testing"
"time"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
_ "github.com/mattn/go-sqlite3"
"github.com/kandev/kandev/internal/common/logger"
)
// workspaceScopedConfigsDDL is PR #1572's one-config-per-workspace shape
// (workspace_id PRIMARY KEY, no id column) that migrateConfigsTableToInstances
// upgrades.
const workspaceScopedConfigsDDL = `
CREATE TABLE sentry_configs (
workspace_id TEXT PRIMARY KEY,
auth_method TEXT NOT NULL,
url TEXT NOT NULL DEFAULT 'https://sentry.io',
last_checked_at DATETIME,
last_ok INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
);`
// workspaceScopedWatchesDDL is the pre-instance sentry_issue_watches shape
// (workspace-scoped, no sentry_instance_id) that migrateWatchesAddInstanceColumn
// rebuilds, plus its child dedup table.
const workspaceScopedWatchesDDL = `
CREATE TABLE sentry_issue_watches (
id TEXT PRIMARY KEY,
workspace_id TEXT NOT NULL,
workflow_id TEXT NOT NULL,
workflow_step_id TEXT NOT NULL,
repository_id TEXT NOT NULL DEFAULT '',
base_branch TEXT NOT NULL DEFAULT '',
filter_json TEXT NOT NULL DEFAULT '{}',
agent_profile_id TEXT NOT NULL DEFAULT '',
executor_profile_id TEXT NOT NULL DEFAULT '',
prompt TEXT NOT NULL DEFAULT '',
enabled BOOLEAN NOT NULL DEFAULT 1,
poll_interval_seconds INTEGER NOT NULL DEFAULT 300,
max_inflight_tasks INTEGER DEFAULT 5,
last_polled_at DATETIME,
last_error TEXT NOT NULL DEFAULT '',
last_error_at DATETIME,
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
);
CREATE TABLE sentry_issue_watch_tasks (
id TEXT PRIMARY KEY,
issue_watch_id TEXT NOT NULL,
issue_short_id TEXT NOT NULL,
issue_url TEXT NOT NULL,
task_id TEXT NOT NULL DEFAULT '',
created_at DATETIME NOT NULL,
UNIQUE(issue_watch_id, issue_short_id),
FOREIGN KEY(issue_watch_id) REFERENCES sentry_issue_watches(id) ON DELETE CASCADE
);`
func openMigrationDB(t *testing.T) *sqlx.DB {
t.Helper()
db, err := sqlx.Open("sqlite3", ":memory:")
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
db.SetMaxOpenConns(1)
db.SetMaxIdleConns(1)
if _, err := db.Exec(`PRAGMA foreign_keys = ON`); err != nil {
t.Fatalf("enable foreign keys: %v", err)
}
t.Cleanup(func() { _ = db.Close() })
return db
}
// seedWorkspaceScopedSchema builds the pre-instance workspace-scoped tables and
// seeds configs for ws-1 (self-hosted) and ws-2 (SaaS), watches for ws-1, ws-2
// and ws-3 (which has NO config), plus one dedup task row for the ws-1 watch.
// Returns the ws-1/ws-2/ws-3 watch IDs.
func seedWorkspaceScopedSchema(t *testing.T, db *sqlx.DB) (w1, w2, w3 string) {
t.Helper()
now := time.Now().UTC().Truncate(time.Second)
if _, err := db.Exec(workspaceScopedConfigsDDL + workspaceScopedWatchesDDL); err != nil {
t.Fatalf("seed schema: %v", err)
}
if _, err := db.Exec(`
INSERT INTO sentry_configs (workspace_id, auth_method, url, last_checked_at, last_ok, last_error, created_at, updated_at)
VALUES ('ws-1', ?, 'https://sentry.example.com', ?, 1, 'healthy', ?, ?),
('ws-2', ?, 'https://sentry.io', NULL, 0, '', ?, ?)`,
AuthMethodAuthToken, now, now, now, AuthMethodAuthToken, now, now); err != nil {
t.Fatalf("seed configs: %v", err)
}
w1, w2, w3 = uuid.New().String(), uuid.New().String(), uuid.New().String()
for _, watch := range []struct{ id, ws string }{{w1, "ws-1"}, {w2, "ws-2"}, {w3, "ws-3"}} {
if _, err := db.Exec(`
INSERT INTO sentry_issue_watches (id, workspace_id, workflow_id, workflow_step_id, filter_json, created_at, updated_at)
VALUES (?, ?, 'wf', 'step', '{"orgSlug":"acme","projectSlug":"fe"}', ?, ?)`,
watch.id, watch.ws, now, now); err != nil {
t.Fatalf("seed watch %s: %v", watch.ws, err)
}
}
if _, err := db.Exec(`
INSERT INTO sentry_issue_watch_tasks (id, issue_watch_id, issue_short_id, issue_url, task_id, created_at)
VALUES (?, ?, 'PROJ-1', 'https://sentry.example.com/issues/PROJ-1', 'task-1', ?)`,
uuid.New().String(), w1, now); err != nil {
t.Fatalf("seed dedup task: %v", err)
}
return w1, w2, w3
}
// TestMigration_WorkspaceConfigsToInstances pins acceptance (a): the
// workspace-scoped model upgrades to id-keyed instances, the per-workspace
// secret is rekeyed to the per-instance key, and every watch's
// sentry_instance_id is backfilled when its workspace has exactly one config.
func TestMigration_WorkspaceConfigsToInstances(t *testing.T) {
db := openMigrationDB(t)
w1, w2, w3 := seedWorkspaceScopedSchema(t, db)
secrets := newFakeSecretStore()
ctx := context.Background()
_ = secrets.Set(ctx, SecretKeyForWorkspace("ws-1"), "tok", "tok-1")
_ = secrets.Set(ctx, SecretKeyForWorkspace("ws-2"), "tok", "tok-2")
svc, _, err := Provide(db, db, secrets, nil, logger.Default())
if err != nil {
t.Fatalf("Provide (migrate): %v", err)
}
store := svc.Store()
// One instance per workspace config, host-derived names, health preserved.
inst1List, _ := store.ListInstances(ctx, "ws-1")
inst2List, _ := store.ListInstances(ctx, "ws-2")
if len(inst1List) != 1 || len(inst2List) != 1 {
t.Fatalf("expected one instance per workspace, got ws-1=%d ws-2=%d", len(inst1List), len(inst2List))
}
inst1, inst2 := inst1List[0], inst2List[0]
if inst1.Name != "sentry.example.com" || inst1.URL != "https://sentry.example.com" || !inst1.LastOk {
t.Errorf("ws-1 instance not migrated faithfully: %+v", inst1)
}
if inst2.Name != "sentry.io" {
t.Errorf("ws-2 instance name = %q, want host-derived 'sentry.io'", inst2.Name)
}
// Watches backfilled to their workspace's instance; the config-less
// workspace's watch stays unbound (NULL).
gw1, _ := store.GetIssueWatch(ctx, w1)
gw2, _ := store.GetIssueWatch(ctx, w2)
gw3, _ := store.GetIssueWatch(ctx, w3)
if gw1.SentryInstanceID != inst1.ID {
t.Errorf("ws-1 watch bound to %q, want %q", gw1.SentryInstanceID, inst1.ID)
}
if gw2.SentryInstanceID != inst2.ID {
t.Errorf("ws-2 watch bound to %q, want %q", gw2.SentryInstanceID, inst2.ID)
}
if gw3.SentryInstanceID != "" {
t.Errorf("config-less workspace watch should stay unbound, got %q", gw3.SentryInstanceID)
}
// The dedup child row survived the watches table rebuild (FK preserved).
ids, _ := store.ListIssueWatchTaskIDs(ctx, w1)
if len(ids) != 1 || ids[0] != "task-1" {
t.Errorf("expected dedup task preserved through rebuild, got %v", ids)
}
// Secret rekeyed from the workspace key to the per-instance key.
if got, _ := secrets.Reveal(ctx, secretKeyForInstance(inst1.ID)); got != "tok-1" {
t.Errorf("ws-1 secret not rekeyed to instance key, got %q", got)
}
if got, _ := secrets.Reveal(ctx, secretKeyForInstance(inst2.ID)); got != "tok-2" {
t.Errorf("ws-2 secret not rekeyed to instance key, got %q", got)
}
}
// TestMigration_RerunIsIdempotent pins acceptance (c): re-running the whole
// migration + secret rekey after a completed run changes nothing.
func TestMigration_RerunIsIdempotent(t *testing.T) {
db := openMigrationDB(t)
w1, _, _ := seedWorkspaceScopedSchema(t, db)
secrets := newFakeSecretStore()
ctx := context.Background()
_ = secrets.Set(ctx, SecretKeyForWorkspace("ws-1"), "tok", "tok-1")
_ = secrets.Set(ctx, SecretKeyForWorkspace("ws-2"), "tok", "tok-2")
svc1, _, err := Provide(db, db, secrets, nil, logger.Default())
if err != nil {
t.Fatalf("first Provide: %v", err)
}
before, _ := svc1.Store().ListAllInstances(ctx)
boundBefore, _ := svc1.Store().GetIssueWatch(ctx, w1)
// Re-run: a fresh NewStore + secret rekey over the same (now-migrated) DB.
store2, err := NewStore(db, db)
if err != nil {
t.Fatalf("second NewStore: %v", err)
}
migrateInstanceSecrets(store2, secrets, logger.Default())
after, _ := store2.ListAllInstances(ctx)
if len(after) != len(before) || len(after) != 2 {
t.Fatalf("instance count changed on rerun: before=%d after=%d", len(before), len(after))
}
if after[0].ID != before[0].ID || after[1].ID != before[1].ID {
t.Error("instance IDs changed on rerun")
}
boundAfter, _ := store2.GetIssueWatch(ctx, w1)
if boundAfter.SentryInstanceID != boundBefore.SentryInstanceID {
t.Errorf("watch binding changed on rerun: %q -> %q", boundBefore.SentryInstanceID, boundAfter.SentryInstanceID)
}
if got, _ := secrets.Reveal(ctx, secretKeyForInstance(boundBefore.SentryInstanceID)); got != "tok-1" {
t.Errorf("secret changed on rerun, got %q", got)
}
}
// TestMigration_CrashAfterConfigsRebuild pins the other half of acceptance (c):
// a crash after the configs table was rebuilt to the id-keyed shape but before
// the watches table gained its FK column. The next boot must complete the watch
// rebuild + backfill against the already-migrated configs.
func TestMigration_CrashAfterConfigsRebuild(t *testing.T) {
db := openMigrationDB(t)
ctx := context.Background()
now := time.Now().UTC().Truncate(time.Second)
// Simulate the post-configs-rebuild / pre-watches-rebuild state: configs are
// already id-keyed, watches are still workspace-scoped without the FK column.
inst1, inst2 := uuid.New().String(), uuid.New().String()
if _, err := db.Exec(`CREATE TABLE sentry_configs (` + sentryConfigsColumns + `)`); err != nil {
t.Fatalf("create id-keyed configs: %v", err)
}
if _, err := db.Exec(`
INSERT INTO sentry_configs (id, workspace_id, name, auth_method, url, last_ok, last_error, created_at, updated_at)
VALUES (?, 'ws-1', 'sentry.example.com', ?, 'https://sentry.example.com', 0, '', ?, ?),
(?, 'ws-2', 'sentry.io', ?, 'https://sentry.io', 0, '', ?, ?)`,
inst1, AuthMethodAuthToken, now, now, inst2, AuthMethodAuthToken, now, now); err != nil {
t.Fatalf("seed id-keyed configs: %v", err)
}
w1, w2, w3 := uuid.New().String(), uuid.New().String(), uuid.New().String()
if _, err := db.Exec(workspaceScopedWatchesDDL); err != nil {
t.Fatalf("seed workspace-scoped watches: %v", err)
}
for _, watch := range []struct{ id, ws string }{{w1, "ws-1"}, {w2, "ws-2"}, {w3, "ws-3"}} {
if _, err := db.Exec(`
INSERT INTO sentry_issue_watches (id, workspace_id, workflow_id, workflow_step_id, filter_json, created_at, updated_at)
VALUES (?, ?, 'wf', 'step', '{}', ?, ?)`, watch.id, watch.ws, now, now); err != nil {
t.Fatalf("seed watch %s: %v", watch.ws, err)
}
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("resume migration: %v", err)
}
// Configs are left untouched (no second rebuild → IDs preserved).
gi1, _ := store.GetInstance(ctx, inst1)
if gi1 == nil {
t.Fatal("existing id-keyed config was clobbered")
}
// Watches now carry the FK column, backfilled from the existing configs.
if gw1, _ := store.GetIssueWatch(ctx, w1); gw1.SentryInstanceID != inst1 {
t.Errorf("ws-1 watch bound to %q, want %q", gw1.SentryInstanceID, inst1)
}
if gw2, _ := store.GetIssueWatch(ctx, w2); gw2.SentryInstanceID != inst2 {
t.Errorf("ws-2 watch bound to %q, want %q", gw2.SentryInstanceID, inst2)
}
if gw3, _ := store.GetIssueWatch(ctx, w3); gw3.SentryInstanceID != "" {
t.Errorf("config-less workspace watch should stay unbound, got %q", gw3.SentryInstanceID)
}
}
// experimentalWatchesDDL is the unmerged-#1469 experimental shape:
// sentry_issue_watches carries sentry_instance_id as NOT NULL DEFAULT ” with
// NO foreign key. It only ever existed on dev machines that ran that build;
// migrateWatchesAddInstanceColumn must still converge it to the nullable-FK
// shape rather than skip it because the column name happens to be present.
const experimentalWatchesDDL = `
CREATE TABLE sentry_issue_watches (
id TEXT PRIMARY KEY,
workspace_id TEXT NOT NULL,
sentry_instance_id TEXT NOT NULL DEFAULT '',
workflow_id TEXT NOT NULL,
workflow_step_id TEXT NOT NULL,
repository_id TEXT NOT NULL DEFAULT '',
base_branch TEXT NOT NULL DEFAULT '',
filter_json TEXT NOT NULL DEFAULT '{}',
agent_profile_id TEXT NOT NULL DEFAULT '',
executor_profile_id TEXT NOT NULL DEFAULT '',
prompt TEXT NOT NULL DEFAULT '',
enabled BOOLEAN NOT NULL DEFAULT 1,
poll_interval_seconds INTEGER NOT NULL DEFAULT 300,
max_inflight_tasks INTEGER DEFAULT 5,
last_polled_at DATETIME,
last_error TEXT NOT NULL DEFAULT '',
last_error_at DATETIME,
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
);
CREATE TABLE sentry_issue_watch_tasks (
id TEXT PRIMARY KEY,
issue_watch_id TEXT NOT NULL,
issue_short_id TEXT NOT NULL,
issue_url TEXT NOT NULL,
task_id TEXT NOT NULL DEFAULT '',
created_at DATETIME NOT NULL,
UNIQUE(issue_watch_id, issue_short_id),
FOREIGN KEY(issue_watch_id) REFERENCES sentry_issue_watches(id) ON DELETE CASCADE
);`
// TestMigration_ExperimentalNonNullInstanceColumnRebuilt pins the hardened
// guard: a watches table that already has sentry_instance_id but as
// NOT NULL DEFAULT ” with no foreign key is rebuilt into the nullable-FK shape
// (not skipped), converting the ” sentinel to a real backfill / NULL.
func TestMigration_ExperimentalNonNullInstanceColumnRebuilt(t *testing.T) {
db := openMigrationDB(t)
ctx := context.Background()
now := time.Now().UTC().Truncate(time.Second)
inst1 := uuid.New().String()
if _, err := db.Exec(`CREATE TABLE sentry_configs (` + sentryConfigsColumns + `)`); err != nil {
t.Fatalf("create id-keyed configs: %v", err)
}
if _, err := db.Exec(`
INSERT INTO sentry_configs (id, workspace_id, name, auth_method, url, last_ok, last_error, created_at, updated_at)
VALUES (?, 'ws-1', 'sentry.example.com', ?, 'https://sentry.example.com', 0, '', ?, ?)`,
inst1, AuthMethodAuthToken, now, now); err != nil {
t.Fatalf("seed configs: %v", err)
}
if _, err := db.Exec(experimentalWatchesDDL); err != nil {
t.Fatalf("seed experimental watches: %v", err)
}
w1, w3 := uuid.New().String(), uuid.New().String()
// Experimental rows store the '' sentinel for the unbound case.
for _, watch := range []struct{ id, ws string }{{w1, "ws-1"}, {w3, "ws-3"}} {
if _, err := db.Exec(`
INSERT INTO sentry_issue_watches (id, workspace_id, sentry_instance_id, workflow_id, workflow_step_id, filter_json, created_at, updated_at)
VALUES (?, ?, '', 'wf', 'step', '{}', ?, ?)`, watch.id, watch.ws, now, now); err != nil {
t.Fatalf("seed watch %s: %v", watch.ws, err)
}
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("migrate experimental schema: %v", err)
}
// Column is now nullable and backed by the ON DELETE RESTRICT FK to id.
nullable, err := store.columnIsNullable("sentry_issue_watches", "sentry_instance_id")
if err != nil || !nullable {
t.Errorf("sentry_instance_id nullable=%v err=%v, want nullable", nullable, err)
}
hasFK, err := store.hasForeignKey("sentry_issue_watches", "sentry_instance_id", "sentry_configs", "id", "RESTRICT")
if err != nil || !hasFK {
t.Errorf("sentry_instance_id FK present=%v err=%v, want RESTRICT FK to id", hasFK, err)
}
// Rows re-backfilled: ws-1 to its sole instance, config-less ws-3 to NULL.
if gw1, _ := store.GetIssueWatch(ctx, w1); gw1.SentryInstanceID != inst1 {
t.Errorf("ws-1 watch bound to %q, want %q", gw1.SentryInstanceID, inst1)
}
if gw3, _ := store.GetIssueWatch(ctx, w3); gw3.SentryInstanceID != "" {
t.Errorf("config-less watch should be unbound, got %q", gw3.SentryInstanceID)
}
// FK now enforced: deleting an in-use instance is blocked.
if _, err := db.Exec(`DELETE FROM sentry_configs WHERE id = ?`, inst1); err == nil {
t.Error("expected FK RESTRICT to block deleting an in-use instance after rebuild")
}
}
// TestMigration_RekeyDoesNotSeedLaterSecretlessInstance ensures a completed
// legacy secret migration cannot grant an ordinary later instance the stale
// workspace or singleton token on a subsequent process start.
func TestMigration_RekeyDoesNotSeedLaterSecretlessInstance(t *testing.T) {
db := openMigrationDB(t)
seedWorkspaceScopedSchema(t, db)
ctx := context.Background()
secrets := newFakeSecretStore()
if err := secrets.Set(ctx, SecretKeyForWorkspace("ws-1"), "tok", "workspace-token"); err != nil {
t.Fatalf("seed workspace token: %v", err)
}
if err := secrets.Set(ctx, SecretKey, "tok", "singleton-token"); err != nil {
t.Fatalf("seed singleton token: %v", err)
}
svc, _, err := Provide(db, db, secrets, nil, logger.Default())
if err != nil {
t.Fatalf("first Provide: %v", err)
}
later := testInstance("ws-1", "Later")
if err := svc.Store().CreateInstance(ctx, later); err != nil {
t.Fatalf("create later secretless instance: %v", err)
}
if _, _, err := Provide(db, db, secrets, nil, logger.Default()); err != nil {
t.Fatalf("restart Provide: %v", err)
}
if exists, err := secrets.Exists(ctx, secretKeyForInstance(later.ID)); err != nil {
t.Fatalf("check later instance secret: %v", err)
} else if exists {
t.Fatal("later secretless instance inherited a stale legacy token")
}
}
// TestMigration_RekeyRetriesOriginalInstanceDespiteLaterAddition ensures a
// transient secret-store failure on the original migrated instance's rekey
// does not permanently strand it once a later, unrelated instance is added to
// the same workspace before the next restart: only the later instance is
// excluded from ever inheriting the legacy token, not the legitimate original.
func TestMigration_RekeyRetriesOriginalInstanceDespiteLaterAddition(t *testing.T) {
db := openMigrationDB(t)
seedWorkspaceScopedSchema(t, db)
ctx := context.Background()
secrets := newFakeSecretStore()
if err := secrets.Set(ctx, SecretKeyForWorkspace("ws-1"), "tok", "workspace-token"); err != nil {
t.Fatalf("seed workspace token: %v", err)
}
secrets.setErr = errors.New("secret store unavailable")
svc, _, err := Provide(db, db, secrets, nil, logger.Default())
if err != nil {
t.Fatalf("first Provide: %v", err)
}
instances, err := svc.Store().ListInstances(ctx, "ws-1")
if err != nil || len(instances) != 1 {
t.Fatalf("list ws-1 instances: %v %+v", err, instances)
}
original := instances[0]
if exists, _ := secrets.Exists(ctx, secretKeyForInstance(original.ID)); exists {
t.Fatal("expected the first rekey attempt to fail, but the instance key already exists")
}
later := testInstance("ws-1", "Later")
if err := svc.Store().CreateInstance(ctx, later); err != nil {
t.Fatalf("create later secretless instance: %v", err)
}
secrets.setErr = nil
if _, _, err := Provide(db, db, secrets, nil, logger.Default()); err != nil {
t.Fatalf("restart Provide: %v", err)
}
if exists, err := secrets.Exists(ctx, secretKeyForInstance(original.ID)); err != nil || !exists {
t.Fatalf("expected the original instance to recover its legacy token once the transient failure cleared, exists=%v err=%v", exists, err)
}
if exists, err := secrets.Exists(ctx, secretKeyForInstance(later.ID)); err != nil || exists {
t.Fatalf("later secretless instance must still never inherit the legacy token, exists=%v err=%v", exists, err)
}
}
// TestMigration_MultipleInstancesLeaveLegacyWatchUnbound ensures the watch
// rebuild preserves the unbound fallback when a workspace has several possible
// instance targets rather than guessing the oldest one.
func TestMigration_MultipleInstancesLeaveLegacyWatchUnbound(t *testing.T) {
db := openMigrationDB(t)
ctx := context.Background()
now := time.Now().UTC().Truncate(time.Second)
first, second := uuid.New().String(), uuid.New().String()
if _, err := db.Exec(`CREATE TABLE sentry_configs (` + sentryConfigsColumns + `)`); err != nil {
t.Fatalf("create id-keyed configs: %v", err)
}
if _, err := db.Exec(`
INSERT INTO sentry_configs (id, workspace_id, name, auth_method, url, last_ok, last_error, created_at, updated_at)
VALUES (?, 'ws-1', 'First', ?, 'https://first.example.com', 0, '', ?, ?),
(?, 'ws-1', 'Second', ?, 'https://second.example.com', 0, '', ?, ?)`,
first, AuthMethodAuthToken, now, now,
second, AuthMethodAuthToken, now.Add(time.Minute), now.Add(time.Minute)); err != nil {
t.Fatalf("seed instances: %v", err)
}
if _, err := db.Exec(workspaceScopedWatchesDDL); err != nil {
t.Fatalf("create legacy watches: %v", err)
}
watchID := uuid.New().String()
if _, err := db.Exec(`
INSERT INTO sentry_issue_watches (id, workspace_id, workflow_id, workflow_step_id, filter_json, created_at, updated_at)
VALUES (?, 'ws-1', 'wf', 'step', '{}', ?, ?)`, watchID, now, now); err != nil {
t.Fatalf("seed legacy watch: %v", err)
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("migrate watches: %v", err)
}
watch, err := store.GetIssueWatch(ctx, watchID)
if err != nil {
t.Fatalf("get migrated watch: %v", err)
}
if watch.SentryInstanceID != "" {
t.Fatalf("multi-instance legacy watch bound to %q, want unbound", watch.SentryInstanceID)
}
}
// TestMigration_ExperimentalBindingSurvivesRebuild ensures a valid explicit
// binding from the experimental no-FK shape is not overwritten by backfill.
func TestMigration_ExperimentalBindingSurvivesRebuild(t *testing.T) {
db := openMigrationDB(t)
ctx := context.Background()
now := time.Now().UTC().Truncate(time.Second)
first, selected := uuid.New().String(), uuid.New().String()
if _, err := db.Exec(`CREATE TABLE sentry_configs (` + sentryConfigsColumns + `)`); err != nil {
t.Fatalf("create id-keyed configs: %v", err)
}
if _, err := db.Exec(`
INSERT INTO sentry_configs (id, workspace_id, name, auth_method, url, last_ok, last_error, created_at, updated_at)
VALUES (?, 'ws-1', 'First', ?, 'https://first.example.com', 0, '', ?, ?),
(?, 'ws-1', 'Selected', ?, 'https://selected.example.com', 0, '', ?, ?)`,
first, AuthMethodAuthToken, now, now,
selected, AuthMethodAuthToken, now.Add(time.Minute), now.Add(time.Minute)); err != nil {
t.Fatalf("seed instances: %v", err)
}
if _, err := db.Exec(experimentalWatchesDDL); err != nil {
t.Fatalf("create experimental watches: %v", err)
}
watchID := uuid.New().String()
if _, err := db.Exec(`
INSERT INTO sentry_issue_watches (id, workspace_id, sentry_instance_id, workflow_id, workflow_step_id, filter_json, created_at, updated_at)
VALUES (?, 'ws-1', ?, 'wf', 'step', '{}', ?, ?)`, watchID, selected, now, now); err != nil {
t.Fatalf("seed experimental watch: %v", err)
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("migrate watches: %v", err)
}
watch, err := store.GetIssueWatch(ctx, watchID)
if err != nil {
t.Fatalf("get migrated watch: %v", err)
}
if watch.SentryInstanceID != selected {
t.Fatalf("experimental binding = %q, want %q", watch.SentryInstanceID, selected)
}
}
// TestHasForeignKey_ImplicitPrimaryKeyReference pins the NULL-`to` edge case: a
// FK declared as `REFERENCES sentry_configs` (implicit primary key, no column
// named) is reported by SQLite's foreign_key_list with a NULL `to`. hasForeignKey
// must resolve that to the single-column PK (`id`) and recognize the FK rather
// than treat the NULL as a non-match and force an unnecessary table rebuild.
func TestHasForeignKey_ImplicitPrimaryKeyReference(t *testing.T) {
db := openMigrationDB(t)
if _, err := db.Exec(`CREATE TABLE sentry_configs (` + sentryConfigsColumns + `)`); err != nil {
t.Fatalf("create configs: %v", err)
}
if _, err := db.Exec(`
CREATE TABLE child (
id TEXT PRIMARY KEY,
sentry_instance_id TEXT,
FOREIGN KEY(sentry_instance_id) REFERENCES sentry_configs ON DELETE RESTRICT
)`); err != nil {
t.Fatalf("create child with implicit-PK FK: %v", err)
}
store := &Store{db: db, ro: db}
ok, err := store.hasForeignKey("child", "sentry_instance_id", "sentry_configs", "id", "RESTRICT")
if err != nil {
t.Fatalf("hasForeignKey error: %v", err)
}
if !ok {
t.Error("hasForeignKey = false, want true for an implicit-PK reference (REFERENCES sentry_configs)")
}
}
// TestHasForeignKey_ImplicitCompositePrimaryKeyNoFalseMatch guards the composite
// case: an implicit reference to a table whose PRIMARY KEY spans several columns
// targets the whole key, so it must not be reported as matching a single wanted
// column.
func TestHasForeignKey_ImplicitCompositePrimaryKeyNoFalseMatch(t *testing.T) {
db := openMigrationDB(t)
if _, err := db.Exec(`CREATE TABLE parent (a TEXT, b TEXT, PRIMARY KEY(a, b))`); err != nil {
t.Fatalf("create parent: %v", err)
}
if _, err := db.Exec(`
CREATE TABLE child (
a TEXT,
b TEXT,
FOREIGN KEY(a, b) REFERENCES parent ON DELETE RESTRICT
)`); err != nil {
t.Fatalf("create child with composite implicit-PK FK: %v", err)
}
store := &Store{db: db, ro: db}
ok, err := store.hasForeignKey("child", "a", "parent", "a", "RESTRICT")
if err != nil {
t.Fatalf("hasForeignKey error: %v", err)
}
if ok {
t.Error("hasForeignKey = true, want false: an implicit composite-PK reference must not match a single wanted column")
}
}
+160 -94
View File
@@ -7,11 +7,18 @@ import (
"sync"
)
// MockClient implements Client with in-memory data for E2E tests. A single
// shared instance per process, driven by HTTP control routes mounted in mock
// mode.
// MockClient backs the in-memory Client used by E2E tests. It is instance-aware:
// each Sentry instance has its own dataset keyed by instance ID, so a test can
// prove instance A and instance B return different data. A single shared
// MockClient per process is driven by the HTTP control routes mounted in mock
// mode; the ClientFactory hands each instance a view bound to its ID.
type MockClient struct {
mu sync.RWMutex
mu sync.RWMutex
datasets map[string]*mockDataset // instance ID → dataset
}
// mockDataset is the per-instance seeded state.
type mockDataset struct {
authResult *TestConnectionResult
organizations []SentryOrganization
projects []SentryProject
@@ -22,58 +29,88 @@ type MockClient struct {
getError *APIError
}
// NewMockClient seeds a default-success TestAuth so a fresh config flips to
// NewMockClient returns an empty instance-aware mock. Instances default to a
// successful TestAuth (seeded lazily) so a freshly-created instance flips to
// "Authenticated" without explicit seeding.
func NewMockClient() *MockClient {
return &MockClient{
authResult: &TestConnectionResult{
OK: true,
UserID: "mock-user",
DisplayName: "Mock User",
Email: "mock@example.com",
},
issues: make(map[string]*SentryIssue),
return &MockClient{datasets: make(map[string]*mockDataset)}
}
func newMockDataset() *mockDataset {
return &mockDataset{
authResult: defaultMockAuthResult(),
issues: make(map[string]*SentryIssue),
}
}
// --- Client interface ---
func defaultMockAuthResult() *TestConnectionResult {
return &TestConnectionResult{
OK: true,
UserID: "mock-user",
DisplayName: "Mock User",
Email: "mock@example.com",
}
}
func (m *MockClient) TestAuth(context.Context) (*TestConnectionResult, error) {
// dataset returns the dataset for instanceID, lazily creating it. The caller
// must hold the write lock.
func (m *MockClient) dataset(instanceID string) *mockDataset {
ds, ok := m.datasets[instanceID]
if !ok {
ds = newMockDataset()
m.datasets[instanceID] = ds
}
return ds
}
// --- instance-scoped read operations (used by the per-instance Client view) ---
func (m *MockClient) testAuth(instanceID string) (*TestConnectionResult, error) {
m.mu.RLock()
defer m.mu.RUnlock()
if m.authResult == nil {
return &TestConnectionResult{OK: false, Error: "mock: no auth result configured"}, nil
ds := m.datasets[instanceID]
if ds == nil || ds.authResult == nil {
return defaultMockAuthResult(), nil
}
r := *m.authResult
r := *ds.authResult
return &r, nil
}
func (m *MockClient) ListOrganizations(context.Context) ([]SentryOrganization, error) {
func (m *MockClient) listOrganizations(instanceID string) ([]SentryOrganization, error) {
m.mu.RLock()
defer m.mu.RUnlock()
out := make([]SentryOrganization, len(m.organizations))
copy(out, m.organizations)
ds := m.datasets[instanceID]
if ds == nil {
return nil, nil
}
out := make([]SentryOrganization, len(ds.organizations))
copy(out, ds.organizations)
return out, nil
}
func (m *MockClient) ListProjects(context.Context) ([]SentryProject, error) {
func (m *MockClient) listProjects(instanceID string) ([]SentryProject, error) {
m.mu.RLock()
defer m.mu.RUnlock()
out := make([]SentryProject, len(m.projects))
copy(out, m.projects)
ds := m.datasets[instanceID]
if ds == nil {
return nil, nil
}
out := make([]SentryProject, len(ds.projects))
copy(out, ds.projects)
return out, nil
}
func (m *MockClient) SearchIssues(_ context.Context, filter SearchFilter, _ string) (*SearchResult, error) {
func (m *MockClient) searchIssues(instanceID string, filter SearchFilter) (*SearchResult, error) {
m.mu.RLock()
defer m.mu.RUnlock()
out := make([]SentryIssue, 0, len(m.issueOrder))
for _, id := range m.issueOrder {
issue, ok := m.issues[id]
if !ok {
continue
}
if !mockMatchesFilter(issue, filter) {
ds := m.datasets[instanceID]
if ds == nil {
return &SearchResult{IsLast: true}, nil
}
out := make([]SentryIssue, 0, len(ds.issueOrder))
for _, id := range ds.issueOrder {
issue, ok := ds.issues[id]
if !ok || !mockMatchesFilter(issue, filter) {
continue
}
out = append(out, *issue)
@@ -81,19 +118,23 @@ func (m *MockClient) SearchIssues(_ context.Context, filter SearchFilter, _ stri
return &SearchResult{Issues: out, IsLast: true}, nil
}
func (m *MockClient) GetIssue(_ context.Context, idOrShortID string) (*SentryIssue, error) {
func (m *MockClient) getIssue(instanceID, idOrShortID string) (*SentryIssue, error) {
m.mu.RLock()
defer m.mu.RUnlock()
if m.getError != nil {
err := *m.getError
ds := m.datasets[instanceID]
if ds == nil {
return nil, &APIError{StatusCode: http.StatusNotFound, Message: "issue not found: " + idOrShortID}
}
if ds.getError != nil {
err := *ds.getError
return nil, &err
}
if issue, ok := m.issues[idOrShortID]; ok {
if issue, ok := ds.issues[idOrShortID]; ok {
cp := *issue
return &cp, nil
}
// Fall back to numeric ID lookup so callers can use either form.
for _, i := range m.issues {
for _, i := range ds.issues {
if i.ID == idOrShortID {
cp := *i
return &cp, nil
@@ -102,13 +143,68 @@ func (m *MockClient) GetIssue(_ context.Context, idOrShortID string) (*SentryIss
return nil, &APIError{StatusCode: http.StatusNotFound, Message: "issue not found: " + idOrShortID}
}
// --- setters used by MockController, scoped per instance ---
// SetAuthResult sets the auth result an instance returns from TestAuth.
func (m *MockClient) SetAuthResult(instanceID string, r *TestConnectionResult) {
m.mu.Lock()
defer m.mu.Unlock()
m.dataset(instanceID).authResult = r
}
// SetOrganizations replaces an instance's organization list.
func (m *MockClient) SetOrganizations(instanceID string, organizations []SentryOrganization) {
m.mu.Lock()
defer m.mu.Unlock()
cp := make([]SentryOrganization, len(organizations))
copy(cp, organizations)
m.dataset(instanceID).organizations = cp
}
// SetProjects replaces an instance's project list.
func (m *MockClient) SetProjects(instanceID string, projects []SentryProject) {
m.mu.Lock()
defer m.mu.Unlock()
cp := make([]SentryProject, len(projects))
copy(cp, projects)
m.dataset(instanceID).projects = cp
}
// AddIssue appends an issue to an instance's dataset (idempotent by key).
func (m *MockClient) AddIssue(instanceID string, issue *SentryIssue) {
m.mu.Lock()
defer m.mu.Unlock()
ds := m.dataset(instanceID)
cp := *issue
key := issue.ShortID
if key == "" {
key = issue.ID
}
if _, exists := ds.issues[key]; !exists {
ds.issueOrder = append(ds.issueOrder, key)
}
ds.issues[key] = &cp
}
// SetGetIssueError forces GetIssue on an instance to fail (nil clears it).
func (m *MockClient) SetGetIssueError(instanceID string, err *APIError) {
m.mu.Lock()
defer m.mu.Unlock()
m.dataset(instanceID).getError = err
}
// Reset clears every instance dataset back to empty.
func (m *MockClient) Reset() {
m.mu.Lock()
defer m.mu.Unlock()
m.datasets = make(map[string]*mockDataset)
}
// mockMatchesFilter applies the filter predicates that map to a per-issue
// field, so E2E tests can assert the backend forwarded the filter rather than
// silently returning everything. Deliberately NOT enforced (no per-issue
// analog on SentryIssue): OrgSlug (the mock's project list is one tenant),
// Environment (issues carry no environment in our projection), and StatsPeriod
// (a relative time window, not an issue attribute). The real REST client's
// URL building for those params is covered in rest_client_test.go.
// analog on SentryIssue): OrgSlug, Environment, and StatsPeriod. The real REST
// client's URL building for those params is covered in rest_client_test.go.
func mockMatchesFilter(issue *SentryIssue, f SearchFilter) bool {
if f.ProjectSlug != "" && issue.ProjectSlug != f.ProjectSlug {
return false
@@ -136,71 +232,41 @@ func containsFold(xs []string, target string) bool {
return false
}
// --- Setters used by MockController ---
func (m *MockClient) SetAuthResult(r *TestConnectionResult) {
m.mu.Lock()
defer m.mu.Unlock()
m.authResult = r
// mockInstanceClient is a Client view bound to one instance ID, delegating to
// the shared MockClient's per-instance dataset.
type mockInstanceClient struct {
shared *MockClient
instanceID string
}
func (m *MockClient) SetOrganizations(organizations []SentryOrganization) {
m.mu.Lock()
defer m.mu.Unlock()
cp := make([]SentryOrganization, len(organizations))
copy(cp, organizations)
m.organizations = cp
func (c *mockInstanceClient) TestAuth(context.Context) (*TestConnectionResult, error) {
return c.shared.testAuth(c.instanceID)
}
func (m *MockClient) SetProjects(projects []SentryProject) {
m.mu.Lock()
defer m.mu.Unlock()
cp := make([]SentryProject, len(projects))
copy(cp, projects)
m.projects = cp
func (c *mockInstanceClient) ListOrganizations(context.Context) ([]SentryOrganization, error) {
return c.shared.listOrganizations(c.instanceID)
}
func (m *MockClient) AddIssue(issue *SentryIssue) {
m.mu.Lock()
defer m.mu.Unlock()
cp := *issue
key := issue.ShortID
if key == "" {
key = issue.ID
}
if _, exists := m.issues[key]; !exists {
m.issueOrder = append(m.issueOrder, key)
}
m.issues[key] = &cp
func (c *mockInstanceClient) ListProjects(context.Context) ([]SentryProject, error) {
return c.shared.listProjects(c.instanceID)
}
func (m *MockClient) SetGetIssueError(err *APIError) {
m.mu.Lock()
defer m.mu.Unlock()
m.getError = err
func (c *mockInstanceClient) SearchIssues(_ context.Context, filter SearchFilter, _ string) (*SearchResult, error) {
return c.shared.searchIssues(c.instanceID, filter)
}
// Reset clears every seeded value back to defaults.
func (m *MockClient) Reset() {
m.mu.Lock()
defer m.mu.Unlock()
m.authResult = &TestConnectionResult{
OK: true,
UserID: "mock-user",
DisplayName: "Mock User",
Email: "mock@example.com",
}
m.organizations = nil
m.projects = nil
m.issues = make(map[string]*SentryIssue)
m.issueOrder = nil
m.getError = nil
func (c *mockInstanceClient) GetIssue(_ context.Context, idOrShortID string) (*SentryIssue, error) {
return c.shared.getIssue(c.instanceID, idOrShortID)
}
// MockClientFactory returns a ClientFactory that always hands back the shared
// MockClient regardless of credentials.
// MockClientFactory returns a ClientFactory that hands each instance a view of
// the shared MockClient bound to that instance's ID.
func MockClientFactory(shared *MockClient) ClientFactory {
return func(*SentryConfig, string) Client {
return shared
return func(cfg *SentryConfig, _ string) Client {
instanceID := ""
if cfg != nil {
instanceID = cfg.ID
}
return &mockInstanceClient{shared: shared, instanceID: instanceID}
}
}
@@ -6,9 +6,14 @@ import (
"testing"
)
// mockInstance returns a Client view of the shared mock bound to instanceID.
func mockInstance(m *MockClient, instanceID string) Client {
return MockClientFactory(m)(&SentryConfig{ID: instanceID}, "")
}
func TestMockClient_DefaultsToSuccessfulAuth(t *testing.T) {
m := NewMockClient()
res, err := m.TestAuth(context.Background())
res, err := mockInstance(m, "inst-1").TestAuth(context.Background())
if err != nil || !res.OK {
t.Fatalf("expected OK=true by default, got %+v err=%v", res, err)
}
@@ -16,10 +21,10 @@ func TestMockClient_DefaultsToSuccessfulAuth(t *testing.T) {
func TestMockClient_SearchFiltersByProject(t *testing.T) {
m := NewMockClient()
m.AddIssue(&SentryIssue{ShortID: "FE-1", Title: "Boom", Level: "error", Status: "unresolved", ProjectSlug: "frontend"})
m.AddIssue(&SentryIssue{ShortID: "BE-1", Title: "Crash", Level: "fatal", Status: "unresolved", ProjectSlug: "backend"})
m.AddIssue("inst-1", &SentryIssue{ShortID: "FE-1", Title: "Boom", Level: "error", Status: "unresolved", ProjectSlug: "frontend"})
m.AddIssue("inst-1", &SentryIssue{ShortID: "BE-1", Title: "Crash", Level: "fatal", Status: "unresolved", ProjectSlug: "backend"})
res, err := m.SearchIssues(context.Background(), SearchFilter{
res, err := mockInstance(m, "inst-1").SearchIssues(context.Background(), SearchFilter{
OrgSlug: "acme", ProjectSlug: "frontend",
}, "")
if err != nil {
@@ -32,10 +37,11 @@ func TestMockClient_SearchFiltersByProject(t *testing.T) {
func TestMockClient_SearchFiltersByLevelStatusQuery(t *testing.T) {
m := NewMockClient()
m.AddIssue(&SentryIssue{ShortID: "A-1", Title: "Login failed", Level: "error", Status: "unresolved", ProjectSlug: "fe"})
m.AddIssue(&SentryIssue{ShortID: "A-2", Title: "Signup failed", Level: "warning", Status: "unresolved", ProjectSlug: "fe"})
m.AddIssue(&SentryIssue{ShortID: "A-3", Title: "Login broken", Level: "error", Status: "resolved", ProjectSlug: "fe"})
m.AddIssue("inst-1", &SentryIssue{ShortID: "A-1", Title: "Login failed", Level: "error", Status: "unresolved", ProjectSlug: "fe"})
m.AddIssue("inst-1", &SentryIssue{ShortID: "A-2", Title: "Signup failed", Level: "warning", Status: "unresolved", ProjectSlug: "fe"})
m.AddIssue("inst-1", &SentryIssue{ShortID: "A-3", Title: "Login broken", Level: "error", Status: "resolved", ProjectSlug: "fe"})
client := mockInstance(m, "inst-1")
cases := []struct {
name string
filter SearchFilter
@@ -48,7 +54,7 @@ func TestMockClient_SearchFiltersByLevelStatusQuery(t *testing.T) {
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
res, err := m.SearchIssues(context.Background(), tc.filter, "")
res, err := client.SearchIssues(context.Background(), tc.filter, "")
if err != nil {
t.Fatalf("search: %v", err)
}
@@ -65,42 +71,60 @@ func TestMockClient_SearchFiltersByLevelStatusQuery(t *testing.T) {
func TestMockClient_GetIssueByShortIDOrNumeric(t *testing.T) {
m := NewMockClient()
m.AddIssue(&SentryIssue{ID: "99", ShortID: "PROJ-1", Title: "x"})
if _, err := m.GetIssue(context.Background(), "PROJ-1"); err != nil {
m.AddIssue("inst-1", &SentryIssue{ID: "99", ShortID: "PROJ-1", Title: "x"})
client := mockInstance(m, "inst-1")
if _, err := client.GetIssue(context.Background(), "PROJ-1"); err != nil {
t.Errorf("short id lookup failed: %v", err)
}
if _, err := m.GetIssue(context.Background(), "99"); err != nil {
if _, err := client.GetIssue(context.Background(), "99"); err != nil {
t.Errorf("numeric id lookup failed: %v", err)
}
if _, err := m.GetIssue(context.Background(), "missing"); err == nil {
if _, err := client.GetIssue(context.Background(), "missing"); err == nil {
t.Error("expected error on missing id")
}
}
func TestMockClient_GetIssueErrorOverride(t *testing.T) {
m := NewMockClient()
m.AddIssue(&SentryIssue{ShortID: "PROJ-1"})
m.SetGetIssueError(&APIError{StatusCode: http.StatusInternalServerError, Message: "boom"})
if _, err := m.GetIssue(context.Background(), "PROJ-1"); err == nil {
m.AddIssue("inst-1", &SentryIssue{ShortID: "PROJ-1"})
m.SetGetIssueError("inst-1", &APIError{StatusCode: http.StatusInternalServerError, Message: "boom"})
if _, err := mockInstance(m, "inst-1").GetIssue(context.Background(), "PROJ-1"); err == nil {
t.Error("expected forced error")
}
}
func TestMockClient_Reset(t *testing.T) {
m := NewMockClient()
m.AddIssue(&SentryIssue{ShortID: "PROJ-1"})
m.SetProjects([]SentryProject{{Slug: "fe"}})
m.AddIssue("inst-1", &SentryIssue{ShortID: "PROJ-1"})
m.SetProjects("inst-1", []SentryProject{{Slug: "fe"}})
m.Reset()
res, _ := m.SearchIssues(context.Background(), SearchFilter{OrgSlug: "x"}, "")
client := mockInstance(m, "inst-1")
res, _ := client.SearchIssues(context.Background(), SearchFilter{OrgSlug: "x"}, "")
if len(res.Issues) != 0 {
t.Error("expected issues cleared")
}
projects, _ := m.ListProjects(context.Background())
projects, _ := client.ListProjects(context.Background())
if len(projects) != 0 {
t.Error("expected projects cleared")
}
}
// TestMockClient_InstanceIsolation proves two instances hold independent data.
func TestMockClient_InstanceIsolation(t *testing.T) {
m := NewMockClient()
m.AddIssue("inst-a", &SentryIssue{ShortID: "A-1", Title: "from A", ProjectSlug: "fe"})
m.AddIssue("inst-b", &SentryIssue{ShortID: "B-1", Title: "from B", ProjectSlug: "fe"})
aRes, _ := mockInstance(m, "inst-a").SearchIssues(context.Background(), SearchFilter{OrgSlug: "acme"}, "")
bRes, _ := mockInstance(m, "inst-b").SearchIssues(context.Background(), SearchFilter{OrgSlug: "acme"}, "")
if len(aRes.Issues) != 1 || aRes.Issues[0].ShortID != "A-1" {
t.Errorf("instance A leaked/missing data: %+v", aRes.Issues)
}
if len(bRes.Issues) != 1 || bRes.Issues[0].ShortID != "B-1" {
t.Errorf("instance B leaked/missing data: %+v", bRes.Issues)
}
}
func sameStrings(a, b []string) bool {
if len(a) != len(b) {
return false
+55 -21
View File
@@ -1,7 +1,9 @@
package sentry
import (
"errors"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
@@ -11,7 +13,8 @@ import (
// MockController exposes HTTP endpoints that drive the in-memory MockClient
// during E2E tests. Mounted by RegisterMockRoutes only when the service was
// built with a MockClient.
// built with a MockClient. Every data endpoint is scoped to an instance via the
// `?instanceId=` query param so tests can seed distinct datasets per instance.
type MockController struct {
mock *MockClient
store *Store
@@ -36,14 +39,28 @@ func (c *MockController) RegisterRoutes(router *gin.Engine) {
api.DELETE("/reset", c.reset)
}
func (c *MockController) requireInstanceID(ctx *gin.Context) (string, bool) {
instanceID := strings.TrimSpace(ctx.Query("instanceId"))
if instanceID == "" {
writeErr(ctx, http.StatusBadRequest, "instanceId query parameter required")
return "", false
}
return instanceID, true
}
// setAuthResult seeds an instance's TestAuth response. instanceId is
// optional (unlike the other seed routes): TestConnectionCandidate builds a
// client for a not-yet-persisted config using the empty-string instance ID,
// so pre-save "Test connection" specs must be able to seed that dataset too.
func (c *MockController) setAuthResult(ctx *gin.Context) {
var req TestConnectionResult
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
instanceID := strings.TrimSpace(ctx.Query("instanceId"))
r := req
c.mock.SetAuthResult(&r)
c.mock.SetAuthResult(instanceID, &r)
ctx.JSON(http.StatusOK, gin.H{"set": true})
}
@@ -53,18 +70,19 @@ func (c *MockController) setAuthHealth(ctx *gin.Context) {
Error string `json:"error"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
workspaceID := ctx.Query("workspace_id")
var err error
if workspaceID == "" {
err = c.store.UpdateAuthHealth(ctx.Request.Context(), req.OK, req.Error, time.Now().UTC())
} else {
err = c.store.UpdateAuthHealthForWorkspace(ctx.Request.Context(), workspaceID, req.OK, req.Error, time.Now().UTC())
instanceID, ok := c.requireInstanceID(ctx)
if !ok {
return
}
if err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
if err := c.store.UpdateAuthHealthForInstance(ctx.Request.Context(), instanceID, req.OK, req.Error, time.Now().UTC()); err != nil {
if errors.Is(err, ErrInstanceNotFound) {
writeErr(ctx, http.StatusNotFound, err.Error())
return
}
writeErr(ctx, http.StatusInternalServerError, err.Error())
return
}
ctx.JSON(http.StatusOK, gin.H{"set": true})
@@ -75,10 +93,14 @@ func (c *MockController) setOrganizations(ctx *gin.Context) {
Organizations []SentryOrganization `json:"organizations"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
c.mock.SetOrganizations(req.Organizations)
instanceID, ok := c.requireInstanceID(ctx)
if !ok {
return
}
c.mock.SetOrganizations(instanceID, req.Organizations)
ctx.JSON(http.StatusOK, gin.H{"count": len(req.Organizations)})
}
@@ -87,10 +109,14 @@ func (c *MockController) setProjects(ctx *gin.Context) {
Projects []SentryProject `json:"projects"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
c.mock.SetProjects(req.Projects)
instanceID, ok := c.requireInstanceID(ctx)
if !ok {
return
}
c.mock.SetProjects(instanceID, req.Projects)
ctx.JSON(http.StatusOK, gin.H{"count": len(req.Projects)})
}
@@ -99,11 +125,15 @@ func (c *MockController) addIssues(ctx *gin.Context) {
Issues []SentryIssue `json:"issues"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
instanceID, ok := c.requireInstanceID(ctx)
if !ok {
return
}
for i := range req.Issues {
c.mock.AddIssue(&req.Issues[i])
c.mock.AddIssue(instanceID, &req.Issues[i])
}
ctx.JSON(http.StatusOK, gin.H{"added": len(req.Issues)})
}
@@ -114,13 +144,17 @@ func (c *MockController) setGetIssueError(ctx *gin.Context) {
Message string `json:"message"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
writeBadPayload(ctx)
return
}
instanceID, ok := c.requireInstanceID(ctx)
if !ok {
return
}
if req.StatusCode == 0 {
c.mock.SetGetIssueError(nil)
c.mock.SetGetIssueError(instanceID, nil)
} else {
c.mock.SetGetIssueError(&APIError{StatusCode: req.StatusCode, Message: req.Message})
c.mock.SetGetIssueError(instanceID, &APIError{StatusCode: req.StatusCode, Message: req.Message})
}
ctx.JSON(http.StatusOK, gin.H{"set": true})
}
@@ -0,0 +1,101 @@
package sentry
import (
"net/http"
"testing"
"github.com/gin-gonic/gin"
"github.com/kandev/kandev/internal/common/logger"
)
func TestMockController_SeedRoutesRequireInstanceID(t *testing.T) {
gin.SetMode(gin.TestMode)
router := gin.New()
ctrl := NewMockController(NewMockClient(), newTestStore(t), logger.Default())
ctrl.RegisterRoutes(router)
for _, tc := range []struct {
name string
method string
target string
body string
}{
{
name: "auth health",
method: http.MethodPut,
target: "/api/v1/sentry/mock/auth-health",
body: `{"ok":true}`,
},
{
name: "organizations",
method: http.MethodPost,
target: "/api/v1/sentry/mock/organizations",
body: `{"organizations":[]}`,
},
{
name: "projects",
method: http.MethodPost,
target: "/api/v1/sentry/mock/projects",
body: `{"projects":[]}`,
},
{
name: "issues",
method: http.MethodPost,
target: "/api/v1/sentry/mock/issues",
body: `{"issues":[]}`,
},
{
name: "get issue error",
method: http.MethodPut,
target: "/api/v1/sentry/mock/get-issue-error",
body: `{"statusCode":500,"message":"upstream failed"}`,
},
} {
t.Run(tc.name, func(t *testing.T) {
resp := do(router, tc.method, tc.target, tc.body)
if resp.Code != http.StatusBadRequest {
t.Errorf("status = %d, want 400; body=%s", resp.Code, resp.Body.String())
}
})
}
}
// TestMockController_SetAuthResult_AllowsEmptyInstanceID pins the pre-save
// "Test connection" flow: TestConnectionCandidate builds a client for a
// not-yet-persisted config (empty instance ID), so E2E specs must be able to
// seed that empty-ID dataset via /mock/auth-result without an instanceId.
func TestMockController_SetAuthResult_AllowsEmptyInstanceID(t *testing.T) {
gin.SetMode(gin.TestMode)
router := gin.New()
mock := NewMockClient()
ctrl := NewMockController(mock, newTestStore(t), logger.Default())
ctrl.RegisterRoutes(router)
resp := do(router, http.MethodPut, "/api/v1/sentry/mock/auth-result", `{"ok":false,"error":"invalid token"}`)
if resp.Code != http.StatusOK {
t.Fatalf("status = %d, want 200; body=%s", resp.Code, resp.Body.String())
}
result, err := mock.testAuth("")
if err != nil {
t.Fatalf("test auth: %v", err)
}
if result.OK || result.Error != "invalid token" {
t.Errorf("candidate auth result = %+v, want seeded failure", result)
}
}
// TestMockController_SetAuthHealth_MissingInstance404 pins the P2 fix: seeding
// auth-health for a missing/misspelled instance returns 404 (not {set:true}),
// so E2E seeding fails fast instead of silently succeeding.
func TestMockController_SetAuthHealth_MissingInstance404(t *testing.T) {
gin.SetMode(gin.TestMode)
router := gin.New()
ctrl := NewMockController(NewMockClient(), newTestStore(t), logger.Default())
ctrl.RegisterRoutes(router)
resp := do(router, http.MethodPut, "/api/v1/sentry/mock/auth-health?instanceId=ghost", `{"ok":true}`)
if resp.Code != http.StatusNotFound {
t.Errorf("status = %d, want 404; body=%s", resp.Code, resp.Body.String())
}
}
+79 -27
View File
@@ -1,6 +1,9 @@
// Package sentry implements the Sentry integration (Phase 1: configure + browse).
// A single install-wide configuration, a REST client for projects and issues,
// and the HTTP handlers that expose these capabilities to the frontend.
// Package sentry implements the Sentry integration: multiple named Sentry
// instances per workspace, a REST client for projects and issues, and the HTTP
// handlers that expose these capabilities to the frontend. Each workspace may
// hold several instances (e.g. a SaaS org plus a self-hosted host); every
// instance carries its own URL + token + auth-health, and issue-watches bind to
// exactly one instance.
package sentry
import (
@@ -9,24 +12,40 @@ import (
"github.com/kandev/kandev/internal/integrations/optional"
)
// AuthMethodAuthToken is the only auth method Sentry supports in Phase 1: a
// user or organization auth token sent as `Authorization: Bearer <token>`.
// AuthMethodAuthToken is the only auth method Sentry supports: a user or
// organization auth token sent as `Authorization: Bearer <token>`.
const AuthMethodAuthToken = "auth_token"
// SecretKey is the legacy secret-store key used for the old install-wide Sentry
// token. New workspace-scoped configs use SecretKeyForWorkspace.
// SecretKey is the legacy secret-store key used for the pre-workspace
// install-wide Sentry token. Retained for the boot migration only.
const SecretKey = "sentry:singleton:token"
// SecretKeyForWorkspace returns the workspace-scoped Sentry secret key.
// SecretKeyForWorkspace returns the workspace-scoped Sentry secret key used by
// the (now superseded) one-config-per-workspace model. Retained for the boot
// migration only; live reads/writes use secretKeyForInstance.
func SecretKeyForWorkspace(workspaceID string) string {
return "sentry:" + workspaceID + ":token"
}
// SentryConfig is the workspace-scoped configuration for the Sentry
// integration. The token is stored separately in the encrypted secret store.
// secretKeyForInstance returns the per-instance Sentry secret key. The
// "instance:" segment keeps this namespace disjoint from the legacy
// singleton/workspace keys so a workspace UUID can never collide with an
// instance UUID.
func secretKeyForInstance(instanceID string) string {
return "sentry:instance:" + instanceID + ":token"
}
// SentryConfig is a single named Sentry instance within a workspace. The token
// is stored separately in the encrypted secret store under
// secretKeyForInstance(ID).
type SentryConfig struct {
WorkspaceID string `json:"workspaceId,omitempty" db:"workspace_id"`
AuthMethod string `json:"authMethod" db:"auth_method"`
// ID is the instance UUID, stable for the life of the instance and used as
// the secret key, the client-cache key, and the watch foreign key.
ID string `json:"id" db:"id"`
WorkspaceID string `json:"workspaceId" db:"workspace_id"`
// Name is the user-facing label, required and unique within a workspace.
Name string `json:"name" db:"name"`
AuthMethod string `json:"authMethod" db:"auth_method"`
// URL is the base URL of the Sentry instance (e.g. https://sentry.io for
// SaaS, or a self-hosted host). The REST client appends /api/0. Defaults
// to the sentry.io SaaS endpoint when left blank.
@@ -42,17 +61,36 @@ type SentryConfig struct {
UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
}
// SetConfigRequest is the payload sent by the UI to create or update the
// Sentry configuration. When Secret is empty on update, the existing secret
// is retained; when non-empty it replaces the stored value.
type SetConfigRequest struct {
AuthMethod string `json:"authMethod"`
// CreateConfigRequest is the payload sent by the UI to create a new Sentry
// instance in a workspace.
type CreateConfigRequest struct {
WorkspaceID string `json:"workspaceId"`
Name string `json:"name"`
AuthMethod string `json:"authMethod"`
// URL is the Sentry instance base URL. Optional: blank defaults to the
// sentry.io SaaS endpoint, preserving the prior single-tenant behavior.
// sentry.io SaaS endpoint.
URL string `json:"url"`
Secret string `json:"secret"`
}
// UpdateConfigRequest updates an existing instance identified by its ID. When
// Secret is empty the existing secret is retained; when non-empty it replaces
// the stored value. Name/URL/AuthMethod replace the stored values.
type UpdateConfigRequest struct {
Name string `json:"name"`
AuthMethod string `json:"authMethod"`
URL string `json:"url"`
Secret string `json:"secret"`
}
// CopyConfigRequest copies every instance from SourceWorkspaceID into
// TargetWorkspaceID: fresh instance IDs, secrets copied under the new keys,
// names deduped, no watches carried over.
type CopyConfigRequest struct {
SourceWorkspaceID string `json:"sourceWorkspaceId"`
TargetWorkspaceID string `json:"targetWorkspaceId"`
}
// TestConnectionResult reports what the backend learned when pinging Sentry
// with the supplied credentials.
type TestConnectionResult struct {
@@ -138,10 +176,15 @@ const (
// whenever a new matching issue appears. Mirrors the Linear/Jira shape so the
// orchestrator's WatcherSource pipeline applies uniformly.
type IssueWatch struct {
ID string `json:"id" db:"id"`
WorkspaceID string `json:"workspaceId" db:"workspace_id"`
WorkflowID string `json:"workflowId" db:"workflow_id"`
WorkflowStepID string `json:"workflowStepId" db:"workflow_step_id"`
ID string `json:"id" db:"id"`
WorkspaceID string `json:"workspaceId" db:"workspace_id"`
// SentryInstanceID binds the watch to exactly one Sentry instance. Empty =
// legacy unbound watch (stored as SQL NULL); the poller resolves an unbound
// watch to the workspace's sole instance at poll time. Immutable once set:
// changing instance means creating a new watch.
SentryInstanceID string `json:"sentryInstanceId" db:"-"`
WorkflowID string `json:"workflowId" db:"workflow_id"`
WorkflowStepID string `json:"workflowStepId" db:"workflow_step_id"`
// RepositoryID optionally binds watcher-created tasks to a repository so the
// agent launches in an isolated worktree of that repo instead of a blank
// scratch checkout. Empty = unbound, which preserves the historical
@@ -188,10 +231,14 @@ type IssueWatchTask struct {
// issue matching a watch that has no existing dedup row. The orchestrator
// consumes this to create (and optionally auto-start) a Kandev task.
type NewSentryIssueEvent struct {
IssueWatchID string `json:"issueWatchId"`
WorkspaceID string `json:"workspaceId"`
WorkflowID string `json:"workflowId"`
WorkflowStepID string `json:"workflowStepId"`
IssueWatchID string `json:"issueWatchId"`
WorkspaceID string `json:"workspaceId"`
// SentryInstanceID is the instance the originating watch is bound to (empty
// for a migrated legacy watch resolved to its workspace's sole instance).
// Carried onto the created task's metadata for traceability.
SentryInstanceID string `json:"sentryInstanceId,omitempty"`
WorkflowID string `json:"workflowId"`
WorkflowStepID string `json:"workflowStepId"`
// RepositoryID / BaseBranch carry the watch's optional repository binding so
// the orchestrator source can populate IssueTaskRequest.Repositories without
// reloading the watch row. Empty RepositoryID = unbound (repo-less task).
@@ -209,7 +256,10 @@ type NewSentryIssueEvent struct {
// CreateIssueWatchRequest is the payload for POST /api/v1/sentry/watches/issue.
type CreateIssueWatchRequest struct {
WorkspaceID string `json:"workspaceId"`
WorkspaceID string `json:"workspaceId"`
// SentryInstanceID binds the watch to a Sentry instance. Required and must
// belong to WorkspaceID. Immutable after creation.
SentryInstanceID string `json:"sentryInstanceId"`
WorkflowID string `json:"workflowId"`
WorkflowStepID string `json:"workflowStepId"`
RepositoryID string `json:"repositoryId"`
@@ -225,6 +275,8 @@ type CreateIssueWatchRequest struct {
// UpdateIssueWatchRequest is the payload for PATCH /api/v1/sentry/watches/issue/:id.
// All fields are pointers so the caller can omit ones it doesn't want to change.
// Note: the bound Sentry instance is deliberately absent — instance binding is
// immutable, so changing it means creating a new watch.
type UpdateIssueWatchRequest struct {
WorkflowID *string `json:"workflowId,omitempty"`
WorkflowStepID *string `json:"workflowStepId,omitempty"`
+5 -3
View File
@@ -134,10 +134,12 @@ func (p *Poller) checkIssueWatches(ctx context.Context) {
if !isIssueWatchDue(w, time.Now()) {
continue
}
newIssues, err := p.service.CheckIssueWatch(ctx, w)
instanceID, newIssues, err := p.service.CheckIssueWatch(ctx, w)
if err != nil {
p.logger.Warn("sentry poller: check issue watch failed",
zap.String("watch_id", w.ID), zap.Error(err))
zap.String("watch_id", w.ID),
zap.String("instance_id", instanceID),
zap.Error(err))
continue
}
for _, issue := range newIssues {
@@ -145,7 +147,7 @@ func (p *Poller) checkIssueWatches(ctx context.Context) {
zap.String("watch_id", w.ID),
zap.String("short_id", issue.ShortID),
zap.String("title", issue.Title))
p.service.publishNewSentryIssueEvent(ctx, w, issue)
p.service.publishNewSentryIssueEvent(ctx, w, instanceID, issue)
}
}
}
@@ -105,6 +105,53 @@ func TestPoller_CheckIssueWatches_PublishesNewIssuesOnly(t *testing.T) {
}
}
// TestPoller_CheckIssueWatches_PublishesResolvedInstanceIDForUnboundWatch pins
// the fix for the bug where CheckIssueWatch resolves the instance actually
// polled (via resolveWatchInstanceID) but publishNewSentryIssueEvent read
// w.SentryInstanceID directly, leaving NewSentryIssueEvent.SentryInstanceID
// empty for every unbound legacy watch. The published event must carry the
// resolved instance, not the watch's raw (possibly empty) SentryInstanceID.
func TestPoller_CheckIssueWatches_PublishesResolvedInstanceIDForUnboundWatch(t *testing.T) {
f := newPollerFixture(t)
ctx := context.Background()
cfg := f.saveConfigForWorkspace(t, "ws-1", "tok") // workspace's sole instance
eb := bus.NewMemoryEventBus(logger.Default())
defer eb.Close()
f.svc.SetEventBus(eb)
sub, err := newRecordingSubscriber(eb, 1)
if err != nil {
t.Fatalf("subscribe: %v", err)
}
w := newTestIssueWatch("ws-1") // unbound: SentryInstanceID left empty
if w.SentryInstanceID != "" {
t.Fatalf("expected unbound watch, got instance %q", w.SentryInstanceID)
}
if err := f.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("create watch: %v", err)
}
f.client.searchIssuesFn = func(_ SearchFilter, _ string) (*SearchResult, error) {
return &SearchResult{
Issues: []SentryIssue{{ShortID: "PROJ-1", Title: "first", Permalink: "https://sentry.io/issues/PROJ-1"}},
IsLast: true,
}, nil
}
f.poller.checkIssueWatches(ctx)
<-sub.done
got := sub.snapshot()
if len(got) != 1 {
t.Fatalf("expected 1 published event, got %d", len(got))
}
if got[0].SentryInstanceID != cfg.ID {
t.Errorf("published event SentryInstanceID = %q, want resolved instance %q", got[0].SentryInstanceID, cfg.ID)
}
}
func TestPoller_CheckIssueWatches_SkipsDisabled(t *testing.T) {
f := newPollerFixture(t)
ctx := context.Background()
+41 -23
View File
@@ -30,60 +30,78 @@ func newPollerFixture(t *testing.T) *pollerFixture {
return f
}
// saveConfig persists the default workspace directly via store + secret fakes,
// bypassing Service.SetConfig (and its async probe).
func (f *pollerFixture) saveConfig(t *testing.T, secret string) {
// saveConfig seeds a single instance in a default workspace, bypassing
// Service.CreateInstance (and its async probe). Returns the seeded instance.
func (f *pollerFixture) saveConfig(t *testing.T, secret string) *SentryConfig {
t.Helper()
f.saveConfigForWorkspace(t, "", secret)
return f.saveConfigForWorkspace(t, "ws-1", secret)
}
// saveConfigForWorkspace persists a workspace config directly via store +
// secret fakes, bypassing Service.SetConfig (and its async probe).
func (f *pollerFixture) saveConfigForWorkspace(t *testing.T, workspaceID, secret string) {
// saveConfigForWorkspace seeds one instance (+ secret) in a workspace, so an
// unbound watch in that workspace resolves to it at poll time.
func (f *pollerFixture) saveConfigForWorkspace(t *testing.T, workspaceID, secret string) *SentryConfig {
t.Helper()
ctx := context.Background()
if err := f.store.UpsertConfigForWorkspace(ctx, workspaceID, &SentryConfig{AuthMethod: AuthMethodAuthToken}); err != nil {
cfg := &SentryConfig{WorkspaceID: workspaceID, Name: "Primary", AuthMethod: AuthMethodAuthToken, URL: DefaultSentryURL}
if err := f.store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("save config: %v", err)
}
key := SecretKey
if workspaceID != "" {
key = SecretKeyForWorkspace(workspaceID)
}
if err := f.secrets.Set(ctx, key, "sentry", secret); err != nil {
t.Fatalf("save secret: %v", err)
if secret != "" {
if err := f.secrets.Set(ctx, secretKeyForInstance(cfg.ID), "sentry", secret); err != nil {
t.Fatalf("save secret: %v", err)
}
}
return cfg
}
func TestService_RecordAuthHealth_Success(t *testing.T) {
f := newPollerFixture(t)
f.saveConfig(t, "tok")
cfg := f.saveConfig(t, "tok")
f.client.testAuthFn = func() (*TestConnectionResult, error) {
return &TestConnectionResult{OK: true}, nil
}
f.svc.RecordAuthHealth(context.Background())
cfg, _ := f.store.GetConfig(context.Background())
if cfg == nil || !cfg.LastOk {
t.Errorf("expected LastOk=true, got %+v", cfg)
got, _ := f.store.GetInstance(context.Background(), cfg.ID)
if got == nil || !got.LastOk {
t.Errorf("expected LastOk=true, got %+v", got)
}
}
func TestService_RecordAuthHealth_Failure(t *testing.T) {
f := newPollerFixture(t)
f.saveConfig(t, "tok")
cfg := f.saveConfig(t, "tok")
f.client.testAuthFn = func() (*TestConnectionResult, error) {
return &TestConnectionResult{OK: false, Error: "401 unauthorized"}, nil
}
f.svc.RecordAuthHealth(context.Background())
cfg, _ := f.store.GetConfig(context.Background())
if cfg.LastOk {
got, _ := f.store.GetInstance(context.Background(), cfg.ID)
if got.LastOk {
t.Error("expected LastOk=false")
}
if cfg.LastError != "401 unauthorized" {
t.Errorf("expected error preserved, got %q", cfg.LastError)
if got.LastError != "401 unauthorized" {
t.Errorf("expected error preserved, got %q", got.LastError)
}
}
// TestService_RecordAuthHealth_MultipleInstances verifies the bounded worker
// pool probes every instance, not just one.
func TestService_RecordAuthHealth_MultipleInstances(t *testing.T) {
f := newPollerFixture(t)
a := f.saveConfigForWorkspace(t, "ws-1", "tok-a")
b := f.saveConfigForWorkspace(t, "ws-2", "tok-b")
f.client.testAuthFn = func() (*TestConnectionResult, error) {
return &TestConnectionResult{OK: true}, nil
}
f.svc.RecordAuthHealth(context.Background())
for _, id := range []string{a.ID, b.ID} {
got, _ := f.store.GetInstance(context.Background(), id)
if got == nil || !got.LastOk {
t.Errorf("instance %s not probed: %+v", id, got)
}
}
}
+151 -3
View File
@@ -21,9 +21,9 @@ func MockEnabled() bool {
return os.Getenv(mockEnvVar) == "true"
}
// Provide builds the Sentry service. eventBus is used by the Phase 2 issue
// watcher to publish NewSentryIssueEvent for the orchestrator to consume.
// Cleanup is a no-op — the service holds only in-memory client caches.
// Provide builds the Sentry service. eventBus is used by the issue watcher to
// publish NewSentryIssueEvent for the orchestrator to consume. Cleanup is a
// no-op — the service holds only in-memory client caches.
//
// When KANDEV_MOCK_SENTRY=true, the service is wired to a process-wide
// MockClient and the same instance is exposed via Service.MockClient() so the
@@ -33,7 +33,11 @@ func Provide(writer, reader *sqlx.DB, secrets SecretStore, eventBus bus.EventBus
if err != nil {
return nil, nil, err
}
// Two-stage secret migration mirroring the schema migration lineage:
// singleton→workspace key (kept from PR #1572), then workspace/singleton
// key→per-instance key for the multi-instance model.
migrateLegacySecret(store, secrets, log)
migrateInstanceSecrets(store, secrets, log)
clientFn := DefaultClientFactory
var mock *MockClient
if MockEnabled() {
@@ -50,6 +54,10 @@ func Provide(writer, reader *sqlx.DB, secrets SecretStore, eventBus bus.EventBus
return svc, cleanup, nil
}
// migrateLegacySecret rekeys the pre-workspace install-wide token from the
// singleton secret key to the workspace key that received the migrated config
// row. Retained from the workspace-scoped model so the subsequent per-instance
// rekey has a workspace key to read.
func migrateLegacySecret(store *Store, secrets SecretStore, log *logger.Logger) {
target := store.MigratedFromWorkspace()
if target == "" || secrets == nil {
@@ -74,6 +82,146 @@ func migrateLegacySecret(store *Store, secrets SecretStore, log *logger.Logger)
}
}
// migrateInstanceSecrets rekeys a legacy workspace token only to the earliest
// (oldest by creation) instance in that workspace. The pre-instance schema
// allowed exactly one config per workspace, so that oldest instance is the
// migration's true target; a later second instance must never inherit the
// old token. Eligibility keys off creation order rather than current
// workspace cardinality, so a transient secret-store failure on the oldest
// instance's own rekey can still be retried on a later restart even after a
// second instance has since been added to the same workspace. Completed
// rekeys remove the legacy keys; cardinality guards also make a restart safe
// if a cleanup attempt previously failed.
func migrateInstanceSecrets(store *Store, secrets SecretStore, log *logger.Logger) {
if secrets == nil {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
instances, err := store.ListAllInstances(ctx)
if err != nil {
log.Warn("sentry: list instances for secret migration failed", zap.Error(err))
return
}
oldestPerWorkspace := oldestInstanceIDPerWorkspace(instances)
allowSingleton := len(instances) == 1
for _, inst := range instances {
if oldestPerWorkspace[inst.WorkspaceID] != inst.ID {
continue
}
rekeyInstanceSecret(ctx, secrets, inst, allowSingleton, log)
}
cleanupLegacyInstanceSecretKeys(ctx, secrets, instances, log)
}
// oldestInstanceIDPerWorkspace returns, for each workspace, the ID of its
// earliest-created instance — the only instance ever eligible to inherit that
// workspace's legacy pre-instance secret. Ties (identical CreatedAt) resolve
// by the lexicographically smaller ID so the choice is deterministic.
func oldestInstanceIDPerWorkspace(instances []*SentryConfig) map[string]string {
oldest := make(map[string]*SentryConfig, len(instances))
for _, inst := range instances {
cur, ok := oldest[inst.WorkspaceID]
if !ok || inst.CreatedAt.Before(cur.CreatedAt) ||
(inst.CreatedAt.Equal(cur.CreatedAt) && inst.ID < cur.ID) {
oldest[inst.WorkspaceID] = inst
}
}
out := make(map[string]string, len(oldest))
for workspaceID, inst := range oldest {
out[workspaceID] = inst.ID
}
return out
}
func rekeyInstanceSecret(ctx context.Context, secrets SecretStore, inst *SentryConfig, allowSingleton bool, log *logger.Logger) {
instanceKey := secretKeyForInstance(inst.ID)
exists, err := secrets.Exists(ctx, instanceKey)
if err != nil {
log.Warn("sentry: instance secret existence check failed",
zap.String("instance_id", inst.ID), zap.Error(err))
return
}
if exists {
return
}
value := revealLegacySecret(ctx, secrets, inst.WorkspaceID, allowSingleton)
if value == "" {
return
}
if err := secrets.Set(ctx, instanceKey, "Sentry auth token", value); err != nil {
log.Warn("sentry: instance secret migration failed",
zap.String("instance_id", inst.ID), zap.Error(err))
}
}
// cleanupLegacyInstanceSecretKeys deletes a workspace key only after every
// instance in that workspace has an instance-scoped key. The global singleton
// key is likewise removed only after every instance has been rekeyed.
func cleanupLegacyInstanceSecretKeys(ctx context.Context, secrets SecretStore, instances []*SentryConfig, log *logger.Logger) {
workspaceComplete := make(map[string]bool, len(instances))
allComplete := len(instances) > 0
for _, inst := range instances {
if _, ok := workspaceComplete[inst.WorkspaceID]; !ok {
workspaceComplete[inst.WorkspaceID] = true
}
exists, err := secrets.Exists(ctx, secretKeyForInstance(inst.ID))
if err != nil {
log.Warn("sentry: instance secret existence check failed during legacy cleanup",
zap.String("instance_id", inst.ID), zap.Error(err))
workspaceComplete[inst.WorkspaceID] = false
allComplete = false
continue
}
if !exists {
workspaceComplete[inst.WorkspaceID] = false
allComplete = false
}
}
for workspaceID, complete := range workspaceComplete {
if complete {
deleteLegacySecret(ctx, secrets, SecretKeyForWorkspace(workspaceID), log)
}
}
if allComplete {
deleteLegacySecret(ctx, secrets, SecretKey, log)
}
}
func deleteLegacySecret(ctx context.Context, secrets SecretStore, key string, log *logger.Logger) {
exists, err := secrets.Exists(ctx, key)
if err != nil {
log.Warn("sentry: legacy secret existence check failed", zap.String("secret_key", key), zap.Error(err))
return
}
if !exists {
return
}
if err := secrets.Delete(ctx, key); err != nil {
log.Warn("sentry: legacy secret cleanup failed", zap.String("secret_key", key), zap.Error(err))
}
}
// revealLegacySecret reads the pre-instance token for a workspace. The
// install-wide singleton is considered only when it has one unambiguous
// instance destination; live reads use secretKeyForInstance only.
func revealLegacySecret(ctx context.Context, secrets SecretStore, workspaceID string, allowSingleton bool) string {
keys := []string{SecretKeyForWorkspace(workspaceID)}
if allowSingleton {
keys = append(keys, SecretKey)
}
for _, key := range keys {
exists, err := secrets.Exists(ctx, key)
if err != nil || !exists {
continue
}
if value, err := secrets.Reveal(ctx, key); err == nil && value != "" {
return value
}
}
return ""
}
// RegisterMockRoutes mounts the mock control routes when the service was built
// with a MockClient. No-op otherwise.
func RegisterMockRoutes(router *gin.Engine, svc *Service, log *logger.Logger) {
+353 -261
View File
@@ -33,19 +33,44 @@ type RepositoryLookup interface {
GetRepository(ctx context.Context, id string) (workspaceID, defaultBranch string, ok bool)
}
// Service orchestrates Sentry config storage, the cached client, and the
// browse operations used by the HTTP handlers.
// ErrInvalidConfig is returned when a create/update request fails validation.
var ErrInvalidConfig = errors.New("sentry: invalid configuration")
// ErrInstanceNotFound is returned when an instance ID does not exist or does
// not belong to the requesting workspace. Callers map this to HTTP 404.
var ErrInstanceNotFound = errors.New("sentry: instance not found")
// ErrInstanceRequired is returned when an operation needs an instance ID but
// none was supplied. Callers map this to HTTP 400.
var ErrInstanceRequired = errors.New("sentry: a Sentry instance must be selected")
// ErrDuplicateInstanceName is returned when a create/update would collide with
// an existing instance name in the same workspace. Callers map this to HTTP 409.
var ErrDuplicateInstanceName = errors.New("sentry: an instance with this name already exists in this workspace")
// ErrInstanceInUse is returned when an instance cannot be deleted because issue
// watches still reference it. WatchCount is the number of referencing watches
// (enabled + disabled). Callers map this to HTTP 409.
type ErrInstanceInUse struct{ WatchCount int }
func (e ErrInstanceInUse) Error() string {
return fmt.Sprintf("sentry: instance is referenced by %d issue watch(es)", e.WatchCount)
}
// Service orchestrates Sentry instance storage, the per-instance cached client,
// and the browse operations used by the HTTP handlers.
type Service struct {
store *Store
secrets SecretStore
log *logger.Logger
mu sync.Mutex
clientFn ClientFactory
clients map[string]Client
// clients caches one Client per instance ID.
clients map[string]Client
// clientGen is incremented by invalidateClient each time a cached client
// is discarded. clientFor captures it before I/O and only stores a newly
// built client when the value is unchanged, preventing a stale client from
// clobbering a concurrent invalidation.
// is discarded. clientForInstance captures it before I/O and only stores a
// newly built client when the value is unchanged, preventing a stale client
// from clobbering a concurrent invalidation.
clientGen map[string]uint64
probeHook func()
// mockClient is non-nil only when Provide built the service with a MockClient.
@@ -123,142 +148,214 @@ func (s *Service) Store() *Store {
return s.store
}
// GetConfig returns the singleton config enriched with a HasSecret flag.
func (s *Service) GetConfig(ctx context.Context) (*SentryConfig, error) {
workspaceID, err := s.defaultWorkspaceID()
// ListInstances returns every instance in a workspace, each enriched with a
// HasSecret flag.
func (s *Service) ListInstances(ctx context.Context, workspaceID string) ([]*SentryConfig, error) {
cfgs, err := s.store.ListInstances(ctx, workspaceID)
if err != nil {
return nil, err
}
return s.GetConfigForWorkspace(ctx, workspaceID)
for _, cfg := range cfgs {
cfg.HasSecret = s.secretExists(ctx, cfg.ID)
}
return cfgs, nil
}
// GetConfigForWorkspace returns a workspace config enriched with a HasSecret flag.
func (s *Service) GetConfigForWorkspace(ctx context.Context, workspaceID string) (*SentryConfig, error) {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
// GetInstance returns one instance enriched with a HasSecret flag, or
// ErrInstanceNotFound when the ID does not exist in the workspace.
func (s *Service) GetInstance(ctx context.Context, workspaceID, id string) (*SentryConfig, error) {
cfg, err := s.store.GetInstance(ctx, id)
if err != nil {
return nil, err
}
cfg, err := s.store.GetConfigForWorkspace(ctx, workspaceID)
if err != nil || cfg == nil {
return cfg, err
if cfg == nil || cfg.WorkspaceID != workspaceID {
return nil, ErrInstanceNotFound
}
if s.secrets == nil {
return cfg, nil
}
exists, existsErr := s.secretExists(ctx, workspaceID)
if existsErr != nil {
s.log.Warn("sentry: secret exists check failed", zap.Error(existsErr))
}
cfg.HasSecret = exists
cfg.HasSecret = s.secretExists(ctx, cfg.ID)
return cfg, nil
}
// ErrInvalidConfig is returned by SetConfig when the request fails validation.
var ErrInvalidConfig = errors.New("sentry: invalid configuration")
// SetConfig is upsert. An empty Secret on update keeps the existing token.
func (s *Service) SetConfig(ctx context.Context, req *SetConfigRequest) (*SentryConfig, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
// CreateInstance validates the request, persists a new instance, stores the
// secret, and kicks off an async auth-health probe.
func (s *Service) CreateInstance(ctx context.Context, workspaceID string, req *CreateConfigRequest) (*SentryConfig, error) {
authMethod, instanceURL := req.AuthMethod, req.URL
if err := validateInstanceWrite(req.Name, &authMethod, &instanceURL); err != nil {
return nil, err
}
return s.SetConfigForWorkspace(ctx, workspaceID, req)
}
// SetConfigForWorkspace is upsert for one workspace. An empty Secret on update
// keeps the existing token.
func (s *Service) SetConfigForWorkspace(ctx context.Context, workspaceID string, req *SetConfigRequest) (*SentryConfig, error) {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
if err != nil {
cfg := &SentryConfig{
WorkspaceID: workspaceID,
Name: strings.TrimSpace(req.Name),
AuthMethod: authMethod,
URL: instanceURL,
}
if err := s.store.CreateInstance(ctx, cfg); err != nil {
return nil, err
}
if err := validateConfigRequest(req); err != nil {
return nil, fmt.Errorf("%w: %s", ErrInvalidConfig, err.Error())
}
cfg := &SentryConfig{AuthMethod: req.AuthMethod, URL: req.URL}
if err := s.store.UpsertConfigForWorkspace(ctx, workspaceID, cfg); err != nil {
return nil, fmt.Errorf("upsert sentry config: %w", err)
}
if req.Secret != "" && s.secrets != nil {
if err := s.secrets.Set(ctx, SecretKeyForWorkspace(workspaceID), "Sentry auth token", req.Secret); err != nil {
return nil, fmt.Errorf("store sentry secret: %w", err)
if err := s.secrets.Set(ctx, secretKeyForInstance(cfg.ID), "Sentry auth token", req.Secret); err != nil {
secretErr := fmt.Errorf("store sentry secret: %w", err)
if rollbackErr := s.store.DeleteInstance(context.WithoutCancel(ctx), cfg.ID); rollbackErr != nil {
s.invalidateClient(cfg.ID)
return nil, errors.Join(secretErr, fmt.Errorf("rollback created sentry instance: %w", rollbackErr))
}
s.invalidateClient(cfg.ID)
return nil, secretErr
}
}
s.invalidateClient(workspaceID)
// Probe asynchronously so a slow Sentry doesn't stall the save response.
go func() {
s.RecordAuthHealthForWorkspace(context.Background(), workspaceID)
}()
return s.GetConfigForWorkspace(ctx, workspaceID)
s.invalidateClient(cfg.ID)
go s.RecordAuthHealthForInstance(context.WithoutCancel(ctx), cfg.ID)
return s.GetInstance(ctx, workspaceID, cfg.ID)
}
// DeleteConfig removes both the config row and the stored secret.
func (s *Service) DeleteConfig(ctx context.Context) error {
workspaceID, err := s.defaultWorkspaceID()
// UpdateInstance validates and applies an update to an existing instance. An
// empty Secret keeps the existing token; a non-empty Secret replaces it.
func (s *Service) UpdateInstance(ctx context.Context, workspaceID, id string, req *UpdateConfigRequest) (*SentryConfig, error) {
existing, err := s.store.GetInstance(ctx, id)
if err != nil {
return nil, err
}
if existing == nil || existing.WorkspaceID != workspaceID {
return nil, ErrInstanceNotFound
}
authMethod, instanceURL := req.AuthMethod, req.URL
if err := validateInstanceWrite(req.Name, &authMethod, &instanceURL); err != nil {
return nil, err
}
previous := *existing
updated := previous
updated.Name = strings.TrimSpace(req.Name)
updated.AuthMethod = authMethod
updated.URL = instanceURL
if err := s.store.UpdateInstance(ctx, &updated); err != nil {
return nil, err
}
if req.Secret != "" && s.secrets != nil {
if err := s.secrets.Set(ctx, secretKeyForInstance(id), "Sentry auth token", req.Secret); err != nil {
secretErr := fmt.Errorf("store sentry secret: %w", err)
rollbackCtx := context.WithoutCancel(ctx)
// Re-fetch the persisted row rather than blindly restoring
// `previous`: a second UpdateInstance may have landed on this
// instance between our own row write above and this failed
// secret write. Only roll back when the row still matches
// exactly what this request wrote — otherwise restoring
// `previous` would silently discard that other write.
current, rereadErr := s.store.GetInstance(rollbackCtx, id)
switch {
case rereadErr != nil:
s.log.Warn("sentry: skipped update rollback, could not reload instance",
zap.String("instance_id", id), zap.Error(rereadErr))
case current == nil || !instanceMetadataMatches(current, &updated):
s.log.Warn("sentry: skipped update rollback, instance changed concurrently",
zap.String("instance_id", id))
default:
if rollbackErr := s.store.UpdateInstance(rollbackCtx, &previous); rollbackErr != nil {
s.invalidateClient(id)
return nil, errors.Join(secretErr, fmt.Errorf("rollback sentry instance update: %w", rollbackErr))
}
}
s.invalidateClient(id)
return nil, secretErr
}
}
s.invalidateClient(id)
go s.RecordAuthHealthForInstance(context.WithoutCancel(ctx), id)
return s.GetInstance(ctx, workspaceID, id)
}
// instanceMetadataMatches reports whether current's mutable columns — the
// ones Store.UpdateInstance persists (name, auth_method, url) — still equal
// what this request itself wrote in written. It backs UpdateInstance's
// rollback: a mismatch means a concurrent UpdateInstance landed on the same
// row since, so restoring a stale `previous` snapshot would clobber it. The
// last_* health columns are owned by the async poller and are intentionally
// excluded from the comparison.
func instanceMetadataMatches(current, written *SentryConfig) bool {
return current.Name == written.Name &&
current.AuthMethod == written.AuthMethod &&
current.URL == written.URL
}
// DeleteInstance removes an instance, its secret, and its cached client. It
// refuses deletion when issue watches still reference the instance, returning
// ErrInstanceInUse with the watch count; the DB ON DELETE RESTRICT foreign key
// is the atomic net for a watch created between the count and the delete.
func (s *Service) DeleteInstance(ctx context.Context, workspaceID, id string) error {
existing, err := s.store.GetInstance(ctx, id)
if err != nil {
return err
}
return s.DeleteConfigForWorkspace(ctx, workspaceID)
}
// DeleteConfigForWorkspace removes both the config row and the stored secret.
func (s *Service) DeleteConfigForWorkspace(ctx context.Context, workspaceID string) error {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
if existing == nil || existing.WorkspaceID != workspaceID {
return ErrInstanceNotFound
}
count, err := s.store.CountWatchesForInstance(ctx, id)
if err != nil {
return err
}
if err := s.store.DeleteConfigForWorkspace(ctx, workspaceID); err != nil {
// The workspace's sole instance also backs every unbound (NULL
// sentry_instance_id) watch: resolveWatchInstanceID resolves those to it at
// poll time, so deleting it would strand them. Count them as in-use too.
// When more than one instance remains, unbound watches stay resolvable, so
// they are not attributed to this delete.
instances, err := s.store.ListInstances(ctx, workspaceID)
if err != nil {
return err
}
if len(instances) == 1 {
unbound, err := s.store.CountUnboundIssueWatchesInWorkspace(ctx, workspaceID)
if err != nil {
return err
}
count += unbound
}
if count > 0 {
return ErrInstanceInUse{WatchCount: count}
}
if err := s.store.DeleteInstance(ctx, id); err != nil {
var inUse ErrInstanceInUse
if errors.As(err, &inUse) {
return ErrInstanceInUse{WatchCount: s.recountWatches(ctx, id)}
}
return err
}
if s.secrets != nil {
if err := s.secrets.Delete(ctx, SecretKeyForWorkspace(workspaceID)); err != nil {
if err := s.secrets.Delete(ctx, secretKeyForInstance(id)); err != nil {
s.log.Warn("sentry: secret delete failed", zap.Error(err))
}
}
s.invalidateClient(workspaceID)
s.invalidateClient(id)
return nil
}
// TestConnection validates credentials either from a fresh SetConfigRequest
// (before persisting) or from the stored config (after saving).
func (s *Service) TestConnection(ctx context.Context, req *SetConfigRequest) (*TestConnectionResult, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
// recountWatches returns the current watch count for an instance, defaulting to
// 1 when the recount itself fails so the caller still reports "in use".
func (s *Service) recountWatches(ctx context.Context, instanceID string) int {
if n, err := s.store.CountWatchesForInstance(ctx, instanceID); err == nil {
return n
}
return s.TestConnectionForWorkspace(ctx, workspaceID, req)
return 1
}
// TestConnectionForWorkspace validates credentials for one workspace.
func (s *Service) TestConnectionForWorkspace(ctx context.Context, workspaceID string, req *SetConfigRequest) (*TestConnectionResult, error) {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
if err != nil {
// TestConnectionCandidate validates arbitrary credentials supplied by the UI
// before they are persisted (the pre-save "Test connection" flow).
func (s *Service) TestConnectionCandidate(ctx context.Context, req *CreateConfigRequest) (*TestConnectionResult, error) {
authMethod, instanceURL := req.AuthMethod, req.URL
if err := prepareInstanceCredentials(&authMethod, &instanceURL); err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
}
cfg, secret, err := s.resolveCredentials(ctx, workspaceID, req)
if err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
if req.Secret == "" {
return &TestConnectionResult{OK: false, Error: "no auth token provided — paste one to test"}, nil
}
client := s.clientFn(cfg, secret)
return client.TestAuth(ctx)
cfg := &SentryConfig{AuthMethod: authMethod, URL: instanceURL}
return s.clientFn(cfg, req.Secret).TestAuth(ctx)
}
// ProbeAuth validates the stored credentials.
func (s *Service) ProbeAuth(ctx context.Context) (*TestConnectionResult, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
// TestInstance validates the stored credentials of an existing instance after
// resolving and ownership-checking it against the workspace.
func (s *Service) TestInstance(ctx context.Context, workspaceID, instanceID string) (*TestConnectionResult, error) {
if _, err := s.requireInstance(ctx, workspaceID, instanceID); err != nil {
return nil, err
}
return s.ProbeAuthForWorkspace(ctx, workspaceID)
}
// ProbeAuthForWorkspace validates the stored credentials for one workspace.
func (s *Service) ProbeAuthForWorkspace(ctx context.Context, workspaceID string) (*TestConnectionResult, error) {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
if err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
}
client, err := s.clientFor(ctx, workspaceID)
client, err := s.clientForInstance(ctx, instanceID)
if err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
}
@@ -271,42 +368,60 @@ const authProbeTimeout = 15 * time.Second
// authHealthWriteTimeout bounds the DB write that persists the probe outcome.
const authHealthWriteTimeout = 5 * time.Second
// SetProbeHook installs a callback fired at the end of each RecordAuthHealth
// call. Production code never sets this; tests use it to synchronise on probe
// completion without sleep-polling.
// authHealthPoolSize bounds concurrent per-instance probes so one instance on a
// 15s timeout cannot stall the whole poll while many instances are configured.
const authHealthPoolSize = 6
// SetProbeHook installs a callback fired at the end of each RecordAuthHealth /
// RecordAuthHealthForInstance call. Production code never sets this; tests use
// it to synchronise on probe completion without sleep-polling.
func (s *Service) SetProbeHook(fn func()) {
s.mu.Lock()
defer s.mu.Unlock()
s.probeHook = fn
}
// RecordAuthHealth probes credentials and writes the outcome onto the row.
// RecordAuthHealth probes every instance's credentials through a bounded worker
// pool and writes each outcome onto its row.
func (s *Service) RecordAuthHealth(ctx context.Context) {
workspaceIDs, err := s.store.ListConfigWorkspaceIDs(ctx)
instances, err := s.store.ListAllInstances(ctx)
if err != nil {
s.log.Warn("sentry: list config workspaces failed", zap.Error(err))
s.log.Warn("sentry: list instances for auth health failed", zap.Error(err))
return
}
if len(workspaceIDs) == 0 {
if len(instances) == 0 {
s.fireProbeHook()
return
}
for _, workspaceID := range workspaceIDs {
s.RecordAuthHealthForWorkspace(ctx, workspaceID)
sem := make(chan struct{}, authHealthPoolSize)
var wg sync.WaitGroup
for _, inst := range instances {
if ctx.Err() != nil {
break
}
wg.Add(1)
sem <- struct{}{}
go func(id string) {
defer wg.Done()
defer func() { <-sem }()
s.recordAuthHealthForInstance(ctx, id)
}(inst.ID)
}
wg.Wait()
s.fireProbeHook()
}
// RecordAuthHealthForWorkspace probes credentials and writes the outcome onto
// one workspace row.
func (s *Service) RecordAuthHealthForWorkspace(ctx context.Context, workspaceID string) {
workspaceID, normalizeErr := s.normalizeWorkspaceID(workspaceID)
if normalizeErr != nil {
s.log.Warn("sentry: resolve workspace for auth health failed", zap.Error(normalizeErr))
return
}
// RecordAuthHealthForInstance probes one instance's credentials, writes the
// outcome, and fires the probe hook.
func (s *Service) RecordAuthHealthForInstance(ctx context.Context, instanceID string) {
s.recordAuthHealthForInstance(ctx, instanceID)
s.fireProbeHook()
}
func (s *Service) recordAuthHealthForInstance(ctx context.Context, instanceID string) {
probeCtx, cancel := context.WithTimeout(ctx, authProbeTimeout)
defer cancel()
res, err := s.ProbeAuthForWorkspace(probeCtx, workspaceID)
res, err := s.probeInstance(probeCtx, instanceID)
ok := err == nil && res != nil && res.OK
errMsg := ""
switch {
@@ -319,10 +434,20 @@ func (s *Service) RecordAuthHealthForWorkspace(ctx context.Context, workspaceID
// still record the failure.
writeCtx, writeCancel := context.WithTimeout(context.Background(), authHealthWriteTimeout)
defer writeCancel()
if updateErr := s.store.UpdateAuthHealthForWorkspace(writeCtx, workspaceID, ok, errMsg, time.Now().UTC()); updateErr != nil {
if updateErr := s.store.UpdateAuthHealthForInstance(writeCtx, instanceID, ok, errMsg, time.Now().UTC()); updateErr != nil {
s.log.Warn("sentry: update auth health failed", zap.Error(updateErr))
}
s.fireProbeHook()
}
// probeInstance builds the instance client and runs a TestAuth probe. A build
// failure (e.g. no secret) is reported as a non-OK result, not an error, so the
// health row records the cause.
func (s *Service) probeInstance(ctx context.Context, instanceID string) (*TestConnectionResult, error) {
client, err := s.clientForInstance(ctx, instanceID)
if err != nil {
return &TestConnectionResult{OK: false, Error: err.Error()}, nil
}
return client.TestAuth(ctx)
}
func (s *Service) fireProbeHook() {
@@ -334,79 +459,78 @@ func (s *Service) fireProbeHook() {
}
}
// ListOrganizations returns the organizations the stored token can access.
func (s *Service) ListOrganizations(ctx context.Context) ([]SentryOrganization, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return nil, err
}
client, err := s.clientFor(ctx, workspaceID)
// ListOrganizations returns the organizations the instance's token can access.
func (s *Service) ListOrganizations(ctx context.Context, workspaceID, instanceID string) ([]SentryOrganization, error) {
client, err := s.browseClient(ctx, workspaceID, instanceID)
if err != nil {
return nil, err
}
return client.ListOrganizations(ctx)
}
// ListProjects returns the projects the stored token can access.
func (s *Service) ListProjects(ctx context.Context) ([]SentryProject, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return nil, err
}
client, err := s.clientFor(ctx, workspaceID)
// ListProjects returns the projects the instance's token can access.
func (s *Service) ListProjects(ctx context.Context, workspaceID, instanceID string) ([]SentryProject, error) {
client, err := s.browseClient(ctx, workspaceID, instanceID)
if err != nil {
return nil, err
}
return client.ListProjects(ctx)
}
// SearchIssues runs a filtered search. The caller supplies the org/project to
// search — there is no install-wide default to fall back on.
func (s *Service) SearchIssues(ctx context.Context, filter SearchFilter, cursor string) (*SearchResult, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return nil, err
}
return s.SearchIssuesForWorkspace(ctx, workspaceID, filter, cursor)
}
// SearchIssuesForWorkspace runs a filtered search against one workspace's client.
func (s *Service) SearchIssuesForWorkspace(ctx context.Context, workspaceID string, filter SearchFilter, cursor string) (*SearchResult, error) {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
if err != nil {
return nil, err
}
client, err := s.clientFor(ctx, workspaceID)
// SearchIssues runs a filtered search against one instance's client.
func (s *Service) SearchIssues(ctx context.Context, workspaceID, instanceID string, filter SearchFilter, cursor string) (*SearchResult, error) {
client, err := s.browseClient(ctx, workspaceID, instanceID)
if err != nil {
return nil, err
}
return client.SearchIssues(ctx, filter, cursor)
}
// GetIssue loads a single issue by short ID or numeric ID.
func (s *Service) GetIssue(ctx context.Context, idOrShortID string) (*SentryIssue, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return nil, err
}
client, err := s.clientFor(ctx, workspaceID)
// GetIssue loads a single issue by short ID or numeric ID from one instance.
func (s *Service) GetIssue(ctx context.Context, workspaceID, instanceID, idOrShortID string) (*SentryIssue, error) {
client, err := s.browseClient(ctx, workspaceID, instanceID)
if err != nil {
return nil, err
}
return client.GetIssue(ctx, idOrShortID)
}
// clientFor returns the cached client, creating it if needed.
// It captures the generation counter before releasing the lock for I/O so
// that a concurrent invalidateClient call during the build window is not
// silently overwritten: if the counter changed the freshly built client is
// returned to the caller without being cached, and the next call rebuilds
// with the updated config.
func (s *Service) clientFor(ctx context.Context, workspaceID string) (Client, error) {
workspaceID, err := s.normalizeWorkspaceID(workspaceID)
// browseClient resolves and ownership-checks the instance, then returns its
// cached client. Returns ErrInstanceRequired / ErrInstanceNotFound before any
// client is built.
func (s *Service) browseClient(ctx context.Context, workspaceID, instanceID string) (Client, error) {
if _, err := s.requireInstance(ctx, workspaceID, instanceID); err != nil {
return nil, err
}
return s.clientForInstance(ctx, instanceID)
}
// requireInstance resolves an instance and asserts it belongs to the workspace.
// Returns ErrInstanceRequired for a blank ID and ErrInstanceNotFound when the
// instance is missing or owned by another workspace.
func (s *Service) requireInstance(ctx context.Context, workspaceID, instanceID string) (*SentryConfig, error) {
if instanceID == "" {
return nil, ErrInstanceRequired
}
cfg, err := s.store.GetInstance(ctx, instanceID)
if err != nil {
return nil, err
}
if cfg == nil || cfg.WorkspaceID != workspaceID {
return nil, ErrInstanceNotFound
}
return cfg, nil
}
// clientForInstance returns the cached client for an instance, creating it if
// needed. It captures the generation counter before releasing the lock for I/O
// so a concurrent invalidateClient during the build window is not silently
// overwritten: if the counter changed the freshly built client is returned to
// the caller without being cached, and the next call rebuilds.
func (s *Service) clientForInstance(ctx context.Context, instanceID string) (Client, error) {
if instanceID == "" {
return nil, ErrNotConfigured
}
s.mu.Lock()
if s.clients == nil {
s.clients = make(map[string]Client)
@@ -414,15 +538,14 @@ func (s *Service) clientFor(ctx context.Context, workspaceID string) (Client, er
if s.clientGen == nil {
s.clientGen = make(map[string]uint64)
}
if s.clients[workspaceID] != nil {
c := s.clients[workspaceID]
if c := s.clients[instanceID]; c != nil {
s.mu.Unlock()
return c, nil
}
gen := s.clientGen[workspaceID]
gen := s.clientGen[instanceID]
s.mu.Unlock()
cfg, err := s.store.GetConfigForWorkspace(ctx, workspaceID)
cfg, err := s.store.GetInstance(ctx, instanceID)
if err != nil {
return nil, err
}
@@ -431,13 +554,14 @@ func (s *Service) clientFor(ctx context.Context, workspaceID string) (Client, er
}
secret := ""
if s.secrets != nil {
secret, err = s.revealSecret(ctx, workspaceID)
if err != nil {
return nil, fmt.Errorf("read sentry secret: %w", err)
revealed, ok, revealErr := s.revealInstanceSecret(ctx, instanceID)
if revealErr != nil {
return nil, fmt.Errorf("read sentry secret: %w", revealErr)
}
if secret == "" {
if !ok {
return nil, ErrNotConfigured
}
secret = revealed
}
client := s.clientFn(cfg, secret)
s.mu.Lock()
@@ -448,129 +572,97 @@ func (s *Service) clientFor(ctx context.Context, workspaceID string) (Client, er
if s.clientGen == nil {
s.clientGen = make(map[string]uint64)
}
if s.clients[workspaceID] != nil {
if c := s.clients[instanceID]; c != nil {
// Another goroutine already cached a client; use that one.
return s.clients[workspaceID], nil
return c, nil
}
if s.clientGen[workspaceID] != gen {
if s.clientGen[instanceID] != gen {
// invalidateClient ran while we were doing I/O — the config/secret we
// read is now stale. Return the client to the caller for this call only;
// the next call will rebuild with fresh credentials.
// the next call rebuilds with fresh credentials.
return client, nil
}
s.clients[workspaceID] = client
s.clients[instanceID] = client
return client, nil
}
// invalidateClient drops the cached client so the next request rebuilds it.
// The generation counter is incremented so a concurrent clientFor build does
// not restore a client built from the now-stale config.
func (s *Service) invalidateClient(workspaceID string) {
// invalidateClient drops the cached client for an instance so the next request
// rebuilds it. The generation counter is incremented so a concurrent
// clientForInstance build does not restore a client from the now-stale config.
func (s *Service) invalidateClient(instanceID string) {
s.mu.Lock()
if s.clients != nil {
delete(s.clients, workspaceID)
delete(s.clients, instanceID)
}
if s.clientGen == nil {
s.clientGen = make(map[string]uint64)
}
s.clientGen[workspaceID]++
s.clientGen[instanceID]++
s.mu.Unlock()
}
// resolveCredentials picks credentials for a test: inline if the request
// carries a secret, otherwise the stored secret.
func (s *Service) resolveCredentials(ctx context.Context, workspaceID string, req *SetConfigRequest) (*SentryConfig, string, error) {
cfg := &SentryConfig{AuthMethod: req.AuthMethod, URL: normalizeSentryURL(req.URL)}
if req.Secret != "" {
if cfg.URL == "" {
cfg.URL = DefaultSentryURL
}
return cfg, req.Secret, nil
}
// secretExists reports whether an instance has a stored token, distinguishing
// absence from a backend error (logged, treated as absent).
func (s *Service) secretExists(ctx context.Context, instanceID string) bool {
if s.secrets == nil {
return nil, "", errors.New("no secret store configured")
return false
}
secret, err := s.revealSecret(ctx, workspaceID)
exists, err := s.secrets.Exists(ctx, secretKeyForInstance(instanceID))
if err != nil {
s.log.Warn("sentry: secret reveal failed", zap.Error(err))
return nil, "", fmt.Errorf("read sentry secret: %w", err)
s.log.Warn("sentry: secret exists check failed", zap.Error(err))
return false
}
if secret == "" {
return nil, "", errors.New("no auth token stored — paste one to test")
}
stored, storeErr := s.store.GetConfigForWorkspace(ctx, workspaceID)
if storeErr != nil {
s.log.Warn("sentry: load stored config for credential resolution failed", zap.Error(storeErr))
}
if stored != nil {
if cfg.AuthMethod == "" {
cfg.AuthMethod = stored.AuthMethod
}
if cfg.URL == "" {
cfg.URL = stored.URL
}
}
if cfg.URL == "" {
cfg.URL = DefaultSentryURL
}
return cfg, secret, nil
return exists
}
func (s *Service) defaultWorkspaceID() (string, error) {
return s.store.defaultWorkspaceID()
}
func (s *Service) normalizeWorkspaceID(workspaceID string) (string, error) {
if workspaceID != "" {
return workspaceID, nil
}
return s.defaultWorkspaceID()
}
func (s *Service) secretExists(ctx context.Context, workspaceID string) (bool, error) {
// revealInstanceSecret returns the stored token for an instance. ok is false
// (with a nil error) when no token is stored, so callers can map that to
// ErrNotConfigured without conflating it with a backend failure.
func (s *Service) revealInstanceSecret(ctx context.Context, instanceID string) (string, bool, error) {
if s.secrets == nil {
return false, nil
}
exists, err := s.secrets.Exists(ctx, SecretKeyForWorkspace(workspaceID))
if err != nil || exists {
return exists, err
}
return s.secrets.Exists(ctx, SecretKey)
}
func (s *Service) revealSecret(ctx context.Context, workspaceID string) (string, error) {
if s.secrets == nil {
return "", nil
}
secret, err := s.secrets.Reveal(ctx, SecretKeyForWorkspace(workspaceID))
if err == nil && secret != "" {
return secret, nil
}
legacy, legacyErr := s.secrets.Reveal(ctx, SecretKey)
if legacyErr == nil && legacy != "" {
return legacy, nil
return "", false, nil
}
exists, err := s.secrets.Exists(ctx, secretKeyForInstance(instanceID))
if err != nil {
return "", err
return "", false, err
}
return "", legacyErr
if !exists {
return "", false, nil
}
secret, err := s.secrets.Reveal(ctx, secretKeyForInstance(instanceID))
if err != nil {
return "", false, err
}
return secret, secret != "", nil
}
// validateConfigRequest normalizes and validates a config request in place: it
// defaults a blank auth method and instance URL, rejects unknown auth methods,
// and rejects URLs the HTTP client could not use (see validateSentryURL).
func validateConfigRequest(req *SetConfigRequest) error {
if req.AuthMethod == "" {
req.AuthMethod = AuthMethodAuthToken
// validateInstanceWrite validates a create/update request: a non-empty name and
// a usable auth method + URL (both normalized in place). All failures are
// wrapped in ErrInvalidConfig so the handler maps them to HTTP 400.
func validateInstanceWrite(name string, authMethod, instanceURL *string) error {
if strings.TrimSpace(name) == "" {
return fmt.Errorf("%w: name is required", ErrInvalidConfig)
}
if req.AuthMethod != AuthMethodAuthToken {
return fmt.Errorf("unknown auth method: %q", req.AuthMethod)
if err := prepareInstanceCredentials(authMethod, instanceURL); err != nil {
return fmt.Errorf("%w: %s", ErrInvalidConfig, err.Error())
}
req.URL = normalizeSentryURL(req.URL)
if req.URL == "" {
req.URL = DefaultSentryURL
return nil
}
// prepareInstanceCredentials defaults a blank auth method + URL and validates
// them in place, returning a plain error (callers wrap or surface it).
func prepareInstanceCredentials(authMethod, instanceURL *string) error {
if *authMethod == "" {
*authMethod = AuthMethodAuthToken
}
return validateSentryURL(req.URL)
if *authMethod != AuthMethodAuthToken {
return fmt.Errorf("unknown auth method: %q", *authMethod)
}
*instanceURL = normalizeSentryURL(*instanceURL)
if *instanceURL == "" {
*instanceURL = DefaultSentryURL
}
return validateSentryURL(*instanceURL)
}
// normalizeSentryURL trims whitespace and trailing slashes and prepends
@@ -32,12 +32,19 @@ func (s *Service) CreateIssueWatch(ctx context.Context, req *CreateIssueWatchReq
if err := validateIssueWatchCreate(req); err != nil {
return nil, err
}
if strings.TrimSpace(req.SentryInstanceID) == "" {
return nil, fmt.Errorf("%w: sentryInstanceId is required", ErrInstanceRequired)
}
if _, err := s.requireInstance(ctx, req.WorkspaceID, req.SentryInstanceID); err != nil {
return nil, err
}
repositoryID, baseBranch, err := s.resolveRepositoryBinding(ctx, req.WorkspaceID, req.RepositoryID, req.BaseBranch)
if err != nil {
return nil, err
}
w := &IssueWatch{
WorkspaceID: req.WorkspaceID,
SentryInstanceID: req.SentryInstanceID,
WorkflowID: req.WorkflowID,
WorkflowStepID: req.WorkflowStepID,
RepositoryID: repositoryID,
@@ -172,19 +179,27 @@ func (s *Service) ResetIssueWatch(ctx context.Context, watchID string) (int, err
return res.TasksDeleted, err
}
// CheckIssueWatch runs the watch's filter once and returns the issues that
// haven't been turned into tasks yet. last_polled_at is stamped regardless of
// whether the search succeeded — a failing search still counts as "we tried".
// CheckIssueWatch runs the watch's filter once and returns the Sentry
// instance actually polled (resolved via resolveWatchInstanceID — never
// w.SentryInstanceID directly, which is empty for an unbound legacy watch)
// plus the issues that haven't been turned into tasks yet. last_polled_at is
// stamped regardless of whether the search succeeded — a failing search
// still counts as "we tried".
//
// Concurrency note: callers must tolerate being handed an issue that gets
// stolen by a concurrent reserver. The duplicate publish is harmless — the
// second reserver loses the INSERT OR IGNORE race in the orchestrator and
// bails. Same pattern as the Linear / Jira watchers.
func (s *Service) CheckIssueWatch(ctx context.Context, w *IssueWatch) ([]*SentryIssue, error) {
func (s *Service) CheckIssueWatch(ctx context.Context, w *IssueWatch) (string, []*SentryIssue, error) {
defer s.stampWatchLastPolled(w.ID)
client, err := s.clientFor(ctx, w.WorkspaceID)
instanceID, err := s.resolveWatchInstanceID(ctx, w)
if err != nil {
return nil, err
s.stampWatchError(w.ID, err.Error())
return "", nil, err
}
client, err := s.clientForInstance(ctx, instanceID)
if err != nil {
return instanceID, nil, err
}
// Intentionally reads only the first page per tick (bounded-page-per-tick
// invariant, matching the Linear/Jira watchers). SearchIssues sorts results
@@ -192,14 +207,14 @@ func (s *Service) CheckIssueWatch(ctx context.Context, w *IssueWatch) ([]*Sentry
// on page one and are not missed by the single-page read.
res, err := client.SearchIssues(ctx, w.Filter, "")
if err != nil {
return nil, err
return instanceID, nil, err
}
seen, err := s.store.ListSeenIssueShortIDs(ctx, w.ID)
if err != nil {
// Skip this tick rather than treat a failed dedup read as "nothing seen":
// a nil map would let the whole page (up to 100 issues) publish as events.
// The next tick retries with a working dedup set.
return nil, fmt.Errorf("load dedup set for watch %s: %w", w.ID, err)
return instanceID, nil, fmt.Errorf("load dedup set for watch %s: %w", w.ID, err)
}
out := make([]*SentryIssue, 0, len(res.Issues))
for i := range res.Issues {
@@ -209,7 +224,8 @@ func (s *Service) CheckIssueWatch(ctx context.Context, w *IssueWatch) ([]*Sentry
}
out = append(out, &issue)
}
return out, nil
s.clearWatchError(w.ID)
return instanceID, out, nil
}
// stampWatchLastPolled writes the current timestamp using a fresh background
@@ -224,6 +240,75 @@ func (s *Service) stampWatchLastPolled(watchID string) {
}
}
// resolveWatchInstanceID picks the Sentry instance a watch should poll. A
// bound watch uses its stored instance. An unbound (migrated legacy) watch
// resolves to the workspace's sole instance per ADR-0030, regardless of that
// instance's health — matching the pre-existing single-instance contract.
// When the workspace has several instances, the choice is otherwise
// ambiguous, so it narrows to the healthy subset: a single healthy instance
// wins, and zero or several healthy instances still cannot run unambiguously.
func (s *Service) resolveWatchInstanceID(ctx context.Context, w *IssueWatch) (string, error) {
if w.SentryInstanceID != "" {
return w.SentryInstanceID, nil
}
instances, err := s.store.ListInstances(ctx, w.WorkspaceID)
if err != nil {
return "", err
}
switch len(instances) {
case 0:
return "", fmt.Errorf("%w: watch is unbound and its workspace has no Sentry instance", ErrNotConfigured)
case 1:
return instances[0].ID, nil
default:
return resolveAmbiguousWatchInstance(instances)
}
}
// resolveAmbiguousWatchInstance breaks a multi-instance tie by preferring the
// workspace's sole healthy instance; zero or several healthy instances remain
// ambiguous and require an explicit binding.
func resolveAmbiguousWatchInstance(instances []*SentryConfig) (string, error) {
healthyInstances := make([]*SentryConfig, 0, len(instances))
for _, instance := range instances {
if instance.LastOk {
healthyInstances = append(healthyInstances, instance)
}
}
switch len(healthyInstances) {
case 1:
return healthyInstances[0].ID, nil
case 0:
return "", fmt.Errorf("%w: watch is unbound and its workspace has no healthy Sentry instance", ErrNotConfigured)
default:
return "", fmt.Errorf("%w: watch is unbound and its workspace has %d healthy Sentry instances; bind one to the watch", ErrInvalidConfig, len(healthyInstances))
}
}
// stampWatchError records a non-fatal poll-time failure cause on the watch row
// without disabling it, using a detached short-deadline context so a cancelled
// caller ctx does not drop the record.
func (s *Service) stampWatchError(watchID, cause string) {
ctx, cancel := context.WithTimeout(context.Background(), authHealthWriteTimeout)
defer cancel()
if err := s.store.StampIssueWatchError(ctx, watchID, cause); err != nil {
s.log.Warn("sentry: stamp watch error failed",
zap.String("watch_id", watchID), zap.Error(err))
}
}
// clearWatchError removes stale poll error state using a detached context so a
// successful check still clears it if the caller context is subsequently
// cancelled.
func (s *Service) clearWatchError(watchID string) {
ctx, cancel := context.WithTimeout(context.Background(), authHealthWriteTimeout)
defer cancel()
if err := s.store.ClearIssueWatchError(ctx, watchID); err != nil {
s.log.Warn("sentry: clear watch error failed",
zap.String("watch_id", watchID), zap.Error(err))
}
}
// ReserveIssueWatchTask exposes the dedup store API to the orchestrator's
// WatcherSource implementation.
func (s *Service) ReserveIssueWatchTask(ctx context.Context, watchID, shortID, issueURL string) (bool, error) {
@@ -243,9 +328,11 @@ func (s *Service) ReleaseIssueWatchTask(ctx context.Context, watchID, shortID st
}
// publishNewSentryIssueEvent emits the orchestrator-facing event for one
// freshly-observed issue. No-op when the event bus is not wired (tests, early
// boot).
func (s *Service) publishNewSentryIssueEvent(ctx context.Context, w *IssueWatch, issue *SentryIssue) {
// freshly-observed issue. instanceID must be the instance actually polled
// (CheckIssueWatch's resolved return value) rather than w.SentryInstanceID,
// which is empty for an unbound legacy watch. No-op when the event bus is not
// wired (tests, early boot).
func (s *Service) publishNewSentryIssueEvent(ctx context.Context, w *IssueWatch, instanceID string, issue *SentryIssue) {
s.mu.Lock()
eb := s.eventBus
s.mu.Unlock()
@@ -255,6 +342,7 @@ func (s *Service) publishNewSentryIssueEvent(ctx context.Context, w *IssueWatch,
evt := bus.NewEvent(events.SentryNewIssue, "sentry", &NewSentryIssueEvent{
IssueWatchID: w.ID,
WorkspaceID: w.WorkspaceID,
SentryInstanceID: instanceID,
WorkflowID: w.WorkflowID,
WorkflowStepID: w.WorkflowStepID,
RepositoryID: w.RepositoryID,
@@ -19,19 +19,20 @@ func (f fakeRepoLookup) GetRepository(_ context.Context, _ string) (string, stri
func TestService_CreateIssueWatch_RepositoryBinding(t *testing.T) {
ctx := context.Background()
baseReq := func() *CreateIssueWatchRequest {
baseReq := func(instID string) *CreateIssueWatchRequest {
return &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"},
WorkspaceID: "ws-1",
SentryInstanceID: instID,
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"},
}
}
t.Run("default branch filled from repo", func(t *testing.T) {
f := newSvcFixture(t)
f.svc.SetRepositoryLookup(fakeRepoLookup{workspaceID: "ws-1", defaultBranch: "main", ok: true})
req := baseReq()
req := baseReq(f.ensureInstance(t, "ws-1"))
req.RepositoryID = "repo-1"
w, err := f.svc.CreateIssueWatch(ctx, req)
if err != nil {
@@ -45,7 +46,7 @@ func TestService_CreateIssueWatch_RepositoryBinding(t *testing.T) {
t.Run("explicit branch preserved", func(t *testing.T) {
f := newSvcFixture(t)
f.svc.SetRepositoryLookup(fakeRepoLookup{workspaceID: "ws-1", defaultBranch: "main", ok: true})
req := baseReq()
req := baseReq(f.ensureInstance(t, "ws-1"))
req.RepositoryID = "repo-1"
req.BaseBranch = "release/v2"
w, err := f.svc.CreateIssueWatch(ctx, req)
@@ -60,7 +61,7 @@ func TestService_CreateIssueWatch_RepositoryBinding(t *testing.T) {
t.Run("cross-workspace repo rejected", func(t *testing.T) {
f := newSvcFixture(t)
f.svc.SetRepositoryLookup(fakeRepoLookup{workspaceID: "ws-other", defaultBranch: "main", ok: true})
req := baseReq()
req := baseReq(f.ensureInstance(t, "ws-1"))
req.RepositoryID = "repo-1"
if _, err := f.svc.CreateIssueWatch(ctx, req); !errors.Is(err, ErrInvalidConfig) {
t.Fatalf("expected ErrInvalidConfig for cross-workspace repo, got %v", err)
@@ -70,7 +71,7 @@ func TestService_CreateIssueWatch_RepositoryBinding(t *testing.T) {
t.Run("missing repo rejected", func(t *testing.T) {
f := newSvcFixture(t)
f.svc.SetRepositoryLookup(fakeRepoLookup{ok: false})
req := baseReq()
req := baseReq(f.ensureInstance(t, "ws-1"))
req.RepositoryID = "ghost"
if _, err := f.svc.CreateIssueWatch(ctx, req); !errors.Is(err, ErrInvalidConfig) {
t.Fatalf("expected ErrInvalidConfig for missing repo, got %v", err)
@@ -79,7 +80,7 @@ func TestService_CreateIssueWatch_RepositoryBinding(t *testing.T) {
t.Run("unbound skips lookup and clears branch", func(t *testing.T) {
f := newSvcFixture(t) // no RepositoryLookup wired
req := baseReq()
req := baseReq(f.ensureInstance(t, "ws-1"))
req.BaseBranch = "ignored-without-repo"
w, err := f.svc.CreateIssueWatch(ctx, req)
if err != nil {
@@ -97,10 +98,11 @@ func TestService_UpdateIssueWatch_RepositoryBinding(t *testing.T) {
f.svc.SetRepositoryLookup(fakeRepoLookup{workspaceID: "ws-1", defaultBranch: "main", ok: true})
w, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"},
WorkspaceID: "ws-1",
SentryInstanceID: f.ensureInstance(t, "ws-1"),
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"},
})
if err != nil {
t.Fatalf("create: %v", err)
@@ -134,7 +136,8 @@ func TestService_UpdateIssueWatch_RebindAndDeletedRepo(t *testing.T) {
f.svc.SetRepositoryLookup(fakeRepoLookup{workspaceID: "ws-1", defaultBranch: "main", ok: true})
w, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", WorkflowID: "wf", WorkflowStepID: "step",
WorkspaceID: "ws-1", SentryInstanceID: f.ensureInstance(t, "ws-1"),
WorkflowID: "wf", WorkflowStepID: "step",
Filter: SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"},
})
if err != nil {
@@ -170,9 +173,11 @@ func TestService_IssueWatch_RejectsInvalidBaseBranch(t *testing.T) {
ctx := context.Background()
f := newSvcFixture(t)
f.svc.SetRepositoryLookup(fakeRepoLookup{workspaceID: "ws-1", defaultBranch: "main", ok: true})
instID := f.ensureInstance(t, "ws-1")
base := func() *CreateIssueWatchRequest {
return &CreateIssueWatchRequest{
WorkspaceID: "ws-1", WorkflowID: "wf", WorkflowStepID: "step",
WorkspaceID: "ws-1", SentryInstanceID: instID,
WorkflowID: "wf", WorkflowStepID: "step",
Filter: SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"}, RepositoryID: "repo-1",
}
}
@@ -4,12 +4,11 @@ import (
"context"
"errors"
"testing"
"time"
"github.com/kandev/kandev/internal/integrations/optional"
)
func intPtr(v int) *int { return &v }
// withSearchResults returns a fakeClient that always returns the given issues
// for SearchIssues, ignoring the filter.
func (c *fakeClient) withSearchResults(issues []SentryIssue) *fakeClient {
@@ -22,48 +21,64 @@ func (c *fakeClient) withSearchResults(issues []SentryIssue) *fakeClient {
func validFilter() SearchFilter {
return SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend"}
}
func intPtr(value int) *int {
return &value
}
func TestService_CreateIssueWatch_DefaultsAndValidation(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
instID := f.ensureInstance(t, "ws-1")
// Missing org/project is rejected — a watch must name what it polls.
// Bad filters are rejected before the instance check, so no instance needed.
for name, filter := range map[string]SearchFilter{
"empty": {},
"org only": {OrgSlug: "acme"},
"whitespace org": {OrgSlug: " ", ProjectSlug: "frontend"},
// Sentry has no OR form for is:, so multiple statuses would AND-combine
// into a query that matches nothing — reject at save time.
"multi status": {OrgSlug: "acme", ProjectSlug: "frontend", Statuses: []string{"unresolved", "ignored"}},
"multi status": {OrgSlug: "acme", ProjectSlug: "frontend", Statuses: []string{"unresolved", "ignored"}},
} {
if _, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: filter,
WorkspaceID: "ws-1", SentryInstanceID: instID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: filter,
}); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("%s filter should be rejected, got %v", name, err)
}
}
// Happy path assigns ID + defaults Enabled=true.
w, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: validFilter(),
WorkspaceID: "ws-1", SentryInstanceID: instID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
})
if err != nil {
t.Fatalf("create: %v", err)
}
if w.ID == "" {
t.Fatal("expected ID assigned")
if w.ID == "" || !w.Enabled {
t.Fatalf("unexpected created watch: %+v", w)
}
if !w.Enabled {
t.Error("expected Enabled defaulted to true")
if w.SentryInstanceID != instID {
t.Errorf("expected instance %q bound, got %q", instID, w.SentryInstanceID)
}
if w.Filter.OrgSlug != "acme" || w.Filter.ProjectSlug != "frontend" {
t.Errorf("filter not persisted: %+v", w.Filter)
}
// TestService_CreateIssueWatch_InstanceValidation pins the required + owned
// contract on the bound instance.
func TestService_CreateIssueWatch_InstanceValidation(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
other := f.seedInstance(t, "ws-2", "Other", "")
// Missing instance → ErrInstanceRequired.
if _, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
}); !errors.Is(err, ErrInstanceRequired) {
t.Errorf("expected ErrInstanceRequired for missing instance, got %v", err)
}
// Instance from another workspace → ErrInstanceNotFound.
if _, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", SentryInstanceID: other.ID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
}); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound for cross-workspace instance, got %v", err)
}
}
@@ -71,23 +86,16 @@ func TestService_UpdateIssueWatch_LegacyMultiStatusToggle(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
// Seed a legacy watch carrying multiple statuses directly through the
// store, bypassing service validation — mirrors rows created before the
// single-status rule existed.
// Seed a legacy watch (unbound, multi-status) directly through the store.
w := newTestIssueWatch("ws-1")
w.Filter.Statuses = []string{"unresolved", "ignored"}
if err := f.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("seed watch: %v", err)
}
// A partial update that leaves the filter untouched (the enable/disable
// toggle sends only {enabled}) must still succeed for the legacy watch.
disabled := false
if _, err := f.svc.UpdateIssueWatch(ctx, w.ID, &UpdateIssueWatchRequest{Enabled: &disabled}); err != nil {
t.Fatalf("toggle on legacy multi-status watch should succeed, got %v", err)
}
// Patching the filter to keep multiple statuses must be rejected.
bad := SearchFilter{OrgSlug: "acme", ProjectSlug: "frontend", Statuses: []string{"unresolved", "ignored"}}
if _, err := f.svc.UpdateIssueWatch(ctx, w.ID, &UpdateIssueWatchRequest{Filter: &bad}); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("filter patch with multiple statuses should be rejected, got %v", err)
@@ -97,95 +105,96 @@ func TestService_UpdateIssueWatch_LegacyMultiStatusToggle(t *testing.T) {
func TestService_UpdateIssueWatch_PartialPatch(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: validFilter(),
Prompt: "original",
WorkspaceID: "ws-1", SentryInstanceID: f.ensureInstance(t, "ws-1"),
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(), Prompt: "original",
})
if err != nil {
t.Fatalf("create: %v", err)
}
// Patch only the prompt; everything else must remain.
newPrompt := "updated"
updated, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{
Prompt: &newPrompt,
})
updated, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{Prompt: &newPrompt})
if err != nil {
t.Fatalf("update: %v", err)
}
if updated.Prompt != "updated" {
t.Errorf("prompt not patched: %q", updated.Prompt)
t.Errorf("prompt not updated: got %q, want %q", updated.Prompt, "updated")
}
if updated.Filter.OrgSlug != "acme" || updated.WorkspaceID != created.WorkspaceID {
t.Errorf("unexpected mutation of unset fields: %+v", updated)
if updated.Filter.OrgSlug != "acme" {
t.Errorf("filter changed by prompt-only patch: got orgSlug %q, want %q", updated.Filter.OrgSlug, "acme")
}
if updated.WorkspaceID != created.WorkspaceID {
t.Errorf("workspace id changed: got %q, want %q", updated.WorkspaceID, created.WorkspaceID)
}
// Patching the filter to something empty is rejected to keep watch rows valid.
empty := SearchFilter{}
if _, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{Filter: &empty}); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("expected ErrInvalidConfig for empty filter patch, got %v", err)
}
}
func TestService_IssueWatch_MaxInflightTasks(t *testing.T) {
// TestService_UpdateIssueWatch_InstanceImmutable pins acceptance (g): the bound
// instance is absent from the update request, so it cannot be changed.
func TestService_UpdateIssueWatch_InstanceImmutable(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
// A non-positive cap is rejected at create.
if _, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: validFilter(),
MaxInflightTasks: intPtr(0),
}); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("expected ErrInvalidConfig for non-positive cap, got %v", err)
}
// A positive cap round-trips through the store.
instA := f.seedInstance(t, "ws-1", "A", "")
created, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: validFilter(),
MaxInflightTasks: intPtr(3),
WorkspaceID: "ws-1", SentryInstanceID: instA.ID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
})
if err != nil {
t.Fatalf("create: %v", err)
}
reloaded, err := f.svc.GetIssueWatch(ctx, created.ID)
prompt := "changed"
updated, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{Prompt: &prompt})
if err != nil {
t.Fatalf("get: %v", err)
t.Fatalf("update: %v", err)
}
if updated.SentryInstanceID != instA.ID {
t.Errorf("instance changed on update: got %q want %q", updated.SentryInstanceID, instA.ID)
}
reloaded, _ := f.store.GetIssueWatch(ctx, created.ID)
if reloaded.SentryInstanceID != instA.ID {
t.Errorf("persisted instance changed: got %q want %q", reloaded.SentryInstanceID, instA.ID)
}
}
func TestService_IssueWatch_MaxInflightTasks(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
instID := f.ensureInstance(t, "ws-1")
base := func() *CreateIssueWatchRequest {
return &CreateIssueWatchRequest{
WorkspaceID: "ws-1", SentryInstanceID: instID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
}
}
req := base()
req.MaxInflightTasks = intPtr(0)
if _, err := f.svc.CreateIssueWatch(ctx, req); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("expected ErrInvalidConfig for non-positive cap, got %v", err)
}
req = base()
req.MaxInflightTasks = intPtr(3)
created, err := f.svc.CreateIssueWatch(ctx, req)
if err != nil {
t.Fatalf("create: %v", err)
}
reloaded, _ := f.svc.GetIssueWatch(ctx, created.ID)
if reloaded.MaxInflightTasks == nil || *reloaded.MaxInflightTasks != 3 {
t.Fatalf("expected cap 3 persisted, got %v", reloaded.MaxInflightTasks)
}
// PATCH tri-state: omitted leaves the cap unchanged.
unchanged, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{})
if err != nil {
t.Fatalf("patch (omit): %v", err)
if err != nil || unchanged.MaxInflightTasks == nil || *unchanged.MaxInflightTasks != 3 {
t.Errorf("omitted cap should stay 3, got %v (err %v)", unchanged.MaxInflightTasks, err)
}
if unchanged.MaxInflightTasks == nil || *unchanged.MaxInflightTasks != 3 {
t.Errorf("omitted cap should stay 3, got %v", unchanged.MaxInflightTasks)
}
// PATCH tri-state: explicit null clears the cap to uncapped.
uncapped, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{
MaxInflightTasks: optional.Int{Present: true, Value: nil},
})
if err != nil {
t.Fatalf("patch (null): %v", err)
if err != nil || uncapped.MaxInflightTasks != nil {
t.Errorf("null cap should clear to uncapped, got %v (err %v)", uncapped.MaxInflightTasks, err)
}
if uncapped.MaxInflightTasks != nil {
t.Errorf("null cap should clear to uncapped, got %v", *uncapped.MaxInflightTasks)
}
// PATCH tri-state: a non-positive value is rejected.
if _, err := f.svc.UpdateIssueWatch(ctx, created.ID, &UpdateIssueWatchRequest{
MaxInflightTasks: optional.Int{Present: true, Value: intPtr(-1)},
}); !errors.Is(err, ErrInvalidConfig) {
@@ -196,24 +205,18 @@ func TestService_IssueWatch_MaxInflightTasks(t *testing.T) {
func TestService_CreateIssueWatch_RejectsOutOfRangeInterval(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
instID := f.ensureInstance(t, "ws-1")
for _, n := range []int{1, 30, 59, 3601, 86400} {
_, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: validFilter(),
PollIntervalSeconds: n,
})
if !errors.Is(err, ErrInvalidConfig) {
if _, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", SentryInstanceID: instID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(), PollIntervalSeconds: n,
}); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("expected ErrInvalidConfig for pollIntervalSeconds=%d, got %v", n, err)
}
}
// Zero is allowed (the store coerces to default).
if _, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1",
WorkflowID: "wf",
WorkflowStepID: "step",
Filter: validFilter(),
WorkspaceID: "ws-1", SentryInstanceID: instID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
}); err != nil {
t.Errorf("expected zero pollIntervalSeconds to be accepted, got %v", err)
}
@@ -223,17 +226,14 @@ func TestService_UpdateIssueWatch_RejectsEmptyWorkflowFields(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", WorkflowID: "wf", WorkflowStepID: "step",
Filter: validFilter(),
WorkspaceID: "ws-1", SentryInstanceID: f.ensureInstance(t, "ws-1"),
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
})
if err != nil {
t.Fatalf("create: %v", err)
}
empty := ""
for _, req := range []*UpdateIssueWatchRequest{
{WorkflowID: &empty},
{WorkflowStepID: &empty},
} {
for _, req := range []*UpdateIssueWatchRequest{{WorkflowID: &empty}, {WorkflowStepID: &empty}} {
if _, err := f.svc.UpdateIssueWatch(ctx, created.ID, req); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("expected ErrInvalidConfig for %+v, got %v", req, err)
}
@@ -243,8 +243,7 @@ func TestService_UpdateIssueWatch_RejectsEmptyWorkflowFields(t *testing.T) {
func TestService_UpdateIssueWatch_NotFound(t *testing.T) {
f := newSvcFixture(t)
prompt := "x"
_, err := f.svc.UpdateIssueWatch(context.Background(), "ghost", &UpdateIssueWatchRequest{Prompt: &prompt})
if !errors.Is(err, ErrIssueWatchNotFound) {
if _, err := f.svc.UpdateIssueWatch(context.Background(), "ghost", &UpdateIssueWatchRequest{Prompt: &prompt}); !errors.Is(err, ErrIssueWatchNotFound) {
t.Errorf("expected ErrIssueWatchNotFound, got %v", err)
}
}
@@ -252,33 +251,23 @@ func TestService_UpdateIssueWatch_NotFound(t *testing.T) {
func TestService_CheckIssueWatch_FiltersAlreadySeen(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfigForWorkspace(ctx, "ws-1", &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "sntrys_abc",
}); err != nil {
t.Fatalf("set config: %v", err)
}
inst := f.seedInstance(t, "ws-1", "A", "sntrys_abc")
f.client.withSearchResults([]SentryIssue{
{ShortID: "PROJ-1", Title: "one", Permalink: "https://sentry.io/issues/PROJ-1"},
{ShortID: "PROJ-2", Title: "two", Permalink: "https://sentry.io/issues/PROJ-2"},
{ShortID: "PROJ-3", Title: "three", Permalink: "https://sentry.io/issues/PROJ-3"},
})
w, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", WorkflowID: "wf", WorkflowStepID: "step",
Filter: validFilter(),
WorkspaceID: "ws-1", SentryInstanceID: inst.ID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
})
if err != nil {
t.Fatalf("create watch: %v", err)
}
// Pre-seed PROJ-2 as already turned into a task.
if _, err := f.store.ReserveIssueWatchTask(ctx, w.ID, "PROJ-2", "https://sentry.io/issues/PROJ-2"); err != nil {
t.Fatalf("seed reservation: %v", err)
}
got, err := f.svc.CheckIssueWatch(ctx, w)
_, got, err := f.svc.CheckIssueWatch(ctx, w)
if err != nil {
t.Fatalf("check: %v", err)
}
@@ -290,7 +279,6 @@ func TestService_CheckIssueWatch_FiltersAlreadySeen(t *testing.T) {
t.Error("PROJ-2 should have been filtered as already seen")
}
}
refreshed, _ := f.store.GetIssueWatch(ctx, w.ID)
if refreshed.LastPolledAt == nil {
t.Error("expected last_polled_at stamped after check")
@@ -300,19 +288,18 @@ func TestService_CheckIssueWatch_FiltersAlreadySeen(t *testing.T) {
func TestService_CheckIssueWatch_StampsLastPolledOnError(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "sntrys_abc",
}); err != nil {
t.Fatalf("set config: %v", err)
}
inst := f.seedInstance(t, "ws-1", "A", "sntrys_abc")
f.client.searchIssuesFn = func(_ SearchFilter, _ string) (*SearchResult, error) {
return nil, errors.New("upstream 500")
}
w, _ := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", WorkflowID: "wf", WorkflowStepID: "step",
Filter: validFilter(),
w, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", SentryInstanceID: inst.ID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
})
if _, err := f.svc.CheckIssueWatch(ctx, w); err == nil {
if err != nil {
t.Fatalf("create: %v", err)
}
if _, _, err := f.svc.CheckIssueWatch(ctx, w); err == nil {
t.Error("expected error from search to surface to caller")
}
refreshed, _ := f.store.GetIssueWatch(ctx, w.ID)
@@ -320,3 +307,154 @@ func TestService_CheckIssueWatch_StampsLastPolledOnError(t *testing.T) {
t.Error("expected last_polled_at stamped even on search failure (liveness signal)")
}
}
func TestService_CheckIssueWatch_ClearsLastErrorAfterSuccess(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
inst := f.seedInstance(t, "ws-1", "A", "sntrys_abc")
w, err := f.svc.CreateIssueWatch(ctx, &CreateIssueWatchRequest{
WorkspaceID: "ws-1", SentryInstanceID: inst.ID,
WorkflowID: "wf", WorkflowStepID: "step", Filter: validFilter(),
})
if err != nil {
t.Fatalf("create watch: %v", err)
}
if err := f.store.StampIssueWatchError(ctx, w.ID, "upstream 500"); err != nil {
t.Fatalf("stamp initial error: %v", err)
}
f.client.withSearchResults(nil)
if _, _, err := f.svc.CheckIssueWatch(ctx, w); err != nil {
t.Fatalf("check recovered watch: %v", err)
}
reloaded, err := f.store.GetIssueWatch(ctx, w.ID)
if err != nil {
t.Fatalf("reload watch: %v", err)
}
if reloaded.LastError != "" {
t.Errorf("last error = %q, want cleared after success", reloaded.LastError)
}
if reloaded.LastErrorAt != nil {
t.Errorf("last error timestamp = %v, want cleared after success", reloaded.LastErrorAt)
}
}
// TestService_CheckIssueWatch_ResolvesSoleInstance pins acceptance (b): an
// unbound (NULL-instance) watch resolves to its workspace's sole instance at
// poll time.
func TestService_CheckIssueWatch_ResolvesSoleInstance(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
inst := f.seedInstance(t, "ws-1", "Primary", "tok") // the sole healthy instance, with a secret
if err := f.store.UpdateAuthHealthForInstance(ctx, inst.ID, true, "", time.Now().UTC()); err != nil {
t.Fatalf("mark instance healthy: %v", err)
}
f.client.withSearchResults([]SentryIssue{
{ShortID: "PROJ-1", Title: "one", Permalink: "https://sentry.io/issues/PROJ-1"},
})
// Watch created directly with a NULL instance (migrated legacy row).
w := newTestIssueWatch("ws-1")
if err := f.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("seed unbound watch: %v", err)
}
if w.SentryInstanceID != "" {
t.Fatalf("expected unbound watch, got instance %q", w.SentryInstanceID)
}
gotInstanceID, got, err := f.svc.CheckIssueWatch(ctx, w)
if err != nil {
t.Fatalf("check unbound watch: %v", err)
}
if gotInstanceID != inst.ID {
t.Errorf("resolved instance = %q, want sole instance %q", gotInstanceID, inst.ID)
}
if len(got) != 1 || got[0].ShortID != "PROJ-1" {
t.Fatalf("expected sole-instance resolution to return PROJ-1, got %+v", got)
}
}
// TestService_ResolveWatchInstanceID_SoleInstanceIgnoresHealth pins the
// ADR-0030 single-instance contract: an unbound watch resolves to its
// workspace's only instance even when that instance has never been health
// probed (LastOk still false) — matching the pre-existing behavior every
// poller test's saveConfigForWorkspace helper relies on.
func TestService_ResolveWatchInstanceID_SoleInstanceIgnoresHealth(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
inst := f.seedInstance(t, "ws-1", "Primary", "tok")
instanceID, err := f.svc.resolveWatchInstanceID(ctx, newTestIssueWatch("ws-1"))
if err != nil {
t.Fatalf("resolve watch instance: %v", err)
}
if instanceID != inst.ID {
t.Errorf("resolved instance = %q, want sole instance %q", instanceID, inst.ID)
}
}
func TestService_ResolveWatchInstanceID_AmbiguousMultiInstancePrefersHealthy(t *testing.T) {
t.Run("selects the sole healthy instance among several", func(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
f.seedInstance(t, "ws-1", "Unhealthy", "tok")
healthy := f.seedInstance(t, "ws-1", "Healthy", "tok")
if err := f.store.UpdateAuthHealthForInstance(ctx, healthy.ID, true, "", time.Now().UTC()); err != nil {
t.Fatalf("mark instance healthy: %v", err)
}
instanceID, err := f.svc.resolveWatchInstanceID(ctx, newTestIssueWatch("ws-1"))
if err != nil {
t.Fatalf("resolve watch instance: %v", err)
}
if instanceID != healthy.ID {
t.Errorf("resolved instance = %q, want healthy instance %q", instanceID, healthy.ID)
}
})
t.Run("rejects when several instances exist and none is healthy", func(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
f.seedInstance(t, "ws-1", "A", "tok")
f.seedInstance(t, "ws-1", "B", "tok")
if _, err := f.svc.resolveWatchInstanceID(ctx, newTestIssueWatch("ws-1")); !errors.Is(err, ErrNotConfigured) {
t.Errorf("expected ErrNotConfigured with no healthy instance among several, got %v", err)
}
})
t.Run("rejects when multiple instances are healthy", func(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
for _, name := range []string{"A", "B"} {
instance := f.seedInstance(t, "ws-1", name, "tok")
if err := f.store.UpdateAuthHealthForInstance(ctx, instance.ID, true, "", time.Now().UTC()); err != nil {
t.Fatalf("mark %s healthy: %v", name, err)
}
}
if _, err := f.svc.resolveWatchInstanceID(ctx, newTestIssueWatch("ws-1")); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("expected ErrInvalidConfig with multiple healthy instances, got %v", err)
}
})
}
// TestService_CheckIssueWatch_UnboundNoInstanceStampsError pins the other half
// of acceptance (b): an unbound watch whose workspace has no instance stamps a
// last_error and skips, without disabling the watch.
func TestService_CheckIssueWatch_UnboundNoInstanceStampsError(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
w := newTestIssueWatch("ws-empty") // workspace has zero instances
if err := f.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("seed watch: %v", err)
}
if _, _, err := f.svc.CheckIssueWatch(ctx, w); err == nil {
t.Error("expected an error when no instance can be resolved")
}
refreshed, _ := f.store.GetIssueWatch(ctx, w.ID)
if refreshed.LastError == "" {
t.Error("expected last_error stamped when resolution fails")
}
if !refreshed.Enabled {
t.Error("watch must stay enabled (stamp + skip, not disable) so it auto-heals")
}
}
+526 -286
View File
@@ -26,8 +26,15 @@ func (s *slowSecretStore) Reveal(ctx context.Context, id string) (string, error)
}
type fakeSecretStore struct {
mu sync.Mutex
secrets map[string]string
mu sync.Mutex
secrets map[string]string
setErr error
setErrAfter int
setErrAfterWrite bool
setHook func()
revealErr error
revealErrForID string
deleteMissingErr error
}
func newFakeSecretStore() *fakeSecretStore {
@@ -37,16 +44,34 @@ func newFakeSecretStore() *fakeSecretStore {
func (f *fakeSecretStore) Reveal(_ context.Context, id string) (string, error) {
f.mu.Lock()
defer f.mu.Unlock()
if f.revealErr != nil && (f.revealErrForID == "" || f.revealErrForID == id) {
return "", f.revealErr
}
v, ok := f.secrets[id]
if !ok {
return "", errors.New("not found")
return "", errors.New("secret not found: " + id)
}
return v, nil
}
// Set runs setHook (if any) before acquiring its lock, letting a test drive a
// synchronous client build against the pre-failure row state — simulating a
// concurrent clientForInstance call racing the write this Set is about to fail.
func (f *fakeSecretStore) Set(_ context.Context, id, _, value string) error {
if f.setHook != nil {
f.setHook()
}
f.mu.Lock()
defer f.mu.Unlock()
if f.setErr != nil {
if f.setErrAfter == 0 {
if f.setErrAfterWrite {
f.secrets[id] = value
}
return f.setErr
}
f.setErrAfter--
}
f.secrets[id] = value
return nil
}
@@ -54,6 +79,9 @@ func (f *fakeSecretStore) Set(_ context.Context, id, _, value string) error {
func (f *fakeSecretStore) Delete(_ context.Context, id string) error {
f.mu.Lock()
defer f.mu.Unlock()
if _, ok := f.secrets[id]; !ok && f.deleteMissingErr != nil {
return f.deleteMissingErr
}
delete(f.secrets, id)
return nil
}
@@ -64,6 +92,11 @@ func (f *fakeSecretStore) Exists(_ context.Context, id string) (bool, error) {
_, ok := f.secrets[id]
return ok, nil
}
func (f *fakeSecretStore) count() int {
f.mu.Lock()
defer f.mu.Unlock()
return len(f.secrets)
}
// fakeClient is an in-memory Client for verifying service plumbing.
type fakeClient struct {
@@ -139,178 +172,477 @@ func newSvcFixture(t *testing.T) *svcFixture {
return f
}
func waitForAuthProbe(t *testing.T, f *svcFixture) *SentryConfig {
// seedInstance persists an instance + secret directly via the store/secret fake,
// bypassing Service.CreateInstance (and its async probe).
func (f *svcFixture) seedInstance(t *testing.T, workspaceID, name, secret string) *SentryConfig {
t.Helper()
cfg := &SentryConfig{WorkspaceID: workspaceID, Name: name, AuthMethod: AuthMethodAuthToken, URL: DefaultSentryURL}
if err := f.store.CreateInstance(context.Background(), cfg); err != nil {
t.Fatalf("seed instance: %v", err)
}
if secret != "" {
if err := f.secrets.Set(context.Background(), secretKeyForInstance(cfg.ID), "tok", secret); err != nil {
t.Fatalf("seed secret: %v", err)
}
}
return cfg
}
// ensureInstance returns the ID of a workspace's sole instance, creating a
// "Primary" instance when none exists. Reused across tests that need a valid
// SentryInstanceID for a watch without minding which instance it is.
func (f *svcFixture) ensureInstance(t *testing.T, workspaceID string) string {
t.Helper()
instances, err := f.store.ListInstances(context.Background(), workspaceID)
if err != nil {
t.Fatalf("list instances: %v", err)
}
if len(instances) > 0 {
return instances[0].ID
}
return f.seedInstance(t, workspaceID, "Primary", "").ID
}
func waitForAuthProbe(t *testing.T, f *svcFixture) {
t.Helper()
select {
case <-f.probed:
cfg, err := f.svc.GetConfig(context.Background())
if err != nil {
t.Fatalf("get config after probe: %v", err)
}
return cfg
case <-time.After(2 * time.Second):
t.Fatalf("async probe hook did not fire within 2s")
return nil
}
}
func TestService_SetConfig_PersistsAndStoresSecret(t *testing.T) {
func TestService_CreateInstance_PersistsAndStoresSecret(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
cfg, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken,
Secret: "sntrys_xyz",
})
if err != nil {
t.Fatalf("set: %v", err)
}
if cfg.AuthMethod != AuthMethodAuthToken {
t.Errorf("config not stored: %+v", cfg)
}
if !cfg.HasSecret {
t.Error("expected HasSecret=true")
}
if got, _ := f.secrets.Reveal(ctx, SecretKeyForWorkspace("default")); got != "sntrys_xyz" {
t.Errorf("secret stored = %q", got)
}
}
func TestService_GetConfig_HidesSecretValue(t *testing.T) {
// GetConfig must surface HasSecret=true but never the secret itself.
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "secret-tok",
}); err != nil {
t.Fatalf("set: %v", err)
}
cfg, err := f.svc.GetConfig(ctx)
if err != nil || cfg == nil {
t.Fatalf("get: %v / %v", err, cfg)
}
if !cfg.HasSecret {
t.Error("expected HasSecret=true")
}
}
func TestService_SetConfig_EmptySecret_KeepsExisting(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "first",
}); err != nil {
t.Fatalf("initial: %v", err)
}
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken,
}); err != nil {
t.Fatalf("update: %v", err)
}
if got, _ := f.secrets.Reveal(ctx, SecretKeyForWorkspace("default")); got != "first" {
t.Errorf("secret should be preserved, got %q", got)
}
}
func TestService_SetConfig_ProbesAsync(t *testing.T) {
f := newSvcFixture(t)
f.client.testAuthFn = func() (*TestConnectionResult, error) {
return &TestConnectionResult{OK: true, DisplayName: "Alice"}, nil
}
if _, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "tok",
}); err != nil {
t.Fatalf("set: %v", err)
cfg, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{
Name: "SaaS", AuthMethod: AuthMethodAuthToken, Secret: "sntrys_xyz",
})
if err != nil {
t.Fatalf("create: %v", err)
}
cfg := waitForAuthProbe(t, f)
if !cfg.LastOk {
t.Errorf("expected LastOk=true after async probe, got %+v", cfg)
if cfg.ID == "" || cfg.WorkspaceID != "ws-1" || cfg.Name != "SaaS" {
t.Errorf("instance not stored: %+v", cfg)
}
if !cfg.HasSecret {
t.Error("expected HasSecret=true")
}
if got, _ := f.secrets.Reveal(ctx, secretKeyForInstance(cfg.ID)); got != "sntrys_xyz" {
t.Errorf("secret stored under instance key = %q", got)
}
waitForAuthProbe(t, f)
reloaded, _ := f.store.GetInstance(ctx, cfg.ID)
if !reloaded.LastOk {
t.Errorf("expected LastOk=true after async probe, got %+v", reloaded)
}
}
func TestService_Validation_RejectsBadAuth(t *testing.T) {
func TestService_CreateInstance_SecretSetFailureRollsBackAndAllowsRetry(t *testing.T) {
f := newSvcFixture(t)
if _, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: "bogus",
}); err == nil {
t.Error("expected validation error for unknown auth method")
ctx := context.Background()
injected := errors.New("secret store unavailable")
req := &CreateConfigRequest{Name: "SaaS", Secret: "sntrys_xyz"}
f.secrets.setErr = injected
if _, err := f.svc.CreateInstance(ctx, "ws-1", req); !errors.Is(err, injected) {
t.Fatalf("expected injected secret error, got %v", err)
}
instances, err := f.store.ListInstances(ctx, "ws-1")
if err != nil {
t.Fatalf("list instances after failed create: %v", err)
}
if len(instances) != 0 {
t.Fatalf("failed create left %d instance(s), want 0", len(instances))
}
f.secrets.setErr = nil
created, err := f.svc.CreateInstance(ctx, "ws-1", req)
if err != nil {
t.Fatalf("retry same-name create: %v", err)
}
if created.Name != req.Name {
t.Errorf("retry created unexpected instance: %+v", created)
}
waitForAuthProbe(t, f)
}
func TestService_CreateInstance_Validation(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
cases := map[string]*CreateConfigRequest{
"missing name": {Name: "", Secret: "t"},
"bad auth": {Name: "X", AuthMethod: "bogus"},
"bad scheme": {Name: "X", URL: "ftp://nope"},
"non-root url": {Name: "X", URL: "https://sentry.example.com/path"},
}
for name, req := range cases {
if _, err := f.svc.CreateInstance(ctx, "ws-1", req); !errors.Is(err, ErrInvalidConfig) {
t.Errorf("%s: expected ErrInvalidConfig, got %v", name, err)
}
}
}
func TestService_Validation_DefaultsAuthMethod(t *testing.T) {
func TestService_CreateInstance_DefaultsAndNormalizesURL(t *testing.T) {
f := newSvcFixture(t)
if _, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{Secret: "tok"}); err != nil {
t.Fatalf("expected default auth method, got error: %v", err)
ctx := context.Background()
blank, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{Name: "SaaS", Secret: "t"})
if err != nil {
t.Fatalf("create blank url: %v", err)
}
if blank.URL != DefaultSentryURL {
t.Errorf("expected URL defaulted to %q, got %q", DefaultSentryURL, blank.URL)
}
host, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{Name: "Self", URL: "sentry.example.com/", Secret: "t"})
if err != nil {
t.Fatalf("create host url: %v", err)
}
if host.URL != "https://sentry.example.com" {
t.Errorf("expected normalized URL, got %q", host.URL)
}
}
func TestService_TestConnection_InlineSecret(t *testing.T) {
// TestService_UniqueName_PerWorkspace pins acceptance (h) at the service layer.
func TestService_UniqueName_PerWorkspace(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{Name: "Prod", Secret: "t"}); err != nil {
t.Fatalf("first: %v", err)
}
if _, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{Name: "Prod", Secret: "t"}); !errors.Is(err, ErrDuplicateInstanceName) {
t.Errorf("expected ErrDuplicateInstanceName, got %v", err)
}
if _, err := f.svc.CreateInstance(ctx, "ws-2", &CreateConfigRequest{Name: "Prod", Secret: "t"}); err != nil {
t.Errorf("same name in another workspace should succeed, got %v", err)
}
}
// TestService_InstanceCRUD_ScopedPerWorkspace pins acceptance (d): an instance
// is only reachable through its owning workspace.
func TestService_InstanceCRUD_ScopedPerWorkspace(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
a := f.seedInstance(t, "ws-1", "A", "ta")
f.seedInstance(t, "ws-2", "B", "tb")
if _, err := f.svc.GetInstance(ctx, "ws-1", a.ID); err != nil {
t.Fatalf("get own instance: %v", err)
}
// Cross-workspace GetInstance is a 404, not a leak.
if _, err := f.svc.GetInstance(ctx, "ws-2", a.ID); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound cross-workspace, got %v", err)
}
// List is scoped.
list, err := f.svc.ListInstances(ctx, "ws-1")
if err != nil || len(list) != 1 || list[0].ID != a.ID {
t.Fatalf("ListInstances(ws-1) = %+v err=%v", list, err)
}
if !list[0].HasSecret {
t.Error("expected HasSecret=true for seeded instance")
}
// Update / delete cross-workspace are 404.
if _, err := f.svc.UpdateInstance(ctx, "ws-2", a.ID, &UpdateConfigRequest{Name: "hijack"}); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound on cross-workspace update, got %v", err)
}
if err := f.svc.DeleteInstance(ctx, "ws-2", a.ID); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound on cross-workspace delete, got %v", err)
}
}
func TestService_UpdateInstance_EmptySecretKeepsExisting(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{Name: "A", Secret: "first"})
if err != nil {
t.Fatalf("create: %v", err)
}
waitForAuthProbe(t, f)
if _, err := f.svc.UpdateInstance(ctx, "ws-1", created.ID, &UpdateConfigRequest{Name: "A2"}); err != nil {
t.Fatalf("update: %v", err)
}
waitForAuthProbe(t, f)
if got, _ := f.secrets.Reveal(ctx, secretKeyForInstance(created.ID)); got != "first" {
t.Errorf("secret should be preserved on empty-secret update, got %q", got)
}
reloaded, _ := f.svc.GetInstance(ctx, "ws-1", created.ID)
if reloaded.Name != "A2" {
t.Errorf("name not updated: %q", reloaded.Name)
}
}
// TestService_UpdateInstance_SecretSetFailureRestoresMetadataAndClient pins
// the metadata/secret rollback and the defensive cache invalidation that
// backs it: a client cached before the update is dropped once the update
// fails, and the next access rebuilds against the restored (not the
// attempted) configuration — closing the narrower race pinned by
// TestService_UpdateInstance_SecretSetFailureInvalidatesRacedClient below,
// where a client built during the failed window must not survive either.
func TestService_UpdateInstance_SecretSetFailureRestoresMetadataAndClient(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created := f.seedInstance(t, "ws-1", "Original", "old-token")
type build struct {
url string
secret string
}
var builds []build
f.svc.clientFn = func(cfg *SentryConfig, secret string) Client {
builds = append(builds, build{url: cfg.URL, secret: secret})
return &fakeClient{}
}
cached, err := f.svc.clientForInstance(ctx, created.ID)
if err != nil {
t.Fatalf("cache original client: %v", err)
}
injected := errors.New("secret store unavailable")
f.secrets.setErr = injected
if _, err := f.svc.UpdateInstance(ctx, "ws-1", created.ID, &UpdateConfigRequest{
Name: "Replacement", URL: "https://replacement.example.com", Secret: "new-token",
}); !errors.Is(err, injected) {
t.Fatalf("expected injected secret error, got %v", err)
}
stored, err := f.store.GetInstance(ctx, created.ID)
if err != nil {
t.Fatalf("reload instance after failed update: %v", err)
}
if stored == nil || stored.Name != "Original" || stored.AuthMethod != AuthMethodAuthToken || stored.URL != DefaultSentryURL {
t.Fatalf("failed update changed persisted metadata: %+v", stored)
}
if secret, err := f.secrets.Reveal(ctx, secretKeyForInstance(created.ID)); err != nil || secret != "old-token" {
t.Errorf("failed update changed persisted secret: secret=%q err=%v", secret, err)
}
afterFailure, err := f.svc.clientForInstance(ctx, created.ID)
if err != nil {
t.Fatalf("read client after failed update: %v", err)
}
if afterFailure == cached {
t.Error("failed update did not invalidate the pre-existing cached client")
}
if len(builds) != 2 || builds[1].url != DefaultSentryURL || builds[1].secret != "old-token" {
t.Fatalf("expected the post-failure rebuild against the restored config, got %+v", builds)
}
}
// TestService_UpdateInstance_SecretSetFailureInvalidatesRacedClient pins a
// narrower race than the previous test: a client built and cached DURING the
// failed update (after the row is temporarily persisted with the new URL but
// before the failing secret write) must not survive the rollback. Without an
// invalidation on the successful-rollback path, that stale new-URL+old-secret
// client would keep serving forever, since clientForInstance's cache check
// never re-validates against the store.
func TestService_UpdateInstance_SecretSetFailureInvalidatesRacedClient(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created := f.seedInstance(t, "ws-1", "Original", "old-token")
type build struct {
url string
secret string
}
var builds []build
f.svc.clientFn = func(cfg *SentryConfig, secret string) Client {
builds = append(builds, build{url: cfg.URL, secret: secret})
return &fakeClient{}
}
f.secrets.setErr = errors.New("secret store unavailable")
f.secrets.setHook = func() {
// Runs after UpdateInstance has already persisted the new URL but
// before the secret write it's about to fail — simulating a request
// racing in during that exact window.
if _, err := f.svc.clientForInstance(ctx, created.ID); err != nil {
t.Fatalf("raced client build: %v", err)
}
}
if _, err := f.svc.UpdateInstance(ctx, "ws-1", created.ID, &UpdateConfigRequest{
Name: "Replacement", URL: "https://replacement.example.com", Secret: "new-token",
}); !errors.Is(err, f.secrets.setErr) {
t.Fatalf("expected injected secret error, got %v", err)
}
if len(builds) != 1 || builds[0].url != "https://replacement.example.com" || builds[0].secret != "old-token" {
t.Fatalf("expected the race to build against the temporary row, got %+v", builds)
}
rebuilt, err := f.svc.clientForInstance(ctx, created.ID)
if err != nil {
t.Fatalf("read client after rollback: %v", err)
}
if len(builds) != 2 || builds[1].url != DefaultSentryURL || builds[1].secret != "old-token" {
t.Fatalf("expected a fresh build against the rolled-back row, got %+v", builds)
}
if rebuilt == nil {
t.Error("expected a rebuilt client, got nil")
}
}
// TestService_UpdateInstance_SecretSetFailureSkipsRollbackOnConcurrentWrite
// pins the fix for a rollback that blindly restored the `previous` row
// snapshot even when a second, concurrent UpdateInstance had landed on the
// same instance between this request's own row write and its failed secret
// write — silently discarding that other write. The rollback must detect
// that the persisted row no longer matches what this request itself wrote
// and skip the restore, while still returning this request's own secretErr.
func TestService_UpdateInstance_SecretSetFailureSkipsRollbackOnConcurrentWrite(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created := f.seedInstance(t, "ws-1", "Original", "old-token")
injected := errors.New("secret store unavailable")
f.secrets.setErr = injected
f.secrets.setHook = func() {
// Runs after this UpdateInstance call has already persisted its own
// "Replacement" row but before its secret write fails — simulating a
// second UpdateInstance request landing on the same instance during
// that exact window and winning the race.
concurrent := *created
concurrent.Name = "ConcurrentWinner"
concurrent.AuthMethod = AuthMethodAuthToken
concurrent.URL = "https://concurrent.example.com"
if err := f.store.UpdateInstance(context.Background(), &concurrent); err != nil {
t.Fatalf("simulate concurrent update: %v", err)
}
}
if _, err := f.svc.UpdateInstance(ctx, "ws-1", created.ID, &UpdateConfigRequest{
Name: "Replacement", URL: "https://replacement.example.com", Secret: "new-token",
}); !errors.Is(err, injected) {
t.Fatalf("expected injected secret error, got %v", err)
}
stored, err := f.store.GetInstance(ctx, created.ID)
if err != nil {
t.Fatalf("reload instance after failed update: %v", err)
}
if stored == nil || stored.Name != "ConcurrentWinner" || stored.URL != "https://concurrent.example.com" {
t.Fatalf("rollback clobbered the concurrent write: %+v", stored)
}
}
func TestService_DeleteInstance_RemovesSecretAndCache(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
created, err := f.svc.CreateInstance(ctx, "ws-1", &CreateConfigRequest{Name: "A", Secret: "t"})
if err != nil {
t.Fatalf("create: %v", err)
}
waitForAuthProbe(t, f)
if err := f.svc.DeleteInstance(ctx, "ws-1", created.ID); err != nil {
t.Fatalf("delete: %v", err)
}
if exists, _ := f.secrets.Exists(ctx, secretKeyForInstance(created.ID)); exists {
t.Error("expected secret removed")
}
if _, err := f.svc.GetInstance(ctx, "ws-1", created.ID); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected instance gone, got %v", err)
}
}
// TestService_DeleteInstance_InUse pins acceptance (f): an instance referenced
// by a watch cannot be deleted; the error carries the watch count.
func TestService_DeleteInstance_InUse(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
inst := f.seedInstance(t, "ws-1", "A", "t")
w := newTestIssueWatch("ws-1")
w.SentryInstanceID = inst.ID
if err := f.store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("create watch: %v", err)
}
// Add a disabled watch too — the count must include it.
w2 := newTestIssueWatch("ws-1")
w2.SentryInstanceID = inst.ID
w2.Enabled = false
if err := f.store.CreateIssueWatch(ctx, w2); err != nil {
t.Fatalf("create disabled watch: %v", err)
}
err := f.svc.DeleteInstance(ctx, "ws-1", inst.ID)
var inUse ErrInstanceInUse
if !errors.As(err, &inUse) {
t.Fatalf("expected ErrInstanceInUse, got %v", err)
}
if inUse.WatchCount != 2 {
t.Errorf("expected watch count 2 (enabled + disabled), got %d", inUse.WatchCount)
}
}
func TestService_TestConnectionCandidate(t *testing.T) {
f := newSvcFixture(t)
var seenURL string
f.svc.clientFn = func(cfg *SentryConfig, secret string) Client {
seenURL = cfg.URL
return f.client
}
called := false
f.client.testAuthFn = func() (*TestConnectionResult, error) {
called = true
return &TestConnectionResult{OK: true, DisplayName: "Alice"}, nil
return &TestConnectionResult{OK: true}, nil
}
res, err := f.svc.TestConnection(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "inline-tok",
res, err := f.svc.TestConnectionCandidate(context.Background(), &CreateConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "inline", URL: "https://sentry.example.com",
})
if err != nil || !called {
t.Fatalf("called=%v err=%v", called, err)
if err != nil || !called || !res.OK {
t.Fatalf("called=%v res=%+v err=%v", called, res, err)
}
if !res.OK {
t.Errorf("result: %+v", res)
if seenURL != "https://sentry.example.com" {
t.Errorf("expected configured URL passed to client, got %q", seenURL)
}
// No secret → failure result, no client call.
res, err = f.svc.TestConnectionCandidate(context.Background(), &CreateConfigRequest{AuthMethod: AuthMethodAuthToken})
if err != nil {
t.Fatalf("unexpected err: %v", err)
}
if res.OK {
t.Error("expected OK=false when no secret provided")
}
}
func TestService_TestConnection_UsesStoredSecretWhenRequestEmpty(t *testing.T) {
func TestService_TestInstance_UsesStoredSecret(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "stored",
}); err != nil {
t.Fatalf("set: %v", err)
}
waitForAuthProbe(t, f)
inst := f.seedInstance(t, "ws-1", "A", "stored")
var sawSecret string
f.svc.clientFn = func(_ *SentryConfig, secret string) Client {
sawSecret = secret
return f.client
}
if _, err := f.svc.TestConnection(ctx, &SetConfigRequest{AuthMethod: AuthMethodAuthToken}); err != nil {
if _, err := f.svc.TestInstance(ctx, "ws-1", inst.ID); err != nil {
t.Fatalf("test: %v", err)
}
if sawSecret != "stored" {
t.Errorf("expected stored secret used, got %q", sawSecret)
}
}
func TestService_TestConnection_NoStoredSecret_ReturnsFailure(t *testing.T) {
f := newSvcFixture(t)
res, err := f.svc.TestConnection(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken,
})
if err != nil {
t.Fatalf("unexpected err: %v", err)
}
if res.OK {
t.Error("expected OK=false when no secret stored")
// Cross-workspace test is a 404.
if _, err := f.svc.TestInstance(ctx, "ws-2", inst.ID); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound cross-workspace, got %v", err)
}
}
func TestService_SearchIssues_PassesFilterThrough(t *testing.T) {
func TestService_Browse_RequireInstanceAndForwardsFilter(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "t",
}); err != nil {
t.Fatalf("set: %v", err)
inst := f.seedInstance(t, "ws-1", "A", "t")
// Missing instance ID → ErrInstanceRequired.
if _, err := f.svc.SearchIssues(ctx, "ws-1", "", SearchFilter{OrgSlug: "acme"}, ""); !errors.Is(err, ErrInstanceRequired) {
t.Errorf("expected ErrInstanceRequired for blank instanceID, got %v", err)
}
// Cross-workspace instance → ErrInstanceNotFound.
if _, err := f.svc.SearchIssues(ctx, "ws-2", inst.ID, SearchFilter{OrgSlug: "acme"}, ""); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound cross-workspace, got %v", err)
}
waitForAuthProbe(t, f)
var seenOrg string
f.client.searchIssuesFn = func(filter SearchFilter, _ string) (*SearchResult, error) {
seenOrg = filter.OrgSlug
return &SearchResult{IsLast: true}, nil
}
if _, err := f.svc.SearchIssues(ctx, SearchFilter{OrgSlug: "acme"}, ""); err != nil {
if _, err := f.svc.SearchIssues(ctx, "ws-1", inst.ID, SearchFilter{OrgSlug: "acme"}, ""); err != nil {
t.Fatalf("search: %v", err)
}
if seenOrg != "acme" {
@@ -318,225 +650,133 @@ func TestService_SearchIssues_PassesFilterThrough(t *testing.T) {
}
}
func TestService_GetIssue_NotConfigured(t *testing.T) {
func TestService_GetIssue_NotConfiguredWhenNoSecret(t *testing.T) {
f := newSvcFixture(t)
_, err := f.svc.GetIssue(context.Background(), "PROJ-1")
if !errors.Is(err, ErrNotConfigured) {
t.Errorf("expected ErrNotConfigured, got %v", err)
ctx := context.Background()
// Instance exists but has no stored secret → ErrNotConfigured (503).
inst := f.seedInstance(t, "ws-1", "A", "")
if _, err := f.svc.GetIssue(ctx, "ws-1", inst.ID, "PROJ-1"); !errors.Is(err, ErrNotConfigured) {
t.Errorf("expected ErrNotConfigured for secretless instance, got %v", err)
}
// Unknown instance → ErrInstanceNotFound (404).
if _, err := f.svc.GetIssue(ctx, "ws-1", "ghost", "PROJ-1"); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound for unknown instance, got %v", err)
}
}
func TestService_DeleteConfig_RemovesSecretAndCache(t *testing.T) {
// TestService_ClientCache_PerInstanceIsolation pins acceptance (j): each
// instance caches its own client; invalidating one does not rebuild the other.
func TestService_ClientCache_PerInstanceIsolation(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
_, _ = f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "t",
})
waitForAuthProbe(t, f)
if err := f.svc.DeleteConfig(ctx); err != nil {
t.Fatalf("delete: %v", err)
a := f.seedInstance(t, "ws-1", "A", "ta")
b := f.seedInstance(t, "ws-1", "B", "tb")
if _, err := f.svc.clientForInstance(ctx, a.ID); err != nil {
t.Fatalf("client a: %v", err)
}
if exists, _ := f.secrets.Exists(ctx, SecretKey); exists {
t.Error("expected secret removed")
if _, err := f.svc.clientForInstance(ctx, b.ID); err != nil {
t.Fatalf("client b: %v", err)
}
cfg, _ := f.svc.GetConfig(ctx)
if cfg != nil {
t.Errorf("expected config gone, got %+v", cfg)
if got := f.factoryHit.Load(); got != 2 {
t.Fatalf("expected 2 factory hits (one per instance), got %d", got)
}
// Cached: no new build.
_, _ = f.svc.clientForInstance(ctx, a.ID)
_, _ = f.svc.clientForInstance(ctx, b.ID)
if got := f.factoryHit.Load(); got != 2 {
t.Fatalf("expected cache hits (still 2 builds), got %d", got)
}
// Invalidate A only → A rebuilds, B stays cached.
f.svc.invalidateClient(a.ID)
_, _ = f.svc.clientForInstance(ctx, a.ID)
_, _ = f.svc.clientForInstance(ctx, b.ID)
if got := f.factoryHit.Load(); got != 3 {
t.Fatalf("expected only A to rebuild (3 total), got %d", got)
}
}
// TestService_ClientFor_InvalidateDuringBuild verifies the TOCTOU fix: when
// invalidateClient runs while clientFor is blocked on I/O, the freshly built
// (now-stale) client must not be stored in s.client. The subsequent call must
// rebuild, hitting the factory a second time.
// invalidateClient runs while clientForInstance is blocked on I/O, the freshly
// built (now-stale) client must not be cached. The next call must rebuild.
func TestService_ClientFor_InvalidateDuringBuild(t *testing.T) {
fakes := newFakeSecretStore()
_ = fakes.Set(context.Background(), SecretKeyForWorkspace("default"), "tok", "sntrys_xyz")
store := newTestStore(t)
ctx := context.Background()
// Seed a config row so clientFor gets past the nil-config check.
if err := store.UpsertConfig(ctx, &SentryConfig{
AuthMethod: AuthMethodAuthToken,
}); err != nil {
t.Fatalf("seed config: %v", err)
cfg := &SentryConfig{WorkspaceID: "ws-1", Name: "A", AuthMethod: AuthMethodAuthToken, URL: DefaultSentryURL}
if err := store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("seed instance: %v", err)
}
fakes := newFakeSecretStore()
_ = fakes.Set(ctx, secretKeyForInstance(cfg.ID), "tok", "sntrys_xyz")
var factoryHit atomic.Int32
client := &fakeClient{}
// invalidateCh is closed by the Reveal hook to signal the main goroutine
// to call invalidateClient while the first clientFor is mid-I/O.
invalidateCh := make(chan struct{})
// doneCh is closed by the Reveal hook after it has signalled.
doneCh := make(chan struct{})
slow := &slowSecretStore{fakeSecretStore: fakes}
svc := NewService(store, slow, func(_ *SentryConfig, _ string) Client {
factoryHit.Add(1)
return client
}, logger.Default())
invalidateCh := make(chan struct{})
slow.revealHook = func() {
// Signal that we're mid-I/O, then wait for the invalidation to complete.
close(invalidateCh)
// Give the invalidation goroutine time to run.
time.Sleep(10 * time.Millisecond)
close(doneCh)
}
// First clientFor call — will block in Reveal while we invalidate.
errCh := make(chan error, 1)
go func() {
_, err := svc.clientFor(ctx, "default")
_, err := svc.clientForInstance(ctx, cfg.ID)
errCh <- err
}()
// Wait until clientFor is inside Reveal, then invalidate.
<-invalidateCh
svc.invalidateClient("default")
// Wait for the first clientFor to finish.
svc.invalidateClient(cfg.ID)
if err := <-errCh; err != nil {
t.Fatalf("first clientFor: %v", err)
t.Fatalf("first clientForInstance: %v", err)
}
// The invalidation must have reset the cache, so s.client should be nil now.
// A second clientFor must hit the factory again (not return the cached stale client).
slow.revealHook = nil // no more blocking
if _, err := svc.clientFor(ctx, "default"); err != nil {
t.Fatalf("second clientFor: %v", err)
slow.revealHook = nil
if _, err := svc.clientForInstance(ctx, cfg.ID); err != nil {
t.Fatalf("second clientForInstance: %v", err)
}
if got := factoryHit.Load(); got < 2 {
t.Errorf("expected factory called at least twice (once per clientFor after invalidation), got %d", got)
t.Errorf("expected factory called at least twice after invalidation, got %d", got)
}
}
// TestService_SetConfig_DefaultsURLToSentryIO asserts a blank instance URL is
// stored as the sentry.io SaaS default.
func TestService_SetConfig_DefaultsURLToSentryIO(t *testing.T) {
f := newSvcFixture(t)
cfg, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "tok",
})
if err != nil {
t.Fatalf("set: %v", err)
}
if cfg.URL != DefaultSentryURL {
t.Errorf("expected URL defaulted to %q, got %q", DefaultSentryURL, cfg.URL)
}
}
// TestService_SetConfig_NormalizesAndPersistsURL asserts a host-only URL is
// normalized (scheme added, trailing slash trimmed) before being stored.
func TestService_SetConfig_NormalizesAndPersistsURL(t *testing.T) {
f := newSvcFixture(t)
cfg, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "tok", URL: "sentry.example.com/",
})
if err != nil {
t.Fatalf("set: %v", err)
}
if cfg.URL != "https://sentry.example.com" {
t.Errorf("expected normalized URL, got %q", cfg.URL)
}
}
// TestService_SetConfig_RejectsMalformedURL asserts a non-http(s) URL is
// rejected at save time.
func TestService_SetConfig_RejectsMalformedURL(t *testing.T) {
f := newSvcFixture(t)
_, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "tok", URL: "ftp://nope",
})
if err == nil {
t.Error("expected validation error for non-http(s) URL")
}
}
// TestService_TestConnection_PassesConfiguredURL ensures a pre-save test uses
// the URL the user typed in the form, so a self-hosted instance can be
// validated before the config is persisted.
func TestService_TestConnection_PassesConfiguredURL(t *testing.T) {
f := newSvcFixture(t)
var sawURL string
f.svc.clientFn = func(cfg *SentryConfig, _ string) Client {
sawURL = cfg.URL
return f.client
}
if _, err := f.svc.TestConnection(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "inline", URL: "https://sentry.example.com",
}); err != nil {
t.Fatalf("test: %v", err)
}
if sawURL != "https://sentry.example.com" {
t.Errorf("expected configured URL passed to client, got %q", sawURL)
}
}
// TestService_TestConnection_FallsBackToStoredURL covers the post-save "Test
// connection" path (blank secret, blank URL in the request): the stored
// instance URL must be used rather than silently reverting to sentry.io.
func TestService_TestConnection_FallsBackToStoredURL(t *testing.T) {
// TestService_DeleteInstance_SoleInstanceCountsUnboundWatches pins the P1 fix:
// deleting a workspace's sole instance must be refused while unbound (NULL
// sentry_instance_id) watches exist, because resolveWatchInstanceID resolves
// them to that instance at poll time. The unbound watch does not trip the FK
// (its instance id is NULL), so the service must count it explicitly.
func TestService_DeleteInstance_SoleInstanceCountsUnboundWatches(t *testing.T) {
f := newSvcFixture(t)
ctx := context.Background()
if _, err := f.svc.SetConfig(ctx, &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "stored", URL: "https://sentry.example.com",
}); err != nil {
t.Fatalf("set: %v", err)
inst := f.seedInstance(t, "ws-1", "A", "t")
// Unbound watch: no SentryInstanceID → NULL in the DB.
if err := f.store.CreateIssueWatch(ctx, newTestIssueWatch("ws-1")); err != nil {
t.Fatalf("create unbound watch: %v", err)
}
waitForAuthProbe(t, f)
var sawURL string
f.svc.clientFn = func(cfg *SentryConfig, _ string) Client {
sawURL = cfg.URL
return f.client
err := f.svc.DeleteInstance(ctx, "ws-1", inst.ID)
var inUse ErrInstanceInUse
if !errors.As(err, &inUse) {
t.Fatalf("expected ErrInstanceInUse for sole instance with unbound watch, got %v", err)
}
if _, err := f.svc.TestConnection(ctx, &SetConfigRequest{AuthMethod: AuthMethodAuthToken}); err != nil {
t.Fatalf("test: %v", err)
}
if sawURL != "https://sentry.example.com" {
t.Errorf("expected stored URL used, got %q", sawURL)
if inUse.WatchCount != 1 {
t.Errorf("expected unbound watch counted (1), got %d", inUse.WatchCount)
}
}
// TestService_SetConfig_RejectsNonRootURL asserts URLs carrying a path, query,
// or fragment are rejected, so /api/0 cannot be appended to a malformed base.
func TestService_SetConfig_RejectsNonRootURL(t *testing.T) {
cases := []struct {
name string
url string
}{
{"path", "https://sentry.example.com/some/path"},
{"query", "https://sentry.example.com?x=1"},
{"fragment", "https://sentry.example.com#frag"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
f := newSvcFixture(t)
_, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "tok", URL: tc.url,
})
if err == nil {
t.Errorf("expected rejection of non-root URL %q", tc.url)
}
})
}
}
// TestService_SetConfig_AllowsHostRootWithTrailingSlash guards the boundary:
// a bare host root (with or without a trailing slash) must still be accepted
// and normalized, so the non-root rejection above doesn't over-reach.
func TestService_SetConfig_AllowsHostRootWithTrailingSlash(t *testing.T) {
// TestService_DeleteInstance_UnboundNotCountedWhenMultipleInstances is the
// complement: with a second instance present, an unbound watch stays resolvable
// after one instance is removed, so it must not block that delete.
func TestService_DeleteInstance_UnboundNotCountedWhenMultipleInstances(t *testing.T) {
f := newSvcFixture(t)
cfg, err := f.svc.SetConfig(context.Background(), &SetConfigRequest{
AuthMethod: AuthMethodAuthToken, Secret: "tok", URL: "https://sentry.example.com/",
})
if err != nil {
t.Fatalf("host root with trailing slash should be accepted: %v", err)
ctx := context.Background()
a := f.seedInstance(t, "ws-1", "A", "t")
f.seedInstance(t, "ws-1", "B", "t")
if err := f.store.CreateIssueWatch(ctx, newTestIssueWatch("ws-1")); err != nil {
t.Fatalf("create unbound watch: %v", err)
}
if cfg.URL != "https://sentry.example.com" {
t.Errorf("expected trailing slash trimmed, got %q", cfg.URL)
if err := f.svc.DeleteInstance(ctx, "ws-1", a.ID); err != nil {
t.Fatalf("expected delete to succeed with a second instance present, got %v", err)
}
}
+599 -122
View File
@@ -5,19 +5,21 @@ import (
"database/sql"
"errors"
"fmt"
"net/url"
"strings"
"time"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
"github.com/kandev/kandev/internal/integrations/workspacescope"
)
// Store persists workspace-scoped Sentry configuration. The secret token is
// delegated to the shared encrypted secret store and not stored here.
// Store persists workspace-scoped Sentry instances. Each instance's secret
// token is delegated to the shared encrypted secret store and not stored here.
type Store struct {
db *sqlx.DB
ro *sqlx.DB
defaultWorkspace workspacescope.DefaultResolver
migratedToWorkspace string
}
@@ -30,21 +32,34 @@ func NewStore(writer, reader *sqlx.DB) (*Store, error) {
return s, nil
}
const createTablesSQL = `
CREATE TABLE IF NOT EXISTS sentry_configs (
workspace_id TEXT PRIMARY KEY,
// sentryConfigsColumns is the id-keyed multi-instance sentry_configs column
// list, shared by createTablesSQL and the workspace→instance rebuild so the two
// can never drift.
const sentryConfigsColumns = `
id TEXT PRIMARY KEY,
workspace_id TEXT NOT NULL,
name TEXT NOT NULL,
auth_method TEXT NOT NULL,
url TEXT NOT NULL DEFAULT 'https://sentry.io',
last_checked_at DATETIME,
last_ok INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
);
updated_at DATETIME NOT NULL,
UNIQUE(workspace_id, name)`
CREATE TABLE IF NOT EXISTS sentry_issue_watches (
// sentryWatchesColumns is the sentry_issue_watches column list including the
// nullable sentry_instance_id foreign key. Shared by createTablesSQL and the
// instance-column rebuild.
const sentryWatchesColumns = `
id TEXT PRIMARY KEY,
workspace_id TEXT NOT NULL,
-- Bound Sentry instance. NULL = legacy unbound watch (created before a
-- workspace had an instance, or migrated from the single-config model);
-- the poller resolves an unbound watch to the workspace's sole instance
-- at poll time. ON DELETE RESTRICT so an in-use instance cannot be
-- deleted out from under a watch.
sentry_instance_id TEXT,
workflow_id TEXT NOT NULL,
workflow_step_id TEXT NOT NULL,
-- Optional repository binding. Empty = unbound (repo-less task, the
@@ -63,7 +78,16 @@ const createTablesSQL = `
last_error TEXT NOT NULL DEFAULT '',
last_error_at DATETIME,
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
updated_at DATETIME NOT NULL,
FOREIGN KEY(sentry_instance_id) REFERENCES sentry_configs(id) ON DELETE RESTRICT`
const createTablesSQL = `
CREATE TABLE IF NOT EXISTS sentry_configs (` + sentryConfigsColumns + `
);
CREATE INDEX IF NOT EXISTS idx_sentry_configs_workspace
ON sentry_configs(workspace_id);
CREATE TABLE IF NOT EXISTS sentry_issue_watches (` + sentryWatchesColumns + `
);
CREATE INDEX IF NOT EXISTS idx_sentry_issue_watches_workspace
ON sentry_issue_watches(workspace_id);
@@ -85,17 +109,31 @@ const createTablesSQL = `
const singletonID = "singleton"
// MigratedFromWorkspace is kept for parity with Jira/Linear provider
// migrations. It returns the workspace_id that received a legacy singleton row.
// migrations. It returns the workspace_id that received a legacy singleton row,
// so the provider secret migration can rekey the token from the singleton
// secret key to the workspace key before it is rekeyed again per instance.
func (s *Store) MigratedFromWorkspace() string {
return s.migratedToWorkspace
}
// initSchema creates the integration tables when absent and applies the
// additive column migrations that bring older databases to the current schema.
// initSchema brings any database shape up to the id-keyed multi-instance model
// and applies the additive column migrations. Ordering matters:
// 1. legacy singleton → workspace-keyed (PR #1572's migration, kept verbatim);
// 2. workspace-keyed → id-keyed instances (this change);
// 3. createTablesSQL builds any absent table (fresh install, or the empty
// sentry_configs a watches-only migration needs to reference);
// 4. additive ALTER-ADD column migrations reach the full pre-FK watches shape;
// 5. watches table rebuild adds the nullable sentry_instance_id FK + backfill.
//
// Steps 2 and 5 are each guarded on shape detection so a crash between them
// re-runs safely.
func (s *Store) initSchema() error {
if err := s.migrateLegacySingletonTable(); err != nil {
return err
}
if err := s.migrateConfigsTableToInstances(); err != nil {
return err
}
if _, err := s.db.Exec(createTablesSQL); err != nil {
return err
}
@@ -108,7 +146,19 @@ func (s *Store) initSchema() error {
if err := s.addIssueWatchLastErrorColumns(); err != nil {
return err
}
return s.addIssueWatchRepositoryColumns()
if err := s.addIssueWatchRepositoryColumns(); err != nil {
return err
}
if err := s.migrateWatchesAddInstanceColumn(); err != nil {
return err
}
// The instance index is created here rather than in createTablesSQL: on a
// pre-#1572 database the watches table exists without the sentry_instance_id
// column until the rebuild above adds it, so indexing that column earlier
// would fail. Idempotent for fresh installs (column already present).
_, err := s.db.Exec(`CREATE INDEX IF NOT EXISTS idx_sentry_issue_watches_instance
ON sentry_issue_watches(sentry_instance_id)`)
return err
}
func (s *Store) migrateLegacySingletonTable() error {
@@ -187,6 +237,364 @@ func (s *Store) migrateLegacySingletonTable() error {
return nil
}
// legacyWorkspaceConfig is one row of the pre-instance workspace-keyed
// sentry_configs table, read before the id-keyed rebuild.
type legacyWorkspaceConfig struct {
workspaceID string
authMethod string
url string
lastCheckedAt sql.NullTime
lastOk int64
lastError string
createdAt sql.NullTime
updatedAt sql.NullTime
}
// migrateConfigsTableToInstances rebuilds a workspace-keyed sentry_configs
// table (PR #1572's one-config-per-workspace shape: workspace_id PRIMARY KEY,
// no id column) into the id-keyed multi-instance shape, creating exactly one
// instance per existing workspace row (id=uuid, name derived from the URL host
// with per-workspace suffixing on collision). Idempotent: a table that already
// has an id column (fresh install or a completed prior run) is left untouched,
// so a crash between this step and the watch rebuild re-runs safely.
func (s *Store) migrateConfigsTableToInstances() error {
cols, err := s.tableColumns("sentry_configs")
if err != nil {
return err
}
if len(cols) == 0 {
return nil // fresh install — createTablesSQL builds the id-keyed table.
}
if _, hasID := cols["id"]; hasID {
return nil // already id-keyed.
}
if _, hasWorkspace := cols["workspace_id"]; !hasWorkspace {
return nil // unexpected shape; the legacy-singleton path owns it.
}
legacy, err := s.readLegacyWorkspaceConfigs(cols)
if err != nil {
return err
}
usedNames := make(map[string]map[string]struct{})
ids := make([]string, len(legacy))
names := make([]string, len(legacy))
for i, r := range legacy {
if usedNames[r.workspaceID] == nil {
usedNames[r.workspaceID] = make(map[string]struct{})
}
ids[i] = uuid.New().String()
names[i] = uniqueInstanceName(usedNames[r.workspaceID], hostFromURL(r.url))
}
tx, err := s.db.Begin()
if err != nil {
return err
}
defer func() { _ = tx.Rollback() }()
if _, err := tx.Exec(`DROP TABLE sentry_configs`); err != nil {
return err
}
if _, err := tx.Exec(`CREATE TABLE sentry_configs (` + sentryConfigsColumns + `)`); err != nil {
return err
}
for i, r := range legacy {
if _, err := tx.Exec(`
INSERT INTO sentry_configs (id, workspace_id, name, auth_method, url,
last_checked_at, last_ok, last_error, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
ids[i], r.workspaceID, names[i], r.authMethod, r.url,
nullableTime(r.lastCheckedAt), r.lastOk, r.lastError,
nullableTime(r.createdAt), nullableTime(r.updatedAt)); err != nil {
return err
}
}
return tx.Commit()
}
// readLegacyWorkspaceConfigs reads every row of the workspace-keyed
// sentry_configs table, defaulting url / health columns for databases predating
// them so the rebuild always has a complete row.
func (s *Store) readLegacyWorkspaceConfigs(cols map[string]struct{}) ([]legacyWorkspaceConfig, error) {
selectCols := "workspace_id, auth_method"
if _, ok := cols["url"]; ok {
selectCols += ", url"
} else {
selectCols += ", 'https://sentry.io' AS url"
}
if healthColumnsPresent(cols) {
selectCols += ", last_checked_at, last_ok, last_error"
} else {
selectCols += ", NULL AS last_checked_at, 0 AS last_ok, '' AS last_error"
}
selectCols += ", created_at, updated_at"
rows, err := s.db.Query(`SELECT ` + selectCols + ` FROM sentry_configs ORDER BY created_at, workspace_id`)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
var out []legacyWorkspaceConfig
for rows.Next() {
var r legacyWorkspaceConfig
if err := rows.Scan(&r.workspaceID, &r.authMethod, &r.url,
&r.lastCheckedAt, &r.lastOk, &r.lastError, &r.createdAt, &r.updatedAt); err != nil {
return nil, err
}
out = append(out, r)
}
return out, rows.Err()
}
// migrateWatchesAddInstanceColumn rebuilds sentry_issue_watches to add the
// nullable sentry_instance_id foreign key. SQLite cannot ALTER-ADD a column
// with a FOREIGN KEY clause, so the table is rebuilt: create new, copy rows,
// drop old, rename. An unbound watch is backfilled only when its workspace has
// exactly one instance; zero or multiple candidates remain NULL for the
// poll-time fallback. Existing valid experimental bindings survive the rebuild.
// The rebuild runs on a dedicated connection with foreign_keys temporarily off
// so DROP TABLE does not cascade-delete sentry_issue_watch_tasks children (the
// PRAGMA is a no-op inside a transaction and per-connection), then restores
// enforcement. Idempotent: the migration is skipped only when the column
// already has the exact nullable-FK target shape, so a crash mid-migration (or
// an older wrong-shaped column) always re-runs safely.
func (s *Store) migrateWatchesAddInstanceColumn() error {
cols, err := s.tableColumns("sentry_issue_watches")
if err != nil {
return err
}
if len(cols) == 0 {
return nil // fresh install — createTablesSQL builds the column + FK.
}
hasExistingInstanceID := false
if _, ok := cols["sentry_instance_id"]; ok {
correct, err := s.watchesInstanceColumnCorrect()
if err != nil {
return err
}
if correct {
return nil // already the nullable-FK shape.
}
// Column exists but predates the FK/nullable schema (an experimental
// pre-release build stored it as NOT NULL DEFAULT '' with no foreign
// key). Rebuild it into the correct shape while preserving a valid
// explicit binding.
hasExistingInstanceID = true
}
ctx := context.Background()
conn, err := s.db.Conn(ctx)
if err != nil {
return err
}
defer func() { _ = conn.Close() }()
if _, err := conn.ExecContext(ctx, `PRAGMA foreign_keys = OFF`); err != nil {
return err
}
// Restore enforcement on the way out regardless of outcome.
defer func() { _, _ = conn.ExecContext(ctx, `PRAGMA foreign_keys = ON`) }()
return rebuildWatchesWithInstanceColumn(ctx, conn, hasExistingInstanceID)
}
// watchesInstanceColumnCorrect reports whether sentry_issue_watches
// .sentry_instance_id already has the target shape: a NULLABLE column backed by
// a foreign key to sentry_configs. Older experimental builds added it as
// NOT NULL DEFAULT ” without a foreign key; those must be rebuilt, not skipped.
func (s *Store) watchesInstanceColumnCorrect() (bool, error) {
nullable, err := s.columnIsNullable("sentry_issue_watches", "sentry_instance_id")
if err != nil {
return false, err
}
if !nullable {
return false, nil
}
return s.hasForeignKey("sentry_issue_watches", "sentry_instance_id", "sentry_configs", "id", "RESTRICT")
}
// columnIsNullable reports whether a column exists and permits NULL (PRAGMA
// table_info notnull flag == 0).
func (s *Store) columnIsNullable(table, column string) (bool, error) {
rows, err := s.db.Query(fmt.Sprintf("PRAGMA table_info(%s)", table))
if err != nil {
return false, err
}
defer func() { _ = rows.Close() }()
for rows.Next() {
var (
cid int
name string
ctype string
notnull int
dflt sql.NullString
pk int
)
if err := rows.Scan(&cid, &name, &ctype, &notnull, &dflt, &pk); err != nil {
return false, err
}
if name == column {
return notnull == 0, nil
}
}
return false, rows.Err()
}
// hasForeignKey reports whether `table` has a foreign key from `column` to
// `refTable(wantRefColumn)` with the given ON DELETE rule (PRAGMA
// foreign_key_list; SQLite reports on_delete uppercased, e.g. "RESTRICT").
func (s *Store) hasForeignKey(table, column, refTable, wantRefColumn, wantOnDelete string) (bool, error) {
rows, err := s.db.Query(fmt.Sprintf("PRAGMA foreign_key_list(%s)", table))
if err != nil {
return false, err
}
type fkRow struct {
from string
refTbl string
to sql.NullString
onDelete string
}
var fks []fkRow
for rows.Next() {
var (
id int
seq int
refTbl string
from string
to sql.NullString
onUpdate string
onDelete string
match string
)
if err := rows.Scan(&id, &seq, &refTbl, &from, &to, &onUpdate, &onDelete, &match); err != nil {
_ = rows.Close()
return false, err
}
fks = append(fks, fkRow{from: from, refTbl: refTbl, to: to, onDelete: onDelete})
}
if err := rows.Err(); err != nil {
_ = rows.Close()
return false, err
}
if err := rows.Close(); err != nil {
return false, err
}
for _, fk := range fks {
if fk.from != column || fk.refTbl != refTable || fk.onDelete != wantOnDelete {
continue
}
toColumn := fk.to.String
if !fk.to.Valid {
// SQLite reports `to` as NULL when the FK references the referenced
// table's PRIMARY KEY implicitly (`REFERENCES sentry_configs` rather
// than `REFERENCES sentry_configs(id)`). Resolve it to the
// single-column PK — after the rows above are closed so this nested
// query never contends for a single-connection pool.
pk, err := s.singleColumnPrimaryKey(fk.refTbl)
if err != nil {
return false, err
}
toColumn = pk
}
if toColumn == wantRefColumn {
return true, nil
}
}
return false, nil
}
// singleColumnPrimaryKey returns the primary-key column of table when it has
// exactly one; empty for a table with no primary key or a composite one. Used
// to resolve a NULL `to` in foreign_key_list, which SQLite reports when a FK
// references the referenced table's PRIMARY KEY implicitly.
func (s *Store) singleColumnPrimaryKey(table string) (string, error) {
rows, err := s.db.Query(fmt.Sprintf("PRAGMA table_info(%s)", table))
if err != nil {
return "", err
}
defer func() { _ = rows.Close() }()
pkCols := make([]string, 0, 1)
for rows.Next() {
var (
cid int
name string
ctype string
notnull int
dflt sql.NullString
pk int
)
if err := rows.Scan(&cid, &name, &ctype, &notnull, &dflt, &pk); err != nil {
return "", err
}
if pk > 0 {
pkCols = append(pkCols, name)
}
}
if err := rows.Err(); err != nil {
return "", err
}
if len(pkCols) == 1 {
return pkCols[0], nil
}
return "", nil
}
// rebuildWatchesWithInstanceColumn performs the create/copy/drop/rename table
// rebuild inside a single transaction on conn (which already has foreign_keys
// disabled). A legacy unbound watch is backfilled only when its workspace has
// exactly one instance; otherwise NULL preserves the poll-time fallback.
func rebuildWatchesWithInstanceColumn(ctx context.Context, conn *sql.Conn, hasExistingInstanceID bool) error {
instanceIDExpr := `
CASE
WHEN (SELECT COUNT(*) FROM sentry_configs c WHERE c.workspace_id = w.workspace_id) = 1 THEN
(SELECT c.id FROM sentry_configs c WHERE c.workspace_id = w.workspace_id)
ELSE NULL
END`
if hasExistingInstanceID {
instanceIDExpr = `
CASE
WHEN w.sentry_instance_id <> '' THEN
(SELECT c.id FROM sentry_configs c
WHERE c.id = w.sentry_instance_id AND c.workspace_id = w.workspace_id)
WHEN (SELECT COUNT(*) FROM sentry_configs c WHERE c.workspace_id = w.workspace_id) = 1 THEN
(SELECT c.id FROM sentry_configs c WHERE c.workspace_id = w.workspace_id)
ELSE NULL
END`
}
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
return err
}
defer func() { _ = tx.Rollback() }()
if _, err := tx.ExecContext(ctx, `CREATE TABLE sentry_issue_watches_new (`+sentryWatchesColumns+`)`); err != nil {
return err
}
copySQL := `
INSERT INTO sentry_issue_watches_new (
id, workspace_id, sentry_instance_id, workflow_id, workflow_step_id,
repository_id, base_branch, filter_json, agent_profile_id,
executor_profile_id, prompt, enabled, poll_interval_seconds,
max_inflight_tasks, last_polled_at, last_error, last_error_at,
created_at, updated_at)
SELECT
w.id, w.workspace_id,` + instanceIDExpr + `,
w.workflow_id, w.workflow_step_id, w.repository_id, w.base_branch,
w.filter_json, w.agent_profile_id, w.executor_profile_id, w.prompt,
w.enabled, w.poll_interval_seconds, w.max_inflight_tasks,
w.last_polled_at, w.last_error, w.last_error_at, w.created_at, w.updated_at
FROM sentry_issue_watches w`
if _, err := tx.ExecContext(ctx, copySQL); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `DROP TABLE sentry_issue_watches`); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `ALTER TABLE sentry_issue_watches_new RENAME TO sentry_issue_watches`); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_sentry_issue_watches_workspace ON sentry_issue_watches(workspace_id)`); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_sentry_issue_watches_instance ON sentry_issue_watches(sentry_instance_id)`); err != nil {
return err
}
return tx.Commit()
}
func isLegacySingletonConfig(cols map[string]struct{}) bool {
if len(cols) == 0 {
return false
@@ -214,12 +622,45 @@ func nullableTime(t sql.NullTime) interface{} {
return t.Time
}
// defaultInstanceName is the fallback instance name when a URL yields no host.
const defaultInstanceName = "Sentry"
// hostFromURL extracts the host of a Sentry instance URL for use as a default
// instance name. Falls back to "Sentry" for a blank/unparseable URL.
func hostFromURL(rawURL string) string {
rawURL = strings.TrimSpace(rawURL)
if rawURL == "" {
return defaultInstanceName
}
u, err := url.Parse(rawURL)
if err != nil || u.Host == "" {
return defaultInstanceName
}
return u.Host
}
// uniqueInstanceName returns a name unique within the supplied set, suffixing
// " (2)", " (3)", … on collision. The chosen name is recorded in used so the
// next call for the same workspace avoids it.
func uniqueInstanceName(used map[string]struct{}, base string) string {
if base == "" {
base = defaultInstanceName
}
name := base
for i := 2; ; i++ {
if _, taken := used[name]; !taken {
used[name] = struct{}{}
return name
}
name = fmt.Sprintf("%s (%d)", base, i)
}
}
// addIssueWatchRepositoryColumns brings older databases up to the current
// schema by appending repository_id / base_branch to sentry_issue_watches when
// missing. Both backfill to ” (unbound), so existing repo-less watches keep
// their behaviour. Fresh installs hit the column-already-present branch since
// createTablesSQL declares both columns. Idempotent — column lookup before each
// ALTER avoids the "duplicate column name" error.
// their behaviour. Idempotent — column lookup before each ALTER avoids the
// "duplicate column name" error.
func (s *Store) addIssueWatchRepositoryColumns() error {
cols, err := s.tableColumns("sentry_issue_watches")
if err != nil {
@@ -241,11 +682,9 @@ func (s *Store) addIssueWatchRepositoryColumns() error {
return nil
}
// addConfigURLColumn brings older databases up to the current schema by adding
// the url column to sentry_configs when missing. Existing rows — all SaaS
// installs, since this predates self-hosted support — backfill to the
// sentry.io default (mirrors DefaultSentryURL). A fresh install hits the
// column-already-present branch since createTablesSQL declares the column.
// addConfigURLColumn adds the url column to a workspace-keyed sentry_configs
// table when missing (a pre-self-hosted database). Retained for the upgrade
// lineage; the id-keyed table always declares url, so this is a no-op there.
func (s *Store) addConfigURLColumn() error {
cols, err := s.tableColumns("sentry_configs")
if err != nil {
@@ -263,10 +702,9 @@ func (s *Store) addConfigURLColumn() error {
return nil
}
// addMaxInflightTasksColumn brings older databases up to the current schema by
// adding the max_inflight_tasks column to sentry_issue_watches when missing.
// Existing rows backfill to the default (5). A fresh install hits the
// column-already-present branch since createTablesSQL declares the column.
// addMaxInflightTasksColumn adds the max_inflight_tasks column to
// sentry_issue_watches when missing, backfilling existing rows to the default
// (5). Idempotent.
func (s *Store) addMaxInflightTasksColumn() error {
cols, err := s.tableColumns("sentry_issue_watches")
if err != nil {
@@ -284,11 +722,9 @@ func (s *Store) addMaxInflightTasksColumn() error {
return nil
}
// addIssueWatchLastErrorColumns brings older databases up to the current
// schema by appending last_error / last_error_at to sentry_issue_watches when
// missing. Fresh installs hit the column-already-present branch since
// createTablesSQL declares both columns. Idempotent — column lookup before
// each ALTER avoids the "duplicate column name" error.
// addIssueWatchLastErrorColumns appends last_error / last_error_at to
// sentry_issue_watches when missing. Idempotent — column lookup before each
// ALTER avoids the "duplicate column name" error.
func (s *Store) addIssueWatchLastErrorColumns() error {
cols, err := s.tableColumns("sentry_issue_watches")
if err != nil {
@@ -311,7 +747,8 @@ func (s *Store) addIssueWatchLastErrorColumns() error {
}
// tableColumns returns the set of column names for a table via PRAGMA
// table_info, used by the lightweight ADD COLUMN migrations above.
// table_info, used by the lightweight ADD COLUMN migrations and the shape
// detection guarding the table rebuilds above.
func (s *Store) tableColumns(table string) (map[string]struct{}, error) {
rows, err := s.db.Query(fmt.Sprintf("PRAGMA table_info(%s)", table))
if err != nil {
@@ -336,29 +773,37 @@ func (s *Store) tableColumns(table string) (map[string]struct{}, error) {
return cols, rows.Err()
}
const selectConfigColumns = `workspace_id, auth_method, url,
const selectInstanceColumns = `id, workspace_id, name, auth_method, url,
last_checked_at, last_ok, last_error, created_at, updated_at`
// GetConfig returns the default workspace Sentry config, or nil when no row
// exists. New code should call GetConfigForWorkspace.
func (s *Store) GetConfig(ctx context.Context) (*SentryConfig, error) {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
// ListInstances returns every Sentry instance in a workspace, ordered by name.
func (s *Store) ListInstances(ctx context.Context, workspaceID string) ([]*SentryConfig, error) {
var rows []SentryConfig
if err := s.ro.SelectContext(ctx, &rows,
`SELECT `+selectInstanceColumns+` FROM sentry_configs WHERE workspace_id = ? ORDER BY name, id`,
workspaceID); err != nil {
return nil, err
}
return s.GetConfigForWorkspace(ctx, workspaceID)
return instancePtrs(rows), nil
}
// GetConfigForWorkspace returns the Sentry config for a workspace, or nil when
// no row exists.
func (s *Store) GetConfigForWorkspace(ctx context.Context, workspaceID string) (*SentryConfig, error) {
workspaceID, err := s.resolveWorkspaceID(workspaceID)
if err != nil {
// ListAllInstances returns every instance across all workspaces. Used by the
// auth-health poller and the provider secret rekey.
func (s *Store) ListAllInstances(ctx context.Context) ([]*SentryConfig, error) {
var rows []SentryConfig
if err := s.ro.SelectContext(ctx, &rows,
`SELECT `+selectInstanceColumns+` FROM sentry_configs ORDER BY workspace_id, name, id`); err != nil {
return nil, err
}
return instancePtrs(rows), nil
}
// GetInstance returns an instance by ID, or nil when no row matches. Ownership
// is checked by the service against the request's workspace.
func (s *Store) GetInstance(ctx context.Context, id string) (*SentryConfig, error) {
var cfg SentryConfig
err = s.ro.GetContext(ctx, &cfg,
`SELECT `+selectConfigColumns+` FROM sentry_configs WHERE workspace_id = ?`, workspaceID)
err := s.ro.GetContext(ctx, &cfg,
`SELECT `+selectInstanceColumns+` FROM sentry_configs WHERE id = ?`, id)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
@@ -368,109 +813,141 @@ func (s *Store) GetConfigForWorkspace(ctx context.Context, workspaceID string) (
return &cfg, nil
}
// UpsertConfig inserts or updates the default workspace config row. The last_* health
// columns are owned by the poller and written via UpdateAuthHealth.
func (s *Store) UpsertConfig(ctx context.Context, cfg *SentryConfig) error {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return err
}
return s.UpsertConfigForWorkspace(ctx, workspaceID, cfg)
}
// UpsertConfigForWorkspace inserts or updates a workspace config row.
func (s *Store) UpsertConfigForWorkspace(ctx context.Context, workspaceID string, cfg *SentryConfig) error {
workspaceID, err := s.resolveWorkspaceID(workspaceID)
if err != nil {
return err
// CreateInstance inserts a new instance row. ID and timestamps are assigned
// here when unset. A duplicate (workspace_id, name) surfaces as
// ErrDuplicateInstanceName.
func (s *Store) CreateInstance(ctx context.Context, cfg *SentryConfig) error {
if cfg.ID == "" {
cfg.ID = uuid.New().String()
}
now := time.Now().UTC()
if cfg.CreatedAt.IsZero() {
cfg.CreatedAt = now
}
cfg.UpdatedAt = now
_, err = s.db.ExecContext(ctx, `
INSERT INTO sentry_configs (workspace_id, auth_method, url, created_at, updated_at)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT(workspace_id) DO UPDATE SET
auth_method = excluded.auth_method,
url = excluded.url,
updated_at = excluded.updated_at`,
workspaceID, cfg.AuthMethod, cfg.URL, cfg.CreatedAt, cfg.UpdatedAt)
_, err := s.db.ExecContext(ctx, `
INSERT INTO sentry_configs (id, workspace_id, name, auth_method, url, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?)`,
cfg.ID, cfg.WorkspaceID, cfg.Name, cfg.AuthMethod, cfg.URL, cfg.CreatedAt, cfg.UpdatedAt)
if isUniqueViolation(err) {
return ErrDuplicateInstanceName
}
return err
}
// DeleteConfig removes the default workspace config row.
func (s *Store) DeleteConfig(ctx context.Context) error {
workspaceID, err := s.defaultWorkspaceID()
// UpdateInstance overwrites name/auth_method/url of an existing instance. The
// last_* health columns are owned by the poller. Returns ErrInstanceNotFound
// when no row matches and ErrDuplicateInstanceName on a name collision.
func (s *Store) UpdateInstance(ctx context.Context, cfg *SentryConfig) error {
cfg.UpdatedAt = time.Now().UTC()
res, err := s.db.ExecContext(ctx, `
UPDATE sentry_configs SET name = ?, auth_method = ?, url = ?, updated_at = ?
WHERE id = ?`,
cfg.Name, cfg.AuthMethod, cfg.URL, cfg.UpdatedAt, cfg.ID)
if isUniqueViolation(err) {
return ErrDuplicateInstanceName
}
if err != nil {
return err
}
return s.DeleteConfigForWorkspace(ctx, workspaceID)
}
// DeleteConfigForWorkspace removes the workspace config row.
func (s *Store) DeleteConfigForWorkspace(ctx context.Context, workspaceID string) error {
workspaceID, err := s.resolveWorkspaceID(workspaceID)
n, err := res.RowsAffected()
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `DELETE FROM sentry_configs WHERE workspace_id = ?`, workspaceID)
return err
if n == 0 {
return ErrInstanceNotFound
}
return nil
}
// HasConfig reports whether any config row exists. Used by the auth-health
// poller to decide whether to probe at all.
// DeleteInstance removes an instance row. A watch still referencing it trips
// the ON DELETE RESTRICT foreign key, surfaced as ErrInstanceInUse (the service
// fills the watch count). Returns ErrInstanceNotFound when no row matches.
func (s *Store) DeleteInstance(ctx context.Context, id string) error {
res, err := s.db.ExecContext(ctx, `DELETE FROM sentry_configs WHERE id = ?`, id)
if isForeignKeyViolation(err) {
return ErrInstanceInUse{}
}
if err != nil {
return err
}
n, err := res.RowsAffected()
if err != nil {
return err
}
if n == 0 {
return ErrInstanceNotFound
}
return nil
}
// CountWatchesForInstance counts every watch (enabled and disabled) bound to an
// instance, used to reject deletion of an in-use instance with a friendly count.
func (s *Store) CountWatchesForInstance(ctx context.Context, instanceID string) (int, error) {
var n int
if err := s.ro.GetContext(ctx, &n,
`SELECT COUNT(*) FROM sentry_issue_watches WHERE sentry_instance_id = ?`, instanceID); err != nil {
return 0, err
}
return n, nil
}
// CountUnboundIssueWatchesInWorkspace counts watches in a workspace that are not
// bound to any instance (sentry_instance_id IS NULL). resolveWatchInstanceID
// resolves these legacy/migrated watches to the workspace's sole instance at
// poll time, so deleting that sole instance would strand them.
func (s *Store) CountUnboundIssueWatchesInWorkspace(ctx context.Context, workspaceID string) (int, error) {
var n int
if err := s.ro.GetContext(ctx, &n,
`SELECT COUNT(*) FROM sentry_issue_watches WHERE workspace_id = ? AND sentry_instance_id IS NULL`, workspaceID); err != nil {
return 0, err
}
return n, nil
}
// UpdateAuthHealthForInstance records the result of a credential probe on one
// instance row.
func (s *Store) UpdateAuthHealthForInstance(ctx context.Context, id string, ok bool, errMsg string, checkedAt time.Time) error {
res, err := s.db.ExecContext(ctx, `
UPDATE sentry_configs
SET last_checked_at = ?, last_ok = ?, last_error = ?
WHERE id = ?`,
checkedAt, ok, errMsg, id)
if err != nil {
return err
}
n, err := res.RowsAffected()
if err != nil {
return err
}
if n == 0 {
return ErrInstanceNotFound
}
return nil
}
// HasConfig reports whether any instance exists. Used by the auth-health poller
// to decide whether to probe at all.
func (s *Store) HasConfig(ctx context.Context) (bool, error) {
var present int
err := s.ro.GetContext(ctx, &present,
`SELECT COUNT(*) FROM sentry_configs`)
if err != nil {
if err := s.ro.GetContext(ctx, &present, `SELECT COUNT(*) FROM sentry_configs`); err != nil {
return false, err
}
return present > 0, nil
}
// ListConfigWorkspaceIDs returns every workspace with a saved Sentry config.
func (s *Store) ListConfigWorkspaceIDs(ctx context.Context) ([]string, error) {
var ids []string
if err := s.ro.SelectContext(ctx, &ids, `SELECT workspace_id FROM sentry_configs ORDER BY workspace_id`); err != nil {
return nil, err
func instancePtrs(rows []SentryConfig) []*SentryConfig {
out := make([]*SentryConfig, len(rows))
for i := range rows {
out[i] = &rows[i]
}
return ids, nil
return out
}
// UpdateAuthHealth records the result of a credential probe.
func (s *Store) UpdateAuthHealth(ctx context.Context, ok bool, errMsg string, checkedAt time.Time) error {
workspaceID, err := s.defaultWorkspaceID()
if err != nil {
return err
}
return s.UpdateAuthHealthForWorkspace(ctx, workspaceID, ok, errMsg, checkedAt)
func isUniqueViolation(err error) bool {
return err != nil && strings.Contains(err.Error(), "UNIQUE constraint failed")
}
// UpdateAuthHealthForWorkspace records the result of a credential probe for a
// single workspace config row.
func (s *Store) UpdateAuthHealthForWorkspace(ctx context.Context, workspaceID string, ok bool, errMsg string, checkedAt time.Time) error {
workspaceID, err := s.resolveWorkspaceID(workspaceID)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `
UPDATE sentry_configs
SET last_checked_at = ?, last_ok = ?, last_error = ?
WHERE workspace_id = ?`,
checkedAt, ok, errMsg, workspaceID)
return err
}
func (s *Store) defaultWorkspaceID() (string, error) {
return s.defaultWorkspace.Resolve(s.db)
}
func (s *Store) resolveWorkspaceID(workspaceID string) (string, error) {
if workspaceID != "" {
return workspaceID, nil
}
return s.defaultWorkspaceID()
func isForeignKeyViolation(err error) bool {
return err != nil && strings.Contains(err.Error(), "FOREIGN KEY constraint failed")
}
@@ -15,24 +15,25 @@ import (
// the way SQLite holds it. The store marshals/unmarshals at this boundary so
// service callers see a typed SearchFilter and never have to think about JSON.
type issueWatchRow struct {
ID string `db:"id"`
WorkspaceID string `db:"workspace_id"`
WorkflowID string `db:"workflow_id"`
WorkflowStepID string `db:"workflow_step_id"`
RepositoryID string `db:"repository_id"`
BaseBranch string `db:"base_branch"`
FilterJSON string `db:"filter_json"`
AgentProfileID string `db:"agent_profile_id"`
ExecutorProfileID string `db:"executor_profile_id"`
Prompt string `db:"prompt"`
Enabled bool `db:"enabled"`
PollIntervalSeconds int `db:"poll_interval_seconds"`
MaxInflightTasks sql.NullInt64 `db:"max_inflight_tasks"`
LastPolledAt *time.Time `db:"last_polled_at"`
LastError string `db:"last_error"`
LastErrorAt *time.Time `db:"last_error_at"`
CreatedAt time.Time `db:"created_at"`
UpdatedAt time.Time `db:"updated_at"`
ID string `db:"id"`
WorkspaceID string `db:"workspace_id"`
SentryInstanceID sql.NullString `db:"sentry_instance_id"`
WorkflowID string `db:"workflow_id"`
WorkflowStepID string `db:"workflow_step_id"`
RepositoryID string `db:"repository_id"`
BaseBranch string `db:"base_branch"`
FilterJSON string `db:"filter_json"`
AgentProfileID string `db:"agent_profile_id"`
ExecutorProfileID string `db:"executor_profile_id"`
Prompt string `db:"prompt"`
Enabled bool `db:"enabled"`
PollIntervalSeconds int `db:"poll_interval_seconds"`
MaxInflightTasks sql.NullInt64 `db:"max_inflight_tasks"`
LastPolledAt *time.Time `db:"last_polled_at"`
LastError string `db:"last_error"`
LastErrorAt *time.Time `db:"last_error_at"`
CreatedAt time.Time `db:"created_at"`
UpdatedAt time.Time `db:"updated_at"`
}
func (r *issueWatchRow) toIssueWatch() (*IssueWatch, error) {
@@ -50,6 +51,7 @@ func (r *issueWatchRow) toIssueWatch() (*IssueWatch, error) {
return &IssueWatch{
ID: r.ID,
WorkspaceID: r.WorkspaceID,
SentryInstanceID: r.SentryInstanceID.String,
WorkflowID: r.WorkflowID,
WorkflowStepID: r.WorkflowStepID,
RepositoryID: r.RepositoryID,
@@ -79,6 +81,16 @@ func nullableInt(v *int) interface{} {
return *v
}
// nullableString converts a string into a value suitable for a nullable SQL
// column: "" becomes SQL NULL, any other value is passed through. Used for
// sentry_instance_id where NULL means a legacy unbound watch.
func nullableString(v string) interface{} {
if v == "" {
return nil
}
return v
}
func encodeFilter(f SearchFilter) (string, error) {
b, err := json.Marshal(f)
if err != nil {
@@ -91,14 +103,14 @@ func encodeFilter(f SearchFilter) (string, error) {
// SELECTs use issueWatchSelectColumns which wraps the nullable last_error in
// COALESCE so older databases (pre-self-heal migration) read back as empty
// strings rather than NULL.
const issueWatchInsertColumns = `id, workspace_id, workflow_id, workflow_step_id,
const issueWatchInsertColumns = `id, workspace_id, sentry_instance_id, workflow_id, workflow_step_id,
repository_id, base_branch, filter_json,
agent_profile_id, executor_profile_id, prompt, enabled,
poll_interval_seconds, max_inflight_tasks, last_polled_at,
last_error, last_error_at,
created_at, updated_at`
const issueWatchSelectColumns = `id, workspace_id, workflow_id, workflow_step_id,
const issueWatchSelectColumns = `id, workspace_id, sentry_instance_id, workflow_id, workflow_step_id,
COALESCE(repository_id, '') AS repository_id, COALESCE(base_branch, '') AS base_branch, filter_json,
agent_profile_id, executor_profile_id, prompt, enabled,
poll_interval_seconds, max_inflight_tasks, last_polled_at,
@@ -123,8 +135,8 @@ func (s *Store) CreateIssueWatch(ctx context.Context, w *IssueWatch) error {
}
_, err = s.db.ExecContext(ctx, `
INSERT INTO sentry_issue_watches (`+issueWatchInsertColumns+`)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
w.ID, w.WorkspaceID, w.WorkflowID, w.WorkflowStepID,
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
w.ID, w.WorkspaceID, nullableString(w.SentryInstanceID), w.WorkflowID, w.WorkflowStepID,
w.RepositoryID, w.BaseBranch, filterJSON,
w.AgentProfileID, w.ExecutorProfileID, w.Prompt, w.Enabled,
w.PollIntervalSeconds, nullableInt(w.MaxInflightTasks), w.LastPolledAt,
@@ -245,6 +257,31 @@ func (s *Store) DisableIssueWatchWithError(ctx context.Context, id, cause string
return err
}
// StampIssueWatchError records a non-fatal cause on a watch (last_error /
// last_error_at) without changing its enabled state, so the settings UI can
// surface why the most recent poll could not run while the watch keeps
// retrying. Used when an unbound watch cannot resolve a Sentry instance.
func (s *Store) StampIssueWatchError(ctx context.Context, id, cause string) error {
now := time.Now().UTC()
_, err := s.db.ExecContext(ctx,
`UPDATE sentry_issue_watches
SET last_error = ?, last_error_at = ?, updated_at = ?
WHERE id = ?`,
cause, now, now, id)
return err
}
// ClearIssueWatchError removes the non-fatal poll error state after a
// successful watch check so the settings UI reflects current health.
func (s *Store) ClearIssueWatchError(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx,
`UPDATE sentry_issue_watches
SET last_error = '', last_error_at = NULL, updated_at = ?
WHERE id = ? AND (last_error <> '' OR last_error_at IS NOT NULL)`,
time.Now().UTC(), id)
return err
}
// DeleteIssueWatch removes a watch and its dedup rows in a single transaction.
// The explicit child DELETE guards older databases where foreign_keys may not
// have been enabled at attach time.
+218 -196
View File
@@ -3,6 +3,7 @@ package sentry
import (
"context"
"database/sql"
"errors"
"testing"
"time"
@@ -19,6 +20,11 @@ func newTestStore(t *testing.T) *Store {
raw.SetMaxOpenConns(1)
raw.SetMaxIdleConns(1)
db := sqlx.NewDb(raw, "sqlite3")
// Enforce foreign keys as production does (DSN _foreign_keys=on) so the
// ON DELETE RESTRICT net for in-use instances is exercised in tests.
if _, err := db.Exec(`PRAGMA foreign_keys = ON`); err != nil {
t.Fatalf("enable foreign keys: %v", err)
}
t.Cleanup(func() { _ = db.Close() })
store, err := NewStore(db, db)
if err != nil {
@@ -27,54 +33,174 @@ func newTestStore(t *testing.T) *Store {
return store
}
func TestStore_UpsertGetDelete(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
cfg := &SentryConfig{AuthMethod: AuthMethodAuthToken}
if err := store.UpsertConfig(ctx, cfg); err != nil {
t.Fatalf("upsert: %v", err)
}
got, err := store.GetConfig(ctx)
if err != nil {
t.Fatalf("get: %v", err)
}
if got == nil {
t.Fatal("expected config, got nil")
}
if got.AuthMethod != cfg.AuthMethod {
t.Errorf("round-trip mismatch: %+v vs %+v", got, cfg)
}
if got.CreatedAt.IsZero() || got.UpdatedAt.IsZero() {
t.Error("timestamps not set")
}
// Idempotent upsert does not duplicate rows.
if err := store.UpsertConfig(ctx, cfg); err != nil {
t.Fatalf("update upsert: %v", err)
}
if err := store.DeleteConfig(ctx); err != nil {
t.Fatalf("delete: %v", err)
}
gone, err := store.GetConfig(ctx)
if err != nil {
t.Fatalf("get after delete: %v", err)
}
if gone != nil {
t.Errorf("expected nil after delete, got %+v", gone)
func testInstance(workspaceID, name string) *SentryConfig {
return &SentryConfig{
WorkspaceID: workspaceID,
Name: name,
AuthMethod: AuthMethodAuthToken,
URL: DefaultSentryURL,
}
}
func TestStore_GetConfig_Missing(t *testing.T) {
func TestStore_CreateGetInstance(t *testing.T) {
store := newTestStore(t)
cfg, err := store.GetConfig(context.Background())
ctx := context.Background()
cfg := testInstance("ws-1", "SaaS")
cfg.URL = "https://sentry.example.com"
if err := store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("create: %v", err)
}
if cfg.ID == "" {
t.Fatal("expected ID assigned")
}
if cfg.CreatedAt.IsZero() || cfg.UpdatedAt.IsZero() {
t.Error("timestamps not set")
}
got, err := store.GetInstance(ctx, cfg.ID)
if err != nil || got == nil {
t.Fatalf("get: %v / %v", err, got)
}
if got.WorkspaceID != "ws-1" || got.Name != "SaaS" || got.URL != "https://sentry.example.com" {
t.Errorf("round-trip mismatch: %+v", got)
}
}
func TestStore_GetInstance_Missing(t *testing.T) {
store := newTestStore(t)
got, err := store.GetInstance(context.Background(), "ghost")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if cfg != nil {
t.Errorf("expected nil for missing config, got %+v", cfg)
if got != nil {
t.Errorf("expected nil for missing instance, got %+v", got)
}
}
func TestStore_ListInstances_ScopedByWorkspace(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
for _, c := range []*SentryConfig{
testInstance("ws-1", "A"),
testInstance("ws-1", "B"),
testInstance("ws-2", "C"),
} {
if err := store.CreateInstance(ctx, c); err != nil {
t.Fatalf("create: %v", err)
}
}
got, err := store.ListInstances(ctx, "ws-1")
if err != nil {
t.Fatalf("list: %v", err)
}
if len(got) != 2 {
t.Fatalf("expected 2 instances for ws-1, got %d", len(got))
}
for _, c := range got {
if c.WorkspaceID != "ws-1" {
t.Errorf("workspace leaked into list: %s", c.WorkspaceID)
}
}
}
// TestStore_UniqueNamePerWorkspace pins acceptance (h): (workspace_id, name) is
// unique, but the same name is allowed in a different workspace.
func TestStore_UniqueNamePerWorkspace(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
if err := store.CreateInstance(ctx, testInstance("ws-1", "Prod")); err != nil {
t.Fatalf("first create: %v", err)
}
if err := store.CreateInstance(ctx, testInstance("ws-1", "Prod")); !errors.Is(err, ErrDuplicateInstanceName) {
t.Fatalf("expected ErrDuplicateInstanceName for duplicate name in same workspace, got %v", err)
}
// Same name in a different workspace is fine.
if err := store.CreateInstance(ctx, testInstance("ws-2", "Prod")); err != nil {
t.Fatalf("same name in other workspace should succeed, got %v", err)
}
}
func TestStore_UpdateInstance(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
cfg := testInstance("ws-1", "Old")
if err := store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("create: %v", err)
}
created := cfg.CreatedAt
cfg.Name = "New"
cfg.URL = "https://sentry.example.com"
if err := store.UpdateInstance(ctx, cfg); err != nil {
t.Fatalf("update: %v", err)
}
got, _ := store.GetInstance(ctx, cfg.ID)
if got.Name != "New" || got.URL != "https://sentry.example.com" {
t.Errorf("update did not persist: %+v", got)
}
if !got.CreatedAt.Equal(created) {
t.Errorf("update must not change created_at: %v vs %v", got.CreatedAt, created)
}
// Update to a name already taken in the workspace is rejected.
other := testInstance("ws-1", "Taken")
if err := store.CreateInstance(ctx, other); err != nil {
t.Fatalf("create other: %v", err)
}
cfg.Name = "Taken"
if err := store.UpdateInstance(ctx, cfg); !errors.Is(err, ErrDuplicateInstanceName) {
t.Errorf("expected ErrDuplicateInstanceName on rename collision, got %v", err)
}
// Update of a missing row is ErrInstanceNotFound.
ghost := testInstance("ws-1", "Ghost")
ghost.ID = "does-not-exist"
if err := store.UpdateInstance(ctx, ghost); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound, got %v", err)
}
}
func TestStore_DeleteInstance(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
cfg := testInstance("ws-1", "Prod")
if err := store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("create: %v", err)
}
if err := store.DeleteInstance(ctx, cfg.ID); err != nil {
t.Fatalf("delete: %v", err)
}
got, _ := store.GetInstance(ctx, cfg.ID)
if got != nil {
t.Errorf("expected instance gone, got %+v", got)
}
if err := store.DeleteInstance(ctx, cfg.ID); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound on second delete, got %v", err)
}
}
// TestStore_DeleteInstance_FKRestrictHolds pins the DB-level safety net from
// acceptance (f): a watch referencing an instance blocks its deletion via ON
// DELETE RESTRICT, surfaced as ErrInstanceInUse.
func TestStore_DeleteInstance_FKRestrictHolds(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
cfg := testInstance("ws-1", "Prod")
if err := store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("create instance: %v", err)
}
w := newTestIssueWatch("ws-1")
w.SentryInstanceID = cfg.ID
if err := store.CreateIssueWatch(ctx, w); err != nil {
t.Fatalf("create watch: %v", err)
}
if err := store.DeleteInstance(ctx, cfg.ID); !errors.As(err, &ErrInstanceInUse{}) {
t.Fatalf("expected ErrInstanceInUse from FK RESTRICT, got %v", err)
}
n, err := store.CountWatchesForInstance(ctx, cfg.ID)
if err != nil || n != 1 {
t.Fatalf("expected 1 referencing watch, got %d (err %v)", n, err)
}
}
@@ -83,187 +209,83 @@ func TestStore_HasConfig(t *testing.T) {
ctx := context.Background()
has, _ := store.HasConfig(ctx)
if has {
t.Errorf("expected HasConfig=false on empty store")
t.Error("expected HasConfig=false on empty store")
}
if err := store.UpsertConfig(ctx, &SentryConfig{AuthMethod: AuthMethodAuthToken}); err != nil {
t.Fatalf("upsert: %v", err)
if err := store.CreateInstance(ctx, testInstance("ws-1", "A")); err != nil {
t.Fatalf("create: %v", err)
}
has, _ = store.HasConfig(ctx)
if !has {
t.Errorf("expected HasConfig=true after upsert")
t.Error("expected HasConfig=true after create")
}
}
func TestStore_UpdateAuthHealth(t *testing.T) {
func TestStore_UpdateAuthHealthForInstance(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
if err := store.UpsertConfig(ctx, &SentryConfig{AuthMethod: AuthMethodAuthToken}); err != nil {
t.Fatalf("upsert: %v", err)
cfg := testInstance("ws-1", "A")
if err := store.CreateInstance(ctx, cfg); err != nil {
t.Fatalf("create: %v", err)
}
cfg, _ := store.GetConfig(ctx)
if cfg.LastCheckedAt != nil {
t.Errorf("expected nil last_checked_at on fresh row, got %v", cfg.LastCheckedAt)
got, _ := store.GetInstance(ctx, cfg.ID)
if got.LastCheckedAt != nil {
t.Errorf("expected nil last_checked_at on fresh row, got %v", got.LastCheckedAt)
}
now := time.Now().UTC().Truncate(time.Second)
if err := store.UpdateAuthHealth(ctx, true, "", now); err != nil {
if err := store.UpdateAuthHealthForInstance(ctx, cfg.ID, true, "", now); err != nil {
t.Fatalf("update ok: %v", err)
}
cfg, _ = store.GetConfig(ctx)
if !cfg.LastOk {
t.Error("expected last_ok=true after successful probe")
got, _ = store.GetInstance(ctx, cfg.ID)
if !got.LastOk || got.LastCheckedAt == nil || !got.LastCheckedAt.Equal(now) {
t.Errorf("unexpected health state after success: %+v", got)
}
if cfg.LastCheckedAt == nil || !cfg.LastCheckedAt.Equal(now) {
t.Errorf("expected last_checked_at=%v, got %v", now, cfg.LastCheckedAt)
}
failAt := now.Add(time.Minute)
if err := store.UpdateAuthHealth(ctx, false, "401 unauthorized", failAt); err != nil {
if err := store.UpdateAuthHealthForInstance(ctx, cfg.ID, false, "401 unauthorized", now.Add(time.Minute)); err != nil {
t.Fatalf("update fail: %v", err)
}
cfg, _ = store.GetConfig(ctx)
if cfg.LastOk {
t.Error("expected last_ok=false after failure")
}
if cfg.LastError != "401 unauthorized" {
t.Errorf("expected last_error preserved, got %q", cfg.LastError)
got, _ = store.GetInstance(ctx, cfg.ID)
if got.LastOk || got.LastError != "401 unauthorized" {
t.Errorf("expected failure recorded, got %+v", got)
}
}
// TestStore_UpsertGetConfig_RoundTripsURL asserts the instance URL persists
// through an upsert/get cycle.
func TestStore_UpsertGetConfig_RoundTripsURL(t *testing.T) {
func TestStore_CountUnboundIssueWatchesInWorkspace(t *testing.T) {
store := newTestStore(t)
ctx := context.Background()
cfg := &SentryConfig{AuthMethod: AuthMethodAuthToken, URL: "https://sentry.example.com"}
if err := store.UpsertConfig(ctx, cfg); err != nil {
t.Fatalf("upsert: %v", err)
inst := testInstance("ws-1", "A")
if err := store.CreateInstance(ctx, inst); err != nil {
t.Fatalf("create instance: %v", err)
}
got, err := store.GetConfig(ctx)
if err != nil || got == nil {
t.Fatalf("get: %v / %v", err, got)
// A bound watch must not count.
bound := newTestIssueWatch("ws-1")
bound.SentryInstanceID = inst.ID
if err := store.CreateIssueWatch(ctx, bound); err != nil {
t.Fatalf("create bound watch: %v", err)
}
if got.URL != "https://sentry.example.com" {
t.Errorf("url not persisted: got %q", got.URL)
// Two unbound (NULL sentry_instance_id) watches in ws-1 must count.
for range 2 {
if err := store.CreateIssueWatch(ctx, newTestIssueWatch("ws-1")); err != nil {
t.Fatalf("create unbound watch: %v", err)
}
}
// An unbound watch in another workspace must not leak in.
if err := store.CreateIssueWatch(ctx, newTestIssueWatch("ws-2")); err != nil {
t.Fatalf("create other-workspace watch: %v", err)
}
n, err := store.CountUnboundIssueWatchesInWorkspace(ctx, "ws-1")
if err != nil {
t.Fatalf("count: %v", err)
}
if n != 2 {
t.Errorf("expected 2 unbound watches in ws-1, got %d", n)
}
}
func TestStore_MigrateSingletonConfigToActiveWorkspace(t *testing.T) {
raw, err := sql.Open("sqlite3", ":memory:")
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
raw.SetMaxOpenConns(1)
raw.SetMaxIdleConns(1)
db := sqlx.NewDb(raw, "sqlite3")
t.Cleanup(func() { _ = db.Close() })
now := time.Now().UTC()
checkedAt := now.Add(-5 * time.Minute).Truncate(time.Second)
if _, err := db.Exec(`
CREATE TABLE workspaces (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
created_at TIMESTAMP NOT NULL,
updated_at TIMESTAMP NOT NULL
);
CREATE TABLE users (
id TEXT PRIMARY KEY,
email TEXT NOT NULL,
settings TEXT NOT NULL DEFAULT '{}',
created_at TIMESTAMP NOT NULL,
updated_at TIMESTAMP NOT NULL
);
CREATE TABLE sentry_configs (
id TEXT PRIMARY KEY CHECK(id = 'singleton'),
auth_method TEXT NOT NULL,
url TEXT NOT NULL DEFAULT 'https://sentry.io',
last_checked_at DATETIME,
last_ok INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
);
INSERT INTO workspaces (id, name, created_at, updated_at)
VALUES ('ws-first', 'First', ?, ?), ('ws-active', 'Active', ?, ?);
INSERT INTO users (id, email, settings, created_at, updated_at)
VALUES ('default-user', 'default@kandev.local', '{"workspace_id":"ws-active"}', ?, ?);
INSERT INTO sentry_configs
(id, auth_method, url, last_checked_at, last_ok, last_error, created_at, updated_at)
VALUES ('singleton', ?, 'https://sentry.example.com', ?, 1, 'healthy', ?, ?);
`, now.Add(-time.Hour), now.Add(-time.Hour), now, now, now, now, AuthMethodAuthToken, checkedAt, now, now); err != nil {
t.Fatalf("seed singleton schema: %v", err)
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("new store: %v", err)
}
if got := store.MigratedFromWorkspace(); got != "ws-active" {
t.Fatalf("expected singleton config migrated to active workspace, got %q", got)
}
cfg, err := store.GetConfigForWorkspace(context.Background(), "ws-active")
if err != nil {
t.Fatalf("get active workspace config: %v", err)
}
if cfg == nil {
t.Fatal("expected migrated config")
}
if cfg.URL != "https://sentry.example.com" {
t.Errorf("expected migrated URL, got %q", cfg.URL)
}
if cfg.AuthMethod != AuthMethodAuthToken {
t.Errorf("expected migrated auth method %q, got %q", AuthMethodAuthToken, cfg.AuthMethod)
}
if !cfg.LastOk || cfg.LastError != "healthy" {
t.Errorf("unexpected migrated health state: %+v", cfg)
}
if cfg.LastCheckedAt == nil || !cfg.LastCheckedAt.Equal(checkedAt) {
t.Errorf("expected last_checked_at=%v, got %v", checkedAt, cfg.LastCheckedAt)
}
}
// TestStore_MigratesURLColumn seeds a pre-self-hosted sentry_configs table (no
// url column) and verifies NewStore adds the column, backfilling the existing
// SaaS row to the sentry.io default rather than an empty string.
func TestStore_MigratesURLColumn(t *testing.T) {
raw, err := sql.Open("sqlite3", ":memory:")
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
raw.SetMaxOpenConns(1)
raw.SetMaxIdleConns(1)
db := sqlx.NewDb(raw, "sqlite3")
t.Cleanup(func() { _ = db.Close() })
now := time.Now().UTC()
if _, err := db.Exec(`
CREATE TABLE sentry_configs (
id TEXT PRIMARY KEY CHECK(id = 'singleton'),
auth_method TEXT NOT NULL,
last_checked_at DATETIME,
last_ok INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
)`); err != nil {
t.Fatalf("create legacy schema: %v", err)
}
if _, err := db.Exec(`INSERT INTO sentry_configs (id, auth_method, created_at, updated_at)
VALUES ('singleton', ?, ?, ?)`, AuthMethodAuthToken, now, now); err != nil {
t.Fatalf("seed legacy row: %v", err)
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("new store (migrate): %v", err)
}
cfg, err := store.GetConfig(context.Background())
if err != nil || cfg == nil {
t.Fatalf("get after migrate: %v / %v", err, cfg)
}
if cfg.URL != DefaultSentryURL {
t.Errorf("expected legacy row backfilled to %q, got %q", DefaultSentryURL, cfg.URL)
// TestStore_UpdateAuthHealthForInstance_MissingInstance pins the zero-rows path:
// probing a non-existent instance surfaces ErrInstanceNotFound so the mock
// seed endpoint can fail fast instead of silently reporting success.
func TestStore_UpdateAuthHealthForInstance_MissingInstance(t *testing.T) {
store := newTestStore(t)
if err := store.UpdateAuthHealthForInstance(context.Background(), "ghost", true, "", time.Now().UTC()); !errors.Is(err, ErrInstanceNotFound) {
t.Errorf("expected ErrInstanceNotFound for missing instance, got %v", err)
}
}
@@ -1,6 +1,15 @@
import { describe, expect, it } from "vitest";
import { afterEach, describe, expect, it, vi } from "vitest";
import { integrationFromPathname } from "./integration-copy-config";
import { copySentryInstances } from "@/lib/api/domains/sentry-api";
import { copyIntegrationConfig, integrationFromPathname } from "./integration-copy-config";
vi.mock("@/lib/api/domains/sentry-api", () => ({
copySentryInstances: vi.fn(),
}));
afterEach(() => {
vi.clearAllMocks();
});
describe("integrationFromPathname", () => {
it("recognizes global integration settings routes", () => {
@@ -18,3 +27,11 @@ describe("integrationFromPathname", () => {
expect(integrationFromPathname("/settings/workspace/ws-1/integrations")).toBeNull();
});
});
describe("copyIntegrationConfig", () => {
it("scopes Sentry copies to the source workspace and sends only the target", async () => {
await copyIntegrationConfig("sentry", "ws-source", "ws-target");
expect(copySentryInstances).toHaveBeenCalledWith("ws-target", { workspaceId: "ws-source" });
});
});
@@ -1,7 +1,7 @@
import { copySlackConfig } from "@/lib/api/domains/slack-api";
import { copyJiraConfig } from "@/lib/api/domains/jira-api";
import { copyLinearConfig } from "@/lib/api/domains/linear-api";
import { copySentryConfig } from "@/lib/api/domains/sentry-api";
import { copySentryInstances } from "@/lib/api/domains/sentry-api";
import { copyGitHubWorkspaceSettings } from "@/lib/api/domains/github-api";
// IntegrationSlug is the set of integration settings pages that support copying
@@ -55,7 +55,7 @@ export async function copyIntegrationConfig(
await copyLinearConfig(targetWorkspaceId, options);
return;
case "sentry":
await copySentryConfig(targetWorkspaceId, options);
await copySentryInstances(targetWorkspaceId, options);
return;
case "github":
await copyGitHubWorkspaceSettings(targetWorkspaceId, options);
@@ -39,6 +39,10 @@ export type ValidatedPopoverProps<T> = {
align?: "start" | "end";
headline: string;
placeholder: string;
// extraFields renders integration-specific controls (e.g. a Sentry instance
// selector) between the headline and the key input. Optional; omitted by
// integrations that need only the key input.
extraFields?: ReactNode;
// Validation: extract a key from the user's input. Returning null shows the
// hint as an error. The hint typically reads "Paste a Jira ticket URL or
// key (PROJ-123)" or similar — integration-specific copy.
@@ -51,6 +55,10 @@ export type ValidatedPopoverProps<T> = {
// Submit button labels.
submitLabel: string; // e.g. "Link", "Import"
submittingLabel: string; // e.g. "Linking...", "Loading..."
// submitDisabled blocks submission even when the key input is non-empty (e.g.
// a required instance selector has no choice yet). Optional; defaults to
// enabled.
submitDisabled?: boolean;
};
type TriggerButtonProps = Pick<
@@ -122,6 +130,8 @@ type PopoverBodyProps = {
submitLabel: string;
submittingLabel: string;
testIdPrefix?: string;
extraFields?: ReactNode;
submitDisabled?: boolean;
};
function PopoverBody({
@@ -135,10 +145,13 @@ function PopoverBody({
submitLabel,
submittingLabel,
testIdPrefix,
extraFields,
submitDisabled,
}: PopoverBodyProps) {
return (
<div className="space-y-2">
<div className="text-xs font-medium">{headline}</div>
{extraFields}
<Input
autoFocus
value={value}
@@ -167,7 +180,7 @@ function PopoverBody({
type="button"
size="sm"
onClick={() => void onSubmit()}
disabled={loading || !value.trim()}
disabled={loading || !value.trim() || !!submitDisabled}
className="h-7 cursor-pointer"
data-testid={testIdPrefix ? `${testIdPrefix}-submit` : undefined}
>
@@ -256,6 +269,8 @@ export function ValidatedPopover<T>(props: ValidatedPopoverProps<T>) {
<PopoverContent align={align ?? "end"} className="w-80 p-3">
<PopoverBody
headline={headline}
extraFields={props.extraFields}
submitDisabled={props.submitDisabled}
placeholder={placeholder}
value={value}
onChange={setValue}
@@ -0,0 +1,42 @@
import { afterEach, describe, expect, it } from "vitest";
import { cleanup, render, screen } from "@testing-library/react";
import type { SentryConfig } from "@/lib/types/sentry";
import { SentryInstanceCard } from "./sentry-instance-card";
function instance(id: string, name: string): SentryConfig {
return {
id,
workspaceId: "workspace-1",
name,
authMethod: "auth_token",
url: "https://sentry.example.com",
hasSecret: false,
lastOk: false,
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
};
}
afterEach(() => cleanup());
describe("SentryInstanceCard", () => {
it("gives each instance action a distinct accessible name", () => {
render(
<>
<SentryInstanceCard
instance={instance("instance-1", "Production")}
onEdit={() => {}}
onDelete={() => {}}
/>
<SentryInstanceCard
instance={instance("instance-2", "Self-hosted")}
onEdit={() => {}}
onDelete={() => {}}
/>
</>,
);
expect(screen.getByRole("button", { name: "Edit Production Sentry instance" })).toBeTruthy();
expect(screen.getByRole("button", { name: "Delete Self-hosted Sentry instance" })).toBeTruthy();
});
});
@@ -0,0 +1,71 @@
"use client";
import { IconPencil, IconTrash } from "@tabler/icons-react";
import { Button } from "@kandev/ui/button";
import {
IntegrationAuthStatusBanner,
type IntegrationAuthHealth,
} from "@/components/integrations/auth-status-banner";
import type { SentryConfig } from "@/lib/types/sentry";
// configToHealth maps an instance's backend-recorded probe fields to the shared
// auth-status banner shape. Returns null (banner hidden) until a secret exists.
export function configToHealth(config: SentryConfig): IntegrationAuthHealth | null {
if (!config.hasSecret) return null;
if (!config.lastCheckedAt) return { ok: false, error: "", checkedAt: null };
return {
ok: !!config.lastOk,
error: config.lastError ?? "",
checkedAt: new Date(config.lastCheckedAt),
};
}
type SentryInstanceCardProps = {
instance: SentryConfig;
onEdit: () => void;
onDelete: () => void;
};
// SentryInstanceCard renders one saved instance: its name, URL, per-instance
// auth-health banner, and edit/delete actions.
export function SentryInstanceCard({ instance, onEdit, onDelete }: SentryInstanceCardProps) {
return (
<div className="space-y-3 rounded-md border p-4" data-testid="sentry-instance-card">
<div className="flex items-start justify-between gap-3">
<div className="min-w-0">
<p className="font-medium truncate" data-testid="sentry-instance-name">
{instance.name}
</p>
<p className="text-xs text-muted-foreground truncate">{instance.url}</p>
</div>
<div className="flex items-center gap-2 shrink-0">
<Button
type="button"
size="sm"
variant="outline"
onClick={onEdit}
aria-label={`Edit ${instance.name} Sentry instance`}
className="cursor-pointer gap-1"
data-testid="sentry-instance-edit-button"
>
<IconPencil className="h-3.5 w-3.5" />
Edit
</Button>
<Button
type="button"
size="sm"
variant="destructive"
onClick={onDelete}
aria-label={`Delete ${instance.name} Sentry instance`}
className="cursor-pointer gap-1"
data-testid="sentry-instance-delete-button"
>
<IconTrash className="h-3.5 w-3.5" />
Delete
</Button>
</div>
</div>
<IntegrationAuthStatusBanner health={configToHealth(instance)} />
</div>
);
}
@@ -0,0 +1,80 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { cleanup, fireEvent, render, screen } from "@testing-library/react";
import { TooltipProvider } from "@kandev/ui/tooltip";
import type { SentryConfig } from "@/lib/types/sentry";
vi.mock("@/components/toast-provider", () => ({
useToast: () => ({ toast: vi.fn() }),
}));
vi.mock("@/lib/api/domains/sentry-api", () => ({
createSentryInstance: vi.fn(),
updateSentryInstance: vi.fn(),
testSentryConnection: vi.fn(),
testSentryInstance: vi.fn(),
sentryErrorCode: vi.fn(),
SENTRY_ERROR_CODES: { nameTaken: "SENTRY_INSTANCE_NAME_TAKEN" },
}));
import { SentryInstanceForm } from "./sentry-instance-form";
const savedInstance: SentryConfig = {
id: "instance-1",
workspaceId: "workspace-1",
name: "Production",
authMethod: "auth_token",
url: "https://sentry.example.com",
hasSecret: true,
lastOk: true,
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
};
function renderForm() {
return render(
<TooltipProvider>
<SentryInstanceForm
workspaceId="workspace-1"
instance={savedInstance}
idPrefix="sentry-edit"
onSaved={vi.fn()}
onCancel={vi.fn()}
/>
</TooltipProvider>,
);
}
afterEach(() => {
cleanup();
vi.clearAllMocks();
});
describe("SentryInstanceForm", () => {
it("requires a token before testing an edited saved URL", () => {
renderForm();
fireEvent.change(screen.getByTestId("sentry-edit-url-input"), {
target: { value: "https://sentry-new.example.com" },
});
expect(screen.getByTestId("sentry-edit-test-button")).toHaveProperty("disabled", true);
});
it("labels new-instance forms without labeling edit forms", () => {
render(
<TooltipProvider>
<SentryInstanceForm
workspaceId="workspace-1"
instance={null}
idPrefix="sentry-add"
onSaved={vi.fn()}
onCancel={vi.fn()}
/>
</TooltipProvider>,
);
expect(screen.getByTestId("sentry-add-form-heading").textContent).toBe("New Instance");
expect(screen.getByTestId("sentry-add-form-heading").className).toContain("font-semibold");
expect(screen.queryByTestId("sentry-edit-form-heading")).toBeNull();
});
});
@@ -0,0 +1,311 @@
"use client";
import { useCallback, useState } from "react";
import { IconInfoCircle } from "@tabler/icons-react";
import { Button } from "@kandev/ui/button";
import { Input } from "@kandev/ui/input";
import { Label } from "@kandev/ui/label";
import { Separator } from "@kandev/ui/separator";
import { Alert, AlertDescription } from "@kandev/ui/alert";
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
import { useToast } from "@/components/toast-provider";
import {
createSentryInstance,
SENTRY_ERROR_CODES,
sentryErrorCode,
testSentryConnection,
testSentryInstance,
updateSentryInstance,
} from "@/lib/api/domains/sentry-api";
import {
SENTRY_AUTH_METHOD,
SENTRY_DEFAULT_URL,
type SentryConfig,
type TestSentryConnectionResult,
} from "@/lib/types/sentry";
const FIELD = "space-y-1.5";
const HELP = "text-xs text-muted-foreground";
type FormState = { name: string; url: string; secret: string };
function instanceToForm(instance: SentryConfig | null): FormState {
return { name: instance?.name ?? "", url: instance?.url || SENTRY_DEFAULT_URL, secret: "" };
}
type FieldProps = {
form: FormState;
idPrefix: string;
loading: boolean;
update: <K extends keyof FormState>(key: K, value: FormState[K]) => void;
};
function NameField({ form, idPrefix, loading, update }: FieldProps) {
return (
<div className={FIELD}>
<Label htmlFor={`${idPrefix}-name`}>Name</Label>
<Input
id={`${idPrefix}-name`}
data-testid={`${idPrefix}-name-input`}
placeholder="Production, Self-hosted, …"
value={form.name}
onChange={(e) => update("name", e.target.value)}
disabled={loading}
/>
<p className={HELP}>A label for this instance. Must be unique within the workspace.</p>
</div>
);
}
function UrlField({ form, idPrefix, loading, update }: FieldProps) {
return (
<div className={FIELD}>
<Label htmlFor={`${idPrefix}-url`}>Instance URL</Label>
<Input
id={`${idPrefix}-url`}
data-testid={`${idPrefix}-url-input`}
type="url"
placeholder={SENTRY_DEFAULT_URL}
value={form.url}
onChange={(e) => update("url", e.target.value)}
disabled={loading}
/>
<p className={HELP}>
Base URL of your Sentry instance. Leave as {SENTRY_DEFAULT_URL} for Sentry SaaS, or point it
at a self-hosted install (e.g. https://sentry.your-company.com).
</p>
</div>
);
}
function SecretField({
form,
idPrefix,
loading,
update,
hasSavedSecret,
}: FieldProps & { hasSavedSecret: boolean }) {
return (
<div className={FIELD}>
<div className="flex items-center gap-1.5">
<Label htmlFor={`${idPrefix}-secret`}>
Auth token
{hasSavedSecret && (
<span className="text-xs text-muted-foreground ml-2">
(saved — leave blank to keep the current value)
</span>
)}
</Label>
<Tooltip>
<TooltipTrigger asChild>
<IconInfoCircle
className="h-3.5 w-3.5 text-muted-foreground/50 hover:text-muted-foreground cursor-help shrink-0"
aria-label="Required token scopes"
/>
</TooltipTrigger>
<TooltipContent className="max-w-xs" align="start">
<p className="text-xs font-medium mb-1">Grant Read access to these scopes:</p>
<ul className="text-xs space-y-0.5">
<li>
<code className="text-[10px] bg-white/15 px-1 rounded">org:read</code>{" "}
<span className="opacity-70">Organization — resolve the org and list issues</span>
</li>
<li>
<code className="text-[10px] bg-white/15 px-1 rounded">project:read</code>{" "}
<span className="opacity-70">Project — list projects and scope searches</span>
</li>
<li>
<code className="text-[10px] bg-white/15 px-1 rounded">event:read</code>{" "}
<span className="opacity-70">
Issue &amp; Event — browse issues and run watchers
</span>
</li>
</ul>
</TooltipContent>
</Tooltip>
</div>
<Input
id={`${idPrefix}-secret`}
data-testid={`${idPrefix}-secret-input`}
type="password"
placeholder={hasSavedSecret ? "••••••••" : "sntrys_..."}
value={form.secret}
onChange={(e) => update("secret", e.target.value)}
disabled={loading}
/>
</div>
);
}
function TestResultAlert({ result }: { result: TestSentryConnectionResult | null }) {
if (!result) return null;
return (
<Alert variant={result.ok ? "default" : "destructive"}>
<AlertDescription>
{result.ok
? `Connected as ${result.displayName || result.email || result.userId}`
: `Failed: ${result.error}`}
</AlertDescription>
</Alert>
);
}
type UseInstanceFormArgs = {
workspaceId: string;
instance: SentryConfig | null;
form: FormState;
onSaved: (cfg: SentryConfig) => void;
};
function useInstanceForm({ workspaceId, instance, form, onSaved }: UseInstanceFormArgs) {
const { toast } = useToast();
const [saving, setSaving] = useState(false);
const [testing, setTesting] = useState(false);
const [testResult, setTestResult] = useState<TestSentryConnectionResult | null>(null);
// A saved instance can re-test its stored token only while its URL is
// unchanged. Any typed token or URL change is a candidate configuration.
const candidateTest = !instance || !!form.secret || form.url !== instance.url;
const handleTest = useCallback(async () => {
setTesting(true);
setTestResult(null);
try {
const res = candidateTest
? await testSentryConnection(workspaceId, {
secret: form.secret || undefined,
url: form.url || undefined,
authMethod: SENTRY_AUTH_METHOD,
})
: await testSentryInstance(workspaceId, instance!.id);
setTestResult(res);
} catch (err) {
setTestResult({ ok: false, error: String(err) });
} finally {
setTesting(false);
}
}, [workspaceId, instance, candidateTest, form.secret, form.url]);
const handleSave = useCallback(async () => {
setSaving(true);
try {
const saved = instance
? await updateSentryInstance(workspaceId, instance.id, {
name: form.name.trim(),
authMethod: SENTRY_AUTH_METHOD,
url: form.url,
secret: form.secret,
})
: await createSentryInstance(workspaceId, {
workspaceId,
name: form.name.trim(),
authMethod: SENTRY_AUTH_METHOD,
url: form.url,
secret: form.secret,
});
toast({ description: "Sentry instance saved", variant: "success" });
onSaved(saved);
} catch (err) {
const message =
sentryErrorCode(err) === SENTRY_ERROR_CODES.nameTaken
? `An instance named "${form.name.trim()}" already exists in this workspace.`
: `Save failed: ${String(err)}`;
toast({ description: message, variant: "error" });
} finally {
setSaving(false);
}
}, [workspaceId, instance, form, toast, onSaved]);
return { saving, testing, testResult, candidateTest, handleTest, handleSave };
}
type SentryInstanceFormProps = {
workspaceId: string;
// instance === null creates a new instance; otherwise the form edits it.
instance: SentryConfig | null;
// idPrefix scopes element ids + testids so the mutually-exclusive add/edit
// forms never collide (e.g. "sentry-add" vs "sentry-edit").
idPrefix: string;
onSaved: (cfg: SentryConfig) => void;
onCancel: () => void;
};
export function SentryInstanceForm({
workspaceId,
instance,
idPrefix,
onSaved,
onCancel,
}: SentryInstanceFormProps) {
const [form, setForm] = useState<FormState>(() => instanceToForm(instance));
const update = useCallback(
<K extends keyof FormState>(key: K, value: FormState[K]) =>
setForm((prev) => ({ ...prev, [key]: value })),
[],
);
const { saving, testing, testResult, candidateTest, handleTest, handleSave } = useInstanceForm({
workspaceId,
instance,
form,
onSaved,
});
const hasSavedSecret = !!instance?.hasSecret;
const missingSecret = !hasSavedSecret && !form.secret;
const requiresTestSecret = !form.secret && (candidateTest || missingSecret);
const disableSave = saving || !form.name.trim() || missingSecret;
const disableTest = testing || requiresTestSecret;
let saveLabel = instance ? "Update" : "Save";
if (saving) saveLabel = "Saving...";
return (
<div className="space-y-4 rounded-md border p-4" data-testid={`${idPrefix}-form`}>
{instance === null && (
<h4 data-testid={`${idPrefix}-form-heading`} className="text-sm font-semibold">
New Instance
</h4>
)}
<NameField form={form} idPrefix={idPrefix} loading={saving} update={update} />
<UrlField form={form} idPrefix={idPrefix} loading={saving} update={update} />
<SecretField
form={form}
idPrefix={idPrefix}
loading={saving}
update={update}
hasSavedSecret={hasSavedSecret}
/>
<TestResultAlert result={testResult} />
<Separator />
<div className="flex flex-wrap items-center gap-2">
<Button
type="button"
variant="outline"
onClick={handleTest}
disabled={disableTest}
className="cursor-pointer"
title={requiresTestSecret ? "Paste an auth token to test the connection" : undefined}
data-testid={`${idPrefix}-test-button`}
>
{testing ? "Testing..." : "Test connection"}
</Button>
<Button
type="button"
onClick={handleSave}
disabled={disableSave}
className="cursor-pointer"
data-testid={`${idPrefix}-save-button`}
>
{saveLabel}
</Button>
<Button
type="button"
variant="ghost"
onClick={onCancel}
className="ml-auto cursor-pointer"
data-testid={`${idPrefix}-cancel-button`}
>
Cancel
</Button>
</div>
</div>
);
}
@@ -0,0 +1,112 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import { listSentryProjects, searchSentryIssues } from "@/lib/api/domains/sentry-api";
import { useSentryInstances } from "@/hooks/domains/sentry/use-sentry-availability";
import type { SentryConfig } from "@/lib/types/sentry";
vi.mock("@/lib/api/domains/sentry-api", () => ({
listSentryProjects: vi.fn(),
searchSentryIssues: vi.fn(),
}));
vi.mock("@/hooks/domains/sentry/use-sentry-availability", () => ({
useSentryInstances: vi.fn(),
}));
import { SentryIssueDialog } from "./sentry-issue-dialog";
const instance: SentryConfig = {
id: "shared-instance",
workspaceId: "workspace-1",
name: "Production",
authMethod: "auth_token",
url: "https://sentry.example.com",
hasSecret: true,
lastOk: true,
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
};
function mockAvailability() {
vi.mocked(useSentryInstances).mockReturnValue({
loading: false,
instances: [instance],
healthy: [instance],
available: true,
state: "single",
});
}
afterEach(() => {
cleanup();
vi.clearAllMocks();
});
describe("SentryIssueDialog", () => {
it("clears filters and results when its workspace changes", async () => {
mockAvailability();
vi.mocked(listSentryProjects).mockResolvedValue({
projects: [{ id: "project-1", slug: "web", name: "Web", orgSlug: "acme" }],
} as never);
vi.mocked(searchSentryIssues).mockResolvedValue({
issues: [
{
id: "issue-1",
shortId: "WEB-1",
title: "Stale workspace issue",
permalink: "https://sentry.example.com/issues/1",
projectSlug: "web",
level: "error",
status: "unresolved",
},
],
isLast: true,
} as never);
const view = render(
<SentryIssueDialog open={true} onOpenChange={vi.fn()} workspaceId="workspace-1" />,
);
await waitFor(() => {
expect((screen.getByLabelText("Organization") as HTMLInputElement).value).toBe("acme");
});
fireEvent.change(screen.getByLabelText("Query"), { target: { value: "is:unresolved" } });
fireEvent.click(screen.getByRole("button", { name: "Search" }));
await screen.findByText("Stale workspace issue");
view.rerender(
<SentryIssueDialog open={true} onOpenChange={vi.fn()} workspaceId="workspace-2" />,
);
expect((screen.getByLabelText("Query") as HTMLInputElement).value).toBe("");
expect(screen.queryByText("Stale workspace issue")).toBeNull();
});
it("clears a stuck loading state when a workspace change interrupts an in-flight search", async () => {
mockAvailability();
vi.mocked(listSentryProjects).mockResolvedValue({
projects: [{ id: "project-1", slug: "web", name: "Web", orgSlug: "acme" }],
} as never);
const pendingSearch = new Promise<never>(() => {});
vi.mocked(searchSentryIssues).mockReturnValue(pendingSearch);
const view = render(
<SentryIssueDialog open={true} onOpenChange={vi.fn()} workspaceId="workspace-1" />,
);
await waitFor(() => {
expect((screen.getByLabelText("Organization") as HTMLInputElement).value).toBe("acme");
});
fireEvent.click(screen.getByRole("button", { name: "Search" }));
await waitFor(() => {
expect(document.querySelector(".animate-spin")).not.toBeNull();
});
view.rerender(
<SentryIssueDialog open={true} onOpenChange={vi.fn()} workspaceId="workspace-2" />,
);
expect(document.querySelector(".animate-spin")).toBeNull();
});
});
@@ -9,7 +9,12 @@ import { Input } from "@kandev/ui/input";
import { Label } from "@kandev/ui/label";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@kandev/ui/select";
import { listSentryProjects, searchSentryIssues } from "@/lib/api/domains/sentry-api";
import {
useSentryInstances,
type SentryAvailabilityState,
} from "@/hooks/domains/sentry/use-sentry-availability";
import type {
SentryConfig,
SentryIssue,
SentryLevel,
SentryProject,
@@ -68,9 +73,31 @@ export function SentryIssueDialog({ open, onOpenChange, workspaceId }: SentryIss
);
}
type DialogState = ReturnType<typeof useDialogState>;
// DialogState is the browse dialog's shared view-model, passed to the filter and
// results subcomponents. Named explicitly (not ReturnType) so the contract lives
// at this module boundary.
interface DialogState {
filter: FilterState;
updateFilter: <K extends keyof FilterState>(key: K, value: FilterState[K]) => void;
projects: SentryProject[];
issues: SentryIssue[];
nextCursor: string | undefined;
isLast: boolean;
loading: boolean;
error: string | null;
search: (nextCursorValue?: string) => Promise<void>;
// instanceId is the Sentry instance the browse calls are scoped to; empty
// until one is chosen (or auto-selected when the workspace has exactly one
// healthy instance).
instanceId: string;
setInstanceId: (id: string) => void;
healthy: SentryConfig[];
instancesState: SentryAvailabilityState;
}
function useDialogState(open: boolean, workspaceId?: string) {
function useDialogState(open: boolean, workspaceId?: string): DialogState {
const { healthy, state: instancesState } = useSentryInstances(workspaceId);
const [instanceId, setInstanceId] = useState("");
const [filter, setFilter] = useState<FilterState>(initialFilter);
const [projects, setProjects] = useState<SentryProject[]>([]);
const [issues, setIssues] = useState<SentryIssue[]>([]);
@@ -82,10 +109,52 @@ function useDialogState(open: boolean, workspaceId?: string) {
// Monotonic request id: only the most recent search may write results, so an
// out-of-order response from a superseded search can't clobber the list.
const searchSeq = useRef(0);
const previousWorkspaceId = useRef(workspaceId);
const resetBrowseState = useCallback((clearProjects = false) => {
setFilter(initialFilter);
if (clearProjects) setProjects([]);
setIssues([]);
setNextCursor(undefined);
setIsLast(true);
setError(null);
setConfigLoaded(false);
// Invalidating the sequence makes the in-flight search's `finally` skip
// setLoading(false) by design (its result is now stale) — so this reset
// must clear loading itself, or the dialog is stuck loading forever.
setLoading(false);
searchSeq.current++;
}, []);
// Auto-select the sole healthy instance; force an explicit pick when several;
// drop a selection that is no longer healthy.
useEffect(() => {
setInstanceId((prev) => {
if (healthy.length === 0) return "";
if (healthy.length === 1) return healthy[0].id;
return healthy.some((i) => i.id === prev) ? prev : "";
});
}, [healthy]);
// Switching instance invalidates the previous instance's filter, results and
// cursor: reset them, invalidate any in-flight search, and refetch projects.
useEffect(() => {
resetBrowseState();
}, [instanceId, resetBrowseState]);
// A workspace switch can retain a stale instance selection until availability
// finishes loading. Clear the browse state directly instead of waiting for
// that selection to change.
useEffect(() => {
if (previousWorkspaceId.current === workspaceId) return;
previousWorkspaceId.current = workspaceId;
resetBrowseState(true);
}, [workspaceId, resetBrowseState]);
useBrowseProjects({
open,
workspaceId,
instanceId,
loaded: configLoaded,
setFilter,
setLoaded: setConfigLoaded,
@@ -100,20 +169,21 @@ function useDialogState(open: boolean, workspaceId?: string) {
const search = useCallback(
async (nextCursorValue?: string) => {
if (!instanceId) {
setError("Select a Sentry instance to search");
return;
}
if (!filter.orgSlug) {
setError("Organization slug is required");
return;
}
if (!workspaceId) return;
const seq = ++searchSeq.current;
setLoading(true);
setError(null);
try {
const payload = toSearchFilter(filter);
const res = await searchSentryIssues(
payload,
nextCursorValue,
workspaceId ? { workspaceId } : undefined,
);
const res = await searchSentryIssues(workspaceId, instanceId, payload, nextCursorValue);
// A newer search started while this one was in flight — drop the result.
if (seq !== searchSeq.current) return;
const page = res.issues ?? [];
@@ -128,7 +198,7 @@ function useDialogState(open: boolean, workspaceId?: string) {
if (seq === searchSeq.current) setLoading(false);
}
},
[workspaceId, filter],
[workspaceId, instanceId, filter],
);
return {
@@ -141,6 +211,10 @@ function useDialogState(open: boolean, workspaceId?: string) {
loading,
error,
search,
instanceId,
setInstanceId,
healthy,
instancesState,
};
}
@@ -159,6 +233,7 @@ function toSearchFilter(filter: FilterState): SentrySearchFilter {
type BrowseProjectsArgs = {
open: boolean;
workspaceId: string | undefined;
instanceId: string;
loaded: boolean;
setFilter: (f: (prev: FilterState) => FilterState) => void;
setLoaded: (v: boolean) => void;
@@ -168,6 +243,7 @@ type BrowseProjectsArgs = {
function useBrowseProjects({
open,
workspaceId,
instanceId,
loaded,
setFilter,
setLoaded,
@@ -181,14 +257,18 @@ function useBrowseProjects({
return;
}
if (loaded) return;
// Without a chosen instance there is nothing to fetch; wait (leave `loaded`
// false) until one is selected.
if (!workspaceId || !instanceId) {
setProjects([]);
return;
}
let cancelled = false;
(async () => {
try {
const res = await listSentryProjects(workspaceId ? { workspaceId } : undefined).catch(
() => ({
projects: [] as SentryProject[],
}),
);
const res = await listSentryProjects(workspaceId, instanceId).catch(() => ({
projects: [] as SentryProject[],
}));
if (cancelled) return;
const projects = res.projects ?? [];
setProjects(projects);
@@ -205,12 +285,13 @@ function useBrowseProjects({
return () => {
cancelled = true;
};
}, [open, workspaceId, loaded, setFilter, setLoaded, setProjects]);
}, [open, workspaceId, instanceId, loaded, setFilter, setLoaded, setProjects]);
}
function FiltersBar({ state }: { state: DialogState }) {
return (
<div className="border-b px-5 py-4 space-y-3 shrink-0">
<InstanceSelectRow state={state} />
<FilterTopRow state={state} />
<FilterChipRow
label="Level"
@@ -231,6 +312,45 @@ function FiltersBar({ state }: { state: DialogState }) {
);
}
// InstanceSelectRow renders the instance picker when the workspace has several
// healthy instances, a hint when none are usable, and nothing when a sole
// instance was auto-selected.
function InstanceSelectRow({ state }: { state: DialogState }) {
const { healthy, instanceId, setInstanceId, instancesState } = state;
if (instancesState === "empty") {
return (
<p className="text-xs text-muted-foreground">
No Sentry instances configured for this workspace.
</p>
);
}
if (instancesState === "unhealthy") {
return (
<p className="text-xs text-muted-foreground">
No healthy Sentry instance — check the integration settings.
</p>
);
}
if (healthy.length <= 1) return null;
return (
<div className="space-y-1 max-w-sm">
<Label className="text-xs text-muted-foreground">Sentry instance</Label>
<Select value={instanceId || undefined} onValueChange={setInstanceId}>
<SelectTrigger className="h-8 text-xs" data-testid="sentry-browse-instance-select">
<SelectValue placeholder="Select an instance to browse" />
</SelectTrigger>
<SelectContent>
{healthy.map((instance) => (
<SelectItem key={instance.id} value={instance.id}>
{instance.name}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
);
}
function FilterTopRow({ state }: { state: DialogState }) {
const { filter, updateFilter, projects } = state;
return (
@@ -367,7 +487,7 @@ function FilterChipRow({ label, options, selected, onToggle, chipClass }: ChipRo
}
function SearchActionRow({ state }: { state: DialogState }) {
const { filter, updateFilter, loading, search } = state;
const { filter, updateFilter, loading, search, instanceId } = state;
return (
<div className="flex items-end gap-2">
<div className="flex-1 space-y-1">
@@ -392,7 +512,7 @@ function SearchActionRow({ state }: { state: DialogState }) {
type="button"
size="sm"
onClick={() => void search()}
disabled={loading || !filter.orgSlug}
disabled={loading || !filter.orgSlug || !instanceId}
className="cursor-pointer gap-1.5"
>
{loading ? (
@@ -407,7 +527,7 @@ function SearchActionRow({ state }: { state: DialogState }) {
}
function ResultsBody({ state }: { state: DialogState }) {
const { issues, loading, error, isLast, nextCursor, search } = state;
const { issues, loading, error, isLast, nextCursor, search, instanceId } = state;
const empty = useMemo(() => !loading && !error && issues.length === 0, [loading, error, issues]);
return (
@@ -415,7 +535,9 @@ function ResultsBody({ state }: { state: DialogState }) {
{error && <SentryErrorMessage error={error} compact />}
{empty && (
<div className="text-sm text-muted-foreground py-12 text-center">
No issues yet. Run a search to begin.
{instanceId
? "No issues yet. Run a search to begin."
: "Select a Sentry instance to browse its issues."}
</div>
)}
{issues.map((issue) => (
@@ -0,0 +1,171 @@
import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
listSentryInstances,
listSentryOrganizations,
listSentryProjects,
} from "@/lib/api/domains/sentry-api";
import type { SentryConfig, SentryIssueWatch } from "@/lib/types/sentry";
import { SentryIssueWatchDialog } from "./sentry-issue-watch-dialog";
const { WORKSPACE_ID } = vi.hoisted(() => ({ WORKSPACE_ID: "ws-1" }));
vi.mock("@/components/state-provider", () => ({
useAppStore: (selector: (state: unknown) => unknown) =>
selector({
workspaces: { activeId: WORKSPACE_ID, items: [{ id: WORKSPACE_ID, name: "Workspace" }] },
workflows: { items: [] },
agentProfiles: { items: [] },
executors: { items: [] },
}),
}));
vi.mock("@/hooks/domains/settings/use-settings-data", () => ({ useSettingsData: vi.fn() }));
vi.mock("@/hooks/use-workflows", () => ({ useWorkflows: vi.fn() }));
vi.mock("@/hooks/use-workflow-steps", () => ({
useWorkflowSteps: () => ({ steps: [], loading: false }),
stepPlaceholder: () => "Select workflow first",
}));
vi.mock("@/components/watcher-repository-fields", () => ({ WatcherRepositoryFields: () => null }));
vi.mock("@/components/settings/profile-edit/script-editor", () => ({
ScriptEditor: () => null,
computeEditorHeight: () => 0,
}));
vi.mock("./sentry-issue-watch-multiselect", () => ({
LevelMultiSelect: () => null,
StatusMultiSelect: () => null,
}));
vi.mock("./sentry-issue-watch-throttle-field", () => ({ MaxInflightTasksField: () => null }));
vi.mock("@/lib/api/domains/sentry-api", () => ({
listSentryInstances: vi.fn(),
listSentryOrganizations: vi.fn(),
listSentryProjects: vi.fn(),
}));
const PRIMARY_INSTANCE_ID = "instance-a";
function sentryInstance(id: string, name: string): SentryConfig {
return {
id,
workspaceId: WORKSPACE_ID,
name,
authMethod: "auth_token",
url: "https://sentry.io",
hasSecret: true,
lastOk: true,
createdAt: "",
updatedAt: "",
};
}
function legacyUnboundWatch(): SentryIssueWatch {
return {
id: "watch-1",
workspaceId: WORKSPACE_ID,
sentryInstanceId: "",
workflowId: "workflow-1",
workflowStepId: "step-1",
repositoryId: "",
baseBranch: "",
filter: { orgSlug: "acme", projectSlug: "frontend" },
agentProfileId: "",
executorProfileId: "",
prompt: "Handle the issue.",
enabled: true,
pollIntervalSeconds: 300,
maxInflightTasks: 5,
createdAt: "",
updatedAt: "",
};
}
function selectTrigger(label: string): HTMLButtonElement {
const trigger = screen.getByText(label).parentElement?.querySelector("button");
if (!(trigger instanceof HTMLButtonElement)) throw new Error(`Missing ${label} selector`);
return trigger;
}
async function choose(label: string, option: string): Promise<void> {
fireEvent.click(selectTrigger(label));
fireEvent.click(await screen.findByRole("option", { name: option }));
}
afterEach(() => {
cleanup();
vi.clearAllMocks();
});
beforeEach(() => {
vi.mocked(listSentryInstances).mockResolvedValue([
sentryInstance(PRIMARY_INSTANCE_ID, "Production"),
sentryInstance("instance-b", "Self-hosted"),
]);
vi.mocked(listSentryOrganizations).mockImplementation(async (_workspaceId, instanceId) => ({
organizations: [
{ id: instanceId, slug: instanceId === PRIMARY_INSTANCE_ID ? "acme" : "globex", name: "" },
],
}));
vi.mocked(listSentryProjects).mockImplementation(async (_workspaceId, instanceId) => ({
projects: [
{
id: instanceId,
slug: instanceId === PRIMARY_INSTANCE_ID ? "frontend" : "backend",
name: instanceId === PRIMARY_INSTANCE_ID ? "Frontend" : "Backend",
orgSlug: instanceId === PRIMARY_INSTANCE_ID ? "acme" : "globex",
},
],
}));
});
describe("SentryIssueWatchDialog", () => {
it("removes the previous instance's org and project choices before the new lookup resolves", async () => {
render(
<SentryIssueWatchDialog
open
onOpenChange={vi.fn()}
watch={null}
workspaceId={WORKSPACE_ID}
onCreate={vi.fn()}
onUpdate={vi.fn()}
/>,
);
await waitFor(() => {
expect(listSentryInstances).toHaveBeenCalledWith(WORKSPACE_ID);
});
await choose("Sentry instance", "Production");
await waitFor(() => {
expect(listSentryOrganizations).toHaveBeenCalledWith(WORKSPACE_ID, PRIMARY_INSTANCE_ID);
expect(listSentryProjects).toHaveBeenCalledWith(WORKSPACE_ID, PRIMARY_INSTANCE_ID);
});
await choose("Sentry instance", "Self-hosted");
fireEvent.click(selectTrigger("Organization slug"));
expect(screen.queryByRole("option", { name: "acme" })).toBeNull();
fireEvent.keyDown(document, { key: "Escape" });
fireEvent.click(selectTrigger("Project slug"));
expect(screen.queryByRole("option", { name: "Frontend (frontend)" })).toBeNull();
});
it("permits mutable updates to a legacy unbound watch while its instance remains immutable", async () => {
render(
<SentryIssueWatchDialog
open
onOpenChange={vi.fn()}
watch={legacyUnboundWatch()}
workspaceId={WORKSPACE_ID}
onCreate={vi.fn()}
onUpdate={vi.fn()}
/>,
);
await waitFor(() => {
expect((screen.getByRole("button", { name: "Update" }) as HTMLButtonElement).disabled).toBe(
false,
);
});
expect(selectTrigger("Sentry instance").disabled).toBe(true);
});
});
@@ -25,7 +25,11 @@ import {
ScriptEditor,
computeEditorHeight,
} from "@/components/settings/profile-edit/script-editor";
import { listSentryProjects, listSentryOrganizations } from "@/lib/api/domains/sentry-api";
import {
listSentryInstances,
listSentryProjects,
listSentryOrganizations,
} from "@/lib/api/domains/sentry-api";
import { WatcherRepositoryFields } from "@/components/watcher-repository-fields";
import { clearWorkspaceScopedForm } from "@/lib/watcher-repository-default";
import { SENTRY_ISSUE_WATCH_PLACEHOLDERS } from "./sentry-issue-watch-placeholders";
@@ -38,12 +42,13 @@ import {
projectSelectItems,
parseMaxInflightTasks,
isWatchFormReady,
buildFilterPayload,
buildWatchPayload,
formStateFromWatch,
makeEmptyForm,
} from "./sentry-issue-watch-form";
import type {
CreateSentryIssueWatchRequest,
SentryConfig,
SentryIssueWatch,
SentryLevel,
SentryProject,
@@ -85,11 +90,16 @@ function useFormData(workspaceId: string) {
return { workflows, agentProfiles: filteredAgentProfiles, allExecutorProfiles };
}
function useSentryProjects(workspaceId: string, orgSlug: string) {
function useSentryProjects(workspaceId: string, instanceId: string, orgSlug: string) {
const [projects, setProjects] = useState<SentryProject[]>([]);
useEffect(() => {
if (!workspaceId || !instanceId) {
setProjects([]);
return;
}
setProjects([]);
let cancelled = false;
listSentryProjects({ workspaceId })
listSentryProjects(workspaceId, instanceId)
.then((res) => {
if (!cancelled) setProjects(res.projects ?? []);
})
@@ -99,7 +109,7 @@ function useSentryProjects(workspaceId: string, orgSlug: string) {
return () => {
cancelled = true;
};
}, [workspaceId]);
}, [workspaceId, instanceId]);
// Sentry's auth-token endpoint already filters to the user's accessible orgs;
// if an orgSlug is set, restrict to projects that match.
return useMemo(
@@ -194,7 +204,7 @@ function FilterFields({
setForm: FormSetter;
orgs: string[];
}) {
const projects = useSentryProjects(form.workspaceId, form.orgSlug);
const projects = useSentryProjects(form.workspaceId, form.sentryInstanceId, form.orgSlug);
const toggleLevel = useCallback(
(level: SentryLevel) =>
setForm((p) => ({
@@ -334,6 +344,64 @@ function WorkspacePicker({
);
}
// useWorkspaceInstances loads the workspace's Sentry instances for the required
// instance selector and auto-selects the sole instance on a fresh create.
function useWorkspaceInstances(
open: boolean,
workspaceId: string,
hasWatch: boolean,
setForm: FormSetter,
) {
const [instances, setInstances] = useState<SentryConfig[]>([]);
useEffect(() => {
if (!open || !workspaceId) {
setInstances([]);
return;
}
let cancelled = false;
listSentryInstances(workspaceId)
.then((list) => {
if (!cancelled) setInstances(list);
})
.catch(() => {
if (!cancelled) setInstances([]);
});
return () => {
cancelled = true;
};
}, [open, workspaceId]);
useEffect(() => {
if (hasWatch || instances.length !== 1) return;
setForm((p) => (p.sentryInstanceId ? p : { ...p, sentryInstanceId: instances[0].id }));
}, [hasWatch, instances, setForm]);
return instances;
}
function InstancePicker({
instances,
value,
onChange,
disabled,
}: {
instances: SentryConfig[];
value: string;
onChange: (v: string) => void;
disabled?: boolean;
}) {
const noInstances = instances.length === 0;
return (
<SelectField
label="Sentry instance"
description="Which Sentry instance this watcher polls. Immutable after creation."
value={value}
onChange={onChange}
placeholder={noInstances ? "No Sentry instances in this workspace" : "Select an instance"}
items={instances.map((i) => ({ id: i.id, label: i.name }))}
disabled={disabled || noInstances}
/>
);
}
function AutomationFields({ form, setForm }: { form: FormState; setForm: FormSetter }) {
const { workflows, agentProfiles, allExecutorProfiles } = useFormData(form.workspaceId);
const { steps, loading: stepsLoading } = useWorkflowSteps(form.workflowId);
@@ -428,12 +496,22 @@ function savingLabel(saving: boolean, isEdit: boolean): string {
// useWatchOrgs loads the org list for the org dropdown and auto-selects the
// sole org on a fresh create (with one choice there is nothing to pick).
function useWatchOrgs(open: boolean, workspaceId: string, hasWatch: boolean, setForm: FormSetter) {
function useWatchOrgs(
open: boolean,
workspaceId: string,
instanceId: string,
hasWatch: boolean,
setForm: FormSetter,
) {
const [orgs, setOrgs] = useState<string[]>([]);
useEffect(() => {
if (!open) return;
if (!open || !instanceId) {
setOrgs([]);
return;
}
setOrgs([]);
let cancelled = false;
listSentryOrganizations({ workspaceId })
listSentryOrganizations(workspaceId, instanceId)
.then((res) => {
if (!cancelled) setOrgs((res.organizations ?? []).map((o) => o.slug));
})
@@ -443,7 +521,7 @@ function useWatchOrgs(open: boolean, workspaceId: string, hasWatch: boolean, set
return () => {
cancelled = true;
};
}, [open, workspaceId]);
}, [open, workspaceId, instanceId]);
useEffect(() => {
if (hasWatch || orgs.length !== 1) return;
setForm((p) => (p.orgSlug ? p : { ...p, orgSlug: orgs[0] }));
@@ -471,37 +549,27 @@ export function SentryIssueWatchDialog({
}
}, [watch, open, workspaceId, activeWorkspaceId]);
const orgs = useWatchOrgs(open, form.workspaceId, !!watch, setForm);
const instances = useWorkspaceInstances(open, form.workspaceId, !!watch, setForm);
const orgs = useWatchOrgs(open, form.workspaceId, form.sentryInstanceId, !!watch, setForm);
const workspaceLocked = !!watch || !!workspaceId;
const workspaceLocked = true;
const canSave = isWatchFormReady(form);
const canSave = isWatchFormReady(form, { requiresInstance: !watch });
const handleSave = useCallback(async () => {
const maxInflight = parseMaxInflightTasks(form.maxInflightTasks);
if (maxInflight === "invalid") return;
setSaving(true);
try {
const filter = buildFilterPayload(form);
const payload = {
filter,
workflowId: form.workflowId,
workflowStepId: form.workflowStepId,
// Empty repositoryId clears the binding; empty base branch is sent
// verbatim so the backend fills the repo's default at save time.
repositoryId: form.repositoryId,
baseBranch: form.repositoryId ? form.baseBranch : "",
agentProfileId: form.agentProfileId,
executorProfileId: form.executorProfileId,
prompt: form.prompt,
enabled: form.enabled,
pollIntervalSeconds: form.pollInterval,
maxInflightTasks: maxInflight,
};
const payload = buildWatchPayload(form, maxInflight);
if (watch) {
await onUpdate(watch.id, watch.workspaceId, payload);
} else {
await onCreate({ ...payload, workspaceId: form.workspaceId });
await onCreate({
...payload,
workspaceId: form.workspaceId,
sentryInstanceId: form.sentryInstanceId,
});
}
onOpenChange(false);
} catch {
@@ -528,6 +596,14 @@ export function SentryIssueWatchDialog({
onChange={(v) => setForm((p) => clearWorkspaceScopedForm(p, v))}
disabled={workspaceLocked}
/>
<InstancePicker
instances={instances}
value={form.sentryInstanceId}
onChange={(v) =>
setForm((p) => ({ ...p, sentryInstanceId: v, orgSlug: "", projectSlug: "" }))
}
disabled={!!watch}
/>
<Separator />
<FilterFields form={form} setForm={setForm} orgs={orgs} />
<Separator />
@@ -5,6 +5,7 @@ import {
maxInflightTasksString,
parseMaxInflightTasks,
buildFilterPayload,
isWatchFormReady,
makeEmptyForm,
} from "./sentry-issue-watch-form";
import type { SentryProject } from "@/lib/types/sentry";
@@ -97,3 +98,18 @@ describe("buildFilterPayload", () => {
expect(filter.projectSlug).toBe("web");
});
});
describe("isWatchFormReady", () => {
it("allows a legacy unbound watch to update its mutable fields", () => {
const legacyUnbound = {
...makeEmptyForm("ws-1"),
orgSlug: "acme",
projectSlug: "web",
workflowId: "workflow-1",
workflowStepId: "step-1",
sentryInstanceId: "",
};
expect(isWatchFormReady(legacyUnbound, { requiresInstance: false })).toBe(true);
});
});
@@ -20,6 +20,8 @@ export const STATS_PERIOD_OPTIONS: { value: string; label: string }[] = [
export interface FormState {
workspaceId: string;
/** The Sentry instance to poll. Required; immutable after create. */
sentryInstanceId: string;
orgSlug: string;
projectSlug: string;
environment: string;
@@ -44,6 +46,7 @@ export interface FormState {
export function makeEmptyForm(workspaceId: string): FormState {
return {
workspaceId,
sentryInstanceId: "",
orgSlug: "",
projectSlug: "",
environment: "",
@@ -68,6 +71,7 @@ export function formStateFromWatch(w: SentryIssueWatch): FormState {
const f: SentrySearchFilter = w.filter ?? { orgSlug: "" };
return {
workspaceId: w.workspaceId,
sentryInstanceId: w.sentryInstanceId ?? "",
orgSlug: f.orgSlug ?? "",
projectSlug: f.projectSlug ?? "",
environment: f.environment ?? "",
@@ -144,9 +148,13 @@ export function projectSelectItems(projects: SentryProject[], current: string):
// isWatchFormReady aggregates the dialog's "can Save enable?" rule. Kept here
// so the rule has one named home and the dialog stays under its line limit.
export function isWatchFormReady(form: FormState): boolean {
export function isWatchFormReady(
form: FormState,
{ requiresInstance = true }: { requiresInstance?: boolean } = {},
): boolean {
return (
!!form.workspaceId &&
(!requiresInstance || !!form.sentryInstanceId) &&
!!form.orgSlug.trim() &&
!!form.projectSlug.trim() &&
!!form.workflowId &&
@@ -170,3 +178,24 @@ export function buildFilterPayload(form: FormState): SentrySearchFilter {
statsPeriod: form.statsPeriod || undefined,
};
}
// buildWatchPayload assembles the create/update watch fields shared by both
// paths (everything except workspaceId + sentryInstanceId, which only create
// carries). maxInflightTasks is resolved by the caller via parseMaxInflightTasks.
export function buildWatchPayload(form: FormState, maxInflightTasks: number | null) {
return {
filter: buildFilterPayload(form),
workflowId: form.workflowId,
workflowStepId: form.workflowStepId,
// Empty repositoryId clears the binding; empty base branch is sent verbatim
// so the backend fills the repo's default at save time.
repositoryId: form.repositoryId,
baseBranch: form.repositoryId ? form.baseBranch : "",
agentProfileId: form.agentProfileId,
executorProfileId: form.executorProfileId,
prompt: form.prompt,
enabled: form.enabled,
pollIntervalSeconds: form.pollInterval,
maxInflightTasks,
};
}
@@ -0,0 +1,76 @@
import { cleanup, render, screen } from "@testing-library/react";
import { afterEach, describe, expect, it, vi } from "vitest";
import { TooltipProvider } from "@kandev/ui/tooltip";
import type { SentryIssueWatch } from "@/lib/types/sentry";
import { SentryIssueWatchTable } from "./sentry-issue-watch-table";
function watch(over: Partial<SentryIssueWatch>): SentryIssueWatch {
return {
id: "w1",
workspaceId: "ws-1",
sentryInstanceId: "inst-1",
workflowId: "wf",
workflowStepId: "step",
repositoryId: "",
baseBranch: "",
filter: { orgSlug: "acme", projectSlug: "web" },
agentProfileId: "ap",
executorProfileId: "",
prompt: "",
enabled: true,
pollIntervalSeconds: 300,
lastPolledAt: null,
lastError: "",
lastErrorAt: null,
createdAt: "",
updatedAt: "",
...over,
} as unknown as SentryIssueWatch;
}
const noop = vi.fn();
function resolveName(id: string): string {
if (id === "inst-1") return "Production";
if (id === "") return "—";
return "(unavailable)";
}
function renderTable(watches: SentryIssueWatch[]) {
return render(
<TooltipProvider>
<SentryIssueWatchTable
watches={watches}
instanceName={resolveName}
onEdit={noop}
onDelete={noop}
onTrigger={noop}
onReset={noop}
onToggleEnabled={noop}
/>
</TooltipProvider>,
);
}
afterEach(() => {
cleanup();
vi.clearAllMocks();
});
describe("SentryIssueWatchTable", () => {
it("shows an Instance column, not a Workspace column (integration is workspace-scoped)", () => {
renderTable([watch({ id: "w1" })]);
expect(screen.getByText("Instance")).toBeTruthy();
expect(screen.queryByText("Workspace")).toBeNull();
});
it("renders each watch's bound instance name via the resolver", () => {
renderTable([
watch({ id: "w1", sentryInstanceId: "inst-1" }),
watch({ id: "w2", sentryInstanceId: "inst-gone" }),
watch({ id: "w3", sentryInstanceId: "" }),
]);
const cells = screen.getAllByTestId("watch-instance").map((c) => c.textContent);
expect(cells).toEqual(["Production", "(unavailable)", "—"]);
});
});
@@ -11,14 +11,14 @@ import { Button } from "@kandev/ui/button";
import { Badge } from "@kandev/ui/badge";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@kandev/ui/table";
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
import { useAppStore } from "@/components/state-provider";
import type { SentryIssueWatch, SentrySearchFilter } from "@/lib/types/sentry";
type SentryIssueWatchTableProps = {
watches: SentryIssueWatch[];
// showWorkspace renders a Workspace column when the table aggregates rows
// from every workspace (install-wide settings page).
showWorkspace?: boolean;
// instanceName resolves a watch's bound sentryInstanceId to its display name.
// The table is workspace-scoped, so it shows which instance each watch polls
// (not which workspace it belongs to).
instanceName: (sentryInstanceId: string) => string;
onEdit: (watch: SentryIssueWatch) => void;
onDelete: (id: string, workspaceId: string) => void;
onTrigger: (id: string, workspaceId: string) => void;
@@ -149,16 +149,13 @@ function WatchActions({
export function SentryIssueWatchTable({
watches,
showWorkspace,
instanceName,
onEdit,
onDelete,
onTrigger,
onReset,
onToggleEnabled,
}: SentryIssueWatchTableProps) {
const workspaces = useAppStore((s) => s.workspaces.items);
const workspaceName = (id: string) => workspaces.find((w) => w.id === id)?.name ?? id;
if (watches.length === 0) {
return (
<p className="text-sm text-muted-foreground py-4 text-center">
@@ -171,7 +168,7 @@ export function SentryIssueWatchTable({
<Table>
<TableHeader>
<TableRow>
{showWorkspace && <TableHead>Workspace</TableHead>}
<TableHead>Instance</TableHead>
<TableHead>Filter</TableHead>
<TableHead>Interval</TableHead>
<TableHead>Last Polled</TableHead>
@@ -182,11 +179,9 @@ export function SentryIssueWatchTable({
<TableBody>
{watches.map((watch) => (
<TableRow key={watch.id} className="cursor-pointer" onClick={() => onEdit(watch)}>
{showWorkspace && (
<TableCell className="text-xs text-muted-foreground">
{workspaceName(watch.workspaceId)}
</TableCell>
)}
<TableCell className="text-xs text-muted-foreground" data-testid="watch-instance">
{instanceName(watch.sentryInstanceId)}
</TableCell>
<TableCell
className="font-mono text-xs max-w-md truncate"
title={summarizeFilter(watch.filter)}
@@ -0,0 +1,69 @@
import { cleanup, render } from "@testing-library/react";
import { afterEach, describe, expect, it, vi } from "vitest";
import { useSentryIssueWatches } from "@/hooks/domains/sentry/use-sentry-issue-watches";
import { SentryIssueWatchersSection } from "./sentry-issue-watchers-section";
// The global active workspace intentionally differs from the routed workspace.
const h = vi.hoisted(() => ({ activeId: "ws-active" as string | null }));
vi.mock("@/components/state-provider", () => ({
useAppStore: (sel: (s: unknown) => unknown) =>
sel({ workspaces: { activeId: h.activeId, items: [] } }),
}));
vi.mock("@/hooks/domains/sentry/use-sentry-issue-watches", () => ({
useSentryIssueWatches: vi.fn(() => ({
items: [],
loading: false,
create: vi.fn(),
update: vi.fn(),
remove: vi.fn(),
trigger: vi.fn(),
previewReset: vi.fn(),
reset: vi.fn(),
})),
}));
vi.mock("@/hooks/domains/sentry/use-sentry-availability", () => ({
useSentryInstances: vi.fn(() => ({
instances: [],
healthy: [],
loading: false,
available: false,
state: "empty",
})),
}));
vi.mock("@/components/toast-provider", () => ({ useToast: () => ({ toast: vi.fn() }) }));
vi.mock("./sentry-issue-watch-table", () => ({ SentryIssueWatchTable: () => null }));
vi.mock("./sentry-issue-watch-dialog", () => ({ SentryIssueWatchDialog: () => null }));
vi.mock("@/components/watches/reset-watch-dialog", () => ({
ResetWatchDialog: () => null,
useWatchResetController: () => ({
resetting: null,
setResetting: vi.fn(),
onOpenChange: vi.fn(),
previewLoader: vi.fn(),
confirmReset: vi.fn(),
}),
}));
afterEach(() => {
cleanup();
vi.clearAllMocks();
});
describe("SentryIssueWatchersSection scoping", () => {
it("fetches watches only for its supplied workspace (never all workspaces)", () => {
render(<SentryIssueWatchersSection workspaceId="ws-active" />);
expect(vi.mocked(useSentryIssueWatches)).toHaveBeenCalledWith("ws-active");
// never the unscoped `undefined` that would return foreign-workspace watches
expect(vi.mocked(useSentryIssueWatches)).not.toHaveBeenCalledWith(undefined);
});
it("fetches watches for the routed workspace before the active workspace", () => {
render(<SentryIssueWatchersSection workspaceId="ws-route" />);
expect(vi.mocked(useSentryIssueWatches)).toHaveBeenCalledWith("ws-route");
expect(vi.mocked(useSentryIssueWatches)).not.toHaveBeenCalledWith("ws-active");
});
});
@@ -7,14 +7,15 @@ import { Card, CardContent } from "@kandev/ui/card";
import { SettingsSection } from "@/components/settings/settings-section";
import { useToast } from "@/components/toast-provider";
import { useSentryIssueWatches } from "@/hooks/domains/sentry/use-sentry-issue-watches";
import { useSentryInstances } from "@/hooks/domains/sentry/use-sentry-availability";
import { ResetWatchDialog, useWatchResetController } from "@/components/watches/reset-watch-dialog";
import { SentryIssueWatchTable } from "./sentry-issue-watch-table";
import { SentryIssueWatchDialog } from "./sentry-issue-watch-dialog";
import type { SentryIssueWatch } from "@/lib/types/sentry";
// SentryIssueWatchersSection lists watches across every workspace in a single
// flat table on the install-wide settings page. The dialog's create flow asks
// the user to pick the workspace.
// SentryIssueWatchersSection lists watches for the workspace resolved by its
// parent integration page. Creating a watch is locked to that workspace and
// requires picking one of its Sentry instances.
type RawActions = {
create: ReturnType<typeof useSentryIssueWatches>["create"];
update: ReturnType<typeof useSentryIssueWatches>["update"];
@@ -121,9 +122,17 @@ function useToastedActions({ create, update, remove, trigger, reset }: RawAction
};
}
export function SentryIssueWatchersSection() {
export function SentryIssueWatchersSection({ workspaceId }: { workspaceId: string }) {
const { items, loading, create, update, remove, trigger, previewReset, reset } =
useSentryIssueWatches();
useSentryIssueWatches(workspaceId);
const { instances } = useSentryInstances(workspaceId);
const instanceName = useCallback(
(id: string) => {
if (!id) return "—";
return instances.find((i) => i.id === id)?.name ?? "(unavailable)";
},
[instances],
);
const actions = useToastedActions({ create, update, remove, trigger, reset });
const [dialogOpen, setDialogOpen] = useState(false);
@@ -170,7 +179,7 @@ export function SentryIssueWatchersSection() {
) : (
<SentryIssueWatchTable
watches={items}
showWorkspace
instanceName={instanceName}
onEdit={openEdit}
onDelete={actions.remove}
onTrigger={actions.trigger}
@@ -0,0 +1,162 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
import { TooltipProvider } from "@kandev/ui/tooltip";
import { listSentryInstances } from "@/lib/api/domains/sentry-api";
import type { SentryConfig } from "@/lib/types/sentry";
const mocks = vi.hoisted(() => ({
activeWorkspaceId: "ws-active",
setEnabled: vi.fn(),
toast: vi.fn(),
workspaces: [
{ id: "ws-active", name: "Active" },
{ id: "ws-route", name: "Route" },
],
}));
vi.mock("@/components/toast-provider", () => ({
useToast: () => ({ toast: mocks.toast }),
}));
vi.mock("@/hooks/domains/sentry/use-sentry-enabled", () => ({
useSentryEnabled: () => ({ enabled: true, setEnabled: mocks.setEnabled }),
}));
vi.mock("@/hooks/domains/integrations/use-integration-availability", () => ({
INTEGRATION_STATUS_REFRESH_MS: 1,
}));
vi.mock("@kandev/ui/switch", () => ({
Switch: ({ onCheckedChange: _onCheckedChange, ...props }: Record<string, unknown>) => (
<button {...props} />
),
}));
vi.mock("@/components/state-provider", () => ({
useAppStore: (
selector: (state: {
workspaces: { activeId: string; items: { id: string; name: string }[] };
}) => unknown,
) =>
selector({
workspaces: {
activeId: mocks.activeWorkspaceId,
items: mocks.workspaces,
},
}),
}));
vi.mock("./sentry-issue-watchers-section", () => ({
SentryIssueWatchersSection: ({ workspaceId }: { workspaceId: string }) => (
<div data-testid="sentry-watchers-workspace">{workspaceId}</div>
),
}));
vi.mock("@/lib/api/domains/sentry-api", () => ({
createSentryInstance: vi.fn(),
deleteSentryInstance: vi.fn(),
listSentryInstances: vi.fn(),
sentryErrorCode: vi.fn(),
sentryInUseWatchCount: vi.fn(),
testSentryConnection: vi.fn(),
testSentryInstance: vi.fn(),
updateSentryInstance: vi.fn(),
SENTRY_ERROR_CODES: { nameTaken: "SENTRY_INSTANCE_NAME_TAKEN" },
}));
import { SentryConnectionSection, SentryIntegrationPage } from "./sentry-settings";
const instance: SentryConfig = {
id: "instance-1",
workspaceId: "workspace-1",
name: "Production",
authMethod: "auth_token",
url: "https://sentry.example.com",
hasSecret: true,
lastOk: true,
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
};
beforeEach(() => {
vi.useFakeTimers();
mocks.activeWorkspaceId = "ws-active";
});
afterEach(() => {
cleanup();
vi.useRealTimers();
vi.clearAllMocks();
});
describe("SentryConnectionSection", () => {
it("restores the add path when a polling refresh removes the instance being edited", async () => {
vi.mocked(listSentryInstances).mockResolvedValueOnce([instance]).mockResolvedValueOnce([]);
render(
<TooltipProvider>
<SentryConnectionSection workspaceId="workspace-1" />
</TooltipProvider>,
);
await act(async () => {
await Promise.resolve();
});
expect(screen.getByTestId("sentry-instance-edit-button")).toBeTruthy();
fireEvent.click(screen.getByTestId("sentry-instance-edit-button"));
expect(screen.getByTestId("sentry-edit-form")).toBeTruthy();
await act(async () => {
await vi.advanceTimersByTimeAsync(1);
});
expect(screen.getByRole("button", { name: "Add instance" })).toBeTruthy();
});
it("keeps initial load failures visible but silences recurring poll failures", async () => {
vi.mocked(listSentryInstances).mockRejectedValue(new Error("offline"));
render(
<TooltipProvider>
<SentryConnectionSection workspaceId="workspace-1" />
</TooltipProvider>,
);
await act(async () => {
await Promise.resolve();
});
expect(mocks.toast).toHaveBeenCalledTimes(1);
await act(async () => {
await vi.advanceTimersByTimeAsync(1);
});
expect(mocks.toast).toHaveBeenCalledTimes(1);
});
});
describe("SentryIntegrationPage workspace scope", () => {
it("passes the route workspace to watchers before the global active workspace", () => {
vi.mocked(listSentryInstances).mockResolvedValue([]);
render(
<TooltipProvider>
<SentryIntegrationPage workspaceId="ws-route" />
</TooltipProvider>,
);
expect(screen.getByTestId("sentry-watchers-workspace").textContent).toBe("ws-route");
});
it("uses the global active workspace when no route workspace is supplied", () => {
vi.mocked(listSentryInstances).mockResolvedValue([]);
render(
<TooltipProvider>
<SentryIntegrationPage />
</TooltipProvider>,
);
expect(screen.getByTestId("sentry-watchers-workspace").textContent).toBe("ws-active");
});
});
+173 -373
View File
@@ -1,376 +1,124 @@
"use client";
import { useCallback, useEffect, useState } from "react";
import { IconBrandSentry, IconInfoCircle } from "@tabler/icons-react";
import { useCallback, useEffect, useRef, useState } from "react";
import { IconBrandSentry, IconPlus } from "@tabler/icons-react";
import { Button } from "@kandev/ui/button";
import { Card, CardContent } from "@kandev/ui/card";
import { Input } from "@kandev/ui/input";
import { Label } from "@kandev/ui/label";
import { Separator } from "@kandev/ui/separator";
import { Alert, AlertDescription } from "@kandev/ui/alert";
import { Switch } from "@kandev/ui/switch";
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
import { useToast } from "@/components/toast-provider";
import { SettingsSection } from "@/components/settings/settings-section";
import { useSentryEnabled } from "@/hooks/domains/sentry/use-sentry-enabled";
import {
IntegrationAuthStatusBanner,
type IntegrationAuthHealth,
} from "@/components/integrations/auth-status-banner";
import { WorkspaceScopedSection } from "@/components/integrations/workspace-scoped-section";
import { INTEGRATION_STATUS_REFRESH_MS } from "@/hooks/domains/integrations/use-integration-availability";
import {
fetchSentryConfig,
saveSentryConfig,
deleteSentryConfig,
testSentryConnection,
deleteSentryInstance,
listSentryInstances,
sentryInUseWatchCount,
} from "@/lib/api/domains/sentry-api";
import {
SENTRY_AUTH_METHOD,
SENTRY_DEFAULT_URL,
type SentryConfig,
type TestSentryConnectionResult,
} from "@/lib/types/sentry";
import type { SentryConfig } from "@/lib/types/sentry";
import { SentryInstanceCard } from "./sentry-instance-card";
import { SentryInstanceForm } from "./sentry-instance-form";
import { SentryIssueWatchersSection } from "./sentry-issue-watchers-section";
type FormState = {
url: string;
secret: string;
};
// EditMode is the mutually-exclusive form state: at most one add-or-edit form
// is open at a time.
type EditMode = { kind: "none" } | { kind: "add" } | { kind: "edit"; id: string };
const emptyForm: FormState = { url: SENTRY_DEFAULT_URL, secret: "" };
// useInstanceList loads and polls a workspace's Sentry instances. Fetches are
// request-versioned so a slow load for a previous workspace (or an overlapping
// poll) can't clobber newer results.
function useInstanceList(workspaceId: string) {
const { toast } = useToast();
const [instances, setInstances] = useState<SentryConfig[]>([]);
const [loading, setLoading] = useState(true);
const requestId = useRef(0);
function configToForm(cfg: SentryConfig | null): FormState {
// Only the instance URL and the (write-only) secret are editable here;
// org/project are chosen per-watcher and per-browse, not stored install-wide.
return { url: cfg?.url || SENTRY_DEFAULT_URL, secret: "" };
}
function saveLabel(saving: boolean, hasConfig: boolean): string {
if (saving) return "Saving...";
return hasConfig ? "Update" : "Save";
}
function configToHealth(config: SentryConfig | null): IntegrationAuthHealth | null {
if (!config?.hasSecret) return null;
if (!config.lastCheckedAt) return { ok: false, error: "", checkedAt: null };
return {
ok: !!config.lastOk,
error: config.lastError ?? "",
checkedAt: new Date(config.lastCheckedAt),
};
}
type UpdateFn = <K extends keyof FormState>(key: K, value: FormState[K]) => void;
type UrlFieldProps = {
form: FormState;
loading: boolean;
update: UpdateFn;
};
function UrlField({ form, loading, update }: UrlFieldProps) {
return (
<div className="space-y-1.5">
<Label htmlFor="sentry-url">Instance URL</Label>
<Input
id="sentry-url"
data-testid="sentry-url-input"
type="url"
placeholder={SENTRY_DEFAULT_URL}
value={form.url}
onChange={(e) => update("url", e.target.value)}
disabled={loading}
/>
<p className="text-xs text-muted-foreground">
Base URL of your Sentry instance. Leave as {SENTRY_DEFAULT_URL} for Sentry SaaS, or point it
at a self-hosted install (e.g. https://sentry.your-company.com).
</p>
</div>
const reload = useCallback(
async (reportError = true) => {
const current = ++requestId.current;
try {
const list = await listSentryInstances(workspaceId);
if (current !== requestId.current) return;
setInstances(list);
} catch (err) {
if (current !== requestId.current) return;
if (reportError) {
toast({
description: `Failed to load Sentry instances: ${String(err)}`,
variant: "error",
});
}
} finally {
if (current === requestId.current) setLoading(false);
}
},
[workspaceId, toast],
);
useEffect(() => {
setLoading(true);
setInstances([]);
void reload();
// Poll so per-instance health banners stay fresh without a manual refresh.
const id = setInterval(() => void reload(false), INTEGRATION_STATUS_REFRESH_MS);
return () => clearInterval(id);
}, [reload]);
return { instances, loading, reload };
}
type SecretFieldProps = {
form: FormState;
loading: boolean;
update: UpdateFn;
hasSavedSecret: boolean;
type InstanceListProps = {
instances: SentryConfig[];
mode: EditMode;
workspaceId: string;
onEdit: (id: string) => void;
onDelete: (instance: SentryConfig) => void;
onSaved: () => void;
onCancel: () => void;
};
function SecretField({ form, loading, update, hasSavedSecret }: SecretFieldProps) {
return (
<div className="space-y-1.5">
<div className="flex items-center gap-1.5">
<Label htmlFor="sentry-secret">
Auth token
{hasSavedSecret && (
<span className="text-xs text-muted-foreground ml-2">
(saved — leave blank to keep the current value)
</span>
)}
</Label>
<Tooltip>
<TooltipTrigger asChild>
<IconInfoCircle
className="h-3.5 w-3.5 text-muted-foreground/50 hover:text-muted-foreground cursor-help shrink-0"
aria-label="Required token scopes"
/>
</TooltipTrigger>
<TooltipContent className="max-w-xs" align="start">
<p className="text-xs font-medium mb-1">Grant Read access to these scopes:</p>
<ul className="text-xs space-y-0.5">
<li>
<code className="text-[10px] bg-white/15 px-1 rounded">org:read</code>{" "}
<span className="opacity-70">Organization — resolve the org and list issues</span>
</li>
<li>
<code className="text-[10px] bg-white/15 px-1 rounded">project:read</code>{" "}
<span className="opacity-70">Project — list projects and scope searches</span>
</li>
<li>
<code className="text-[10px] bg-white/15 px-1 rounded">event:read</code>{" "}
<span className="opacity-70">
Issue &amp; Event — browse issues and run watchers
</span>
</li>
</ul>
</TooltipContent>
</Tooltip>
</div>
<Input
id="sentry-secret"
data-testid="sentry-secret-input"
type="password"
placeholder={hasSavedSecret ? "••••••••" : "sntrys_..."}
value={form.secret}
onChange={(e) => update("secret", e.target.value)}
disabled={loading}
/>
<p className="text-xs text-muted-foreground">
Create a new personal token at{" "}
<a
className="underline"
href="https://sentry.io/settings/account/api/auth-tokens/new-token/"
target="_blank"
rel="noreferrer"
>
sentry.io → Settings → Auth Tokens
</a>
</p>
</div>
);
}
function TestResultAlert({ result }: { result: TestSentryConnectionResult | null }) {
if (!result) return null;
return (
<Alert variant={result.ok ? "default" : "destructive"}>
<AlertDescription>
{result.ok
? `Connected as ${result.displayName || result.email || result.userId}`
: `Failed: ${result.error}`}
</AlertDescription>
</Alert>
);
}
type ActionBarProps = {
saving: boolean;
testing: boolean;
loading: boolean;
hasConfig: boolean;
disableSave: boolean;
disableTest: boolean;
onTest: () => void;
onSave: () => void;
onDelete: () => void;
};
function ActionBar({
saving,
testing,
loading,
hasConfig,
disableSave,
disableTest,
onTest,
onSave,
function InstanceList({
instances,
mode,
workspaceId,
onEdit,
onDelete,
}: ActionBarProps) {
onSaved,
onCancel,
}: InstanceListProps) {
if (instances.length === 0 && mode.kind !== "add") {
return (
<p className="text-sm text-muted-foreground py-2" data-testid="sentry-no-instances">
No Sentry instances yet. Add one to connect this workspace.
</p>
);
}
return (
<div className="flex flex-wrap items-center gap-2">
<Button
type="button"
variant="outline"
onClick={onTest}
disabled={testing || loading || disableTest}
className="cursor-pointer"
title={disableTest ? "Paste an auth token to test the connection" : undefined}
data-testid="sentry-test-button"
>
{testing ? "Testing..." : "Test connection"}
</Button>
<Button
type="button"
onClick={onSave}
disabled={disableSave}
className="cursor-pointer"
data-testid="sentry-save-button"
>
{saveLabel(saving, hasConfig)}
</Button>
{hasConfig && (
<Button
type="button"
variant="destructive"
onClick={onDelete}
className="ml-auto cursor-pointer"
data-testid="sentry-delete-button"
>
Remove configuration
</Button>
<div className="space-y-3">
{instances.map((instance) =>
mode.kind === "edit" && mode.id === instance.id ? (
<SentryInstanceForm
key={instance.id}
workspaceId={workspaceId}
instance={instance}
idPrefix="sentry-edit"
onSaved={onSaved}
onCancel={onCancel}
/>
) : (
<SentryInstanceCard
key={instance.id}
instance={instance}
onEdit={() => onEdit(instance.id)}
onDelete={() => onDelete(instance)}
/>
),
)}
</div>
);
}
type SettingsActionsArgs = {
workspaceId: string;
form: FormState;
setConfig: (cfg: SentryConfig | null) => void;
setForm: (form: FormState) => void;
setTestResult: (r: TestSentryConnectionResult | null) => void;
};
function useSettingsActions({
workspaceId,
form,
setConfig,
setForm,
setTestResult,
}: SettingsActionsArgs) {
const { toast } = useToast();
const [saving, setSaving] = useState(false);
const [testing, setTesting] = useState(false);
const handleTest = useCallback(async () => {
setTesting(true);
setTestResult(null);
try {
const res = await testSentryConnection(form.secret || undefined, form.url || undefined, {
workspaceId,
});
setTestResult(res);
} catch (err) {
setTestResult({ ok: false, error: String(err) });
} finally {
setTesting(false);
}
}, [workspaceId, form, setTestResult]);
const handleSave = useCallback(async () => {
setSaving(true);
try {
const saved = await saveSentryConfig(
{
authMethod: SENTRY_AUTH_METHOD,
url: form.url,
secret: form.secret,
},
{ workspaceId },
);
setConfig(saved);
setForm(configToForm(saved));
setTestResult(null);
toast({ description: "Sentry configuration saved", variant: "success" });
} catch (err) {
toast({ description: `Save failed: ${String(err)}`, variant: "error" });
} finally {
setSaving(false);
}
}, [workspaceId, form, toast, setConfig, setForm, setTestResult]);
const handleDelete = useCallback(async () => {
if (!confirm("Remove Sentry configuration?")) return;
try {
await deleteSentryConfig({ workspaceId });
setConfig(null);
setForm(emptyForm);
setTestResult(null);
toast({ description: "Sentry configuration removed", variant: "success" });
} catch (err) {
toast({ description: `Delete failed: ${String(err)}`, variant: "error" });
}
}, [workspaceId, toast, setConfig, setForm, setTestResult]);
return { saving, testing, handleTest, handleSave, handleDelete };
}
function useSentrySettings(workspaceId: string) {
const { toast } = useToast();
const [config, setConfig] = useState<SentryConfig | null>(null);
const [form, setForm] = useState<FormState>(emptyForm);
const [loading, setLoading] = useState(true);
const [testResult, setTestResult] = useState<TestSentryConnectionResult | null>(null);
const health = configToHealth(config);
const load = useCallback(async () => {
setLoading(true);
try {
const cfg = (await fetchSentryConfig({ workspaceId })) ?? null;
setConfig(cfg);
setForm(configToForm(cfg));
} catch (err) {
toast({ description: `Failed to load Sentry config: ${String(err)}`, variant: "error" });
} finally {
setLoading(false);
}
}, [workspaceId, toast]);
useEffect(() => {
void load();
}, [load]);
useEffect(() => {
const id = setInterval(() => {
fetchSentryConfig({ workspaceId })
.then((cfg) => setConfig(cfg ?? null))
.catch(() => {
/* transient failures are fine — next tick retries */
});
}, INTEGRATION_STATUS_REFRESH_MS);
return () => clearInterval(id);
}, [workspaceId]);
const update = useCallback(
<K extends keyof FormState>(key: K, value: FormState[K]) =>
setForm((prev) => ({ ...prev, [key]: value })),
[],
);
const { saving, testing, handleTest, handleSave, handleDelete } = useSettingsActions({
workspaceId,
form,
setConfig,
setForm,
setTestResult,
});
return {
config,
form,
loading,
saving,
testing,
testResult,
health,
update,
handleTest,
handleSave,
handleDelete,
};
}
function EnabledPill() {
const { enabled, setEnabled } = useSentryEnabled();
return (
@@ -389,41 +137,89 @@ function EnabledPill() {
}
export function SentryConnectionSection({ workspaceId }: { workspaceId: string }) {
const s = useSentrySettings(workspaceId);
const missingSecret = !s.config?.hasSecret && !s.form.secret;
const disableSave = s.saving || missingSecret;
const disableTest = missingSecret;
const { instances, loading, reload } = useInstanceList(workspaceId);
const { toast } = useToast();
const [mode, setMode] = useState<EditMode>({ kind: "none" });
const closeForm = useCallback(() => setMode({ kind: "none" }), []);
const handleSaved = useCallback(async () => {
setMode({ kind: "none" });
await reload();
}, [reload]);
const handleDelete = useCallback(
async (instance: SentryConfig) => {
if (!confirm(`Remove Sentry instance "${instance.name}"?`)) return;
try {
await deleteSentryInstance(workspaceId, instance.id);
toast({ description: "Sentry instance removed", variant: "success" });
await reload();
} catch (err) {
const watchCount = sentryInUseWatchCount(err);
if (watchCount !== null) {
const plural = watchCount === 1 ? "watch" : "watches";
toast({
description: `Can't delete "${instance.name}": ${watchCount} ${plural} still bound to it. Reassign or remove those watchers first.`,
variant: "error",
});
return;
}
toast({ description: `Delete failed: ${String(err)}`, variant: "error" });
}
},
[workspaceId, toast, reload],
);
const canAddInstance =
mode.kind === "none" ||
(mode.kind === "edit" && !instances.some((instance) => instance.id === mode.id));
return (
<SettingsSection
icon={<IconBrandSentry className="h-5 w-5" />}
title="Sentry integration"
description="Connect this workspace to Sentry with a user auth token. Credentials are stored encrypted server-side for the selected workspace."
description="Connect this workspace to Sentry. Add a named instance for each Sentry org or self-hosted host; credentials are stored encrypted server-side."
action={<EnabledPill />}
>
<Card>
<CardContent className="space-y-4 pt-6">
<IntegrationAuthStatusBanner health={s.health} />
<UrlField form={s.form} loading={s.loading} update={s.update} />
<SecretField
form={s.form}
loading={s.loading}
update={s.update}
hasSavedSecret={!!s.config?.hasSecret}
/>
<TestResultAlert result={s.testResult} />
<Separator />
<ActionBar
saving={s.saving}
testing={s.testing}
loading={s.loading}
hasConfig={!!s.config}
disableSave={disableSave}
disableTest={disableTest}
onTest={s.handleTest}
onSave={s.handleSave}
onDelete={s.handleDelete}
/>
<CardContent className="space-y-3 pt-6">
<h3 className="text-sm font-semibold" data-testid="sentry-instances-heading">
Instances
</h3>
{loading && instances.length === 0 ? (
<p className="text-sm text-muted-foreground py-4 text-center">Loading…</p>
) : (
<InstanceList
instances={instances}
mode={mode}
workspaceId={workspaceId}
onEdit={(id) => setMode({ kind: "edit", id })}
onDelete={handleDelete}
onSaved={handleSaved}
onCancel={closeForm}
/>
)}
{mode.kind === "add" && (
<SentryInstanceForm
workspaceId={workspaceId}
instance={null}
idPrefix="sentry-add"
onSaved={handleSaved}
onCancel={closeForm}
/>
)}
{canAddInstance && (
<Button
type="button"
variant="outline"
onClick={() => setMode({ kind: "add" })}
className="cursor-pointer gap-1"
data-testid="sentry-add-instance-button"
>
<IconPlus className="h-4 w-4" />
Add instance
</Button>
)}
</CardContent>
</Card>
</SettingsSection>
@@ -438,9 +234,13 @@ export function SentryIntegrationPage({ workspaceId }: SentryIntegrationPageProp
return (
<div className="space-y-8">
<WorkspaceScopedSection workspaceId={workspaceId}>
{(workspaceId) => <SentryConnectionSection key={workspaceId} workspaceId={workspaceId} />}
{(resolvedWorkspaceId) => (
<div key={resolvedWorkspaceId} className="space-y-8">
<SentryConnectionSection workspaceId={resolvedWorkspaceId} />
<SentryIssueWatchersSection workspaceId={resolvedWorkspaceId} />
</div>
)}
</WorkspaceScopedSection>
<SentryIssueWatchersSection />
</div>
);
}
@@ -6,6 +6,9 @@ import { getJiraTicket } from "@/lib/api/domains/jira-api";
import { getLinearIssue } from "@/lib/api/domains/linear-api";
import { getSentryIssue } from "@/lib/api/domains/sentry-api";
import { updateTask } from "@/lib/api/domains/kanban-api";
import { useSentryInstances } from "@/hooks/domains/sentry/use-sentry-availability";
import type { SentryAvailability } from "@/hooks/domains/sentry/use-sentry-availability";
import type { SentryConfig } from "@/lib/types/sentry";
import { TaskExternalLinkDialog } from "./task-external-link-dialog";
vi.mock("@/lib/api/domains/jira-api", () => ({
@@ -24,13 +27,45 @@ vi.mock("@/lib/api/domains/kanban-api", () => ({
updateTask: vi.fn(),
}));
vi.mock("@/hooks/domains/sentry/use-sentry-availability", () => ({
useSentryInstances: vi.fn(),
isHealthySentryInstance: (i: SentryConfig) => i.hasSecret && i.lastOk,
}));
const INPUT_TEST_ID = "task-external-link-input";
const SUBMIT_TEST_ID = "task-external-link-submit";
const ERROR_TEST_ID = "task-external-link-error";
const INSTANCE_SELECT_TEST_ID = "sentry-link-instance-select";
const NO_INSTANCE_TEST_ID = "sentry-link-no-instance";
const TASK_ID = "task-1";
const WORKSPACE_ID = "workspace-1";
const TASK_TITLE = "Fix login";
function instance(id: string, name: string): SentryConfig {
return {
id,
workspaceId: WORKSPACE_ID,
name,
authMethod: "auth_token",
url: "https://sentry.io",
hasSecret: true,
lastOk: true,
lastError: "",
createdAt: "",
updatedAt: "",
};
}
function mockSentryInstances(state: SentryAvailability["state"], healthy: SentryConfig[]) {
vi.mocked(useSentryInstances).mockReturnValue({
loading: false,
instances: healthy,
healthy,
available: healthy.length > 0,
state,
});
}
afterEach(() => {
cleanup();
vi.clearAllMocks();
@@ -52,7 +87,7 @@ function renderDialog(provider: "jira" | "linear" | "sentry" = "jira") {
);
}
describe("TaskExternalLinkDialog", () => {
describe("TaskExternalLinkDialog — Jira and Linear", () => {
it("validates and links a Jira ticket by updating the task title", async () => {
vi.mocked(getJiraTicket).mockResolvedValue({ key: "PROJ-12" } as never);
vi.mocked(updateTask).mockResolvedValue({ id: TASK_ID, title: "PROJ-12: Fix login" } as never);
@@ -86,24 +121,63 @@ describe("TaskExternalLinkDialog", () => {
});
expect(updateTask).toHaveBeenCalledWith(TASK_ID, { title: "ENG-20: Fix login" });
});
});
it("extracts and links a Sentry issue key from a numeric issue URL", async () => {
describe("TaskExternalLinkDialog — Sentry linking", () => {
it("auto-selects the sole healthy Sentry instance and links against it", async () => {
mockSentryInstances("single", [instance("inst-1", "Production")]);
vi.mocked(getSentryIssue).mockResolvedValue({ shortId: "API-42" } as never);
vi.mocked(updateTask).mockResolvedValue({ id: TASK_ID, title: "API-42: Fix login" } as never);
renderDialog("sentry");
// The sole instance auto-selects, so no picker is shown.
expect(screen.queryByTestId(INSTANCE_SELECT_TEST_ID)).toBeNull();
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), {
target: { value: "https://sentry.io/organizations/acme/issues/123456/" },
});
fireEvent.click(screen.getByTestId(SUBMIT_TEST_ID));
// The chosen instance id is threaded into the strict browse contract.
await waitFor(() => {
expect(getSentryIssue).toHaveBeenCalledWith("123456", { workspaceId: WORKSPACE_ID });
expect(getSentryIssue).toHaveBeenCalledWith(WORKSPACE_ID, "inst-1", "123456");
});
expect(updateTask).toHaveBeenCalledWith(TASK_ID, { title: "API-42: Fix login" });
});
it("prompts for a Sentry instance when several are healthy and blocks submit", () => {
mockSentryInstances("multi", [
instance("inst-1", "Production"),
instance("inst-2", "Self-hosted"),
]);
renderDialog("sentry");
// A picker is shown and submit stays disabled until an instance is chosen.
expect(screen.getByTestId(INSTANCE_SELECT_TEST_ID)).toBeTruthy();
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), { target: { value: "PROJ-1" } });
const submit = screen.getByTestId(SUBMIT_TEST_ID) as HTMLButtonElement;
expect(submit.disabled).toBe(true);
fireEvent.click(submit);
expect(getSentryIssue).not.toHaveBeenCalled();
});
it("explains and blocks linking when the workspace has no healthy Sentry instance", () => {
mockSentryInstances("empty", []);
renderDialog("sentry");
expect(screen.getByTestId(NO_INSTANCE_TEST_ID)).toBeTruthy();
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), { target: { value: "PROJ-1" } });
const submit = screen.getByTestId(SUBMIT_TEST_ID) as HTMLButtonElement;
expect(submit.disabled).toBe(true);
fireEvent.click(submit);
expect(getSentryIssue).not.toHaveBeenCalled();
});
});
describe("TaskExternalLinkDialog — validation", () => {
it("shows an inline validation error for invalid input", async () => {
renderDialog("jira");
@@ -124,3 +198,69 @@ describe("TaskExternalLinkDialog", () => {
expect(screen.queryByTestId(ERROR_TEST_ID)).toBeNull();
});
});
describe("TaskExternalLinkDialog — Sentry availability", () => {
it("clears a selected Sentry instance when it is no longer healthy", async () => {
mockSentryInstances("multi", [
instance("inst-1", "Production"),
instance("inst-2", "Self-hosted"),
]);
renderDialog("sentry");
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), { target: { value: "PROJ-1" } });
fireEvent.click(screen.getByTestId(INSTANCE_SELECT_TEST_ID));
fireEvent.click(await screen.findByRole("option", { name: "Production" }));
await waitFor(() => {
expect((screen.getByTestId(SUBMIT_TEST_ID) as HTMLButtonElement).disabled).toBe(false);
});
mockSentryInstances("multi", [
instance("inst-2", "Self-hosted"),
instance("inst-3", "Staging"),
]);
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), { target: { value: "PROJ-2" } });
await waitFor(() => {
expect((screen.getByTestId(SUBMIT_TEST_ID) as HTMLButtonElement).disabled).toBe(true);
});
});
});
describe("TaskExternalLinkDialog — Sentry sole-instance swap", () => {
it("retargets the link when a poll swaps the sole healthy instance (state stays single)", async () => {
mockSentryInstances("single", [instance("inst-1", "Alpha")]);
vi.mocked(getSentryIssue).mockResolvedValue({ shortId: "PROJ-2" } as never);
vi.mocked(updateTask).mockResolvedValue({ id: TASK_ID, title: "PROJ-2: Fix login" } as never);
const view = renderDialog("sentry");
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), { target: { value: "PROJ-1" } });
await waitFor(() => {
expect((screen.getByTestId(SUBMIT_TEST_ID) as HTMLButtonElement).disabled).toBe(false);
});
// A polling refresh replaces the sole healthy instance (inst-1 -> inst-2)
// while availability state remains "single". The effect must retarget the
// new instance rather than link against the stale inst-1.
mockSentryInstances("single", [instance("inst-2", "Beta")]);
view.rerender(
<StateProvider>
<ToastProvider>
<TaskExternalLinkDialog
open={true}
onOpenChange={vi.fn()}
provider="sentry"
task={{ id: TASK_ID, title: TASK_TITLE }}
workspaceId={WORKSPACE_ID}
/>
</ToastProvider>
</StateProvider>,
);
fireEvent.change(screen.getByTestId(INPUT_TEST_ID), { target: { value: "PROJ-2" } });
fireEvent.click(screen.getByTestId(SUBMIT_TEST_ID));
await waitFor(() => {
expect(getSentryIssue).toHaveBeenCalledWith(WORKSPACE_ID, "inst-2", "PROJ-2");
});
});
});
@@ -12,6 +12,7 @@ import {
} from "@kandev/ui/dialog";
import { Input } from "@kandev/ui/input";
import { Label } from "@kandev/ui/label";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@kandev/ui/select";
import { useToast } from "@/components/toast-provider";
import { useAppStoreApi } from "@/components/state-provider";
import { getJiraTicket } from "@/lib/api/domains/jira-api";
@@ -21,6 +22,7 @@ import { updateTask } from "@/lib/api/domains/kanban-api";
import { JIRA_KEY_RE } from "@/components/jira/jira-ticket-common";
import { LINEAR_KEY_RE } from "@/components/linear/linear-issue-common";
import { extractSentryShortId } from "@/components/sentry/sentry-issue-common";
import { useSentryInstances } from "@/hooks/domains/sentry/use-sentry-availability";
import { findTaskInSnapshots } from "@/lib/kanban/find-task";
import type { SentryIssue } from "@/lib/types/sentry";
import { buildLinkedIssueTitle } from "./task-external-link-utils";
@@ -48,8 +50,11 @@ type ProviderConfig = {
validationHint: string;
successLabel: string;
extractKey: (raw: string) => string | null;
fetch: (key: string, workspaceId: string) => Promise<unknown>;
fetch: (key: string, workspaceId: string, instanceId?: string) => Promise<unknown>;
resolveLinkedKey?: (requestedKey: string, result: unknown) => string;
// requiresInstance gates providers (Sentry) whose fetch must target a chosen
// instance within the workspace before it can run.
requiresInstance?: boolean;
};
const SENTRY_NUMERIC_ISSUE_URL_RE = /\/issues\/(\d+)(?:[/?#]|$)/i;
@@ -95,23 +100,93 @@ const PROVIDERS: Record<ExternalLinkProvider, ProviderConfig> = {
validationHint: "Paste a Sentry issue URL or short ID (PROJ-123).",
successLabel: "Sentry issue linked",
extractKey: extractSentryIssueKey,
fetch: (key, workspaceId) => getSentryIssue(key, { workspaceId }),
fetch: (key, workspaceId, instanceId) => getSentryIssue(workspaceId, instanceId ?? "", key),
resolveLinkedKey: (requestedKey, result) =>
isSentryIssue(result) && result.shortId ? result.shortId : requestedKey,
requiresInstance: true,
},
};
export function TaskExternalLinkDialog({
open,
onOpenChange,
provider,
task,
// SentryLinkInstanceField resolves which Sentry instance a link targets: it
// auto-selects the sole healthy instance, prompts with a picker when several
// are healthy, and explains when none is usable. Owns the instances hook so the
// parent dialog stays provider-agnostic.
function SentryLinkInstanceField({
workspaceId,
}: TaskExternalLinkDialogProps) {
instanceId,
onChange,
}: {
workspaceId: string;
instanceId: string;
onChange: (id: string) => void;
}) {
const sentry = useSentryInstances(workspaceId);
// Depend on a by-value signature of the healthy instance IDs rather than the
// `healthy` array identity: useSentryInstances rebuilds that array on every
// poll (new reference, usually identical contents), which would otherwise
// re-fire this effect needlessly. The signature still changes when the sole
// healthy instance is swapped (state stays "single") or a selected instance
// drops out of a "multi" set.
const healthySignature = sentry.healthy
.map((instance) => instance.id)
.sort()
.join("\n");
useEffect(() => {
const healthyIds = healthySignature ? healthySignature.split("\n") : [];
if (sentry.state === "single") {
onChange(healthyIds[0]);
} else if (
sentry.state === "empty" ||
sentry.state === "unhealthy" ||
(instanceId !== "" && !healthyIds.includes(instanceId))
) {
onChange("");
}
}, [sentry.state, healthySignature, instanceId, onChange]);
if (sentry.state === "empty" || sentry.state === "unhealthy") {
return (
<p className="text-xs text-muted-foreground" data-testid="sentry-link-no-instance">
Connect a healthy Sentry instance in Settings → Integrations → Sentry to link issues.
</p>
);
}
if (sentry.state !== "multi") return null;
return (
<div className="space-y-2">
<Label htmlFor="sentry-link-instance">Sentry instance</Label>
<Select value={instanceId} onValueChange={onChange}>
<SelectTrigger id="sentry-link-instance" data-testid="sentry-link-instance-select">
<SelectValue placeholder="Select an instance" />
</SelectTrigger>
<SelectContent>
{sentry.healthy.map((inst) => (
<SelectItem key={inst.id} value={inst.id}>
{inst.name}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
);
}
// useExternalLinkForm holds the dialog's transient state and the submit action
// (resolve key → fetch the external issue → rename the task). Extracted so the
// component body stays within the max-lines lint budget.
function useExternalLinkForm(
config: ProviderConfig,
task: TaskExternalLinkTarget,
workspaceId: string,
open: boolean,
onOpenChange: (open: boolean) => void,
) {
const { toast } = useToast();
const store = useAppStoreApi();
const config = PROVIDERS[provider];
const [input, setInput] = useState("");
const [instanceId, setInstanceId] = useState("");
const [submitting, setSubmitting] = useState(false);
const [error, setError] = useState<string | null>(null);
@@ -119,6 +194,7 @@ export function TaskExternalLinkDialog({
if (open) {
setInput("");
setError(null);
setInstanceId("");
}
}, [open]);
@@ -128,11 +204,15 @@ export function TaskExternalLinkDialog({
setError(config.validationHint);
return;
}
if (config.requiresInstance && !instanceId) {
setError("Select a Sentry instance to link against.");
return;
}
setSubmitting(true);
setError(null);
try {
const result = await config.fetch(key, workspaceId);
const result = await config.fetch(key, workspaceId, instanceId || undefined);
const state = store.getState();
const latestTask = findTaskInSnapshots(
task.id,
@@ -152,6 +232,20 @@ export function TaskExternalLinkDialog({
}
};
return { input, setInput, instanceId, setInstanceId, submitting, error, setError, submit };
}
export function TaskExternalLinkDialog({
open,
onOpenChange,
provider,
task,
workspaceId,
}: TaskExternalLinkDialogProps) {
const config = PROVIDERS[provider];
const { input, setInput, instanceId, setInstanceId, submitting, error, setError, submit } =
useExternalLinkForm(config, task, workspaceId, open, onOpenChange);
return (
<Dialog open={open} onOpenChange={onOpenChange}>
<DialogContent className="w-[calc(100vw-2rem)] sm:max-w-lg">
@@ -159,6 +253,13 @@ export function TaskExternalLinkDialog({
<DialogTitle>{config.title}</DialogTitle>
<DialogDescription>{config.description}</DialogDescription>
</DialogHeader>
{provider === "sentry" && (
<SentryLinkInstanceField
workspaceId={workspaceId}
instanceId={instanceId}
onChange={setInstanceId}
/>
)}
<div className="space-y-2">
<Label htmlFor="task-external-link-input">{config.inputLabel}</Label>
<Input
@@ -192,7 +293,7 @@ export function TaskExternalLinkDialog({
type="button"
className="cursor-pointer"
onClick={submit}
disabled={submitting || !input.trim()}
disabled={submitting || !input.trim() || (config.requiresInstance && !instanceId)}
data-dialog-default-action
data-testid="task-external-link-submit"
>
+1 -4
View File
@@ -204,12 +204,9 @@ export const test = backendFixture.extend<
await apiClient
.rawRequest("DELETE", `/api/v1/linear/config?${scoped}`)
.catch(() => undefined);
await apiClient
.rawRequest("DELETE", `/api/v1/sentry/config?${scoped}`)
.catch(() => undefined);
await apiClient.deleteAllSentryInstances(seedData.workspaceId).catch(() => undefined);
await apiClient.rawRequest("DELETE", `/api/v1/jira/config`).catch(() => undefined);
await apiClient.rawRequest("DELETE", `/api/v1/linear/config`).catch(() => undefined);
await apiClient.rawRequest("DELETE", `/api/v1/sentry/config`).catch(() => undefined);
await Promise.all([
apiClient.mockJiraReset().catch(() => undefined),
apiClient.mockLinearReset().catch(() => undefined),
+172 -27
View File
@@ -1484,14 +1484,15 @@ export class ApiClient {
});
}
async setSentryConfig(payload: {
async createSentryInstance(payload: {
name: string;
secret: string;
url?: string;
workspaceId?: string;
}): Promise<unknown> {
}): Promise<{ id: string }> {
const { workspaceId, ...config } = payload;
const path = await this.withActiveWorkspace("/api/v1/sentry/config", workspaceId);
return this.request("PUT", path, {
const path = await this.withActiveWorkspace("/api/v1/sentry/instances", workspaceId);
return this.request("POST", path, {
authMethod: "auth_token",
url: "https://sentry.io",
...config,
@@ -1511,19 +1512,37 @@ export class ApiClient {
): Promise<void> {
const timeoutMs = typeof options === "number" ? options : (options.timeoutMs ?? 5_000);
const workspaceId = typeof options === "number" ? undefined : options.workspaceId;
const path = await this.withActiveWorkspace(`/api/v1/${integration}/config`, workspaceId);
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
const res = await this.rawRequest("GET", path);
if (res.ok && res.status === 200) {
const cfg = (await res.json()) as { hasSecret?: boolean; lastOk?: boolean };
if (cfg.hasSecret && cfg.lastOk) return;
}
await new Promise((r) => setTimeout(r, 100));
if (await this.integrationReportsHealthy(integration, workspaceId)) return;
await new Promise<void>((resolve) => setTimeout(resolve, 100));
}
throw new Error(`${integration} config never reported lastOk: true within ${timeoutMs}ms`);
}
// integrationReportsHealthy probes an integration's current auth-health.
// Sentry is multi-instance (checks whether ANY instance is healthy); the
// others expose a single workspace config.
private async integrationReportsHealthy(
integration: "jira" | "linear" | "sentry",
workspaceId?: string,
): Promise<boolean> {
if (integration === "sentry") {
const path = await this.withActiveWorkspace("/api/v1/sentry/instances", workspaceId);
const res = await this.rawRequest("GET", path);
if (!res.ok || res.status !== 200) return false;
const body = (await res.json()) as {
instances?: Array<{ hasSecret?: boolean; lastOk?: boolean }>;
};
return (body.instances ?? []).some((i) => Boolean(i.hasSecret) && Boolean(i.lastOk));
}
const path = await this.withActiveWorkspace(`/api/v1/${integration}/config`, workspaceId);
const res = await this.rawRequest("GET", path);
if (!res.ok || res.status !== 200) return false;
const cfg = (await res.json()) as { hasSecret?: boolean; lastOk?: boolean };
return Boolean(cfg.hasSecret) && Boolean(cfg.lastOk);
}
// --- Jira Mock Control ---
async mockJiraReset(): Promise<void> {
@@ -1634,32 +1653,148 @@ export class ApiClient {
await this.request("DELETE", "/api/v1/sentry/mock/reset");
}
async mockSentrySetAuthResult(result: {
ok: boolean;
userId?: string;
displayName?: string;
email?: string;
error?: string;
}): Promise<void> {
await this.request("PUT", "/api/v1/sentry/mock/auth-result", result);
// mockSentrySetAuthResult seeds the auth-check result for one instance's mock
// dataset. Omit instanceId to target the pre-save ("") dataset used by
// test-connection before an instance exists.
async mockSentrySetAuthResult(
result: { ok: boolean; userId?: string; displayName?: string; email?: string; error?: string },
instanceId?: string,
): Promise<void> {
const query = instanceId ? `?instanceId=${encodeURIComponent(instanceId)}` : "";
await this.request("PUT", `/api/v1/sentry/mock/auth-result${query}`, result);
}
// mockSentrySetAuthHealth synchronously stamps last_ok/last_error on one
// instance row, bypassing the async probe.
async mockSentrySetAuthHealth(args: {
instanceId: string;
ok: boolean;
error?: string;
workspaceId?: string;
}): Promise<void> {
const { workspaceId, ...payload } = args;
const path = await this.withActiveWorkspace("/api/v1/sentry/mock/auth-health", workspaceId);
await this.request("PUT", path, payload);
const { instanceId, ...payload } = args;
await this.request(
"PUT",
`/api/v1/sentry/mock/auth-health?instanceId=${encodeURIComponent(instanceId)}`,
payload,
);
}
async mockSentrySetOrganizations(organizations: MockSentryOrganization[]): Promise<void> {
await this.request("POST", "/api/v1/sentry/mock/organizations", { organizations });
async mockSentrySetOrganizations(
instanceId: string,
organizations: MockSentryOrganization[],
): Promise<void> {
await this.request(
"POST",
`/api/v1/sentry/mock/organizations?instanceId=${encodeURIComponent(instanceId)}`,
{ organizations },
);
}
async mockSentrySetProjects(projects: MockSentryProject[]): Promise<void> {
await this.request("POST", "/api/v1/sentry/mock/projects", { projects });
async mockSentrySetProjects(instanceId: string, projects: MockSentryProject[]): Promise<void> {
await this.request(
"POST",
`/api/v1/sentry/mock/projects?instanceId=${encodeURIComponent(instanceId)}`,
{ projects },
);
}
// --- Sentry instance + watch CRUD ---
async createSentryInstance(opts: {
workspaceId: string;
name: string;
url?: string;
secret: string;
authMethod?: string;
}): Promise<MockSentryInstance> {
return this.request<MockSentryInstance>(
"POST",
`/api/v1/sentry/instances?workspace_id=${encodeURIComponent(opts.workspaceId)}`,
{
workspaceId: opts.workspaceId,
name: opts.name,
authMethod: opts.authMethod ?? "auth_token",
url: opts.url ?? "https://sentry.io",
secret: opts.secret,
},
);
}
async listSentryInstances(workspaceId: string): Promise<MockSentryInstance[]> {
const { instances } = await this.request<{ instances: MockSentryInstance[] }>(
"GET",
`/api/v1/sentry/instances?workspace_id=${encodeURIComponent(workspaceId)}`,
);
return instances ?? [];
}
// deleteSentryInstanceRaw returns the raw Response so callers can assert the
// 409 SENTRY_INSTANCE_IN_USE (with watchCount) when a watch still binds.
async deleteSentryInstanceRaw(workspaceId: string, instanceId: string): Promise<Response> {
return this.rawRequest(
"DELETE",
`/api/v1/sentry/instances/${encodeURIComponent(instanceId)}?workspace_id=${encodeURIComponent(workspaceId)}`,
);
}
// deleteAllSentryInstances removes every watch (FK-protected) then every
// instance in a workspace — the per-test cleanup replacement for the removed
// /config DELETE.
async deleteAllSentryInstances(workspaceId?: string): Promise<void> {
const watchesPath = await this.withActiveWorkspace("/api/v1/sentry/watches/issue", workspaceId);
const watchesRes = await this.rawRequest("GET", watchesPath);
if (watchesRes.ok) {
const body = (await watchesRes.json()) as { watches?: Array<{ id: string }> };
for (const w of body.watches ?? []) {
const p = await this.withActiveWorkspace(
`/api/v1/sentry/watches/issue/${encodeURIComponent(w.id)}`,
workspaceId,
);
await this.rawRequest("DELETE", p).catch(() => undefined);
}
}
const listPath = await this.withActiveWorkspace("/api/v1/sentry/instances", workspaceId);
const res = await this.rawRequest("GET", listPath);
if (!res.ok) return;
const body = (await res.json()) as { instances?: Array<{ id: string }> };
for (const instance of body.instances ?? []) {
const p = await this.withActiveWorkspace(
`/api/v1/sentry/instances/${encodeURIComponent(instance.id)}`,
workspaceId,
);
await this.rawRequest("DELETE", p).catch(() => undefined);
}
}
async createSentryIssueWatch(opts: {
workspaceId: string;
sentryInstanceId: string;
workflowId: string;
workflowStepId: string;
agentProfileId: string;
executorProfileId?: string;
orgSlug: string;
projectSlug?: string;
prompt?: string;
pollIntervalSeconds?: number;
}): Promise<{ id: string; sentryInstanceId: string; enabled: boolean }> {
return this.request(
"POST",
`/api/v1/sentry/watches/issue?workspace_id=${encodeURIComponent(opts.workspaceId)}`,
{
workspaceId: opts.workspaceId,
sentryInstanceId: opts.sentryInstanceId,
workflowId: opts.workflowId,
workflowStepId: opts.workflowStepId,
repositoryId: "",
baseBranch: "",
filter: { orgSlug: opts.orgSlug, projectSlug: opts.projectSlug },
agentProfileId: opts.agentProfileId,
executorProfileId: opts.executorProfileId ?? "",
prompt: opts.prompt ?? "Investigate {{issue.title}}",
pollIntervalSeconds: opts.pollIntervalSeconds ?? 300,
},
);
}
// --- Linear issue watch CRUD ---
@@ -2052,3 +2187,13 @@ export type MockLinearIssue = {
export type MockSentryOrganization = { id: string; slug: string; name: string };
export type MockSentryProject = { id: string; slug: string; name: string; orgSlug: string };
// MockSentryInstance is the subset of a created instance the e2e helpers read.
export type MockSentryInstance = {
id: string;
workspaceId: string;
name: string;
url: string;
hasSecret: boolean;
lastOk: boolean;
};
+35 -13
View File
@@ -1,24 +1,46 @@
import { type Locator, type Page } from "@playwright/test";
// SentrySettingsPage drives the multi-instance Sentry settings UI: an instance
// list of cards plus mutually-exclusive add/edit forms.
export class SentrySettingsPage {
readonly urlInput: Locator;
readonly secretInput: Locator;
readonly testButton: Locator;
readonly saveButton: Locator;
readonly deleteButton: Locator;
readonly statusBanner: Locator;
readonly addInstanceButton: Locator;
readonly cards: Locator;
readonly noInstances: Locator;
readonly addNameInput: Locator;
readonly addUrlInput: Locator;
readonly addSecretInput: Locator;
readonly addTestButton: Locator;
readonly addSaveButton: Locator;
constructor(private page: Page) {
this.urlInput = page.getByTestId("sentry-url-input");
this.secretInput = page.getByTestId("sentry-secret-input");
this.testButton = page.getByTestId("sentry-test-button");
this.saveButton = page.getByTestId("sentry-save-button");
this.deleteButton = page.getByTestId("sentry-delete-button");
this.statusBanner = page.getByTestId("integration-auth-status-banner");
this.addInstanceButton = page.getByTestId("sentry-add-instance-button");
this.cards = page.getByTestId("sentry-instance-card");
this.noInstances = page.getByTestId("sentry-no-instances");
this.addNameInput = page.getByTestId("sentry-add-name-input");
this.addUrlInput = page.getByTestId("sentry-add-url-input");
this.addSecretInput = page.getByTestId("sentry-add-secret-input");
this.addTestButton = page.getByTestId("sentry-add-test-button");
this.addSaveButton = page.getByTestId("sentry-add-save-button");
}
async goto() {
await this.page.goto("/settings/integrations/sentry");
await this.secretInput.waitFor({ state: "visible" });
// The "Add instance" button renders whenever no form is open — present in
// both the empty and populated states, so it is a reliable ready signal.
await this.addInstanceButton.waitFor({ state: "visible" });
}
async addInstance(name: string, secret: string, url?: string) {
await this.addInstanceButton.click();
await this.addNameInput.fill(name);
if (url) await this.addUrlInput.fill(url);
await this.addSecretInput.fill(secret);
await this.addSaveButton.click();
}
// cardByName scopes to the card whose visible name matches, so per-instance
// assertions (banner, delete) target the right card.
cardByName(name: string): Locator {
return this.cards.filter({ hasText: name });
}
}
@@ -3,68 +3,87 @@ import { SentrySettingsPage } from "../../pages/sentry-settings-page";
const TOKEN = "sntrys_xxx";
test.describe("Sentry settings", () => {
// The settings page configures only the auth token; org/project are chosen
// per-watcher and per-browse, not stored install-wide. This covers the
// connect → save → validated flow and persistence of the saved token.
test("connects, saves, and reports a healthy token", async ({ testPage, apiClient }) => {
test.describe("Sentry settings — instances", () => {
// The settings page manages a LIST of named instances per workspace. This
// covers add → the card appears → the backend probe flips it healthy.
test("adds a named instance and reports it healthy", async ({ testPage, apiClient }) => {
await apiClient.mockSentryReset();
await apiClient.mockSentrySetAuthResult({
ok: true,
userId: "u-1",
displayName: "Sentry Tester",
email: "tester@example.com",
});
const settings = new SentrySettingsPage(testPage);
await settings.goto();
// Connection test surfaces inline success ("Connected as <displayName>").
await settings.secretInput.fill(TOKEN);
await settings.testButton.click();
await expect(testPage.getByText(/Connected as Sentry Tester/)).toBeVisible();
// The add form pre-fills the SaaS URL default.
await settings.addInstanceButton.click();
await expect(settings.addUrlInput).toHaveValue("https://sentry.io");
// Save persists the secret and triggers the auth-health probe that flips
// lastOk -> true.
await settings.saveButton.click();
await expect(settings.saveButton).toHaveText(/Update/i);
await settings.addNameInput.fill("Production");
await settings.addSecretInput.fill(TOKEN);
await settings.addSaveButton.click();
// The instance now renders as a card. Its async probe (unseeded mock = OK)
// flips lastOk true; reload to pick up the health banner deterministically.
await expect(settings.cardByName("Production")).toBeVisible();
await apiClient.waitForIntegrationAuthHealthy("sentry");
// Reload: the saved token survives (placeholder shows the masked state and
// the action becomes "Update"/"Remove configuration").
await settings.goto();
await expect(settings.saveButton).toHaveText(/Update/i);
await expect(settings.deleteButton).toBeVisible();
await expect(
settings.cardByName("Production").getByTestId("integration-auth-status-banner"),
).toHaveAttribute("data-state", "ok");
});
// Self-hosted support: the instance URL defaults to sentry.io, accepts a
// custom host, and persists across reload via the saved config.
test("defaults the instance URL and persists a self-hosted URL", async ({
// Two instances coexist in one workspace; a watcher bound to one FK-protects
// it, so deleting that instance is blocked (409 SENTRY_INSTANCE_IN_USE with a
// watch count) while the unbound instance deletes cleanly.
test("blocks deleting an instance a watcher still uses", async ({
testPage,
apiClient,
seedData,
}) => {
await apiClient.mockSentryReset();
await apiClient.mockSentrySetAuthResult({
ok: true,
userId: "u-2",
displayName: "Self Hosted",
const primary = await apiClient.createSentryInstance({
workspaceId: seedData.workspaceId,
name: "Primary",
secret: TOKEN,
});
const secondary = await apiClient.createSentryInstance({
workspaceId: seedData.workspaceId,
name: "Secondary",
url: "https://sentry.acme.example.com",
secret: TOKEN,
});
await apiClient.mockSentrySetAuthHealth({ instanceId: primary.id, ok: true });
await apiClient.mockSentrySetAuthHealth({ instanceId: secondary.id, ok: true });
// Bind a watch to the primary instance only.
await apiClient.createSentryIssueWatch({
workspaceId: seedData.workspaceId,
sentryInstanceId: primary.id,
workflowId: seedData.workflowId,
workflowStepId: seedData.startStepId,
agentProfileId: seedData.agentProfileId,
orgSlug: "acme",
projectSlug: "web",
});
// API contract: delete-in-use rejects 409 and reports the blocking count.
const res = await apiClient.deleteSentryInstanceRaw(seedData.workspaceId, primary.id);
expect(res.status).toBe(409);
const body = (await res.json()) as { code?: string; watchCount?: number };
expect(body.code).toBe("SENTRY_INSTANCE_IN_USE");
expect(body.watchCount).toBe(1);
// UI: the delete is surfaced as an error and the primary card survives; the
// watcher-free secondary deletes cleanly.
const settings = new SentrySettingsPage(testPage);
await settings.goto();
await expect(settings.cards).toHaveCount(2);
testPage.on("dialog", (d) => d.accept());
// The URL field is pre-filled with the SaaS default.
await expect(settings.urlInput).toHaveValue("https://sentry.io");
await settings.cardByName("Primary").getByTestId("sentry-instance-delete-button").click();
await expect(testPage.getByText(/still bound to it/i)).toBeVisible();
await expect(settings.cardByName("Primary")).toBeVisible();
// Point it at a self-hosted instance and save with a token.
await settings.urlInput.fill("https://sentry.acme.example.com");
await settings.secretInput.fill(TOKEN);
await settings.saveButton.click();
await expect(settings.saveButton).toHaveText(/Update/i);
await apiClient.waitForIntegrationAuthHealthy("sentry");
// Reload: the custom instance URL round-trips through the saved config.
await settings.goto();
await expect(settings.urlInput).toHaveValue("https://sentry.acme.example.com");
await settings.cardByName("Secondary").getByTestId("sentry-instance-delete-button").click();
await expect(settings.cardByName("Secondary")).toHaveCount(0);
await expect(settings.cardByName("Primary")).toBeVisible();
});
});
@@ -13,11 +13,16 @@ test.describe("Mobile sidebar — external link menu", () => {
secret: "api-token-value",
});
await apiClient.setLinearConfig({ secret: "lin_api_xxx" });
await apiClient.setSentryConfig({ secret: "sntrys_xxx" });
const sentry = await apiClient.createSentryInstance({
workspaceId: seedData.workspaceId,
name: "Sentry",
secret: "sntrys_xxx",
});
await apiClient.mockSentrySetAuthHealth({ instanceId: sentry.id, ok: true });
await Promise.all([
apiClient.waitForIntegrationAuthHealthy("jira"),
apiClient.waitForIntegrationAuthHealthy("linear"),
apiClient.waitForIntegrationAuthHealthy("sentry"),
apiClient.waitForIntegrationAuthHealthy("sentry", { workspaceId: seedData.workspaceId }),
]);
const task = await apiClient.seedTask(seedData.workspaceId, "Mobile external link task", {
@@ -1,28 +1,92 @@
"use client";
import { useCallback } from "react";
import { fetchSentryConfig } from "@/lib/api/domains/sentry-api";
import {
useIntegrationAuthed,
useIntegrationAvailable,
} from "../integrations/use-integration-availability";
import { useEffect, useMemo, useRef, useState } from "react";
import { listSentryInstances } from "@/lib/api/domains/sentry-api";
import type { SentryConfig } from "@/lib/types/sentry";
import { INTEGRATION_STATUS_REFRESH_MS } from "../integrations/use-integration-availability";
import { useSentryEnabled } from "./use-sentry-enabled";
export function useSentryAuthed(workspaceId?: string | null): boolean {
const fetchConfig = useCallback(
async () => (await fetchSentryConfig(workspaceId ? { workspaceId } : undefined)) ?? null,
[workspaceId],
);
return useIntegrationAuthed(fetchConfig);
// isHealthySentryInstance is the single definition of a usable instance:
// credentials are stored AND the most recent backend probe succeeded.
export function isHealthySentryInstance(instance: SentryConfig): boolean {
return instance.hasSecret && instance.lastOk;
}
export function useSentryAvailable(workspaceId?: string | null): boolean {
const fetchConfig = useCallback(
async () => (await fetchSentryConfig(workspaceId ? { workspaceId } : undefined)) ?? null,
[workspaceId],
);
return useIntegrationAvailable({
useEnabled: useSentryEnabled,
fetchConfig,
});
// SentryAvailabilityState distinguishes the shapes the browse surfaces care
// about: still loading, no instances at all, instances but none healthy, one
// healthy (auto-select), or several healthy (must prompt).
export type SentryAvailabilityState = "loading" | "empty" | "unhealthy" | "single" | "multi";
export type SentryAvailability = {
loading: boolean;
// instances is every instance in the workspace; healthy is the subset that is
// authenticated and passing its health probe.
instances: SentryConfig[];
healthy: SentryConfig[];
// available gates whether Sentry entry points render: toggle on AND at least
// one healthy instance.
available: boolean;
state: SentryAvailabilityState;
};
// useSentryInstances polls a workspace's Sentry instances (respecting the
// per-workspace enabled toggle) and derives the availability state the browse
// surfaces and settings banner consume. Fetches are request-versioned so a slow
// response for a previous workspace can't clobber a newer one.
export function useSentryInstances(workspaceId?: string | null): SentryAvailability {
const { enabled, loaded } = useSentryEnabled();
const active = loaded && enabled && !!workspaceId;
const [instances, setInstances] = useState<SentryConfig[]>([]);
const [loading, setLoading] = useState(true);
const requestId = useRef(0);
useEffect(() => {
if (!active || !workspaceId) {
// Drop any state carried over from a previous workspace / enabled toggle
// so a disabled integration shows no stale instances.
setInstances([]);
setLoading(false);
return;
}
setLoading(true);
setInstances([]);
let cancelled = false;
const refresh = async () => {
const current = ++requestId.current;
try {
const list = await listSentryInstances(workspaceId);
if (cancelled || current !== requestId.current) return;
setInstances(list);
} catch {
if (cancelled || current !== requestId.current) return;
setInstances([]);
} finally {
if (!cancelled && current === requestId.current) setLoading(false);
}
};
void refresh();
const id = setInterval(() => void refresh(), INTEGRATION_STATUS_REFRESH_MS);
return () => {
cancelled = true;
clearInterval(id);
};
}, [active, workspaceId]);
return useMemo(() => {
const healthy = instances.filter(isHealthySentryInstance);
const available = active && healthy.length >= 1;
let state: SentryAvailabilityState;
if (loading) state = "loading";
else if (instances.length === 0) state = "empty";
else if (healthy.length === 0) state = "unhealthy";
else if (healthy.length === 1) state = "single";
else state = "multi";
return { loading, instances, healthy, available, state };
}, [active, instances, loading]);
}
// useSentryAvailable is the boolean gate that shows/hides Sentry entry points:
// the workspace toggle is on AND at least one instance is healthy.
export function useSentryAvailable(workspaceId?: string | null): boolean {
return useSentryInstances(workspaceId).available;
}
@@ -0,0 +1,39 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("@/lib/config", () => ({
getBackendConfig: () => ({ apiBaseUrl: "http://api.test" }),
}));
import { copySentryInstances } from "./sentry-api";
type FetchInput = Parameters<typeof fetch>[0];
type FetchInit = Parameters<typeof fetch>[1];
const fetchSpy = vi.fn<[FetchInput, FetchInit?], Promise<Response>>();
beforeEach(() => {
fetchSpy.mockReset();
vi.stubGlobal("fetch", fetchSpy);
});
afterEach(() => {
vi.unstubAllGlobals();
});
describe("copySentryInstances", () => {
it("scopes the copy to its source workspace and sends only the target in JSON", async () => {
fetchSpy.mockResolvedValueOnce(
new Response(JSON.stringify({ instances: [] }), {
status: 200,
headers: { "Content-Type": "application/json" },
}),
);
await copySentryInstances("ws-target", { workspaceId: "ws-source" });
const [url, init] = fetchSpy.mock.calls.at(-1) ?? [];
expect(String(url)).toBe("http://api.test/api/v1/sentry/config/copy?workspace_id=ws-source");
expect(init?.method).toBe("POST");
expect(JSON.parse(String(init?.body))).toEqual({ targetWorkspaceId: "ws-target" });
});
});
+198 -74
View File
@@ -1,5 +1,7 @@
import { fetchJson, type ApiRequestOptions } from "../client";
import { ApiError, fetchJson, type ApiRequestOptions } from "../client";
import type {
CopySentryConfigRequest,
CreateSentryConfigRequest,
CreateSentryIssueWatchRequest,
SentryConfig,
SentryIssue,
@@ -8,93 +10,203 @@ import type {
SentryProject,
SentrySearchFilter,
SentrySearchResult,
SetSentryConfigRequest,
TestSentryConnectionResult,
UpdateSentryConfigRequest,
UpdateSentryIssueWatchRequest,
} from "@/lib/types/sentry";
type WorkspaceApiOptions = ApiRequestOptions & { workspaceId?: string };
const BASE = "/api/v1/sentry";
function withWorkspace(path: string, options?: WorkspaceApiOptions): string {
if (!options?.workspaceId) return path;
const separator = path.includes("?") ? "&" : "?";
return `${path}${separator}workspace_id=${encodeURIComponent(options.workspaceId)}`;
// SENTRY_ERROR_CODES are the wire-level `code` discriminators the backend
// stamps on structured error bodies so the UI can react without matching on
// human-readable error text.
export const SENTRY_ERROR_CODES = {
instanceRequired: "SENTRY_INSTANCE_REQUIRED",
instanceNotFound: "SENTRY_INSTANCE_NOT_FOUND",
instanceInUse: "SENTRY_INSTANCE_IN_USE",
nameTaken: "SENTRY_INSTANCE_NAME_TAKEN",
notConfigured: "SENTRY_NOT_CONFIGURED",
} as const;
// sentryErrorCode extracts the backend `code` from a failed request, or null
// when the rejection is not an ApiError or carries no code.
export function sentryErrorCode(err: unknown): string | null {
if (!(err instanceof ApiError)) return null;
const body = err.body;
if (body && typeof body === "object" && "code" in body) {
const code = body.code;
return typeof code === "string" ? code : null;
}
return null;
}
function requestOptions(options?: WorkspaceApiOptions): ApiRequestOptions | undefined {
if (!options) return undefined;
const { workspaceId: _workspaceId, ...rest } = options;
return rest;
// sentryInUseWatchCount returns the count of watches blocking a delete when the
// error is a 409 SENTRY_INSTANCE_IN_USE, else null.
export function sentryInUseWatchCount(err: unknown): number | null {
if (!(err instanceof ApiError) || err.status !== 409) return null;
if (sentryErrorCode(err) !== SENTRY_ERROR_CODES.instanceInUse) return null;
const body = err.body;
if (body && typeof body === "object" && "watchCount" in body) {
const count = body.watchCount;
return typeof count === "number" ? count : null;
}
return null;
}
// fetchSentryConfig returns undefined when the backend responds 204 (no config yet).
export async function fetchSentryConfig(
options?: WorkspaceApiOptions,
): Promise<SentryConfig | undefined> {
return fetchJson<SentryConfig | undefined>(
withWorkspace(`/api/v1/sentry/config`, options),
requestOptions(options),
// withParams appends non-empty query params to a path, respecting any existing
// query string.
function withParams(path: string, params: Record<string, string>): string {
const search = new URLSearchParams();
for (const [key, value] of Object.entries(params)) {
if (value) search.set(key, value);
}
const query = search.toString();
if (!query) return path;
return `${path}${path.includes("?") ? "&" : "?"}${query}`;
}
// --- Instances (per-workspace named Sentry configs) ---
// listSentryInstances returns every Sentry instance configured in a workspace.
export async function listSentryInstances(workspaceId: string, options?: ApiRequestOptions) {
const res = await fetchJson<{ instances: SentryConfig[] }>(
withParams(`${BASE}/instances`, { workspace_id: workspaceId }),
options,
);
return res.instances ?? [];
}
// getSentryInstance fetches one instance by id, scoped to its workspace.
export async function getSentryInstance(
workspaceId: string,
id: string,
options?: ApiRequestOptions,
) {
return fetchJson<SentryConfig>(
withParams(`${BASE}/instances/${encodeURIComponent(id)}`, { workspace_id: workspaceId }),
options,
);
}
export async function saveSentryConfig(
payload: SetSentryConfigRequest,
options?: WorkspaceApiOptions,
// createSentryInstance adds a new named instance to a workspace.
export async function createSentryInstance(
workspaceId: string,
payload: CreateSentryConfigRequest,
options?: ApiRequestOptions,
) {
return fetchJson<SentryConfig>(withWorkspace(`/api/v1/sentry/config`, options), {
...requestOptions(options),
init: { ...(options?.init ?? {}), method: "PUT", body: JSON.stringify(payload) },
return fetchJson<SentryConfig>(withParams(`${BASE}/instances`, { workspace_id: workspaceId }), {
...options,
init: { ...(options?.init ?? {}), method: "POST", body: JSON.stringify(payload) },
});
}
export async function deleteSentryConfig(options?: WorkspaceApiOptions) {
return fetchJson<{ deleted: boolean }>(withWorkspace(`/api/v1/sentry/config`, options), {
...requestOptions(options),
init: { ...(options?.init ?? {}), method: "DELETE" },
});
}
export async function testSentryConnection(
secret?: string,
url?: string,
options?: WorkspaceApiOptions,
// updateSentryInstance replaces an instance's name/url/auth (and, when a
// non-empty secret is supplied, its stored token).
export async function updateSentryInstance(
workspaceId: string,
id: string,
payload: UpdateSentryConfigRequest,
options?: ApiRequestOptions,
) {
const payload: { secret?: string; url?: string } = {};
if (secret) payload.secret = secret;
if (url) payload.url = url;
return fetchJson<TestSentryConnectionResult>(
withWorkspace(`/api/v1/sentry/config/test`, options),
return fetchJson<SentryConfig>(
withParams(`${BASE}/instances/${encodeURIComponent(id)}`, { workspace_id: workspaceId }),
{
...requestOptions(options),
init: {
...(options?.init ?? {}),
method: "POST",
body: JSON.stringify(payload),
},
...options,
init: { ...(options?.init ?? {}), method: "PUT", body: JSON.stringify(payload) },
},
);
}
// copySentryConfig copies the Sentry config + credential from the workspace in
// options (source) to targetWorkspaceId.
export async function copySentryConfig(targetWorkspaceId: string, options?: WorkspaceApiOptions) {
return fetchJson<SentryConfig>(withWorkspace(`/api/v1/sentry/config/copy`, options), {
...requestOptions(options),
init: { ...(options?.init ?? {}), method: "POST", body: JSON.stringify({ targetWorkspaceId }) },
});
}
export async function listSentryOrganizations(options?: WorkspaceApiOptions) {
return fetchJson<{ organizations: SentryOrganization[] }>(
withWorkspace(`/api/v1/sentry/organizations`, options),
requestOptions(options),
// deleteSentryInstance removes an instance. Rejects with a 409
// SENTRY_INSTANCE_IN_USE (carrying watchCount) when watches still bind to it.
export async function deleteSentryInstance(
workspaceId: string,
id: string,
options?: ApiRequestOptions,
) {
return fetchJson<{ deleted: boolean }>(
withParams(`${BASE}/instances/${encodeURIComponent(id)}`, { workspace_id: workspaceId }),
{
...options,
init: { ...(options?.init ?? {}), method: "DELETE" },
},
);
}
export async function listSentryProjects(options?: WorkspaceApiOptions) {
// testSentryInstance pings Sentry with a saved instance's stored credentials.
export async function testSentryInstance(
workspaceId: string,
id: string,
options?: ApiRequestOptions,
) {
return fetchJson<TestSentryConnectionResult>(
withParams(`${BASE}/instances/${encodeURIComponent(id)}/test`, { workspace_id: workspaceId }),
{ ...options, init: { ...(options?.init ?? {}), method: "POST" } },
);
}
// testSentryConnection pings Sentry with ad-hoc credentials (before an instance
// is saved) to validate a token/URL pair.
export async function testSentryConnection(
workspaceId: string,
creds: { secret?: string; url?: string; authMethod?: string },
options?: ApiRequestOptions,
) {
const payload: { secret?: string; url?: string; authMethod?: string } = {};
if (creds.secret) payload.secret = creds.secret;
if (creds.url) payload.url = creds.url;
if (creds.authMethod) payload.authMethod = creds.authMethod;
return fetchJson<TestSentryConnectionResult>(
withParams(`${BASE}/test-connection`, { workspace_id: workspaceId }),
{
...options,
init: { ...(options?.init ?? {}), method: "POST", body: JSON.stringify(payload) },
},
);
}
// copySentryInstances copies every instance (and its credential) from the
// source workspace (options.workspaceId) into the target workspace in the
// JSON body, returning the newly-created instances. The source workspace is
// authoritative for this route, so options.workspaceId is required —
// mirrors copyGitHubWorkspaceSettings's convention for consistency.
export async function copySentryInstances(
targetWorkspaceId: string,
options: { workspaceId: string } & ApiRequestOptions,
) {
const { workspaceId: sourceWorkspaceId, ...requestOptions } = options;
const payload: Pick<CopySentryConfigRequest, "targetWorkspaceId"> = { targetWorkspaceId };
const res = await fetchJson<{ instances: SentryConfig[] }>(
withParams(`${BASE}/config/copy`, { workspace_id: sourceWorkspaceId }),
{
...requestOptions,
init: { ...(requestOptions.init ?? {}), method: "POST", body: JSON.stringify(payload) },
},
);
return res.instances ?? [];
}
// --- Browse (org/project/issue lookups scoped to one instance) ---
export async function listSentryOrganizations(
workspaceId: string,
instanceId: string,
options?: ApiRequestOptions,
) {
return fetchJson<{ organizations: SentryOrganization[] }>(
withParams(`${BASE}/organizations`, { workspace_id: workspaceId, instanceId }),
options,
);
}
export async function listSentryProjects(
workspaceId: string,
instanceId: string,
options?: ApiRequestOptions,
) {
return fetchJson<{ projects: SentryProject[] }>(
withWorkspace(`/api/v1/sentry/projects`, options),
requestOptions(options),
withParams(`${BASE}/projects`, { workspace_id: workspaceId, instanceId }),
options,
);
}
@@ -109,23 +221,32 @@ function appendFilter(search: URLSearchParams, filter: SentrySearchFilter): void
}
export async function searchSentryIssues(
workspaceId: string,
instanceId: string,
filter: SentrySearchFilter,
cursor?: string,
options?: WorkspaceApiOptions,
options?: ApiRequestOptions,
) {
const search = new URLSearchParams();
search.set("workspace_id", workspaceId);
search.set("instanceId", instanceId);
appendFilter(search, filter);
if (cursor) search.set("cursor", cursor);
return fetchJson<SentrySearchResult>(
withWorkspace(`/api/v1/sentry/issues?${search.toString()}`, options),
requestOptions(options),
);
return fetchJson<SentrySearchResult>(`${BASE}/issues?${search.toString()}`, options);
}
export async function getSentryIssue(idOrShortId: string, options?: WorkspaceApiOptions) {
export async function getSentryIssue(
workspaceId: string,
instanceId: string,
idOrShortId: string,
options?: ApiRequestOptions,
) {
return fetchJson<SentryIssue>(
withWorkspace(`/api/v1/sentry/issues/${encodeURIComponent(idOrShortId)}`, options),
requestOptions(options),
withParams(`${BASE}/issues/${encodeURIComponent(idOrShortId)}`, {
workspace_id: workspaceId,
instanceId,
}),
options,
);
}
@@ -156,10 +277,13 @@ export async function createSentryIssueWatch(
payload: CreateSentryIssueWatchRequest,
options?: ApiRequestOptions,
) {
return fetchJson<SentryIssueWatch>(`/api/v1/sentry/watches/issue`, {
...options,
init: { ...(options?.init ?? {}), method: "POST", body: JSON.stringify(payload) },
});
return fetchJson<SentryIssueWatch>(
withParams(`${BASE}/watches/issue`, { workspace_id: payload.workspaceId }),
{
...options,
init: { ...(options?.init ?? {}), method: "POST", body: JSON.stringify(payload) },
},
);
}
export async function updateSentryIssueWatch(
+39 -2
View File
@@ -8,7 +8,12 @@ export const SENTRY_AUTH_METHOD: SentryAuthMethod = "auth_token";
export const SENTRY_DEFAULT_URL = "https://sentry.io";
export interface SentryConfig {
workspaceId?: string;
// ID is the instance UUID: stable for the life of the instance, used as the
// secret key, client-cache key, and issue-watch foreign key.
id: string;
workspaceId: string;
// Name is the user-facing label, required and unique within a workspace.
name: string;
authMethod: SentryAuthMethod;
url: string;
hasSecret: boolean;
@@ -19,12 +24,33 @@ export interface SentryConfig {
updatedAt: string;
}
export interface SetSentryConfigRequest {
// CreateSentryConfigRequest creates a new named Sentry instance in a workspace.
export interface CreateSentryConfigRequest {
workspaceId: string;
name: string;
authMethod: SentryAuthMethod;
url: string;
secret: string;
}
// UpdateSentryConfigRequest updates an existing instance by ID. A blank secret
// keeps the stored value; a non-empty secret replaces it. Name/URL/AuthMethod
// always replace the stored values.
export interface UpdateSentryConfigRequest {
name: string;
authMethod: SentryAuthMethod;
url: string;
secret: string;
}
// CopySentryConfigRequest copies every instance from the source workspace into
// the target workspace: fresh IDs, secrets copied under new keys, names deduped,
// no watches carried over.
export interface CopySentryConfigRequest {
sourceWorkspaceId: string;
targetWorkspaceId: string;
}
export interface TestSentryConnectionResult {
ok: boolean;
userId?: string;
@@ -86,6 +112,12 @@ export interface SentrySearchResult {
export interface SentryIssueWatch {
id: string;
workspaceId: string;
/**
* The Sentry instance this watch polls. Immutable after create — changing it
* means creating a new watch. Empty string = legacy unbound watch (resolved
* to the workspace's sole instance at poll time).
*/
sentryInstanceId: string;
workflowId: string;
workflowStepId: string;
/**
@@ -110,6 +142,11 @@ export interface SentryIssueWatch {
export interface CreateSentryIssueWatchRequest {
workspaceId: string;
/**
* The Sentry instance to poll. Required and must belong to `workspaceId`.
* Immutable after creation.
*/
sentryInstanceId: string;
workflowId: string;
workflowStepId: string;
/** Optional repository binding; empty/omitted = unbound (repo-less task). */
@@ -72,6 +72,39 @@ task-creating pollers.
active workspace route state. Install-wide `/config` semantics are deprecated
for integrations that support workspace-scoped settings.
## Sentry: multiple named instances per workspace
Sentry extends the workspace-scoped baseline: a workspace may hold **several
named Sentry instances** (e.g. a sentry.io SaaS org plus a self-hosted host),
not a single config. This deliberately diverges from the Jira/Linear/GitLab
one-config-per-workspace shape — teams commonly watch issues across more than
one Sentry deployment from the same workspace.
- `sentry_configs` is keyed by an instance `id` (UUID) with a `workspace_id`
column and `UNIQUE(workspace_id, name)`; the secret lives under
`sentry:instance:<id>:token`, disjoint from the legacy
`sentry:<workspaceId>:token` / `sentry:singleton:token` namespaces so a
workspace UUID can never collide with an instance UUID.
- `sentry_issue_watches.sentry_instance_id` is a nullable FK to
`sentry_configs(id)` with `ON DELETE RESTRICT`. NULL marks a migrated legacy
watch; the poller resolves it to the workspace's sole instance at poll time,
or disables it with a recorded error when zero/many instances exist. The
bound instance is **immutable** — changing it means creating a new watch.
- The HTTP surface is instance CRUD under `/api/v1/sentry/instances` with an
authoritative `?workspace_id=`; the instance must belong to that workspace or
the request 404s. Browse endpoints require `workspace_id` + `instanceId`.
Install-wide `/config` GET/PUT/DELETE is removed; `/config/copy` copies a
workspace's instances (new ids, copied secrets, no watches, deduped names).
- Deleting an instance that still has watches returns 409
`SENTRY_INSTANCE_IN_USE` (with `watchCount`); the FK RESTRICT is the atomic
backstop behind the friendly count.
Startup migration chains singleton → workspace-config → per-instance: main's
existing legacy-singleton→workspace step runs first, then each workspace config
row becomes one instance (name derived from the URL host, deduped per
workspace), watches backfill to that instance, and the secret is re-keyed
idempotently (crash-safe: derivable from the post-migration instance rows).
## Alternatives Considered
### Keep GitHub settings global