gitlink-cli/shortcuts/issue/batch_test.go

package issue

import (
	"encoding/json"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/gitlink-org/gitlink-cli/internal/output"
)

func TestParseIssueNumbers(t *testing.T) {
	got, err := parseIssueNumbers("1, 2,2, 3")
	if err != nil {
		t.Fatalf("parseIssueNumbers returned error: %v", err)
	}
	want := []string{"1", "2", "3"}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("parseIssueNumbers() = %#v, want %#v", got, want)
	}
}

func TestParseIssueNumbersRejectsInvalidNumber(t *testing.T) {
	if _, err := parseIssueNumbers("1,abc"); err == nil {
		t.Fatal("parseIssueNumbers() expected an error for a non-integer issue number")
	}
}

func TestReadIssueNumbersFromCSVWithHeader(t *testing.T) {
	path := writeTempCSV(t, "title,number,state\nfirst,12,open\nsecond,13,open\n")
	got, err := readIssueNumbersFromCSV(path)
	if err != nil {
		t.Fatalf("readIssueNumbersFromCSV returned error: %v", err)
	}
	want := []string{"12", "13"}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("readIssueNumbersFromCSV() = %#v, want %#v", got, want)
	}
}

func TestReadIssueNumbersFromCSVWithProjectIssuesIndexHeader(t *testing.T) {
	path := writeTempCSV(t, "title,project_issues_index,state\nfirst,12,open\nsecond,13,open\n")
	got, err := readIssueNumbersFromCSV(path)
	if err != nil {
		t.Fatalf("readIssueNumbersFromCSV returned error: %v", err)
	}
	want := []string{"12", "13"}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("readIssueNumbersFromCSV() = %#v, want %#v", got, want)
	}
}

func TestReadIssueNumbersFromCSVWithoutHeaderUsesFirstColumn(t *testing.T) {
	path := writeTempCSV(t, "21,open\n22,closed\n21,duplicate\n")
	got, err := readIssueNumbersFromCSV(path)
	if err != nil {
		t.Fatalf("readIssueNumbersFromCSV returned error: %v", err)
	}
	want := []string{"21", "22"}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("readIssueNumbersFromCSV() = %#v, want %#v", got, want)
	}
}

func TestCollectIssueNumbersMergesCLIAndCSV(t *testing.T) {
	path := writeTempCSV(t, "number\n2\n3\n")
	got, err := collectIssueNumbers("1,2", path)
	if err != nil {
		t.Fatalf("collectIssueNumbers returned error: %v", err)
	}
	want := []string{"1", "2", "3"}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("collectIssueNumbers() = %#v, want %#v", got, want)
	}
}

func TestParseBool(t *testing.T) {
	if !parseBool("true") {
		t.Fatal("parseBool(true) = false, want true")
	}
	if parseBool("") {
		t.Fatal("parseBool(empty) = true, want false")
	}
}

func TestIssueShortcutsExposeBatchCommands(t *testing.T) {
	names := map[string]bool{}
	for _, shortcut := range Shortcuts() {
		names[shortcut.Name] = true
	}
	for _, want := range []string{"batch-list", "batch-close", "batch-label"} {
		if !names[want] {
			t.Fatalf("Shortcuts missing %s", want)
		}
	}
}

func TestBatchListFiltersOlderThanDaysAndLabel(t *testing.T) {
	old := time.Now().AddDate(0, 0, -45).Format(time.RFC3339)
	fresh := time.Now().AddDate(0, 0, -3).Format(time.RFC3339)
	env := batchIssueEnvelope([]map[string]interface{}{
		{
			"project_issues_index": 1,
			"subject":              "stale bug",
			"status":               "open",
			"labels":               []interface{}{"bug", "stale"},
			"updated_at":           old,
		},
		{
			"project_issues_index": 2,
			"subject":              "fresh bug",
			"status":               "open",
			"labels":               []interface{}{"bug"},
			"updated_at":           fresh,
		},
		{
			"project_issues_index": 3,
			"subject":              "stale docs",
			"status":               "open",
			"labels":               []interface{}{"docs"},
			"updated_at":           old,
		},
	})

	got := normalizeBatchIssueCandidates(env, batchIssueOptions{
		State:         "open",
		Label:         "bug",
		OlderThanDays: 30,
		Limit:         50,
	})

	if len(got) != 1 || got[0].Number != 1 {
		t.Fatalf("filtered candidates = %#v, want only issue #1", got)
	}
}

func TestBatchListLimitTruncates(t *testing.T) {
	old := time.Now().AddDate(0, 0, -45).Format(time.RFC3339)
	env := batchIssueEnvelope([]map[string]interface{}{
		{"project_issues_index": 1, "subject": "one", "status": "open", "updated_at": old},
		{"project_issues_index": 2, "subject": "two", "status": "open", "updated_at": old},
	})
	candidates := normalizeBatchIssueCandidates(env, batchIssueOptions{State: "open", OlderThanDays: 30, Limit: 1})
	if len(candidates) > 1 {
		candidates = candidates[:1]
	}
	if len(candidates) != 1 || candidates[0].Number != 1 {
		t.Fatalf("limited candidates = %#v, want first issue only", candidates)
	}
}

func TestBatchCandidateMissingUpdatedAtDoesNotPanic(t *testing.T) {
	env := batchIssueEnvelope([]map[string]interface{}{
		{"project_issues_index": 1, "subject": "missing update", "status": "open"},
	})
	got := normalizeBatchIssueCandidates(env, batchIssueOptions{State: "open", Limit: 50})
	if len(got) != 1 || got[0].DaysInactive != 0 {
		t.Fatalf("candidate = %#v, want one candidate with zero inactive days", got)
	}
}

func TestBatchCloseSafetyValidation(t *testing.T) {
	err := validateBatchCloseOptions(batchIssueOptions{Limit: 20})
	if err == nil {
		t.Fatal("validateBatchCloseOptions returned nil without older-than-days")
	}
	err = validateBatchCloseOptions(batchIssueOptions{OlderThanDays: 3, Limit: 20})
	if err == nil {
		t.Fatal("validateBatchCloseOptions returned nil for unsafe older-than-days")
	}
}

func TestBatchCloseDefaultDryRunResult(t *testing.T) {
	result := BatchIssueResult{
		Owner:      "owner",
		Repo:       "repo",
		DryRun:     true,
		Action:     "close",
		Total:      1,
		Success:    1,
		Candidates: []BatchIssueCandidate{{Number: 1, State: "open", Title: "old issue"}},
	}
	rendered, err := renderBatchIssueResultString(result, "table")
	if err != nil {
		t.Fatalf("renderBatchIssueResultString returned error: %v", err)
	}
	if !strings.Contains(rendered, "DRY-RUN") || !strings.Contains(rendered, "old issue") {
		t.Fatalf("table output = %q, want dry-run and issue title", rendered)
	}
}

func TestBatchLabelRequiresAddLabel(t *testing.T) {
	if err := validateBatchLabelOptions(batchIssueOptions{OlderThanDays: 30}); err == nil {
		t.Fatal("validateBatchLabelOptions returned nil without --add-label")
	}
}

func TestBatchJSONRenderCanUnmarshal(t *testing.T) {
	result := BatchIssueResult{
		Owner:      "owner",
		Repo:       "repo",
		DryRun:     true,
		Action:     "list",
		Total:      1,
		Success:    1,
		Candidates: []BatchIssueCandidate{{Number: 1, State: "open", Title: "old issue"}},
	}
	rendered, err := renderBatchIssueResultString(result, "json")
	if err != nil {
		t.Fatalf("renderBatchIssueResultString returned error: %v", err)
	}
	var decoded BatchIssueResult
	if err := json.Unmarshal([]byte(rendered), &decoded); err != nil {
		t.Fatalf("json.Unmarshal returned error: %v\noutput=%s", err, rendered)
	}
	if decoded.Total != 1 || decoded.Candidates[0].Number != 1 {
		t.Fatalf("decoded result = %#v, want one candidate", decoded)
	}
}

func TestBatchWriteFailureRecordsError(t *testing.T) {
	result := BatchIssueResult{
		Owner:      "owner",
		Repo:       "repo",
		DryRun:     false,
		Action:     "close",
		Total:      1,
		Failed:     1,
		Candidates: []BatchIssueCandidate{{Number: 1, State: "open", Title: "old issue"}},
		Errors:     []string{"#1: close issue: HTTP 500"},
	}
	rendered, err := renderBatchIssueResultString(result, "table")
	if err != nil {
		t.Fatalf("renderBatchIssueResultString returned error: %v", err)
	}
	if !strings.Contains(rendered, "FAILED=1") || !strings.Contains(rendered, "HTTP 500") {
		t.Fatalf("table output = %q, want failure summary and error", rendered)
	}
}

func batchIssueEnvelope(issues []map[string]interface{}) *output.Envelope {
	items := make([]interface{}, 0, len(issues))
	for _, issue := range issues {
		items = append(items, issue)
	}
	return output.SuccessEnvelope(map[string]interface{}{"issues": items}, nil)
}

func writeTempCSV(t *testing.T, content string) string {
	t.Helper()
	path := filepath.Join(t.TempDir(), "issues.csv")
	if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
		t.Fatalf("write temp csv: %v", err)
	}
	return path
}