def test_waiting_period(self):
# When the insuree already reaches his limit of visits
# Given
from core import datetime
insuree = create_test_insuree()
child_insuree = create_test_insuree(custom_props={
"dob": datetime.datetime(2020, 1, 1),
"family": insuree.family
})
self.assertIsNotNone(insuree)
product = create_test_product("CSECT")
policy = create_test_policy(product, insuree, link=True)
policy_child = create_test_policy(product, child_insuree, link=True)
service = create_test_service("C")
product_service = create_test_product_service(
product, service, custom_props={"waiting_period_adult": 6, "waiting_period_child": 0})
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a visit within the waiting period should be refused
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
self.assertEqual(len(errors), 1, "An adult visit within the waiting period should be refused")
self.assertEqual(claim1.services.first().rejection_reason, REJECTION_REASON_WAITING_PERIOD_FAIL)
# a visit after the waiting period should be fine
claim2 = create_test_claim({
"insuree_id": insuree.id,
"date_from": datetime.datetime(2020, 2, 1),
"date_to": datetime.datetime(2020, 2, 1),
"date_claimed": datetime.datetime(2020, 2, 1),
})
service2 = create_test_claimservice(claim2, custom_props={"service_id": service.id})
errors = validate_claim(claim2, True)
self.assertEqual(len(errors), 0, "This one should be accepted as after the waiting period")
# a child should not have the waiting period
claim3 = create_test_claim({"insuree_id": child_insuree.id})
service3 = create_test_claimservice(claim3, custom_props={"service_id": service.id})
errors = validate_claim(claim3, True)
self.assertEqual(len(errors), 0, "The child has no waiting period")
# tearDown
service3.delete()
claim3.delete()
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.all().delete()
policy.delete()
policy_child.insuree_policies.all().delete()
policy_child.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_frequency(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("CSECT")
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("C",
custom_props={
"code": "G34B",
"frequency": 180
})
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a visit should be accepted
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
mark_test_claim_as_processed(claim1)
self.assertEquals(len(errors), 0, "The first visit should be accepted")
# a second visit should be denied
claim2 = create_test_claim({"insuree_id": insuree.id})
service2 = create_test_claimservice(
claim2, custom_props={"service_id": service.id})
errors = validate_claim(claim2, True)
self.assertGreater(
len(errors), 0,
"The second service should be refused as it is withing 180 days")
# Then
claim1.refresh_from_db()
claim2.refresh_from_db()
# tearDown
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
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 test_validate_patient_category(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={"max_no_visits": 1})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("V", custom_props={"patient_category": 1})
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# 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})
errors = validate_claim(claim1, True)
# Then
claim1.refresh_from_db()
self.assertEquals(len(errors), 1)
self.assertEquals(errors[0]['code'], 1) # claimed rejected because all services are rejected
self.assertEquals(claim1.services.first().rejection_reason, 4) # reason is wrong insuree mask
# tearDown
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_limit_surgery(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("DELIV",
custom_props={"max_no_surgery": 1})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("S", custom_props={"code": "SSSS"})
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a delivery should be accepted
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
mark_test_claim_as_processed(claim1)
self.assertEquals(len(errors), 0,
"The first surgery should be accepted")
# a second delivery should be denied
claim2 = create_test_claim({"insuree_id": insuree.id})
service2 = create_test_claimservice(
claim2, custom_props={"service_id": service.id})
errors = validate_claim(claim2, True)
self.assertGreater(
len(errors), 0,
"The second service should fail because there is already one surgery"
)
# Then
claim1.refresh_from_db()
claim2.refresh_from_db()
# tearDown
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_validate_max_visits(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={"max_no_visits": 1})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("V")
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a visit should be accepted
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
self.assertEquals(len(errors), 0, "The first visit should be accepted")
# a second visit should be denied
claim2 = create_test_claim({"insuree_id": insuree.id})
service2 = create_test_claimservice(claim2, "V")
errors = validate_claim(claim2, True)
# TODO Temporarily disabled
# self.assertGreater(len(errors), 0, "The second visit should be refused")
# Then
claim1.refresh_from_db()
claim2.refresh_from_db()
# tearDown
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_simple_monthly_batch_run(self) -> None:
insuree1 = create_test_insuree()
self.assertIsNotNone(insuree1)
product = create_test_product("TEST1",
custom_props={
"location_id": 1,
"period_rel_prices": 4
})
policy = create_test_policy(product, insuree1, link=True)
service = create_test_service("V")
product_service = create_test_product_service(
product,
service,
custom_props={"price_origin": ProductService.ORIGIN_RELATIVE})
pricelist_detail = add_service_to_hf_pricelist(service)
premium = create_test_premium(policy_id=policy.id, with_payer=True)
create_test_rel_distr_range(product.id,
RelativeDistribution.TYPE_QUARTER,
RelativeDistribution.CARE_TYPE_BOTH, 10)
claim1 = create_test_claim({"insuree_id": insuree1.id})
service1 = create_test_claimservice(claim1,
custom_props={
"service_id": service.id,
"price_origin":
ProductService.ORIGIN_RELATIVE,
"product": product
})
errors = validate_claim(claim1, True)
self.assertEquals(len(errors), 0)
errors = validate_assign_prod_to_claimitems_and_services(claim1)
self.assertEquals(len(errors), 0)
_mark_as_processed(claim1)
claim1.refresh_from_db()
result = process_batch(1, location_id=1, period=6, year=2019)
# tearDown
premium.delete()
premium.payer.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
for rd in product.relative_distributions.all():
rd.delete()
product.delete()
def test_get_claim_category_D(self):
# Given
claim = create_test_claim()
service1 = create_test_claimservice(claim, "D")
# when
category = get_claim_category(claim)
# then
self.assertIsNotNone(category)
self.assertEquals(category, "D")
# tearDown
service1.delete()
claim.delete()
def test_get_claim_category_some_invalid(self):
# Given
claim = create_test_claim()
services = [
create_test_claimservice(claim, "H", False),
create_test_claimservice(claim, "A", False),
create_test_claimservice(claim, "S"),
]
# when
category = get_claim_category(claim)
# then
self.assertIsNotNone(category)
self.assertEquals(category, "S")
# tearDown
for service in services:
service.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()
item = create_test_item("D", custom_props={})
product = create_test_product("BCUL0001",
custom_props={
"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)
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()