gitlink-cli/shortcuts/workflow/engine/engine_test.go

package engine

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gitlink-org/gitlink-cli/internal/client"
	"github.com/gitlink-org/gitlink-cli/internal/output"
	"github.com/gitlink-org/gitlink-cli/shortcuts/common"
	wf "github.com/gitlink-org/gitlink-cli/shortcuts/workflow"
)

func TestRunWithAPISteps(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == "GET" && r.URL.Path == "/v1/owner/repo/issues.json":
			writeJSON(t, w, output.SuccessEnvelope([]map[string]interface{}{
				{"id": 1, "subject": "bug"},
				{"id": 2, "subject": "feature"},
			}, nil))
		case r.Method == "GET" && r.URL.Path == "/v1/owner/repo/labels.json":
			writeJSON(t, w, output.SuccessEnvelope([]map[string]interface{}{
				{"id": 10, "name": "bug"},
				{"id": 11, "name": "enhancement"},
			}, nil))
		default:
			t.Fatalf("unexpected request: %s %s", r.Method, r.URL.Path)
		}
	}))
	defer server.Close()

	ctx := newTestContext(t, server)
	wfDef := &wf.WorkflowDef{
		Name: "test-api",
		Steps: []wf.StepDef{
			{Type: wf.StepTypeAPI, Name: "fetch-issues", Purpose: "get issues", Method: "GET", Target: "{v1}/issues"},
			{Type: wf.StepTypeAPI, Name: "fetch-labels", Purpose: "get labels", Method: "GET", Target: "{v1}/labels"},
		},
	}

	result, err := Run(ctx, wfDef, false)
	if err != nil {
		t.Fatalf("Run() failed: %v", err)
	}
	if result.Owner != "owner" || result.Repo != "repo" {
		t.Fatalf("expected owner/repo = owner/repo, got %s/%s", result.Owner, result.Repo)
	}
	if len(result.Steps) != 2 {
		t.Fatalf("expected 2 step results, got %d", len(result.Steps))
	}
	for _, sr := range result.Steps {
		if !sr.OK {
			t.Fatalf("step %q: expected ok=true, got error=%q", sr.Step, sr.Error)
		}
	}
}

func TestSkillStepReceivesUpstream(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/v1/owner/repo/issues.json" {
			writeJSON(t, w, output.SuccessEnvelope(map[string]interface{}{
				"issues": []map[string]interface{}{{"id": 1}},
			}, nil))
		} else if r.URL.Path == "/v1/owner/repo/labels.json" {
			writeJSON(t, w, output.SuccessEnvelope(map[string]interface{}{
				"labels": []map[string]interface{}{{"name": "bug"}},
			}, nil))
		} else {
			t.Fatalf("unexpected request: %s %s", r.Method, r.URL.Path)
		}
	}))
	defer server.Close()

	ctx := newTestContext(t, server)
	wfDef := &wf.WorkflowDef{
		Name: "test-skill-upstream",
		Steps: []wf.StepDef{
			{Type: wf.StepTypeAPI, Name: "get-issues", Purpose: "issues", Method: "GET", Target: "{v1}/issues"},
			{Type: wf.StepTypeAPI, Name: "get-labels", Purpose: "labels", Method: "GET", Target: "{v1}/labels"},
			{Type: wf.StepTypeSkill, Name: "ai-triage", Purpose: "triage", Target: "gitlink-triage"},
		},
	}

	result, err := Run(ctx, wfDef, true) // dry-run to test upstream without AI
	if err != nil {
		t.Fatalf("Run() failed: %v", err)
	}

	skillData, ok := result.Steps[2].Data.(map[string]interface{})
	if !ok {
		t.Fatal("skill step data is not a map")
	}
	if v, _ := skillData["_dry_run"]; v != true {
		t.Fatal("skill step should have _dry_run=true")
	}
	upstream, ok := skillData["_upstream"].(map[string]interface{})
	if !ok {
		t.Fatal("skill step missing _upstream map")
	}
	if _, hasIssues := upstream["get-issues"]; !hasIssues {
		t.Fatal("_upstream missing get-issues key")
	}
	if _, hasLabels := upstream["get-labels"]; !hasLabels {
		t.Fatal("_upstream missing get-labels key")
	}
	if skillData["_skill"] != "gitlink-triage" {
		t.Fatalf("_skill = %q, want %q", skillData["_skill"], "gitlink-triage")
	}
}

func TestSkillStepWithDependsOn(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		writeJSON(t, w, output.SuccessEnvelope(map[string]interface{}{"ok": true}, nil))
	}))
	defer server.Close()

	ctx := newTestContext(t, server)
	wfDef := &wf.WorkflowDef{
		Name: "test-depends-on",
		Steps: []wf.StepDef{
			{Type: wf.StepTypeAPI, Name: "open-issues", Purpose: "issues", Method: "GET", Target: "{v1}/issues"},
			{Type: wf.StepTypeAPI, Name: "labels", Purpose: "labels", Method: "GET", Target: "{v1}/labels"},
			{Type: wf.StepTypeAPI, Name: "members", Purpose: "members", Method: "GET", Target: "{v1}/members"},
			{Type: wf.StepTypeSkill, Name: "triage", Purpose: "triage", Target: "gitlink-triage",
				DependsOn: []string{"open-issues", "labels"}},
		},
	}

	result, err := Run(ctx, wfDef, true) // dry-run to test DependsOn filter without AI
	if err != nil {
		t.Fatalf("Run() failed: %v", err)
	}

	skillData, ok := result.Steps[3].Data.(map[string]interface{})
	if !ok {
		t.Fatal("skill step data is not a map")
	}
	upstream, ok := skillData["_upstream"].(map[string]interface{})
	if !ok {
		t.Fatal("skill step missing _upstream map")
	}
	if _, hasIssues := upstream["open-issues"]; !hasIssues {
		t.Fatal("_upstream missing open-issues key")
	}
	if _, hasLabels := upstream["labels"]; !hasLabels {
		t.Fatal("_upstream missing labels key")
	}
	if _, hasMembers := upstream["members"]; hasMembers {
		t.Fatal("_upstream should NOT contain members (not in DependsOn)")
	}
}

func TestRunStepFailure(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(500)
		writeJSON(t, w, map[string]interface{}{
			"ok": false, "error": "internal server error",
		})
	}))
	defer server.Close()

	ctx := newTestContext(t, server)
	wfDef := &wf.WorkflowDef{
		Name: "test-fail",
		Steps: []wf.StepDef{
			{Type: wf.StepTypeAPI, Name: "bad-step", Purpose: "will fail", Method: "GET", Target: "{v1}/bad"},
		},
	}

	result, err := Run(ctx, wfDef, false)
	if err != nil {
		t.Fatalf("Run() returned error: %v (steps should fail gracefully)", err)
	}
	if result.Steps[0].OK {
		t.Fatal("expected step to fail, but it passed")
	}
}

func TestRunUnknownStepType(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		t.Fatalf("no request expected")
	}))
	defer server.Close()

	ctx := newTestContext(t, server)
	wfDef := &wf.WorkflowDef{
		Name: "test-unknown",
		Steps: []wf.StepDef{
			{Type: wf.StepType("invalid"), Name: "bad", Purpose: "unknown", Target: "x"},
		},
	}

	result, err := Run(ctx, wfDef, false)
	if err != nil {
		t.Fatalf("Run() returned error: %v", err)
	}
	if result.Steps[0].OK {
		t.Fatal("unknown step type should fail")
	}
}

func TestSkillStepDryRun(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		writeJSON(t, w, output.SuccessEnvelope(map[string]interface{}{"ok": true}, nil))
	}))
	defer server.Close()

	ctx := newTestContext(t, server)
	wfDef := &wf.WorkflowDef{
		Name: "test-dry-run",
		Steps: []wf.StepDef{
			{Type: wf.StepTypeAPI, Name: "get-data", Purpose: "data", Method: "GET", Target: "{v1}/issues"},
			{Type: wf.StepTypeSkill, Name: "ai-step", Purpose: "AI analysis", Target: "gitlink-triage",
				DependsOn: []string{"get-data"}},
		},
	}

	result, err := Run(ctx, wfDef, true)
	if err != nil {
		t.Fatalf("Run() dry-run failed: %v", err)
	}

	skillData, ok := result.Steps[1].Data.(map[string]interface{})
	if !ok {
		t.Fatal("skill step data is not a map")
	}
	if v, _ := skillData["_dry_run"]; v != true {
		t.Fatal("dry-run skill step should have _dry_run=true")
	}
}

func newTestContext(t *testing.T, server *httptest.Server) *common.RuntimeContext {
	t.Helper()
	return &common.RuntimeContext{
		Client: &client.Client{
			HTTP:    server.Client(),
			BaseURL: server.URL,
		},
		Owner:  "owner",
		Repo:   "repo",
		Format: "json",
		Args:   map[string]string{},
	}
}

func writeJSON(t *testing.T, w http.ResponseWriter, payload interface{}) {
	t.Helper()
	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(payload); err != nil {
		t.Fatalf("failed to write response: %v", err)
	}
}