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_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()
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()