Work/Backend/internal/posixproj/projector_test.go

// Path: Backend/internal/posixproj/projector_test.go

package posixproj

import (
	"encoding/json"
	"os"
	"path/filepath"
	"testing"

	"github.com/fxamacker/cbor/v2"
)

const (
	testSettingsFileName = "settings.cbor"
	testLayoutFileName   = "layout.cbor"
	testHomeFileName     = "home.cbor"
	testUsersFileName    = "users.cbor"
	testACLFileName      = "acl.cbor"
	testFolderFileName   = "folder.cbor"
	testItemFileName     = "item.cbor"
	testDataFileName     = "data.cbor"
	testSchemaFileName   = "schema.json"
	testManifestFileName = "manifest.jsonc"
)

func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) {
	root := filepath.Join(t.TempDir(), "POSIX")

	mustMkdirAll(t, filepath.Join(root, "catalog", "packs"))
	mustMkdirAll(t, filepath.Join(root, "catalog", "standalone"))
	mustMkdirAll(t, filepath.Join(root, "catalog", "packs", "pack-core", "entries", "app-shell"))
	mustMkdirAll(t, filepath.Join(root, "catalog", "standalone", "app-shell"))
	mustMkdirAll(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team"))
	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "children"))
	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "tree"))
	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "tree"))
	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "children"))
	mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap"))
	mustMkdirAll(t, filepath.Join(root, "users", "personals"))

	mustWriteStructured(t, filepath.Join(root, testSettingsFileName), map[string]any{
		"installation": map[string]any{
			"id":             "installation-1",
			"name":           "MangoPig",
			"isBootstrapped": true,
		},
		"organization": map[string]any{
			"id":   "org-1",
			"name": "Primary Organization",
			"slug": "primary-organization",
		},
	})
	mustWriteStructured(t, filepath.Join(root, testLayoutFileName), map[string]any{
		"type": "tenant-layout",
		"home": map[string]any{"defaultProjectSlug": "primary-project"},
	})
	mustWriteStructured(t, filepath.Join(root, "catalog", "packs", "pack-core", testManifestFileName), map[string]any{
		"id":      "pack-core",
		"slug":    "core",
		"type":    "pack",
		"name":    "Core Pack",
		"entries": []map[string]any{{"slug": "app-shell", "path": "entries/app-shell"}},
	})
	mustWriteStructured(t, filepath.Join(root, "catalog", "packs", "pack-core", "entries", "app-shell", testManifestFileName), map[string]any{
		"id":   "app-shell",
		"slug": "app-shell",
		"type": "app",
		"runtime": map[string]any{
			"kind": "route",
			"path": "/v1/app-shell",
		},
	})
	mustWriteStructured(t, filepath.Join(root, "catalog", "standalone", "app-shell", testManifestFileName), map[string]any{
		"id":     "app-shell",
		"slug":   "app-shell",
		"type":   "app",
		"source": "standalone",
	})
	mustWriteStructured(t, filepath.Join(root, "departments", "department-primary-department", testSettingsFileName), map[string]any{
		"id":   "dept-1",
		"name": "Primary Department",
		"slug": "primary-department",
		"type": "department",
	})
	mustWriteStructured(t, filepath.Join(root, "departments", "department-primary-department", testUsersFileName), map[string]any{
		"users": []map[string]any{{"id": "admin-1"}},
	})
	mustWriteStructured(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team", testSettingsFileName), map[string]any{
		"id":   "team-1",
		"name": "Primary Team",
		"slug": "primary-team",
		"type": "team",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", testSettingsFileName), map[string]any{
		"id":   "project-1",
		"name": "Primary Project",
		"slug": "primary-project",
		"type": "project",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", testHomeFileName), map[string]any{
		"type":    "project-home",
		"project": "primary-project",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", testACLFileName), map[string]any{
		"inherits": true,
		"rules":    []any{},
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", testFolderFileName), map[string]any{
		"name": "Design",
		"slug": "design",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", testACLFileName), map[string]any{
		"inherits": true,
		"rules":    []any{},
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", testSettingsFileName), map[string]any{
		"id":   "project-2",
		"name": "Web Project",
		"slug": "web",
		"type": "project",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", testHomeFileName), map[string]any{
		"type":    "project-home",
		"project": "web",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", testACLFileName), map[string]any{
		"inherits": true,
		"rules":    []any{},
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", testFolderFileName), map[string]any{
		"name": "Docs",
		"slug": "docs",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testItemFileName), map[string]any{
		"id":   "item-1",
		"name": "Roadmap",
		"slug": "roadmap",
		"type": "board",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testSchemaFileName), map[string]any{
		"type": "object",
	})
	mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testDataFileName), map[string]any{
		"title": "Roadmap",
	})
	mustWriteStructured(t, filepath.Join(root, "users", testSettingsFileName), map[string]any{
		"primaryAdminId": "admin-1",
	})
	mustWriteStructured(t, filepath.Join(root, "users", testDataFileName), map[string]any{
		"users": []map[string]any{{"id": "admin-1", "email": "ronald@example.com"}},
	})

	nodes, err := ScanRoot(root)
	if err != nil {
		t.Fatalf("ScanRoot() error = %v", err)
	}

	index := make(map[string]Node, len(nodes))
	for _, node := range nodes {
		index[node.Path] = node
	}

	rootNode, ok := index[rootProjectionPath]
	if !ok {
		t.Fatalf("expected synthetic root node")
	}
	if rootNode.LogicalType != "tenant_root" {
		t.Fatalf("expected root logical type tenant_root, got %q", rootNode.LogicalType)
	}
	if rootNode.OrganizationSlug != "primary-organization" {
		t.Fatalf("expected root organization slug primary-organization, got %q", rootNode.OrganizationSlug)
	}

	tenantSettings := index[testSettingsFileName]
	if tenantSettings.LogicalType != "tenant" || tenantSettings.FileRole != "settings" {
		t.Fatalf("unexpected tenant settings classification: %#v", tenantSettings)
	}
	if tenantSettings.InstallationID != "installation-1" {
		t.Fatalf("expected installation id installation-1, got %q", tenantSettings.InstallationID)
	}

	packManifest := index[filepath.ToSlash(filepath.Join("catalog", "packs", "pack-core", testManifestFileName))]
	if packManifest.LogicalType != "catalog" || packManifest.FileRole != "manifest" {
		t.Fatalf("unexpected pack manifest classification: %#v", packManifest)
	}
	if packManifest.ResourceSlug != "core" {
		t.Fatalf("expected pack manifest resource slug core, got %q", packManifest.ResourceSlug)
	}

	entryManifest := index[filepath.ToSlash(filepath.Join("catalog", "packs", "pack-core", "entries", "app-shell", testManifestFileName))]
	if entryManifest.LogicalType != "catalog" || entryManifest.FileRole != "manifest" {
		t.Fatalf("unexpected catalog entry manifest classification: %#v", entryManifest)
	}
	if entryManifest.ResourceID != "app-shell" {
		t.Fatalf("expected catalog entry manifest resource id app-shell, got %q", entryManifest.ResourceID)
	}

	standaloneManifest := index[filepath.ToSlash(filepath.Join("catalog", "standalone", "app-shell", testManifestFileName))]
	if standaloneManifest.LogicalType != "catalog" || standaloneManifest.FileRole != "manifest" {
		t.Fatalf("unexpected standalone manifest classification: %#v", standaloneManifest)
	}
	if standaloneManifest.ResourceSlug != "app-shell" {
		t.Fatalf("expected standalone manifest resource slug app-shell, got %q", standaloneManifest.ResourceSlug)
	}

	deptSettings := index[filepath.ToSlash(filepath.Join("departments", "department-primary-department", testSettingsFileName))]
	if deptSettings.DepartmentSlug != "primary-department" {
		t.Fatalf("expected department slug primary-department, got %q", deptSettings.DepartmentSlug)
	}
	if deptSettings.ResourceID != "dept-1" {
		t.Fatalf("expected department resource id dept-1, got %q", deptSettings.ResourceID)
	}

	teamSettings := index[filepath.ToSlash(filepath.Join("departments", "department-primary-department", "teams", "team-primary-team", testSettingsFileName))]
	if teamSettings.TeamSlug != "primary-team" {
		t.Fatalf("expected team slug primary-team, got %q", teamSettings.TeamSlug)
	}

	projectSettings := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", testSettingsFileName))]
	if projectSettings.ProjectSlug != "primary-project" {
		t.Fatalf("expected project slug primary-project, got %q", projectSettings.ProjectSlug)
	}
	if projectSettings.ResourceName != "Primary Project" {
		t.Fatalf("expected project resource name Primary Project, got %q", projectSettings.ResourceName)
	}

	projectTree := index["projects/project-primary-project/tree"]
	if projectTree.LogicalType != "project_tree" || projectTree.NodeKind != NodeKindDirectory {
		t.Fatalf("unexpected project tree node: %#v", projectTree)
	}

	projectChildren := index["projects/project-primary-project/children"]
	if projectChildren.LogicalType != "project_children" || projectChildren.NodeKind != NodeKindDirectory {
		t.Fatalf("unexpected project children node: %#v", projectChildren)
	}

	hierarchyFolder := index["projects/project-primary-project/children/folder-design"]
	if hierarchyFolder.LogicalType != "hierarchy_folder" || hierarchyFolder.ProjectSlug != "primary-project" {
		t.Fatalf("unexpected hierarchy folder node: %#v", hierarchyFolder)
	}

	hierarchyFolderACL := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "children", "folder-design", testACLFileName))]
	if hierarchyFolderACL.LogicalType != "hierarchy_folder" || hierarchyFolderACL.FileRole != "acl" {
		t.Fatalf("unexpected hierarchy folder acl classification: %#v", hierarchyFolderACL)
	}

	childProjectSettings := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "children", "folder-design", "children", "project-web", testSettingsFileName))]
	if childProjectSettings.LogicalType != "project" || childProjectSettings.ProjectSlug != "web" {
		t.Fatalf("unexpected child project classification: %#v", childProjectSettings)
	}

	treeFolder := index["projects/project-primary-project/tree/folder-docs"]
	if treeFolder.LogicalType != "hierarchy_folder" || treeFolder.ProjectSlug != "primary-project" {
		t.Fatalf("unexpected tree folder node: %#v", treeFolder)
	}

	treeFolderACL := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "tree", "folder-docs", testFolderFileName))]
	if treeFolderACL.LogicalType != "hierarchy_folder" || treeFolderACL.FileRole != "folder" {
		t.Fatalf("unexpected tree folder file classification: %#v", treeFolderACL)
	}

	treeItem := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testItemFileName))]
	if treeItem.LogicalType != "item" || treeItem.FileRole != "item" {
		t.Fatalf("unexpected tree item classification: %#v", treeItem)
	}
	if treeItem.ResourceSlug != "roadmap" {
		t.Fatalf("expected tree item resource slug roadmap, got %#v", treeItem.ResourceSlug)
	}

	usersData := index[filepath.ToSlash(filepath.Join("users", testDataFileName))]
	if usersData.LogicalType != "users" || usersData.FileRole != "data" {
		t.Fatalf("unexpected users data classification: %#v", usersData)
	}
	if usersData.Checksum == "" || usersData.SizeBytes == 0 {
		t.Fatalf("expected users/%s checksum and size to be populated: %#v", testDataFileName, usersData)
	}
}

func mustMkdirAll(t *testing.T, path string) {
	t.Helper()
	if err := os.MkdirAll(path, 0o755); err != nil {
		t.Fatalf("MkdirAll(%q) error = %v", path, err)
	}
}

func mustWriteStructured(t *testing.T, path string, payload any) {
	t.Helper()
	var (
		bytes []byte
		err   error
	)
	switch filepath.Ext(path) {
	case ".cbor":
		bytes, err = cbor.Marshal(payload)
	case ".json":
		bytes, err = json.MarshalIndent(payload, "", "  ")
		if err == nil {
			bytes = append(bytes, '\n')
		}
	case ".jsonc":
		bytes, err = json.MarshalIndent(payload, "", "  ")
		if err == nil {
			bytes = append([]byte("// Fixture JSONC with comments and trailing commas enabled.\n"), bytes...)
			bytes = append(bytes[:len(bytes)-2], []byte(",\n}\n")...)
		}
	default:
		t.Fatalf("unsupported structured fixture file %q", path)
	}
	if err != nil {
		t.Fatalf("marshal %q error = %v", path, err)
	}
	if err := os.WriteFile(path, bytes, 0o644); err != nil {
		t.Fatalf("WriteFile(%q) error = %v", path, err)
	}
}