mollie.TestRefundsService_ListOrderRefunds - Code Metrics - Inspection of "Merge pull request #327 from VictorAvelar/review-s..." - VictorAvelar/mollie-api-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ade00f...013a6a )

unknown

created 2024-03-16 07:54 UTC

mollie.TestRefundsService_ListOrderRefunds C

↳ Parent: mollie/refunds_test.go

Complexity

Conditions

Size

Total Lines	102
Code Lines	79

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	79
nop	1
dl	0
loc	102
rs	6.7539
c	0
b	0
f	0

How to fix Long Method

package mollie

import (
	"context"
	"fmt"
	"net/http"
	"testing"

	"github.com/VictorAvelar/mollie-api-go/v4/testdata"
	"github.com/stretchr/testify/assert"
)

func TestRefundsService_CreatePaymentRefund(t *testing.T) {
	type args struct {
		ctx       context.Context
		paymentID string
		re        CreatePaymentRefund
		options   *PaymentRefundOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"create payment refund works as expected",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				CreatePaymentRefund{
					Amount: &Amount{
						Value:    "5.00",
						Currency: "EUR",
					},
				},
				&PaymentRefundOptions{},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusCreated)
				w.Write([]byte(testdata.CreatePaymentRefundResponse))
			},
		},
		{
			"create payment refund works as expected with access tokens",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				CreatePaymentRefund{
					Amount: &Amount{
						Value:    "5.00",
						Currency: "EUR",
					},
				},
				&PaymentRefundOptions{},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusCreated)
				w.Write([]byte(testdata.CreatePaymentRefundResponse))
			},
		},
		{
			"create payment refund, an error is returned from the server",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				CreatePaymentRefund{},
				&PaymentRefundOptions{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"create payment refund, an error occurs when parsing json",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				CreatePaymentRefund{},
				&PaymentRefundOptions{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get settlement refunds, invalid url when building request",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				CreatePaymentRefund{},
				&PaymentRefundOptions{},
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s/refunds", c.args.paymentID), c.handler)

			res, ref, err := tClient.Refunds.CreatePaymentRefund(
				c.args.ctx,
				c.args.paymentID,
				c.args.re,
				c.args.options,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Refund{}, ref)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestRefundsService_GetPaymentRefund(t *testing.T) {
	type args struct {
		ctx       context.Context
		paymentID string
		refundID  string
		opts      *PaymentRefundOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get payment refund works as expected",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
				&PaymentRefundOptions{},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.GetPaymentRefundResponse))
			},
		},
		{
			"get payment refund works as expected with access tokens",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
				&PaymentRefundOptions{},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.GetPaymentRefundResponse))
			},
		},
		{
			"get payment refund, an error is returned from the server",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
				&PaymentRefundOptions{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"get payment refund, an error occurs when parsing json",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
				&PaymentRefundOptions{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get payment refund, invalid url when building request",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
				&PaymentRefundOptions{},
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc(
				fmt.Sprintf("/v2/payments/%s/refunds/%s", c.args.paymentID, c.args.refundID),
				c.handler,
			)

			res, ref, err := tClient.Refunds.GetPaymentRefund(
				c.args.ctx,
				c.args.paymentID,
				c.args.refundID,
				c.args.opts,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Refund{}, ref)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestRefundsService_ListPaymentRefunds(t *testing.T) {
	type args struct {
		ctx       context.Context
		paymentID string
		opts      *RefundsListOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"list payment refunds works as expected",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				&RefundsListOptions{},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.ListPaymentRefundsResponse))
			},
		},
		{
			"list payment refunds works as expected with access tokens",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				&RefundsListOptions{},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.ListPaymentRefundsResponse))
			},
		},
		{
			"list payment refunds, an error is returned from the server",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				&RefundsListOptions{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"list payment refunds, an error occurs when parsing json",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				&RefundsListOptions{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"list payment refunds, invalid url when building request",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				&RefundsListOptions{},
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s/refunds", c.args.paymentID), c.handler)

			res, rl, err := tClient.Refunds.ListPaymentRefunds(
				c.args.ctx,
				c.args.paymentID,
				c.args.opts,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &RefundsList{}, rl)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestRefundsService_CancelPaymentRefund(t *testing.T) {
	type args struct {
		ctx       context.Context
		paymentID string
		refundID  string
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"cancel payment refund works as expected",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusNoContent)
			},
		},
		{
			"cancel payment refund works as expected with access tokens",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusNoContent)
			},
		},
		{
			"cancel payment refund, an error is returned from the server",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"cancel payment refund, invalid url when building request",
			args{
				context.Background(),
				"tr_7UhSN1zuXS",
				"re_4qqhO89gsT",
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc(
				fmt.Sprintf("/v2/payments/%s/refunds/%s", c.args.paymentID, c.args.refundID),
				c.handler,
			)

			res, err := tClient.Refunds.CancelPaymentRefund(
				c.args.ctx,
				c.args.paymentID,
				c.args.refundID,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestRefundsService_CreateOrderRefund(t *testing.T) {
	type args struct {
		ctx     context.Context
		orderID string
		r       CreateOrderRefund
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"create order refund works as expected",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				CreateOrderRefund{
					Lines: []*OrderRefundLine{
						{
							ID:       "odl_dgtxyl",
							Quantity: 1,
							Amount:   &Amount{Value: "5.00", Currency: "EUR"},
						},
					},
				},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusCreated)
				w.Write([]byte(testdata.CreateOrderRefundResponse))
			},
		},
		{
			"create order refund works as expected with access tokens",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				CreateOrderRefund{
					Lines: []*OrderRefundLine{
						{
							ID:       "odl_dgtxyl",
							Quantity: 1,
							Amount:   &Amount{Value: "5.00", Currency: "EUR"},
						},
					},
				},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusCreated)
				w.Write([]byte(testdata.CreateOrderRefundResponse))
			},
		},
		{
			"create order refund, an error is returned from the server",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				CreateOrderRefund{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"create order refund, an error occurs when parsing json",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				CreateOrderRefund{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"create order refund, invalid url when building request",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				CreateOrderRefund{},
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc(fmt.Sprintf("/v2/orders/%s/refunds", c.args.orderID), c.handler)

			res, ref, err := tClient.Refunds.CreateOrderRefund(
				c.args.ctx,
				c.args.orderID,
				c.args.r,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Refund{}, ref)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestRefundsService_ListOrderRefunds(t *testing.T) {
	type args struct {
		ctx     context.Context
		orderID string
		opts    *RefundsListOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"list order refunds works as expected",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				&RefundsListOptions{},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.ListOrderRefundsResponse))
			},
		},
		{
			"list order refunds works as expected with access tokens",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				&RefundsListOptions{},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.ListOrderRefundsResponse))
			},
		},
		{
			"list order refunds, an error is returned from the server",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				&RefundsListOptions{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"list order refunds, an error occurs when parsing json",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				&RefundsListOptions{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"list order refunds, invalid url when building request",
			args{
				context.Background(),
				"ord_8wmqcHMN4U",
				&RefundsListOptions{},
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc(fmt.Sprintf("/v2/orders/%s/refunds", c.args.orderID), c.handler)

			res, rl, err := tClient.Refunds.ListOrderRefunds(
				c.args.ctx,
				c.args.orderID,
				c.args.opts,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &RefundsList{}, rl)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestRefundsService_List(t *testing.T) {
	type args struct {
		ctx  context.Context
		opts *RefundsListOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"list refunds works as expected",
			args{
				context.Background(),
				&RefundsListOptions{},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.ListRefundsResponse))
			},
		},
		{
			"list refunds works as expected with access tokens",
			args{
				context.Background(),
				&RefundsListOptions{},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(testdata.ListRefundsResponse))
			},
		},
		{
			"list refunds, an error is returned from the server",
			args{
				context.Background(),
				&RefundsListOptions{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"list refunds, an error occurs when parsing json",
			args{
				context.Background(),
				&RefundsListOptions{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"list refunds, invalid url when building request",
			args{
				context.Background(),
				&RefundsListOptions{},
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()
		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc("/v2/refunds", c.handler)

			res, rl, err := tClient.Refunds.List(
				c.args.ctx,
				c.args.opts,
			)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error(), "error message does not match")
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &RefundsList{}, rl)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}


1			package mollie
2
3			import (
4			"context"
5			"fmt"
6			"net/http"
7			"testing"
8
9			"github.com/VictorAvelar/mollie-api-go/v4/testdata"
10			"github.com/stretchr/testify/assert"
11			)
12
13			func TestRefundsService_CreatePaymentRefund(t *testing.T) {
14			type args struct {
15			ctx context.Context
16			paymentID string
17			re CreatePaymentRefund
18			options *PaymentRefundOptions
19			}
20
21			cases := []struct {
22			name string
23			args args
24			wantErr bool
25			err error
26			pre func()
27			handler http.HandlerFunc
28			}{
29			{
30			"create payment refund works as expected",
31			args{
32			context.Background(),
33			"tr_7UhSN1zuXS",
34			CreatePaymentRefund{
35			Amount: &Amount{
36			Value: "5.00",
37			Currency: "EUR",
38			},
39			},
40			&PaymentRefundOptions{},
41			},
42			false,
43			nil,
44			noPre,
45			func(w http.ResponseWriter, r *http.Request) {
46			w.WriteHeader(http.StatusCreated)
47			w.Write([]byte(testdata.CreatePaymentRefundResponse))
48			},
49			},
50			{
51			"create payment refund works as expected with access tokens",
52			args{
53			context.Background(),
54			"tr_7UhSN1zuXS",
55			CreatePaymentRefund{
56			Amount: &Amount{
57			Value: "5.00",
58			Currency: "EUR",
59			},
60			},
61			&PaymentRefundOptions{},
62			},
63			false,
64			nil,
65			setAccessToken,
66			func(w http.ResponseWriter, r *http.Request) {
67			w.WriteHeader(http.StatusCreated)
68			w.Write([]byte(testdata.CreatePaymentRefundResponse))
69			},
70			},
71			{
72			"create payment refund, an error is returned from the server",
73			args{
74			context.Background(),
75			"tr_7UhSN1zuXS",
76			CreatePaymentRefund{},
77			&PaymentRefundOptions{},
78			},
79			true,
80			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
81			noPre,
82			errorHandler,
83			},
84			{
85			"create payment refund, an error occurs when parsing json",
86			args{
87			context.Background(),
88			"tr_7UhSN1zuXS",
89			CreatePaymentRefund{},
90			&PaymentRefundOptions{},
91			},
92			true,
93			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
94			noPre,
95			encodingHandler,
96			},
97			{
98			"get settlement refunds, invalid url when building request",
99			args{
100			context.Background(),
101			"tr_7UhSN1zuXS",
102			CreatePaymentRefund{},
103			&PaymentRefundOptions{},
104			},
105			true,
106			errBadBaseURL,
107			crashSrv,
108			errorHandler,
109			},
110			}
111
112			for _, c := range cases {
113			setup()
114			defer teardown()
115			t.Run(c.name, func(t *testing.T) {
116			c.pre()
117			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s/refunds", c.args.paymentID), c.handler)
118
119			res, ref, err := tClient.Refunds.CreatePaymentRefund(
120			c.args.ctx,
121			c.args.paymentID,
122			c.args.re,
123			c.args.options,
124			)
125			if c.wantErr {
126			assert.NotNil(t, err)
127			assert.EqualError(t, err, c.err.Error())
128			} else {
129			assert.Nil(t, err)
130			assert.IsType(t, &Refund{}, ref)
131			assert.IsType(t, &http.Response{}, res.Response)
132			}
133			})
134			}
135			}
136
137			func TestRefundsService_GetPaymentRefund(t *testing.T) {
138			type args struct {
139			ctx context.Context
140			paymentID string
141			refundID string
142			opts *PaymentRefundOptions
143			}
144
145			cases := []struct {
146			name string
147			args args
148			wantErr bool
149			err error
150			pre func()
151			handler http.HandlerFunc
152			}{
153			{
154			"get payment refund works as expected",
155			args{
156			context.Background(),
157			"tr_7UhSN1zuXS",
158			"re_4qqhO89gsT",
159			&PaymentRefundOptions{},
160			},
161			false,
162			nil,
163			noPre,
164			func(w http.ResponseWriter, r *http.Request) {
165			w.WriteHeader(http.StatusOK)
166			w.Write([]byte(testdata.GetPaymentRefundResponse))
167			},
168			},
169			{
170			"get payment refund works as expected with access tokens",
171			args{
172			context.Background(),
173			"tr_7UhSN1zuXS",
174			"re_4qqhO89gsT",
175			&PaymentRefundOptions{},
176			},
177			false,
178			nil,
179			setAccessToken,
180			func(w http.ResponseWriter, r *http.Request) {
181			w.WriteHeader(http.StatusOK)
182			w.Write([]byte(testdata.GetPaymentRefundResponse))
183			},
184			},
185			{
186			"get payment refund, an error is returned from the server",
187			args{
188			context.Background(),
189			"tr_7UhSN1zuXS",
190			"re_4qqhO89gsT",
191			&PaymentRefundOptions{},
192			},
193			true,
194			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
195			noPre,
196			errorHandler,
197			},
198			{
199			"get payment refund, an error occurs when parsing json",
200			args{
201			context.Background(),
202			"tr_7UhSN1zuXS",
203			"re_4qqhO89gsT",
204			&PaymentRefundOptions{},
205			},
206			true,
207			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
208			noPre,
209			encodingHandler,
210			},
211			{
212			"get payment refund, invalid url when building request",
213			args{
214			context.Background(),
215			"tr_7UhSN1zuXS",
216			"re_4qqhO89gsT",
217			&PaymentRefundOptions{},
218			},
219			true,
220			errBadBaseURL,
221			crashSrv,
222			errorHandler,
223			},
224			}
225
226			for _, c := range cases {
227			setup()
228			defer teardown()
229			t.Run(c.name, func(t *testing.T) {
230			c.pre()
231			tMux.HandleFunc(
232			fmt.Sprintf("/v2/payments/%s/refunds/%s", c.args.paymentID, c.args.refundID),
233			c.handler,
234			)
235
236			res, ref, err := tClient.Refunds.GetPaymentRefund(
237			c.args.ctx,
238			c.args.paymentID,
239			c.args.refundID,
240			c.args.opts,
241			)
242			if c.wantErr {
243			assert.NotNil(t, err)
244			assert.EqualError(t, err, c.err.Error())
245			} else {
246			assert.Nil(t, err)
247			assert.IsType(t, &Refund{}, ref)
248			assert.IsType(t, &http.Response{}, res.Response)
249			}
250			})
251			}
252			}
253
254			func TestRefundsService_ListPaymentRefunds(t *testing.T) {
255			type args struct {
256			ctx context.Context
257			paymentID string
258			opts *RefundsListOptions
259			}
260
261			cases := []struct {
262			name string
263			args args
264			wantErr bool
265			err error
266			pre func()
267			handler http.HandlerFunc
268			}{
269			{
270			"list payment refunds works as expected",
271			args{
272			context.Background(),
273			"tr_7UhSN1zuXS",
274			&RefundsListOptions{},
275			},
276			false,
277			nil,
278			noPre,
279			func(w http.ResponseWriter, r *http.Request) {
280			w.WriteHeader(http.StatusOK)
281			w.Write([]byte(testdata.ListPaymentRefundsResponse))
282			},
283			},
284			{
285			"list payment refunds works as expected with access tokens",
286			args{
287			context.Background(),
288			"tr_7UhSN1zuXS",
289			&RefundsListOptions{},
290			},
291			false,
292			nil,
293			setAccessToken,
294			func(w http.ResponseWriter, r *http.Request) {
295			w.WriteHeader(http.StatusOK)
296			w.Write([]byte(testdata.ListPaymentRefundsResponse))
297			},
298			},
299			{
300			"list payment refunds, an error is returned from the server",
301			args{
302			context.Background(),
303			"tr_7UhSN1zuXS",
304			&RefundsListOptions{},
305			},
306			true,
307			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
308			noPre,
309			errorHandler,
310			},
311			{
312			"list payment refunds, an error occurs when parsing json",
313			args{
314			context.Background(),
315			"tr_7UhSN1zuXS",
316			&RefundsListOptions{},
317			},
318			true,
319			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
320			noPre,
321			encodingHandler,
322			},
323			{
324			"list payment refunds, invalid url when building request",
325			args{
326			context.Background(),
327			"tr_7UhSN1zuXS",
328			&RefundsListOptions{},
329			},
330			true,
331			errBadBaseURL,
332			crashSrv,
333			errorHandler,
334			},
335			}
336
337			for _, c := range cases {
338			setup()
339			defer teardown()
340			t.Run(c.name, func(t *testing.T) {
341			c.pre()
342			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s/refunds", c.args.paymentID), c.handler)
343
344			res, rl, err := tClient.Refunds.ListPaymentRefunds(
345			c.args.ctx,
346			c.args.paymentID,
347			c.args.opts,
348			)
349			if c.wantErr {
350			assert.NotNil(t, err)
351			assert.EqualError(t, err, c.err.Error())
352			} else {
353			assert.Nil(t, err)
354			assert.IsType(t, &RefundsList{}, rl)
355			assert.IsType(t, &http.Response{}, res.Response)
356			}
357			})
358			}
359			}
360
361			func TestRefundsService_CancelPaymentRefund(t *testing.T) {
362			type args struct {
363			ctx context.Context
364			paymentID string
365			refundID string
366			}
367
368			cases := []struct {
369			name string
370			args args
371			wantErr bool
372			err error
373			pre func()
374			handler http.HandlerFunc
375			}{
376			{
377			"cancel payment refund works as expected",
378			args{
379			context.Background(),
380			"tr_7UhSN1zuXS",
381			"re_4qqhO89gsT",
382			},
383			false,
384			nil,
385			noPre,
386			func(w http.ResponseWriter, r *http.Request) {
387			w.WriteHeader(http.StatusNoContent)
388			},
389			},
390			{
391			"cancel payment refund works as expected with access tokens",
392			args{
393			context.Background(),
394			"tr_7UhSN1zuXS",
395			"re_4qqhO89gsT",
396			},
397			false,
398			nil,
399			setAccessToken,
400			func(w http.ResponseWriter, r *http.Request) {
401			w.WriteHeader(http.StatusNoContent)
402			},
403			},
404			{
405			"cancel payment refund, an error is returned from the server",
406			args{
407			context.Background(),
408			"tr_7UhSN1zuXS",
409			"re_4qqhO89gsT",
410			},
411			true,
412			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
413			noPre,
414			errorHandler,
415			},
416			{
417			"cancel payment refund, invalid url when building request",
418			args{
419			context.Background(),
420			"tr_7UhSN1zuXS",
421			"re_4qqhO89gsT",
422			},
423			true,
424			errBadBaseURL,
425			crashSrv,
426			errorHandler,
427			},
428			}
429
430			for _, c := range cases {
431			setup()
432			defer teardown()
433			t.Run(c.name, func(t *testing.T) {
434			c.pre()
435			tMux.HandleFunc(
436			fmt.Sprintf("/v2/payments/%s/refunds/%s", c.args.paymentID, c.args.refundID),
437			c.handler,
438			)
439
440			res, err := tClient.Refunds.CancelPaymentRefund(
441			c.args.ctx,
442			c.args.paymentID,
443			c.args.refundID,
444			)
445			if c.wantErr {
446			assert.NotNil(t, err)
447			assert.EqualError(t, err, c.err.Error())
448			} else {
449			assert.Nil(t, err)
450			assert.IsType(t, &http.Response{}, res.Response)
451			}
452			})
453			}
454			}
455
456			func TestRefundsService_CreateOrderRefund(t *testing.T) {
457			type args struct {
458			ctx context.Context
459			orderID string
460			r CreateOrderRefund
461			}
462
463			cases := []struct {
464			name string
465			args args
466			wantErr bool
467			err error
468			pre func()
469			handler http.HandlerFunc
470			}{
471			{
472			"create order refund works as expected",
473			args{
474			context.Background(),
475			"ord_8wmqcHMN4U",
476			CreateOrderRefund{
477			Lines: []*OrderRefundLine{
478			{
479			ID: "odl_dgtxyl",
480			Quantity: 1,
481			Amount: &Amount{Value: "5.00", Currency: "EUR"},
482			},
483			},
484			},
485			},
486			false,
487			nil,
488			noPre,
489			func(w http.ResponseWriter, r *http.Request) {
490			w.WriteHeader(http.StatusCreated)
491			w.Write([]byte(testdata.CreateOrderRefundResponse))
492			},
493			},
494			{
495			"create order refund works as expected with access tokens",
496			args{
497			context.Background(),
498			"ord_8wmqcHMN4U",
499			CreateOrderRefund{
500			Lines: []*OrderRefundLine{
501			{
502			ID: "odl_dgtxyl",
503			Quantity: 1,
504			Amount: &Amount{Value: "5.00", Currency: "EUR"},
505			},
506			},
507			},
508			},
509			false,
510			nil,
511			setAccessToken,
512			func(w http.ResponseWriter, r *http.Request) {
513			w.WriteHeader(http.StatusCreated)
514			w.Write([]byte(testdata.CreateOrderRefundResponse))
515			},
516			},
517			{
518			"create order refund, an error is returned from the server",
519			args{
520			context.Background(),
521			"ord_8wmqcHMN4U",
522			CreateOrderRefund{},
523			},
524			true,
525			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
526			noPre,
527			errorHandler,
528			},
529			{
530			"create order refund, an error occurs when parsing json",
531			args{
532			context.Background(),
533			"ord_8wmqcHMN4U",
534			CreateOrderRefund{},
535			},
536			true,
537			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
538			noPre,
539			encodingHandler,
540			},
541			{
542			"create order refund, invalid url when building request",
543			args{
544			context.Background(),
545			"ord_8wmqcHMN4U",
546			CreateOrderRefund{},
547			},
548			true,
549			errBadBaseURL,
550			crashSrv,
551			errorHandler,
552			},
553			}
554
555			for _, c := range cases {
556			setup()
557			defer teardown()
558			t.Run(c.name, func(t *testing.T) {
559			c.pre()
560			tMux.HandleFunc(fmt.Sprintf("/v2/orders/%s/refunds", c.args.orderID), c.handler)
561
562			res, ref, err := tClient.Refunds.CreateOrderRefund(
563			c.args.ctx,
564			c.args.orderID,
565			c.args.r,
566			)
567			if c.wantErr {
568			assert.NotNil(t, err)
569			assert.EqualError(t, err, c.err.Error())
570			} else {
571			assert.Nil(t, err)
572			assert.IsType(t, &Refund{}, ref)
573			assert.IsType(t, &http.Response{}, res.Response)
574			}
575			})
576			}
577			}
578
579			func TestRefundsService_ListOrderRefunds(t *testing.T) {
580			type args struct {
581			ctx context.Context
582			orderID string
583			opts *RefundsListOptions
584			}
585
586			cases := []struct {
587			name string
588			args args
589			wantErr bool
590			err error
591			pre func()
592			handler http.HandlerFunc
593			}{
594			{
595			"list order refunds works as expected",
596			args{
597			context.Background(),
598			"ord_8wmqcHMN4U",
599			&RefundsListOptions{},
600			},
601			false,
602			nil,
603			noPre,
604			func(w http.ResponseWriter, r *http.Request) {
605			w.WriteHeader(http.StatusOK)
606			w.Write([]byte(testdata.ListOrderRefundsResponse))
607			},
608			},
609			{
610			"list order refunds works as expected with access tokens",
611			args{
612			context.Background(),
613			"ord_8wmqcHMN4U",
614			&RefundsListOptions{},
615			},
616			false,
617			nil,
618			setAccessToken,
619			func(w http.ResponseWriter, r *http.Request) {
620			w.WriteHeader(http.StatusOK)
621			w.Write([]byte(testdata.ListOrderRefundsResponse))
622			},
623			},
624			{
625			"list order refunds, an error is returned from the server",
626			args{
627			context.Background(),
628			"ord_8wmqcHMN4U",
629			&RefundsListOptions{},
630			},
631			true,
632			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
633			noPre,
634			errorHandler,
635			},
636			{
637			"list order refunds, an error occurs when parsing json",
638			args{
639			context.Background(),
640			"ord_8wmqcHMN4U",
641			&RefundsListOptions{},
642			},
643			true,
644			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
645			noPre,
646			encodingHandler,
647			},
648			{
649			"list order refunds, invalid url when building request",
650			args{
651			context.Background(),
652			"ord_8wmqcHMN4U",
653			&RefundsListOptions{},
654			},
655			true,
656			errBadBaseURL,
657			crashSrv,
658			errorHandler,
659			},
660			}
661
662			for _, c := range cases {
663			setup()
664			defer teardown()
665			t.Run(c.name, func(t *testing.T) {
666			c.pre()
667			tMux.HandleFunc(fmt.Sprintf("/v2/orders/%s/refunds", c.args.orderID), c.handler)
668
669			res, rl, err := tClient.Refunds.ListOrderRefunds(
670			c.args.ctx,
671			c.args.orderID,
672			c.args.opts,
673			)
674			if c.wantErr {
675			assert.NotNil(t, err)
676			assert.EqualError(t, err, c.err.Error())
677			} else {
678			assert.Nil(t, err)
679			assert.IsType(t, &RefundsList{}, rl)
680			assert.IsType(t, &http.Response{}, res.Response)
681			}
682			})
683			}
684			}
685
686			func TestRefundsService_List(t *testing.T) {
687			type args struct {
688			ctx context.Context
689			opts *RefundsListOptions
690			}
691
692			cases := []struct {
693			name string
694			args args
695			wantErr bool
696			err error
697			pre func()
698			handler http.HandlerFunc
699			}{
700			{
701			"list refunds works as expected",
702			args{
703			context.Background(),
704			&RefundsListOptions{},
705			},
706			false,
707			nil,
708			noPre,
709			func(w http.ResponseWriter, r *http.Request) {
710			w.WriteHeader(http.StatusOK)
711			w.Write([]byte(testdata.ListRefundsResponse))
712			},
713			},
714			{
715			"list refunds works as expected with access tokens",
716			args{
717			context.Background(),
718			&RefundsListOptions{},
719			},
720			false,
721			nil,
722			setAccessToken,
723			func(w http.ResponseWriter, r *http.Request) {
724			w.WriteHeader(http.StatusOK)
725			w.Write([]byte(testdata.ListRefundsResponse))
726			},
727			},
728			{
729			"list refunds, an error is returned from the server",
730			args{
731			context.Background(),
732			&RefundsListOptions{},
733			},
734			true,
735			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
736			noPre,
737			errorHandler,
738			},
739			{
740			"list refunds, an error occurs when parsing json",
741			args{
742			context.Background(),
743			&RefundsListOptions{},
744			},
745			true,
746			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
747			noPre,
748			encodingHandler,
749			},
750			{
751			"list refunds, invalid url when building request",
752			args{
753			context.Background(),
754			&RefundsListOptions{},
755			},
756			true,
757			errBadBaseURL,
758			crashSrv,
759			errorHandler,
760			},
761			}
762
763			for _, c := range cases {
764			setup()
765			defer teardown()
766			t.Run(c.name, func(t *testing.T) {
767			c.pre()
768			tMux.HandleFunc("/v2/refunds", c.handler)
769
770			res, rl, err := tClient.Refunds.List(
771			c.args.ctx,
772			c.args.opts,
773			)
774			if c.wantErr {
775			assert.NotNil(t, err)
776			assert.EqualError(t, err, c.err.Error(), "error message does not match")
777			} else {
778			assert.Nil(t, err)
779			assert.IsType(t, &RefundsList{}, rl)
780			assert.IsType(t, &http.Response{}, res.Response)
781			}
782			})
783			}
784			}
785

VictorAvelar / mollie-api-go

GitHub Access Token became invalid

Push — master ( ade00f...013a6a )

mollie.TestRefundsService_ListOrderRefunds C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like