review-bot/gitea/adapter_test.go

package gitea_test

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

	"gitea.weiker.me/rodin/review-bot/gitea"
	"gitea.weiker.me/rodin/review-bot/vcs"
)

func TestAdapter_GetPullRequest(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]any{
			"title": "Test PR",
			"body":  "PR body",
			"head": map[string]any{
				"sha": "abc123",
				"ref": "feature-branch",
			},
			"base": map[string]any{
				"ref": "main",
			},
		})
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	pr, err := adapter.GetPullRequest(context.Background(), "owner", "repo", 42)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if pr.Number != 42 {
		t.Errorf("Number = %d, want 42", pr.Number)
	}
	if pr.Title != "Test PR" {
		t.Errorf("Title = %q, want %q", pr.Title, "Test PR")
	}
	if pr.Body != "PR body" {
		t.Errorf("Body = %q, want %q", pr.Body, "PR body")
	}
	if pr.Head.SHA != "abc123" {
		t.Errorf("Head.SHA = %q, want %q", pr.Head.SHA, "abc123")
	}
	if pr.Head.Ref != "feature-branch" {
		t.Errorf("Head.Ref = %q, want %q", pr.Head.Ref, "feature-branch")
	}
	if pr.Base.Ref != "main" {
		t.Errorf("Base.Ref = %q, want %q", pr.Base.Ref, "main")
	}
}

func TestAdapter_GetPullRequestFiles(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode([]map[string]any{
			{"filename": "main.go", "status": "modified"},
			{"filename": "new.go", "status": "added"},
		})
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	files, err := adapter.GetPullRequestFiles(context.Background(), "owner", "repo", 1)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(files) != 2 {
		t.Fatalf("got %d files, want 2", len(files))
	}
	if files[0].Filename != "main.go" || files[0].Status != "modified" {
		t.Errorf("files[0] = %+v", files[0])
	}
	if files[1].Filename != "new.go" || files[1].Status != "added" {
		t.Errorf("files[1] = %+v", files[1])
	}
}

func TestAdapter_ListReviews(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode([]map[string]any{
			{
				"id":        1,
				"body":      "LGTM",
				"user":      map[string]any{"login": "reviewer1"},
				"state":     "APPROVED",
				"stale":     false,
				"commit_id": "abc123",
			},
			{
				"id":        2,
				"body":      "Needs work",
				"user":      map[string]any{"login": "reviewer2"},
				"state":     "REQUEST_CHANGES",
				"stale":     true,
				"commit_id": "def456",
			},
		})
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	reviews, err := adapter.ListReviews(context.Background(), "owner", "repo", 1)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(reviews) != 2 {
		t.Fatalf("got %d reviews, want 2", len(reviews))
	}
	if reviews[0].ID != 1 || reviews[0].Body != "LGTM" || reviews[0].User.Login != "reviewer1" {
		t.Errorf("reviews[0] = %+v", reviews[0])
	}
	if reviews[0].State != "APPROVED" || reviews[0].Stale || reviews[0].CommitID != "abc123" {
		t.Errorf("reviews[0] state/stale/commit = %v/%v/%v", reviews[0].State, reviews[0].Stale, reviews[0].CommitID)
	}
	if reviews[1].ID != 2 || !reviews[1].Stale || reviews[1].State != "REQUEST_CHANGES" {
		t.Errorf("reviews[1] = %+v", reviews[1])
	}
}

func TestAdapter_GetCommitStatuses(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode([]map[string]any{
			{
				"status":      "success",
				"context":     "ci/test",
				"description": "All tests pass",
				"target_url":  "https://ci.example.com/1",
			},
		})
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	statuses, err := adapter.GetCommitStatuses(context.Background(), "owner", "repo", "abc123")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(statuses) != 1 {
		t.Fatalf("got %d statuses, want 1", len(statuses))
	}
	if statuses[0].Status != "success" {
		t.Errorf("Status = %q, want %q", statuses[0].Status, "success")
	}
	if statuses[0].Context != "ci/test" {
		t.Errorf("Context = %q, want %q", statuses[0].Context, "ci/test")
	}
	if statuses[0].Description != "All tests pass" {
		t.Errorf("Description = %q, want %q", statuses[0].Description, "All tests pass")
	}
	if statuses[0].TargetURL != "https://ci.example.com/1" {
		t.Errorf("TargetURL = %q, want %q", statuses[0].TargetURL, "https://ci.example.com/1")
	}
}

func TestAdapter_PostReview_EventTranslation(t *testing.T) {
	tests := []struct {
		name      string
		event     vcs.ReviewEvent
		wantEvent string
	}{
		{"APPROVE becomes APPROVED", vcs.ReviewEventApprove, "APPROVED"},
		{"REQUEST_CHANGES stays", vcs.ReviewEventRequestChanges, "REQUEST_CHANGES"},
		{"COMMENT stays", vcs.ReviewEventComment, "COMMENT"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var gotEvent string
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", "application/json")
				var payload struct {
					Event string `json:"event"`
				}
				json.NewDecoder(r.Body).Decode(&payload)
				gotEvent = payload.Event
				json.NewEncoder(w).Encode(map[string]any{
					"id":   1,
					"body": "test",
					"user": map[string]any{"login": "bot"},
				})
			}))
			defer server.Close()

			client := gitea.NewClient(server.URL, "token")
			adapter := gitea.NewAdapter(client)

			_, err := adapter.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
				Body:  "test",
				Event: tt.event,
				// No comments → no diff fetch needed
			})
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}
			if gotEvent != tt.wantEvent {
				t.Errorf("event = %q, want %q", gotEvent, tt.wantEvent)
			}
		})
	}
}

func TestAdapter_PostReview_WithComments_PositionTranslation(t *testing.T) {
	diff := `diff --git a/main.go b/main.go
--- a/main.go
+++ b/main.go
@@ -1,3 +1,4 @@
 package main
 
+// new comment at line 3
 func main() {}
`
	var gotComments []struct {
		Path        string `json:"path"`
		NewPosition int64  `json:"new_position"`
		Body        string `json:"body"`
	}

	call := 0
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		call++
		w.Header().Set("Content-Type", "application/json")
		if call == 1 {
			// Diff request
			w.Write([]byte(diff))
			return
		}
		// Review post
		var payload struct {
			Comments []struct {
				Path        string `json:"path"`
				NewPosition int64  `json:"new_position"`
				Body        string `json:"body"`
			} `json:"comments"`
		}
		json.NewDecoder(r.Body).Decode(&payload)
		gotComments = payload.Comments
		json.NewEncoder(w).Encode(map[string]any{
			"id":   1,
			"body": "review",
			"user": map[string]any{"login": "bot"},
		})
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	// Position 4 in this diff is "+// new comment at line 3" → new line 3
	_, err := adapter.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
		Body:  "review",
		Event: vcs.ReviewEventRequestChanges,
		Comments: []vcs.ReviewComment{
			{
				Path:     "main.go",
				Position: 4,
				CommitID: "abc123",
				Body:     "needs fix",
			},
		},
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if len(gotComments) != 1 {
		t.Fatalf("got %d comments, want 1", len(gotComments))
	}
	if gotComments[0].Path != "main.go" {
		t.Errorf("path = %q, want %q", gotComments[0].Path, "main.go")
	}
	if gotComments[0].NewPosition != 3 {
		t.Errorf("new_position = %d, want 3", gotComments[0].NewPosition)
	}
	if gotComments[0].Body != "needs fix" {
		t.Errorf("body = %q, want %q", gotComments[0].Body, "needs fix")
	}
}

func TestAdapter_DismissReview(t *testing.T) {
	var deleteCalled bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodDelete {
			deleteCalled = true
			w.WriteHeader(204)
			return
		}
		w.WriteHeader(404)
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	err := adapter.DismissReview(context.Background(), "owner", "repo", 1, 99, "stale review")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !deleteCalled {
		t.Error("expected delete to be called")
	}
}

func TestAdapter_Underlying(t *testing.T) {
	client := gitea.NewClient("http://example.com", "token")
	adapter := gitea.NewAdapter(client)
	if adapter.Underlying() != client {
		t.Error("Underlying() should return the wrapped client")
	}
}

func TestAdapter_ListContents(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode([]map[string]any{
			{"name": "main.go", "path": "src/main.go", "type": "file"},
			{"name": "util", "path": "src/util", "type": "dir"},
		})
	}))
	defer server.Close()

	client := gitea.NewClient(server.URL, "token")
	adapter := gitea.NewAdapter(client)

	entries, err := adapter.ListContents(context.Background(), "owner", "repo", "src")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(entries) != 2 {
		t.Fatalf("got %d entries, want 2", len(entries))
	}
	if entries[0].Name != "main.go" || entries[0].Type != "file" {
		t.Errorf("entries[0] = %+v", entries[0])
	}
	if entries[1].Name != "util" || entries[1].Type != "dir" {
		t.Errorf("entries[1] = %+v", entries[1])
	}
}

func TestAdapter_CompileTimeCheck(t *testing.T) {
	// This is a compile-time assertion — if it compiles, the adapter satisfies vcs.Client
	var _ vcs.Client = (*gitea.Adapter)(nil)
}