def test_validate_family(self):
# When the insuree family is invalid
# Given
invalid_insuree = Insuree.objects.filter(
family__in=Family.objects.filter(
validity_to__isnull=False)).first()
self.assertIsNotNone(invalid_insuree)
claim = create_test_claim({"insuree_id": invalid_insuree.id})
service1 = create_test_claimservice(claim, "S")
item1 = create_test_claimitem(claim, "D")
# When
errors = validate_claim(claim, True)
# Then
claim.refresh_from_db()
item1.refresh_from_db()
self.assertGreaterEqual(len(errors), 1,
"Should raise at least one error")
error7 = [e for e in errors if e['code'] == 7]
self.assertGreaterEqual(
len(error7), 1, "There should be 1 error code 7: invalid insuree")
self.assertEquals(item1.rejection_reason, 7,
"Database was updated with rejection reason")
# tearDown
service1.delete()
item1.delete()
claim.delete()
def test_validate_pricelist_hf1(self):
# When the claimitem points to a pricelist that doesn't correspond to the claim HF
hf_without_pricelist = HealthFacility.objects.filter(
items_pricelist__id__isnull=True).first()
self.assertIsNotNone(
hf_without_pricelist,
"This test requires a health facility without a price list item")
# Given
claim = create_test_claim(
{"health_facility_id": hf_without_pricelist.id})
service1 = create_test_claimservice(claim, "S")
item1 = create_test_claimitem(claim, "D")
# When
errors = validate_claim(claim, True)
# Then
claim.refresh_from_db()
service1.refresh_from_db()
item1.refresh_from_db()
self.assertGreaterEqual(len(errors), 1,
"Should raise at least one error")
error1 = [e for e in errors if e['code'] == 1] # all services rejected
self.assertGreaterEqual(len(error1), 1,
"There should be an error code 1")
self.assertEquals(item1.rejection_reason, 2,
"Database was updated with rejection reason")
# tearDown
service1.delete()
item1.delete()
claim.delete()
def handle(self, *args, **options):
nb_claims = options["nb_claims"][0]
nb_services = options["nb_services"][0]
nb_items = options["nb_items"][0]
verbose = options["verbose"]
for claim_num in range(1, nb_claims + 1):
insuree = self.get_random_insuree()
claim_admin = self.get_random_claim_admin()
hf = self.get_random_hf()
claim = create_test_claim({
"insuree_id":
insuree,
"code":
''.join(
random.choices(string.ascii_uppercase + string.digits,
k=8)),
"admin_id":
claim_admin,
"health_facility_id":
hf
})
if verbose:
print(claim_num, "created claim", claim, "for insuree",
insuree, "with code", claim.code)
for svc_num in range(1, nb_services + 1):
service = self.get_random_service()
claim_service = create_test_claimservice(
claim, custom_props={"service_id": service})
if verbose:
print(claim_num, svc_num, "Created claim service",
claim_service, "for service", service)
for item_num in range(1, nb_items + 1):
item = self.get_random_service()
claim_item = create_test_claimitem(
claim, "D", custom_props={"item_id": item})
if verbose:
print(claim_num, item_num, "Created claim service",
claim_item, "for service", item)
def test_submit_claim_dedrem(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("VISIT", custom_props={})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("V", custom_props={})
item = create_test_item("D", custom_props={})
product_service = create_test_product_service(product, service)
product_item = create_test_product_item(product, item)
pricelist_detail1 = add_service_to_hf_pricelist(service)
pricelist_detail2 = add_item_to_hf_pricelist(item)
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
item1 = create_test_claimitem(claim1,
"D",
custom_props={"item_id": item.id})
errors = validate_claim(claim1, True)
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, True)
self.assertEqual(len(errors), 0)
# Then
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
self.assertEqual(len(errors), 0)
self.assertEqual(item1.price_adjusted, 100)
self.assertEqual(item1.price_valuated, 700)
self.assertEqual(item1.deductable_amount, 0)
self.assertEqual(item1.exceed_ceiling_amount, 0)
self.assertIsNone(item1.exceed_ceiling_amount_category)
self.assertEqual(item1.remunerated_amount, 700)
self.assertEqual(claim1.status, Claim.STATUS_VALUATED)
self.assertEqual(claim1.audit_user_id_process, -1)
self.assertIsNotNone(claim1.process_stamp)
self.assertIsNotNone(claim1.date_processed)
dedrem_qs = ClaimDedRem.objects.filter(claim=claim1)
self.assertEqual(dedrem_qs.count(), 1)
dedrem1 = dedrem_qs.first()
self.assertEqual(dedrem1.policy_id, item1.policy_id)
self.assertEqual(dedrem1.insuree_id, claim1.insuree_id)
self.assertEqual(dedrem1.audit_user_id, -1)
self.assertEqual(dedrem1.ded_g, 0)
self.assertEqual(dedrem1.rem_g, 1400)
self.assertEqual(dedrem1.rem_op, 1400)
self.assertIsNone(dedrem1.rem_ip)
self.assertEqual(dedrem1.rem_surgery, 0)
self.assertEqual(dedrem1.rem_consult, 0)
self.assertEqual(dedrem1.rem_hospitalization, 0)
self.assertIsNotNone(claim1.validity_from)
self.assertIsNone(claim1.validity_to)
# tearDown
dedrem_qs.delete()
service1.delete()
item1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_item.delete()
product_service.delete()
pricelist_detail1.delete()
pricelist_detail2.delete()
service.delete()
item.delete()
product.delete()
"name": "Basic Cover Ultha",
"lump_sum": 10_000,
"max_amount_delivery": 55,
})
product_service = create_test_product_service(product, service)
product_item = create_test_product_item(product, item)
policy = create_test_policy(product, insuree, link=True)
pricelist_detail1 = add_service_to_hf_pricelist(service)
pricelist_detail2 = add_item_to_hf_pricelist(item)
# The insuree has a patient_category of 6, not matching the service category
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
item1 = create_test_claimitem(claim1,
"D",
custom_props={"item_id": item.id})
errors = validate_claim(claim1, True)
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, True)
self.assertEqual(len(errors), 0)
# Then
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
self.assertEqual(len(errors), 0)
self.assertEqual(item1.price_adjusted, 100)
self.assertEqual(item1.price_valuated, 55)
self.assertEqual(item1.deductable_amount, 0)
self.assertEqual(item1.exceed_ceiling_amount, 0)
def test_review_reject_delete_dedrem(self):
"""
This test creates a claim, submits it so that it gets dedrem entries,
then submits a review rejecting part of it, then process the claim.
It should not be processed (which was ok) but the dedrem should be deleted.
"""
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
service = create_test_service("A", custom_props={"name": "test_review_reject_delete_dedrem"})
item = create_test_item("A", custom_props={"name": "test_review_reject_delete_dedrem"})
product = create_test_product("BCUL0001", custom_props={
"name": "Basic Cover Ultha deldedrem",
"lump_sum": 10_000,
})
product_service = create_test_product_service(product, service)
product_item = create_test_product_item(product, item)
policy = create_test_policy(product, insuree, link=True)
pricelist_detail1 = add_service_to_hf_pricelist(service)
pricelist_detail2 = add_item_to_hf_pricelist(item)
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id, "qty_provided": 2})
item1 = create_test_claimitem(
claim1, "A", custom_props={"item_id": item.id, "qty_provided": 3})
errors = validate_claim(claim1, True)
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, False)
self.assertEqual(len(errors), 0)
# Make sure that the dedrem was generated
dedrem = ClaimDedRem.objects.filter(claim=claim1).first()
self.assertIsNotNone(dedrem)
self.assertEquals(dedrem.rem_g, 500) # 100*2 + 100*3
# Review the claim and reject all of it
# A partial rejection would still trigger the process_dedrem and be fine
item1.qty_approved = 0
item1.price_approved = 0
item1.status = ClaimItem.STATUS_REJECTED
item1.rejection_reason = -1
item1.audit_user_id_review = -1
item1.justification = "Review comment item"
item1.save()
service1.qty_approved = 0
service1.price_approved = 0
service1.status = ClaimItem.STATUS_REJECTED
service1.rejection_reason = -1
service1.audit_user_id_review = -1
service1.justification = "Review comment svc"
service1.save()
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
set_claims_status([claim1.uuid], "review_status", Claim.REVIEW_DELIVERED)
update_claims_dedrems([claim1.uuid], User.objects.first())
errors = validate_claim(claim1, True)
if len(errors) == 0:
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, False)
# The claim should be globally rejected since the review rejected all items/svc
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
self.assertEquals(claim1.status, Claim.STATUS_REJECTED)
self.assertEquals(claim1.rejection_reason, REJECTION_REASON_INVALID_ITEM_OR_SERVICE)
self.assertEquals(item1.status, ClaimDetail.STATUS_REJECTED)
self.assertEquals(item1.rejection_reason, -1)
self.assertEquals(service1.status, ClaimDetail.STATUS_REJECTED)
self.assertEquals(service1.rejection_reason, -1)
# Then dedrem should have been deleted
dedrem = ClaimDedRem.objects.filter(claim=claim1).first()
self.assertIsNone(dedrem)
# tearDown
# dedrem.delete() # already done if the test passed
delete_claim_with_itemsvc_dedrem_and_history(claim1)
policy.insuree_policies.first().delete()
policy.delete()
product_item.delete()
product_service.delete()
pricelist_detail1.delete()
pricelist_detail2.delete()
service.delete()
item.delete()
product.delete()