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())