sdk_test.go.templ

package sdk

import (
	"bytes"
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"reflect"
	"strings"
	"testing"
	"time"
)

func TestNewClient(t *testing.T) {
	type args struct {
		optFns []func(*options)
	}
	tests := []struct {
		name    string
		envVar  string
		args    args
		want    Client
		wantErr bool
	}{
		{
			name:   "happy path",
			envVar: "foo",
			args: args{
				optFns: nil,
			},
			want: &client{
				options: options{
					key:        "foo",
					httpClient: &http.Client{Timeout: defaultTimeout},
				},
				baseURL: baseURL,
			},
			wantErr: false,
		},
		{
			name:   "unhappy path: missing api key",
			envVar: "",
			args: args{
				optFns: nil,
			},
			want:    nil,
			wantErr: true,
		},
		{
			name:   "happy path: custom http client",
			envVar: "bar",
			args: args{
				optFns: []func(*options){
					WithHTTPClient(&http.Client{Timeout: 1 * time.Minute}),
				},
			},
			want: &client{
				options: options{
					key:        "bar",
					httpClient: &http.Client{Timeout: 1 * time.Minute},
				},
				baseURL: baseURL,
			},
			wantErr: false,
		},
		{
			name:   "happy path: custom http client and key from variadic fn",
			envVar: "",
			args: args{
				optFns: []func(*options){
					WithHTTPClient(&http.Client{Timeout: 1 * time.Minute}),
					WithAPIKey("bar"),
				},
			},
			want: &client{
				options: options{
					key:        "bar",
					httpClient: &http.Client{Timeout: 1 * time.Minute},
				},
				baseURL: baseURL,
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(
			tt.name, func(t *testing.T) {
				t.Setenv("NEON_API_KEY", tt.envVar)

				got, err := NewClient(tt.args.optFns...)
				if (err != nil) != tt.wantErr {
					t.Errorf("NewClient() error = %v, wantErr %v", err, tt.wantErr)
					return
				}
				if !reflect.DeepEqual(got, tt.want) {
					t.Errorf("NewClient() got = %v, want %v", got, tt.want)
				}

			},
		)
	}
}

type mockPayload struct {
	Foo string `json:"foo"`
}

type mockHttp struct {
	reqHeaders http.Header
	respBody   mockPayload
	err        Error
}

func (m *mockHttp) Do(req *http.Request) (*http.Response, error) {
	m.reqHeaders = req.Header

	if m.err.HTTPCode > 299 {
		o, _ := json.Marshal(m.err.errorResp)
		return &http.Response{
			StatusCode: m.err.HTTPCode,
			Request:    req,
			Body:       io.NopCloser(bytes.NewReader(o)),
		}, nil
	}

	var (
		err error
		r   []byte
	)
	if req.Body != nil {
		buf, err := io.ReadAll(req.Body)
		defer func() { _ = req.Body.Close() }()
		if err != nil {
			return nil, err
		}
		if err := json.Unmarshal(buf, &m.respBody); err != nil {
			return nil, err
		}
		m.respBody.Foo = "resp:" + strings.TrimPrefix(m.respBody.Foo, "req:")
	}

	if m.respBody.Foo != "" {
		r, err = json.Marshal(m.respBody)
		if err != nil {
			return nil, err
		}
	}

	return &http.Response{
		StatusCode:    m.err.HTTPCode,
		Body:          io.NopCloser(bytes.NewReader(r)),
		ContentLength: int64(len(r)),
		Request:       req,
	}, nil
}

func Test_client_requestHandler(t *testing.T) {
	type fields struct {
		options options
		baseURL string
	}
	type args struct {
		url             string
		t               string
		reqPayload      interface{}
		responsePayload interface{}
	}

	var respPayload mockPayload

	tests := []struct {
		name               string
		fields             fields
		args               args
		wantRequestHeaders http.Header
		wantResp           mockPayload
		wantErr            error
	}{
		{
			name: "happy path: post w payload",
			fields: fields{
				options: options{
					key: "foo",
					httpClient: &mockHttp{
						err: Error{HTTPCode: http.StatusOK},
					},
				},
				baseURL: "",
			},
			args: args{
				url:             "",
				t:               "POST",
				reqPayload:      mockPayload{Foo: "req:bar"},
				responsePayload: &respPayload,
			},
			wantRequestHeaders: http.Header{
				"Accept":        []string{"application/json"},
				"Content-Type":  []string{"application/json"},
				"Authorization": []string{"Bearer foo"},
			},
			wantResp: mockPayload{Foo: "resp:bar"},
			wantErr:  nil,
		},
		{
			name: "happy path: get w/o payload",
			fields: fields{
				options: options{
					key: "bar",
					httpClient: &mockHttp{
						err:      Error{HTTPCode: http.StatusOK},
						respBody: mockPayload{Foo: "resp:"},
					},
				},
				baseURL: "",
			},
			args: args{
				url:             "",
				t:               "GET",
				responsePayload: &respPayload,
			},
			wantRequestHeaders: http.Header{
				"Accept":        []string{"application/json"},
				"Content-Type":  []string{"application/json"},
				"Authorization": []string{"Bearer bar"},
			},
			wantResp: mockPayload{Foo: "resp:"},
			wantErr:  nil,
		},
		{
			name: "unhappy path: get w/o payload",
			fields: fields{
				options: options{
					key: "bar",
					httpClient: &mockHttp{
						err: Error{
							HTTPCode: http.StatusNotFound,
							errorResp: errorResp{
								Code:    "foo",
								Message: "bar",
							},
						},
					},
				},
				baseURL: "",
			},
			args: args{
				url:             "",
				t:               "GET",
				responsePayload: &respPayload,
			},
			wantRequestHeaders: http.Header{
				"Accept":        []string{"application/json"},
				"Content-Type":  []string{"application/json"},
				"Authorization": []string{"Bearer bar"},
			},
			wantResp: mockPayload{},
			wantErr: Error{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Code:    "foo",
					Message: "bar",
				},
			},
		},
		{
			name: "unhappy path: https://github.com/neondatabase/neon/issues/2159",
			fields: fields{
				options: options{
					key: "bar",
					httpClient: &mockHttp{
						err: Error{HTTPCode: http.StatusOK},
					},
				},
				baseURL: "",
			},
			args: args{
				url:             "",
				t:               "GET",
				responsePayload: &respPayload,
			},
			wantRequestHeaders: http.Header{
				"Accept":        []string{"application/json"},
				"Content-Type":  []string{"application/json"},
				"Authorization": []string{"Bearer bar"},
			},
			wantResp: mockPayload{},
			wantErr: Error{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Code:    "",
					Message: "object not found",
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(
			tt.name, func(t *testing.T) {
				c := &client{
					options: tt.fields.options,
					baseURL: tt.fields.baseURL,
				}
				respPayload = mockPayload{}

				if err := c.requestHandler(
					tt.args.url, tt.args.t, tt.args.reqPayload, tt.args.responsePayload,
				); err != tt.wantErr {
					t.Errorf("requestHandler() error = %v, wantErr %v", err, tt.wantErr)
				}

				if !reflect.DeepEqual(tt.wantRequestHeaders, (tt.fields.options.httpClient).(*mockHttp).reqHeaders) {
					t.Errorf("missing expected request headers")
				}

				if !reflect.DeepEqual(tt.wantResp, respPayload) {
					t.Errorf("response payload does not match expectations")
				}

			},
		)
	}
}

type faultyReader struct{}

func (f faultyReader) Read(_ []byte) (n int, err error) {
	return 1, errors.New("foo")
}

func Test_convertErrorResponse(t *testing.T) {
	type args struct {
		res *http.Response
	}
	tests := []struct {
		name    string
		args    args
		wantErr error
	}{
		{
			name: "happy path: not found",
			args: args{
				res: &http.Response{
					StatusCode: http.StatusNotFound,
					Body:       io.NopCloser(strings.NewReader(`{"code":"","message":"not found"}`)),
				},
			},
			wantErr: Error{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Message: "not found",
				},
			},
		},
		{
			name: "unhappy path: faulty body content",
			args: args{
				res: &http.Response{
					StatusCode: http.StatusNotFound,
					Body:       io.NopCloser(faultyReader{}),
				},
			},
			wantErr: Error{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Message: "cannot read response bytes",
				},
			},
		},
		{
			name: "unhappy path: faulty json",
			args: args{
				res: &http.Response{
					StatusCode: http.StatusNotFound,
					Body:       io.NopCloser(strings.NewReader(`{`)),
				},
			},
			wantErr: Error{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Message: "unexpected end of JSON input",
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(
			tt.name, func(t *testing.T) {
				if err := convertErrorResponse(tt.args.res); !reflect.DeepEqual(tt.wantErr, err) {
					t.Errorf("convertErrorResponse() error = %v, wantErr %v", err, tt.wantErr)
				}
			},
		)
	}
}

func TestError_Error(t *testing.T) {
	type fields struct {
		HTTPCode  int
		errorResp errorResp
	}
	tests := []struct {
		name   string
		fields fields
		want   string
	}{
		{
			name: "404",
			fields: fields{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Message: "object not found",
				},
			},
			want: "[HTTP Code: 404][Error Code: ] object not found",
		},
		{
			name: "406",
			fields: fields{
				HTTPCode: http.StatusNotAcceptable,
				errorResp: errorResp{
					Code:    "foo",
					Message: "bar",
				},
			},
			want: "[HTTP Code: 406][Error Code: foo] bar",
		},
	}
	for _, tt := range tests {
		t.Run(
			tt.name, func(t *testing.T) {
				e := Error{
					HTTPCode:  tt.fields.HTTPCode,
					errorResp: tt.fields.errorResp,
				}
				if got := e.Error(); got != tt.want {
					t.Errorf("Error() = %s, want %s", got, tt.want)
				}
			},
		)
	}
}

func TestError_httpResp(t *testing.T) {
	type fields struct {
		HTTPCode  int
		errorResp errorResp
	}
	tests := []struct {
		name   string
		fields fields
		want   *http.Response
	}{
		{
			name: "",
			fields: fields{
				HTTPCode: http.StatusNotFound,
				errorResp: errorResp{
					Code:    "foo",
					Message: "object not found",
				},
			},
			want: &http.Response{
				Status:        "foo",
				StatusCode:    http.StatusNotFound,
				Body:          io.NopCloser(bytes.NewReader([]byte(`{"code":"foo","message":"object not found"}`))),
				ContentLength: int64(len(`{"code":"foo","message":"object not found"}`)),
			},
		},
	}
	for _, tt := range tests {
		t.Run(
			tt.name, func(t *testing.T) {
				e := Error{
					HTTPCode:  tt.fields.HTTPCode,
					errorResp: tt.fields.errorResp,
				}
				if got := e.httpResp(); !reflect.DeepEqual(got, tt.want) {
					t.Errorf("httpResp() = %v, want %v", got, tt.want)
				}
			},
		)
	}
}

{{ range .EndpointsImplementationTest }}
{{.}}
{{ end }}

func TestTypes(t *testing.T) {
	// GIVEN
	// the types are defined correctly

	// WHEN
	// check fields' types

	// THEN
	// optional fields of the complex types
	// are expected to be pointers to the underlying structs
	if reflect.TypeOf(EndpointCreateRequestEndpoint{}.Settings).Kind() != reflect.Ptr {
		t.Errorf("EndpointCreateRequestEndpoint{}.Settings must be pointer")
	}

	if reflect.TypeOf(EndpointUpdateRequestEndpoint{}.Settings).Kind() != reflect.Ptr {
		t.Errorf("EndpointUpdateRequestEndpoint{}.Settings must be pointer")
	}
}

type dummyType interface {
	int | int64 | int32 | bool | string | float64 | float32
}

func createPointer[V dummyType](v V) *V {
	return &v
}