make Do use Raw

Author: scriptnull

client.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -41,38 +42,24 @@ func NewClient(gqlEndpoint string, opt *ClientOpts) *Client {
 	return c
 }
 
-func (c *Client) Do(ctx context.Context, q Queryable) (*bytes.Buffer, error) {
-	reqObj := graphqlRequest{
-		Query:     q.Query(),
-		Variables: q.Variables(),
-	}
-
-	var reqBytes bytes.Buffer
-	err := json.NewEncoder(&reqBytes).Encode(&reqObj)
-	if err != nil {
-		return nil, err
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.endpoint, &reqBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Add("Content-Type", "application/json")
-	for key, value := range c.headers {
-		req.Header.Add(key, value)
-	}
+var (
+	ErrHTTPRedirect     = errors.New("redirected request with http status code")
+	ErrHTTPFailedStatus = errors.New("error response with http status code")
+)
 
-	resp, err := c.httpClient.Do(req)
+// Do performs a gql query and returns early if faced with a non-successful http status code.
+func (c *Client) Do(ctx context.Context, q Queryable) (*bytes.Buffer, error) {
+	resp, err := c.Raw(ctx, q)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
 
 	switch {
 	case resp.StatusCode > 299 && resp.StatusCode < 399:
-		return nil, fmt.Errorf("redirected request with http status code: %d", resp.StatusCode)
+		return nil, fmt.Errorf("%w: %d", ErrHTTPRedirect, resp.StatusCode)
 	case resp.StatusCode > 399:
-		return nil, fmt.Errorf("error response with http status code: %d", resp.StatusCode)
+		return nil, fmt.Errorf("%w: %d", ErrHTTPFailedStatus, resp.StatusCode)
 	}
 
 	var respBytes bytes.Buffer

client_test.go

@@ -3,6 +3,7 @@ package eywa_test
 import (
 	"bytes"
 	"context"
+	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -24,6 +25,82 @@ func (m *MockQuerable) Variables() map[string]interface{} {
 	return m.Vars
 }
 
+func TestDoClient(t *testing.T) {
+	tt := []struct {
+		name             string
+		server           *httptest.Server
+		expectedErr      error
+		expectedResponse []byte
+	}{
+		{
+			name: "Valid GQL response",
+			server: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte(`{"data": {"test": "test"}}`))
+			})),
+			expectedResponse: []byte(`{"data": {"test": "test"}}`),
+		},
+		{
+			name: "A 401 response",
+			server: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusUnauthorized)
+				w.Write([]byte(`{"error": {"message": "unauthorized"}}`))
+			})),
+			expectedErr: eywa.ErrHTTPFailedStatus,
+		},
+		{
+			name: "A 403 response",
+			server: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusUnauthorized)
+				w.Write([]byte(`{"error": {"message": "forbidden"}}`))
+			})),
+			expectedErr: eywa.ErrHTTPFailedStatus,
+		},
+		{
+			name: "A 503 non-json response",
+			server: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusServiceUnavailable)
+				w.Write([]byte(`Service unavailable`))
+			})),
+			expectedErr: eywa.ErrHTTPFailedStatus,
+		},
+		{
+			name: "A 301 Redirect",
+			server: httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusMovedPermanently)
+				w.Write([]byte(`Moved Permanently`))
+			})),
+			expectedErr: eywa.ErrHTTPRedirect,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			gqlClient := eywa.NewClient(tc.server.URL, nil)
+			resp, err := gqlClient.Do(context.TODO(), &MockQuerable{})
+			if err != nil && tc.expectedErr == nil {
+				t.Errorf("Expected no error, got %v", err)
+				return
+			}
+			if err == nil && tc.expectedErr != nil {
+				t.Errorf("Expected error %v, got nil", tc.expectedErr)
+				return
+			}
+			if err != nil && tc.expectedErr != nil {
+				if !errors.Is(err, tc.expectedErr) {
+					t.Errorf("Expected error %v, got %v", tc.expectedErr, err)
+					return
+				}
+				return
+			}
+			if !bytes.Equal(tc.expectedResponse, resp.Bytes()) {
+				t.Errorf("Expected response %s, got %s", string(tc.expectedResponse), resp.String())
+				return
+			}
+		})
+	}
+}
+
 func TestRawClient(t *testing.T) {
 	tt := []struct {
 		name             string