vibetree/internal/folders/folders_test.go

package folders_test

import (
	"context"
	"database/sql"
	"path/filepath"
	"testing"

	"vibetree/internal/database"
	"vibetree/internal/folders"
	"vibetree/internal/models"
)

func testDB(t *testing.T) *sql.DB {
	t.Helper()
	dir := t.TempDir()
	db, err := database.Open(filepath.Join(dir, "test.db"))
	if err != nil {
		t.Fatalf("open db: %v", err)
	}
	t.Cleanup(func() { db.Close() })
	return db
}

func TestFolderCreateAndChildren(t *testing.T) {
	ctx := context.Background()
	s := folders.NewStore(testDB(t))

	root := &models.Folder{Name: "Main Office"}
	if err := s.Create(ctx, root); err != nil {
		t.Fatalf("create root: %v", err)
	}
	if root.ID == 0 {
		t.Fatal("expected assigned ID")
	}

	child := &models.Folder{Name: "Network", ParentID: &root.ID}
	if err := s.Create(ctx, child); err != nil {
		t.Fatalf("create child: %v", err)
	}

	children, err := s.Children(ctx, &root.ID)
	if err != nil {
		t.Fatalf("children: %v", err)
	}
	if len(children) != 1 || children[0].Name != "Network" {
		t.Fatalf("unexpected children: %+v", children)
	}
	if children[0].FolderCount != 0 {
		t.Fatalf("expected 0 sub-folders, got %d", children[0].FolderCount)
	}
}

func TestFolderCreateRequiresName(t *testing.T) {
	s := folders.NewStore(testDB(t))
	err := s.Create(context.Background(), &models.Folder{})
	if err != folders.ErrNameRequired {
		t.Fatalf("expected ErrNameRequired, got %v", err)
	}
}

func TestFolderMovePreventsCycles(t *testing.T) {
	ctx := context.Background()
	s := folders.NewStore(testDB(t))

	a := &models.Folder{Name: "A"}
	must(t, s.Create(ctx, a))
	b := &models.Folder{Name: "B", ParentID: &a.ID}
	must(t, s.Create(ctx, b))
	c := &models.Folder{Name: "C", ParentID: &b.ID}
	must(t, s.Create(ctx, c))

	// Moving A under its own descendant C must fail.
	if err := s.Move(ctx, a.ID, &c.ID); err != folders.ErrInvalidParent {
		t.Fatalf("expected ErrInvalidParent, got %v", err)
	}
	// Moving A under itself must fail.
	if err := s.Move(ctx, a.ID, &a.ID); err != folders.ErrInvalidParent {
		t.Fatalf("expected ErrInvalidParent for self-move, got %v", err)
	}
	// A legitimate move should succeed.
	if err := s.Move(ctx, c.ID, &a.ID); err != nil {
		t.Fatalf("expected valid move to succeed: %v", err)
	}
}

func TestFolderDeleteRequiresEmpty(t *testing.T) {
	ctx := context.Background()
	s := folders.NewStore(testDB(t))

	a := &models.Folder{Name: "A"}
	must(t, s.Create(ctx, a))
	b := &models.Folder{Name: "B", ParentID: &a.ID}
	must(t, s.Create(ctx, b))

	if err := s.Delete(ctx, a.ID); err != folders.ErrNotEmpty {
		t.Fatalf("expected ErrNotEmpty, got %v", err)
	}
	if err := s.Delete(ctx, b.ID); err != nil {
		t.Fatalf("delete empty folder: %v", err)
	}
	if err := s.Delete(ctx, a.ID); err != nil {
		t.Fatalf("delete now-empty folder: %v", err)
	}
}

func TestFolderDeleteAndRelocate(t *testing.T) {
	ctx := context.Background()
	s := folders.NewStore(testDB(t))

	a := &models.Folder{Name: "A"}
	must(t, s.Create(ctx, a))
	b := &models.Folder{Name: "B", ParentID: &a.ID}
	must(t, s.Create(ctx, b))
	dest := &models.Folder{Name: "Dest"}
	must(t, s.Create(ctx, dest))

	if err := s.DeleteAndRelocate(ctx, a.ID, &dest.ID); err != nil {
		t.Fatalf("delete and relocate: %v", err)
	}
	children, err := s.Children(ctx, &dest.ID)
	if err != nil {
		t.Fatalf("children: %v", err)
	}
	if len(children) != 1 || children[0].ID != b.ID {
		t.Fatalf("expected B relocated under Dest, got %+v", children)
	}
	if _, err := s.Get(ctx, a.ID); err != folders.ErrNotFound {
		t.Fatalf("expected A to be deleted, got %v", err)
	}
}

func TestFolderCascadeDelete(t *testing.T) {
	ctx := context.Background()
	s := folders.NewStore(testDB(t))

	a := &models.Folder{Name: "A"}
	must(t, s.Create(ctx, a))
	b := &models.Folder{Name: "B", ParentID: &a.ID}
	must(t, s.Create(ctx, b))
	c := &models.Folder{Name: "C", ParentID: &b.ID}
	must(t, s.Create(ctx, c))

	if err := s.CascadeDelete(ctx, a.ID); err != nil {
		t.Fatalf("cascade delete: %v", err)
	}
	for _, id := range []int64{a.ID, b.ID, c.ID} {
		if _, err := s.Get(ctx, id); err != folders.ErrNotFound {
			t.Fatalf("expected folder %d deleted, got %v", id, err)
		}
	}
}

func must(t *testing.T, err error) {
	t.Helper()
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
}