gitea-mcp/operation/issue/blocking_test.go

package issue

import (
	"context"
	"encoding/json"
	"fmt"
	"maps"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"gitea.com/gitea/gitea-mcp/pkg/flag"

	"github.com/modelcontextprotocol/go-sdk/mcp"
)

func Test_issueBlocking(t *testing.T) {
	const (
		owner = "octo"
		repo  = "demo"
	)
	blocksPath := fmt.Sprintf("/api/v1/repos/%s/%s/issues/42/blocks", owner, repo)
	depsPath := fmt.Sprintf("/api/v1/repos/%s/%s/issues/42/dependencies", owner, repo)

	tests := []struct {
		name       string
		fn         func(context.Context, map[string]any) (*mcp.CallToolResult, error)
		args       map[string]any
		wantPath   string
		wantMethod string
		wantQuery  string
		wantIndex  float64
	}{
		{
			name:       "list blocks paginates",
			fn:         listIssueBlocksFn,
			args:       map[string]any{"page": float64(2), "per_page": float64(10)},
			wantPath:   blocksPath,
			wantMethod: http.MethodGet,
			wantQuery:  "limit=10&page=2",
		},
		{
			name:       "block issue posts index",
			fn:         blockIssueFn,
			args:       map[string]any{"blocked_issue": float64(7)},
			wantPath:   blocksPath,
			wantMethod: http.MethodPost,
			wantIndex:  7,
		},
		{
			name:       "unblock issue deletes with index",
			fn:         unblockIssueFn,
			args:       map[string]any{"blocked_issue": float64(7)},
			wantPath:   blocksPath,
			wantMethod: http.MethodDelete,
			wantIndex:  7,
		},
		{
			name:       "list dependencies paginates",
			fn:         listIssueDependenciesFn,
			args:       map[string]any{"page": float64(3), "per_page": float64(5)},
			wantPath:   depsPath,
			wantMethod: http.MethodGet,
			wantQuery:  "limit=5&page=3",
		},
		{
			name:       "add dependency posts index",
			fn:         addIssueDependencyFn,
			args:       map[string]any{"blocking_issue": float64(9)},
			wantPath:   depsPath,
			wantMethod: http.MethodPost,
			wantIndex:  9,
		},
		{
			name:       "remove dependency deletes with index",
			fn:         removeIssueDependencyFn,
			args:       map[string]any{"blocking_issue": float64(9)},
			wantPath:   depsPath,
			wantMethod: http.MethodDelete,
			wantIndex:  9,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var (
				gotMethod string
				gotPath   string
				gotQuery  string
				gotBody   map[string]any
			)
			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				switch r.URL.Path {
				case "/api/v1/version":
					w.Header().Set("Content-Type", "application/json")
					_, _ = w.Write([]byte(`{"version":"1.27.2"}`))
				case blocksPath, depsPath:
					gotMethod = r.Method
					gotPath = r.URL.Path
					gotQuery = r.URL.RawQuery
					_ = json.NewDecoder(r.Body).Decode(&gotBody)
					w.Header().Set("Content-Type", "application/json")
					if r.Method == http.MethodGet {
						_, _ = w.Write([]byte(`[{"number":7,"title":"blocked","state":"open"}]`))
					} else {
						_, _ = w.Write([]byte(`{"number":7,"title":"blocked","state":"open"}`))
					}
				default:
					http.NotFound(w, r)
				}
			})
			server := httptest.NewServer(handler)
			defer server.Close()

			origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
			flag.Host, flag.Token, flag.Version = server.URL, "", "test"
			defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()

			args := map[string]any{"owner": owner, "repo": repo, "issue_number": float64(42)}
			maps.Copy(args, tt.args)
			res, err := tt.fn(context.Background(), args)
			if err != nil {
				t.Fatalf("handler error = %v", err)
			}
			if res.IsError {
				t.Fatalf("unexpected error result: %v", res.Content)
			}
			if gotMethod != tt.wantMethod {
				t.Fatalf("method = %s, want %s", gotMethod, tt.wantMethod)
			}
			if gotPath != tt.wantPath {
				t.Fatalf("path = %s, want %s", gotPath, tt.wantPath)
			}
			if tt.wantQuery != "" && gotQuery != tt.wantQuery {
				t.Fatalf("query = %s, want %s", gotQuery, tt.wantQuery)
			}
			if tt.wantIndex != 0 && gotBody["index"] != tt.wantIndex {
				t.Fatalf("body index = %v, want %v", gotBody["index"], tt.wantIndex)
			}
			body := res.Content[0].(*mcp.TextContent).Text
			if !strings.Contains(body, `"number":7`) && !strings.Contains(body, `"number": 7`) {
				t.Fatalf("expected slim issue in output, got: %s", body)
			}
		})
	}
}