moved stats to non-pointers; added some unit tests; organized a bit of code to new files

Author: mpholcomb

Makefile

@@ -15,10 +15,8 @@ vet:
 
 .PHONY: test
 test:
-	go test ./...
+	go test -cover ./...
 
 .PHONY: run-example
 run-example:
 	go run example/main.go
-
-# TODO: deal with coverfiles

client.go

@@ -3,41 +3,9 @@
 package listennotes
 
 import (
-	"encoding/json"
-	"fmt"
 	"net/http"
 )
 
-// Base urls for access the available api endpoints
-const (
-	BaseURLProduction = "https://listen-api.listennotes.com/api/v2"
-	BaseURLTest       = "https://listen-api-test.listennotes.com/api/v2"
-)
-
-// Request header keys
-const (
-	RequestHeaderKeyAPI = "X-ListenAPI-Key"
-)
-
-// Reponse header keys
-const (
-	ResponseHeaderKeyFreeQuota       = "X-ListenAPI-FreeQuota"
-	ResponseHeaderKeyUsage           = "X-ListenAPI-Usage"
-	ResponseHeaderKeyLatencySeconds  = "X-listenAPI-Latency-Seconds"
-	ResponseHeaderKeyNextBillingDate = "X-Listenapi-NextBillingDate"
-)
-
-// TimeFormat is the string format of all response times
-const TimeFormat = "2006-01-02T15:04:05.000000+07:00"
-
-var defaultHTTPClient *http.Client = &http.Client{}
-
-// Response is the standard response for all client functions
-type Response struct {
-	Stats ResponseStatistics
-	Data  map[string]interface{}
-}
-
 // HTTPClient is the client interface
 type HTTPClient interface {
 	Search(args map[string]string) (*Response, error)
@@ -74,44 +42,5 @@ func NewClient(apiKey string, opts ...ClientOption) HTTPClient {
 }
 
 func (c *standardHTTPClient) Search(args map[string]string) (*Response, error) {
-
-	// TODO: move all this common stuff to a function
-	url := fmt.Sprintf("%s/search", c.baseURL)
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Add(RequestHeaderKeyAPI, c.apiKey)
-
-	q := req.URL.Query()
-	for k, v := range args {
-		q.Add(k, v)
-	}
-	req.URL.RawQuery = q.Encode()
-
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to executing request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	// map any generic status code errors
-	if mappedError, ok := errMap[resp.StatusCode]; ok && mappedError != nil {
-		return nil, mappedError
-	}
-
-	// generic body parsing
-	var genericJSON map[string]interface{}
-	if err := json.NewDecoder(resp.Body).Decode(&genericJSON); err != nil {
-		return nil, fmt.Errorf("failed parsing the response: %w", err)
-	}
-
-	// gather the header statistics
-	stats := parseStats(resp)
-
-	return &Response{
-		Stats: stats,
-		Data:  genericJSON,
-	}, nil
+	return c.execute(args, "search")
 }

client_test.go

@@ -0,0 +1,55 @@
+package listennotes_test
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"testing"
+
+	listennotes "github.com/ListenNotes/podcast-api-go"
+)
+
+func TestMockURL(t *testing.T) {
+	noDial := fmt.Errorf("no-dial")
+
+	httpClient := &http.Client{
+		Transport: &http.Transport{
+			Dial: func(network, addr string) (net.Conn, error) {
+				if addr != "listen-api-test.listennotes.com:443" {
+					t.Errorf("custom baseURL was not used: %s", addr)
+				}
+				return nil, noDial
+			},
+		},
+	}
+
+	client := listennotes.NewClient("", listennotes.WithHTTPClient(httpClient))
+	_, err := client.Search(map[string]string{"q": "a"})
+
+	if !errors.Is(err, noDial) {
+		t.Errorf("mock http client failure was not as expected: %s", err)
+	}
+}
+
+func TestProductionURL(t *testing.T) {
+	noDial := fmt.Errorf("no-dial")
+
+	httpClient := &http.Client{
+		Transport: &http.Transport{
+			Dial: func(network, addr string) (net.Conn, error) {
+				if addr != "listen-api.listennotes.com:443" {
+					t.Errorf("custom baseURL was not used: %s", addr)
+				}
+				return nil, noDial
+			},
+		},
+	}
+
+	client := listennotes.NewClient("anapikey", listennotes.WithHTTPClient(httpClient))
+	_, err := client.Search(map[string]string{"q": "a"})
+
+	if !errors.Is(err, noDial) {
+		t.Errorf("mock http client failure was not as expected: %s", err)
+	}
+}

constants.go

@@ -0,0 +1,23 @@
+package listennotes
+
+// Base urls for access the available api endpoints
+const (
+	BaseURLProduction = "https://listen-api.listennotes.com/api/v2"
+	BaseURLTest       = "https://listen-api-test.listennotes.com/api/v2"
+)
+
+// Request header keys
+const (
+	RequestHeaderKeyAPI = "X-ListenAPI-Key"
+)
+
+// Reponse header keys
+const (
+	ResponseHeaderKeyFreeQuota       = "X-ListenAPI-FreeQuota"
+	ResponseHeaderKeyUsage           = "X-ListenAPI-Usage"
+	ResponseHeaderKeyLatencySeconds  = "X-listenAPI-Latency-Seconds"
+	ResponseHeaderKeyNextBillingDate = "X-Listenapi-NextBillingDate"
+)
+
+// TimeFormat is the string format of all response times
+const TimeFormat = "2006-01-02T15:04:05.999999-07:00"

example/main.go

@@ -14,7 +14,6 @@ func main() {
 	// the test data will return the same page each time, but this is an example of getting the next_offset out fo the resulting payload
 	nextOffset := fetchAndOutputPage(client, 0)
 	fetchAndOutputPage(client, nextOffset)
-	fetchAndOutputPage(client, nextOffset)
 }
 
 func fetchAndOutputPage(client listennotes.HTTPClient, offset int) int {

httpclient.go

@@ -0,0 +1,17 @@
+package listennotes
+
+import (
+	"net"
+	"net/http"
+	"time"
+)
+
+var defaultHTTPClient = &http.Client{
+	Timeout: time.Second * 30,
+	Transport: &http.Transport{
+		Dial: (&net.Dialer{
+			Timeout: 10 * time.Second,
+		}).Dial,
+		TLSHandshakeTimeout: 10 * time.Second,
+	},
+}

options_test.go

@@ -0,0 +1,54 @@
+package listennotes_test
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"testing"
+
+	listennotes "github.com/ListenNotes/podcast-api-go"
+)
+
+func TestWithHTTPOptions(t *testing.T) {
+
+	noDial := fmt.Errorf("no-dial")
+
+	httpClient := &http.Client{
+		Transport: &http.Transport{
+			Dial: func(network, addr string) (net.Conn, error) {
+				return nil, noDial
+			},
+		},
+	}
+
+	client := listennotes.NewClient("", listennotes.WithHTTPClient(httpClient))
+	_, err := client.Search(map[string]string{"q": "a"})
+
+	if !errors.Is(err, noDial) {
+		t.Errorf("mock http client failure was not as expected: %s", err)
+	}
+
+}
+
+func TestWithBaseURL(t *testing.T) {
+	noDial := fmt.Errorf("no-dial")
+
+	httpClient := &http.Client{
+		Transport: &http.Transport{
+			Dial: func(network, addr string) (net.Conn, error) {
+				if addr != "localhost:80" {
+					t.Errorf("custom baseURL was not used: %s", addr)
+				}
+				return nil, noDial
+			},
+		},
+	}
+
+	client := listennotes.NewClient("", listennotes.WithHTTPClient(httpClient), listennotes.WithBaseURL("http://localhost/test-url"))
+	_, err := client.Search(map[string]string{"q": "a"})
+
+	if !errors.Is(err, noDial) {
+		t.Errorf("mock http client failure was not as expected: %s", err)
+	}
+}

request.go

@@ -0,0 +1,54 @@
+package listennotes
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// Response is the standard response for all client functions
+type Response struct {
+	Stats ResponseStatistics
+	Data  map[string]interface{}
+}
+
+func (c *standardHTTPClient) execute(args map[string]string, path string) (*Response, error) {
+	url := fmt.Sprintf("%s/%s", c.baseURL, path)
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request to %s: %w", path, err)
+	}
+	req.Header.Add(RequestHeaderKeyAPI, c.apiKey)
+
+	q := req.URL.Query()
+	for k, v := range args {
+		q.Add(k, v)
+	}
+	req.URL.RawQuery = q.Encode()
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to executing request to %s: %w", path, err)
+	}
+	defer resp.Body.Close()
+
+	// map any generic status code errors
+	if mappedError, ok := errMap[resp.StatusCode]; ok && mappedError != nil {
+		return nil, mappedError
+	}
+
+	// generic body parsing
+	var genericJSON map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&genericJSON); err != nil {
+		return nil, fmt.Errorf("failed parsing the response from %s: %w", path, err)
+	}
+
+	// gather the header statistics
+	stats := parseStats(resp)
+
+	return &Response{
+		Stats: stats,
+		Data:  genericJSON,
+	}, nil
+}

request_test.go

@@ -0,0 +1,7 @@
+package listennotes
+
+import "testing"
+
+func TestStandardClientExecute(t *testing.T) {
+
+}

stats.go

@@ -8,10 +8,10 @@ import (
 
 // ResponseStatistics will contain the stats information provided by API response headers
 type ResponseStatistics struct {
-	FreeQuota       *int
-	Usage           *int
-	LatencySeconds  *float64
-	NextBillingDate *time.Time
+	FreeQuota       int
+	Usage           int
+	LatencySeconds  float64
+	NextBillingDate time.Time
 }
 
 func parseStats(resp *http.Response) ResponseStatistics {
@@ -21,16 +21,17 @@ func parseStats(resp *http.Response) ResponseStatistics {
 	stats := ResponseStatistics{}
 
 	if freeQuota, err := strconv.Atoi(resp.Header.Get(ResponseHeaderKeyFreeQuota)); err == nil {
-		stats.FreeQuota = &freeQuota
+		stats.FreeQuota = freeQuota
 	}
 	if usage, err := strconv.Atoi(resp.Header.Get(ResponseHeaderKeyUsage)); err == nil {
-		stats.Usage = &usage
+		stats.Usage = usage
 	}
 	if latency, err := strconv.ParseFloat(resp.Header.Get(ResponseHeaderKeyLatencySeconds), 64); err == nil {
-		stats.LatencySeconds = &latency
+		stats.LatencySeconds = latency
 	}
-	if nextBill, err := time.Parse(resp.Header.Get(ResponseHeaderKeyNextBillingDate), ""); err == nil {
-		stats.NextBillingDate = &nextBill
+
+	if nextBill, err := time.Parse(TimeFormat, resp.Header.Get(ResponseHeaderKeyNextBillingDate)); err == nil {
+		stats.NextBillingDate = nextBill
 	}
 
 	return stats