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

mollie.TestPaymentsService_Update C
last analyzed 2024-05-08 11:56 UTC

↳ Parent: mollie/payments_test.go

Complexity

Conditions

Size

Total Lines	118
Code Lines	88

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	88
nop	1
dl	0
loc	118
rs	5.0593
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 TestPaymentsService_Get(t *testing.T) {
	setEnv()
	defer unsetEnv()

	type args struct {
		ctx     context.Context
		payment string
		options *PaymentOptions
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get payments works as expected.",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				&PaymentOptions{
					Include: []IncludeValue{IncludeQrCode},
				},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				testQuery(t, r, "include=details.qrCode")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.GetPaymentResponse))
			},
		},
		{
			"get payments, an error is returned from the server",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"get payments, an error occurs when parsing json",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get payments, invalid url when building request",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				nil,
			},
			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", c.args.payment), c.handler)

			res, m, err := tClient.Payments.Get(c.args.ctx, c.args.payment, 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, &Payment{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx     context.Context
		options *ListPaymentsOptions
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get payments works as expected.",
			args{
				context.Background(),
				&ListPaymentsOptions{
					From: "tr_12o93213",
				},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "GET")
				testQuery(t, r, "from=tr_12o93213")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.ListPaymentsResponse))
			},
		},
		{
			"get payments, an error is returned from the server",
			args{
				context.Background(),
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"get payments, an error occurs when parsing json",
			args{
				context.Background(),
				nil,
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get payments, invalid url when building request",
			args{
				context.Background(),
				nil,
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()

		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc("/v2/payments", c.handler)

			res, m, err := tClient.Payments.List(c.args.ctx, 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, &PaymentList{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx     context.Context
		payment CreatePayment
		options *PaymentOptions
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"create payments works as expected.",
			args{
				context.Background(),
				CreatePayment{
					BillingEmail: "[email protected]",
				},
				&PaymentOptions{
					Include: []IncludeValue{},
				},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "POST")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.GetPaymentResponse))
			},
		},
		{
			"create payments with access token works as expected.",
			args{
				context.Background(),
				CreatePayment{
					BillingEmail: "[email protected]",
				},
				&PaymentOptions{
					Include: []IncludeValue{},
				},
			},
			false,
			nil,
			setAccessToken,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer access_token_test")
				testMethod(t, r, "POST")
				testQuery(t, r, "testmode=true")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.GetPaymentResponse))
			},
		},
		{
			"create payments, an error is returned from the server",
			args{
				context.Background(),
				CreatePayment{},
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"create payments, an error occurs when parsing json",
			args{
				context.Background(),
				CreatePayment{},
				nil,
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"create payments, invalid url when building request",
			args{
				context.Background(),
				CreatePayment{},
				nil,
			},
			true,
			errBadBaseURL,
			crashSrv,
			errorHandler,
		},
	}

	for _, c := range cases {
		setup()
		defer teardown()

		t.Run(c.name, func(t *testing.T) {
			c.pre()
			tMux.HandleFunc("/v2/payments", c.handler)

			res, m, err := tClient.Payments.Create(c.args.ctx, c.args.payment, 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, &Payment{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx     context.Context
		id      string
		payment UpdatePayment
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"update payments works as expected.",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				UpdatePayment{
					BillingEmail: "[email protected]",
				},
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "PATCH")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.UpdatePaymentResponse))
			},
		},
		{
			"update payments using access token works as expected.",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				UpdatePayment{
					BillingEmail: "[email protected]",
				},
			},
			false,
			nil,
			func() {
				tClient.WithAuthenticationValue("access_example_token")
			},
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer access_example_token")
				testMethod(t, r, "PATCH")
				testQuery(t, r, "testmode=true")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.UpdatePaymentResponse))
			},
		},
		{
			"update payments, an error is returned from the server",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				UpdatePayment{},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"update payments, an error occurs when parsing json",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				UpdatePayment{},
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"update payments, invalid url when building request",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
				UpdatePayment{},
			},
			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", c.args.id), c.handler)

			res, m, err := tClient.Payments.Update(c.args.ctx, c.args.id, c.args.payment)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Payment{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx context.Context
		id  string
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get payments works as expected.",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
			},
			false,
			nil,
			noPre,
			func(w http.ResponseWriter, r *http.Request) {
				testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
				testMethod(t, r, "DELETE")

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.GetPaymentResponse))
			},
		},
		{
			"get payments, an error is returned from the server",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			noPre,
			errorHandler,
		},
		{
			"get payments, an error occurs when parsing json",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get payments, invalid url when building request",
			args{
				context.Background(),
				"tr_WDqYK6vllg",
			},
			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", c.args.id), c.handler)

			res, m, err := tClient.Payments.Cancel(c.args.ctx, c.args.id)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Payment{}, m)
				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 TestPaymentsService_Get(t *testing.T) {
14			setEnv()
15			defer unsetEnv()
16
17			type args struct {
18			ctx context.Context
19			payment string
20			options *PaymentOptions
21			}
22			cases := []struct {
23			name string
24			args args
25			wantErr bool
26			err error
27			pre func()
28			handler http.HandlerFunc
29			}{
30			{
31			"get payments works as expected.",
32			args{
33			context.Background(),
34			"tr_WDqYK6vllg",
35			&PaymentOptions{
36			Include: []IncludeValue{IncludeQrCode},
37			},
38			},
39			false,
40			nil,
41			noPre,
42			func(w http.ResponseWriter, r *http.Request) {
43			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
44			testMethod(t, r, "GET")
45			testQuery(t, r, "include=details.qrCode")
46
47			if _, ok := r.Header[AuthHeader]; !ok {
48			w.WriteHeader(http.StatusUnauthorized)
49			}
50			_, _ = w.Write([]byte(testdata.GetPaymentResponse))
51			},
52			},
53			{
54			"get payments, an error is returned from the server",
55			args{
56			context.Background(),
57			"tr_WDqYK6vllg",
58			nil,
59			},
60			true,
61			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
62			noPre,
63			errorHandler,
64			},
65			{
66			"get payments, an error occurs when parsing json",
67			args{
68			context.Background(),
69			"tr_WDqYK6vllg",
70			nil,
71			},
72			true,
73			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
74			noPre,
75			encodingHandler,
76			},
77			{
78			"get payments, invalid url when building request",
79			args{
80			context.Background(),
81			"tr_WDqYK6vllg",
82			nil,
83			},
84			true,
85			errBadBaseURL,
86			crashSrv,
87			errorHandler,
88			},
89			}
90
91			for _, c := range cases {
92			setup()
93			defer teardown()
94
95			t.Run(c.name, func(t *testing.T) {
96			c.pre()
97			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s", c.args.payment), c.handler)
98
99			res, m, err := tClient.Payments.Get(c.args.ctx, c.args.payment, c.args.options)
100			if c.wantErr {
101			assert.NotNil(t, err)
102			assert.EqualError(t, err, c.err.Error())
103			} else {
104			assert.Nil(t, err)
105			assert.IsType(t, &Payment{}, m)
106			assert.IsType(t, &http.Response{}, res.Response)
107			}
108			})
109			}
110			}
111
112			func TestPaymentsService_List(t *testing.T) {
113			setEnv()
114			defer unsetEnv()
115
116			type args struct {
117			ctx context.Context
118			options *ListPaymentsOptions
119			}
120			cases := []struct {
121			name string
122			args args
123			wantErr bool
124			err error
125			pre func()
126			handler http.HandlerFunc
127			}{
128			{
129			"get payments works as expected.",
130			args{
131			context.Background(),
132			&ListPaymentsOptions{
133			From: "tr_12o93213",
134			},
135			},
136			false,
137			nil,
138			noPre,
139			func(w http.ResponseWriter, r *http.Request) {
140			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
141			testMethod(t, r, "GET")
142			testQuery(t, r, "from=tr_12o93213")
143
144			if _, ok := r.Header[AuthHeader]; !ok {
145			w.WriteHeader(http.StatusUnauthorized)
146			}
147			_, _ = w.Write([]byte(testdata.ListPaymentsResponse))
148			},
149			},
150			{
151			"get payments, an error is returned from the server",
152			args{
153			context.Background(),
154			nil,
155			},
156			true,
157			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
158			noPre,
159			errorHandler,
160			},
161			{
162			"get payments, an error occurs when parsing json",
163			args{
164			context.Background(),
165			nil,
166			},
167			true,
168			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
169			noPre,
170			encodingHandler,
171			},
172			{
173			"get payments, invalid url when building request",
174			args{
175			context.Background(),
176			nil,
177			},
178			true,
179			errBadBaseURL,
180			crashSrv,
181			errorHandler,
182			},
183			}
184
185			for _, c := range cases {
186			setup()
187			defer teardown()
188
189			t.Run(c.name, func(t *testing.T) {
190			c.pre()
191			tMux.HandleFunc("/v2/payments", c.handler)
192
193			res, m, err := tClient.Payments.List(c.args.ctx, c.args.options)
194			if c.wantErr {
195			assert.NotNil(t, err)
196			assert.EqualError(t, err, c.err.Error())
197			} else {
198			assert.Nil(t, err)
199			assert.IsType(t, &PaymentList{}, m)
200			assert.IsType(t, &http.Response{}, res.Response)
201			}
202			})
203			}
204			}
205
206			func TestPaymentsService_Create(t *testing.T) {
207			setEnv()
208			defer unsetEnv()
209
210			type args struct {
211			ctx context.Context
212			payment CreatePayment
213			options *PaymentOptions
214			}
215			cases := []struct {
216			name string
217			args args
218			wantErr bool
219			err error
220			pre func()
221			handler http.HandlerFunc
222			}{
223			{
224			"create payments works as expected.",
225			args{
226			context.Background(),
227			CreatePayment{
228			BillingEmail: "[email protected]",
229			},
230			&PaymentOptions{
231			Include: []IncludeValue{},
232			},
233			},
234			false,
235			nil,
236			noPre,
237			func(w http.ResponseWriter, r *http.Request) {
238			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
239			testMethod(t, r, "POST")
240
241			if _, ok := r.Header[AuthHeader]; !ok {
242			w.WriteHeader(http.StatusUnauthorized)
243			}
244			_, _ = w.Write([]byte(testdata.GetPaymentResponse))
245			},
246			},
247			{
248			"create payments with access token works as expected.",
249			args{
250			context.Background(),
251			CreatePayment{
252			BillingEmail: "[email protected]",
253			},
254			&PaymentOptions{
255			Include: []IncludeValue{},
256			},
257			},
258			false,
259			nil,
260			setAccessToken,
261			func(w http.ResponseWriter, r *http.Request) {
262			testHeader(t, r, AuthHeader, "Bearer access_token_test")
263			testMethod(t, r, "POST")
264			testQuery(t, r, "testmode=true")
265
266			if _, ok := r.Header[AuthHeader]; !ok {
267			w.WriteHeader(http.StatusUnauthorized)
268			}
269			_, _ = w.Write([]byte(testdata.GetPaymentResponse))
270			},
271			},
272			{
273			"create payments, an error is returned from the server",
274			args{
275			context.Background(),
276			CreatePayment{},
277			nil,
278			},
279			true,
280			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
281			noPre,
282			errorHandler,
283			},
284			{
285			"create payments, an error occurs when parsing json",
286			args{
287			context.Background(),
288			CreatePayment{},
289			nil,
290			},
291			true,
292			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
293			noPre,
294			encodingHandler,
295			},
296			{
297			"create payments, invalid url when building request",
298			args{
299			context.Background(),
300			CreatePayment{},
301			nil,
302			},
303			true,
304			errBadBaseURL,
305			crashSrv,
306			errorHandler,
307			},
308			}
309
310			for _, c := range cases {
311			setup()
312			defer teardown()
313
314			t.Run(c.name, func(t *testing.T) {
315			c.pre()
316			tMux.HandleFunc("/v2/payments", c.handler)
317
318			res, m, err := tClient.Payments.Create(c.args.ctx, c.args.payment, c.args.options)
319			if c.wantErr {
320			assert.NotNil(t, err)
321			assert.EqualError(t, err, c.err.Error())
322			} else {
323			assert.Nil(t, err)
324			assert.IsType(t, &Payment{}, m)
325			assert.IsType(t, &http.Response{}, res.Response)
326			}
327			})
328			}
329			}
330
331			func TestPaymentsService_Update(t *testing.T) {
332			setEnv()
333			defer unsetEnv()
334
335			type args struct {
336			ctx context.Context
337			id string
338			payment UpdatePayment
339			}
340			cases := []struct {
341			name string
342			args args
343			wantErr bool
344			err error
345			pre func()
346			handler http.HandlerFunc
347			}{
348			{
349			"update payments works as expected.",
350			args{
351			context.Background(),
352			"tr_WDqYK6vllg",
353			UpdatePayment{
354			BillingEmail: "[email protected]",
355			},
356			},
357			false,
358			nil,
359			noPre,
360			func(w http.ResponseWriter, r *http.Request) {
361			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
362			testMethod(t, r, "PATCH")
363
364			if _, ok := r.Header[AuthHeader]; !ok {
365			w.WriteHeader(http.StatusUnauthorized)
366			}
367			_, _ = w.Write([]byte(testdata.UpdatePaymentResponse))
368			},
369			},
370			{
371			"update payments using access token works as expected.",
372			args{
373			context.Background(),
374			"tr_WDqYK6vllg",
375			UpdatePayment{
376			BillingEmail: "[email protected]",
377			},
378			},
379			false,
380			nil,
381			func() {
382			tClient.WithAuthenticationValue("access_example_token")
383			},
384			func(w http.ResponseWriter, r *http.Request) {
385			testHeader(t, r, AuthHeader, "Bearer access_example_token")
386			testMethod(t, r, "PATCH")
387			testQuery(t, r, "testmode=true")
388
389			if _, ok := r.Header[AuthHeader]; !ok {
390			w.WriteHeader(http.StatusUnauthorized)
391			}
392			_, _ = w.Write([]byte(testdata.UpdatePaymentResponse))
393			},
394			},
395			{
396			"update payments, an error is returned from the server",
397			args{
398			context.Background(),
399			"tr_WDqYK6vllg",
400			UpdatePayment{},
401			},
402			true,
403			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
404			noPre,
405			errorHandler,
406			},
407			{
408			"update payments, an error occurs when parsing json",
409			args{
410			context.Background(),
411			"tr_WDqYK6vllg",
412			UpdatePayment{},
413			},
414			true,
415			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
416			noPre,
417			encodingHandler,
418			},
419			{
420			"update payments, invalid url when building request",
421			args{
422			context.Background(),
423			"tr_WDqYK6vllg",
424			UpdatePayment{},
425			},
426			true,
427			errBadBaseURL,
428			crashSrv,
429			errorHandler,
430			},
431			}
432
433			for _, c := range cases {
434			setup()
435			defer teardown()
436
437			t.Run(c.name, func(t *testing.T) {
438			c.pre()
439			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s", c.args.id), c.handler)
440
441			res, m, err := tClient.Payments.Update(c.args.ctx, c.args.id, c.args.payment)
442			if c.wantErr {
443			assert.NotNil(t, err)
444			assert.EqualError(t, err, c.err.Error())
445			} else {
446			assert.Nil(t, err)
447			assert.IsType(t, &Payment{}, m)
448			assert.IsType(t, &http.Response{}, res.Response)
449			}
450			})
451			}
452			}
453
454			func TestPaymentsService_Cancel(t *testing.T) {
455			setEnv()
456			defer unsetEnv()
457
458			type args struct {
459			ctx context.Context
460			id string
461			}
462			cases := []struct {
463			name string
464			args args
465			wantErr bool
466			err error
467			pre func()
468			handler http.HandlerFunc
469			}{
470			{
471			"get payments works as expected.",
472			args{
473			context.Background(),
474			"tr_WDqYK6vllg",
475			},
476			false,
477			nil,
478			noPre,
479			func(w http.ResponseWriter, r *http.Request) {
480			testHeader(t, r, AuthHeader, "Bearer token_X12b31ggg23")
481			testMethod(t, r, "DELETE")
482
483			if _, ok := r.Header[AuthHeader]; !ok {
484			w.WriteHeader(http.StatusUnauthorized)
485			}
486			_, _ = w.Write([]byte(testdata.GetPaymentResponse))
487			},
488			},
489			{
490			"get payments, an error is returned from the server",
491			args{
492			context.Background(),
493			"tr_WDqYK6vllg",
494			},
495			true,
496			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
497			noPre,
498			errorHandler,
499			},
500			{
501			"get payments, an error occurs when parsing json",
502			args{
503			context.Background(),
504			"tr_WDqYK6vllg",
505			},
506			true,
507			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
508			noPre,
509			encodingHandler,
510			},
511			{
512			"get payments, invalid url when building request",
513			args{
514			context.Background(),
515			"tr_WDqYK6vllg",
516			},
517			true,
518			errBadBaseURL,
519			crashSrv,
520			errorHandler,
521			},
522			}
523
524			for _, c := range cases {
525			setup()
526			defer teardown()
527
528			t.Run(c.name, func(t *testing.T) {
529			c.pre()
530			tMux.HandleFunc(fmt.Sprintf("/v2/payments/%s", c.args.id), c.handler)
531
532			res, m, err := tClient.Payments.Cancel(c.args.ctx, c.args.id)
533			if c.wantErr {
534			assert.NotNil(t, err)
535			assert.EqualError(t, err, c.err.Error())
536			} else {
537			assert.Nil(t, err)
538			assert.IsType(t, &Payment{}, m)
539			assert.IsType(t, &http.Response{}, res.Response)
540			}
541			})
542			}
543			}
544

VictorAvelar / mollie-api-go

GitHub Access Token became invalid

mollie.TestPaymentsService_Update C last analyzed 2024-05-08 11:56 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

mollie.TestPaymentsService_Update C
last analyzed 2024-05-08 11:56 UTC