RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
fix(dataset): sync folder rename in same transaction to prevent binding loss (#22021)
ZZZZYfa813113e105
diff --git a/internal/service/dataset/rename_folder_test.go b/internal/service/dataset/rename_folder_test.gonew file mode 100644index 0000000000..c85b7c72b6--- /dev/null+++ b/internal/service/dataset/rename_folder_test.go@@ -0,0 +1,316 @@+package dataset++import (+ "bytes"+ "mime/multipart"+ "net/http/httptest"+ "testing"++ "ragflow/internal/common"+ "ragflow/internal/dao"+ "ragflow/internal/entity"+ "ragflow/internal/service"+ "ragflow/internal/service/document"+ filesvc "ragflow/internal/service/file"+ "ragflow/internal/storage"+)++func insertRenameTestFolder(t *testing.T, id, parentID, tenantID, name, source string) {+ t.Helper()+ if err := dao.DB.Create(&entity.File{+ ID: id, ParentID: parentID, TenantID: tenantID, CreatedBy: tenantID,+ Name: name, Type: "folder", SourceType: source,+ }).Error; err != nil {+ t.Fatal(err)+ }+}++func TestDatasetRenameFolder(t *testing.T) {+ for _, tc := range []struct {+ name string+ root bool+ kbRoot bool+ original bool+ target bool+ targetScope string+ targetType string+ originalType string+ kbRootType string+ newName string+ wantCode common.ErrorCode+ }{+ {name: "rename existing folder", root: true, kbRoot: true, original: true, newName: "Renamed"},+ {name: "case only rename", root: true, kbRoot: true, original: true, newName: "ORIGINAL"},+ {name: "same name", root: true, kbRoot: true, original: true, newName: "Original"},+ {name: "target occupied", root: true, kbRoot: true, original: true, target: true, newName: "Renamed", wantCode: common.CodeDataError},+ {name: "target occupied without original", root: true, kbRoot: true, target: true, newName: "Renamed", wantCode: common.CodeDataError},+ {name: "target occupied by virtual file", root: true, kbRoot: true, original: true, target: true, targetType: "virtual", newName: "Renamed", wantCode: common.CodeDataError},+ {name: "virtual file collision without original", root: true, kbRoot: true, target: true, targetType: "virtual", newName: "Renamed", wantCode: common.CodeDataError},+ {name: "virtual file collision ignores case", root: true, kbRoot: true, original: true, target: true, targetType: "virtual", newName: "RENAMED", wantCode: common.CodeDataError},+ {name: "no original folder", root: true, kbRoot: true, newName: "Renamed"},+ {name: "no knowledgebase root", root: true, newName: "Renamed"},+ {name: "no root", newName: "Renamed"},+ {name: "original name is a virtual file", root: true, kbRoot: true, original: true, originalType: "virtual", newName: "Renamed", wantCode: common.CodeDataError},+ {name: "knowledgebase root is a virtual file", root: true, kbRoot: true, kbRootType: "virtual", newName: "Renamed", wantCode: common.CodeDataError},+ {name: "same name in another tenant", root: true, kbRoot: true, original: true, target: true, targetScope: "tenant", newName: "Renamed"},+ {name: "same name under another parent", root: true, kbRoot: true, original: true, target: true, targetScope: "parent", newName: "Renamed"},+ } {+ t.Run(tc.name, func(t *testing.T) {+ db := setupDatasetUpdateTestDB(t)+ pushServiceDB(t, db)+ insertDatasetUpdateKB(t, "kb-1", "tenant-1", "Original")+ if tc.root {+ insertRenameTestFolder(t, "root", "root", "tenant-1", "/", "")+ }+ if tc.kbRoot {+ insertRenameTestFolder(t, "kb-root", "root", "tenant-1", ".knowledgebase", "knowledgebase")+ }+ if tc.original {+ insertRenameTestFolder(t, "original", "kb-root", "tenant-1", "Original", "knowledgebase")+ // Matching names outside the owned folder must remain untouched.+ insertRenameTestFolder(t, "unrelated-original", "root", "tenant-1", "Original", "knowledgebase")+ }+ for id, fileType := range map[string]string{"original": tc.originalType, "kb-root": tc.kbRootType} {+ if fileType != "" {+ if err := db.Model(&entity.File{}).Where("id = ?", id).Update("type", fileType).Error; err != nil {+ t.Fatal(err)+ }+ }+ }+ if tc.target {+ parentID, tenantID := "kb-root", "tenant-1"+ if tc.targetScope == "tenant" {+ tenantID = "tenant-2"+ }+ if tc.targetScope == "parent" {+ parentID = "root"+ }+ if tc.targetType == "virtual" {+ ctx := withDatasetTestContext(t.Context(), "tenant-1", tenantID)+ if _, err := filesvc.NewFileService(nil).CreateFolder(ctx, "Renamed", parentID, "virtual"); err != nil {+ t.Fatalf("create virtual file: %v", err)+ }+ } else {+ insertRenameTestFolder(t, "target", parentID, tenantID, "Renamed", "")+ }+ }+ var before int64+ if err := db.Model(&entity.File{}).Count(&before).Error; err != nil {+ t.Fatal(err)+ }+ ctx := withDatasetTestContext(t.Context(), "tenant-1", "tenant-1")+ _, code, err := testDatasetUpdateService(t).UpdateDataset(ctx, "kb-1", service.UpdateDatasetRequest{Name: &tc.newName})+ if code != tc.wantCode || (err != nil) != (tc.wantCode != common.CodeSuccess) {+ t.Fatalf("rename: code=%v err=%v; want code=%v", code, err, tc.wantCode)+ }+ wantName := tc.newName+ if tc.wantCode != common.CodeSuccess {+ wantName = "Original"+ }+ kb, err := dao.NewKnowledgebaseDAO().GetByID(ctx, db, "kb-1")+ if err != nil || kb.Name != wantName {+ t.Fatalf("knowledgebase=%+v err=%v; want name %s", kb, err, wantName)+ }+ if tc.original {+ var folder entity.File+ if err := db.Where("id = ?", "original").Take(&folder).Error; err != nil || folder.Name != wantName || folder.ParentID != "kb-root" {+ t.Fatalf("folder=%+v err=%v; want name %s with unchanged id and parent", folder, err, wantName)+ }+ folder = entity.File{}+ if err := db.Where("id = ?", "unrelated-original").Take(&folder).Error; err != nil || folder.Name != "Original" {+ t.Fatalf("unrelated folder changed: %+v err=%v", folder, err)+ }+ }+ var after int64+ if err := db.Model(&entity.File{}).Count(&after).Error; err != nil || after != before {+ t.Fatalf("rename created/deleted files: before=%d after=%d err=%v", before, after, err)+ }+ })+ }+}++func TestDatasetRenameFolderRollsBack(t *testing.T) {+ for _, table := range []string{"knowledgebase", "file"} {+ t.Run(table+" update fails", func(t *testing.T) {+ db := setupDatasetUpdateTestDB(t)+ pushServiceDB(t, db)+ insertDatasetUpdateKB(t, "kb-1", "tenant-1", "Original")+ insertRenameTestFolder(t, "root", "root", "tenant-1", "/", "")+ insertRenameTestFolder(t, "kb-root", "root", "tenant-1", ".knowledgebase", "knowledgebase")+ insertRenameTestFolder(t, "original", "kb-root", "tenant-1", "Original", "knowledgebase")+ if err := db.Exec("CREATE TRIGGER reject_rename BEFORE UPDATE OF name ON " + table + " WHEN NEW.name = 'Renamed' BEGIN SELECT RAISE(ABORT, 'rename rejected'); END").Error; err != nil {+ t.Fatal(err)+ }+ name := "Renamed"+ ctx := withDatasetTestContext(t.Context(), "tenant-1", "tenant-1")+ _, code, err := testDatasetUpdateService(t).UpdateDataset(ctx, "kb-1", service.UpdateDatasetRequest{Name: &name})+ if err == nil || code != common.CodeServerError {+ t.Fatalf("rename: code=%v err=%v; want server error", code, err)+ }+ if table == "file" && err.Error() != "database operation failed" {+ t.Fatalf("unexpected public database error: %v", err)+ }+ kb, err := dao.NewKnowledgebaseDAO().GetByID(ctx, db, "kb-1")+ if err != nil || kb.Name != "Original" {+ t.Fatalf("knowledgebase did not roll back: %+v err=%v", kb, err)+ }+ var folder entity.File+ if err := db.Where("id = ?", "original").Take(&folder).Error; err != nil || folder.Name != "Original" {+ t.Fatalf("folder did not roll back: %+v err=%v", folder, err)+ }+ })+ }+}++func TestDatasetRenameFolderSurvivesDeletingReusedName(t *testing.T) {+ for _, tc := range []struct {+ name string+ manualRoot bool+ manualDataset bool+ }{+ {name: "managed folders"},+ {name: "user created dataset folder", manualDataset: true},+ {name: "user created knowledgebase root", manualRoot: true},+ {name: "both user created", manualRoot: true, manualDataset: true},+ } {+ t.Run(tc.name, func(t *testing.T) {+ db := setupDatasetUpdateTestDB(t)+ pushServiceDB(t, db)+ insertCreateDatasetTenant(t, "tenant-1")+ ctx := withDatasetTestContext(t.Context(), "tenant-1", "tenant-1")+ factory := storage.GetStorageFactory()+ previous := factory.GetStorage()+ store := storage.NewMemoryStorage()+ factory.SetStorage(store)+ t.Cleanup(func() { factory.SetStorage(previous) })+ datasets := testDatasetCreateService(t)+ documents := document.NewDocumentService()+ var manualFolderID, kbRootID string+ if tc.manualRoot || tc.manualDataset {+ root, err := dao.NewFileDAO().GetRootFolder(ctx, db, "tenant-1")+ if err != nil {+ t.Fatal(err)+ }+ if tc.manualRoot {+ created, err := filesvc.NewFileService(nil).CreateFolder(ctx, ".knowledgebase", root.ID, "folder")+ if err != nil {+ t.Fatal(err)+ }+ kbRootID = created["id"].(string)+ } else {+ kbRootID = "kb-root"+ insertRenameTestFolder(t, kbRootID, root.ID, "tenant-1", ".knowledgebase", "knowledgebase")+ }+ if tc.manualDataset {+ created, err := filesvc.NewFileService(nil).CreateFolder(ctx, "Original", kbRootID, "folder")+ if err != nil {+ t.Fatal(err)+ }+ manualFolderID = created["id"].(string)+ }+ }+ create := func(name string) *entity.Knowledgebase {+ t.Helper()+ result, code, err := datasets.CreateDataset(ctx, &service.CreateDatasetRequest{Name: name, ParserID: sptr("general"), ParseType: iptr(1)})+ if err != nil || code != common.CodeSuccess {+ t.Fatalf("create %s: code=%v err=%v", name, code, err)+ }+ kb, err := dao.NewKnowledgebaseDAO().GetByID(ctx, db, result["id"].(string))+ if err != nil {+ t.Fatal(err)+ }+ return kb+ }+ upload := func(kb *entity.Knowledgebase, name string) (string, entity.File) {+ t.Helper()+ var body bytes.Buffer+ writer := multipart.NewWriter(&body)+ part, err := writer.CreateFormFile("file", name)+ if err != nil {+ t.Fatal(err)+ }+ if _, err = part.Write([]byte("content for " + name)); err != nil {+ t.Fatal(err)+ }+ if err = writer.Close(); err != nil {+ t.Fatal(err)+ }+ req := httptest.NewRequest("POST", "/", &body)+ req.Header.Set("Content-Type", writer.FormDataContentType())+ if err = req.ParseMultipartForm(1 << 20); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { _ = req.MultipartForm.RemoveAll() })+ results, errs := documents.UploadLocalDocuments(ctx, kb, req.MultipartForm.File["file"], "", nil)+ if len(errs) != 0 || len(results) != 1 {+ t.Fatalf("upload %s: results=%v errors=%v", name, results, errs)+ }+ id := results[0]["id"].(string)+ var file entity.File+ if err = db.Table("file").Select("file.*").Joins("JOIN file2document ON file2document.file_id = file.id").Where("file2document.document_id = ?", id).Take(&file).Error; err != nil {+ t.Fatal(err)+ }+ return id, file+ }+ a := create("Original")+ oldDoc, oldFile := upload(a, "a-old.txt")+ if tc.manualDataset && oldFile.ParentID != manualFolderID {+ t.Fatal("upload did not reuse user-created dataset folder")+ }+ name := "Renamed"+ if _, code, err := datasets.UpdateDataset(ctx, a.ID, service.UpdateDatasetRequest{Name: &name}); err != nil || code != common.CodeSuccess {+ t.Fatalf("rename: code=%v err=%v", code, err)+ }+ var err error+ a, err = dao.NewKnowledgebaseDAO().GetByID(ctx, db, a.ID)+ if err != nil {+ t.Fatal(err)+ }+ newDoc, newFile := upload(a, "a-new.txt")+ if newFile.ParentID != oldFile.ParentID {+ t.Fatalf("A upload changed folders after rename: old=%s new=%s", oldFile.ParentID, newFile.ParentID)+ }+ b := create("Original")+ bDoc, bFile := upload(b, "b.txt")+ if bFile.ParentID == oldFile.ParentID {+ t.Fatal("B reused A's folder")+ }+ if _, code, err := datasets.DeleteDatasets(ctx, []string{b.ID}, false); err != nil || code != common.CodeSuccess {+ t.Fatalf("delete B: code=%v err=%v", code, err)+ }+ var folder entity.File+ if err := db.Where("id = ?", oldFile.ParentID).Take(&folder).Error; err != nil || folder.Name != "Renamed" {+ t.Fatalf("A folder missing or incorrectly named: %+v err=%v", folder, err)+ }+ if tc.manualDataset && folder.SourceType != "" {+ t.Fatalf("rename changed folder source: %q", folder.SourceType)+ }+ if kbRootID != "" && folder.ParentID != kbRootID {+ t.Fatal("upload did not reuse the expected knowledgebase root")+ }+ for _, check := range []struct {+ model interface{}+ id string+ want int64+ }{+ {&entity.Knowledgebase{}, a.ID, 1}, {&entity.Document{}, oldDoc, 1}, {&entity.Document{}, newDoc, 1},+ {&entity.File{}, oldFile.ID, 1}, {&entity.File{}, newFile.ID, 1},+ {&entity.Knowledgebase{}, b.ID, 0}, {&entity.Document{}, bDoc, 0}, {&entity.File{}, bFile.ID, 0}, {&entity.File{}, bFile.ParentID, 0},+ } {+ var count int64+ if err := db.Model(check.model).Where("id = ?", check.id).Count(&count).Error; err != nil || count != check.want {+ t.Fatalf("%T id=%s: count=%d want=%d err=%v", check.model, check.id, count, check.want, err)+ }+ }+ for _, name := range []string{"a-old.txt", "a-new.txt"} {+ blob, err := store.Get(ctx, a.ID, name)+ if err != nil || string(blob) != "content for "+name {+ t.Fatalf("A content changed: name=%s blob=%q err=%v", name, blob, err)+ }+ }+ if store.BucketExists(ctx, b.ID) {+ t.Fatal("B storage bucket survived deletion")+ }+ })+ }+}diff --git a/internal/service/dataset/update.go b/internal/service/dataset/update.goindex 4219919aa4..c12e893c83 100644--- a/internal/service/dataset/update.go+++ b/internal/service/dataset/update.go@@ -253,6 +253,18 @@ func (d *DatasetService) UpdateDataset(ctx context.Context, datasetID string, retxCode = common.CodeDataErrorreturn fmt.Errorf("Dataset name '%s' already exists", nameValue)}+ if nameValue != lockedKB.Name {+ code, renameErr := renameDatasetFolder(ctx, tx, lockedKB, nameValue)+ if renameErr != nil {+ txCode = code+ if code == common.CodeServerError {+ common.Warn("dataset folder rename failed",+ zap.String("dataset_id", lockedKB.ID), zap.Error(renameErr))+ return errors.New("database operation failed")+ }+ return renameErr+ }+ }}if pipelineID != nil {@@ -507,6 +519,67 @@ func (d *DatasetService) UpdateDataset(ctx context.Context, datasetID string, rereturn data, common.CodeSuccess, nil}+// renameDatasetFolder updates an existing dataset folder in the caller's+// transaction. Datasets without a folder do not create one during a rename.+func renameDatasetFolder(ctx context.Context, tx *gorm.DB, kb *entity.Knowledgebase, newName string) (common.ErrorCode, error) {+ var root entity.File+ err := tx.WithContext(ctx).+ Where("tenant_id = ? AND parent_id = id AND type = ?", kb.TenantID, "folder").+ Take(&root).Error+ if dao.IsNotFoundErr(err) {+ return common.CodeSuccess, nil+ }+ if err != nil {+ return common.CodeServerError, err+ }++ var kbRoot entity.File+ err = tx.WithContext(ctx).+ Where("tenant_id = ? AND parent_id = ? AND name = ?",+ kb.TenantID, root.ID, dao.DatasetFolderName).+ Take(&kbRoot).Error+ if dao.IsNotFoundErr(err) {+ return common.CodeSuccess, nil+ }+ if err != nil {+ return common.CodeServerError, err+ }+ if kbRoot.Type != "folder" {+ return common.CodeDataError, errors.New("Knowledgebase root is not a folder")+ }+ fileDAO := dao.NewFileDAO()++ entries := func() *gorm.DB {+ return tx.WithContext(ctx).Model(&entity.File{}).+ Where("tenant_id = ? AND parent_id = ?", kb.TenantID, kbRoot.ID)+ }+ var original entity.File+ // Uploads reuse entries by tenant, parent and name, regardless of source.+ err = entries().Where("name = ?", kb.Name).+ Take(&original).Error+ if err != nil && !dao.IsNotFoundErr(err) {+ return common.CodeServerError, err+ }+ if original.ID != "" && original.Type != "folder" {+ return common.CodeDataError, errors.New("Dataset path is not a folder")+ }++ exists, err := fileDAO.NameExists(ctx, tx, newName, kbRoot.ID, kb.TenantID, original.ID)+ if err != nil {+ return common.CodeServerError, err+ }+ if exists {+ return common.CodeDataError, fmt.Errorf("Dataset folder name '%s' already exists", newName)+ }+ if original.ID == "" {+ return common.CodeSuccess, nil+ }+ if err = entries().Where("id = ? AND type = ?", original.ID, "folder").Update("name", newName).Error; err != nil {+ return common.CodeServerError, err+ }+ return common.CodeSuccess, nil+}+func (d *DatasetService) updateDatasetPagerankChunks(ctx context.Context, update datasetPagerankUpdate) error {newCtx, cancel := context.WithTimeout(ctx, datasetPagerankUpdateTimeout)defer cancel()diff --git a/internal/service/document/document_upload.go b/internal/service/document/document_upload.goindex 2beda0a4bf..f1ca2a6e1c 100644--- a/internal/service/document/document_upload.go+++ b/internal/service/document/document_upload.go@@ -15,6 +15,9 @@ import ("ragflow/internal/storage""ragflow/internal/utility""strings"++ "gorm.io/gorm"+ "gorm.io/gorm/clause")// UploadLocalDocuments stores each uploaded file in object storage and inserts a@@ -168,21 +171,32 @@ func (s *DocumentService) UploadEmptyDocument(ctx context.Context, kb *entity.Kn// folder: root -> .knowledgebase -> <dataset name>. Mirrors Python// get_root_folder + get_kb_folder + new_a_file_from_kb.func (s *DocumentService) ensureKBFolder(ctx context.Context, kb *entity.Knowledgebase, tenantID string) (*entity.File, error) {- root, err := s.fileDAO.GetRootFolder(ctx, dao.DB, tenantID)- if err != nil {- return nil, err- }- kbRoot, err := s.newAFileFromKB(ctx, tenantID, knowledgebaseFolderName, root.ID)- if err != nil {- return nil, err- }- return s.newAFileFromKB(ctx, kb.TenantID, kb.Name, kbRoot.ID)+ var kbFolder *entity.File+ err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ // Use the same lock order as dataset rename and refresh the caller's stale name.+ var current entity.Knowledgebase+ if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).+ Where("id = ? AND tenant_id = ?", kb.ID, kb.TenantID).Take(¤t).Error; err != nil {+ return err+ }+ root, err := s.fileDAO.GetRootFolder(ctx, tx, tenantID)+ if err != nil {+ return err+ }+ kbRoot, err := s.newAFileFromKB(ctx, tx, tenantID, knowledgebaseFolderName, root.ID)+ if err != nil {+ return err+ }+ kbFolder, err = s.newAFileFromKB(ctx, tx, current.TenantID, current.Name, kbRoot.ID)+ return err+ })+ return kbFolder, err}// newAFileFromKB returns the existing folder named name under parentID, or// creates it. Mirrors Python FileService.new_a_file_from_kb.-func (s *DocumentService) newAFileFromKB(ctx context.Context, tenantID, name, parentID string) (*entity.File, error) {- existingFolders, err := s.fileDAO.Query(ctx, dao.DB, name, parentID, tenantID)+func (s *DocumentService) newAFileFromKB(ctx context.Context, db *gorm.DB, tenantID, name, parentID string) (*entity.File, error) {+ existingFolders, err := s.fileDAO.Query(ctx, db, name, parentID, tenantID)if err != nil {return nil, err}@@ -204,7 +218,7 @@ func (s *DocumentService) newAFileFromKB(ctx context.Context, tenantID, name, paLocation: &loc,SourceType: string(entity.FileSourceKnowledgebase),}- if err := s.fileDAO.Create(ctx, dao.DB, folder); err != nil {+ if err := s.fileDAO.Create(ctx, db, folder); err != nil {return nil, err}return folder, nildiff --git a/internal/service/document/document_upload_folder_test.go b/internal/service/document/document_upload_folder_test.gonew file mode 100644index 0000000000..4efdf22775--- /dev/null+++ b/internal/service/document/document_upload_folder_test.go@@ -0,0 +1,65 @@+package document++import (+ "testing"++ "ragflow/internal/entity"+)++func TestEnsureKBFolderUsesCurrentName(t *testing.T) {+ for _, existing := range []bool{false, true} {+ name := "create"+ if existing {+ name = "reuse"+ }+ t.Run(name, func(t *testing.T) {+ db := setupServiceTestDB(t)+ pushServiceDB(t, db)+ insertTestKB(t, "kb-upload", "tenant-1", 0, 0, 0)+ if err := db.Model(&entity.Knowledgebase{}).Where("id = ?", "kb-upload").Update("name", "Renamed").Error; err != nil {+ t.Fatal(err)+ }+ svc := testDocumentService(t)+ stale := &entity.Knowledgebase{ID: "kb-upload", TenantID: "tenant-1", Name: "Original"}+ var originalID string+ if existing {+ folder, err := svc.ensureKBFolder(t.Context(), stale, "tenant-1")+ if err != nil {+ t.Fatal(err)+ }+ originalID = folder.ID+ }+ folder, err := svc.ensureKBFolder(t.Context(), stale, "tenant-1")+ if err != nil {+ t.Fatal(err)+ }+ if folder.Name != "Renamed" || (existing && folder.ID != originalID) {+ t.Fatalf("unexpected folder: %+v", folder)+ }+ var count int64+ if err := db.Model(&entity.File{}).Where("name = ?", "Original").Count(&count).Error; err != nil || count != 0 {+ t.Fatalf("old folders=%d err=%v", count, err)+ }+ })+ }+}++func TestEnsureKBFolderRollsBackCreatedParents(t *testing.T) {+ db := setupServiceTestDB(t)+ pushServiceDB(t, db)+ insertTestKB(t, "kb-upload", "tenant-1", 0, 0, 0)+ if err := db.Exec(`CREATE TRIGGER reject_dataset_folder BEFORE INSERT ON file WHEN NEW.name = 'Rejected' BEGIN SELECT RAISE(ABORT, 'reject folder'); END`).Error; err != nil {+ t.Fatal(err)+ }+ if err := db.Model(&entity.Knowledgebase{}).Where("id = ?", "kb-upload").Update("name", "Rejected").Error; err != nil {+ t.Fatal(err)+ }+ kb := &entity.Knowledgebase{ID: "kb-upload", TenantID: "tenant-1", Name: "Rejected"}+ if _, err := testDocumentService(t).ensureKBFolder(t.Context(), kb, "tenant-1"); err == nil {+ t.Fatal("expected folder creation failure")+ }+ var count int64+ if err := db.Model(&entity.File{}).Count(&count).Error; err != nil || count != 0 {+ t.Fatalf("partial folders=%d err=%v", count, err)+ }+}