If content-type explicitly something other than json don't try to parse body as json (#37)

* If content-type explicitly something other than json don't try to parse body as json

* new tests

* chore: prepare for 0.1.18 release

---------

Co-authored-by: Victor Lymar <[email protected]>

Author: pandemicsyn

knock/client.go

@@ -151,6 +151,18 @@ func (c *Client) handleResponse(ctx context.Context, res *http.Response, v inter
 			Message string `json:"message"`
 		}
 
+		// in some scenarios we don't fully control the response, e.g. an ELB 502.
+		if res.Header.Get("Content-Type") != jsonMediaType {
+			return nil, &Error{
+				msg:  "malformed non-json error response body received with status code: " + http.StatusText(res.StatusCode),
+				Code: ErrResponseMalformed,
+				Meta: map[string]string{
+					"body":        string(out),
+					"http_status": http.StatusText(res.StatusCode),
+				},
+			}
+		}
+
 		errorRes := &errorResponse{}
 		err = json.Unmarshal(out, errorRes)
 		if err != nil {

knock/client_test.go

@@ -0,0 +1,131 @@
+package knock
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestNewClient(t *testing.T) {
+	t.Run("default client", func(t *testing.T) {
+		client, err := NewClient()
+		if err != nil {
+			t.Fatalf("Expected no error, got %v", err)
+		}
+		if client == nil {
+			t.Fatal("Expected non-nil client")
+		}
+		if client.baseURL.String() != DefaultBaseUrl {
+			t.Errorf("Expected base URL %s, got %s", DefaultBaseUrl, client.baseURL.String())
+		}
+	})
+
+	t.Run("with custom base URL", func(t *testing.T) {
+		customURL := "https://custom.knock.app/"
+		client, err := NewClient(WithBaseURL(customURL))
+		if err != nil {
+			t.Fatalf("Expected no error, got %v", err)
+		}
+		if client == nil {
+			t.Fatal("Expected non-nil client")
+		}
+		if client.baseURL.String() != customURL {
+			t.Errorf("Expected base URL %s, got %s", customURL, client.baseURL.String())
+		}
+	})
+}
+
+func TestClientDo(t *testing.T) {
+	t.Run("successful request", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if !strings.Contains(r.Header.Get("User-Agent"), "Knock/Go v") {
+				t.Errorf("Expected User-Agent to contain 'Knock/Go v', got %s", r.Header.Get("User-Agent"))
+			}
+
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			err := json.NewEncoder(w).Encode(map[string]string{"message": "success"})
+			if err != nil {
+				t.Fatalf("Error encoding httptest response: %v", err)
+			}
+		}))
+		defer server.Close()
+
+		client, _ := NewClient(WithBaseURL(server.URL))
+		req, _ := client.newRequest("GET", "/test", nil, nil)
+
+		var response map[string]string
+		_, err := client.do(context.Background(), req, &response)
+
+		if err != nil {
+			t.Fatalf("Expected no error, got %v", err)
+		}
+		if response["message"] != "success" {
+			t.Errorf("Expected message 'success', got %s", response["message"])
+		}
+	})
+
+	t.Run("error response", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusNotFound)
+			err := json.NewEncoder(w).Encode(map[string]string{"code": "not_found", "message": "Resource not found"})
+			if err != nil {
+				t.Fatalf("Error encoding httptest response: %v", err)
+			}
+		}))
+		defer server.Close()
+
+		client, _ := NewClient(WithBaseURL(server.URL))
+		req, _ := client.newRequest("GET", "/test", nil, nil)
+
+		_, err := client.do(context.Background(), req, nil)
+
+		if err == nil {
+			t.Fatal("Expected error, got nil")
+		}
+		knockErr, ok := err.(*Error)
+		if !ok {
+			t.Fatalf("Expected error of type *Error, got %T", err)
+		}
+		if knockErr.Code != ErrNotFound {
+			t.Errorf("Expected error code %v, got %v", ErrNotFound, knockErr.Code)
+		}
+		if knockErr.Error() != "Resource not found" {
+			t.Errorf("Expected error message 'Resource not found', got %s", knockErr.Error())
+		}
+	})
+
+	t.Run("unexpected non-json response", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusBadGateway)
+			_, err := w.Write([]byte("502 Bad Gateway"))
+			if err != nil {
+				t.Fatalf("Error writing httptest response: %v", err)
+			}
+		}))
+		defer server.Close()
+
+		client, _ := NewClient(WithBaseURL(server.URL))
+		req, _ := client.newRequest("GET", "/test", nil, nil)
+
+		_, err := client.do(context.Background(), req, nil)
+
+		if err == nil {
+			t.Fatal("Expected error, got nil")
+		}
+		knockErr, ok := err.(*Error)
+		if !ok {
+			t.Fatalf("Expected error of type *Error, got %T", err)
+		}
+		if knockErr.Code != ErrResponseMalformed {
+			t.Errorf("Expected error code %v, got %v", ErrNotFound, knockErr.Code)
+		}
+		if knockErr.Error() != "malformed non-json error response body received with status code: Bad Gateway" {
+			t.Errorf("Expected error message 'Resource not found', got %s", knockErr.Error())
+		}
+	})
+}

knock/internal/sdk_version.go

@@ -2,4 +2,4 @@ package internal
 
 // SDKVersion is used to populate the sdk's user agent. It should be updated before
 // releasing new versions of the SDK. Eventually we can automate this process.
-const SDKVersion = "0.1.17"
+const SDKVersion = "0.1.18"