commitstatus_test.go

package github_test

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"slices"
	"strconv"
	"testing"
	"time"

	"github.com/Pix4D/go-kit/github"
	"github.com/Pix4D/go-kit/internal/testutils"
)

type mockedResponse struct {
	body               string
	status             int
	rateLimitRemaining string
	rateLimitReset     int64
}

const (
	emptyRateRemaining = "0"    // From the GitHub API.
	fullRateRemaining  = "5000" // From the GitHub API.
)

func TestGitHubStatusSuccessMockAPI(t *testing.T) {
	type testCase struct {
		name     string
		response []mockedResponse
		// wantSleeps:
		// - contains the durations we expect for the sleeps
		// - its size is the number of times we expect the sleep function to be called
		wantSleeps []time.Duration
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	cfg := fakeTestCfg
	context := "go-kit/test"
	targetURL := "https://go-kit.example/builds/job/42"
	now := time.Now()
	desc := now.Format("15:04:05")
	retryFirstDelay := github.DefaultRetry(nil).FirstDelay

	test := func(t *testing.T, tc testCase) {
		attempt := 0
		handler := func(w http.ResponseWriter, r *http.Request) {
			response := tc.response[attempt]
			if response.body == "" { // default
				response.body = "Anything goes..."
			}
			w.Header().Set("x-ratelimit-remaining", response.rateLimitRemaining)
			w.Header().Set("x-ratelimit-reset", strconv.Itoa(int(response.rateLimitReset)))
			w.WriteHeader(response.status)
			_, err := fmt.Fprintln(w, response.body)
			if err != nil {
				t.Fatalf("writing response body: %s", err)
			}
			attempt++
		}
		ts := httptest.NewServer(http.HandlerFunc(handler))
		defer ts.Close()
		log := testutils.MakeTestLog()
		sleepSpy := SleepSpy{}
		rtr := github.DefaultRetry(log)
		rtr.SleepFn = sleepSpy.Sleep
		target := &github.Target{
			Client: ts.Client(),
			Server: ts.URL,
			Retry:  rtr,
		}
		ghStatus := github.NewCommitStatus(target, cfg.Token, cfg.Owner, cfg.Repo, context, log)

		err := ghStatus.Add(ctx, cfg.SHA, "success", targetURL, desc)
		if err != nil {
			t.Fatal("Add:", err)
		}

		if have, want := sleepSpy.sleeps, tc.wantSleeps; slices.Compare(have, want) != 0 {
			t.Errorf("%s:\nhave: %v\nwant: %v", "sleeps", have, want)
		}
	}

	testCases := []testCase{
		{
			name: "Success at first attempt",
			response: []mockedResponse{
				{status: http.StatusCreated},
			},
			wantSleeps: nil,
		},
		{
			name: "Rate limited at the first attempt, success at the second attempt",
			response: []mockedResponse{
				{
					status:             http.StatusForbidden,
					rateLimitRemaining: emptyRateRemaining,
					rateLimitReset:     now.Add(42 * time.Second).Unix(),
				},
				{
					status:             http.StatusCreated,
					rateLimitRemaining: fullRateRemaining,
					rateLimitReset:     now.Add(1 * time.Hour).Unix(),
				},
			},
			wantSleeps: []time.Duration{42 * time.Second},
		},
		{
			name: "retry also on server-side inconsistency (zero sleep time), repro of Pix4D/cogito#124",
			response: []mockedResponse{
				{
					status:             http.StatusForbidden,
					rateLimitRemaining: emptyRateRemaining,
					// This causes sleep time to be 0: it would be silly to fail,
					// we should instead attempt once more. Depending on the problem
					// server-side, the next request might also fail, but at least we
					// did everything we could.
					rateLimitReset: now.Unix(),
				},
				{
					status:             http.StatusCreated,
					rateLimitRemaining: fullRateRemaining,
					rateLimitReset:     now.Add(1 * time.Hour).Unix(),
				},
			},
			wantSleeps: []time.Duration{retryFirstDelay},
		},
		{
			name: "retry also on server-side inconsistency (negative sleep time), repro of Pix4D/cogito#124",
			response: []mockedResponse{
				{
					status:             http.StatusForbidden,
					rateLimitRemaining: emptyRateRemaining,
					// This causes sleep time to be < 0.
					rateLimitReset: now.Add(-30 * time.Minute).Unix(),
				},
				{
					status:             http.StatusForbidden,
					rateLimitRemaining: emptyRateRemaining,
					// This causes sleep time to be < 0.
					rateLimitReset: now.Add(-30 * time.Minute).Unix(),
				},
				{
					status:             http.StatusCreated,
					rateLimitRemaining: fullRateRemaining,
					rateLimitReset:     now.Add(1 * time.Hour).Unix(),
				},
			},
			wantSleeps: []time.Duration{retryFirstDelay, 2 * retryFirstDelay},
		},
		{
			name: "Github is flaky at the first attempt, success at 3rd attempt",
			response: []mockedResponse{
				{status: http.StatusGatewayTimeout},
				{status: http.StatusGatewayTimeout},
				{status: http.StatusCreated},
			},
			wantSleeps: []time.Duration{retryFirstDelay, 2 * retryFirstDelay},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) { test(t, tc) })
	}
}

func TestGitHubStatusFailureMockAPI(t *testing.T) {
	type testCase struct {
		name     string
		response []mockedResponse
		// wantSleeps:
		// - contains the durations we expect for the sleeps
		// - its size is the number of times we expect the sleep function to be called
		wantSleeps []time.Duration
		wantErr    string
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	cfg := fakeTestCfg
	context := "go-kit/test"
	targetURL := "https://go-kit.example/builds/job/42"
	now := time.Now()
	desc := now.Format("15:04:05")
	upTo := 5 * time.Minute
	retryFirstDelay := github.DefaultRetry(nil).FirstDelay

	run := func(t *testing.T, tc testCase) {
		attempt := 0
		handler := func(w http.ResponseWriter, r *http.Request) {
			response := tc.response[attempt]
			if response.body == "" {
				response.body = "fake body"
			}
			w.Header().Set("x-ratelimit-remaining", response.rateLimitRemaining)
			w.Header().Set("x-ratelimit-reset", strconv.Itoa(int(response.rateLimitReset)))
			// The Date header is set automatically by default, but we override it
			// for better control.
			w.Header().Set("Date", now.Format(time.RFC1123))
			w.WriteHeader(response.status)
			_, err := fmt.Fprintln(w, response.body)
			if err != nil {
				t.Fatalf("writing response body: %s", err)
			}
			attempt++
		}
		ts := httptest.NewServer(http.HandlerFunc(handler))
		defer ts.Close()
		wantErr := fmt.Sprintf(tc.wantErr, ts.URL)
		log := testutils.MakeTestLog()
		sleepSpy := SleepSpy{}
		rtr := github.DefaultRetry(log)
		rtr.UpTo = upTo
		rtr.SleepFn = sleepSpy.Sleep
		target := &github.Target{
			Client: ts.Client(),
			Server: ts.URL,
			Retry:  rtr,
		}
		ghStatus := github.NewCommitStatus(target, cfg.Token, cfg.Owner, cfg.Repo, context, log)

		err := ghStatus.Add(ctx, cfg.SHA, "success", targetURL, desc)

		if err == nil {
			t.Fatalf("%s\nhave: %v\nwant: %v", "Add", "<no error>", wantErr)
		}
		if diff := diff(err.Error(), wantErr); diff != "" {
			t.Fatalf("Add: error mismatch:\n%s", diff)
		}
		{
			var ghError *github.StatusError
			if !errors.As(err, &ghError) {
				t.Errorf("%s\nhave: %T\nwant: %T", "Add: error type", err, ghError)
			} else {
				wantStatus := tc.response[len(tc.response)-1].status
				if have, want := ghError.StatusCode, wantStatus; have != want {
					t.Errorf("%s\nhave: %v\nwant: %v", "StatusCode", have, want)
				}
			}
		}

		if have, want := sleepSpy.sleeps, tc.wantSleeps; slices.Compare(have, want) != 0 {
			t.Errorf("%s:\nhave: %v\nwant: %v", "sleeps", have, want)
		}
	}

	testCases := []testCase{
		{
			name: "non transient error, stop at first attempt",
			response: []mockedResponse{
				{
					body:   "fake body",
					status: http.StatusNotFound,
				},
			},
			wantSleeps: nil,
			wantErr: `failed to add state "success" for commit 0123456: 404 Not Found
Body: fake body
Hint: one of the following happened:
    1. The repo https://github.com/fakeOwner/fakeRepo doesn't exist
    2. The user who issued the token doesn't have write access to the repo
    3. The token doesn't have scope repo:status
Action: POST %s/repos/fakeOwner/fakeRepo/statuses/0123456789012345678901234567890123456789
OAuth: X-Accepted-Oauth-Scopes: , X-Oauth-Scopes: `,
		},
		{
			name: "transient error, consume all attempts",
			response: []mockedResponse{
				//                                                cumulative
				{status: http.StatusInternalServerError}, // 2s     2s
				{status: http.StatusInternalServerError}, // 4s     6s
				{status: http.StatusInternalServerError}, // 8s    14s
				{status: http.StatusInternalServerError}, // 16s   30s
				{status: http.StatusInternalServerError}, // 32s  1m2s
				{status: http.StatusInternalServerError}, // 1m   2m2s
				{status: http.StatusInternalServerError}, // 1m   3m2s
				{status: http.StatusInternalServerError}, // 1m   4m2s
				{status: http.StatusInternalServerError}, // 1m   5m2s too long
			},
			wantSleeps: []time.Duration{
				retryFirstDelay,
				4 * time.Second,
				8 * time.Second,
				16 * time.Second,
				32 * time.Second,
				1 * time.Minute,
				1 * time.Minute,
				1 * time.Minute,
			},
			wantErr: `failed to add state "success" for commit 0123456: 500 Internal Server Error
Body: fake body
Hint: Github API is down
Action: POST %s/repos/fakeOwner/fakeRepo/statuses/0123456789012345678901234567890123456789
OAuth: X-Accepted-Oauth-Scopes: , X-Oauth-Scopes: `,
		},
		{
			name: "Rate limited: wait time too long (> Retry.UpTo)",
			response: []mockedResponse{
				{
					body:               "API rate limit exceeded for user ID 123456789. [rate reset in XXmXXs]",
					status:             http.StatusForbidden,
					rateLimitRemaining: emptyRateRemaining,
					rateLimitReset:     now.Add(upTo + time.Second).Unix(),
				},
			},
			wantSleeps: nil,
			wantErr: `failed to add state "success" for commit 0123456: 403 Forbidden
Body: API rate limit exceeded for user ID 123456789. [rate reset in XXmXXs]
Hint: Rate limited but the wait time to reset would be longer than 5m0s (Retry.UpTo)
Action: POST %s/repos/fakeOwner/fakeRepo/statuses/0123456789012345678901234567890123456789
OAuth: X-Accepted-Oauth-Scopes: , X-Oauth-Scopes: `,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) { run(t, tc) })
	}
}

func TestGitHubStatusSuccessIntegration(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	cfg := gitHubSecretsOrFail(t)
	context := "go-kit/test"
	targetURL := "https://go-kit.example/builds/job/42"
	desc := time.Now().Format("15:04:05")
	state := "success"
	log := testutils.MakeTestLog()
	target := &github.Target{
		Client: &http.Client{},
		Server: github.ApiRoot(github.GhDefaultHostname),
		Retry:  github.DefaultRetry(log),
	}
	ghStatus := github.NewCommitStatus(target, cfg.Token, cfg.Owner, cfg.Repo, context, log)

	err := ghStatus.Add(ctx, cfg.SHA, state, targetURL, desc)
	if err != nil {
		t.Fatal("Add:", err)
	}
}

func TestGitHubStatusFailureIntegration(t *testing.T) {
	type testCase struct {
		name       string
		token      string // default: cfg.Token
		owner      string // default: cfg.Owner
		repo       string // default: cfg.Repo
		sha        string // default: cfg.SHA
		wantErr    string
		wantStatus int
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	cfg := gitHubSecretsOrFail(t)
	state := "success"
	log := testutils.MakeTestLog()

	run := func(t *testing.T, tc testCase) {
		// zero values are defaults
		if tc.token == "" {
			tc.token = cfg.Token
		}
		if tc.owner == "" {
			tc.owner = cfg.Owner
		}
		if tc.repo == "" {
			tc.repo = cfg.Repo
		}
		if tc.sha == "" {
			tc.sha = cfg.SHA
		}

		target := &github.Target{
			Client: &http.Client{},
			Server: github.ApiRoot(github.GhDefaultHostname),
			Retry:  github.DefaultRetry(log),
		}
		ghStatus := github.NewCommitStatus(target, tc.token, tc.owner, tc.repo, "dummy-context", log)
		err := ghStatus.Add(ctx, tc.sha, state, "dummy-url", "dummy-desc")

		if err == nil {
			t.Fatalf("%s\nhave: %v\nwant: %v", "Add", "<no error>", tc.wantErr)
		}
		if diff := diff(err.Error(), tc.wantErr); diff != "" {
			t.Fatalf("Add: error mismatch:\n%s", diff)
		}
		{
			var ghError *github.StatusError
			if !errors.As(err, &ghError) {
				t.Errorf("%s\nhave: %T\nwant: %T", "Add: error type", err, ghError)
			} else {
				if have, want := ghError.StatusCode, tc.wantStatus; have != want {
					t.Errorf("%s\nhave: %v\nwant: %v", "StatusCode", have, want)
				}
			}
		}
	}

	testCases := []testCase{
		{
			name:  "bad token: Unauthorized",
			token: "bad-token",
			wantErr: `failed to add state "success" for commit 751affd: 401 Unauthorized
Body: {"documentation_url":"https://docs.github.com/rest","message":"Bad credentials","status":"401"}
Hint: Either wrong credentials or PAT expired (check your email for expiration notice)
Action: POST https://api.github.com/repos/pix4d/go-kit-test-read-write/statuses/751affd155db7a00d936ee6e9f483deee69c5922
OAuth: X-Accepted-Oauth-Scopes: , X-Oauth-Scopes: `,
			wantStatus: http.StatusUnauthorized,
		},
		{
			name: "non existing repo: Not Found",
			repo: "non-existing-really",
			wantErr: `failed to add state "success" for commit 751affd: 404 Not Found
Body: {"documentation_url":"https://docs.github.com/rest/commits/statuses#create-a-commit-status","message":"Not Found","status":"404"}
Hint: one of the following happened:
    1. The repo https://github.com/pix4d/non-existing-really doesn't exist
    2. The user who issued the token doesn't have write access to the repo
    3. The token doesn't have scope repo:status
Action: POST https://api.github.com/repos/pix4d/non-existing-really/statuses/751affd155db7a00d936ee6e9f483deee69c5922
OAuth: X-Accepted-Oauth-Scopes: repo, X-Oauth-Scopes: repo:status`,
			wantStatus: http.StatusNotFound,
		},
		{
			name: "non existing SHA: Unprocessable Entity",
			sha:  "e576e3aa7aaaa048b396e2f34fa24c9cf4d1e822",
			wantErr: `failed to add state "success" for commit e576e3a: 422 Unprocessable Entity
Body: {"documentation_url":"https://docs.github.com/rest/commits/statuses#create-a-commit-status","message":"No commit found for SHA: e576e3aa7aaaa048b396e2f34fa24c9cf4d1e822","status":"422"}
Hint: none
Action: POST https://api.github.com/repos/pix4d/go-kit-test-read-write/statuses/e576e3aa7aaaa048b396e2f34fa24c9cf4d1e822
OAuth: X-Accepted-Oauth-Scopes: , X-Oauth-Scopes: repo:status`,
			wantStatus: http.StatusUnprocessableEntity,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) { run(t, tc) })
	}
}

type SleepSpy struct {
	sleeps []time.Duration
}

func (spy *SleepSpy) Sleep(d time.Duration) {
	spy.sleeps = append(spy.sleeps, d)
}

func TestApiRoot(t *testing.T) {
	type testCase struct {
		name     string
		hostname string
		wantAPI  string
	}

	run := func(t *testing.T, tc testCase) {
		root := github.ApiRoot(tc.hostname)

		if have, want := root, tc.wantAPI; have != want {
			t.Errorf("%s\nhave: %v\nwant: %v", "ApiRoot", have, want)
		}
	}

	testCases := []testCase{
		{
			name:     "hostname is localhost from http testserver",
			hostname: "127.0.0.1:5678",
			wantAPI:  "http://127.0.0.1:5678",
		},
		{
			name:     "default GitHub hostname",
			hostname: github.GhDefaultHostname,
			wantAPI:  "https://api.github.com",
		},
		{
			name:     "Github Enterprise hostname",
			hostname: "github.mycompany.org",
			wantAPI:  "https://github.mycompany.org/api/v3",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) { run(t, tc) })
	}
}