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)