Adding TFT API support (#69)

* TFT, wip

* Finsh TFT draft

* Add more docs

* Fix compilation errors

Author: happsie

internal/client.go

@@ -40,14 +40,14 @@ func NewClient(region api.Region, key string, client Doer, logger log.FieldLogge
 }
 
 // GetInto processes a GET request and saves the response body into the given target.
-func (c *Client) GetInto(endpoint string, target interface{}) error {
+func (c *Client) GetInto(endpoint string, target interface{}, reqOptions ...RequestOption) error {
 	logger := c.Logger().WithFields(
 		log.Fields{
 			"method":   "GetInto",
 			"endpoint": endpoint,
 		},
 	)
-	response, err := c.Get(endpoint)
+	response, err := c.Get(endpoint, reqOptions...)
 	if err != nil {
 		logger.Debug(err)
 		return err
@@ -60,14 +60,14 @@ func (c *Client) GetInto(endpoint string, target interface{}) error {
 }
 
 // PostInto processes a POST request and saves the response body into the given target.
-func (c *Client) PostInto(endpoint string, body, target interface{}) error {
+func (c *Client) PostInto(endpoint string, body, target interface{}, reqOptions ...RequestOption) error {
 	logger := c.Logger().WithFields(
 		log.Fields{
 			"method":   "PostInto",
 			"endpoint": endpoint,
 		},
 	)
-	response, err := c.Post(endpoint, body)
+	response, err := c.Post(endpoint, body, reqOptions...)
 	if err != nil {
 		logger.Debug(err)
 		return err
@@ -80,7 +80,7 @@ func (c *Client) PostInto(endpoint string, body, target interface{}) error {
 }
 
 // Put processes a PUT request.
-func (c *Client) Put(endpoint string, body interface{}) error {
+func (c *Client) Put(endpoint string, body interface{}, reqOptions ...RequestOption) error {
 	logger := c.Logger().WithFields(
 		log.Fields{
 			"method":   "Put",
@@ -92,17 +92,17 @@ func (c *Client) Put(endpoint string, body interface{}) error {
 		logger.Debug(err)
 		return err
 	}
-	_, err := c.DoRequest("PUT", endpoint, buf)
+	_, err := c.DoRequest("PUT", endpoint, buf, reqOptions)
 	return err
 }
 
 // Get processes a GET request.
-func (c *Client) Get(endpoint string) (*http.Response, error) {
-	return c.DoRequest("GET", endpoint, nil)
+func (c *Client) Get(endpoint string, reqOptions ...RequestOption) (*http.Response, error) {
+	return c.DoRequest("GET", endpoint, nil, reqOptions)
 }
 
 // Post processes a POST request.
-func (c *Client) Post(endpoint string, body interface{}) (*http.Response, error) {
+func (c *Client) Post(endpoint string, body interface{}, reqOptions ...RequestOption) (*http.Response, error) {
 	logger := c.Logger().WithFields(
 		log.Fields{
 			"method":   "Post",
@@ -114,19 +114,19 @@ func (c *Client) Post(endpoint string, body interface{}) (*http.Response, error)
 		logger.Debug(err)
 		return nil, err
 	}
-	return c.DoRequest("POST", endpoint, buf)
+	return c.DoRequest("POST", endpoint, buf, reqOptions)
 }
 
 // DoRequest processes a http.Request and returns the response.
 // Rate-Limiting and retrying is handled via the corresponding response headers.
-func (c *Client) DoRequest(method, endpoint string, body io.Reader) (*http.Response, error) {
+func (c *Client) DoRequest(method, endpoint string, body io.Reader, reqOptions []RequestOption) (*http.Response, error) {
 	logger := c.Logger().WithFields(
 		log.Fields{
 			"method":   "DoRequest",
 			"endpoint": endpoint,
 		},
 	)
-	request, err := c.NewRequest(method, endpoint, body)
+	request, err := c.NewRequest(method, endpoint, body, reqOptions...)
 	if err != nil {
 		logger.Debug(err)
 		return nil, err
@@ -154,7 +154,7 @@ func (c *Client) DoRequest(method, endpoint string, body io.Reader) (*http.Respo
 		}
 		logger.Infof("rate limited, waiting %d seconds", seconds)
 		time.Sleep(time.Duration(seconds) * time.Second)
-		return c.DoRequest(method, endpoint, body)
+		return c.DoRequest(method, endpoint, body, reqOptions)
 	}
 	if response.StatusCode < 200 || response.StatusCode > 299 {
 		logger.Debugf("error response: %v", response.Status)
@@ -171,7 +171,7 @@ func (c *Client) DoRequest(method, endpoint string, body io.Reader) (*http.Respo
 }
 
 // NewRequest returns a new http.Request with necessary headers et.
-func (c *Client) NewRequest(method, endpoint string, body io.Reader) (*http.Request, error) {
+func (c *Client) NewRequest(method, endpoint string, body io.Reader, reqOptions ...RequestOption) (*http.Request, error) {
 	logger := c.Logger().WithFields(
 		log.Fields{
 			"method":   "NewRequest",
@@ -185,6 +185,9 @@ func (c *Client) NewRequest(method, endpoint string, body io.Reader) (*http.Requ
 	}
 	request.Header.Add(apiTokenHeaderKey, c.APIKey)
 	request.Header.Add("Accept", "application/json")
+	for _, opt := range reqOptions {
+		opt(request)
+	}
 	return request, nil
 }
 

internal/client_test.go

@@ -93,7 +93,7 @@ func TestClient_DoRequest(t *testing.T) {
 		t.Run(
 			tt.name, func(t *testing.T) {
 				c := NewClient(api.RegionEuropeNorthEast, "", tt.doer, logrus.StandardLogger())
-				_, err := c.DoRequest(tt.args.method, tt.args.endpoint, tt.args.body)
+				_, err := c.DoRequest(tt.args.method, tt.args.endpoint, tt.args.body, nil)
 				assert.Equal(t, err != nil, tt.wantErr)
 			},
 		)

internal/request_options.go

@@ -0,0 +1,13 @@
+package internal
+
+import (
+	"net/http"
+)
+
+type RequestOption func(r *http.Request)
+
+func WithHeader(key, value string) RequestOption {
+	return func(r *http.Request) {
+		r.Header.Add(key, value)
+	}
+}

riot/client.go

@@ -10,6 +10,7 @@ import (
 	"github.com/KnutZuidema/golio/riot/account"
 	"github.com/KnutZuidema/golio/riot/lol"
 	"github.com/KnutZuidema/golio/riot/lor"
+	"github.com/KnutZuidema/golio/riot/tft"
 	"github.com/KnutZuidema/golio/riot/val"
 )
 
@@ -38,6 +39,7 @@ type Client struct {
 	LoL     *lol.Client
 	LoR     *lor.Client
 	Val     *val.Client
+	TFT     *tft.Client
 }
 
 // NewClient returns a new api client for the Riot API
@@ -48,6 +50,7 @@ func NewClient(region api.Region, apiKey string, client internal.Doer, logger lo
 		LoL:     lol.NewClient(baseClient),
 		LoR:     lor.NewClient(baseClient),
 		Val:     val.NewClient(baseClient),
+		TFT:     tft.NewClient(baseClient),
 	}
 
 	// TODO: deprecated, remove in a future release

riot/tft/client.go

@@ -0,0 +1,24 @@
+// Package tft allows you to interact with the Teamfight Tactics API
+package tft
+
+import "github.com/KnutZuidema/golio/internal"
+
+// Client pools all methods for endpoints of the League of Legends TFT API.
+type Client struct {
+	Spectator *SpectatorClient
+	League    *LeagueClient
+	Match     *MatchClient
+	Status    *StatusClient
+	Summoner  *SummonerClient
+}
+
+// NewClient returns a new instance of a League of Legends TFT client.
+func NewClient(base *internal.Client) *Client {
+	return &Client{
+		Spectator: &SpectatorClient{c: base},
+		League:    &LeagueClient{c: base},
+		Match:     &MatchClient{c: base},
+		Status:    &StatusClient{c: base},
+		Summoner:  &SummonerClient{c: base},
+	}
+}

riot/tft/client_test.go

@@ -0,0 +1,19 @@
+package tft
+
+import (
+	"testing"
+
+	log "github.com/sirupsen/logrus"
+
+	"github.com/KnutZuidema/golio/api"
+	"github.com/KnutZuidema/golio/internal"
+	"github.com/KnutZuidema/golio/internal/mock"
+)
+
+func TestNewClient(t *testing.T) {
+	t.Parallel()
+	c := NewClient(internal.NewClient(api.RegionEuropeNorthEast, "key", mock.NewStatusMockDoer(200), log.StandardLogger()))
+	if c == nil {
+		t.Error("returned nil")
+	}
+}

riot/tft/constants.go

@@ -0,0 +1,65 @@
+package tft
+
+const (
+	endpointBase          = "/tft"
+	endpointSpectatorBase = "/lol/spectator" + endpointBase
+
+	endpointSpectatorActiveGamedByPUUID = endpointSpectatorBase + "/v5/active-games/by-puuid/%s"
+	endpointSpectatorFeaturedGames      = endpointSpectatorBase + "/v5/featured-games"
+
+	endpointLeagueBase                = endpointBase + "/league/v1"
+	endpointLeagueChallenger          = endpointLeagueBase + "/challenger?queue=%s"
+	endpointLeagueEntriesBySummoner   = endpointLeagueBase + "/entries/by-summoner/%s"
+	endpointLeagueEntries             = endpointLeagueBase + "/entries/%s/%s"
+	endpointLeagueGrandMaster         = endpointLeagueBase + "/grandmaster?queue=%s"
+	endpointLeagueLeagues             = endpointLeagueBase + "/leagues/%s"
+	endpointLeagueMaster              = endpointLeagueBase + "/master?queue=%s"
+	endpointLeagueRatedLattersByQueue = endpointLeagueBase + "/rated-ladders/%s/top"
+
+	endpointMatchBase      = endpointBase + "/match/v1/matches"
+	endpointMatchesByPUUID = endpointMatchBase + "/by-puuid/%s/ids"
+	endpointMatchByMatchID = endpointMatchBase + "/%s"
+
+	endpointStatusBase         = endpointBase + "/status/v1"
+	endpointStatusPlatformData = endpointStatusBase + "/platform-data"
+
+	endpointSummonerBase         = endpointBase + "/summoner/v1/summoners"
+	endpointSummonerByAccount    = endpointSummonerBase + "/by-account/%s"
+	endpointSummonerByPUUID      = endpointSummonerBase + "/by-puuid/%s"
+	endpointSummonerByMe         = endpointSummonerBase + "/me"
+	endpointSummonerBySummonerID = endpointSummonerBase + "/%s"
+)
+
+type queue string
+
+const (
+	QueueRankedTFT         queue = "RANKED_TFT"
+	QueueRankedTFTDoubleUp queue = "RANKED_TFT_DOUBLE_UP"
+	QueueRankedTFTTurbo    queue = "RANKED_TFT_TURBO"
+)
+
+type tier string
+
+// All possible Tiers
+const (
+	TierIron        tier = "IRON"
+	TierBronze      tier = "BRONZE"
+	TierSilver      tier = "SILVER"
+	TierGold        tier = "GOLD"
+	TierPlatinum    tier = "PLATINUM"
+	TierEmerald     tier = "EMERALD"
+	TierDiamond     tier = "DIAMOND"
+	TierMaster      tier = "MASTER"
+	TierGrandMaster tier = "GRANDMASTER"
+	TierChallenger  tier = "CHALLENGER"
+)
+
+type division string
+
+// All possible divisions
+const (
+	DivisionOne   division = "I"
+	DivisionTwo   division = "II"
+	DivisionThree division = "III"
+	DivisionFour  division = "IV"
+)

riot/tft/league.go

@@ -0,0 +1,110 @@
+package tft
+
+import (
+	"fmt"
+
+	"github.com/KnutZuidema/golio/internal"
+	log "github.com/sirupsen/logrus"
+)
+
+// LeagueClient provides methods for league endpoints of the League of Legends TFT API.
+type LeagueClient struct {
+	c *internal.Client
+}
+
+// GetChallenger returns the current Challenger league for the Region
+func (lc *LeagueClient) GetChallenger(queue queue) (*LeagueList, error) {
+	logger := lc.logger().WithField("method", "GetChallenger")
+	if queue == "" {
+		queue = QueueRankedTFT
+	}
+	url := fmt.Sprintf(endpointLeagueChallenger, queue)
+	var out *LeagueList
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+// GetEntriesBySummoner returns league entries for a given summoner ID
+func (lc *LeagueClient) GetEntriesBySummoner(summonerID string) ([]*LeagueEntry, error) {
+	logger := lc.logger().WithField("method", "GetEntriesBySummoner")
+	url := fmt.Sprintf(endpointLeagueEntriesBySummoner, summonerID)
+	var out []*LeagueEntry
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+// GetEntries returns all the league entries
+func (lc *LeagueClient) GetEntries(tier tier, division division) ([]*LeagueEntry, error) {
+	logger := lc.logger().WithField("method", "GetEntries")
+	url := fmt.Sprintf(endpointLeagueEntries, tier, division)
+	var out []*LeagueEntry
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+// GetGrandMaster returns the current GrandMaster league for the Region
+func (lc *LeagueClient) GetGrandMaster(queue queue) (*LeagueList, error) {
+	logger := lc.logger().WithField("method", "GetGrandMaster")
+	if queue == "" {
+		queue = QueueRankedTFT
+	}
+	url := fmt.Sprintf(endpointLeagueGrandMaster, queue)
+	var out *LeagueList
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+// GetLeagues returns league with given ID, including inactive entries
+func (lc *LeagueClient) GetLeagues(leagueID string) (*LeagueList, error) {
+	logger := lc.logger().WithField("method", "GetLeagues")
+	url := fmt.Sprintf(endpointLeagueLeagues, leagueID)
+	var out *LeagueList
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+// GetMaster returns the current Master league for the Region
+func (lc *LeagueClient) GetMaster(queue queue) (*LeagueList, error) {
+	logger := lc.logger().WithField("method", "GetMaster")
+	if queue == "" {
+		queue = QueueRankedTFT
+	}
+	url := fmt.Sprintf(endpointLeagueMaster, queue)
+	var out *LeagueList
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+// GetRatedLaddersByQueue returns the top rated ladder for given queue
+func (lc *LeagueClient) GetRatedLaddersByQueue(queue queue) ([]*TopRatedLadderEntry, error) {
+	logger := lc.logger().WithField("method", "GetRatedLaddersByQueue")
+	url := fmt.Sprintf(endpointLeagueRatedLattersByQueue, queue)
+	var out []*TopRatedLadderEntry
+	if err := lc.c.GetInto(url, &out); err != nil {
+		logger.Debug(err)
+		return nil, err
+	}
+	return out, nil
+}
+
+func (lc *LeagueClient) logger() log.FieldLogger {
+	return lc.c.Logger().WithField("category", "league")
+}