task-master/internal/server/seed_test.go

package server

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

	"task/internal/project"
	"task/internal/sqlite"
)

func TestSeedDemo(t *testing.T) {
	db, err := sqlite.Open(filepath.Join(t.TempDir(), "seed.db"), []byte("s"))
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()
	if _, err := db.CreateUser("admin", "admin", true); err != nil {
		t.Fatal(err)
	}
	srv := New(db)
	if err := srv.SeedDemo(SeedDemoOptions{}); err != nil {
		t.Fatal(err)
	}
	projects, err := srv.Projects.List()
	if err != nil || len(projects) != 50 {
		t.Fatalf("want 50 projects, got %d err=%v", len(projects), err)
	}
	var testID string
	for _, p := range projects {
		if p.Name == "Test" {
			testID = p.ID
			break
		}
	}
	if testID == "" {
		t.Fatal("missing Test project")
	}
	groups, err := db.ListProjectGroups()
	if err != nil || len(groups) != 2 {
		t.Fatalf("want 2 groups, got %d err=%v", len(groups), err)
	}
	p, err := srv.Projects.Get(testID)
	if err != nil || p.GroupID == "" {
		t.Fatalf("Test project should be grouped, got %+v err=%v", p, err)
	}
	sync, err := srv.Projects.GetSyncBackend(testID)
	if err != nil || sync.Kind != "none" {
		t.Fatalf("sync=%+v err=%v", sync, err)
	}
	tickets, err := srv.Tickets.List(testID)
	if err != nil || len(tickets) == 0 {
		t.Fatalf("tickets empty")
	}
	conns, err := db.ListConnections()
	if err != nil || len(conns) != 0 {
		t.Fatalf("expected no remote connections, got %v", conns)
	}
	// idempotent when projects already exist
	if err := srv.SeedDemo(SeedDemoOptions{}); err != nil {
		t.Fatal(err)
	}
	projects2, _ := srv.Projects.List()
	if len(projects2) != len(projects) {
		t.Fatalf("re-seed changed project count")
	}
}

func TestSeedDemoWiresTUI(t *testing.T) {
	home := t.TempDir()
	t.Setenv("TASK_MASTER_HOME", home)
	dataDir := filepath.Join(home, ".local", "share", "task-master")
	if err := os.MkdirAll(dataDir, 0o755); err != nil {
		t.Fatal(err)
	}

	db, err := sqlite.Open(filepath.Join(dataDir, "seed.db"), []byte("s"))
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()
	if _, err := db.CreateUser("admin", "admin", true); err != nil {
		t.Fatal(err)
	}
	srv := New(db)
	if err := srv.SeedDemo(SeedDemoOptions{
		ClientDataDir: dataDir,
		BaseURL:       "http://127.0.0.1:8080",
	}); err != nil {
		t.Fatal(err)
	}

	store := project.NewDirStore(dataDir)
	for _, name := range tuiSeedProjects {
		meta, err := store.LoadMeta(name)
		if err != nil {
			t.Fatalf("LoadMeta %s: %v", name, err)
		}
		if meta.EffectiveBackend() != project.BackendTaskMaster {
			t.Fatalf("%s backend=%q", name, meta.EffectiveBackend())
		}
		if meta.TaskMaster == nil || !meta.TaskMaster.Configured() {
			t.Fatalf("%s taskmaster not configured: %+v", name, meta.TaskMaster)
		}
		if meta.TaskMaster.BaseURL != "http://127.0.0.1:8080" {
			t.Fatalf("baseURL=%q", meta.TaskMaster.BaseURL)
		}
		auth, err := db.ResolveBearerToken(meta.TaskMaster.Token)
		if err != nil {
			t.Fatalf("token resolve %s: %v", name, err)
		}
		if auth.ProjectID != meta.TaskMaster.ProjectID {
			t.Fatalf("token project mismatch")
		}
		if !sqlite.TokenAllows(auth.Scope, sqlite.TokenScopeWrite) {
			t.Fatalf("want write scope, got %q", auth.Scope)
		}
		tokens, err := db.ListProjectTokens(meta.TaskMaster.ProjectID)
		if err != nil || len(tokens) != 1 || tokens[0].Name != "dev-tui" {
			t.Fatalf("tokens=%v err=%v", tokens, err)
		}
	}
}

func TestSeedBaseURL(t *testing.T) {
	t.Setenv("TM_SEED_BASE_URL", "")
	if got := SeedBaseURL(":8080"); got != "http://127.0.0.1:8080" {
		t.Fatalf("got %q", got)
	}
	if got := SeedBaseURL("0.0.0.0:9000"); got != "http://0.0.0.0:9000" {
		t.Fatalf("got %q", got)
	}
	t.Setenv("TM_SEED_BASE_URL", "http://localhost:8080/")
	if got := SeedBaseURL(":9999"); got != "http://localhost:8080" {
		t.Fatalf("env override got %q", got)
	}
}