initial v0.8 pre-release

forms/record_upsert_test.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 	"testing"
 
-	validation "github.com/go-ozzo/ozzo-validation/v4"
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
@@ -20,36 +19,28 @@ import (
 	"github.com/pocketbase/pocketbase/tools/list"
 )
 
-func TestRecordUpsertPanic1(t *testing.T) {
-	defer func() {
-		if recover() == nil {
-			t.Fatal("The form did not panic")
-		}
-	}()
+func hasRecordFile(app core.App, record *models.Record, filename string) bool {
+	fs, _ := app.NewFilesystem()
+	defer fs.Close()
 
-	forms.NewRecordUpsert(nil, nil)
-}
+	fileKey := filepath.Join(
+		record.Collection().Id,
+		record.Id,
+		filename,
+	)
 
-func TestRecordUpsertPanic2(t *testing.T) {
-	app, _ := tests.NewTestApp()
-	defer app.Cleanup()
+	exists, _ := fs.Exists(fileKey)
 
-	defer func() {
-		if recover() == nil {
-			t.Fatal("The form did not panic")
-		}
-	}()
-
-	forms.NewRecordUpsert(app, nil)
+	return exists
 }
 
 func TestNewRecordUpsert(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo")
+	collection, _ := app.Dao().FindCollectionByNameOrId("demo2")
 	record := models.NewRecord(collection)
-	record.SetDataValue("title", "test_value")
+	record.Set("title", "test_value")
 
 	form := forms.NewRecordUpsert(app, record)
 
@@ -59,12 +50,11 @@ func TestNewRecordUpsert(t *testing.T) {
 	}
 }
 
-func TestRecordUpsertLoadDataUnsupported(t *testing.T) {
+func TestRecordUpsertLoadRequestUnsupported(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	record, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	record, err := app.Dao().FindRecordById("demo2", "0yxhwia2amd8gec")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -75,37 +65,40 @@ func TestRecordUpsertLoadDataUnsupported(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/", strings.NewReader(testData))
 	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationForm)
 
-	if err := form.LoadData(req); err == nil {
-		t.Fatal("Expected LoadData to fail, got nil")
+	if err := form.LoadRequest(req, ""); err == nil {
+		t.Fatal("Expected LoadRequest to fail, got nil")
 	}
 }
 
-func TestRecordUpsertLoadDataJson(t *testing.T) {
+func TestRecordUpsertLoadRequestJson(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	record, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	record, err := app.Dao().FindRecordById("demo1", "84nmscqy84lsi1t")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	testData := map[string]any{
-		"id":      "test_id",
-		"title":   "test123",
-		"unknown": "test456",
-		// file fields unset/delete
-		"onefile":     nil,
-		"manyfiles.0": "",
-		"manyfiles.1": "test.png", // should be ignored
-		"onlyimages":  nil,
+		"a": map[string]any{
+			"b": map[string]any{
+				"id":      "test_id",
+				"text":    "test123",
+				"unknown": "test456",
+				// file fields unset/delete
+				"file_one":                     nil,
+				"file_many.0":                  "",         // delete by index
+				"file_many.1":                  "test.png", // should be ignored
+				"file_many.300_WlbFWSGmW9.png": nil,        // delete by filename
+			},
+		},
 	}
 
 	form := forms.NewRecordUpsert(app, record)
 	jsonBody, _ := json.Marshal(testData)
 	req := httptest.NewRequest(http.MethodGet, "/", bytes.NewReader(jsonBody))
 	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
-	loadErr := form.LoadData(req)
+	loadErr := form.LoadRequest(req, "a.b")
 	if loadErr != nil {
 		t.Fatal(loadErr)
 	}
@@ -114,7 +107,7 @@ func TestRecordUpsertLoadDataJson(t *testing.T) {
 		t.Fatalf("Expect id field to be %q, got %q", "test_id", form.Id)
 	}
 
-	if v, ok := form.Data["title"]; !ok || v != "test123" {
+	if v, ok := form.Data["text"]; !ok || v != "test123" {
 		t.Fatalf("Expect title field to be %q, got %q", "test123", v)
 	}
 
@@ -122,50 +115,43 @@ func TestRecordUpsertLoadDataJson(t *testing.T) {
 		t.Fatalf("Didn't expect unknown field to be set, got %v", v)
 	}
 
-	onefile, ok := form.Data["onefile"]
+	fileOne, ok := form.Data["file_one"]
 	if !ok {
-		t.Fatal("Expect onefile field to be set")
+		t.Fatal("Expect file_one field to be set")
 	}
-	if onefile != "" {
-		t.Fatalf("Expect onefile field to be empty string, got %v", onefile)
+	if fileOne != "" {
+		t.Fatalf("Expect file_one field to be empty string, got %v", fileOne)
 	}
 
-	manyfiles, ok := form.Data["manyfiles"]
-	if !ok || manyfiles == nil {
-		t.Fatal("Expect manyfiles field to be set")
+	fileMany, ok := form.Data["file_many"]
+	if !ok || fileMany == nil {
+		t.Fatal("Expect file_many field to be set")
 	}
-	manyfilesRemains := len(list.ToUniqueStringSlice(manyfiles))
+	manyfilesRemains := len(list.ToUniqueStringSlice(fileMany))
 	if manyfilesRemains != 1 {
-		t.Fatalf("Expect only 1 manyfiles to remain, got \n%v", manyfiles)
-	}
-
-	onlyimages := form.Data["onlyimages"]
-	if len(list.ToUniqueStringSlice(onlyimages)) != 0 {
-		t.Fatalf("Expect onlyimages field to be deleted, got \n%v", onlyimages)
+		t.Fatalf("Expect only 1 file_many to remain, got \n%v", fileMany)
 	}
 }
 
-func TestRecordUpsertLoadDataMultipart(t *testing.T) {
+func TestRecordUpsertLoadRequestMultipart(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	record, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	record, err := app.Dao().FindRecordById("demo1", "84nmscqy84lsi1t")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"id":      "test_id",
-		"title":   "test123",
-		"unknown": "test456",
+		"a.b.id":      "test_id",
+		"a.b.text":    "test123",
+		"a.b.unknown": "test456",
 		// file fields unset/delete
-		"onefile":     "",
-		"manyfiles.0": "", // delete by index
-		"manyfiles.b635c395-6837-49e5-8535-b0a6ebfbdbf3.png": "", // delete by name
-		"manyfiles.1": "test.png", // should be ignored
-		"onlyimages":  "",
-	}, "onlyimages")
+		"a.b.file_one":                     "",
+		"a.b.file_many.0":                  "",
+		"a.b.file_many.300_WlbFWSGmW9.png": "test.png", // delete by name
+		"a.b.file_many.1":                  "test.png", // should be ignored
+	}, "file_many")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -173,7 +159,7 @@ func TestRecordUpsertLoadDataMultipart(t *testing.T) {
 	form := forms.NewRecordUpsert(app, record)
 	req := httptest.NewRequest(http.MethodGet, "/", formData)
 	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	loadErr := form.LoadData(req)
+	loadErr := form.LoadRequest(req, "a.b")
 	if loadErr != nil {
 		t.Fatal(loadErr)
 	}
@@ -182,117 +168,58 @@ func TestRecordUpsertLoadDataMultipart(t *testing.T) {
 		t.Fatalf("Expect id field to be %q, got %q", "test_id", form.Id)
 	}
 
-	if v, ok := form.Data["title"]; !ok || v != "test123" {
-		t.Fatalf("Expect title field to be %q, got %q", "test123", v)
+	if v, ok := form.Data["text"]; !ok || v != "test123" {
+		t.Fatalf("Expect text field to be %q, got %q", "test123", v)
 	}
 
 	if v, ok := form.Data["unknown"]; ok {
 		t.Fatalf("Didn't expect unknown field to be set, got %v", v)
 	}
 
-	onefile, ok := form.Data["onefile"]
+	fileOne, ok := form.Data["file_one"]
 	if !ok {
-		t.Fatal("Expect onefile field to be set")
+		t.Fatal("Expect file_one field to be set")
 	}
-	if onefile != "" {
-		t.Fatalf("Expect onefile field to be empty string, got %v", onefile)
+	if fileOne != "" {
+		t.Fatalf("Expect file_one field to be empty string, got %v", fileOne)
 	}
 
-	manyfiles, ok := form.Data["manyfiles"]
-	if !ok || manyfiles == nil {
-		t.Fatal("Expect manyfiles field to be set")
+	fileMany, ok := form.Data["file_many"]
+	if !ok || fileMany == nil {
+		t.Fatal("Expect file_many field to be set")
 	}
-	manyfilesRemains := len(list.ToUniqueStringSlice(manyfiles))
-	if manyfilesRemains != 0 {
-		t.Fatalf("Expect 0 manyfiles to remain, got %v", manyfiles)
-	}
-
-	onlyimages, ok := form.Data["onlyimages"]
-	if !ok || onlyimages == nil {
-		t.Fatal("Expect onlyimages field to be set")
-	}
-	onlyimagesRemains := len(list.ToUniqueStringSlice(onlyimages))
-	expectedRemains := 1 // -2 removed + 1 new upload
-	if onlyimagesRemains != expectedRemains {
-		t.Fatalf("Expect onlyimages to be %d, got %d (%v)", expectedRemains, onlyimagesRemains, onlyimages)
+	manyfilesRemains := len(list.ToUniqueStringSlice(fileMany))
+	expectedRemains := 2 // -2 from 3 removed + 1 new upload
+	if manyfilesRemains != expectedRemains {
+		t.Fatalf("Expect file_many to be %d, got %d (%v)", expectedRemains, manyfilesRemains, fileMany)
 	}
 }
 
-func TestRecordUpsertValidateFailure(t *testing.T) {
+func TestRecordUpsertLoadData(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	record, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// try with invalid test data to check whether the RecordDataValidator is triggered
-	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"id":      "",
-		"unknown": "test456", // should be ignored
-		"title":   "a",
-		"onerel":  "00000000-84ab-4057-a592-4604a731f78f",
-	}, "manyfiles", "manyfiles")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expectedErrors := []string{"title", "onerel", "manyfiles"}
-
-	form := forms.NewRecordUpsert(app, record)
-	req := httptest.NewRequest(http.MethodGet, "/", formData)
-	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	form.LoadData(req)
-
-	result := form.Validate()
-
-	// parse errors
-	errs, ok := result.(validation.Errors)
-	if !ok && result != nil {
-		t.Fatalf("Failed to parse errors %v", result)
-	}
-
-	// check errors
-	if len(errs) > len(expectedErrors) {
-		t.Fatalf("Expected error keys %v, got %v", expectedErrors, errs)
-	}
-	for _, k := range expectedErrors {
-		if _, ok := errs[k]; !ok {
-			t.Errorf("Missing expected error key %q in %v", k, errs)
-		}
-	}
-}
-
-func TestRecordUpsertValidateSuccess(t *testing.T) {
-	app, _ := tests.NewTestApp()
-	defer app.Cleanup()
-
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	record, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"id":      record.Id,
-		"unknown": "test456", // should be ignored
-		"title":   "abc",
-		"onerel":  "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2",
-	}, "manyfiles", "onefile")
+	record, err := app.Dao().FindRecordById("demo2", "llvuca81nly1qls")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	form := forms.NewRecordUpsert(app, record)
-	req := httptest.NewRequest(http.MethodGet, "/", formData)
-	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	form.LoadData(req)
 
-	result := form.Validate()
-	if result != nil {
-		t.Fatal(result)
+	loadErr := form.LoadData(map[string]any{
+		"title":  "test_new",
+		"active": true,
+	})
+	if loadErr != nil {
+		t.Fatal(loadErr)
+	}
+
+	if v, ok := form.Data["title"]; !ok || v != "test_new" {
+		t.Fatalf("Expect title field to be %v, got %v", "test_new", v)
+	}
+
+	if v, ok := form.Data["active"]; !ok || v != true {
+		t.Fatalf("Expect active field to be %v, got %v", true, v)
 	}
 }
 
@@ -300,15 +227,15 @@ func TestRecordUpsertDrySubmitFailure(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	recordBefore, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	collection, _ := app.Dao().FindCollectionByNameOrId("demo1")
+	recordBefore, err := app.Dao().FindRecordById(collection.Id, "al1h9ijdeojtsjy")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"title":  "a",
-		"onerel": "00000000-84ab-4057-a592-4604a731f78f",
+		"title":   "abc",
+		"rel_one": "missing",
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -317,7 +244,7 @@ func TestRecordUpsertDrySubmitFailure(t *testing.T) {
 	form := forms.NewRecordUpsert(app, recordBefore)
 	req := httptest.NewRequest(http.MethodGet, "/", formData)
 	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	form.LoadData(req)
+	form.LoadRequest(req, "")
 
 	callbackCalls := 0
 
@@ -336,17 +263,17 @@ func TestRecordUpsertDrySubmitFailure(t *testing.T) {
 
 	// ensure that the record changes weren't persisted
 	// ---
-	recordAfter, err := app.Dao().FindFirstRecordByData(collection, "id", recordBefore.Id)
+	recordAfter, err := app.Dao().FindRecordById(collection.Id, recordBefore.Id)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if recordAfter.GetStringDataValue("title") == "a" {
-		t.Fatalf("Expected record.title to be %v, got %v", recordAfter.GetStringDataValue("title"), "a")
+	if recordAfter.GetString("title") == "abc" {
+		t.Fatalf("Expected record.title to be %v, got %v", recordAfter.GetString("title"), "abc")
 	}
 
-	if recordAfter.GetStringDataValue("onerel") == "00000000-84ab-4057-a592-4604a731f78f" {
-		t.Fatalf("Expected record.onerel to be %s, got %s", recordBefore.GetStringDataValue("onerel"), recordAfter.GetStringDataValue("onerel"))
+	if recordAfter.GetString("rel_one") == "missing" {
+		t.Fatalf("Expected record.rel_one to be %s, got %s", recordBefore.GetString("rel_one"), "missing")
 	}
 }
 
@@ -354,16 +281,16 @@ func TestRecordUpsertDrySubmitSuccess(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	recordBefore, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	collection, _ := app.Dao().FindCollectionByNameOrId("demo1")
+	recordBefore, err := app.Dao().FindRecordById(collection.Id, "84nmscqy84lsi1t")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"title":   "dry_test",
-		"onefile": "",
-	}, "manyfiles")
+		"title":    "dry_test",
+		"file_one": "",
+	}, "file_many")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -371,7 +298,7 @@ func TestRecordUpsertDrySubmitSuccess(t *testing.T) {
 	form := forms.NewRecordUpsert(app, recordBefore)
 	req := httptest.NewRequest(http.MethodGet, "/", formData)
 	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	form.LoadData(req)
+	form.LoadRequest(req, "")
 
 	callbackCalls := 0
 
@@ -390,21 +317,21 @@ func TestRecordUpsertDrySubmitSuccess(t *testing.T) {
 
 	// ensure that the record changes weren't persisted
 	// ---
-	recordAfter, err := app.Dao().FindFirstRecordByData(collection, "id", recordBefore.Id)
+	recordAfter, err := app.Dao().FindRecordById(collection.Id, recordBefore.Id)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if recordAfter.GetStringDataValue("title") == "dry_test" {
-		t.Fatalf("Expected record.title to be %v, got %v", recordAfter.GetStringDataValue("title"), "dry_test")
+	if recordAfter.GetString("title") == "dry_test" {
+		t.Fatalf("Expected record.title to be %v, got %v", recordAfter.GetString("title"), "dry_test")
 	}
-	if recordAfter.GetStringDataValue("onefile") == "" {
-		t.Fatal("Expected record.onefile to be set, got empty string")
+	if recordAfter.GetString("file_one") == "" {
+		t.Fatal("Expected record.file_one to not be changed, got empty string")
 	}
 
 	// file wasn't removed
-	if !hasRecordFile(app, recordAfter, recordAfter.GetStringDataValue("onefile")) {
-		t.Fatal("onefile file should not have been deleted")
+	if !hasRecordFile(app, recordAfter, recordAfter.GetString("file_one")) {
+		t.Fatal("file_one file should not have been deleted")
 	}
 }
 
@@ -412,16 +339,23 @@ func TestRecordUpsertSubmitFailure(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	recordBefore, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	collection, err := app.Dao().FindCollectionByNameOrId("demo1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	recordBefore, err := app.Dao().FindRecordById(collection.Id, "84nmscqy84lsi1t")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"title":   "a",
-		"onefile": "",
-	})
+		"text":       "abc",
+		"bool":       "false",
+		"select_one": "invalid",
+		"file_many":  "invalid",
+		"email":      "invalid",
+	}, "file_one")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -429,7 +363,7 @@ func TestRecordUpsertSubmitFailure(t *testing.T) {
 	form := forms.NewRecordUpsert(app, recordBefore)
 	req := httptest.NewRequest(http.MethodGet, "/", formData)
 	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	form.LoadData(req)
+	form.LoadRequest(req, "")
 
 	interceptorCalls := 0
 	interceptor := func(next forms.InterceptorNextFunc) forms.InterceptorNextFunc {
@@ -454,22 +388,32 @@ func TestRecordUpsertSubmitFailure(t *testing.T) {
 
 	// ensure that the record changes weren't persisted
 	// ---
-	recordAfter, err := app.Dao().FindFirstRecordByData(collection, "id", recordBefore.Id)
+	recordAfter, err := app.Dao().FindRecordById(collection.Id, recordBefore.Id)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if recordAfter.GetStringDataValue("title") == "a" {
-		t.Fatalf("Expected record.title to be %v, got %v", recordAfter.GetStringDataValue("title"), "a")
+	if v := recordAfter.Get("text"); v == "abc" {
+		t.Fatalf("Expected record.text not to change, got %v", v)
+	}
+	if v := recordAfter.Get("bool"); v == false {
+		t.Fatalf("Expected record.bool not to change, got %v", v)
+	}
+	if v := recordAfter.Get("select_one"); v == "invalid" {
+		t.Fatalf("Expected record.select_one not to change, got %v", v)
+	}
+	if v := recordAfter.Get("email"); v == "invalid" {
+		t.Fatalf("Expected record.email not to change, got %v", v)
+	}
+	if v := recordAfter.GetStringSlice("file_many"); len(v) != 3 {
+		t.Fatalf("Expected record.file_many not to change, got %v", v)
 	}
 
-	if recordAfter.GetStringDataValue("onefile") == "" {
-		t.Fatal("Expected record.onefile to be set, got empty string")
-	}
-
-	// file wasn't removed
-	if !hasRecordFile(app, recordAfter, recordAfter.GetStringDataValue("onefile")) {
-		t.Fatal("onefile file should not have been deleted")
+	// ensure the files weren't removed
+	for _, f := range recordAfter.GetStringSlice("file_many") {
+		if !hasRecordFile(app, recordAfter, f) {
+			t.Fatal("file_many file should not have been deleted")
+		}
 	}
 }
 
@@ -477,17 +421,18 @@ func TestRecordUpsertSubmitSuccess(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	recordBefore, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	collection, _ := app.Dao().FindCollectionByNameOrId("demo1")
+	recordBefore, err := app.Dao().FindRecordById(collection.Id, "84nmscqy84lsi1t")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	formData, mp, err := tests.MockMultipartData(map[string]string{
-		"title":      "test_save",
-		"onefile":    "",
-		"onlyimages": "",
-	}, "manyfiles.1", "manyfiles") // replace + new file
+		"text":       "test_save",
+		"bool":       "true",
+		"select_one": "optionA",
+		"file_one":   "",
+	}, "file_many.1", "file_many") // replace + new file
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -495,7 +440,7 @@ func TestRecordUpsertSubmitSuccess(t *testing.T) {
 	form := forms.NewRecordUpsert(app, recordBefore)
 	req := httptest.NewRequest(http.MethodGet, "/", formData)
 	req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-	form.LoadData(req)
+	form.LoadRequest(req, "")
 
 	interceptorCalls := 0
 	interceptor := func(next forms.InterceptorNextFunc) forms.InterceptorNextFunc {
@@ -518,29 +463,24 @@ func TestRecordUpsertSubmitSuccess(t *testing.T) {
 
 	// ensure that the record changes were persisted
 	// ---
-	recordAfter, err := app.Dao().FindFirstRecordByData(collection, "id", recordBefore.Id)
+	recordAfter, err := app.Dao().FindRecordById(collection.Id, recordBefore.Id)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if recordAfter.GetStringDataValue("title") != "test_save" {
-		t.Fatalf("Expected record.title to be %v, got %v", recordAfter.GetStringDataValue("title"), "test_save")
+	if v := recordAfter.GetString("text"); v != "test_save" {
+		t.Fatalf("Expected record.text to be %v, got %v", v, "test_save")
 	}
 
-	if hasRecordFile(app, recordAfter, recordAfter.GetStringDataValue("onefile")) {
-		t.Fatal("Expected record.onefile to be deleted")
+	if hasRecordFile(app, recordAfter, recordAfter.GetString("file_one")) {
+		t.Fatal("Expected record.file_one to be deleted")
 	}
 
-	onlyimages := (recordAfter.GetStringSliceDataValue("onlyimages"))
-	if len(onlyimages) != 0 {
-		t.Fatalf("Expected all onlyimages files to be deleted, got %d (%v)", len(onlyimages), onlyimages)
+	fileMany := (recordAfter.GetStringSlice("file_many"))
+	if len(fileMany) != 4 { // 1 replace + 1 new
+		t.Fatalf("Expected 4 record.file_many, got %d (%v)", len(fileMany), fileMany)
 	}
-
-	manyfiles := (recordAfter.GetStringSliceDataValue("manyfiles"))
-	if len(manyfiles) != 3 {
-		t.Fatalf("Expected 3 manyfiles, got %d (%v)", len(manyfiles), manyfiles)
-	}
-	for _, f := range manyfiles {
+	for _, f := range fileMany {
 		if !hasRecordFile(app, recordAfter, f) {
 			t.Fatalf("Expected file %q to exist", f)
 		}
@@ -551,8 +491,8 @@ func TestRecordUpsertSubmitInterceptors(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo4")
-	record, err := app.Dao().FindFirstRecordByData(collection, "id", "054f9f24-0a0a-4e09-87b1-bc7ff2b336a2")
+	collection, _ := app.Dao().FindCollectionByNameOrId("demo3")
+	record, err := app.Dao().FindRecordById(collection.Id, "mk5fmymtx4wsprk")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -574,7 +514,7 @@ func TestRecordUpsertSubmitInterceptors(t *testing.T) {
 	interceptor2Called := false
 	interceptor2 := func(next forms.InterceptorNextFunc) forms.InterceptorNextFunc {
 		return func() error {
-			interceptorRecordTitle = record.GetStringDataValue("title") // to check if the record was filled
+			interceptorRecordTitle = record.GetString("title") // to check if the record was filled
 			interceptor2Called = true
 			return testErr
 		}
@@ -598,27 +538,16 @@ func TestRecordUpsertSubmitInterceptors(t *testing.T) {
 	}
 }
 
-func hasRecordFile(app core.App, record *models.Record, filename string) bool {
-	fs, _ := app.NewFilesystem()
-	defer fs.Close()
-
-	fileKey := filepath.Join(
-		record.Collection().Id,
-		record.Id,
-		filename,
-	)
-
-	exists, _ := fs.Exists(fileKey)
-
-	return exists
-}
-
 func TestRecordUpsertWithCustomId(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
 
-	collection, _ := app.Dao().FindCollectionByNameOrId("demo3")
-	existingRecord, err := app.Dao().FindFirstRecordByData(collection, "id", "2c542824-9de1-42fe-8924-e57c86267760")
+	collection, err := app.Dao().FindCollectionByNameOrId("demo3")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	existingRecord, err := app.Dao().FindRecordById(collection.Id, "mk5fmymtx4wsprk")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -694,7 +623,7 @@ func TestRecordUpsertWithCustomId(t *testing.T) {
 		form := forms.NewRecordUpsert(app, scenario.record)
 		req := httptest.NewRequest(http.MethodGet, "/", formData)
 		req.Header.Set(echo.HeaderContentType, mp.FormDataContentType())
-		form.LoadData(req)
+		form.LoadRequest(req, "")
 
 		dryErr := form.DrySubmit(nil)
 		hasDryErr := dryErr != nil
@@ -711,10 +640,191 @@ func TestRecordUpsertWithCustomId(t *testing.T) {
 		}
 
 		if id, ok := scenario.data["id"]; ok && id != "" && !hasSubmitErr {
-			_, err := app.Dao().FindRecordById(collection, id, nil)
+			_, err := app.Dao().FindRecordById(collection.Id, id)
 			if err != nil {
 				t.Errorf("[%s] Expected to find record with id %s, got %v", scenario.name, id, err)
 			}
 		}
 	}
 }
+
+func TestRecordUpsertAuthRecord(t *testing.T) {
+	scenarios := []struct {
+		testName     string
+		existingId   string
+		data         map[string]any
+		manageAccess bool
+		expectError  bool
+	}{
+		{
+			"empty create data",
+			"",
+			map[string]any{},
+			false,
+			true,
+		},
+		{
+			"empty update data",
+			"4q1xlclmfloku33",
+			map[string]any{},
+			false,
+			false,
+		},
+		{
+			"minimum valid create data",
+			"",
+			map[string]any{
+				"password":        "12345678",
+				"passwordConfirm": "12345678",
+			},
+			false,
+			false,
+		},
+		{
+			"create with all allowed auth fields",
+			"",
+			map[string]any{
+				"username":        "test_new",
+				"email":           "test_new@example.com",
+				"emailVisibility": true,
+				"password":        "12345678",
+				"passwordConfirm": "12345678",
+			},
+			false,
+			false,
+		},
+
+		// verified
+		{
+			"try to set verified without managed access",
+			"",
+			map[string]any{
+				"verified":        true,
+				"password":        "12345678",
+				"passwordConfirm": "12345678",
+			},
+			false,
+			true,
+		},
+		{
+			"try to update verified without managed access",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"verified": true,
+			},
+			false,
+			true,
+		},
+		{
+			"set verified with managed access",
+			"",
+			map[string]any{
+				"verified":        true,
+				"password":        "12345678",
+				"passwordConfirm": "12345678",
+			},
+			true,
+			false,
+		},
+		{
+			"update verified with managed access",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"verified": true,
+			},
+			true,
+			false,
+		},
+
+		// email
+		{
+			"try to update email without managed access",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"email": "test_update@example.com",
+			},
+			false,
+			true,
+		},
+		{
+			"update email with managed access",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"email": "test_update@example.com",
+			},
+			true,
+			false,
+		},
+
+		// password
+		{
+			"try to update password without managed access",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"password":        "1234567890",
+				"passwordConfirm": "1234567890",
+			},
+			false,
+			true,
+		},
+		{
+			"update password without managed access but with oldPassword",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"oldPassword":     "1234567890",
+				"password":        "1234567890",
+				"passwordConfirm": "1234567890",
+			},
+			false,
+			false,
+		},
+		{
+			"update email with managed access (without oldPassword)",
+			"4q1xlclmfloku33",
+			map[string]any{
+				"password":        "1234567890",
+				"passwordConfirm": "1234567890",
+			},
+			true,
+			false,
+		},
+	}
+
+	for _, s := range scenarios {
+		app, _ := tests.NewTestApp()
+		defer app.Cleanup()
+
+		collection, err := app.Dao().FindCollectionByNameOrId("users")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		record := models.NewRecord(collection)
+		if s.existingId != "" {
+			var err error
+			record, err = app.Dao().FindRecordById(collection.Id, s.existingId)
+			if err != nil {
+				t.Errorf("[%s] Failed to fetch auth record with id %s", s.testName, s.existingId)
+				continue
+			}
+		}
+
+		form := forms.NewRecordUpsert(app, record)
+		form.SetFullManageAccess(s.manageAccess)
+		if err := form.LoadData(s.data); err != nil {
+			t.Errorf("[%s] Failed to load form data", s.testName)
+			continue
+		}
+
+		submitErr := form.Submit()
+
+		hasErr := submitErr != nil
+		if hasErr != s.expectError {
+			t.Errorf("[%s] Expected hasErr %v, got %v (%v)", s.testName, s.expectError, hasErr, submitErr)
+		}
+
+		if !hasErr && record.Username() == "" {
+			t.Errorf("[%s] Expected username to be set, got empty string: \n%v", s.testName, record)
+		}
+	}
+}