Files
archie/internal/domain/binding/binding_test.go
T
sam 912db8f590 fix(binding): split ValidateForUpdate so edits can preserve the secret
Real bug found via browser-testing the new bindings UI (t2db.8):
UpdateBinding's own store-layer contract documents that an empty
Secret means "preserve the existing one" (COALESCE against NULLIF),
but handleBindingUpdate validated with the create-time Validate(),
which unconditionally requires a full-length secret -- rejecting the
exact "leave blank to keep it" edit flow the store was built to allow.

Root-cause fix, not a UI workaround: Binding.Validate() (create,
unchanged, still requires a real secret -- there's nothing to fall
back to on insert) now delegates shared field checks to a private
validateCommon(); a new ValidateForUpdate() reuses the same checks but
only enforces the secret-length floor when the caller actually
supplied a new one. handleBindingUpdate now calls ValidateForUpdate.

3 new domain tests + 1 new API-layer test pin: empty secret accepted
on update, a genuinely-short new secret still rejected on update,
empty secret still rejected on create.
2026-09-03 06:17:43 +10:00

95 lines
3.2 KiB
Go

package binding
import "testing"
func validBinding() Binding {
return Binding{
Name: "sentry alerts",
Matcher: Matcher{Source: "sentry"},
MappingID: 1,
Workflow: "implement",
Secret: "0123456789abcdef0123456789abcdef",
}
}
// TestValidateAcceptsNoRepoPin pins backward compatibility: a binding
// with neither Owner nor Repo set (today's only shape) must remain
// valid -- resolveBindingRepo's single-configured-repo fallback still
// applies to it.
func TestValidateAcceptsNoRepoPin(t *testing.T) {
b := validBinding()
if err := b.Validate(); err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
}
// TestValidateAcceptsBothOwnerAndRepo is the multi-repo fix: a binding
// naming a specific owner/repo must be accepted.
func TestValidateAcceptsBothOwnerAndRepo(t *testing.T) {
b := validBinding()
b.Owner, b.Repo = "acme", "widget"
if err := b.Validate(); err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
}
// TestValidateRejectsPartialRepoPin: Owner and Repo are a pair. A
// binding naming only one of them is ambiguous -- it isn't "no pin"
// (that's both empty) and it isn't a complete pin, so it must be
// rejected at validation time rather than silently guessing which
// half was meant.
// TestValidateForUpdateAcceptsEmptySecret is the fix for a real bug found
// via browser testing (t2db.8): UpdateBinding's own documented contract
// treats an empty Secret as "preserve the existing one" (COALESCE against
// NULLIF), but the API handler validated with the create-time Validate,
// which rejected any edit that didn't retype the full secret -- making
// the store's own documented behavior unreachable.
func TestValidateForUpdateAcceptsEmptySecret(t *testing.T) {
b := validBinding()
b.Secret = ""
if err := b.ValidateForUpdate(); err != nil {
t.Fatalf("ValidateForUpdate() = %v, want nil for an empty (preserve-existing) secret", err)
}
}
// TestValidateForUpdateStillEnforcesLengthOnANewSecret confirms the fix
// isn't a blanket bypass: a genuinely-supplied short secret on update is
// still rejected, same floor as create.
func TestValidateForUpdateStillEnforcesLengthOnANewSecret(t *testing.T) {
b := validBinding()
b.Secret = "short"
if err := b.ValidateForUpdate(); err == nil {
t.Fatal("ValidateForUpdate() = nil, want error for a too-short (but non-empty) secret")
}
}
// TestValidateRejectsEmptySecretOnCreate pins that the fix is scoped to
// update only -- Validate (used at create time, where there is no
// existing secret to fall back to) still requires a real one.
func TestValidateRejectsEmptySecretOnCreate(t *testing.T) {
b := validBinding()
b.Secret = ""
if err := b.Validate(); err == nil {
t.Fatal("Validate() = nil, want error for an empty secret at create time")
}
}
func TestValidateRejectsPartialRepoPin(t *testing.T) {
tests := []struct {
name string
owner, repo string
}{
{"owner only", "acme", ""},
{"repo only", "", "widget"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
b := validBinding()
b.Owner, b.Repo = tt.owner, tt.repo
if err := b.Validate(); err == nil {
t.Fatalf("Validate() = nil, want error for partial owner/repo pin (owner=%q repo=%q)", tt.owner, tt.repo)
}
})
}
}