helix_test.go

package helix

import (
	"context"
	"errors"
	"log"
	"net/http"
	"net/http/httptest"
	"reflect"
	"strconv"
	"strings"
	"testing"
	"time"
)

type mockHTTPClient struct {
	mockHandler http.HandlerFunc
}

func (mtc *mockHTTPClient) Do(req *http.Request) (*http.Response, error) {
	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(mtc.mockHandler)
	handler.ServeHTTP(rr, req)

	return rr.Result(), nil
}

func newMockClient(options *Options, mockHandler http.HandlerFunc) *Client {
	options.HTTPClient = &mockHTTPClient{mockHandler}
	return &Client{
		opts: options,
		ctx:  context.Background(),
	}
}

func newMockHandler(statusCode int, json string, headers map[string]string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if len(headers) > 0 {
			for key, value := range headers {
				w.Header().Add(key, value)
			}
		}

		w.WriteHeader(statusCode)
		w.Write([]byte(json))
	}
}

func TestNewClient(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		extpectErr bool
		options    *Options
	}{
		{
			true,
			&Options{}, // no client id
		},
		{
			false,
			&Options{
				ClientID:        "my-client-id",
				ClientSecret:    "my-client-secret",
				HTTPClient:      &http.Client{},
				AppAccessToken:  "my-app-access-token",
				UserAccessToken: "my-user-access-token",
				RefreshToken:    "my-refresh-token",
				UserAgent:       "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.162 Safari/537.36",
				RateLimitFunc:   func(*Response) error { return nil },
				RedirectURI:     "http://localhost/auth/callback",
				APIBaseURL:      "http://localhost/proxy",
			},
		},
	}

	for _, testCase := range testCases {
		client, err := NewClient(testCase.options)
		if err != nil && !testCase.extpectErr {
			t.Errorf("Did not expect an error, got \"%s\"", err.Error())
		}

		if testCase.extpectErr {
			continue
		}

		opts := client.opts

		if opts.ClientID != testCase.options.ClientID {
			t.Errorf("expected clientID to be \"%s\", got \"%s\"", testCase.options.ClientID, opts.ClientID)
		}

		if opts.ClientSecret != testCase.options.ClientSecret {
			t.Errorf("expected clientSecret to be \"%s\", got \"%s\"", testCase.options.ClientSecret, opts.ClientSecret)
		}

		if reflect.TypeOf(opts.RateLimitFunc).Kind() != reflect.Func {
			t.Errorf("expected rateLimitFunc to be a function, got \"%+v\"", reflect.TypeOf(opts.RateLimitFunc).Kind())
		}

		if opts.HTTPClient != testCase.options.HTTPClient {
			t.Errorf("expected httpClient to be \"%s\", got \"%s\"", testCase.options.HTTPClient, opts.HTTPClient)
		}

		if opts.UserAgent != testCase.options.UserAgent {
			t.Errorf("expected userAgent to be \"%s\", got \"%s\"", testCase.options.UserAgent, opts.UserAgent)
		}

		if opts.AppAccessToken != testCase.options.AppAccessToken {
			t.Errorf("expected accessToken to be \"%s\", got \"%s\"", testCase.options.AppAccessToken, opts.AppAccessToken)
		}

		if opts.UserAccessToken != testCase.options.UserAccessToken {
			t.Errorf("expected accessToken to be \"%s\", got \"%s\"", testCase.options.UserAccessToken, opts.UserAccessToken)
		}

		if opts.RefreshToken != testCase.options.RefreshToken {
			t.Errorf("expected refreshToken to be \"%s\", got \"%s\"", testCase.options.RefreshToken, opts.RefreshToken)
		}

		if opts.RedirectURI != testCase.options.RedirectURI {
			t.Errorf("expected redirectURI to be \"%s\", got \"%s\"", testCase.options.RedirectURI, opts.RedirectURI)
		}

		if opts.APIBaseURL != testCase.options.APIBaseURL {
			t.Errorf("expected APIBaseURL to be \"%s\", got \"%s\"", testCase.options.APIBaseURL, opts.APIBaseURL)
		}
	}
}

func TestNewClientDefault(t *testing.T) {
	t.Parallel()

	options := &Options{ClientID: "my-client-id"}

	client, err := NewClient(options)
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	opts := client.opts

	if opts.ClientID != options.ClientID {
		t.Errorf("expected clientID to be \"%s\", got \"%s\"", options.ClientID, opts.ClientID)
	}

	if opts.ClientSecret != "" {
		t.Errorf("expected clientSecret to be \"%s\", got \"%s\"", options.ClientSecret, opts.ClientSecret)
	}

	if opts.UserAgent != "" {
		t.Errorf("expected userAgent to be \"%s\", got \"%s\"", "", opts.UserAgent)
	}

	if opts.UserAccessToken != "" {
		t.Errorf("expected accesstoken to be \"\", got \"%s\"", opts.UserAccessToken)
	}

	if opts.HTTPClient != http.DefaultClient {
		t.Errorf("expected httpClient to be \"%v\", got \"%v\"", http.DefaultClient, opts.HTTPClient)
	}

	if opts.RateLimitFunc != nil {
		t.Errorf("expected rateLimitFunc to be \"%v\", got \"%v\"", nil, opts.RateLimitFunc)
	}

	if opts.RedirectURI != options.RedirectURI {
		t.Errorf("expected redirectURI to be \"%s\", got \"%s\"", options.RedirectURI, opts.RedirectURI)
	}
}

func TestNewClientHasContext(t *testing.T) {
	t.Parallel()

	contextExists := false
	mockClient := &mockHTTPClient{func(w http.ResponseWriter, r *http.Request) {
		contextExists = r.Context() != nil
	}}

	c, err := NewClient(&Options{
		ClientID:   "test",
		HTTPClient: mockClient,
	})
	if err != nil {
		t.Errorf("could not create client: %v", err)
		return
	}

	_, err = c.GetStreams(nil)

	if err != nil {
		t.Errorf("Did not expect error, got \"%s\"", err)
	}

	if !contextExists {
		t.Error("Expected context to be passed into request, got nil context")
	}
}

func TestNewClientWithContext(t *testing.T) {
	t.Parallel()

	type CtxKey string
	ctxKey := CtxKey("test")

	contextExists := false
	mockClient := &mockHTTPClient{func(w http.ResponseWriter, r *http.Request) {
		ctx := r.Context()
		contextExists = ctx != nil && ctx.Value(ctxKey) != nil
	}}

	ctx := context.WithValue(context.Background(), ctxKey, 0)
	c, err := NewClientWithContext(ctx, &Options{
		ClientID:   "test",
		HTTPClient: mockClient,
	})
	if err != nil {
		t.Errorf("could not create client with context: %v", err)
		return
	}

	_, err = c.GetStreams(nil)

	if err != nil {
		t.Errorf("Did not expect error, got \"%s\"", err)
	}

	if !contextExists {
		t.Error("Expected context to be passed into request, got nil context")
	}
}

func TestNewClientWithContextCancel(t *testing.T) {
	t.Parallel()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	wasCanceled := false
	mockClient := &mockHTTPClient{func(w http.ResponseWriter, r *http.Request) {
		<-r.Context().Done()
		wasCanceled = true
	}}

	c, err := NewClientWithContext(ctx, &Options{
		ClientID:   "test",
		HTTPClient: mockClient,
	})
	if err != nil {
		t.Errorf("Could not create client with context: %v", err)
		return
	}

	cancel()
	_, err = c.GetStreams(nil)

	if err != nil {
		t.Errorf("Did not expect error, got \"%s\"", err)
	}

	if !wasCanceled {
		t.Error("Context was not cancelled")
	}
}

func TestNoContext(t *testing.T) {
	t.Parallel()

	contextExists := false
	handlerFunc := func(w http.ResponseWriter, r *http.Request) {
		if r.Context() != nil {
			contextExists = true
		}
	}

	c := newMockClient(&Options{}, handlerFunc)
	_, err := c.GetStreams(nil)

	if err != nil {
		t.Errorf("Did not expect error, got \"%s\"", err)
	}

	if !contextExists {
		t.Error("Expected context to be passed into request, got nil context")
	}
}

func TestRatelimitCallback(t *testing.T) {
	t.Parallel()

	respBody1 := `{"error":"Too Many Requests","status":429,"message":"Request limit exceeded"}`
	options1 := &Options{
		ClientID: "my-client-id",
		RateLimitFunc: func(resp *Response) error {
			return nil
		},
	}

	c := newMockClient(options1, newMockHandler(http.StatusTooManyRequests, respBody1, nil))
	go func() {
		_, err := c.GetStreams(&StreamsParams{})
		if err != nil {
			t.Errorf("Did not expect error, got \"%s\"", err.Error())
		}
	}()

	time.Sleep(5 * time.Millisecond)

	respBody2 := `{"data":[{"id":"EncouragingPluckySlothSSSsss","url":"https://clips.twitch.tv/EncouragingPluckySlothSSSsss","embed_url":"https://clips.twitch.tv/embed?clip=EncouragingPluckySlothSSSsss","broadcaster_id":"26490481","creator_id":"143839181","video_id":"222004532","game_id":"490377","language":"en","title":"summit and fat tim discover how to use maps","view_count":81808,"created_at":"2018-01-25T04:04:15Z","thumbnail_url":"https://clips-media-assets.twitch.tv/182509178-preview-480x272.jpg"}]}`
	options2 := &Options{
		ClientID: "my-client-id",
	}

	c = newMockClient(options2, newMockHandler(http.StatusOK, respBody2, nil))
	_, err := c.GetStreams(&StreamsParams{})
	if err != nil {
		t.Errorf("Did not expect error, got \"%s\"", err.Error())
	}
}

func TestRatelimitCallbackFailsOnError(t *testing.T) {
	t.Parallel()

	errMsg := "Oops! Your rate limiter funciton is broken :("
	respBody1 := `{"error":"Too Many Requests","status":429,"message":"Request limit exceeded"}`
	options1 := &Options{
		ClientID: "my-client-id",
		RateLimitFunc: func(resp *Response) error {
			return errors.New(errMsg)
		},
	}

	c := newMockClient(options1, newMockHandler(http.StatusTooManyRequests, respBody1, nil))
	_, err := c.GetStreams(&StreamsParams{})
	if err == nil {
		t.Error("Expected error, got none")
	}

	if err.Error() != errMsg {
		t.Errorf("Expected error to be \"%s\", got \"%s\"", errMsg, err.Error())
	}
}

func TestAutomaticUserTokenRefresh(t *testing.T) {
	t.Parallel()

	options := &Options{
		ClientID:        "client-id",
		ClientSecret:    "old-client-secret",
		UserAccessToken: "old-user-token",
		RefreshToken:    "old-refresh-token",
	}
	client := newMockClient(options, func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.URL.Path, "/oauth2/token") {
			w.Write([]byte(`{"access_token":"new-access-token","expires_in":14154,"refresh_token":"new-refresh-token","scope":["analytics:read:games","bits:read","clips:edit","user:edit","user:read:email"]}`))
		} else if strings.Contains(r.URL.Path, "/channels/followers") {
			if strings.Contains(r.Header.Get("Authorization"), "old-user-token") {
				w.WriteHeader(http.StatusUnauthorized)
				w.Write([]byte(`{"error":"Unauthorized","status":401,"message":"Invalid OAuth token"}`))
			} else {
				w.Write([]byte(`{"total":8,"data":[],"pagination":{}}`))
			}
		} else {
			log.Printf("Unknown URL sent to test server: %s", r.URL.Path)
		}
	})

	_, err := client.GetChannelFollows(&GetChannelFollowsParams{}) // any method works
	if err != nil {
		t.Fatalf("Did not expect an error, got \"%s\"", err.Error())
	}

	time.Sleep(5 * time.Millisecond)

	if client.opts.UserAccessToken != "new-access-token" {
		t.Errorf("expected UserAccessToken to be %q, got %q", "new-access-token", client.opts.UserAccessToken)
	}
	if client.opts.RefreshToken != "new-refresh-token" {
		t.Errorf("expected RefreshToken to be %q, got %q", "new-refresh-token", client.opts.RefreshToken)
	}
}

func TestSetRequestHeaders(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		endpoint        string
		method          string
		userBearerToken string
		appBearerToken  string
	}{
		{"/users", "GET", "my-user-access-token", "my-app-access-token"},
		{"/entitlements/upload", "POST", "", "my-app-access-token"},
		{"/streams", "GET", "", ""},
	}

	for _, testCase := range testCases {
		client, err := NewClient(&Options{
			ClientID:        "my-client-id",
			UserAgent:       "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.162 Safari/537.36",
			AppAccessToken:  testCase.appBearerToken,
			UserAccessToken: testCase.userBearerToken,
		})
		if err != nil {
			t.Errorf("Did not expect an error, got \"%s\"", err.Error())
		}

		req, _ := http.NewRequest(testCase.method, testCase.endpoint, nil)
		client.setRequestHeaders(req)

		if testCase.userBearerToken != "" {
			expectedAuthHeader := "Bearer " + testCase.userBearerToken
			if req.Header.Get("Authorization") != expectedAuthHeader {
				t.Errorf("expected Authorization header to be \"%s\", got \"%s\"", expectedAuthHeader, req.Header.Get("Authorization"))
			}
		}

		if testCase.userBearerToken == "" && testCase.appBearerToken != "" {
			expectedAuthHeader := "Bearer " + testCase.appBearerToken
			if req.Header.Get("Authorization") != expectedAuthHeader {
				t.Errorf("expected Authorization header to be \"%s\", got \"%s\"", expectedAuthHeader, req.Header.Get("Authorization"))
			}
		}

		if testCase.userBearerToken == "" && testCase.appBearerToken == "" {
			if req.Header.Get("Authorization") != "" {
				t.Error("did not expect Authorization header to be set")
			}
		}

		if req.Header.Get("User-Agent") != client.opts.UserAgent {
			t.Errorf("expected User-Agent header to be \"%s\", got \"%s\"", client.opts.UserAgent, req.Header.Get("User-Agent"))
		}
	}
}

func TestGetRateLimitHeaders(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		statusCode      int
		options         *Options
		Logins          []string
		respBody        string
		headerLimit     string
		headerRemaining string
		headerReset     string
	}{
		{
			http.StatusOK,
			&Options{ClientID: "my-client-id"},
			[]string{"summit1g"},
			`{"data":[{"id":"26490481","login":"summit1g","display_name":"summit1g","type":"","broadcaster_type":"partner","description":"I'm a competitive CounterStrike player who likes to play casually now and many other games. You will mostly see me play CS, H1Z1,and single player games at night. There will be many othergames played on this stream in the future as they come out:D","profile_image_url":"https://static-cdn.jtvnw.net/jtv_user_pictures/200cea12142f2384-profile_image-300x300.png","offline_image_url":"https://static-cdn.jtvnw.net/jtv_user_pictures/summit1g-channel_offline_image-e2f9a1df9e695ec1-1920x1080.png","view_count":202707885}]}`,
			"30",
			"29",
			"1529183210",
		},
		{
			http.StatusOK,
			&Options{ClientID: "my-client-id"},
			[]string{"summit1g"},
			`{"data":[{"id":"26490481","login":"summit1g","display_name":"summit1g","type":"","broadcaster_type":"partner","description":"I'm a competitive CounterStrike player who likes to play casually now and many other games. You will mostly see me play CS, H1Z1,and single player games at night. There will be many othergames played on this stream in the future as they come out:D","profile_image_url":"https://static-cdn.jtvnw.net/jtv_user_pictures/200cea12142f2384-profile_image-300x300.png","offline_image_url":"https://static-cdn.jtvnw.net/jtv_user_pictures/summit1g-channel_offline_image-e2f9a1df9e695ec1-1920x1080.png","view_count":202707885}]}`,
			"",
			"",
			"",
		},
	}

	for _, testCase := range testCases {
		mockRespHeaders := make(map[string]string)

		if testCase.headerLimit != "" {
			mockRespHeaders["Ratelimit-Limit"] = testCase.headerLimit
			mockRespHeaders["Ratelimit-Remaining"] = testCase.headerRemaining
			mockRespHeaders["Ratelimit-Reset"] = testCase.headerReset
		}

		c := newMockClient(testCase.options, newMockHandler(testCase.statusCode, testCase.respBody, mockRespHeaders))

		resp, err := c.GetUsers(&UsersParams{
			Logins: testCase.Logins,
		})
		if err != nil {
			t.Error(err)
		}

		expctedHeaderLimit, _ := strconv.Atoi(testCase.headerLimit)
		if resp.GetRateLimit() != expctedHeaderLimit {
			t.Errorf("expected \"Ratelimit-Limit\" to be \"%d\", got \"%d\"", expctedHeaderLimit, resp.GetRateLimit())
		}

		expctedHeaderRemaining, _ := strconv.Atoi(testCase.headerRemaining)
		if resp.GetRateLimitRemaining() != expctedHeaderRemaining {
			t.Errorf("expected \"Ratelimit-Remaining\" to be \"%d\", got \"%d\"", expctedHeaderRemaining, resp.GetRateLimitRemaining())
		}

		expctedHeaderReset, _ := strconv.Atoi(testCase.headerReset)
		if resp.GetRateLimitReset() != expctedHeaderReset {
			t.Errorf("expected \"Ratelimit-Reset\" to be \"%d\", got \"%d\"", expctedHeaderReset, resp.GetRateLimitReset())
		}
	}
}

type badMockHTTPClient struct {
	mockHandler http.HandlerFunc
}

func (mtc *badMockHTTPClient) Do(req *http.Request) (*http.Response, error) {
	return nil, errors.New("Oops, that's bad :(")
}

func TestFailedHTTPClientDoRequest(t *testing.T) {
	t.Parallel()

	options := &Options{
		ClientID: "my-client-id",
		HTTPClient: &badMockHTTPClient{
			newMockHandler(0, "", nil),
		},
	}

	c := &Client{
		opts: options,
		ctx:  context.Background(),
	}

	_, err := c.GetUsers(&UsersParams{
		Logins: []string{"summit1g"},
	})
	if err == nil {
		t.Error("expected error but got nil")
	}

	if err.Error() != "Failed to execute API request: Oops, that's bad :(" {
		t.Errorf("expected error does match return error: %v", err)
	}
}

func TestDecodingBadJSON(t *testing.T) {
	t.Parallel()

	// Invalid JSON (missing `"` from the beginning)
	c := newMockClient(&Options{ClientID: "my-client-id"}, newMockHandler(http.StatusOK, `data":["some":"data"]}`, nil))

	_, err := c.GetUsers(&UsersParams{
		Logins: []string{"summit1g"},
	})
	if err == nil {
		t.Error("expected error but got nil")
	}

	if err.Error() != "Failed to decode API response: invalid character 'd' looking for beginning of value" {
		t.Error("expected error does match return error")
	}
}

func TestGetAppAccessToken(t *testing.T) {
	t.Parallel()

	accessToken := "my-app-access-token"

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	client.SetAppAccessToken(accessToken)

	if client.GetAppAccessToken() != accessToken {
		t.Errorf("expected GetAppAccessToken to return \"%s\", got \"%s\"", accessToken, client.GetAppAccessToken())
	}
}

func TestSetAppAccessToken(t *testing.T) {
	t.Parallel()

	accessToken := "my-app-access-token"

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	client.SetAppAccessToken(accessToken)

	if client.opts.AppAccessToken != accessToken {
		t.Errorf("expected accessToken to be \"%s\", got \"%s\"", accessToken, client.opts.AppAccessToken)
	}
}

func TestGetUserAccessToken(t *testing.T) {
	t.Parallel()

	accessToken := "my-user-access-token"

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	client.SetUserAccessToken(accessToken)

	if client.GetUserAccessToken() != accessToken {
		t.Errorf("expected GetUserAccessToken to return \"%s\", got \"%s\"", accessToken, client.GetUserAccessToken())
	}
}

func TestSetUserAccessToken(t *testing.T) {
	t.Parallel()

	accessToken := "my-user-access-token"

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	client.SetUserAccessToken(accessToken)

	if client.opts.UserAccessToken != accessToken {
		t.Errorf("expected accessToken to be \"%s\", got \"%s\"", accessToken, client.opts.UserAccessToken)
	}
}

func TestGetRefreshToken(t *testing.T) {
	t.Parallel()

	refreshToken := "my-refresh-token"

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	client.SetRefreshToken(refreshToken)

	if client.GetRefreshToken() != refreshToken {
		t.Errorf("expected GetRefreshToken to return \"%s\", got \"%s\"", refreshToken, client.GetRefreshToken())
	}
}

func TestSetRefreshToken(t *testing.T) {
	t.Parallel()

	refreshToken := "my-refresh-token"

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	client.SetRefreshToken(refreshToken)

	if client.opts.RefreshToken != refreshToken {
		t.Errorf("expected RefreshToken to be \"%s\", got \"%s\"", refreshToken, client.opts.RefreshToken)
	}
}

func TestSetUserAgent(t *testing.T) {
	t.Parallel()

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	userAgent := "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.162 Safari/537.36"
	client.SetUserAgent(userAgent)

	if client.opts.UserAgent != userAgent {
		t.Errorf("expected accessToken to be \"%s\", got \"%s\"", userAgent, client.opts.UserAgent)
	}
}

func TestSetRedirectURI(t *testing.T) {
	t.Parallel()

	client, err := NewClient(&Options{
		ClientID: "cid",
	})
	if err != nil {
		t.Errorf("Did not expect an error, got \"%s\"", err.Error())
	}

	redirectURI := "http://localhost/auth/callback"
	client.SetRedirectURI(redirectURI)

	if client.opts.RedirectURI != redirectURI {
		t.Errorf("expected redirectURI to be \"%s\", got \"%s\"", redirectURI, client.opts.RedirectURI)
	}
}

func TestOnUserAccessTokenRefreshed(t *testing.T) {
	t.Parallel()

	options := &Options{
		ClientID:        "client-id",
		ClientSecret:    "old-client-secret",
		UserAccessToken: "old-user-token",
		RefreshToken:    "old-refresh-token",
	}
	client := newMockClient(options, func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.URL.Path, "/oauth2/token") {
			w.Write([]byte(`{"access_token":"new-access-token","expires_in":14154,"refresh_token":"new-refresh-token","scope":["analytics:read:games","bits:read","clips:edit","user:edit","user:read:email"]}`))
		} else if strings.Contains(r.URL.Path, "/channels/followers") {
			if strings.Contains(r.Header.Get("Authorization"), "old-user-token") {
				w.WriteHeader(http.StatusUnauthorized)
				w.Write([]byte(`{"error":"Unauthorized","status":401,"message":"Invalid OAuth token"}`))
			} else {
				w.Write([]byte(`{"total":8,"data":[],"pagination":{}}`))
			}
		} else {
			log.Printf("Unknown URL sent to test server: %s", r.URL.Path)
		}
	})

	var newAccessToken, newRefreshToken string
	client.OnUserAccessTokenRefreshed(func(a, r string) {
		newAccessToken = a
		newRefreshToken = r
	})
	wantNewAccessToken := "new-access-token"
	wantNewRefreshToken := "new-refresh-token"

	_, err := client.GetChannelFollows(&GetChannelFollowsParams{}) // any method works
	if err != nil {
		t.Fatalf("Did not expect an error, got \"%s\"", err.Error())
	}

	time.Sleep(10 * time.Millisecond)

	if newAccessToken != wantNewAccessToken {
		t.Errorf("expected newAccessToken to be %q, got %q", wantNewAccessToken, newAccessToken)
	}
	if newRefreshToken != wantNewRefreshToken {
		t.Errorf("expected newRefreshToken to be %q, got %q", wantNewRefreshToken, newRefreshToken)
	}
}

func TestHydrateRequestCommon(t *testing.T) {
	t.Parallel()
	var sourceResponse Response
	sampleStatusCode := 200
	sampleHeaders := http.Header{}
	sampleHeaders.Set("Content-Type", "application/json")
	sampleError := "foo"
	sampleErrorStatus := 1
	sampleErrorMessage := "something done broke"
	sourceResponse.ResponseCommon.StatusCode = sampleStatusCode
	sourceResponse.ResponseCommon.Header = sampleHeaders
	sourceResponse.ResponseCommon.Error = sampleError
	sourceResponse.ResponseCommon.ErrorStatus = sampleErrorStatus
	sourceResponse.ResponseCommon.ErrorMessage = sampleErrorMessage

	var targetResponse Response
	sourceResponse.HydrateResponseCommon(&targetResponse.ResponseCommon)
	if targetResponse.StatusCode != sampleStatusCode {
		t.Errorf("expected StatusCode to be \"%d\", got \"%d\"", sampleStatusCode, targetResponse.ResponseCommon.StatusCode)
	}

	if targetResponse.Header.Get("Content-Type") != "application/json" {
		t.Errorf("expected headers to match")
	}

	if targetResponse.Error != sampleError {
		t.Errorf("expected Error to be \"%s\", got \"%s\"", sampleError, targetResponse.ResponseCommon.Error)
	}

	if targetResponse.ErrorStatus != sampleErrorStatus {
		t.Errorf("expected ErrorStatus to be \"%d\", got \"%d\"", sampleErrorStatus, targetResponse.ResponseCommon.ErrorStatus)
	}

	if targetResponse.ErrorMessage != sampleErrorMessage {
		t.Errorf("expected ErrorMessage to be \"%s\", got \"%s\"", sampleErrorMessage, targetResponse.ResponseCommon.ErrorMessage)
	}
}

func TestQueryStringBuilderAllQuery(t *testing.T) {
	t.Parallel()

	// For structs where every member has a query tag
	type Struct struct {
		Foo string `query:"foo"`
		Bar string `query:"bar"`
	}
	v := &Struct{Foo: "value", Bar: "value"}
	expectedQueryString := `bar=value&foo=value`

	req, err := http.NewRequest("GET", "https://example.com", nil)
	if err != nil {
		t.Error("request creation failed")
	}

	q, err := buildQueryString(req, v)
	if err != nil {
		t.Errorf("expected buildQueryString to not error, got \"%s\"", err)
	}
	if q != expectedQueryString {
		t.Errorf(`expected q to be "%s", got "%s"`, expectedQueryString, q)
	}
}

func TestQueryStringBuilderPartialQuery(t *testing.T) {
	t.Parallel()

	// For structs where only some members have a query tag
	type Struct struct {
		Foo string `query:"foo"`
		Bar string `json:"bar"`
	}
	v := &Struct{Foo: "value", Bar: "value"}
	expectedQueryString := `foo=value`

	req, err := http.NewRequest("GET", "https://example.com", nil)
	if err != nil {
		t.Error("request creation failed")
	}

	q, err := buildQueryString(req, v)
	if err != nil {
		t.Errorf("expected buildQueryString to not error, got \"%s\"", err)
	}
	if q != expectedQueryString {
		t.Errorf(`expected q to be "%s", got "%s"`, expectedQueryString, q)
	}
}

func TestQueryStringBuilderNoQuery(t *testing.T) {
	t.Parallel()

	// For structs where no members have query tags
	type Struct struct {
		Foo string `json:"foo"`
		Bar string `json:"bar"`
	}
	v := &Struct{Foo: "value", Bar: "value"}
	expectedQueryString := ``

	req, err := http.NewRequest("GET", "https://example.com", nil)
	if err != nil {
		t.Error("request creation failed")
	}

	q, err := buildQueryString(req, v)
	if err != nil {
		t.Errorf("expected buildQueryString to not error, got \"%s\"", err)
	}
	if q != expectedQueryString {
		t.Errorf(`expected q to be "%s", got "%s"`, expectedQueryString, q)
	}
}