mollie/chargebacks_test.go - Code Metrics - VictorAvelar/mollie-api-go - Measure and Improve Code Quality continuously with Scrutinizer

mollie/chargebacks_test.go A
last analyzed 2025-06-09 10:27 UTC

↳ Parent: Project

Size/Duplication

Total Lines	366
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	25
eloc	265
dl	0
loc	366
rs	10
c	0
b	0
f	0

3 Methods

Rating	Name	Size	Complexity
C	mollie.TestChargebacksService_Get	115	7
C	mollie.TestChargebacksService_List	110	9
C	mollie.TestChargebacksService_ListForPayment	118	9

package mollie

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

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

func TestChargebacksService_Get(t *testing.T) {
	setEnv()
	defer unsetEnv()

	type args struct {
		ctx        context.Context
		payment    string
		chargeback string
		options    *ChargebackOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"get chargebacks",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				"chb_n9z0tp",
				&ChargebackOptions{
					Include: []IncludeValue{IncludeQrCode},
				},
			},
			false,
			nil,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}

				_, _ = w.Write([]byte(testdata.GetChargebackResponse))
			},
			noPre,
		},
		{
			"get chargebacks returns an http error from the server",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				"chb_n9z0tp",
				&ChargebackOptions{
					Include: []IncludeValue{IncludeQrCode},
				},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			errorHandler,
			noPre,
		},
		{
			"get chargebacks returns an error when creating the request",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				"chb_n9z0tp",
				&ChargebackOptions{
					Include: []IncludeValue{IncludeQrCode},
				},
			},
			true,
			errBadBaseURL,
			errorHandler,
			func() {
				u, _ := url.Parse(tServer.URL)
				tClient.BaseURL = u
			},
		},
		{
			"get chargebacks returns an error when trying to parse the json response",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				"chb_n9z0tp",
				&ChargebackOptions{
					Include: []IncludeValue{IncludeQrCode},
				},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			encodingHandler,
			noPre,
		},
	}

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

			res, cb, err := tClient.Chargebacks.Get(c.args.ctx, c.args.payment, c.args.chargeback, c.args.options)
			if c.wantErr {
				assert.Error(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &Chargeback{}, cb)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestChargebacksService_List(t *testing.T) {
	setEnv()
	defer unsetEnv()

	type args struct {
		ctx     context.Context
		options *ListChargebacksOptions
	}

	noPre := func() {}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"list chargebacks",
			args{
				context.Background(),
				nil,
			},
			false,
			nil,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}

				_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
			},
			noPre,
		},
		{
			"list chargebacks with options",
			args{
				context.Background(),
				&ListChargebacksOptions{
					ProfileID: "pfl_QkEhN94Ba",
				},
			},
			false,
			nil,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}

				_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
			},
			noPre,
		},
		{
			"list chargebacks return an http error from the remote server",
			args{
				context.Background(),
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			errorHandler,
			noPre,
		},
		{
			"list chargebacks return an error when creating the requests",
			args{
				context.Background(),
				nil,
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"list chargebacks return an error when parsing the json response",
			args{
				context.Background(),
				nil,
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			encodingHandler,
			noPre,
		},
	}

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

			c.pre()
			res, cbl, err := tClient.Chargebacks.List(c.args.ctx, c.args.options)
			if c.wantErr {
				assert.Error(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &ChargebacksList{}, cbl)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

func TestChargebacksService_ListForPayment(t *testing.T) {
	setEnv()
	defer unsetEnv()

	type args struct {
		ctx     context.Context
		payment string
		options *ListChargebacksOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"list chargebacks attached to a payment",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			false,
			nil,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}

				_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
			},
			noPre,
		},
		{
			"list chargebacks attached to a payment, with options",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				&ListChargebacksOptions{
					ProfileID: "pfl_QkEhN94Ba",
				},
			},
			false,
			nil,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}

				_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
			},
			noPre,
		},
		{
			"list chargebacks returns an http error from the remote server",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			errorHandler,
			noPre,
		},
		{
			"list chargebacks returns an error when building the request",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			true,
			errBadBaseURL,
			func(rw http.ResponseWriter, r *http.Request) {},
			crashSrv,
		},
		{
			"list chargebacks returns an error when parsing the json response",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			encodingHandler,
			noPre,
		},
	}

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

			c.pre()

			res, cbl, err := tClient.Chargebacks.ListForPayment(c.args.ctx, c.args.payment, c.args.options)
			if c.wantErr {
				assert.Error(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &ChargebacksList{}, cbl)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}


1			package mollie
2
3			import (
4			"context"
5			"fmt"
6			"net/http"
7			"net/url"
8			"testing"
9
10			"github.com/VictorAvelar/mollie-api-go/v4/testdata"
11			"github.com/stretchr/testify/assert"
12			)
13
14			func TestChargebacksService_Get(t *testing.T) {
15			setEnv()
16			defer unsetEnv()
17
18			type args struct {
19			ctx context.Context
20			payment string
21			chargeback string
22			options *ChargebackOptions
23			}
24
25			cases := []struct {
26			name string
27			args args
28			wantErr bool
29			err error
30			handler http.HandlerFunc
31			pre func()
32			}{
33			{
34			"get chargebacks",
35			args{
36			context.Background(),
37			"tr_WDqYK6vllg",
38			"chb_n9z0tp",
39			&ChargebackOptions{
40			Include: []IncludeValue{IncludeQrCode},
41			},
42			},
43			false,
44			nil,
45			func(w http.ResponseWriter, r *http.Request) {
46			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
47			testMethod(t, r, "GET")
48			if _, ok := r.Header[AuthHeader]; !ok {
49			w.WriteHeader(http.StatusUnauthorized)
50			}
51
52			_, _ = w.Write([]byte(testdata.GetChargebackResponse))
53			},
54			noPre,
55			},
56			{
57			"get chargebacks returns an http error from the server",
58			args{
59			context.Background(),
60			"tr_WDqYK6vllg",
61			"chb_n9z0tp",
62			&ChargebackOptions{
63			Include: []IncludeValue{IncludeQrCode},
64			},
65			},
66			true,
67			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
68			errorHandler,
69			noPre,
70			},
71			{
72			"get chargebacks returns an error when creating the request",
73			args{
74			context.Background(),
75			"tr_WDqYK6vllg",
76			"chb_n9z0tp",
77			&ChargebackOptions{
78			Include: []IncludeValue{IncludeQrCode},
79			},
80			},
81			true,
82			errBadBaseURL,
83			errorHandler,
84			func() {
85			u, _ := url.Parse(tServer.URL)
86			tClient.BaseURL = u
87			},
88			},
89			{
90			"get chargebacks returns an error when trying to parse the json response",
91			args{
92			context.Background(),
93			"tr_WDqYK6vllg",
94			"chb_n9z0tp",
95			&ChargebackOptions{
96			Include: []IncludeValue{IncludeQrCode},
97			},
98			},
99			true,
100			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
101			encodingHandler,
102			noPre,
103			},
104			}
105
106			for _, c := range cases {
107			setup()
108			defer teardown()
109			t.Run(c.name, func(t *testing.T) {
110			tMux.HandleFunc(
111			fmt.Sprintf(
112			"/v2/payments/%s/chargebacks/%s",
113			c.args.payment,
114			c.args.chargeback,
115			),
116			c.handler,
117			)
118			c.pre()
119
120			res, cb, err := tClient.Chargebacks.Get(c.args.ctx, c.args.payment, c.args.chargeback, c.args.options)
121			if c.wantErr {
122			assert.Error(t, err)
123			assert.EqualError(t, err, c.err.Error())
124			} else {
125			assert.Nil(t, err)
126			assert.EqualValues(t, c.args.ctx, res.Request.Context())
127			assert.IsType(t, &Chargeback{}, cb)
128			assert.IsType(t, &http.Response{}, res.Response)
129			}
130			})
131			}
132			}
133
134			func TestChargebacksService_List(t *testing.T) {
135			setEnv()
136			defer unsetEnv()
137
138			type args struct {
139			ctx context.Context
140			options *ListChargebacksOptions
141			}
142
143			noPre := func() {}
144
145			cases := []struct {
146			name string
147			args args
148			wantErr bool
149			err error
150			handler http.HandlerFunc
151			pre func()
152			}{
153			{
154			"list chargebacks",
155			args{
156			context.Background(),
157			nil,
158			},
159			false,
160			nil,
161			func(w http.ResponseWriter, r *http.Request) {
162			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
163			testMethod(t, r, "GET")
164			if _, ok := r.Header[AuthHeader]; !ok {
165			w.WriteHeader(http.StatusUnauthorized)
166			}
167
168			_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
169			},
170			noPre,
171			},
172			{
173			"list chargebacks with options",
174			args{
175			context.Background(),
176			&ListChargebacksOptions{
177			ProfileID: "pfl_QkEhN94Ba",
178			},
179			},
180			false,
181			nil,
182			func(w http.ResponseWriter, r *http.Request) {
183			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
184			testMethod(t, r, "GET")
185			if _, ok := r.Header[AuthHeader]; !ok {
186			w.WriteHeader(http.StatusUnauthorized)
187			}
188
189			_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
190			},
191			noPre,
192			},
193			{
194			"list chargebacks return an http error from the remote server",
195			args{
196			context.Background(),
197			nil,
198			},
199			true,
200			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
201			errorHandler,
202			noPre,
203			},
204			{
205			"list chargebacks return an error when creating the requests",
206			args{
207			context.Background(),
208			nil,
209			},
210			true,
211			errBadBaseURL,
212			errorHandler,
213			crashSrv,
214			},
215			{
216			"list chargebacks return an error when parsing the json response",
217			args{
218			context.Background(),
219			nil,
220			},
221			true,
222			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
223			encodingHandler,
224			noPre,
225			},
226			}
227
228			for _, c := range cases {
229			setup()
230			defer teardown()
231			t.Run(c.name, func(t *testing.T) {
232			tMux.HandleFunc("/v2/chargebacks", c.handler)
233
234			c.pre()
235			res, cbl, err := tClient.Chargebacks.List(c.args.ctx, c.args.options)
236			if c.wantErr {
237			assert.Error(t, err)
238			assert.EqualError(t, err, c.err.Error())
239			} else {
240			assert.Nil(t, err)
241			assert.EqualValues(t, c.args.ctx, res.Request.Context())
242			assert.IsType(t, &ChargebacksList{}, cbl)
243			assert.IsType(t, &http.Response{}, res.Response)
244			}
245			})
246			}
247			}
248
249			func TestChargebacksService_ListForPayment(t *testing.T) {
250			setEnv()
251			defer unsetEnv()
252
253			type args struct {
254			ctx context.Context
255			payment string
256			options *ListChargebacksOptions
257			}
258
259			cases := []struct {
260			name string
261			args args
262			wantErr bool
263			err error
264			handler http.HandlerFunc
265			pre func()
266			}{
267			{
268			"list chargebacks attached to a payment",
269			args{
270			context.Background(),
271			"tr_WDqYK6vllg",
272			nil,
273			},
274			false,
275			nil,
276			func(w http.ResponseWriter, r *http.Request) {
277			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
278			testMethod(t, r, "GET")
279			if _, ok := r.Header[AuthHeader]; !ok {
280			w.WriteHeader(http.StatusUnauthorized)
281			}
282
283			_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
284			},
285			noPre,
286			},
287			{
288			"list chargebacks attached to a payment, with options",
289			args{
290			context.Background(),
291			"tr_WDqYK6vllg",
292			&ListChargebacksOptions{
293			ProfileID: "pfl_QkEhN94Ba",
294			},
295			},
296			false,
297			nil,
298			func(w http.ResponseWriter, r *http.Request) {
299			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
300			testMethod(t, r, "GET")
301			if _, ok := r.Header[AuthHeader]; !ok {
302			w.WriteHeader(http.StatusUnauthorized)
303			}
304
305			_, _ = w.Write([]byte(testdata.ListChargebacksResponse))
306			},
307			noPre,
308			},
309			{
310			"list chargebacks returns an http error from the remote server",
311			args{
312			context.Background(),
313			"tr_WDqYK6vllg",
314			nil,
315			},
316			true,
317			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
318			errorHandler,
319			noPre,
320			},
321			{
322			"list chargebacks returns an error when building the request",
323			args{
324			context.Background(),
325			"tr_WDqYK6vllg",
326			nil,
327			},
328			true,
329			errBadBaseURL,
330			func(rw http.ResponseWriter, r *http.Request) {},
331			crashSrv,
332			},
333			{
334			"list chargebacks returns an error when parsing the json response",
335			args{
336			context.Background(),
337			"tr_WDqYK6vllg",
338			nil,
339			},
340			true,
341			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
342			encodingHandler,
343			noPre,
344			},
345			}
346
347			for _, c := range cases {
348			setup()
349			defer teardown()
350			t.Run(c.name, func(t *testing.T) {
351			tMux.HandleFunc(
352			fmt.Sprintf("/v2/payments/%s/chargebacks", c.args.payment),
353			c.handler,
354			)
355
356			c.pre()
357
358			res, cbl, err := tClient.Chargebacks.ListForPayment(c.args.ctx, c.args.payment, c.args.options)
359			if c.wantErr {
360			assert.Error(t, err)
361			assert.EqualError(t, err, c.err.Error())
362			} else {
363			assert.Nil(t, err)
364			assert.EqualValues(t, c.args.ctx, res.Request.Context())
365			assert.IsType(t, &ChargebacksList{}, cbl)
366			assert.IsType(t, &http.Response{}, res.Response)
367			}
368			})
369			}
370			}
371

VictorAvelar / mollie-api-go

GitHub Access Token became invalid

mollie/chargebacks_test.go A last analyzed 2025-06-09 10:27 UTC

Size/Duplication

Importance

3 Methods

Duplication Side-by-Side

Filter issues like

mollie/chargebacks_test.go A
last analyzed 2025-06-09 10:27 UTC