458 lines
13 KiB
Go
458 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestListTrashShowsDeletedNodesAndPhysicalEntries(t *testing.T) {
|
|
app, _ := setupTestApp(t)
|
|
|
|
n, err := app.CreateNodeFromTemplate("", "Trash Me", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create node: %v", err)
|
|
}
|
|
if err := app.DeleteNode(n.ID); err != nil {
|
|
t.Fatalf("DeleteNode: %v", err)
|
|
}
|
|
|
|
trash, err := app.ListTrash()
|
|
if err != nil {
|
|
t.Fatalf("ListTrash: %v", err)
|
|
}
|
|
|
|
var foundNode bool
|
|
for _, node := range trash.Nodes {
|
|
if node.ID == n.ID && node.Title == "Trash Me" && node.DeletedAt != "" {
|
|
foundNode = true
|
|
break
|
|
}
|
|
}
|
|
if !foundNode {
|
|
t.Fatalf("deleted node %s missing from trash nodes: %#v", n.ID, trash.Nodes)
|
|
}
|
|
|
|
var foundPhysical bool
|
|
for _, entry := range trash.Entries {
|
|
if strings.Contains(entry.Name, n.ID) && entry.IsDir {
|
|
foundPhysical = true
|
|
break
|
|
}
|
|
}
|
|
if !foundPhysical {
|
|
t.Fatalf("physical trash entry for %s missing: %#v", n.ID, trash.Entries)
|
|
}
|
|
}
|
|
|
|
func TestRestoreTrashNodeRestoresAncestorPathOnlyForSelectedChild(t *testing.T) {
|
|
app, vault := setupTestApp(t)
|
|
|
|
parent, err := app.CreateNodeFromTemplate("", "Documents", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create parent: %v", err)
|
|
}
|
|
child, err := app.CreateNodeFromTemplate(parent.ID, "Specs", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create child: %v", err)
|
|
}
|
|
other, err := app.CreateNodeFromTemplate(parent.ID, "Drafts", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create other: %v", err)
|
|
}
|
|
|
|
if err := app.DeleteNode(parent.ID); err != nil {
|
|
t.Fatalf("DeleteNode: %v", err)
|
|
}
|
|
if err := app.RestoreTrashNode(child.ID); err != nil {
|
|
t.Fatalf("RestoreTrashNode(child): %v", err)
|
|
}
|
|
|
|
for _, id := range []string{parent.ID, child.ID} {
|
|
if _, err := app.nodes.GetActive(id); err != nil {
|
|
t.Fatalf("node %s should be active after restore: %v", id, err)
|
|
}
|
|
}
|
|
if _, err := app.nodes.GetActive(other.ID); err == nil {
|
|
t.Fatalf("unselected sibling should remain deleted")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(vault, "Documents", "Specs")); err != nil {
|
|
t.Fatalf("restored child path missing: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRestoreTrashNodeFromNestedDeletedFolderRestoresFullPath(t *testing.T) {
|
|
app, vault := setupTestApp(t)
|
|
|
|
parent, err := app.CreateNodeFromTemplate("", "Verstak", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create parent: %v", err)
|
|
}
|
|
templates, err := app.CreateNodeFromTemplate(parent.ID, "templates", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create templates: %v", err)
|
|
}
|
|
registry, err := app.CreateNodeFromTemplate(templates.ID, "registry.go", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create registry: %v", err)
|
|
}
|
|
other, err := app.CreateNodeFromTemplate(templates.ID, "other.go", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create other: %v", err)
|
|
}
|
|
|
|
if err := app.DeleteNode(parent.ID); err != nil {
|
|
t.Fatalf("DeleteNode: %v", err)
|
|
}
|
|
if err := app.RestoreTrashNode(registry.ID); err != nil {
|
|
t.Fatalf("RestoreTrashNode(registry): %v", err)
|
|
}
|
|
|
|
for _, id := range []string{parent.ID, templates.ID, registry.ID} {
|
|
if _, err := app.nodes.GetActive(id); err != nil {
|
|
t.Fatalf("node %s should be active after restore: %v", id, err)
|
|
}
|
|
}
|
|
if _, err := app.nodes.GetActive(other.ID); err == nil {
|
|
t.Fatalf("unselected nested sibling should remain deleted")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(vault, "Verstak", "templates", "registry.go")); err != nil {
|
|
t.Fatalf("restored nested path missing: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTrashCountPurgeAndEmpty(t *testing.T) {
|
|
app, _ := setupTestApp(t)
|
|
a, _ := app.CreateNodeFromTemplate("", "Trash A", "folder.default")
|
|
b, _ := app.CreateNodeFromTemplate("", "Trash B", "folder.default")
|
|
if err := app.DeleteNode(a.ID); err != nil {
|
|
t.Fatalf("delete A: %v", err)
|
|
}
|
|
if err := app.DeleteNode(b.ID); err != nil {
|
|
t.Fatalf("delete B: %v", err)
|
|
}
|
|
count, err := app.TrashCount()
|
|
if err != nil {
|
|
t.Fatalf("TrashCount: %v", err)
|
|
}
|
|
if count != 2 {
|
|
t.Fatalf("TrashCount = %d, want 2", count)
|
|
}
|
|
if err := app.PurgeTrashNodesJSON(`["` + a.ID + `"]`); err != nil {
|
|
t.Fatalf("PurgeTrashNodesJSON: %v", err)
|
|
}
|
|
count, _ = app.TrashCount()
|
|
if count != 1 {
|
|
t.Fatalf("TrashCount after purge = %d, want 1", count)
|
|
}
|
|
if err := app.EmptyTrash(); err != nil {
|
|
t.Fatalf("EmptyTrash: %v", err)
|
|
}
|
|
count, _ = app.TrashCount()
|
|
if count != 0 {
|
|
t.Fatalf("TrashCount after empty = %d, want 0", count)
|
|
}
|
|
}
|
|
|
|
func TestTrashTypeFilePreviewAndRestore(t *testing.T) {
|
|
app, vault := setupTestApp(t)
|
|
|
|
// Create a folder to hold the file.
|
|
parent, err := app.CreateNodeFromTemplate("", "Documents", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create parent: %v", err)
|
|
}
|
|
|
|
// Create a TypeFile node with a file record.
|
|
fileNode, err := app.CreateEmptyFile(parent.ID, "hello.txt")
|
|
if err != nil {
|
|
t.Fatalf("CreateEmptyFile: %v", err)
|
|
}
|
|
|
|
// Write some content to the physical file via file records.
|
|
recs, err := app.files.ListByNode(fileNode.ID)
|
|
if err != nil || len(recs) == 0 {
|
|
t.Fatalf("ListByNode: %v (len=%d)", err, len(recs))
|
|
}
|
|
record := recs[0]
|
|
absPath := filepath.Join(vault, record.Path)
|
|
content := "Hello, World!"
|
|
if err := os.WriteFile(absPath, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("write file: %v", err)
|
|
}
|
|
|
|
// Delete the entire tree.
|
|
if err := app.DeleteNode(parent.ID); err != nil {
|
|
t.Fatalf("DeleteNode: %v", err)
|
|
}
|
|
|
|
// Verify trash listing has the file node with trashFsPath set.
|
|
trash, err := app.ListTrash()
|
|
if err != nil {
|
|
t.Fatalf("ListTrash: %v", err)
|
|
}
|
|
var fileTrashNode *TrashNodeDTO
|
|
for i, n := range trash.Nodes {
|
|
if n.ID == fileNode.ID {
|
|
fileTrashNode = &trash.Nodes[i]
|
|
break
|
|
}
|
|
}
|
|
if fileTrashNode == nil {
|
|
t.Fatalf("file node not found in trash listing")
|
|
}
|
|
if fileTrashNode.TrashFsPath == "" {
|
|
t.Fatalf("file node missing trashFsPath: %+v", fileTrashNode)
|
|
}
|
|
|
|
// Verify ReadTrashFile works with the precomputed path.
|
|
readContent, err := app.ReadTrashFile(fileTrashNode.TrashFsPath)
|
|
if err != nil {
|
|
t.Fatalf("ReadTrashFile: %v", err)
|
|
}
|
|
if readContent != content {
|
|
t.Fatalf("ReadTrashFile content = %q, want %q", readContent, content)
|
|
}
|
|
|
|
// Verify ReadTrashFileContent also works (fallback using file records).
|
|
readContent2, err := app.ReadTrashFileContent(fileNode.ID)
|
|
if err != nil {
|
|
t.Fatalf("ReadTrashFileContent: %v", err)
|
|
}
|
|
if readContent2 != content {
|
|
t.Fatalf("ReadTrashFileContent = %q, want %q", readContent2, content)
|
|
}
|
|
|
|
// Verify trashed file records are still in DB.
|
|
trashedRecs, err := app.files.ListTrashedByNode(fileNode.ID)
|
|
if err != nil {
|
|
t.Fatalf("ListTrashedByNode: %v", err)
|
|
}
|
|
if len(trashedRecs) != 1 {
|
|
t.Fatalf("ListTrashedByNode = %d records, want 1", len(trashedRecs))
|
|
}
|
|
if !trashedRecs[0].Missing {
|
|
t.Fatalf("expected trashed record to have Missing=true")
|
|
}
|
|
if trashedRecs[0].Path == "" {
|
|
t.Fatalf("expected trashed record to keep original Path")
|
|
}
|
|
|
|
// Restore the file node.
|
|
if err := app.RestoreTrashNode(fileNode.ID); err != nil {
|
|
t.Fatalf("RestoreTrashNode: %v", err)
|
|
}
|
|
|
|
// Verify the node is active.
|
|
if _, err := app.nodes.GetActive(fileNode.ID); err != nil {
|
|
t.Fatalf("file node not active after restore: %v", err)
|
|
}
|
|
|
|
// Verify the file record is restored (missing=0).
|
|
restoredRecs, err := app.files.ListByNode(fileNode.ID)
|
|
if err != nil {
|
|
t.Fatalf("ListByNode after restore: %v", err)
|
|
}
|
|
if len(restoredRecs) != 1 {
|
|
t.Fatalf("ListByNode after restore = %d records, want 1", len(restoredRecs))
|
|
}
|
|
if restoredRecs[0].Missing {
|
|
t.Fatalf("file record should have Missing=false after restore")
|
|
}
|
|
|
|
// Verify the physical file content is intact.
|
|
absRestored := filepath.Join(vault, restoredRecs[0].Path)
|
|
restoredBytes, err := os.ReadFile(absRestored)
|
|
if err != nil {
|
|
t.Fatalf("read restored file: %v", err)
|
|
}
|
|
if string(restoredBytes) != content {
|
|
t.Fatalf("restored file content = %q, want %q", string(restoredBytes), content)
|
|
}
|
|
|
|
// Verify the trash entry is gone (file was moved back).
|
|
if _, err := os.Stat(fileTrashNode.TrashFsPath); !os.IsNotExist(err) {
|
|
t.Fatalf("trash entry should be gone after restore, err=%v", err)
|
|
}
|
|
|
|
// Parent is also restored because RestoreTrashNode restores the entire
|
|
// ancestor chain from the requested node up to the root deleted node.
|
|
if _, err := app.nodes.GetActive(parent.ID); err != nil {
|
|
t.Fatalf("parent should be active after child restore (ancestor chain): %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTrashTypeFileInsideFolderRestorePreservesContent(t *testing.T) {
|
|
app, vault := setupTestApp(t)
|
|
|
|
// Create: parent folder → child TypeFile.
|
|
parent, err := app.CreateNodeFromTemplate("", "ProjectX", "folder.default")
|
|
if err != nil {
|
|
t.Fatalf("create parent: %v", err)
|
|
}
|
|
fileNode, err := app.CreateEmptyFile(parent.ID, "data.csv")
|
|
if err != nil {
|
|
t.Fatalf("CreateEmptyFile: %v", err)
|
|
}
|
|
|
|
// Write content.
|
|
recs, err := app.files.ListByNode(fileNode.ID)
|
|
if err != nil || len(recs) == 0 {
|
|
t.Fatalf("ListByNode: %v (len=%d)", err, len(recs))
|
|
}
|
|
absPath := filepath.Join(vault, recs[0].Path)
|
|
content := "a,b,c\n1,2,3"
|
|
if err := os.WriteFile(absPath, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("write file: %v", err)
|
|
}
|
|
|
|
// Delete the whole tree.
|
|
if err := app.DeleteNode(parent.ID); err != nil {
|
|
t.Fatalf("DeleteNode: %v", err)
|
|
}
|
|
|
|
// Restore parent. This moves the directory back from trash but does NOT
|
|
// restore child nodes (RestoreTrashNode walks ancestor chain, not children).
|
|
if err := app.RestoreTrashNode(parent.ID); err != nil {
|
|
t.Fatalf("RestoreTrashNode parent: %v", err)
|
|
}
|
|
|
|
// Only the parent should be active.
|
|
if _, err := app.nodes.GetActive(parent.ID); err != nil {
|
|
t.Fatalf("parent should be active: %v", err)
|
|
}
|
|
if _, err := app.nodes.GetActive(fileNode.ID); err == nil {
|
|
t.Fatalf("child file node should remain deleted (RestoreTrashNode is ancestor-only)")
|
|
}
|
|
|
|
// Parent directory should exist on disk.
|
|
if _, err := os.Stat(filepath.Join(vault, "ProjectX")); err != nil {
|
|
t.Fatalf("parent directory should exist: %v", err)
|
|
}
|
|
|
|
// Now restore the child file node specifically.
|
|
if err := app.RestoreTrashNode(fileNode.ID); err != nil {
|
|
t.Fatalf("RestoreTrashNode file: %v", err)
|
|
}
|
|
|
|
if _, err := app.nodes.GetActive(fileNode.ID); err != nil {
|
|
t.Fatalf("file node should be active: %v", err)
|
|
}
|
|
|
|
// File record should be restored.
|
|
recs, err = app.files.ListByNode(fileNode.ID)
|
|
if err != nil || len(recs) == 0 {
|
|
t.Fatalf("ListByNode after restore: %v (len=%d)", err, len(recs))
|
|
}
|
|
if recs[0].Missing {
|
|
t.Fatalf("file record should not be missing after restore")
|
|
}
|
|
|
|
// Physical file content should be intact.
|
|
absRestored := filepath.Join(vault, recs[0].Path)
|
|
restoredBytes, err := os.ReadFile(absRestored)
|
|
if err != nil {
|
|
t.Fatalf("read restored file: %v", err)
|
|
}
|
|
if string(restoredBytes) != content {
|
|
t.Fatalf("content = %q, want %q", string(restoredBytes), content)
|
|
}
|
|
}
|
|
|
|
func TestTrashTypeFileMultipleRecords(t *testing.T) {
|
|
app, vault := setupTestApp(t)
|
|
|
|
// Create a TypeFile node with two file records.
|
|
fileNode, err := app.CreateEmptyFile("", "report.txt")
|
|
if err != nil {
|
|
t.Fatalf("CreateEmptyFile: %v", err)
|
|
}
|
|
|
|
// Write content to first record.
|
|
recs, err := app.files.ListByNode(fileNode.ID)
|
|
if err != nil || len(recs) == 0 {
|
|
t.Fatalf("ListByNode: %v (len=%d)", err, len(recs))
|
|
}
|
|
absPath1 := filepath.Join(vault, recs[0].Path)
|
|
content1 := "version 1"
|
|
if err := os.WriteFile(absPath1, []byte(content1), 0o644); err != nil {
|
|
t.Fatalf("write file 1: %v", err)
|
|
}
|
|
|
|
// Manually insert a second file record with its own vault file.
|
|
now := nowStr()
|
|
absPath2 := filepath.Join(vault, "report-v2.txt")
|
|
content2 := "version 2"
|
|
if err := os.WriteFile(absPath2, []byte(content2), 0o644); err != nil {
|
|
t.Fatalf("write file 2: %v", err)
|
|
}
|
|
_, err = app.db.Exec(
|
|
`INSERT INTO files (id,node_id,filename,path,storage_mode,size,sha256,mime,created_at,updated_at,missing)
|
|
VALUES (?,?,?,?,?,?,?,?,?,?,0)`,
|
|
"second-record-id", fileNode.ID, "report-v2.txt",
|
|
"report-v2.txt", "vault", 0, "", "text/plain", now, now)
|
|
if err != nil {
|
|
t.Fatalf("insert second record: %v", err)
|
|
}
|
|
|
|
// Delete the node.
|
|
if err := app.DeleteNode(fileNode.ID); err != nil {
|
|
t.Fatalf("DeleteNode: %v", err)
|
|
}
|
|
|
|
// Verify both records are trashed.
|
|
trashedRecs, err := app.files.ListTrashedByNode(fileNode.ID)
|
|
if err != nil {
|
|
t.Fatalf("ListTrashedByNode: %v", err)
|
|
}
|
|
if len(trashedRecs) != 2 {
|
|
t.Fatalf("expected 2 trashed records, got %d", len(trashedRecs))
|
|
}
|
|
for _, r := range trashedRecs {
|
|
if !r.Missing {
|
|
t.Fatalf("record %s should have Missing=true", r.ID)
|
|
}
|
|
}
|
|
|
|
// Verify trash listing has trashFsPath set.
|
|
trash, err := app.ListTrash()
|
|
if err != nil {
|
|
t.Fatalf("ListTrash: %v", err)
|
|
}
|
|
var found bool
|
|
for _, n := range trash.Nodes {
|
|
if n.ID == fileNode.ID {
|
|
found = true
|
|
if n.TrashFsPath == "" {
|
|
t.Fatalf("trashFsPath should be set for file node with multiple records")
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatalf("file node not found in trash listing")
|
|
}
|
|
|
|
// Restore.
|
|
if err := app.RestoreTrashNode(fileNode.ID); err != nil {
|
|
t.Fatalf("RestoreTrashNode: %v", err)
|
|
}
|
|
|
|
// Both records should be restored.
|
|
restoredRecs, err := app.files.ListByNode(fileNode.ID)
|
|
if err != nil {
|
|
t.Fatalf("ListByNode after restore: %v", err)
|
|
}
|
|
if len(restoredRecs) != 2 {
|
|
t.Fatalf("expected 2 restored records, got %d: %+v", len(restoredRecs), restoredRecs)
|
|
}
|
|
for _, r := range restoredRecs {
|
|
if r.Missing {
|
|
t.Fatalf("record %s should not be missing", r.ID)
|
|
}
|
|
}
|
|
}
|
|
|
|
|