rm tests

fstree/fs_test.go

@@ -1,385 +0,0 @@
-/*
-another test that is entirely ae ayee generated
-- ruinivist, 30Dec25
-*/
-
-package fstree
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestWalkFileSystemAndBuildTree(t *testing.T) {
-	t.Run("build tree from real directory", func(t *testing.T) {
-		// Create temporary directory structure
-		tmpDir := t.TempDir()
-
-		// Create test structure:
-		// tmpDir/
-		//   file1.txt
-		//   file2.go
-		//   folder1/
-		//     nested.txt
-		//   folder2/
-		os.WriteFile(filepath.Join(tmpDir, "file1.txt"), []byte("content"), 0644)
-		os.WriteFile(filepath.Join(tmpDir, "file2.go"), []byte("code"), 0644)
-		os.Mkdir(filepath.Join(tmpDir, "folder1"), 0755)
-		os.WriteFile(filepath.Join(tmpDir, "folder1", "nested.txt"), []byte("nested"), 0644)
-		os.Mkdir(filepath.Join(tmpDir, "folder2"), 0755)
-
-		// Build tree
-		root := &FsNode{
-			nodeType: FolderNode,
-			path:     tmpDir,
-			children: make([]*FsNode, 0),
-			expanded: true,
-		}
-
-		flatTree := make([]*FsNode, 0)
-		err := walkFileSystemAndBuildTree(tmpDir, root, &flatTree)
-		if err != nil {
-			t.Fatalf("walkFileSystemAndBuildTree() error = %v", err)
-		}
-
-		// Verify structure
-		if len(root.children) != 4 {
-			t.Fatalf("root children count = %d, want 4", len(root.children))
-		}
-
-		// Check children exist and have correct types
-		fileCount := 0
-		folderCount := 0
-		var folder1 *FsNode
-
-		for _, child := range root.children {
-			if child.parent != root {
-				t.Errorf("child %q parent pointer incorrect", child.FileName())
-			}
-
-			switch child.nodeType {
-			case FileNode:
-				fileCount++
-			case FolderNode:
-				folderCount++
-				if child.FileName() == "folder1" {
-					folder1 = child
-				}
-			}
-		}
-
-		if fileCount != 2 {
-			t.Errorf("file count = %d, want 2", fileCount)
-		}
-		if folderCount != 2 {
-			t.Errorf("folder count = %d, want 2", folderCount)
-		} // Update viewport with selected file content
-
-		// Verify nested structure
-		if folder1 == nil {
-			t.Fatal("folder1 not found")
-		}
-		if len(folder1.children) != 1 {
-			t.Errorf("folder1 children count = %d, want 1", len(folder1.children))
-		}
-		if folder1.children[0].FileName() != "nested.txt" {
-			t.Errorf("nested file name = %q, want %q", folder1.children[0].FileName(), "nested.txt")
-		}
-		if folder1.children[0].nodeType != FileNode {
-			t.Errorf("nested node type = %v, want %v", folder1.children[0].nodeType, FileNode)
-		}
-	})
-
-	t.Run("error when node is nil", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		flatTree := make([]*FsNode, 0)
-		err := walkFileSystemAndBuildTree(tmpDir, nil, &flatTree)
-		if err == nil {
-			t.Fatal("walkFileSystemAndBuildTree() with nil node should return error")
-		}
-		if err.Error() != "node cannot be nil" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when node already has children", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		root := &FsNode{
-			nodeType: FolderNode,
-			path:     tmpDir,
-			children: []*FsNode{{nodeType: FileNode, path: "dummy"}},
-			expanded: true,
-		}
-
-		flatTree := make([]*FsNode, 0)
-		err := walkFileSystemAndBuildTree(tmpDir, root, &flatTree)
-		if err == nil {
-			t.Fatal("walkFileSystemAndBuildTree() with existing children should return error")
-		}
-		if err.Error() != "node already has children" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when path does not exist", func(t *testing.T) {
-		root := &FsNode{
-			nodeType: FolderNode,
-			path:     "/nonexistent/path",
-			children: make([]*FsNode, 0),
-			expanded: true,
-		}
-
-		flatTree := make([]*FsNode, 0)
-		err := walkFileSystemAndBuildTree("/nonexistent/path", root, &flatTree)
-		if err == nil {
-			t.Fatal("walkFileSystemAndBuildTree() with nonexistent path should return error")
-		}
-	})
-
-	t.Run("empty directory", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		root := &FsNode{
-			nodeType: FolderNode,
-			path:     tmpDir,
-			children: make([]*FsNode, 0),
-			expanded: true,
-		}
-
-		flatTree := make([]*FsNode, 0)
-		err := walkFileSystemAndBuildTree(tmpDir, root, &flatTree)
-		if err != nil {
-			t.Fatalf("walkFileSystemAndBuildTree() error = %v", err)
-		}
-
-		if len(root.children) != 0 {
-			t.Errorf("empty directory should have 0 children, got %d", len(root.children))
-		}
-	})
-}
-
-func TestCreateFile(t *testing.T) {
-	t.Run("create file successfully", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		filePath := filepath.Join(tmpDir, "test.txt")
-		content := []byte("test content")
-
-		err := createFile(filePath, content)
-		if err != nil {
-			t.Fatalf("createFile() error = %v", err)
-		}
-
-		data, err := os.ReadFile(filePath)
-		if err != nil {
-			t.Fatalf("failed to read created file: %v", err)
-		}
-		if string(data) != string(content) {
-			t.Errorf("file content = %q, want %q", string(data), string(content))
-		}
-	})
-
-	t.Run("create empty file", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		filePath := filepath.Join(tmpDir, "empty.txt")
-
-		err := createFile(filePath, nil)
-		if err != nil {
-			t.Fatalf("createFile() error = %v", err)
-		}
-
-		info, err := os.Stat(filePath)
-		if err != nil {
-			t.Fatalf("failed to stat file: %v", err)
-		}
-		if info.Size() != 0 {
-			t.Errorf("file size = %d, want 0", info.Size())
-		}
-	})
-
-	t.Run("error when path is empty", func(t *testing.T) {
-		err := createFile("", []byte("content"))
-		if err == nil {
-			t.Fatal("createFile() with empty path should return error")
-		}
-		if err.Error() != "file path cannot be empty" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when file already exists", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		filePath := filepath.Join(tmpDir, "existing.txt")
-		os.WriteFile(filePath, []byte("existing"), 0644)
-
-		err := createFile(filePath, []byte("new"))
-		if err == nil {
-			t.Fatal("createFile() on existing file should return error")
-		}
-		if err.Error() != "file already exists" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-}
-
-func TestCreateFolder(t *testing.T) {
-	t.Run("create folder successfully", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		folderPath := filepath.Join(tmpDir, "testfolder")
-
-		err := createFolder(folderPath)
-		if err != nil {
-			t.Fatalf("createFolder() error = %v", err)
-		}
-
-		info, err := os.Stat(folderPath)
-		if err != nil {
-			t.Fatalf("failed to stat folder: %v", err)
-		}
-		if !info.IsDir() {
-			t.Error("created path is not a directory")
-		}
-	})
-
-	t.Run("error when path is empty", func(t *testing.T) {
-		err := createFolder("")
-		if err == nil {
-			t.Fatal("createFolder() with empty path should return error")
-		}
-		if err.Error() != "folder path cannot be empty" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when folder already exists", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		folderPath := filepath.Join(tmpDir, "existing")
-		os.Mkdir(folderPath, 0755)
-
-		err := createFolder(folderPath)
-		if err == nil {
-			t.Fatal("createFolder() on existing folder should return error")
-		}
-		if err.Error() != "folder already exists" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-}
-
-func TestDeleteFile(t *testing.T) {
-	t.Run("delete file successfully", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		filePath := filepath.Join(tmpDir, "delete.txt")
-		os.WriteFile(filePath, []byte("content"), 0644)
-
-		err := deleteFile(filePath)
-		if err != nil {
-			t.Fatalf("deleteFile() error = %v", err)
-		}
-
-		if _, err := os.Stat(filePath); !os.IsNotExist(err) {
-			t.Error("file still exists after deletion")
-		}
-	})
-
-	t.Run("error when path is empty", func(t *testing.T) {
-		err := deleteFile("")
-		if err == nil {
-			t.Fatal("deleteFile() with empty path should return error")
-		}
-		if err.Error() != "file path cannot be empty" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when file does not exist", func(t *testing.T) {
-		err := deleteFile("/nonexistent/file.txt")
-		if err == nil {
-			t.Fatal("deleteFile() on nonexistent file should return error")
-		}
-		if err.Error() != "file does not exist" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when path is a directory", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		folderPath := filepath.Join(tmpDir, "folder")
-		os.Mkdir(folderPath, 0755)
-
-		err := deleteFile(folderPath)
-		if err == nil {
-			t.Fatal("deleteFile() on directory should return error")
-		}
-		if err.Error() != "path is a directory, not a file" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-}
-
-func TestDeleteFolder(t *testing.T) {
-	t.Run("delete empty folder successfully", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		folderPath := filepath.Join(tmpDir, "emptyfolder")
-		os.Mkdir(folderPath, 0755)
-
-		err := deleteFolder(folderPath)
-		if err != nil {
-			t.Fatalf("deleteFolder() error = %v", err)
-		}
-
-		if _, err := os.Stat(folderPath); !os.IsNotExist(err) {
-			t.Error("folder still exists after deletion")
-		}
-	})
-
-	t.Run("delete folder with contents", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		folderPath := filepath.Join(tmpDir, "withcontents")
-		os.Mkdir(folderPath, 0755)
-		os.WriteFile(filepath.Join(folderPath, "file.txt"), []byte("content"), 0644)
-		os.Mkdir(filepath.Join(folderPath, "subfolder"), 0755)
-
-		err := deleteFolder(folderPath)
-		if err != nil {
-			t.Fatalf("deleteFolder() error = %v", err)
-		}
-
-		if _, err := os.Stat(folderPath); !os.IsNotExist(err) {
-			t.Error("folder still exists after deletion")
-		}
-	})
-
-	t.Run("error when path is empty", func(t *testing.T) {
-		err := deleteFolder("")
-		if err == nil {
-			t.Fatal("deleteFolder() with empty path should return error")
-		}
-		if err.Error() != "folder path cannot be empty" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when folder does not exist", func(t *testing.T) {
-		err := deleteFolder("/nonexistent/folder")
-		if err == nil {
-			t.Fatal("deleteFolder() on nonexistent folder should return error")
-		}
-		if err.Error() != "folder does not exist" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-
-	t.Run("error when path is a file", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		filePath := filepath.Join(tmpDir, "file.txt")
-		os.WriteFile(filePath, []byte("content"), 0644)
-
-		err := deleteFolder(filePath)
-		if err == nil {
-			t.Fatal("deleteFolder() on file should return error")
-		}
-		if err.Error() != "path is a file, not a directory" {
-			t.Errorf("error message = %q", err.Error())
-		}
-	})
-}

fstree/fstree_test.go

@@ -1,280 +0,0 @@
-/*
-This file is almost entirely ae ayee generated. That's one of the
-few good uses of ae ayee in my opinion
-
-- ruinivist, 30Dec25
-*/
-
-package fstree
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func TestFsNode_FileName(t *testing.T) {
-	tests := []struct {
-		name     string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple filename",
-			path:     "/home/user/test.txt",
-			expected: "test.txt",
-		},
-		{
-			name:     "folder name",
-			path:     "/home/user/folder",
-			expected: "folder",
-		},
-		{
-			name:     "root path",
-			path:     "/",
-			expected: "/",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			node := &FsNode{path: tt.path}
-			got := node.FileName()
-			if got != tt.expected {
-				t.Errorf("FileName() = %q, want %q", got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestNewFsTree(t *testing.T) {
-	rootPath := "/home/test"
-	tree := NewFsTree(rootPath)
-
-	if tree == nil {
-		t.Fatal("NewFsTree() returned nil")
-	}
-	if tree.root == nil {
-		t.Fatal("tree.root is nil")
-	}
-	if tree.root.nodeType != FolderNode {
-		t.Errorf("root nodeType = %v, want %v", tree.root.nodeType, FolderNode)
-	}
-	if tree.root.path != rootPath {
-		t.Errorf("root path = %q, want %q", tree.root.path, rootPath)
-	}
-	if !tree.root.expanded {
-		t.Error("root should be expanded by default")
-	}
-	if tree.root.children == nil {
-		t.Error("root children slice should be initialized")
-	}
-}
-
-func TestFsTreeImpl_CreateNode(t *testing.T) {
-	t.Run("create file node successfully", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.CreateNode(tree.root, "file.txt", FileNode)
-		if err != nil {
-			t.Fatalf("CreateNode() error = %v, want nil", err)
-		}
-		if len(tree.root.children) != 1 {
-			t.Fatalf("children count = %d, want 1", len(tree.root.children))
-		}
-
-		child := tree.root.children[0]
-		if child.nodeType != FileNode {
-			t.Errorf("child nodeType = %v, want %v", child.nodeType, FileNode)
-		}
-		expectedPath := filepath.Join("/home/test", "file.txt")
-		if child.path != expectedPath {
-			t.Errorf("child path = %q, want %q", child.path, expectedPath)
-		}
-		if child.parent != tree.root {
-			t.Error("child parent should point to root")
-		}
-		if child.expanded {
-			t.Error("new node should not be expanded by default")
-		}
-	})
-
-	t.Run("create folder node successfully", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.CreateNode(tree.root, "subfolder", FolderNode)
-		if err != nil {
-			t.Fatalf("CreateNode() error = %v, want nil", err)
-		}
-		if len(tree.root.children) != 1 {
-			t.Fatalf("children count = %d, want 1", len(tree.root.children))
-		}
-
-		child := tree.root.children[0]
-		if child.nodeType != FolderNode {
-			t.Errorf("child nodeType = %v, want %v", child.nodeType, FolderNode)
-		}
-	})
-
-	t.Run("error when parent is nil", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.CreateNode(nil, "file.txt", FileNode)
-		if err == nil {
-			t.Fatal("CreateNode() with nil parent should return error")
-		}
-		if err.Error() != "parent node cannot be nil" {
-			t.Errorf("error message = %q, want %q", err.Error(), "parent node cannot be nil")
-		}
-	})
-
-	t.Run("error when parent is file node", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		fileNode := &FsNode{
-			nodeType: FileNode,
-			path:     "/home/test/file.txt",
-			parent:   tree.root,
-		}
-		err := tree.CreateNode(fileNode, "child.txt", FileNode)
-		if err == nil {
-			t.Fatal("CreateNode() with file parent should return error")
-		}
-		if err.Error() != "can only add nodes to folder nodes" {
-			t.Errorf("error message = %q, want %q", err.Error(), "can only add nodes to folder nodes")
-		}
-	})
-
-	t.Run("error when name is empty", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.CreateNode(tree.root, "", FileNode)
-		if err == nil {
-			t.Fatal("CreateNode() with empty name should return error")
-		}
-		if err.Error() != "node name cannot be empty" {
-			t.Errorf("error message = %q, want %q", err.Error(), "node name cannot be empty")
-		}
-	})
-
-	t.Run("create nested nodes", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.CreateNode(tree.root, "folder1", FolderNode)
-		if err != nil {
-			t.Fatalf("CreateNode() error = %v", err)
-		}
-		folder1 := tree.root.children[0]
-
-		err = tree.CreateNode(folder1, "file.txt", FileNode)
-		if err != nil {
-			t.Fatalf("CreateNode() error = %v", err)
-		}
-
-		if len(folder1.children) != 1 {
-			t.Fatalf("folder1 children count = %d, want 1", len(folder1.children))
-		}
-		expectedPath := filepath.Join("/home/test", "folder1", "file.txt")
-		if folder1.children[0].path != expectedPath {
-			t.Errorf("nested file path = %q, want %q", folder1.children[0].path, expectedPath)
-		}
-	})
-}
-
-func TestFsTreeImpl_DeleteNode(t *testing.T) {
-	t.Run("delete node successfully", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		tree.CreateNode(tree.root, "file1.txt", FileNode)
-		tree.CreateNode(tree.root, "file2.txt", FileNode)
-
-		if len(tree.root.children) != 2 {
-			t.Fatalf("initial children count = %d, want 2", len(tree.root.children))
-		}
-
-		nodeToDelete := tree.root.children[0]
-		err := tree.DeleteNode(nodeToDelete)
-		if err != nil {
-			t.Fatalf("DeleteNode() error = %v, want nil", err)
-		}
-
-		if len(tree.root.children) != 1 {
-			t.Errorf("children count after delete = %d, want 1", len(tree.root.children))
-		}
-	})
-
-	t.Run("error when node is nil", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.DeleteNode(nil)
-		if err == nil {
-			t.Fatal("DeleteNode() with nil node should return error")
-		}
-		if err.Error() != "node to delete cannot be nil" {
-			t.Errorf("error message = %q, want %q", err.Error(), "node to delete cannot be nil")
-		}
-	})
-
-	t.Run("error when node has no parent", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		orphanNode := &FsNode{
-			nodeType: FileNode,
-			path:     "/orphan.txt",
-			parent:   nil,
-		}
-		err := tree.DeleteNode(orphanNode)
-		if err == nil {
-			t.Fatal("DeleteNode() with no parent should return error")
-		}
-		if err.Error() != "node to delete must have a parent" {
-			t.Errorf("error message = %q, want %q", err.Error(), "node to delete must have a parent")
-		}
-	})
-}
-
-func TestFsTreeImpl_ToggleExpand(t *testing.T) {
-	t.Run("toggle folder expansion", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		tree.CreateNode(tree.root, "folder1", FolderNode)
-		folder := tree.root.children[0]
-
-		// Initially not expanded
-		if folder.expanded {
-			t.Error("new folder should not be expanded")
-		}
-
-		// Toggle to expanded
-		err := tree.ToggleExpand(folder)
-		if err != nil {
-			t.Fatalf("ToggleExpand() error = %v", err)
-		}
-		if !folder.expanded {
-			t.Error("folder should be expanded after toggle")
-		}
-
-		// Toggle back to collapsed
-		err = tree.ToggleExpand(folder)
-		if err != nil {
-			t.Fatalf("ToggleExpand() error = %v", err)
-		}
-		if folder.expanded {
-			t.Error("folder should be collapsed after second toggle")
-		}
-	})
-
-	t.Run("error when node is nil", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		err := tree.ToggleExpand(nil)
-		if err == nil {
-			t.Fatal("ToggleExpand() with nil node should return error")
-		}
-		if err.Error() != "node cannot be nil" {
-			t.Errorf("error message = %q, want %q", err.Error(), "node cannot be nil")
-		}
-	})
-
-	t.Run("error when node is file", func(t *testing.T) {
-		tree := NewFsTree("/home/test")
-		tree.CreateNode(tree.root, "file.txt", FileNode)
-		fileNode := tree.root.children[0]
-
-		err := tree.ToggleExpand(fileNode)
-		if err == nil {
-			t.Fatal("ToggleExpand() on file node should return error")
-		}
-		if err.Error() != "only folder nodes can be expanded or collapsed" {
-			t.Errorf("error message = %q, want %q", err.Error(), "only folder nodes can be expanded or collapsed")
-		}
-	})
-}