def test_long_creation(self):
msg = self._get_fake_sms(self.text_long)
create_billable_for_sms(msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.assertEqual(sms_billables[0].multipart_count, 2)
def test_gateway_charge_with_api_and_non_matching_gateway_fee_multiple_messages(
self):
"""
A backend with non-matching gateway_fee and an API should charge using the API
'Non-matching' means the message under test does not fit the gateway fee criteria
ASSUMPTION: we assume that the API will return a value accounting for multiple messages if applicable
This may be true for Twilio, but as we add other gateways that support an API we should check
"""
api_fee = Decimal('0.01')
gateway_fee_amount = Decimal('0.0075')
# expect to return the api fee as is
expected_gateway_charge = api_fee
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, long_text)
self.gateway_fees += [
# the default number here has a country code of 1, so make this code different
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction,
gateway_fee_amount,
country_code=10),
]
with patch(
'corehq.apps.smsbillables.models.SmsBillable.get_charge_details_through_api',
return_value=(api_fee, 1)):
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_gateway_charge = self.billable.gateway_charge
self.assertEqual(expected_gateway_charge, actual_gateway_charge)
def test_gateway_charge_for_country_code(self):
"""
Create a generic gateway fee and a specific gateway fee with country code
"""
specific_gateway_fee_amount = Decimal('0.01')
generic_gateway_fee_amount = Decimal('0.005')
expected_gateway_charge = specific_gateway_fee_amount
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, short_text)
self.gateway_fees += [
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction,
generic_gateway_fee_amount),
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction,
specific_gateway_fee_amount,
country_code=1),
]
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_gateway_charge = self.billable.gateway_charge
self.assertEqual(expected_gateway_charge, actual_gateway_charge)
def test_gateway_charge_with_api_and_matching_gateway_fee_multiple_messages(
self):
"""
A backend with non-matching gateway_fee and an API should charge using the API
'Matching' means the message under test fits with the criteria set for the gateway_fee
If using the gateway fee we need to do the calculation for the cost of multiple messages
"""
api_fee = Decimal('0.01')
gateway_fee_amount = Decimal('0.0075')
# expect to return the gateway fee x 2 (long_text takes up 2 messages)
expected_gateway_charge = gateway_fee_amount * 2
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, long_text)
self.gateway_fees += [
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction, gateway_fee_amount),
]
with patch(
'corehq.apps.smsbillables.models.SmsBillable.get_charge_details_through_api',
return_value=(api_fee, None)):
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_gateway_charge = self.billable.gateway_charge
self.assertEqual(expected_gateway_charge, actual_gateway_charge)
def test_gateway_charge_with_api_and_non_matching_gateway_fee(self):
"""
A backend with non-matching gateway_fee and an API should charge using the API
'Non-matching' means the message under test does not fit the gateway fee criteria
"""
api_fee = Decimal('0.01')
gateway_fee_amount = Decimal('0.0075')
# expect to return the api price
expected_gateway_charge = api_fee
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, short_text)
self.gateway_fees += [
# the default number here has a country code of 1, so make this code different
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction,
gateway_fee_amount,
country_code=10),
]
with patch(
'corehq.apps.smsbillables.models.SmsBillable.get_charge_details_through_api',
return_value=(api_fee, 1)):
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_gateway_charge = self.billable.gateway_charge
self.assertEqual(expected_gateway_charge, actual_gateway_charge)
def test_long_creation(self):
msg = self._get_fake_sms(self.text_long)
create_billable_for_sms(msg, delay=False)
sms_billables = SmsBillable.objects.filter(
domain=self.domain,
log_id=msg._id
)
self.assertEqual(sms_billables.count(), 2)
def test_creation(self):
msg = self._get_fake_sms(self.text_short)
create_billable_for_sms(msg, delay=False)
sms_billables = SmsBillable.objects.filter(
domain=self.domain,
log_id=msg.couch_id
)
self.assertEqual(sms_billables.count(), 1)
self.assertEqual(sms_billables[0].multipart_count, 1)
def test_long_creation(self):
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, long_text)
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
self.assertEqual(self.billable.multipart_count, 2)
def remove_from_queue(queued_sms):
with transaction.atomic():
sms = SMS()
for field in sms._meta.fields:
if field.name != 'id':
setattr(sms, field.name, getattr(queued_sms, field.name))
queued_sms.delete()
sms.save()
sms.publish_change()
if sms.direction == OUTGOING and sms.processed and not sms.error:
create_billable_for_sms(sms)
elif sms.direction == INCOMING and sms.domain and domain_has_privilege(sms.domain, privileges.INBOUND_SMS):
create_billable_for_sms(sms)
def remove_from_queue(queued_sms):
with transaction.atomic():
sms = get_sms_from_queued_sms(queued_sms)
queued_sms.delete()
sms.save()
sms.publish_change()
tags = {'backend': sms.backend_api}
if sms.direction == OUTGOING and sms.processed and not sms.error:
create_billable_for_sms(sms)
metrics_counter('commcare.sms.outbound_succeeded', tags=tags)
elif sms.direction == OUTGOING:
metrics_counter('commcare.sms.outbound_failed', tags=tags)
elif sms.direction == INCOMING and sms.domain and domain_has_privilege(sms.domain, privileges.INBOUND_SMS):
create_billable_for_sms(sms)
def test_gateway_fee_after_creation(self):
expected_fee = Decimal('0.005')
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, short_text)
self.gateway_fee = SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction,
expected_fee)
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_fee = self.billable.gateway_fee.amount
self.assertEqual(expected_fee, actual_fee)
def test_gateway_charge_general_criteria(self):
"""
Create a gateway fee with no specific criteria and ensure gateway charge is expected
"""
expected_gateway_charge = Decimal('0.01')
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, short_text)
self.gateway_fees += [
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction,
expected_gateway_charge),
]
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_fee = self.billable.gateway_charge
self.assertEqual(expected_gateway_charge, actual_fee)
def remove_from_queue(queued_sms):
with transaction.atomic():
sms = SMS()
for field in sms._meta.fields:
if field.name != 'id':
setattr(sms, field.name, getattr(queued_sms, field.name))
queued_sms.delete()
sms.save()
sms.publish_change()
tags = {'backend': sms.backend_api, 'icds_indicator': ''}
if isinstance(sms.custom_metadata,
dict) and 'icds_indicator' in sms.custom_metadata:
tags.update({'icds_indicator': sms.custom_metadata['icds_indicator']})
if sms.direction == OUTGOING and sms.processed and not sms.error:
create_billable_for_sms(sms)
metrics_counter('commcare.sms.outbound_succeeded', tags=tags)
elif sms.direction == OUTGOING:
metrics_counter('commcare.sms.outbound_failed', tags=tags)
elif sms.direction == INCOMING and sms.domain and domain_has_privilege(
sms.domain, privileges.INBOUND_SMS):
create_billable_for_sms(sms)
def test_gateway_charge_with_api(self):
"""
A backend that uses an API to fetch prices with a gateway_fee.amount = None should always return
the price specified by the API
"""
expected_gateway_charge = Decimal('0.01')
self.msg = get_fake_sms(self.domain, self.backend.hq_api_id,
self.backend.couch_id, short_text)
self.gateway_fees += [
SmsGatewayFee.create_new(self.backend.hq_api_id,
self.msg.direction, None),
]
with patch(
'corehq.apps.smsbillables.models.SmsBillable.get_charge_details_through_api',
return_value=(expected_gateway_charge, 1)):
create_billable_for_sms(self.msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=self.msg.couch_id)
self.assertEqual(sms_billables.count(), 1)
self.billable = sms_billables[0]
actual_gateway_charge = self.billable.gateway_charge
self.assertEqual(expected_gateway_charge, actual_gateway_charge)
def test_creation(self):
msg = self._get_fake_sms(self.text_short)
create_billable_for_sms(msg, delay=False)
sms_billables = SmsBillable.objects.filter(domain=self.domain,
log_id=msg._id)
self.assertEqual(sms_billables.count(), 1)
