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

mollie.TestSettlementsService_Get B
last analyzed 2025-06-09 10:27 UTC

↳ Parent: mollie/settlements_test.go

Complexity

Conditions

Size

Total Lines	86
Code Lines	65

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	65
nop	1
dl	0
loc	86
rs	7.2121
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 TestSettlementsService_Get(t *testing.T) {
	setEnv()
	defer unsetEnv()

	type args struct {
		ctx        context.Context
		settlement string
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get settlement works as expected.",
			args{
				context.Background(),
				"stl_jDk30akdN",
			},
			false,
			nil,
			noPre,
			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.GetSettlementsResponse))
			},
		},
		{
			"get settlement, an error is returned from the server",
			args{
				context.Background(),
				"stl_jDk30akdN",
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			noPre,
			errorHandler,
		},
		{
			"get settlement, an error occurs when parsing json",
			args{
				context.Background(),
				"stl_jDk30akdN",
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get settlement, invalid url when building request",
			args{
				context.Background(),
				"stl_jDk30akdN",
			},
			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/settlements/%s", c.args.settlement), c.handler)

			res, m, err := tClient.Settlements.Get(c.args.ctx, c.args.settlement)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Settlement{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx        context.Context
		settlement string
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get next settlement works as expected.",
			args{
				context.Background(),
				"next",
			},
			false,
			nil,
			noPre,
			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.GetNextSettlementResponse))
			},
		},
		{
			"get next settlement, an error is returned from the server",
			args{
				context.Background(),
				"next",
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			noPre,
			errorHandler,
		},
		{
			"get next settlement, an error occurs when parsing json",
			args{
				context.Background(),
				"next",
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get next settlement, invalid url when building request",
			args{
				context.Background(),
				"next",
			},
			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/settlements/%s", c.args.settlement), c.handler)

			res, m, err := tClient.Settlements.Next(c.args.ctx)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Settlement{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx        context.Context
		settlement string
	}
	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		pre     func()
		handler http.HandlerFunc
	}{
		{
			"get open settlement works as expected.",
			args{
				context.Background(),
				"open",
			},
			false,
			nil,
			noPre,
			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.GetOpenSettlementResponse))
			},
		},
		{
			"get open settlement, an error is returned from the server",
			args{
				context.Background(),
				"open",
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			noPre,
			errorHandler,
		},
		{
			"get open settlement, an error occurs when parsing json",
			args{
				context.Background(),
				"open",
			},
			true,
			fmt.Errorf("invalid character 'h' looking for beginning of object key string"),
			noPre,
			encodingHandler,
		},
		{
			"get open settlement, invalid url when building request",
			args{
				context.Background(),
				"open",
			},
			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/settlements/%s", c.args.settlement), c.handler)

			res, m, err := tClient.Settlements.Open(c.args.ctx)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Settlement{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

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

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

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

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

			res, m, err := tClient.Settlements.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, &SettlementsList{}, m)
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

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

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

			res, m, err := tClient.Settlements.ListPayments(c.args.ctx, c.args.settlement, 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 TestSettlementsService_GetCaptures(t *testing.T) {
	setEnv()
	defer unsetEnv()

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

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

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

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

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

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

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

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

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

				if _, ok := r.Header[AuthHeader]; !ok {
					w.WriteHeader(http.StatusUnauthorized)
				}
				_, _ = w.Write([]byte(testdata.ListRefundsResponse))
			},
		},
		{
			"get settlement refunds, an error is returned from the server",
			args{
				context.Background(),
				"stl_jDk30akdN",
				&ListSettlementsOptions{
					Limit: 10,
				},
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request"),
			noPre,
			errorHandler,
		},
		{
			"get settlement refunds, an error occurs when parsing json",
			args{
				context.Background(),
				"stl_jDk30akdN",
				&ListSettlementsOptions{
					Limit: 10,
				},
			},
			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(),
				"stl_jDk30akdN",
				&ListSettlementsOptions{
					Limit: 10,
				},
			},
			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/settlements/%s/refunds", c.args.settlement), c.handler)

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

VictorAvelar / mollie-api-go

GitHub Access Token became invalid

mollie.TestSettlementsService_Get B last analyzed 2025-06-09 10:27 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

mollie.TestSettlementsService_Get B
last analyzed 2025-06-09 10:27 UTC