def test_instance_attributes_set(self):
'''
Arguments passed to the constructor should persist themselves as
instance attributes of the same name.
'''
v = veritrans.VTDirect(server_key=self.server_key, sandbox_mode=False)
self.assertEqual(v.server_key, self.server_key)
self.assertFalse(v.sandbox_mode)
v = veritrans.VTDirect(server_key=self.server_key, sandbox_mode=True)
self.assertEqual(v.server_key, self.server_key)
self.assertTrue(v.sandbox_mode)
def test_virtualaccountpermata(self):
"""
Verify Permata Virtual Account
"""
trans_details = self.trans_details
trans_details.order_id = "".join(
[fake.random_letter() for _ in range(10)])
# 2: Create a sandbox gateway
gateway = veritrans.VTDirect(SANDBOX_SERVER_KEY, sandbox_mode=True)
# 3: Create a charge request
payment = payment_types.VirtualAccountPermata()
charge_req = request.ChargeRequest(charge_type=payment,
transaction_details=trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp,
response.VirtualAccountPermataChargeResponse)
self.assertEqual(status.PENDING, resp.status_code)
self.assertEqual(self.trans_details.order_id, resp.order_id)
def test_submit_cancel_request(self):
'''
Large test:
- Do we make our HTTP request with the expected values?
- Do we get back the proper response type
- Does the response contain the data we think it should?
'''
with patch('veritranspay.veritrans.requests.post') as mock_post:
order_id = ''.join([fake.random_letter() for _ in range(25)])
# mock out our approval request
req = MagicMock(spec=request.CancelRequest)
req.order_id = order_id
# req.attach_mock(MagicMock(return_value=order_id), 'order_id')
req.attach_mock(MagicMock(return_value=None), 'validate_all')
# mock out our HTTP post
mock_resp = MagicMock()
mock_resp.attach_mock(
MagicMock(return_value=fixtures.CANCEL_RESPONSE), 'json')
mock_post.return_value = mock_resp
# get a response from the gateway
gateway = veritrans.VTDirect(self.server_key)
resp = gateway.submit_cancel_request(req)
# did we make our HTTP request properly?
mock_post.assert_called_once_with(
'https://api.midtrans.com/v2/'
'{order_id}/cancel'.format(order_id=order_id),
auth=(self.server_key, ''),
headers={'accept': 'application/json'})
# was it the correct type?
self.assertIsInstance(resp, response.CancelResponse)
# last, take our expected return values and do a little
# massaging out to account for modifications performed
# by response object
exp = deepcopy(fixtures.CANCEL_RESPONSE)
exp['status_code'] = int(exp['status_code'])
exp['transaction_time'] = \
helpers.parse_veritrans_datetime(exp['transaction_time'])
exp['gross_amount'] = \
helpers.parse_veritrans_amount(exp['gross_amount'])
# does it have our expected attributes?
self.assertEqual(resp.status_code, int(exp['status_code']))
self.assertEqual(resp.status_message, exp['status_message'])
self.assertEqual(resp.transaction_id, exp['transaction_id'])
self.assertEqual(resp.masked_card, exp['masked_card'])
self.assertEqual(resp.order_id, exp['order_id'])
self.assertEqual(resp.payment_type, exp['payment_type'])
self.assertEqual(resp.transaction_time, exp['transaction_time'])
self.assertEqual(resp.transaction_status,
exp['transaction_status'])
self.assertEqual(resp.fraud_status, exp['fraud_status'])
self.assertEqual(resp.bank, exp['bank'])
self.assertEqual(resp.gross_amount, exp['gross_amount'])
def test_mandiri_click_pay_charge(self):
# 1: Create a sandbox gateway
gateway = veritrans.VTDirect(
server_key=SANDBOX_SERVER_KEY,
sandbox_mode=True)
# 2: Set payment type Internet Banking from Mandiri Click pay
mandiri_clickpay = payment_types.MandiriClickpay(
card_number="4111111111111111",
input1="1111111111",
input2="145000",
input3="54321",
token="000000")
# 3: Create a charge request
charge_req = request.ChargeRequest(
charge_type=mandiri_clickpay,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.MandiriChargeResponse)
self.assertEqual(status.SUCCESS, resp.status_code)
def test_success_cc_charge_request(self):
# 1: get a token
# on live, this step --MUST-- be performed by the web
# application through the javascript library.
token = self.get_token(random.choice(fixtures.CC_ACCEPTED),
SANDBOX_CLIENT_KEY)
# 2: Create a sandbox gateway
gateway = veritrans.VTDirect(SANDBOX_SERVER_KEY, sandbox_mode=True)
# 3: Create a charge request
cc_payment = payment_types.CreditCard(
bank=self.expected['credit_card']['bank'], token_id=token)
charge_req = request.ChargeRequest(
charge_type=cc_payment,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.CreditCardChargeResponse)
self.assertEqual(status.SUCCESS, resp.status_code)
def test_sandbox_mode_expected_url(self):
'''
When sandbox_mode is True, we should receive the veritrans sandbox api
URL back from the base_url property.
'''
v = veritrans.VTDirect(server_key=self.server_key, sandbox_mode=True)
self.assertEqual(v.base_url, veritrans.VTDirect.SANDBOX_API_URL)
def test_virtual_account_mandiri(self):
"""
Verify mandiri bill payment
:return:
"""
# 2: Create a sandbox gateway
gateway = veritrans.VTDirect(SANDBOX_SERVER_KEY, sandbox_mode=True)
# 3: Create a charge request
payment = payment_types.VirtualAccountMandiri(
bill_info1=self.expected['echannel']['bill_info1'],
bill_info2=self.expected['echannel']['bill_info2'])
charge_req = request.ChargeRequest(
charge_type=payment,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp,
response.VirtualAccountMandiriChargeResponse)
self.assertEqual(status.PENDING, resp.status_code)
self.assertEqual(self.trans_details.order_id, resp.order_id)
def test_live_mode_expected_url(self):
'''
When sandbox_mode is False, we should receive the veritrans live api
URL back from the base_url property.
'''
v = veritrans.VTDirect(server_key=self.server_key, sandbox_mode=False)
self.assertEqual(v.base_url, veritrans.VTDirect.LIVE_API_URL)
def test_live_mode_is_default(self):
'''
When sandbox_mode is NOT explicitally set, VTDirect gateway should
default to sandbox_mode=False.
'''
v = veritrans.VTDirect(server_key=self.server_key)
self.assertFalse(v.sandbox_mode)
def test_sanbox_mode_set_as_attribute(self):
'''
The value for 'sandbox_mode' passed to init should be persisted
as an attribute with the same name.
'''
v = veritrans.VTDirect(server_key=self.server_key, sandbox_mode=True)
self.assertEqual(v.server_key, self.server_key)
self.assertTrue(v.sandbox_mode)
def test_invalid_bin_request_raises_ValidationError(self):
gateway = veritrans.VTDirect(server_key=self.server_key)
bins_req = MagicMock(spec=request.BinsRequest)
mock_validate = MagicMock(side_effect=validators.ValidationError)
bins_req.attach_mock(mock_validate, 'validate_all')
self.assertRaises(validators.ValidationError,
lambda: gateway.bin_request(bins_req))
self.assertEqual(mock_validate.call_count, 1)
def test_invalid_approval_request_raises_ValidationError(self):
'''
Validation error should be bubbled-up to the calling client code.
'''
gateway = veritrans.VTDirect(server_key=self.server_key)
approval_req = MagicMock(spec=request.ApprovalRequest)
mock_validate = MagicMock(side_effect=validators.ValidationError)
approval_req.attach_mock(mock_validate, 'validate_all')
self.assertRaises(validators.ValidationError,
lambda: gateway.submit_status_request(approval_req))
self.assertEqual(mock_validate.call_count, 1)
def test_submit_credit_card_charge(self):
'''
Large test for submitting credit card charge.
- Do we make our HTTP Request with the expected values
- Do we get the correct response type back?
- Does the response contain the data that it should?
'''
with patch('veritranspay.veritrans.requests.post') as mock_post:
# create a fake key and request payload
payload = {
'charge_type': 'I am a little tea cup',
}
gateway = veritrans.VTDirect(server_key=self.server_key)
req = MagicMock()
req.charge_type = MagicMock(spec=payment_types.CreditCard)
req.attach_mock(MagicMock(return_value=payload), 'serialize')
# mock the response data
# so thta the JSON method returns a documented response
# value
mock_resp = MagicMock()
mock_post.return_value = mock_resp
mock_resp.attach_mock(
MagicMock(return_value=fixtures.CC_CHARGE_RESPONSE_SUCCESS),
'json')
resp = gateway.submit_charge_request(req)
# make sure requests library was called in the expected way.
mock_post.assert_called_once_with(
'https://api.midtrans.com/v2/charge',
auth=(self.server_key, ''),
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
data=json.dumps(payload))
# did we get the expected response type?
self.assertIsInstance(resp, response.CreditCardChargeResponse)
# did it look like we expected
expected_response_format = response.CreditCardChargeResponse(
**fixtures.CC_CHARGE_RESPONSE_SUCCESS)
# need to compare their dictionary formats
self.assertEqual(expected_response_format.__dict__, resp.__dict__)
def test_invalid_charge_request_raises_ValidationError(self):
'''
Make sure that if any of the sub-entities raise a ValidationError
that it is bubbled out to calling code.
'''
gateway = veritrans.VTDirect(server_key=self.server_key)
charge_req = MagicMock(spec=request.ChargeRequest)
mock_validate = MagicMock(side_effect=validators.ValidationError)
charge_req.attach_mock(mock_validate, 'validate_all')
self.assertRaises(validators.ValidationError,
lambda: gateway.submit_charge_request(charge_req))
self.assertEqual(mock_validate.call_count, 1)
def test_accept_challenged_charge_request(self):
'''
Verify that we can accept challenged charge requests.
'''
# 1: get a token
# on live, this step --MUST-- be performed by the web
# application through the javascript library.
token = self.get_token(random.choice(fixtures.CC_CHALLENGED_FDS),
SANDBOX_CLIENT_KEY)
# 2: Create a sandbox gateway
gateway = veritrans.VTDirect(SANDBOX_SERVER_KEY, sandbox_mode=True)
# 3: Create a charge request
cc_payment = payment_types.CreditCard(
bank=self.expected['credit_card']['bank'], token_id=token)
charge_req = request.ChargeRequest(
charge_type=cc_payment,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit charge request
# - verify we get a status_code of CHALLENGE back
# - verify that we are returned a CreditCardChargeResponse
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.CreditCardChargeResponse)
self.assertEqual(status.CHALLENGE, resp.status_code)
# 5: Lookup the status of the transaction using the response
# - verify can use CreditCareChargeResponse can as a StatusRequest
# - verify we get a StatusResponse back
# - verify the status_code is still CHALLENGE
status_resp = gateway.submit_status_request(resp)
self.assertIsInstance(status_resp, response.StatusResponse)
self.assertEqual(status_resp.status_code, status.CHALLENGE)
# 6: Approve the transaction!
# - verify can build an ApprovalRequest
# - verify we get an ApprovalResponse back
# - verify the status_code is now SUCCESS
approval_req = request.ApprovalRequest(status_resp.order_id)
approval_resp = gateway.submit_approval_request(approval_req)
self.assertIsInstance(approval_resp, response.ApproveResponse)
self.assertEqual(approval_resp.status_code, status.SUCCESS)
def test_bin_request(self):
'''
Large test:
- Do we make our HTTP request with the expected values?
- Do we get back the proper response type
- Does the response contain the data we think it should?
'''
with patch('veritranspay.veritrans.requests.get') as mock_get:
bin_number = fixtures.BIN_RESPONSE.get('data').get('bin')
# mock out our approval request
req = MagicMock(spec=request.BinsRequest)
req.bin_number = bin_number
# req.attach_mock(MagicMock(return_value=order_id), 'order_id')
req.attach_mock(MagicMock(return_value=None), 'validate_all')
# mock out our HTTP post
mock_resp = MagicMock()
type(mock_resp).status_code = PropertyMock(return_value=200)
mock_resp.json.return_value = fixtures.BIN_RESPONSE
mock_resp.return_value.status_message = ''
mock_get.return_value = mock_resp
# get a response from the gateway
gateway = veritrans.VTDirect(self.server_key)
resp = gateway.bin_request(req)
# did we make our HTTP request properly?
mock_get.assert_called_once_with(
'https://api.midtrans.com/v1/bins/'
'{bin_number}'.format(bin_number=bin_number),
auth=(self.server_key, ''),
headers={'accept': 'application/json'})
# was it the correct type?
self.assertIsInstance(resp, response.BinResponse)
# last, take our expected return values and do a little
# massaging out to account for modifications performed
# by response object
exp = deepcopy(fixtures.BIN_RESPONSE)
exp['status_code'] = 200
self.assertEqual(resp.status_code, int(exp['status_code']))
self.assertEqual(resp.status_message, exp['status_message'])
self.assertEqual(bin_number, exp.get('data').get('bin'))
def test_submit_virtualaccountmandiri_charge(self):
with patch('veritranspay.veritrans.requests.post') as mock_post:
# create a fake key and request payload
payload = {
'charge_type': 'I am a little tea cup',
}
gateway = veritrans.VTDirect(server_key=self.server_key)
req = MagicMock()
req.charge_type = MagicMock(
spec=payment_types.VirtualAccountMandiri)
req.attach_mock(MagicMock(return_value=payload), 'serialize')
# mock the response data
# so thta the JSON method returns a documented response
# value
mock_resp = MagicMock()
mock_post.return_value = mock_resp
mock_resp.attach_mock(
MagicMock(return_value=fixtures.
VIRTUALACCOUNTMANDIRI_CHARGE_RESPONSE_SUCCESS),
'json')
resp = gateway.submit_charge_request(req)
# make sure requests library was called in the expected way.
mock_post.assert_called_once_with(
'https://api.midtrans.com/v2/charge',
auth=(self.server_key, ''),
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
data=json.dumps(payload))
# did we get the expected response type?
self.assertIsInstance(resp,
response.VirtualAccountMandiriChargeResponse)
# did it look like we expected
expected_response_format = response.VirtualAccountMandiriChargeResponse(
**fixtures.VIRTUALACCOUNTMANDIRI_CHARGE_RESPONSE_SUCCESS)
# need to compare their dictionary formats
self.assertEqual(expected_response_format.__dict__, resp.__dict__)
def test_bcaklikpay_charger(self):
# 1: Create a sandbox gateway
gateway = veritrans.VTDirect(
server_key=SANDBOX_SERVER_KEY,
sandbox_mode=True)
# 2: Set Internet banking BCA Klik pay
bca_klikpay = payment_types.BCAKlikPay(type_id=1, description="Pembelian barang")
# 3: Create a charge request
charge_req = request.ChargeRequest(
charge_type=bca_klikpay,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.BCAKlikPayChargeResponse)
self.assertEqual(status.CHALLENGE, resp.status_code)
def test_briepay(self):
"""
Verify Bri Epay payment method
"""
# 2: Create a sandbox gateway
gateway = veritrans.VTDirect(SANDBOX_SERVER_KEY, sandbox_mode=True)
# 3: Create a charge request
payment = payment_types.BriEpay()
charge_req = request.ChargeRequest(
charge_type=payment,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.EpayBriChargeResponse)
self.assertEqual(status.PENDING, resp.status_code)
self.assertEqual(self.trans_details.order_id, resp.order_id)
def test_klikbca_charger(self):
# 1: Create a sandbox gateway
gateway = veritrans.VTDirect(
server_key=SANDBOX_SERVER_KEY,
sandbox_mode=True)
# 2: Set Internet banking Klik BCA
klik_bca = payment_types.KlikBCA(user_id="midtrans1014", # error
description="Testing transaction")
# 3: Create a charge request
charge_req = request.ChargeRequest(
charge_type=klik_bca,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.KlikBCAChargeResponse)
self.assertEqual(status.CHALLENGE, resp.status_code)
def test_cimb_clicks_charge(self):
# 1: Create a sandbox gateway
gateway = veritrans.VTDirect(
server_key=SANDBOX_SERVER_KEY,
sandbox_mode=True)
# 2: Set payment type to Cimb Clicks internet banking.
cimb_clicks = payment_types.CimbClicks(
description="Purchase of a special event item")
# 3: Create a charge request
charge_req = request.ChargeRequest(
charge_type=cimb_clicks,
transaction_details=self.trans_details,
customer_details=self.cust_details,
item_details=self.item_details)
# 4: Submit our request
resp = gateway.submit_charge_request(charge_req)
self.assertIsInstance(resp, response.CimbsChargeResponse)
self.assertEqual(status.CHALLENGE, resp.status_code)
def test_requires_server_key(self):
''' server_key should be a required init parameter. '''
self.assertRaises(TypeError, lambda: veritrans.VTDirect())
