cleanup

cmd/bd/create_form_test.go

@@ -0,0 +1,599 @@
+package main
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/steveyegge/beads/internal/types"
+)
+
+func TestParseFormInput(t *testing.T) {
+	t.Run("BasicParsing", func(t *testing.T) {
+		fv := parseCreateFormInput(&createFormRawInput{
+			Title:       "Test Title",
+			Description: "Test Description",
+			IssueType:   "bug",
+			Priority:    "1",
+			Assignee:    "alice",
+		})
+
+		if fv.Title != "Test Title" {
+			t.Errorf("expected title 'Test Title', got %q", fv.Title)
+		}
+		if fv.Description != "Test Description" {
+			t.Errorf("expected description 'Test Description', got %q", fv.Description)
+		}
+		if fv.IssueType != "bug" {
+			t.Errorf("expected issue type 'bug', got %q", fv.IssueType)
+		}
+		if fv.Priority != 1 {
+			t.Errorf("expected priority 1, got %d", fv.Priority)
+		}
+		if fv.Assignee != "alice" {
+			t.Errorf("expected assignee 'alice', got %q", fv.Assignee)
+		}
+	})
+
+	t.Run("PriorityParsing", func(t *testing.T) {
+		// Valid priority
+		fv := parseCreateFormInput(&createFormRawInput{Title: "Title", IssueType: "task", Priority: "0"})
+		if fv.Priority != 0 {
+			t.Errorf("expected priority 0, got %d", fv.Priority)
+		}
+
+		// Invalid priority defaults to 2
+		fv = parseCreateFormInput(&createFormRawInput{Title: "Title", IssueType: "task", Priority: "invalid"})
+		if fv.Priority != 2 {
+			t.Errorf("expected default priority 2 for invalid input, got %d", fv.Priority)
+		}
+
+		// Empty priority defaults to 2
+		fv = parseCreateFormInput(&createFormRawInput{Title: "Title", IssueType: "task", Priority: ""})
+		if fv.Priority != 2 {
+			t.Errorf("expected default priority 2 for empty input, got %d", fv.Priority)
+		}
+	})
+
+	t.Run("LabelsParsing", func(t *testing.T) {
+		fv := parseCreateFormInput(&createFormRawInput{
+			Title:     "Title",
+			IssueType: "task",
+			Priority:  "2",
+			Labels:    "bug, critical, needs-review",
+		})
+
+		if len(fv.Labels) != 3 {
+			t.Fatalf("expected 3 labels, got %d", len(fv.Labels))
+		}
+
+		expected := []string{"bug", "critical", "needs-review"}
+		for i, label := range expected {
+			if fv.Labels[i] != label {
+				t.Errorf("expected label %q at index %d, got %q", label, i, fv.Labels[i])
+			}
+		}
+	})
+
+	t.Run("LabelsWithEmptyValues", func(t *testing.T) {
+		fv := parseCreateFormInput(&createFormRawInput{
+			Title:     "Title",
+			IssueType: "task",
+			Priority:  "2",
+			Labels:    "bug, , critical, ",
+		})
+
+		if len(fv.Labels) != 2 {
+			t.Fatalf("expected 2 non-empty labels, got %d: %v", len(fv.Labels), fv.Labels)
+		}
+	})
+
+	t.Run("DependenciesParsing", func(t *testing.T) {
+		fv := parseCreateFormInput(&createFormRawInput{
+			Title:     "Title",
+			IssueType: "task",
+			Priority:  "2",
+			Deps:      "discovered-from:bd-20, blocks:bd-15",
+		})
+
+		if len(fv.Dependencies) != 2 {
+			t.Fatalf("expected 2 dependencies, got %d", len(fv.Dependencies))
+		}
+
+		expected := []string{"discovered-from:bd-20", "blocks:bd-15"}
+		for i, dep := range expected {
+			if fv.Dependencies[i] != dep {
+				t.Errorf("expected dependency %q at index %d, got %q", dep, i, fv.Dependencies[i])
+			}
+		}
+	})
+
+	t.Run("AllFields", func(t *testing.T) {
+		fv := parseCreateFormInput(&createFormRawInput{
+			Title:       "Full Issue",
+			Description: "Detailed description",
+			IssueType:   "feature",
+			Priority:    "1",
+			Assignee:    "bob",
+			Labels:      "frontend, urgent",
+			Design:      "Use React hooks",
+			Acceptance:  "Tests pass, UI works",
+			ExternalRef: "gh-123",
+			Deps:        "blocks:bd-1",
+		})
+
+		if fv.Title != "Full Issue" {
+			t.Errorf("unexpected title: %q", fv.Title)
+		}
+		if fv.Description != "Detailed description" {
+			t.Errorf("unexpected description: %q", fv.Description)
+		}
+		if fv.IssueType != "feature" {
+			t.Errorf("unexpected issue type: %q", fv.IssueType)
+		}
+		if fv.Priority != 1 {
+			t.Errorf("unexpected priority: %d", fv.Priority)
+		}
+		if fv.Assignee != "bob" {
+			t.Errorf("unexpected assignee: %q", fv.Assignee)
+		}
+		if len(fv.Labels) != 2 {
+			t.Errorf("unexpected labels count: %d", len(fv.Labels))
+		}
+		if fv.Design != "Use React hooks" {
+			t.Errorf("unexpected design: %q", fv.Design)
+		}
+		if fv.AcceptanceCriteria != "Tests pass, UI works" {
+			t.Errorf("unexpected acceptance criteria: %q", fv.AcceptanceCriteria)
+		}
+		if fv.ExternalRef != "gh-123" {
+			t.Errorf("unexpected external ref: %q", fv.ExternalRef)
+		}
+		if len(fv.Dependencies) != 1 {
+			t.Errorf("unexpected dependencies count: %d", len(fv.Dependencies))
+		}
+	})
+}
+
+func TestCreateIssueFromFormValues(t *testing.T) {
+	tmpDir := t.TempDir()
+	testDB := filepath.Join(tmpDir, ".beads", "beads.db")
+	s := newTestStore(t, testDB)
+	ctx := context.Background()
+
+	t.Run("BasicIssue", func(t *testing.T) {
+		fv := &createFormValues{
+			Title:     "Test Form Issue",
+			Priority:  1,
+			IssueType: "bug",
+		}
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		if issue.Title != "Test Form Issue" {
+			t.Errorf("expected title 'Test Form Issue', got %q", issue.Title)
+		}
+		if issue.Priority != 1 {
+			t.Errorf("expected priority 1, got %d", issue.Priority)
+		}
+		if issue.IssueType != types.TypeBug {
+			t.Errorf("expected type bug, got %s", issue.IssueType)
+		}
+		if issue.Status != types.StatusOpen {
+			t.Errorf("expected status open, got %s", issue.Status)
+		}
+	})
+
+	t.Run("WithDescription", func(t *testing.T) {
+		fv := &createFormValues{
+			Title:       "Issue with description",
+			Description: "This is a detailed description",
+			Priority:    2,
+			IssueType:   "task",
+		}
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		if issue.Description != "This is a detailed description" {
+			t.Errorf("expected description, got %q", issue.Description)
+		}
+	})
+
+	t.Run("WithDesignAndAcceptance", func(t *testing.T) {
+		fv := &createFormValues{
+			Title:              "Feature with design",
+			Design:             "Use MVC pattern",
+			AcceptanceCriteria: "All tests pass",
+			IssueType:          "feature",
+			Priority:           2,
+		}
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		if issue.Design != "Use MVC pattern" {
+			t.Errorf("expected design, got %q", issue.Design)
+		}
+		if issue.AcceptanceCriteria != "All tests pass" {
+			t.Errorf("expected acceptance criteria, got %q", issue.AcceptanceCriteria)
+		}
+	})
+
+	t.Run("WithAssignee", func(t *testing.T) {
+		fv := &createFormValues{
+			Title:     "Assigned issue",
+			Assignee:  "alice",
+			Priority:  1,
+			IssueType: "task",
+		}
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		if issue.Assignee != "alice" {
+			t.Errorf("expected assignee 'alice', got %q", issue.Assignee)
+		}
+	})
+
+	t.Run("WithExternalRef", func(t *testing.T) {
+		fv := &createFormValues{
+			Title:       "Issue with external ref",
+			ExternalRef: "gh-123",
+			Priority:    2,
+			IssueType:   "bug",
+		}
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		if issue.ExternalRef == nil {
+			t.Fatal("expected external ref to be set")
+		}
+		if *issue.ExternalRef != "gh-123" {
+			t.Errorf("expected external ref 'gh-123', got %q", *issue.ExternalRef)
+		}
+	})
+
+	t.Run("WithLabels", func(t *testing.T) {
+		fv := &createFormValues{
+			Title:     "Issue with labels",
+			Priority:  0,
+			IssueType: "bug",
+			Labels:    []string{"bug", "critical"},
+		}
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		labels, err := s.GetLabels(ctx, issue.ID)
+		if err != nil {
+			t.Fatalf("failed to get labels: %v", err)
+		}
+
+		if len(labels) != 2 {
+			t.Errorf("expected 2 labels, got %d", len(labels))
+		}
+
+		labelMap := make(map[string]bool)
+		for _, l := range labels {
+			labelMap[l] = true
+		}
+
+		if !labelMap["bug"] || !labelMap["critical"] {
+			t.Errorf("expected labels 'bug' and 'critical', got %v", labels)
+		}
+	})
+
+	t.Run("WithDependencies", func(t *testing.T) {
+		// Create a parent issue first
+		parentFv := &createFormValues{
+			Title:     "Parent issue for deps",
+			Priority:  1,
+			IssueType: "task",
+		}
+		parent, err := CreateIssueFromFormValues(ctx, s, parentFv, "test")
+		if err != nil {
+			t.Fatalf("failed to create parent: %v", err)
+		}
+
+		// Create child with dependency
+		childFv := &createFormValues{
+			Title:        "Child issue",
+			Priority:     1,
+			IssueType:    "task",
+			Dependencies: []string{parent.ID}, // Default blocks type
+		}
+		child, err := CreateIssueFromFormValues(ctx, s, childFv, "test")
+		if err != nil {
+			t.Fatalf("failed to create child: %v", err)
+		}
+
+		deps, err := s.GetDependencies(ctx, child.ID)
+		if err != nil {
+			t.Fatalf("failed to get dependencies: %v", err)
+		}
+
+		if len(deps) == 0 {
+			t.Fatal("expected at least 1 dependency, got 0")
+		}
+
+		found := false
+		for _, d := range deps {
+			if d.ID == parent.ID {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			t.Errorf("expected dependency on %s, not found", parent.ID)
+		}
+	})
+
+	t.Run("WithTypedDependencies", func(t *testing.T) {
+		// Create a parent issue
+		parentFv := &createFormValues{
+			Title:     "Related parent",
+			Priority:  1,
+			IssueType: "task",
+		}
+		parent, err := CreateIssueFromFormValues(ctx, s, parentFv, "test")
+		if err != nil {
+			t.Fatalf("failed to create parent: %v", err)
+		}
+
+		// Create child with typed dependency
+		childFv := &createFormValues{
+			Title:        "Child with typed dep",
+			Priority:     1,
+			IssueType:    "bug",
+			Dependencies: []string{"discovered-from:" + parent.ID},
+		}
+		child, err := CreateIssueFromFormValues(ctx, s, childFv, "test")
+		if err != nil {
+			t.Fatalf("failed to create child: %v", err)
+		}
+
+		deps, err := s.GetDependencies(ctx, child.ID)
+		if err != nil {
+			t.Fatalf("failed to get dependencies: %v", err)
+		}
+
+		if len(deps) == 0 {
+			t.Fatal("expected at least 1 dependency, got 0")
+		}
+
+		found := false
+		for _, d := range deps {
+			if d.ID == parent.ID {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			t.Errorf("expected dependency on %s, not found", parent.ID)
+		}
+	})
+
+	t.Run("AllIssueTypes", func(t *testing.T) {
+		issueTypes := []string{"bug", "feature", "task", "epic", "chore"}
+		expectedTypes := []types.IssueType{
+			types.TypeBug,
+			types.TypeFeature,
+			types.TypeTask,
+			types.TypeEpic,
+			types.TypeChore,
+		}
+
+		for i, issueType := range issueTypes {
+			fv := &createFormValues{
+				Title:     "Test " + issueType,
+				IssueType: issueType,
+				Priority:  2,
+			}
+
+			issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+			if err != nil {
+				t.Fatalf("failed to create issue type %s: %v", issueType, err)
+			}
+
+			if issue.IssueType != expectedTypes[i] {
+				t.Errorf("expected type %s, got %s", expectedTypes[i], issue.IssueType)
+			}
+		}
+	})
+
+	t.Run("MultipleDependencies", func(t *testing.T) {
+		// Create two parent issues
+		parent1Fv := &createFormValues{
+			Title:     "Multi-dep Parent 1",
+			Priority:  1,
+			IssueType: "task",
+		}
+		parent1, err := CreateIssueFromFormValues(ctx, s, parent1Fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create parent1: %v", err)
+		}
+
+		parent2Fv := &createFormValues{
+			Title:     "Multi-dep Parent 2",
+			Priority:  1,
+			IssueType: "task",
+		}
+		parent2, err := CreateIssueFromFormValues(ctx, s, parent2Fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create parent2: %v", err)
+		}
+
+		// Create child with multiple dependencies
+		childFv := &createFormValues{
+			Title:        "Multi-dep Child",
+			Priority:     1,
+			IssueType:    "task",
+			Dependencies: []string{"blocks:" + parent1.ID, "related:" + parent2.ID},
+		}
+		child, err := CreateIssueFromFormValues(ctx, s, childFv, "test")
+		if err != nil {
+			t.Fatalf("failed to create child: %v", err)
+		}
+
+		deps, err := s.GetDependencies(ctx, child.ID)
+		if err != nil {
+			t.Fatalf("failed to get dependencies: %v", err)
+		}
+
+		if len(deps) < 2 {
+			t.Fatalf("expected at least 2 dependencies, got %d", len(deps))
+		}
+
+		foundParents := make(map[string]bool)
+		for _, d := range deps {
+			if d.ID == parent1.ID || d.ID == parent2.ID {
+				foundParents[d.ID] = true
+			}
+		}
+
+		if len(foundParents) != 2 {
+			t.Errorf("expected to find both parent dependencies, found %d", len(foundParents))
+		}
+	})
+
+	t.Run("DiscoveredFromInheritsSourceRepo", func(t *testing.T) {
+		// Create a parent issue with a custom source_repo
+		parent := &types.Issue{
+			Title:      "Parent with source repo",
+			Priority:   1,
+			Status:     types.StatusOpen,
+			IssueType:  types.TypeTask,
+			SourceRepo: "/path/to/custom/repo",
+		}
+
+		if err := s.CreateIssue(ctx, parent, "test"); err != nil {
+			t.Fatalf("failed to create parent: %v", err)
+		}
+
+		// Create a discovered issue with discovered-from dependency
+		childFv := &createFormValues{
+			Title:        "Discovered bug",
+			Priority:     1,
+			IssueType:    "bug",
+			Dependencies: []string{"discovered-from:" + parent.ID},
+		}
+		child, err := CreateIssueFromFormValues(ctx, s, childFv, "test")
+		if err != nil {
+			t.Fatalf("failed to create discovered issue: %v", err)
+		}
+
+		// Verify the discovered issue inherited the source_repo
+		retrievedIssue, err := s.GetIssue(ctx, child.ID)
+		if err != nil {
+			t.Fatalf("failed to get discovered issue: %v", err)
+		}
+
+		if retrievedIssue.SourceRepo != parent.SourceRepo {
+			t.Errorf("expected source_repo %q, got %q", parent.SourceRepo, retrievedIssue.SourceRepo)
+		}
+	})
+
+	t.Run("AllPriorities", func(t *testing.T) {
+		for priority := 0; priority <= 4; priority++ {
+			fv := &createFormValues{
+				Title:     "Priority test",
+				IssueType: "task",
+				Priority:  priority,
+			}
+
+			issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+			if err != nil {
+				t.Fatalf("failed to create issue with priority %d: %v", priority, err)
+			}
+
+			if issue.Priority != priority {
+				t.Errorf("expected priority %d, got %d", priority, issue.Priority)
+			}
+		}
+	})
+}
+
+func TestFormValuesIntegration(t *testing.T) {
+	// Test the full flow: parseCreateFormInput -> CreateIssueFromFormValues
+	tmpDir := t.TempDir()
+	testDB := filepath.Join(tmpDir, ".beads", "beads.db")
+	s := newTestStore(t, testDB)
+	ctx := context.Background()
+
+	t.Run("FullFlow", func(t *testing.T) {
+		// Simulate form input
+		fv := parseCreateFormInput(&createFormRawInput{
+			Title:       "Integration Test Issue",
+			Description: "Testing the full flow from form to storage",
+			IssueType:   "feature",
+			Priority:    "1",
+			Assignee:    "test-user",
+			Labels:      "integration, test",
+			Design:      "Design notes here",
+			Acceptance:  "Should work end to end",
+			ExternalRef: "gh-999",
+		})
+
+		issue, err := CreateIssueFromFormValues(ctx, s, fv, "test")
+		if err != nil {
+			t.Fatalf("failed to create issue: %v", err)
+		}
+
+		// Verify issue was stored
+		retrieved, err := s.GetIssue(ctx, issue.ID)
+		if err != nil {
+			t.Fatalf("failed to retrieve issue: %v", err)
+		}
+
+		if retrieved.Title != "Integration Test Issue" {
+			t.Errorf("unexpected title: %q", retrieved.Title)
+		}
+		if retrieved.Description != "Testing the full flow from form to storage" {
+			t.Errorf("unexpected description: %q", retrieved.Description)
+		}
+		if retrieved.IssueType != types.TypeFeature {
+			t.Errorf("unexpected type: %s", retrieved.IssueType)
+		}
+		if retrieved.Priority != 1 {
+			t.Errorf("unexpected priority: %d", retrieved.Priority)
+		}
+		if retrieved.Assignee != "test-user" {
+			t.Errorf("unexpected assignee: %q", retrieved.Assignee)
+		}
+		if retrieved.Design != "Design notes here" {
+			t.Errorf("unexpected design: %q", retrieved.Design)
+		}
+		if retrieved.AcceptanceCriteria != "Should work end to end" {
+			t.Errorf("unexpected acceptance criteria: %q", retrieved.AcceptanceCriteria)
+		}
+		if retrieved.ExternalRef == nil || *retrieved.ExternalRef != "gh-999" {
+			t.Errorf("unexpected external ref: %v", retrieved.ExternalRef)
+		}
+
+		// Check labels
+		labels, err := s.GetLabels(ctx, issue.ID)
+		if err != nil {
+			t.Fatalf("failed to get labels: %v", err)
+		}
+		if len(labels) != 2 {
+			t.Errorf("expected 2 labels, got %d", len(labels))
+		}
+	})
+}