test(cabana): cover My account profile, password and avatar
- account_internal_test: metadata subtitle reader and writer (NULL, blank, null, [], invalid JSON, non-objects, key preservation, NULL on the last key), the attachOne contract, avatar cap, unique-violation mapping, English fallbacks, and 401 for non-backend principals on all three routes - account_test (Postgres): profile payload incl. copied WinterCMS metadata and avatar rows, trimmed profile saves and metadata keys, the forbidden-key allow-list with unchanged rows, email rules, password rules, the failed attempt log, Bearer and cookie session effects, CSRF, avatar upload, refusals (SVG, HTML as PNG, size, part shape, 413, no bucket) with no row or blob left, replace and remove with blob cleanup - lagoon: TestBackendAdminMetadataColumn covers type, Winter row round trip, rollback of only the column and re-migrate - SPA: AccountView, the user menu account item and avatar image, setCurrentUser and profileInitials; lang fixture gains myaccount keys
This commit is contained in:
246
modules/cabana/account_internal_test.go
Normal file
246
modules/cabana/account_internal_test.go
Normal file
@@ -0,0 +1,246 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon/attach"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
)
|
||||
|
||||
func strPtr(s string) *string { return &s }
|
||||
|
||||
// TestMetadataSubtitleHelpers covers the lenient reader and the
|
||||
// key-preserving writer of Winter's jsonable backend_users.metadata.
|
||||
func TestMetadataSubtitleHelpers(t *testing.T) {
|
||||
t.Run("read", func(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
raw *string
|
||||
want string
|
||||
}{
|
||||
{"nil", nil, ""},
|
||||
{"blank", strPtr(""), ""},
|
||||
{"spaces", strPtr(" "), ""},
|
||||
{"null", strPtr("null"), ""},
|
||||
{"php empty array", strPtr("[]"), ""},
|
||||
{"subtitle", strPtr(`{"subtitle":"Editor"}`), "Editor"},
|
||||
{"padded subtitle", strPtr(` {"subtitle":"Editor","x":1} `), "Editor"},
|
||||
{"number", strPtr(`{"subtitle":5}`), ""},
|
||||
{"null value", strPtr(`{"subtitle":null}`), ""},
|
||||
{"missing key", strPtr(`{"x":"y"}`), ""},
|
||||
{"invalid json", strPtr(`{"subtitle":`), ""},
|
||||
{"string", strPtr(`"text"`), ""},
|
||||
{"array", strPtr(`[1]`), ""},
|
||||
} {
|
||||
if got := metadataString(tc.raw, metadataSubtitle); got != tc.want {
|
||||
t.Errorf("%s: metadataString = %q, want %q", tc.name, got, tc.want)
|
||||
}
|
||||
if got := (BackendUser{Metadata: tc.raw}).Subtitle(); got != tc.want {
|
||||
t.Errorf("%s: Subtitle = %q, want %q", tc.name, got, tc.want)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("write onto empty metadata", func(t *testing.T) {
|
||||
for _, raw := range []*string{nil, strPtr(""), strPtr("null"), strPtr("[]")} {
|
||||
got, err := setMetadataString(raw, metadataSubtitle, "Editor")
|
||||
if err != nil || got == nil || *got != `{"subtitle":"Editor"}` {
|
||||
t.Fatalf("set on %v = %v, %v", raw, got, err)
|
||||
}
|
||||
cleared, err := setMetadataString(raw, metadataSubtitle, "")
|
||||
if err != nil || cleared != nil {
|
||||
t.Fatalf("clear on %v = %v, %v", raw, cleared, err)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("write keeps other keys byte-equal", func(t *testing.T) {
|
||||
raw := strPtr(`{"subtitle":"a","x":{"y":[1,2]}}`)
|
||||
got, err := setMetadataString(raw, metadataSubtitle, "b")
|
||||
if err != nil || got == nil {
|
||||
t.Fatalf("set = %v, %v", got, err)
|
||||
}
|
||||
var decoded map[string]json.RawMessage
|
||||
if err := json.Unmarshal([]byte(*got), &decoded); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(decoded["x"]) != `{"y":[1,2]}` || string(decoded["subtitle"]) != `"b"` {
|
||||
t.Fatalf("metadata = %s", *got)
|
||||
}
|
||||
cleared, err := setMetadataString(got, metadataSubtitle, "")
|
||||
if err != nil || cleared == nil || *cleared != `{"x":{"y":[1,2]}}` {
|
||||
t.Fatalf("clear = %v, %v", cleared, err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("clearing the last key is NULL", func(t *testing.T) {
|
||||
got, err := setMetadataString(strPtr(`{"subtitle":"Editor"}`), metadataSubtitle, "")
|
||||
if err != nil || got != nil {
|
||||
t.Fatalf("clear = %v, %v", got, err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("text that is not an object is never overwritten", func(t *testing.T) {
|
||||
for _, raw := range []string{`{"subtitle":`, `"text"`, `[1]`, `5`} {
|
||||
got, err := setMetadataString(strPtr(raw), metadataSubtitle, "Editor")
|
||||
if !errors.Is(err, errMetadataNotObject) || got != nil {
|
||||
t.Fatalf("set on %q = %v, %v", raw, got, err)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("values are JSON-escaped", func(t *testing.T) {
|
||||
got, err := setMetadataString(nil, metadataSubtitle, `Quote " and \ back`)
|
||||
if err != nil || got == nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if back := metadataString(got, metadataSubtitle); back != `Quote " and \ back` {
|
||||
t.Fatalf("round trip = %q", back)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// TestBackendUserAttachContract pins the WinterCMS morph name and the avatar
|
||||
// attachOne, the account helpers that need no database, and the
|
||||
// unique-violation mapping.
|
||||
func TestBackendUserAttachContract(t *testing.T) {
|
||||
var owner attach.Owner = BackendUser{}
|
||||
if owner.MorphName() != `Backend\Models\User` || BackendUserMorphType != `Backend\Models\User` {
|
||||
t.Fatalf("MorphName = %q", owner.MorphName())
|
||||
}
|
||||
var declared attach.HasRelations = BackendUser{}
|
||||
rels := declared.AttachRelations()
|
||||
if len(rels) != 1 || rels[0] != (attach.Relation{Name: "avatar", Many: false, Public: true}) || BackendUserAvatarField != "avatar" {
|
||||
t.Fatalf("AttachRelations = %#v", rels)
|
||||
}
|
||||
if AvatarMaxBytes != 2<<20 {
|
||||
t.Fatalf("AvatarMaxBytes = %d", AvatarMaxBytes)
|
||||
}
|
||||
|
||||
t.Run("avatar cap", func(t *testing.T) {
|
||||
if got := (&service{}).avatarCap(); got != AvatarMaxBytes+multipartOverhead {
|
||||
t.Fatalf("uncapped = %d", got)
|
||||
}
|
||||
if got := (&service{uploadBytes: 1 << 20}).avatarCap(); got != 1<<20 {
|
||||
t.Fatalf("upload_bytes 1 MiB = %d", got)
|
||||
}
|
||||
if got := (&service{uploadBytes: 64 << 20}).avatarCap(); got != AvatarMaxBytes+multipartOverhead {
|
||||
t.Fatalf("upload_bytes 64 MiB = %d", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unique violation mapping", func(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
err error
|
||||
want bool
|
||||
}{
|
||||
{&pgconn.PgError{Code: "23505", ConstraintName: "backend_users_email_lower_unique"}, true},
|
||||
{fmt.Errorf("wrapped: %w", &pgconn.PgError{Code: "23505", ConstraintName: "backend_users_email_key"}), true},
|
||||
{&pgconn.PgError{Code: "23505", ConstraintName: "backend_users_login_key"}, false},
|
||||
{&pgconn.PgError{Code: "23503", ConstraintName: "backend_users_email_lower_unique"}, false},
|
||||
{errors.New("23505 backend_users_email_lower_unique"), false},
|
||||
} {
|
||||
if got := emailConflict(tc.err); got != tc.want {
|
||||
t.Errorf("emailConflict(%v) = %v, want %v", tc.err, got, tc.want)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("messages fall back to English without a translator", func(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
if got := backendMessage(ctx, nil, "myaccount.current_password_invalid", "fallback"); got != "fallback" {
|
||||
t.Fatalf("backendMessage = %q", got)
|
||||
}
|
||||
for rule, want := range map[string]string{
|
||||
"confirmed": "The password confirmation does not match.",
|
||||
"unique": "The password has already been taken.",
|
||||
"max.string": "The password may not be greater than 72 characters.",
|
||||
"required": "The password field is required.",
|
||||
} {
|
||||
if got := accountMessage(ctx, nil, rule, "password", map[string]string{"max": "72"}); got != want {
|
||||
t.Errorf("accountMessage(%s) = %q, want %q", rule, got, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("details follow the rule order", func(t *testing.T) {
|
||||
details := accountDetails(map[string][]string{"password": {"b"}, "email": {"a"}})
|
||||
if len(details) != 2 || details["email"].([]string)[0] != "a" || details["password"].([]string)[0] != "b" {
|
||||
t.Fatalf("details = %#v", details)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("refused keys", func(t *testing.T) {
|
||||
details := refusedAccountKeys(context.Background(), nil, map[string]any{"email": "x", "login": "y", "role_id": 1})
|
||||
if len(details) != 2 || details["login"] == nil || details["role_id"] == nil {
|
||||
t.Fatalf("details = %#v", details)
|
||||
}
|
||||
if refusedAccountKeys(context.Background(), nil, map[string]any{"email": "x", "subtitle": nil}) != nil {
|
||||
t.Fatal("allowed keys were refused")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// TestAccountRoutesRefuseNonBackendPrincipals calls the three My account
|
||||
// handlers without the guard: no principal, a frontend principal and a
|
||||
// zero id all answer 401 before any body is read or any query runs.
|
||||
func TestAccountRoutesRefuseNonBackendPrincipals(t *testing.T) {
|
||||
svc := &service{}
|
||||
handlers := map[string]http.HandlerFunc{
|
||||
"account update": svc.accountUpdate,
|
||||
"avatar upload": svc.avatarUpload,
|
||||
"avatar remove": svc.avatarRemove,
|
||||
}
|
||||
principals := map[string]*bouncer.Principal{
|
||||
"none": nil,
|
||||
"frontend": {ID: 4, Backend: false},
|
||||
"zero id": {ID: 0, Backend: true},
|
||||
}
|
||||
for name, handler := range handlers {
|
||||
for kind, principal := range principals {
|
||||
t.Run(name+" "+kind, func(t *testing.T) {
|
||||
spy := &readSpy{r: strings.NewReader(`{"email":"x@example.test"}`)}
|
||||
req := httptest.NewRequest(http.MethodPut, adminAPI("/account"), spy)
|
||||
if principal != nil {
|
||||
req = req.WithContext(bouncer.WithUser(req.Context(), principal))
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
handler(rec, req)
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "unauthenticated")
|
||||
if spy.reads != 0 {
|
||||
t.Fatalf("body read %d times", spy.reads)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("backend principal without a database", func(t *testing.T) {
|
||||
super := &bouncer.Principal{ID: 1, Backend: true}
|
||||
for name, handler := range handlers {
|
||||
req := httptest.NewRequest(http.MethodPut, adminAPI("/account"), strings.NewReader(`{"email":"admin@example.test"}`))
|
||||
req = req.WithContext(bouncer.WithUser(req.Context(), super))
|
||||
rec := httptest.NewRecorder()
|
||||
handler(rec, req)
|
||||
if rec.Code != http.StatusInternalServerError {
|
||||
t.Fatalf("%s status=%d body=%s", name, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("avatar lookup without a database", func(t *testing.T) {
|
||||
if f, err := BackendUserAvatar(context.Background(), nil, 1); f != nil || err == nil {
|
||||
t.Fatalf("lookup = %v, %v", f, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -509,3 +509,97 @@ func TestBackendAdminEmailIndexRefusesCaseDuplicates(t *testing.T) {
|
||||
t.Fatal("unique lower(email) index missing")
|
||||
}
|
||||
}
|
||||
|
||||
// TestBackendAdminMetadataColumn covers 202610090001_backend_users_metadata:
|
||||
// WinterCMS's nullable jsonable metadata column, added last, round-tripping a
|
||||
// Winter-shaped row, and a rollback that drops only that column.
|
||||
func TestBackendAdminMetadataColumn(t *testing.T) {
|
||||
db, _ := dedicatedDB(t, "lagoon_admin_metadata")
|
||||
gdb, err := Use(t.Context(), db)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Migrate(gdb, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
columnType := func() (string, string, bool) {
|
||||
var cols []struct {
|
||||
DataType string
|
||||
Nullable string
|
||||
}
|
||||
if err := gdb.Raw(`SELECT data_type, is_nullable AS nullable FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'backend_users' AND column_name = 'metadata'`).Scan(&cols).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(cols) == 0 {
|
||||
return "", "", false
|
||||
}
|
||||
return cols[0].DataType, cols[0].Nullable, true
|
||||
}
|
||||
if typ, nullable, ok := columnType(); !ok || typ != "text" || nullable != "YES" {
|
||||
t.Fatalf("metadata column type=%q nullable=%q present=%v", typ, nullable, ok)
|
||||
}
|
||||
if err := gdb.Exec(`INSERT INTO backend_users (first_name, last_name, login, email, password, permissions, metadata, is_activated, is_superuser, created_at, updated_at)
|
||||
VALUES ('Ada', 'Lovelace', 'ada', 'ada@example.test', 'winter-hash', '{}', '{"subtitle":"Editor","x":1}', TRUE, FALSE, NOW(), NOW())`).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var stored *string
|
||||
if err := gdb.Raw(`SELECT metadata FROM backend_users WHERE login = 'ada'`).Scan(&stored).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stored == nil || *stored != `{"subtitle":"Editor","x":1}` {
|
||||
t.Fatalf("metadata = %v", stored)
|
||||
}
|
||||
|
||||
history, err := HistoryTableName("summercms.cabana")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var ids []string
|
||||
if err := gdb.Table(history).Order("id").Pluck("id", &ids).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(ids) == 0 || ids[len(ids)-1] != "202610090001_backend_users_metadata" {
|
||||
t.Fatalf("cabana history = %v", ids)
|
||||
}
|
||||
if last := BackendAdminMigrations[len(BackendAdminMigrations)-1].ID; last != "202610090001_backend_users_metadata" {
|
||||
t.Fatalf("last BackendAdminMigrations entry = %s", last)
|
||||
}
|
||||
|
||||
m, err := migrator(gdb, "summercms.cabana", BackendAdminMigrations)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := m.RollbackLast(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, _, ok := columnType(); ok {
|
||||
t.Fatal("metadata survived its rollback")
|
||||
}
|
||||
var rows []struct {
|
||||
Login string
|
||||
Email string
|
||||
}
|
||||
if err := gdb.Raw(`SELECT login, email FROM backend_users`).Scan(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 1 || rows[0].Login != "ada" || rows[0].Email != "ada@example.test" {
|
||||
t.Fatalf("rows after rollback = %+v", rows)
|
||||
}
|
||||
if !indexOn(indexDefs(t, gdb, "backend_users"), "lower(email)") {
|
||||
t.Fatal("rolling back metadata dropped the email index")
|
||||
}
|
||||
|
||||
if err := Migrate(gdb, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if typ, _, ok := columnType(); !ok || typ != "text" {
|
||||
t.Fatalf("metadata was not added back: %q %v", typ, ok)
|
||||
}
|
||||
var restored *string
|
||||
if err := gdb.Raw(`SELECT metadata FROM backend_users WHERE login = 'ada'`).Scan(&restored).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if restored != nil {
|
||||
t.Fatalf("re-added metadata = %q, want NULL", *restored)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user