orangemoney.TestMerchantPaymentService_Pay - Code Metrics - Inspection of "Add tests" - NdoleStudio/orangemoney-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( e5960f...63a320 )

by Acho

created 2022-12-08 18:51 UTC

orangemoney.TestMerchantPaymentService_Pay B

↳ Parent: merchant_payment_service_test.go

Complexity

Conditions

Size

Total Lines	66
Code Lines	49

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	49
nop	1
dl	0
loc	66
rs	8.669
c	0
b	0
f	0

How to fix Long Method

package orangemoney

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

	"github.com/NdoleStudio/orangemoney-go/internal/helpers"
	"github.com/NdoleStudio/orangemoney-go/internal/stubs"
	"github.com/stretchr/testify/assert"
)

func TestMerchantPaymentService_Init(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	requests := make([]http.Request, 0)
	responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentInitResponse()}
	server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
	client := New(
		WithBaseURL(server.URL),
		WithUsername(testUsername),
		WithPassword(testPassword),
		WithAuthToken(testAuthToken),
	)

	// Act
	payToken, response, err := client.MerchantPayment.Init(context.Background())

	// Assert
	assert.Nil(t, err)

	assert.GreaterOrEqual(t, len(requests), 2)
	request := requests[len(requests)-1]

	assert.Equal(t, "/omcoreapis/1.0.2/mp/init", request.URL.Path)
	assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
	assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)

	assert.Equal(t, &OrangeResponse[PayToken]{
		Message: "Payment request successfully initiated",
		Data: PayToken{
			Token: "MP22120771FEB7B21FD2381C3786",
		},
	}, payToken)

	// Teardown
	server.Close()
}

func TestMerchantPaymentService_Pay(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	requests := make([]http.Request, 0)
	responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentPayResponse()}
	server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
	client := New(
		WithBaseURL(server.URL),
		WithUsername(testUsername),
		WithPassword(testPassword),
		WithAuthToken(testAuthToken),
	)

	// Act
	transaction, response, err := client.MerchantPayment.Pay(context.Background(), &MerchantPaymentPayPrams{
		SubscriberMSISDN:  "69XXXXXXX",
		ChannelUserMSISDN: "69XXXXXXX",
		Amount:            "100",
		Description:       "Payment Description",
		OrderID:           "abcdef",
		Pin:               "123456",
		PayToken:          "MP22120771FEB7B21FD2381C3786",
		NotificationURL:   "https://example.com/payment-notification",
	})

	// Assert
	assert.Nil(t, err)

	assert.GreaterOrEqual(t, len(requests), 2)
	request := requests[len(requests)-1]

	assert.Equal(t, "/omcoreapis/1.0.2/mp/pay", request.URL.Path)
	assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
	assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)

	assert.Equal(t, &OrangeResponse[MerchantPaymentTransaction]{
		Message: "Merchant payment successfully initiated",
		Data: MerchantPaymentTransaction{
			ID:                        48463325,
			CreatedTime:               "1670442691",
			SubscriberMSISDN:          "69XXXXXXX",
			Amount:                    100,
			PayToken:                  "MP22120771FEB7B21FD2381C3786",
			TransactionID:             "MP221207.2051.B56929",
			TransactionMode:           "12345",
			InitTransactionMessage:    "Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.",
			InitTransactionStatus:     "200",
			ConfirmTransactionStatus:  nil,
			ConfirmTransactionMessage: nil,
			Status:                    "PENDING",
			NotificationURL:           "https://example.com/payment-notification",
			Description:               "Payment Description",
			ChannelUserMSISDN:         "69XXXXXXX",
		},
	}, transaction)

	assert.True(t, transaction.Data.IsPending())
	assert.False(t, transaction.Data.IsConfirmed())
	assert.False(t, transaction.Data.IsExpired())

	// Teardown
	server.Close()
}

func TestMerchantPaymentService_PayWithInsufficientFunds(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	requests := make([]http.Request, 0)
	responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentPayResponseWithInsufficientFunds()}
	server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusExpectationFailed}, responses, &requests)
	client := New(
		WithBaseURL(server.URL),
		WithUsername(testUsername),
		WithPassword(testPassword),
		WithAuthToken(testAuthToken),
	)

	// Act
	_, response, err := client.MerchantPayment.Pay(context.Background(), &MerchantPaymentPayPrams{
		SubscriberMSISDN:  "69XXXXXXX",
		ChannelUserMSISDN: "69XXXXXXX",
		Amount:            "100",
		Description:       "Payment Description",
		OrderID:           "abcdef",
		Pin:               "123456",
		PayToken:          "MP22120771FEB7B21FD2381C3786",
		NotificationURL:   "https://example.com/payment-notification",
	})

	// Assert
	assert.NotNil(t, err)
	assert.Equal(t, http.StatusExpectationFailed, response.HTTPResponse.StatusCode)
	assert.True(t, strings.Contains(string(*response.Body), "60019 :: Le solde du compte du payeur est insuffisant"))

	// Teardown
	server.Close()
}

func TestMerchantPaymentService_Push(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	requests := make([]http.Request, 0)
	responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentPushResponse()}
	server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
	client := New(
		WithBaseURL(server.URL),
		WithUsername(testUsername),
		WithPassword(testPassword),
		WithAuthToken(testAuthToken),
	)
	payToken := "MP22120771FEB7B21FD2381C3786"

	// Act
	transaction, response, err := client.MerchantPayment.Push(context.Background(), &payToken)

	// Assert
	assert.Nil(t, err)

	assert.GreaterOrEqual(t, len(requests), 2)
	request := requests[len(requests)-1]

	assert.Equal(t, "/omcoreapis/1.0.2/mp/push/"+payToken, request.URL.Path)
	assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
	assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)

	assert.Equal(t, &OrangeResponse[MerchantPaymentTransaction]{
		Message: "Push sent to customer",
		Data: MerchantPaymentTransaction{
			ID:                        48463325,
			CreatedTime:               "1670442691",
			SubscriberMSISDN:          "69XXXXXXX",
			Amount:                    100,
			PayToken:                  "MP22120771FEB7B21FD2381C3786",
			TransactionID:             "MP221207.2051.B56929",
			TransactionMode:           "12345",
			InitTransactionMessage:    "Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.",
			InitTransactionStatus:     "200",
			ConfirmTransactionStatus:  nil,
			ConfirmTransactionMessage: nil,
			Status:                    "PENDING",
			NotificationURL:           "https://example.com/payment-notification",
			Description:               "Payment Description",
			ChannelUserMSISDN:         "69XXXXXXX",
		},
	}, transaction)

	assert.True(t, transaction.Data.IsPending())
	assert.False(t, transaction.Data.IsConfirmed())
	assert.False(t, transaction.Data.IsExpired())

	// Teardown
	server.Close()
}

func TestMerchantPaymentService_TransactionStatus(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	requests := make([]http.Request, 0)
	responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentTransactionStatusResponse()}
	server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
	client := New(
		WithBaseURL(server.URL),
		WithUsername(testUsername),
		WithPassword(testPassword),
		WithAuthToken(testAuthToken),
	)
	payToken := "MP22120771FEB7B21FD2381C3786"

	// Act
	transaction, response, err := client.MerchantPayment.TransactionStatus(context.Background(), &payToken)

	// Assert
	assert.Nil(t, err)

	assert.GreaterOrEqual(t, len(requests), 2)
	request := requests[len(requests)-1]

	assert.Equal(t, "/omcoreapis/1.0.2/mp/paymentstatus/"+payToken, request.URL.Path)
	assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
	assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)

	strPtr := func(val string) *string {
		return &val
	}

	assert.Equal(t, &OrangeResponse[MerchantPaymentTransaction]{
		Message: "Transaction retrieved successfully",
		Data: MerchantPaymentTransaction{
			ID:                        48463325,
			CreatedTime:               "1670442691",
			SubscriberMSISDN:          "69XXXXXXX",
			Amount:                    100,
			PayToken:                  "MP22120771FEB7B21FD2381C3786",
			TransactionID:             "MP221207.2051.B56929",
			TransactionMode:           "12345",
			InitTransactionMessage:    "Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.",
			InitTransactionStatus:     "200",
			ConfirmTransactionStatus:  strPtr("200"),
			ConfirmTransactionMessage: strPtr("Successful Payment of COMPANY_NAME from 69XXXXXXX CUSTOMER_NAME. Transaction ID:MP221207.2051.B56929, Amount:100, New balance:1103.5."),
			Status:                    "SUCCESSFULL",
			NotificationURL:           "https://example.com/payment-notification",
			Description:               "Payment Description",
			ChannelUserMSISDN:         "69XXXXXXX",
		},
	}, transaction)

	assert.False(t, transaction.Data.IsPending())
	assert.True(t, transaction.Data.IsConfirmed())
	assert.False(t, transaction.Data.IsExpired())

	// Teardown
	server.Close()
}

func TestMerchantPaymentService_TransactionStatusWithExpired(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	requests := make([]http.Request, 0)
	responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentTransactionStatusResponseWithExpired()}
	server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
	client := New(
		WithBaseURL(server.URL),
		WithUsername(testUsername),
		WithPassword(testPassword),
		WithAuthToken(testAuthToken),
	)
	payToken := "MP22120771FEB7B21FD2381C3786"

	// Act
	transaction, response, err := client.MerchantPayment.TransactionStatus(context.Background(), &payToken)

	// Assert
	assert.Nil(t, err)

	assert.GreaterOrEqual(t, len(requests), 2)
	request := requests[len(requests)-1]

	assert.Equal(t, "/omcoreapis/1.0.2/mp/paymentstatus/"+payToken, request.URL.Path)
	assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
	assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)

	assert.False(t, transaction.Data.IsPending())
	assert.False(t, transaction.Data.IsConfirmed())
	assert.True(t, transaction.Data.IsExpired())

	// Teardown
	server.Close()
}


1			package orangemoney
2
3			import (
4			"context"
5			"net/http"
6			"strings"
7			"testing"
8
9			"github.com/NdoleStudio/orangemoney-go/internal/helpers"
10			"github.com/NdoleStudio/orangemoney-go/internal/stubs"
11			"github.com/stretchr/testify/assert"
12			)
13
14			func TestMerchantPaymentService_Init(t *testing.T) {
15			// Setup
16			t.Parallel()
17
18			// Arrange
19			requests := make([]http.Request, 0)
20			responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentInitResponse()}
21			server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
22			client := New(
23			WithBaseURL(server.URL),
24			WithUsername(testUsername),
25			WithPassword(testPassword),
26			WithAuthToken(testAuthToken),
27			)
28
29			// Act
30			payToken, response, err := client.MerchantPayment.Init(context.Background())
31
32			// Assert
33			assert.Nil(t, err)
34
35			assert.GreaterOrEqual(t, len(requests), 2)
36			request := requests[len(requests)-1]
37
38			assert.Equal(t, "/omcoreapis/1.0.2/mp/init", request.URL.Path)
39			assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
40			assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))
41
42			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
43
44			assert.Equal(t, &OrangeResponse[PayToken]{
45			Message: "Payment request successfully initiated",
46			Data: PayToken{
47			Token: "MP22120771FEB7B21FD2381C3786",
48			},
49			}, payToken)
50
51			// Teardown
52			server.Close()
53			}
54
55			func TestMerchantPaymentService_Pay(t *testing.T) {
56			// Setup
57			t.Parallel()
58
59			// Arrange
60			requests := make([]http.Request, 0)
61			responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentPayResponse()}
62			server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
63			client := New(
64			WithBaseURL(server.URL),
65			WithUsername(testUsername),
66			WithPassword(testPassword),
67			WithAuthToken(testAuthToken),
68			)
69
70			// Act
71			transaction, response, err := client.MerchantPayment.Pay(context.Background(), &MerchantPaymentPayPrams{
72			SubscriberMSISDN: "69XXXXXXX",
73			ChannelUserMSISDN: "69XXXXXXX",
74			Amount: "100",
75			Description: "Payment Description",
76			OrderID: "abcdef",
77			Pin: "123456",
78			PayToken: "MP22120771FEB7B21FD2381C3786",
79			NotificationURL: "https://example.com/payment-notification",
80			})
81
82			// Assert
83			assert.Nil(t, err)
84
85			assert.GreaterOrEqual(t, len(requests), 2)
86			request := requests[len(requests)-1]
87
88			assert.Equal(t, "/omcoreapis/1.0.2/mp/pay", request.URL.Path)
89			assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
90			assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))
91
92			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
93
94			assert.Equal(t, &OrangeResponse[MerchantPaymentTransaction]{
95			Message: "Merchant payment successfully initiated",
96			Data: MerchantPaymentTransaction{
97			ID: 48463325,
98			CreatedTime: "1670442691",
99			SubscriberMSISDN: "69XXXXXXX",
100			Amount: 100,
101			PayToken: "MP22120771FEB7B21FD2381C3786",
102			TransactionID: "MP221207.2051.B56929",
103			TransactionMode: "12345",
104			InitTransactionMessage: "Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.",
105			InitTransactionStatus: "200",
106			ConfirmTransactionStatus: nil,
107			ConfirmTransactionMessage: nil,
108			Status: "PENDING",
109			NotificationURL: "https://example.com/payment-notification",
110			Description: "Payment Description",
111			ChannelUserMSISDN: "69XXXXXXX",
112			},
113			}, transaction)
114
115			assert.True(t, transaction.Data.IsPending())
116			assert.False(t, transaction.Data.IsConfirmed())
117			assert.False(t, transaction.Data.IsExpired())
118
119			// Teardown
120			server.Close()
121			}
122
123			func TestMerchantPaymentService_PayWithInsufficientFunds(t *testing.T) {
124			// Setup
125			t.Parallel()
126
127			// Arrange
128			requests := make([]http.Request, 0)
129			responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentPayResponseWithInsufficientFunds()}
130			server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusExpectationFailed}, responses, &requests)
131			client := New(
132			WithBaseURL(server.URL),
133			WithUsername(testUsername),
134			WithPassword(testPassword),
135			WithAuthToken(testAuthToken),
136			)
137
138			// Act
139			_, response, err := client.MerchantPayment.Pay(context.Background(), &MerchantPaymentPayPrams{
140			SubscriberMSISDN: "69XXXXXXX",
141			ChannelUserMSISDN: "69XXXXXXX",
142			Amount: "100",
143			Description: "Payment Description",
144			OrderID: "abcdef",
145			Pin: "123456",
146			PayToken: "MP22120771FEB7B21FD2381C3786",
147			NotificationURL: "https://example.com/payment-notification",
148			})
149
150			// Assert
151			assert.NotNil(t, err)
152			assert.Equal(t, http.StatusExpectationFailed, response.HTTPResponse.StatusCode)
153			assert.True(t, strings.Contains(string(*response.Body), "60019 :: Le solde du compte du payeur est insuffisant"))
154
155			// Teardown
156			server.Close()
157			}
158
159			func TestMerchantPaymentService_Push(t *testing.T) {
160			// Setup
161			t.Parallel()
162
163			// Arrange
164			requests := make([]http.Request, 0)
165			responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentPushResponse()}
166			server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
167			client := New(
168			WithBaseURL(server.URL),
169			WithUsername(testUsername),
170			WithPassword(testPassword),
171			WithAuthToken(testAuthToken),
172			)
173			payToken := "MP22120771FEB7B21FD2381C3786"
174
175			// Act
176			transaction, response, err := client.MerchantPayment.Push(context.Background(), &payToken)
177
178			// Assert
179			assert.Nil(t, err)
180
181			assert.GreaterOrEqual(t, len(requests), 2)
182			request := requests[len(requests)-1]
183
184			assert.Equal(t, "/omcoreapis/1.0.2/mp/push/"+payToken, request.URL.Path)
185			assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
186			assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))
187
188			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
189
190			assert.Equal(t, &OrangeResponse[MerchantPaymentTransaction]{
191			Message: "Push sent to customer",
192			Data: MerchantPaymentTransaction{
193			ID: 48463325,
194			CreatedTime: "1670442691",
195			SubscriberMSISDN: "69XXXXXXX",
196			Amount: 100,
197			PayToken: "MP22120771FEB7B21FD2381C3786",
198			TransactionID: "MP221207.2051.B56929",
199			TransactionMode: "12345",
200			InitTransactionMessage: "Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.",
201			InitTransactionStatus: "200",
202			ConfirmTransactionStatus: nil,
203			ConfirmTransactionMessage: nil,
204			Status: "PENDING",
205			NotificationURL: "https://example.com/payment-notification",
206			Description: "Payment Description",
207			ChannelUserMSISDN: "69XXXXXXX",
208			},
209			}, transaction)
210
211			assert.True(t, transaction.Data.IsPending())
212			assert.False(t, transaction.Data.IsConfirmed())
213			assert.False(t, transaction.Data.IsExpired())
214
215			// Teardown
216			server.Close()
217			}
218
219			func TestMerchantPaymentService_TransactionStatus(t *testing.T) {
220			// Setup
221			t.Parallel()
222
223			// Arrange
224			requests := make([]http.Request, 0)
225			responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentTransactionStatusResponse()}
226			server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
227			client := New(
228			WithBaseURL(server.URL),
229			WithUsername(testUsername),
230			WithPassword(testPassword),
231			WithAuthToken(testAuthToken),
232			)
233			payToken := "MP22120771FEB7B21FD2381C3786"
234
235			// Act
236			transaction, response, err := client.MerchantPayment.TransactionStatus(context.Background(), &payToken)
237
238			// Assert
239			assert.Nil(t, err)
240
241			assert.GreaterOrEqual(t, len(requests), 2)
242			request := requests[len(requests)-1]
243
244			assert.Equal(t, "/omcoreapis/1.0.2/mp/paymentstatus/"+payToken, request.URL.Path)
245			assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
246			assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))
247
248			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
249
250			strPtr := func(val string) *string {
251			return &val
252			}
253
254			assert.Equal(t, &OrangeResponse[MerchantPaymentTransaction]{
255			Message: "Transaction retrieved successfully",
256			Data: MerchantPaymentTransaction{
257			ID: 48463325,
258			CreatedTime: "1670442691",
259			SubscriberMSISDN: "69XXXXXXX",
260			Amount: 100,
261			PayToken: "MP22120771FEB7B21FD2381C3786",
262			TransactionID: "MP221207.2051.B56929",
263			TransactionMode: "12345",
264			InitTransactionMessage: "Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.",
265			InitTransactionStatus: "200",
266			ConfirmTransactionStatus: strPtr("200"),
267			ConfirmTransactionMessage: strPtr("Successful Payment of COMPANY_NAME from 69XXXXXXX CUSTOMER_NAME. Transaction ID:MP221207.2051.B56929, Amount:100, New balance:1103.5."),
268			Status: "SUCCESSFULL",
269			NotificationURL: "https://example.com/payment-notification",
270			Description: "Payment Description",
271			ChannelUserMSISDN: "69XXXXXXX",
272			},
273			}, transaction)
274
275			assert.False(t, transaction.Data.IsPending())
276			assert.True(t, transaction.Data.IsConfirmed())
277			assert.False(t, transaction.Data.IsExpired())
278
279			// Teardown
280			server.Close()
281			}
282
283			func TestMerchantPaymentService_TransactionStatusWithExpired(t *testing.T) {
284			// Setup
285			t.Parallel()
286
287			// Arrange
288			requests := make([]http.Request, 0)
289			responses := [][]byte{stubs.TokenResponse(), stubs.MerchantPaymentTransactionStatusResponseWithExpired()}
290			server := helpers.MakeRequestCapturingTestServer([]int{http.StatusOK, http.StatusOK}, responses, &requests)
291			client := New(
292			WithBaseURL(server.URL),
293			WithUsername(testUsername),
294			WithPassword(testPassword),
295			WithAuthToken(testAuthToken),
296			)
297			payToken := "MP22120771FEB7B21FD2381C3786"
298
299			// Act
300			transaction, response, err := client.MerchantPayment.TransactionStatus(context.Background(), &payToken)
301
302			// Assert
303			assert.Nil(t, err)
304
305			assert.GreaterOrEqual(t, len(requests), 2)
306			request := requests[len(requests)-1]
307
308			assert.Equal(t, "/omcoreapis/1.0.2/mp/paymentstatus/"+payToken, request.URL.Path)
309			assert.Equal(t, testAuthToken, request.Header.Get("X-AUTH-TOKEN"))
310			assert.Equal(t, "Bearer 19077204-9d0a-31fa-85cf-xxxxxxxxxx", request.Header.Get("Authorization"))
311
312			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
313
314			assert.False(t, transaction.Data.IsPending())
315			assert.False(t, transaction.Data.IsConfirmed())
316			assert.True(t, transaction.Data.IsExpired())
317
318			// Teardown
319			server.Close()
320			}
321

NdoleStudio / orangemoney-go

Push — main ( e5960f...63a320 )

orangemoney.TestMerchantPaymentService_Pay B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like