class MotoTests(unittest.TestCase):
config = HpsServicesConfig()
config.secret_api_key = 'skapi_cert_MRCQAQBC_VQACBE0rFaZlbDDPieMGP06JDAtjyS7NQ'
config.developer_id = '012345'
config.version_number = '0001'
batch_service = HpsBatchService(config)
service = HpsFluentCreditService().with_config(config)
use_tokens = True
use_prepaid = True
visa_token = None
mastercard_token = None
discover_token = None
amex_token = None
test_10_transaction_id = None
test_20_transaction_id = None
test_39_transaction_id = None
test_52_transaction_id = None
test_53_transaction_id = None
""" CARD VERIFY """
def test_000_close_batch(self):
try:
response = self.batch_service.close_batch()
if response is None:
self.fail("Response is None")
print 'batch id: {0}'.format(response.id)
print 'sequence number: {0}'.format(response.sequence_number)
except HpsException, e:
if e.message != 'Transaction was rejected because it requires a batch to be open.':
self.fail(e.message)
class Certification(unittest.TestCase):
credit_service = HpsFluentCreditService().with_config(
TestServicesConfig.valid_services_config)
def test_visa_3ds_decrypted_should_charge_ok(self):
payment_data = TestData.visa_payment_data()
response = self.credit_service.charge(payment_data.transaction_amount)\
.with_payment_data(payment_data)\
.with_payment_data_source('ApplePay')\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual(response.response_code, '00')
def test_visa_3ds_decrypted_should_auth_ok(self):
payment_data = TestData.visa_payment_data()
response = self.credit_service.authorize(payment_data.transaction_amount)\
.with_payment_data(payment_data)\
.with_payment_data_source('ApplePay')\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual(response.response_code, '00')
capture_response = self.credit_service.capture()\
.with_transaction_id(response.transaction_id)\
.execute()
self.assertIsNotNone(capture_response)
def test_amex_3ds_decrypted_should_charge_ok(self):
payment_data = TestData.amex_payment_data()
response = self.credit_service.charge(payment_data.transaction_amount)\
.with_payment_data(payment_data)\
.with_payment_data_source('ApplePay')\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual(response.response_code, '00')
def test_amex_3ds_decrypted_should_auth_ok(self):
payment_data = TestData.amex_payment_data()
response = self.credit_service.authorize(payment_data.transaction_amount)\
.with_payment_data(payment_data)\
.with_payment_data_source('ApplePay')\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual(response.response_code, '00')
capture_response = self.credit_service.capture()\
.with_transaction_id(response.transaction_id)\
.execute()
self.assertIsNotNone(capture_response)
class RecurringTests(unittest.TestCase):
pp_config = HpsPayPlanServiceConfig()
pp_config.secret_api_key = 'skapi_cert_MTyMAQBiHVEAewvIzXVFcmUd2UcyBge_eCpaASUp0A'
service = HpsPayPlanService(pp_config, True)
config = HpsServicesConfig()
config.secret_api_key = 'skapi_cert_MTyMAQBiHVEAewvIzXVFcmUd2UcyBge_eCpaASUp0A'
batch_service = HpsBatchService(config)
credit_service = HpsFluentCreditService().with_config(config)
check_service = HpsFluentCheckService().with_config(config)
customer_person_key = None
customer_company_key = None
payment_method_key_visa = None
payment_method_key_mastercard = None
payment_method_key_check_ppd = None
payment_method_key_check_ccd = None
schedule_key_visa = None
schedule_key_mastercard = None
schedule_key_check_ppd = None
schedule_key_check_ccd = None
today_date = datetime.date.today().strftime('%Y%m%d')
identifier_base = '{0}-{1}-' + ''.join(
random.sample('abcdefghijklmnopqrstuvwxyz', 10))
def get_identifier(self, identifier):
rvalue = self.identifier_base.format(self.today_date, identifier)
print rvalue
return rvalue
""" Batching """
def test_000_close_batch(self):
try:
response = self.batch_service.close_batch()
if response is None:
self.fail("Response is None")
print 'batch id: {0}'.format(response.id)
print 'sequence number: {0}'.format(response.sequence_number)
except HpsException, e:
if e.message != 'Transaction was rejected because it requires a batch to be open.':
self.fail(e.message)
class FluentCreditTests(unittest.TestCase):
service = HpsFluentCreditService().with_config(
TestServicesConfig.valid_services_config)
pp_service = HpsPayPlanService(TestServicesConfig.valid_pay_plan_config)
schedule = None
try:
schedule = pp_service.page(1, 0).find_all_schedules({
'scheduleStatus':
HpsPayPlanScheduleStatus.ACTIVE,
'scheduleIdentifier':
'SecureSubmit'
}).results[0]
except IndexError:
pass
def test_authorize_and_capture(self):
auth_response = self.service.authorize(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(auth_response)
self.assertEqual('00', auth_response.response_code)
capture = self.service.capture(auth_response.transaction_id).execute()
self.assertIsNotNone(capture)
self.assertEqual('00', capture.response_code)
def test_authorize_no_amount(self):
builder = self.service.authorize()\
.with_currency('usd')\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)
self.assertRaises(HpsArgumentException, builder.execute)
def test_authorize_no_currency(self):
builder = self.service.authorize(10)\
.with_currency(None)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)
self.assertRaises(HpsArgumentException, builder.execute)
def test_authorize_multiple_payment_options(self):
builder = self.service.authorize(10)\
.with_card(TestCreditCard.valid_visa)\
.with_token('123456789')\
.with_card_holder(TestCardHolder.valid_card_holder)
self.assertRaises(HpsArgumentException, builder.execute)
def test_authorize_with_gratuity(self):
auth_response = self.service.authorize(13)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_gratuity(3)\
.execute()
self.assertIsNotNone(auth_response)
self.assertEqual('00', auth_response.response_code)
def test_capture_no_transaction_id(self):
builder = self.service.capture()
self.assertRaises(HpsArgumentException, builder.execute)
def test_charge(self):
response = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_charge_no_amount(self):
builder = self.service.charge()\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)
self.assertRaises(HpsArgumentException, builder.execute)
def test_charge_no_currency(self):
builder = self.service.charge(10)\
.with_currency(None)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)
self.assertRaises(HpsArgumentException, builder.execute)
def test_charge_multiple_payment_options(self):
builder = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_token('123456789')\
.with_card_holder(TestCardHolder.valid_card_holder)
self.assertRaises(HpsArgumentException, builder.execute)
def test_charge_with_card_present(self):
response = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_card_present(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_charge_with_reader_present(self):
response = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_reader_present(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_charge_with_gratuity(self):
response = self.service.charge(13)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_gratuity(3)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_cpc_edit(self):
charge = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(charge.transaction_id)
cpc_data = HpsCPCData()
cpc_data.card_holder_po_number = '12345'
cpc_data.tax_type = HpsTaxType.sales_tax
cpc_data.tax_amount = 0.06
cpc_edit = self.service.cpc_edit()\
.with_transaction_id(charge.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_edit)
self.assertEqual('00', cpc_edit.response_code)
def test_cpc_edit_no_transaction_id(self):
cpc_data = HpsCPCData()
cpc_data.card_holder_po_number = '12345'
cpc_data.tax_type = HpsTaxType.sales_tax
cpc_data.tax_amount = 0.06
builder = self.service.cpc_edit()\
.with_cpc_data(cpc_data)
self.assertRaises(HpsArgumentException, builder.execute)
def test_cpc_edit_no_cpc_data(self):
builder = self.service.cpc_edit()\
.with_transaction_id('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_edit(self):
charge = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(charge.transaction_id)
edit = self.service.edit()\
.with_transaction_id(charge.transaction_id)\
.with_amount(11)\
.execute()
self.assertIsNotNone(edit)
self.assertEqual('00', edit.response_code)
def test_edit_no_transaction_id(self):
builder = self.service.edit()\
.with_amount(11)
self.assertRaises(HpsArgumentException, builder.execute)
def test_get(self):
charge = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(charge.transaction_id)
get = self.service.get(charge.transaction_id).execute()
self.assertIsNotNone(get)
self.assertEqual('00', get.response_code)
def test_get_no_transaction_id(self):
builder = self.service.get(None)
self.assertRaises(HpsArgumentException, builder.execute)
def test_list(self):
items = self.service.list()\
.with_utc_start_date(datetime.datetime.utcnow() + datetime.timedelta(-10))\
.with_utc_end_date(datetime.datetime.utcnow())\
.execute()
self.assertIsNotNone(items)
def test_list_no_start(self):
builder = self.service.list()\
.with_utc_end_date(datetime.datetime.utcnow())
self.assertRaises(HpsArgumentException, builder.execute)
def test_list_no_end(self):
builder = self.service.list()\
.with_utc_start_date(datetime.datetime.utcnow() + datetime.timedelta(-10))
self.assertRaises(HpsArgumentException, builder.execute)
def test_refund_by_transaction_id(self):
charge = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertEqual('00', charge.response_code)
self.assertIsNotNone(charge.transaction_id)
refund = self.service.refund(10)\
.with_transaction_id(charge.transaction_id)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(refund)
self.assertEqual('00', refund.response_code)
def test_refund_by_card(self):
charge = self.service.charge(11)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertEqual('00', charge.response_code)
refund = self.service.refund(11)\
.with_card(TestCreditCard.valid_visa)\
.execute()
self.assertIsNotNone(refund)
self.assertEqual('00', refund.response_code)
def test_refund_by_token(self):
charge = self.service.charge(12)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(charge.token_data)
refund = self.service.refund(12)\
.with_token(charge.token_data.token_value)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(refund)
self.assertEqual('00', refund.response_code)
def test_refund_no_amount(self):
builder = self.service.refund()\
.with_transaction_id('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_refund_no_currency(self):
builder = self.service.refund(10)\
.with_currency(None)\
.with_transaction_id('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_refund_transaction_id_and_card(self):
builder = self.service.refund(10)\
.with_transaction_id('123456')\
.with_card(TestCreditCard.valid_visa)
self.assertRaises(HpsArgumentException, builder.execute)
def test_refund_transaction_id_and_token(self):
builder = self.service.refund(10)\
.with_transaction_id('123456')\
.with_token('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_refund_card_and_token(self):
builder = self.service.refund(10)\
.with_token('123456')\
.with_card(TestCreditCard.valid_visa)
self.assertRaises(HpsArgumentException, builder.execute)
def test_refund_no_payment_method(self):
builder = self.service.refund(10)
self.assertRaises(HpsArgumentException, builder.execute)
def test_reverse_by_transaction_id(self):
charge = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertEqual('00', charge.response_code)
self.assertIsNotNone(charge.transaction_id)
reverse = self.service.reverse(10)\
.with_transaction_id(charge.transaction_id)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(reverse)
self.assertEqual('00', reverse.response_code)
def test_reverse_by_card(self):
charge = self.service.charge(11)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertEqual('00', charge.response_code)
reverse = self.service.reverse(11)\
.with_card(TestCreditCard.valid_visa)\
.execute()
self.assertIsNotNone(reverse)
self.assertEqual('00', reverse.response_code)
def test_reverse_by_token(self):
charge = self.service.charge(12)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(charge.token_data)
reverse = self.service.reverse(12)\
.with_token(charge.token_data.token_value)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(reverse)
self.assertEqual('00', reverse.response_code)
def test_reverse_no_amount(self):
builder = self.service.reverse()\
.with_transaction_id('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_reverse_no_currency(self):
builder = self.service.reverse(10)\
.with_currency(None)\
.with_transaction_id('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_reverse_transaction_id_and_card(self):
builder = self.service.reverse(10)\
.with_transaction_id('123456')\
.with_card(TestCreditCard.valid_visa)
self.assertRaises(HpsArgumentException, builder.execute)
def test_reverse_transaction_id_and_token(self):
builder = self.service.reverse(10)\
.with_transaction_id('123456')\
.with_token('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_reverse_card_and_token(self):
builder = self.service.reverse(10)\
.with_token('123456')\
.with_card(TestCreditCard.valid_visa)
self.assertRaises(HpsArgumentException, builder.execute)
def test_reverse_no_payment_method(self):
builder = self.service.reverse(10)
self.assertRaises(HpsArgumentException, builder.execute)
def test_verify(self):
verify = self.service.verify()\
.with_card(TestCreditCard.valid_visa)\
.execute()
self.assertIsNotNone(verify)
self.assertEqual('85', verify.response_code)
def test_verify_multiple_payment_options(self):
builder = self.service.verify()\
.with_card(TestCreditCard.valid_visa)\
.with_token('123456')
self.assertRaises(HpsArgumentException, builder.execute)
def test_void(self):
charge = self.service.charge(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertEqual('00', charge.response_code)
self.assertIsNotNone(charge.transaction_id)
void = self.service.void(charge.transaction_id).execute()
self.assertIsNotNone(void)
self.assertEqual('00', void.response_code)
def test_void_no_transaction_id(self):
builder = self.service.void()
self.assertRaises(HpsArgumentException, builder.execute)
def test_void_partial(self):
response = self.service.authorize(145)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_allow_partial_auth(True)\
.execute()
self.assertEqual('10', response.response_code)
self.assertIsNotNone(response.transaction_id)
self.assertIsNotNone(response.authorized_amount)
void = self.service.void(response.transaction_id)\
.execute()
self.assertIsNotNone(void)
self.assertEqual('00', void.response_code)
def test_recurring_one_time_with_card(self):
if self.schedule is None:
self.skipTest('Schedule was none')
recurring = self.service.recurring(10)\
.with_schedule(self.schedule)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_one_time(True)\
.execute()
self.assertIsNotNone(recurring)
self.assertEqual('00', recurring.response_code)
def test_recurring_one_time_with_token(self):
if self.schedule is None:
self.skipTest('Schedule was none')
token_service = HpsTokenService(
TestServicesConfig.valid_services_config.credential_token)
token_response = token_service.get_token(TestCreditCard.valid_visa)
self.assertIsNotNone(token_response)
self.assertIsNotNone(token_response.token_value)
recurring = self.service.recurring(10)\
.with_schedule(self.schedule)\
.with_token(token_response.token_value)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.with_one_time(True)\
.execute()
self.assertIsNotNone(recurring)
self.assertEqual('00', recurring.response_code)
def test_recurring_with_card(self):
if self.schedule is None:
self.skipTest('Schedule was none')
recurring = self.service.recurring(10)\
.with_schedule(self.schedule)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(recurring)
self.assertEqual('00', recurring.response_code)
def test_recurring_with_token(self):
if self.schedule is None:
self.skipTest('Schedule was none')
token_service = HpsTokenService(
TestServicesConfig.valid_services_config.credential_token)
token_response = token_service.get_token(TestCreditCard.valid_visa)
self.assertIsNotNone(token_response)
self.assertIsNotNone(token_response.token_value)
recurring = self.service.recurring(10)\
.with_schedule(self.schedule)\
.with_token(token_response.token_value)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(recurring)
self.assertEqual('00', recurring.response_code)
def test_additional_auth(self):
auth_response = self.service.authorize(10)\
.with_card(TestCreditCard.valid_visa)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(auth_response)
self.assertEqual('00', auth_response.response_code)
additional_auth = self.service.additional_auth(3)\
.with_transaction_id(auth_response.transaction_id)\
.execute()
self.assertIsNotNone(additional_auth)
self.assertEqual('00', additional_auth.response_code)
capture = self.service.capture(auth_response.transaction_id)\
.with_amount(13)\
.execute()
self.assertIsNotNone(capture)
self.assertEqual('00', capture.response_code)
def test_additional_auth_no_amount(self):
builder = self.service.additional_auth()
self.assertRaises(HpsArgumentException, builder.execute)
def test_swipe_no_encryption(self):
response = self.service.charge(10)\
.with_track_data(TestCreditCard.valid_visa_track)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_swipe_encryption_v1(self):
response = self.service.charge(10)\
.with_track_data(TestCreditCard.valid_visa_track_e3v1)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_swipe_encryption_v2(self):
response = self.service.charge(10)\
.with_track_data(TestCreditCard.valid_visa_track_e3v2)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_proximity_no_encryption(self):
response = self.service.charge(10)\
.with_track_data(TestCreditCard.valid_visa_proximity)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_proximity_encryption_v1(self):
response = self.service.charge(10)\
.with_track_data(TestCreditCard.valid_visa_proximity_e3v1)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_proximity_encryption_v2(self):
response = self.service.charge(10)\
.with_track_data(TestCreditCard.valid_visa_proximity_e3v2)\
.with_card_holder(TestCardHolder.valid_card_holder)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
class RecurringTests(unittest.TestCase):
pp_config = HpsPayPlanServiceConfig()
pp_config.secret_api_key = 'skapi_cert_MTyMAQBiHVEAewvIzXVFcmUd2UcyBge_eCpaASUp0A'
service = HpsPayPlanService(pp_config, True)
config = HpsServicesConfig()
config.secret_api_key = 'skapi_cert_MTyMAQBiHVEAewvIzXVFcmUd2UcyBge_eCpaASUp0A'
batch_service = HpsBatchService(config)
credit_service = HpsFluentCreditService().with_config(config)
check_service = HpsFluentCheckService().with_config(config)
customer_person_key = None
customer_company_key = None
payment_method_key_visa = None
payment_method_key_mastercard = None
payment_method_key_check_ppd = None
payment_method_key_check_ccd = None
schedule_key_visa = None
schedule_key_mastercard = None
schedule_key_check_ppd = None
schedule_key_check_ccd = None
today_date = datetime.date.today().strftime('%Y%m%d')
identifier_base = '{0}-{1}-' + ''.join(random.sample('abcdefghijklmnopqrstuvwxyz', 10))
def get_identifier(self, identifier):
rvalue = self.identifier_base.format(self.today_date, identifier)
print(rvalue)
return rvalue
""" Batching """
def test_000_close_batch(self):
try:
response = self.batch_service.close_batch()
if response is None:
self.fail("Response is None")
print('batch id: {0}'.format(response.id))
print('sequence number: {0}'.format(response.sequence_number))
except HpsException as e:
if e.message != 'Transaction was rejected because it requires a batch to be open.':
self.fail(e.message)
""" Clean up """
def test_000_clean_up(self):
# remove the schedules
sch_results = self.service.page(500, 0).find_all_schedules()
for schedule in sch_results.results:
try:
self.service.delete_schedule(schedule, True)
except HpsException:
pass
# remove payment methods
pm_results = self.service.page(500, 0).find_all_payment_methods()
for pm in pm_results.results:
try:
self.service.delete_payment_method(pm, True)
except HpsException:
pass
# remove customers
cust_results = self.service.page(500, 0).find_all_customers()
for c in cust_results.results:
try:
self.service.delete_customer(c, True)
except HpsException:
pass
""" Customer Setup """
def test_001_add_customer_person(self):
customer = HpsPayPlanCustomer()
customer.customer_identifier = self.get_identifier('Person')
customer.first_name = 'John'
customer.last_name = 'Doe'
customer.customer_status = HpsPayPlanCustomerStatus.ACTIVE
customer.primary_email = '*****@*****.**'
customer.address_line_1 = '123 Main St'
customer.city = 'Dallas'
customer.state_province = 'TX'
customer.zip_postal_code = '98765'
customer.country = 'USA'
customer.phone_day = '5551112222'
response = self.service.add_customer(customer)
self.assertIsNotNone(response)
self.assertIsNotNone(response.customer_key)
self.__class__.customer_person_key = response.customer_key
def test_002_add_customer_company(self):
customer = HpsPayPlanCustomer()
customer.customer_identifier = self.get_identifier('Business')
customer.company = 'AcmeCo'
customer.customer_status = HpsPayPlanCustomerStatus.ACTIVE
customer.primary_email = '*****@*****.**'
customer.address_line_1 = '987 Elm St'
customer.city = 'Princeton'
customer.state_province = 'NJ'
customer.zip_postal_code = '12345'
customer.country = 'USA'
customer.phone_day = '5551112222'
response = self.service.add_customer(customer)
self.assertIsNotNone(response)
self.assertIsNotNone(response.customer_key)
self.__class__.customer_company_key = response.customer_key
""" Payment Setup """
def test_003_add_payment_credit_visa(self):
payment_method = HpsPayPlanPaymentMethod()
payment_method.payment_method_identifier = self.get_identifier('CreditV')
payment_method.payment_method_type = HpsPayPlanPaymentMethodType.CREDIT_CARD
payment_method.name_on_account = 'John Doe'
payment_method.account_number = '4012002000060016'
payment_method.expiration_date = '1225'
payment_method.customer_key = self.__class__.customer_person_key
payment_method.country = 'USA'
response = self.service.add_payment_method(payment_method)
self.assertIsNotNone(response)
self.assertIsNotNone(response.payment_method_key)
self.__class__.payment_method_key_visa = response.payment_method_key
def test_004_add_payment_credit_mastercard(self):
payment_method = HpsPayPlanPaymentMethod()
payment_method.payment_method_identifier = self.get_identifier('CreditMC')
payment_method.payment_method_type = HpsPayPlanPaymentMethodType.CREDIT_CARD
payment_method.name_on_account = 'John Doe'
payment_method.account_number = '5473500000000014'
payment_method.expiration_date = '1225'
payment_method.customer_key = self.__class__.customer_person_key
payment_method.country = 'USA'
response = self.service.add_payment_method(payment_method)
self.assertIsNotNone(response)
self.assertIsNotNone(response.payment_method_key)
self.__class__.payment_method_key_mastercard = response.payment_method_key
def test_005_add_payment_check_ppd(self):
payment_method = HpsPayPlanPaymentMethod()
payment_method.payment_method_identifier = self.get_identifier('CheckPPD')
payment_method.payment_method_type = HpsPayPlanPaymentMethodType.ACH
payment_method.ach_type = 'Checking'
payment_method.account_type = 'Personal'
payment_method.telephone_indicator = 0
payment_method.routing_number = '490000018'
payment_method.name_on_account = 'John Doe'
payment_method.drivers_license_number = '7418529630'
payment_method.drivers_license_state = 'TX'
payment_method.account_number = '24413815'
payment_method.address_line_1 = '123 Main St'
payment_method.city = 'Dallas'
payment_method.state_province = 'TX'
payment_method.zip_postal_code = '98765'
payment_method.customer_key = self.__class__.customer_person_key
payment_method.country = 'USA'
payment_method.account_holder_yob = '1989'
response = self.service.add_payment_method(payment_method)
self.assertIsNotNone(response)
self.assertIsNotNone(response.payment_method_key)
self.__class__.payment_method_key_check_ppd = response.payment_method_key
def test_006_add_payment_check_ccd(self):
payment_method = HpsPayPlanPaymentMethod()
payment_method.payment_method_identifier = self.get_identifier('CheckCCD')
payment_method.payment_method_type = HpsPayPlanPaymentMethodType.ACH
payment_method.ach_type = 'Checking'
payment_method.account_type = 'Business'
payment_method.telephone_indicator = 0
payment_method.routing_number = '490000018'
payment_method.name_on_account = 'Acme Co'
payment_method.drivers_license_number = '3692581470'
payment_method.drivers_license_state = 'TX'
payment_method.account_number = '24413815'
payment_method.address_line_1 = '987 Elm St'
payment_method.city = 'Princeton'
payment_method.state_province = 'NJ'
payment_method.zip_postal_code = '12345'
payment_method.customer_key = self.__class__.customer_company_key
payment_method.country = 'USA'
payment_method.account_holder_yob = '1989'
response = self.service.add_payment_method(payment_method)
self.assertIsNotNone(response)
self.assertIsNotNone(response.payment_method_key)
self.__class__.payment_method_key_check_ccd = response.payment_method_key
""" Payment Setup - Declined """
def test_007_add_payment_check_ppd(self):
payment_method = HpsPayPlanPaymentMethod()
payment_method.payment_method_identifier = self.get_identifier('CheckPPD')
payment_method.payment_method_type = HpsPayPlanPaymentMethodType.ACH
payment_method.ach_type = 'Checking'
payment_method.account_type = 'Personal'
payment_method.telephone_indicator = 0
payment_method.routing_number = '490000050'
payment_method.name_on_account = 'John Doe'
payment_method.drivers_license_number = '7418529630'
payment_method.account_number = '24413815'
payment_method.address_line_1 = '123 Main St'
payment_method.city = 'Dallas'
payment_method.state_province = 'TX'
payment_method.zip_postal_code = '98765'
payment_method.customer_key = self.customer_person_key
self.assertRaises(HpsException, self.service.add_payment_method, payment_method)
""" Recurring Billing using PayPlan - Managed Schedule """
def test_008_add_schedule_credit_visa(self):
schedule = HpsPayPlanSchedule()
schedule.schedule_identifier = self.get_identifier('CreditV')
schedule.customer_key = self.__class__.customer_person_key
schedule.schedule_status = HpsPayPlanScheduleStatus.ACTIVE
schedule.payment_method_key = self.__class__.payment_method_key_visa
schedule.subtotal_amount = HpsPayPlanAmount(3001)
schedule.start_date = '02012027'
schedule.frequency = HpsPayPlanScheduleFrequency.WEEKLY
schedule.duration = HpsPayPlanScheduleDuration.ONGOING
schedule.reprocessing_count = 1
response = self.service.add_schedule(schedule)
self.assertIsNotNone(response)
self.assertIsNotNone(response.schedule_key)
self.__class__.schedule_key_visa = response.schedule_key
def test_009_add_schedule_credit_mastercard(self):
schedule = HpsPayPlanSchedule()
schedule.schedule_identifier = self.get_identifier('CreditMC')
schedule.customer_key = self.__class__.customer_person_key
schedule.schedule_status = HpsPayPlanScheduleStatus.ACTIVE
schedule.payment_method_key = self.__class__.payment_method_key_mastercard
schedule.subtotal_amount = HpsPayPlanAmount(3002)
schedule.start_date = '02012027'
schedule.frequency = HpsPayPlanScheduleFrequency.WEEKLY
schedule.duration = HpsPayPlanScheduleDuration.END_DATE
schedule.end_date = '04012027'
schedule.reprocessing_count = 2
response = self.service.add_schedule(schedule)
self.assertIsNotNone(response)
self.assertIsNotNone(response.schedule_key)
self.__class__.schedule_key_mastercard = response.schedule_key
def test_010_add_schedule_check_ppd(self):
schedule = HpsPayPlanSchedule()
schedule.schedule_identifier = self.get_identifier('CheckPPD')
schedule.customer_key = self.__class__.customer_person_key
schedule.schedule_status = HpsPayPlanScheduleStatus.ACTIVE
schedule.payment_method_key = self.__class__.payment_method_key_check_ppd
schedule.subtotal_amount = HpsPayPlanAmount(3003)
schedule.start_date = '02012027'
schedule.frequency = HpsPayPlanScheduleFrequency.MONTHLY
schedule.duration = HpsPayPlanScheduleDuration.LIMITED_NUMBER
schedule.reprocessing_count = 1
schedule.number_of_payments = 2
schedule.processing_date_info = '1'
response = self.service.add_schedule(schedule)
self.assertIsNotNone(response)
self.assertIsNotNone(response.schedule_key)
self.__class__.schedule_key_check_ppd = response.schedule_key
def test_011_add_schedule_check_ccd(self):
schedule = HpsPayPlanSchedule()
schedule.schedule_identifier = self.get_identifier('CheckCCD')
schedule.customer_key = self.__class__.customer_company_key
schedule.schedule_status = HpsPayPlanScheduleStatus.ACTIVE
schedule.payment_method_key = self.__class__.payment_method_key_check_ccd
schedule.subtotal_amount = HpsPayPlanAmount(3004)
schedule.start_date = '02012027'
schedule.frequency = HpsPayPlanScheduleFrequency.BIWEEKLY
schedule.duration = HpsPayPlanScheduleDuration.ONGOING
schedule.reprocessing_count = 1
response = self.service.add_schedule(schedule)
self.assertIsNotNone(response)
self.assertIsNotNone(response.schedule_key)
self.__class__.schedule_key_check_ccd = response.schedule_key
""" Recurring Billing - Declined """
def test_012_add_schedule_credit_visa(self):
schedule = HpsPayPlanSchedule()
schedule.schedule_identifier = self.get_identifier('CreditV')
schedule.customer_key = self.__class__.customer_person_key
schedule.schedule_status = HpsPayPlanScheduleStatus.ACTIVE
schedule.payment_method_key = self.__class__.payment_method_key_visa
schedule.subtotal_amount = HpsPayPlanAmount(1008)
schedule.start_date = '02012027'
schedule.frequency = HpsPayPlanScheduleFrequency.WEEKLY
schedule.duration = HpsPayPlanScheduleDuration.ONGOING
schedule.reprocessing_count = 2
self.assertRaises(HpsException, self.service.add_schedule, schedule)
def test_013_add_schedule_check_ppd(self):
schedule = HpsPayPlanSchedule()
schedule.schedule_identifier = self.get_identifier('CheckPPD')
schedule.customer_key = self.__class__.customer_person_key
schedule.schedule_status = HpsPayPlanScheduleStatus.ACTIVE
schedule.payment_method_key = self.__class__.payment_method_key_check_ppd
schedule.subtotal_amount = HpsPayPlanAmount(2501)
schedule.start_date = '02012027'
schedule.frequency = HpsPayPlanScheduleFrequency.WEEKLY
schedule.duration = HpsPayPlanScheduleDuration.LIMITED_NUMBER
schedule.reprocessing_count = 1
schedule.number_of_payments = 2
schedule.processing_date_info = '1'
self.assertRaises(HpsException, self.service.add_schedule, schedule)
""" Recurring Billing using PayPlan - Managed Schedule """
def test_014_recurring_billing_visa(self):
response = self.credit_service.recurring(20.01)\
.with_payment_method_key(self.__class__.payment_method_key_visa)\
.with_schedule(self.__class__.schedule_key_visa)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_015_recurring_billing_mastercard(self):
response = self.credit_service.recurring(20.02)\
.with_payment_method_key(self.__class__.payment_method_key_mastercard)\
.with_schedule(self.__class__.schedule_key_mastercard)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_016_recurring_billing_check_ppd(self):
response = self.check_service.recurring(20.03)\
.with_payment_method_key(self.__class__.payment_method_key_check_ppd)\
.with_schedule(self.__class__.schedule_key_check_ppd)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_017_recurring_billing_check_ccd(self):
response = self.check_service.recurring(20.04)\
.with_payment_method_key(self.__class__.payment_method_key_check_ccd)\
.with_schedule(self.__class__.schedule_key_check_ccd)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" One Time Bill Payment """
def test_018_recurring_billing_visa(self):
response = self.credit_service.recurring(20.06)\
.with_payment_method_key(self.__class__.payment_method_key_visa)\
.with_one_time(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_019_recurring_billing_mastercard(self):
response = self.credit_service.recurring(20.07)\
.with_payment_method_key(self.__class__.payment_method_key_mastercard)\
.with_one_time(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_020_recurring_billing_check_ppd(self):
response = self.check_service.recurring(20.08)\
.with_payment_method_key(self.__class__.payment_method_key_check_ppd)\
.with_one_time(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_021_recurring_billing_check_ccd(self):
response = self.check_service.recurring(20.09)\
.with_payment_method_key(self.__class__.payment_method_key_check_ccd)\
.with_one_time(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" One Time Bill Payment - Declined """
def test_022_recurring_billing_visa(self):
builder = self.credit_service.recurring(10.08)\
.with_payment_method_key(self.__class__.payment_method_key_visa)\
.with_one_time(True)
self.assertRaises(HpsCreditException, builder.execute)
def test_023_recurring_billing_check_ppd(self):
builder = self.check_service.recurring(25.02)\
.with_payment_method_key(self.__class__.payment_method_key_check_ppd)\
.with_one_time(True)
self.assertRaises(HpsCheckException, builder.execute)
""" CLOSE BATCH """
def test_999_close_batch(self):
try:
response = self.batch_service.close_batch()
if response is None:
self.fail("Response is None")
print('batch id: {0}'.format(response.id))
print('sequence number: {0}'.format(response.sequence_number))
# print self.__class__.customer_person_key
# print self.__class__.customer_company_key
# print self.__class__.payment_method_key_visa
# print self.__class__.payment_method_key_mastercard
# print self.__class__.payment_method_key_check_ppd
# print self.__class__.payment_method_key_check_ccd
# print self.__class__.schedule_key_visa
# print self.__class__.schedule_key_mastercard
# print self.__class__.schedule_key_check_ppd
# print self.__class__.schedule_key_check_ccd
except HpsException as e:
self.fail(e.message)
class MotoTests(unittest.TestCase):
config = HpsServicesConfig()
config.secret_api_key = 'skapi_cert_MRCQAQBC_VQACBE0rFaZlbDDPieMGP06JDAtjyS7NQ'
config.developer_id = '012345'
config.version_number = '0001'
batch_service = HpsBatchService(config)
service = HpsFluentCreditService().with_config(config)
use_tokens = True
use_prepaid = True
visa_token = None
mastercard_token = None
discover_token = None
amex_token = None
test_10_transaction_id = None
test_20_transaction_id = None
test_39_transaction_id = None
test_52_transaction_id = None
test_53_transaction_id = None
""" CARD VERIFY """
def test_000_close_batch(self):
try:
response = self.batch_service.close_batch()
if response is None:
self.fail("Response is None")
print('batch id: {0}'.format(response.id))
print('sequence number: {0}'.format(response.sequence_number))
except HpsException as e:
if e.message != 'Transaction was rejected because it requires a batch to be open.':
self.fail(e.message)
""" Account Verification """
def test_001_verify_visa(self):
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
response = self.service.verify()\
.with_card(card)\
.with_request_multi_use_token(self.use_tokens)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('85', response.response_code)
def test_002_verify_master_card(self):
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
response = self.service.verify()\
.with_card(card)\
.with_request_multi_use_token(self.use_tokens)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('85', response.response_code)
def test_003_verify_discover(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '6011000990156527'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.verify()\
.with_card(card)\
.with_card_holder(card_holder)\
.with_request_multi_use_token(self.use_tokens)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('85', response.response_code)
""" Address Verification """
def test_004_verify_amex(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
response = self.service.verify()\
.with_card(card)\
.with_card_holder(card_holder)\
.with_request_multi_use_token(self.use_tokens)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" Balance Inquiry (for Prepaid Card) """
def test_005_balance_inquiry_visa(self):
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
response = self.service.prepaid_balance_inquiry()\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" CREDIT SALE (For Multi-Use Token Only) """
def test_006_charge_visa_token(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
response = self.service.charge(13.01)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertIsNotNone(response.token_data)
self.assertIsNotNone(response.token_data.token_value)
self.__class__.visa_token = response.token_data.token_value
def test_007_charge_master_card_token(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(13.02)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertIsNotNone(response.token_data)
self.assertIsNotNone(response.token_data.token_value)
self.__class__.mastercard_token = response.token_data.token_value
def test_008_charge_discover_token(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '750241234'
card = HpsCreditCard()
card.number = '6011000990156527'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(13.03)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertIsNotNone(response.token_data)
self.assertIsNotNone(response.token_data.token_value)
self.__class__.discover_token = response.token_data.token_value
def test_009_charge_amex_token(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 1234
response = self.service.charge(13.04)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_request_multi_use_token(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertIsNotNone(response.token_data)
self.assertIsNotNone(response.token_data.token_value)
self.__class__.amex_token = response.token_data.token_value
""" CREDIT SALE """
def test_010_charge_visa(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
builder = self.service.charge(17.01)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)
if self.use_tokens:
builder.with_token(self.__class__.visa_token)
else:
builder.with_card(card)
response = builder.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.__class__.test_10_transaction_id = response.transaction_id
def test_011_charge_master_card(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
builder = self.service.charge(17.02)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)
if self.use_tokens:
builder.with_token(self.__class__.mastercard_token)
else:
builder.with_card(card)
response = builder.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_012_charge_discover(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '750241234'
direct_market_data = HpsDirectMarketData('123456')
card = HpsCreditCard()
card.number = '6011000990156527'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
builder = self.service.charge(17.03)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)
if self.use_tokens:
builder.with_token(self.__class__.discover_token)
else:
builder.with_card(card)
response = builder.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_013_charge_amex(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 1234
direct_market_data = HpsDirectMarketData('123456')
builder = self.service.charge(17.04)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)
if self.use_tokens:
builder.with_token(self.__class__.amex_token)
else:
builder.with_card(card)
response = builder.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_014_charge_jcb(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '750241234'
card = HpsCreditCard()
card.number = '3566007770007321'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.charge(17.05)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" AUTHORIZATION """
def test_015_authorization_visa(self):
# Test 015a Authorization
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.authorize(17.06)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
# test 015b Capture/AddToBatch
capture = self.service.capture(response.transaction_id).execute()
self.assertIsNotNone(capture)
self.assertEqual('00', capture.response_code)
def test_016_authorization_master_card(self):
# Test 016a Authorization
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '750241234'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.authorize(17.07)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
# test 016b Capture/AddToBatch
capture = self.service.capture(response.transaction_id).execute()
self.assertIsNotNone(capture)
self.assertEqual('00', capture.response_code)
def test_017_authorization_discover(self):
# Test 017a Authorization
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
direct_market_data = HpsDirectMarketData('123456')
card = HpsCreditCard()
card.number = '6011000990156527'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.authorize(17.08)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
# test 017b Capture/AddToBatch
# do not capture
""" PARTIALLY - APPROVED SALE """
def test_018_partial_approval_visa(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.charge(130)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.with_allow_partial_auth(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('10', response.response_code)
self.assertIsNotNone(response.authorized_amount)
self.assertEqual('110.00', response.authorized_amount)
def test_019_partial_approval_discover(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
direct_market_data = HpsDirectMarketData('123456')
card = HpsCreditCard()
card.number = '6011000990156527'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(145)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.with_allow_partial_auth(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('10', response.response_code)
self.assertIsNotNone(response.authorized_amount)
self.assertEqual('65.00', response.authorized_amount)
def test_020_partial_approval_master_card(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
direct_market_data = HpsDirectMarketData('123456')
card = HpsCreditCard()
card.number = '6011000990156527'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(155)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.with_allow_partial_auth(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('10', response.response_code)
self.assertIsNotNone(response.authorized_amount)
self.assertEqual('100.00', response.authorized_amount)
self.__class__.test_20_transaction_id = response.transaction_id
""" LEVEL II CORPORATE PURCHASE CARD """
def test_021_level_ii_response_b(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860 Dallas Pkwy'
card_holder.address.zip = '750241234'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(112.34)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('B', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.not_used)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_022_level_ii_response_b(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '750241234'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(112.34)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_allow_duplicates(True)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('B', response.cpc_indicator)
cpc_data = HpsCPCData('', HpsTaxType.sales_tax, 1.0)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_023_level_ii_response_r(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(123.45)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('R', response.cpc_indicator)
cpc_data = HpsCPCData('', HpsTaxType.tax_exempt)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_024_level_ii_response_s(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(134.56)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('S', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.sales_tax, 1.0)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_025_level_ii_response_s(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(111.06)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('S', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.not_used)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_026_level_ii_response_s(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(111.07)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('S', response.cpc_indicator)
cpc_data = HpsCPCData('', HpsTaxType.sales_tax, 1.00)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_027_level_ii_response_s(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(111.08)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('S', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.sales_tax, 1.00)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_028_level_ii_response_s(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(111.09)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('S', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.tax_exempt)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_029_level_ii_no_response(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 1234
response = self.service.charge(111.10)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('0', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.not_used)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_030_level_ii_no_response(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '750241234'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 1234
response = self.service.charge(111.11)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('0', response.cpc_indicator)
cpc_data = HpsCPCData('', HpsTaxType.sales_tax, 1.00)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_031_level_ii_no_response(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 1234
response = self.service.charge(111.12)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('0', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.sales_tax, 1.00)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
def test_032_level_ii_no_response(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '372700699251018'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 1234
response = self.service.charge(111.13)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_cpc_req(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.assertEqual('0', response.cpc_indicator)
cpc_data = HpsCPCData('9876543210', HpsTaxType.tax_exempt)
cpc_response = self.service.cpc_edit(response.transaction_id)\
.with_cpc_data(cpc_data)\
.execute()
self.assertIsNotNone(cpc_response)
self.assertEqual('00', cpc_response.response_code)
""" PRIOR / VOICE AUTHORIZATION """
def test_033_offline_sale(self):
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.offline_charge(17.10)\
.with_card(card)\
.with_offline_auth_code('654321')\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
def test_033_offline_authorization(self):
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.offline_auth(17.10)\
.with_card(card)\
.with_offline_auth_code('654321')\
.with_direct_market_data(direct_market_data)\
.with_allow_duplicates(True)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" RETURN """
def test_034_offline_credit_return(self):
card = HpsCreditCard()
card.number = '5473500000000014'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
direct_market_data = HpsDirectMarketData('123456')
response = self.service.refund(15.15)\
.with_card(card)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" ONLINE VOID / REVERSAL """
def test_035_void_test_10(self):
void_response = self.service.void(
self.__class__.test_10_transaction_id).execute()
self.assertIsNotNone(void_response)
self.assertEqual('00', void_response.response_code)
def test_036_void_test_20(self):
void_response = self.service.void(
self.__class__.test_20_transaction_id).execute()
self.assertIsNotNone(void_response)
self.assertEqual('00', void_response.response_code)
""" ADVANCED FRAUD SCREENING """
def test_037_fraud_prevention_sale(self):
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.charge(15000).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
# self.assertEqual('FR', response.issuser_response_code)
def test_038_fraud_prevention_return(self):
card = HpsCreditCard()
card.number = '4012002000060016'
card.exp_month = 12
card.exp_year = 2025
card.cvv = 123
response = self.service.refund(15000).with_card(card).execute()
self.assertIsNotNone(response)
if response.response_code != '00':
self.assertEqual('41', response.response_code)
# self.assertEqual('FR', response.issuser_response_code)
""" ONE CARD - GSB CARD FUNCTIONS """
""" BALANCE INQUIRY """
def test_039_balance_inquiry_gsb(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '6277220572999800'
card.exp_month = 12
card.exp_year = 2049
direct_market_data = HpsDirectMarketData('123456')
response = self.service.prepaid_balance_inquiry()\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" ADD VALUE """
def test_040_add_value_gsb(self):
card = HpsTrackData()
card.value = '%B6277220572999800^ / ^49121010557010000016000000?F;6277220572999800=49121010557010000016?'
response = self.service.prepaid_add_value(15.00).with_track_data(
card).execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" SALE """
def test_041_charge_gsb(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '6277220572999800'
card.exp_month = 12
card.exp_year = 2049
direct_market_data = HpsDirectMarketData('123456')
response = self.service.charge(2.05)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
self.__class__.test_39_transaction_id = response.transaction_id
def test_042_charge_gsb(self):
card_holder = HpsCardHolder()
card_holder.address = HpsAddress()
card_holder.address.address = '6860'
card_holder.address.zip = '75024'
card = HpsCreditCard()
card.number = '6277220572999800'
card.exp_month = 12
card.exp_year = 2049
direct_market_data = HpsDirectMarketData('123456')
response = self.service.charge(2.10)\
.with_card(card)\
.with_card_holder(card_holder)\
.with_direct_market_data(direct_market_data)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('00', response.response_code)
""" ONLINE VOID / REVERSAL """
def test_043_void_gsb(self):
void_response = self.service.void(
self.__class__.test_39_transaction_id).execute()
self.assertIsNotNone(void_response)
self.assertEqual('00', void_response.response_code)
""" HMS GIFT - REWARDS """
""" GIFT """
gift_service = HpsFluentGiftCardService(config)
# def gift_card_1(self):
# card = HpsGiftCard()
# card.card_number = '5022440000000000098'
#
# return card
#
# def gift_card_2(self):
# card = HpsGiftCard()
# card.card_number = '5022440000000000007'
#
# return card
""" ACTIVATE """
def test_044_activate_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.activate(6.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_045_activate_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.activate(7.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" LOAD / ADD VALUE """
def test_046_add_value_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.add_value(8.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_047_add_value_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.add_value(9.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" BALANCE INQUIRY """
def test_048_balance_inquiry_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.balance().with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
self.assertEqual('10.00', response.balance_amount)
def test_049_balance_inquiry_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.balance().with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
self.assertEqual('10.00', response.balance_amount)
""" REPLACE / TRANSFER """
def test_050_replace_gift_1(self):
old_card = HpsGiftCard()
old_card.card_number = '5022440000000000098'
new_card = HpsGiftCard()
new_card.card_number = '5022440000000000007'
response = self.gift_service.replace()\
.with_old_card(old_card)\
.with_new_card(new_card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_051_replace_gift_2(self):
new_card = HpsGiftCard()
new_card.card_number = '5022440000000000098'
old_card = HpsGiftCard()
old_card.card_number = '5022440000000000007'
response = self.gift_service.replace()\
.with_old_card(old_card)\
.with_new_card(new_card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" SALE / REDEEM """
def test_052_sale_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.sale(1.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_053_sale_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.sale(2.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_054_sale_gift_1_void(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.sale(3.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
self.__class__.test_52_transaction_id = response.transaction_id
def test_055_sale_gift_2_reversal(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.sale(4.00).with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
self.__class__.test_53_transaction_id = response.transaction_id
""" VOID """
def test_056_void_gift(self):
void_response = self.gift_service.void(
self.__class__.test_52_transaction_id).execute()
self.assertIsNotNone(void_response)
self.assertEqual('0', void_response.response_code)
""" REVERSAL """
def test_057_reversal_gift(self):
reversal_response = self.gift_service.reverse(4.00)\
.with_transaction_id(self.__class__.test_53_transaction_id)\
.execute()
self.assertIsNotNone(reversal_response)
self.assertEqual('0', reversal_response.response_code)
def test_058_reversal_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
reversal_response = self.gift_service.reverse(2.00).with_card(
card).execute()
self.assertIsNotNone(reversal_response)
self.assertEqual('0', reversal_response.response_code)
""" DEACTIVATE """
def test_059_deactivate_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.deactivate().with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" RECEIPTS MESSAGING """
def test_060_receipts_messaging(self):
pass # print and scan receipt for test 51
""" REWARD """
""" BALANCE INQUIRY """
def test_061_balance_inquiry_rewards_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.balance().with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
self.assertEqual('0', response.points_balance_amount)
def test_062_balance_inquiry_rewards_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.balance().with_card(card).execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
self.assertEqual('0', response.points_balance_amount)
""" ALIAS """
def test_063_create_alias_gift_1(self):
response = self.gift_service.alias()\
.with_alias('9725550100')\
.with_action('CREATE')\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_064_create_alias_gift_2(self):
response = self.gift_service.alias()\
.with_alias('9725550100')\
.with_action('CREATE')\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_065_add_alias_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.alias()\
.with_card(card)\
.with_alias('2145550199')\
.with_action('ADD')\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_066_add_alias_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.alias()\
.with_card(card)\
.with_alias('2145550199')\
.with_action('ADD')\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_067_delete_alias_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.alias()\
.with_card(card)\
.with_alias('2145550199')\
.with_action('DELETE')\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" SALE / REDEEM """
def test_068_redeem_points_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.sale(100)\
.with_currency('points')\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_069_redeem_points_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.sale(200)\
.with_currency('points')\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_070_redeem_points_gift_2(self):
gift = HpsGiftCard()
gift.alias = '9725550100'
response = self.gift_service.sale(300)\
.with_currency('points')\
.with_card(gift)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" REWARDS """
def test_071_rewards_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.reward(10)\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_072_rewards_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.reward(11)\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" REPLACE / TRANSFER """
def test_073_replace_gift_1(self):
old_card = HpsGiftCard()
old_card.card_number = '5022440000000000098'
new_card = HpsGiftCard()
new_card.card_number = '5022440000000000007'
response = self.gift_service.replace()\
.with_old_card(old_card)\
.with_new_card(new_card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_074_replace_gift_2(self):
new_card = HpsGiftCard()
new_card.card_number = '5022440000000000098'
old_card = HpsGiftCard()
old_card.card_number = '5022440000000000007'
response = self.gift_service.replace()\
.with_old_card(old_card)\
.with_new_card(new_card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" DEACTIVATE """
def test_075_deactivate_gift_1(self):
card = HpsGiftCard()
card.card_number = '5022440000000000098'
response = self.gift_service.deactivate()\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
def test_076_deactivate_gift_2(self):
card = HpsGiftCard()
card.card_number = '5022440000000000007'
response = self.gift_service.deactivate()\
.with_card(card)\
.execute()
self.assertIsNotNone(response)
self.assertEqual('0', response.response_code)
""" RECEIPTS MESSAGING """
def test_077_receipts_messaging(self):
pass # print and scan receipt for test 51
""" CLOSE BATCH """
def test_999_close_batch(self):
try:
response = self.batch_service.close_batch()
if response is None:
self.fail("Response is None")
print('batch id: {0}'.format(response.id))
print('sequence number: {0}'.format(response.sequence_number))
except HpsException as e:
self.fail(e.message)