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

mollie/balances_test.go A
last analyzed 2024-05-24 15:10 UTC

↳ Parent: Project

Size/Duplication

Total Lines	710
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	42
eloc	499
dl	0
loc	710
rs	9.0399
c	0
b	0
f	0

7 Methods

Rating	Name	Size	Complexity
B	mollie.TestBalancesService_ListPrimaryBalanceTransactions	95	6
B	mollie.TestBalancesService_GetPrimaryReport	99	6
B	mollie.TestBalancesService_Primary	87	6
C	mollie.TestBalancesService_GetReport	100	6
B	mollie.TestBalancesService_Get	95	6
B	mollie.TestBalancesService_List	92	6
C	mollie.TestBalancesService_ListBalanceTransactions	100	6

package mollie

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

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

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

	type args struct {
		ctx     context.Context
		balance string
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"get balance by id works as expected",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
			},
			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.GetBalanceResponse))
			},
			noPre,
		},
		{
			"get balance by id returns an error from the server",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"get balance by id returns an error when creating the request",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"get balance by id returns an error when trying to parse the json response",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
			},
			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) {
			c.pre()

			tMux.HandleFunc(
				fmt.Sprintf(
					"/v2/balances/%s",
					c.args.balance,
				),
				c.handler,
			)

			res, capture, err := tClient.Balances.Get(c.args.ctx, c.args.balance)
			if c.wantErr {
				assert.NotNil(t, err)
				assert.EqualError(t, err, c.err.Error())
			} else {
				assert.Nil(t, err)
				assert.IsType(t, &Balance{}, capture)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx context.Context
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"get primary balance works as expected",
			args{
				context.Background(),
			},
			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.GetBalanceResponse))
			},
			noPre,
		},
		{
			"get primary balance returns an error from the server",
			args{
				context.Background(),
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"get primary balance returns an error when creating the request",
			args{
				context.Background(),
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"get primary balance returns an error when trying to parse the json response",
			args{
				context.Background(),
			},
			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) {
			c.pre()

			tMux.HandleFunc(
				"/v2/balances/primary",
				c.handler,
			)

			res, capture, err := tClient.Balances.Primary(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, &Balance{}, capture)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

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

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"list balances works as expected",
			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.ListBalancesResponse))
			},
			noPre,
		},
		{
			"list balances returns an error from the server",
			args{
				context.Background(),
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"list balances returns an error when creating the request",
			args{
				context.Background(),
				nil,
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"list balances returns an error when trying to parse 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) {
			c.pre()

			tMux.HandleFunc(
				"/v2/balances",
				c.handler,
			)

			res, capture, err := tClient.Balances.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, &BalancesList{}, capture)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx     context.Context
		balance string
		options *BalanceReportOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"get balance report works as expected",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				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.GetBalanceReportResponse))
			},
			noPre,
		},
		{
			"get balance report returns an error from the server",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"get balance report returns an error when creating the request",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				nil,
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"get balance report returns an error when trying to parse the json response",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				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) {
			c.pre()

			tMux.HandleFunc(
				fmt.Sprintf(
					"/v2/balances/%s/report",
					"bal_gVMhHKqSSRYJyPsuoPNFH",
				),
				c.handler,
			)

			res, balanceReport, err := tClient.Balances.GetReport(c.args.ctx, c.args.balance, 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, &BalanceReport{}, balanceReport)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

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

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"get primary balance report works as expected",
			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.GetBalanceReportResponse))
			},
			noPre,
		},
		{
			"get primary balance report returns an error from the server",
			args{
				context.Background(),

				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"get primary balance report returns an error when creating the request",
			args{
				context.Background(),

				nil,
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"get primary balance report returns an error when trying to parse 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) {
			c.pre()

			tMux.HandleFunc(
				fmt.Sprintf(
					"/v2/balances/%s/report",
					"primary",
				),
				c.handler,
			)

			res, balanceReport, err := tClient.Balances.GetPrimaryReport(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, &BalanceReport{}, balanceReport)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

	type args struct {
		ctx     context.Context
		balance string
		options *ListBalanceTransactionsOptions
	}

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"list balance transactions works as expected",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				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.ListBalanceTransactionsResponse))
			},
			noPre,
		},
		{
			"list balance transactions returns an error from the server",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"list balance transactions returns an error when creating the request",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				nil,
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"list balance transactions returns an error when trying to parse the json response",
			args{
				context.Background(),
				"bal_gVMhHKqSSRYJyPsuoPNFH",
				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) {
			c.pre()

			tMux.HandleFunc(
				fmt.Sprintf(
					"/v2/balances/%s/transactions",
					c.args.balance,
				),
				c.handler,
			)

			res, balanceReport, err := tClient.Balances.GetTransactionsList(c.args.ctx, c.args.balance, 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, &BalanceTransactionsList{}, balanceReport)
				assert.EqualValues(t, c.args.ctx, res.Request.Context())
				assert.IsType(t, &http.Response{}, res.Response)
			}
		})
	}
}

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

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

	cases := []struct {
		name    string
		args    args
		wantErr bool
		err     error
		handler http.HandlerFunc
		pre     func()
	}{
		{
			"list primary balance transactions works as expected",
			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.ListBalanceTransactionsResponse))
			},
			noPre,
		},
		{
			"list primary balance transactions returns an error from the server",
			args{
				context.Background(),
				nil,
			},
			true,
			fmt.Errorf("500 Internal Server Error: An internal server error occurred while processing your request."),
			errorHandler,
			noPre,
		},
		{
			"list primary balance transactions returns an error when creating the request",
			args{
				context.Background(),
				nil,
			},
			true,
			errBadBaseURL,
			errorHandler,
			crashSrv,
		},
		{
			"list primary balance transactions returns an error when trying to parse 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) {
			c.pre()

			tMux.HandleFunc(
				fmt.Sprintf(
					"/v2/balances/%s/transactions",
					"primary",
				),
				c.handler,
			)

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

VictorAvelar / mollie-api-go

GitHub Access Token became invalid

mollie/balances_test.go A last analyzed 2024-05-24 15:10 UTC

Size/Duplication

Importance

7 Methods

Duplication Side-by-Side

Filter issues like

mollie/balances_test.go A
last analyzed 2024-05-24 15:10 UTC