Updated clients

Author: djthorpe

pkg/client/client.go

@@ -1,7 +1,6 @@
 package client
 
 import (
-	"bytes"
 	"encoding/json"
 	"encoding/xml"
 	"fmt"
@@ -129,32 +128,24 @@ func (client *Client) Do(in Payload, out any, opts ...RequestOpt) error {
 	}(now)
 
 	// Make a request
-	var body io.Reader
 	var method string = http.MethodGet
 	var accept, mimetype string
 	if in != nil {
-		if in.Type() != "" {
-			data, err := json.Marshal(in)
-			if err != nil {
-				return err
-			}
-			body = bytes.NewReader(data)
-		}
 		method = in.Method()
 		accept = in.Accept()
 		mimetype = in.Type()
 	}
-	req, err := client.request(method, accept, mimetype, body)
+	req, err := client.request(method, accept, mimetype, in)
 	if err != nil {
 		return err
 	}
 
 	// If debug, then log the payload
-	if debug, ok := client.Client.Transport.(*logtransport); ok {
-		if body != nil {
-			debug.Payload(in)
-		}
-	}
+	//if debug, ok := client.Client.Transport.(*logtransport); ok {
+	//	if body != nil {
+	//		debug.Payload(in)
+	//	}
+	//}
 
 	// If client token is set, then add to request
 	if client.token.Scheme != "" && client.token.Value != "" {

pkg/client/payload.go

@@ -1,46 +1,109 @@
 package client
 
 import (
+	"bytes"
+	"encoding/json"
+	"io"
 	"net/http"
+	"strconv"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
-type Payload interface {
-	Type() string
-	Method() string
-	Accept() string
-}
-
-type payload struct {
+type Request struct {
 	method   string
 	accept   string
 	mimetype string
+	buffer   *bytes.Buffer
+}
+
+type Payload interface {
+	io.Reader
+
+	Method() string
+	Accept() string
+	Type() string
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-func NewGetPayload(accept string) Payload {
-	this := new(payload)
+// Return a new empty request which defaults to GET. The accept parameter is the
+// accepted mime-type of the response.
+func NewRequest(accept string) *Request {
+	this := new(Request)
 	this.method = http.MethodGet
-	this.mimetype = ContentTypeJson
 	this.accept = accept
 	return this
 }
 
+// Return a new request with a JSON payload which defaults to GET. The accept
+// parameter is the accepted mime-type of the response.
+func NewJSONRequest(payload any, accept string) (*Request, error) {
+	this := new(Request)
+	this.method = http.MethodGet
+	this.mimetype = ContentTypeJson
+	this.accept = accept
+	this.buffer = new(bytes.Buffer)
+	if err := json.NewEncoder(this.buffer).Encode(payload); err != nil {
+		return nil, err
+	}
+	return this, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (req *Request) String() string {
+	str := "<payload"
+	if req.method != "" {
+		str += " method=" + strconv.Quote(req.method)
+	}
+	if req.accept != "" {
+		str += " accept=" + strconv.Quote(req.accept)
+	}
+	if req.mimetype != "" {
+		str += " mimetype=" + strconv.Quote(req.mimetype)
+	}
+	return str + ">"
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PAYLOAD METHODS
 
-func (payload *payload) Method() string {
-	return payload.method
+// Set the HTTP method to POST
+func (req *Request) Post() *Request {
+	req.method = http.MethodPost
+	return req
+}
+
+// Set the HTTP method to DELETE
+func (req *Request) Delete() *Request {
+	req.method = http.MethodDelete
+	return req
+}
+
+// Return the HTTP method
+func (req *Request) Method() string {
+	return req.method
+}
+
+// Set the request mimetype
+func (req *Request) Type() string {
+	return req.mimetype
 }
 
-func (payload *payload) Accept() string {
-	return payload.accept
+// Return the acceptable mimetype responses
+func (req *Request) Accept() string {
+	return req.accept
 }
 
-func (payload *payload) Type() string {
-	return payload.mimetype
+// Implements the io.Reader interface for a payload
+func (req *Request) Read(b []byte) (n int, err error) {
+	if req.buffer != nil {
+		return req.buffer.Read(b)
+	} else {
+		return 0, io.EOF
+	}
 }

pkg/client/payload_test.go

@@ -0,0 +1,18 @@
+package client_test
+
+import (
+	"testing"
+
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_payload_001(t *testing.T) {
+	assert := assert.New(t)
+	payload := client.NewPayload(client.ContentTypeBinary)
+	assert.NotNil(payload)
+	assert.Equal("GET", payload.Method())
+	assert.Equal(client.ContentTypeJson, payload.Type())
+	assert.Equal(client.ContentTypeBinary, payload.Accept())
+}

pkg/client/transport.go

@@ -48,10 +48,10 @@ func (transport *logtransport) Payload(v interface{}) {
 
 // RoundTrip is called as part of the request/response cycle
 func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	fmt.Fprintln(transport.w, "req:", req.Method, redactedUrl(req.URL))
+	fmt.Fprintln(transport.w, "request:", req.Method, redactedUrl(req.URL))
 	if transport.v {
 		for key := range req.Header {
-			fmt.Fprintf(transport.w, "  <= %v: %q\n", key, req.Header.Get(key))
+			fmt.Fprintf(transport.w, "  => %v: %q\n", key, req.Header.Get(key))
 		}
 	}
 	then := time.Now()
@@ -60,11 +60,11 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 	}()
 	resp, err := transport.RoundTripper.RoundTrip(req)
 	if err != nil {
-		fmt.Fprintln(transport.w, "  => Error:", err)
+		fmt.Fprintln(transport.w, "error:", err)
 	} else {
-		fmt.Fprintln(transport.w, "  =>", resp.Status)
+		fmt.Fprintln(transport.w, "response:", resp.Status)
 		for k, v := range resp.Header {
-			fmt.Fprintf(transport.w, "  => %v: %q\n", k, v)
+			fmt.Fprintf(transport.w, "  <= %v: %q\n", k, v)
 		}
 		// If verbose is switched on, read the body
 		if transport.v && resp.Body != nil {

pkg/ipify/client.go

@@ -5,7 +5,6 @@ to test the client package.
 package ipify
 
 import (
-	"net/http"
 	"net/url"
 
 	// Packages
@@ -19,35 +18,20 @@ type Client struct {
 	*client.Client
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// GLOBALS
-
-const (
-	endPoint = "https://api.ipify.org/"
-)
-
-///////////////////////////////////////////////////////////////////////////////
-// SCHEMA
-
 type Request struct {
-	client.Payload `json:"-"`
+	client.Request
 }
 
 type Response struct {
 	IP string `json:"ip"`
 }
 
-func (r Request) Method() string {
-	return http.MethodGet
-}
-
-func (r Request) Type() string {
-	return ""
-}
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
 
-func (r Request) Accept() string {
-	return client.ContentTypeJson
-}
+const (
+	endPoint = "https://api.ipify.org/"
+)
 
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
@@ -70,30 +54,8 @@ func New(opts ...client.ClientOpt) (*Client, error) {
 // Get returns the current IP address from the API
 func (c *Client) Get() (Response, error) {
 	var response Response
-	if err := c.Do(nil, &response, client.OptQuery(url.Values{"format": []string{"json"}})); err != nil {
+	if err := c.Do(client.NewRequest(client.ContentTypeJson), &response, client.OptQuery(url.Values{"format": []string{"json"}})); err != nil {
 		return Response{}, err
 	}
 	return response, nil
 }
-
-///////////////////////////////////////////////////////////////////////////////
-// WRITER IMPLEMENTATION
-
-func (Response) Columns() []string {
-	return []string{"IP"}
-}
-
-func (r Response) Count() int {
-	if r.IP == "" {
-		return 0
-	} else {
-		return 1
-	}
-}
-
-func (r Response) Row(n int) []any {
-	if n != 0 {
-		return nil
-	}
-	return []any{r.IP}
-}