def test_sensitization(self):
"""Test a sensitization visit within the target area."""
data_setup()
factory = RequestFactory()
sprayarea = Location.objects.get(name='Akros_1')
view = TargetAreaView.as_view()
request = factory.get("/2/3")
response = view(
request,
district_pk=sprayarea.parent_id, slug=sprayarea.id)
self.assertContains(
response,
'Mobilised? <i class="fa fa-times" style="color: red"></i>',
html=True)
sprayarea.is_sensitized = True
sprayarea.save()
response = view(
request, district_pk=sprayarea.parent_id,
slug=sprayarea.id)
self.assertContains(
response,
'Community Ready? \
<i class="fa fa-check-circle" style="color: green"></i>',
html=True)
def test_mda_location_view(self):
"""Test MDALocationView"""
data_setup()
location = Location.objects.filter(level="district").first()
factory = RequestFactory()
request = factory.get("/mda/{}".format(location.pk))
view = MDALocationView.as_view()
response = view(request, location=location.pk)
self.assertContains(response, "MDA", status_code=200)
self.assertContains(response, "Mtendere", 1, status_code=200)
self.assertContains(response, "Lusaka", 1, status_code=200)
# test uri
self.assertEqual(
reverse("mda:location", kwargs={"location": location.pk}),
"/mda/{}".format(location.pk),
)
# test targeted
health_facility = Location.objects.filter(level="RHC").first()
health_facility.target = False
health_facility.save()
response = view(request, location=location.pk)
self.assertContains(response, health_facility.name, 0, 200)
# check catchment view - 404 when not targeted
with self.assertRaises(Http404):
response = view(request, location=health_facility.pk)
def test_create_mobilisation_visit(self):
"""Test create_mobilisation_visit() function."""
data_setup()
mobilisation_visit = create_mobilisation_visit(MOBILISATION_VISIT_DATA)
self.assertIsInstance(mobilisation_visit, Mobilisation)
self.assertTrue(mobilisation_visit.is_mobilised)
self.assertTrue(mobilisation_visit.spray_area.is_mobilised)
def test_spray_area_view(self):
"""Test SprayAreaView"""
data_setup()
factory = RequestFactory()
request = factory.get("/mda")
view = SprayAreaView.as_view()
response = view(request)
self.assertContains(response, "All Eligible Areas", status_code=200)
self.assertContains(response, "Lusaka", 2, status_code=200)
self.assertContains(response, "Mtendere", 2, status_code=200)
self.assertContains(response, "Akros_1", 1, status_code=200)
self.assertContains(response, "Akros_2", 1, status_code=200)
# test uri
self.assertEqual(reverse("mda:index"), "/mda/")
# test targeted
akros_1 = Location.objects.get(name="Akros_1")
akros_1.target = False
akros_1.save()
response = view(request)
self.assertContains(response, "Akros_1", 0, status_code=200)
# test CSV
response = view(request, **{"format": "csv"})
self.assertContains(response, "Akros_2,", 1, status_code=200)
self.assertEqual(response["Content-Type"], "text/csv")
self.assertEqual(
response["Content-Disposition"],
'attachment; filename="sprayareas.csv"',
)
def test_mobilisation(self):
"""Test processing a mobilisation visit via MobilisationView."""
data_setup()
sprayarea = Location.objects.get(name='Akros_1')
factory = RequestFactory()
view = TargetAreaView.as_view()
# Test mobilizatiion has not been mobilised
request = factory.get("/2/3")
response = view(
request,
district_pk=sprayarea.parent_id, slug=sprayarea.id)
self.assertContains(
response,
'Mobilised? \
<i class="fa fa-times" style="color: red"></i>',
html=True)
# mobilize the location
sprayarea.is_mobilised = True
sprayarea.save()
# Test the location is mobilised
response = view(
request, district_pk=sprayarea.parent_id,
slug=sprayarea.id)
self.assertContains(
response,
'Mobilised? \
<i class="fa fa-check-circle" style="color: green"></i>',
html=True)
def test_daily_spray_effectiveness(self, mocked_start_flow):
"""Test daily_spray_effectiveness calls rapidpro"""
data_setup()
load_spray_data()
daily_spray_effectiveness("flow_uuid", '2018-09-20')
self.assertTrue(mocked_start_flow.called)
self.assertEqual(mocked_start_flow.call_count, 1)
def test_create_decision_visit(self):
"""Test create_decision_visit() function"""
data_setup()
decision_visit = create_decision_visit(DECISION_VISIT_DATA)
self.assertIsInstance(decision_visit, Decision)
self.assertEqual(decision_visit.spray_area.last_decision_date,
decision_visit.today)
def test_sprayable(self):
"""Test sprayable."""
data_setup()
load_spray_data()
self.assertEqual(Household.objects.filter(sprayable=False).count(), 4)
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.not_sprayable, 4)
def test_create_sensitization_visit(self):
"""Test create_sensitization_visit() function"""
data_setup()
sensitization_visit = create_sensitization_visit(
SENSITIZATION_VISIT_DATA)
self.assertIsInstance(sensitization_visit, SensitizationVisit)
self.assertTrue(sensitization_visit.is_sensitized)
self.assertTrue(sensitization_visit.spray_area.is_sensitized)
def test_population_treatment(self):
"""Test population_treatment."""
data_setup()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.population_treatment, 0)
load_mda_data()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.population_treatment, 1)
def test_mda_visited_sprayed(self):
"""Test MDA location.visited_sprayed."""
data_setup()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.visited_sprayed, 0)
load_mda_data()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.visited_sprayed, 3)
def test_mda_found(self):
"""Test mda_found."""
data_setup()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.mda_found, 0)
load_mda_data()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.mda_found, 4)
def test_sensitisaion_no_osm(self):
"""Test processing a sensitization visit with no OSM.
"""
data_setup()
sensitization_visit = create_sensitization_visit(
SENSITIZATION_VISIT_DATA_NO_OSM)
self.assertIsInstance(sensitization_visit, SensitizationVisit)
self.assertFalse(sensitization_visit.is_sensitized)
self.assertFalse(sensitization_visit.spray_area.is_sensitized)
def test_last_decision_date(self):
"""Test last_decision_date"""
data_setup()
load_spray_data()
decision_visit = create_decision_visit(DECISION_VISIT_DATA)
self.assertIsInstance(decision_visit, Decision)
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.last_visit, datetime.date(2018, 9, 20))
self.assertEqual(akros_2.last_decision_date, "2018-09-25")
def test_se_serializer(self):
"""Test SprayEffectivenessSerializer"""
data_setup()
load_spray_data()
locations = Location.objects.filter(code="2")
serializer = SprayEffectivenessSerializer(locations, many=True)
data = serializer.data[0]
self.assertEqual(data["spray_effectiveness"], 62)
self.assertEqual(data["district"], "1")
self.assertEqual(data["spray_area"], "Akros_2")
def test_add_spray_data_by_osmid(self):
"""Test spray data is linked by osmid"""
data_setup()
path = os.path.join(FIXTURES_DIR, "spray_data.json")
with codecs.open(path, encoding="utf-8") as spray_data_file:
data = json.load(spray_data_file)[0]
spray = add_spray_data(data)
self.assertTrue(spray.location is not None)
self.assertTrue(spray.household is not None)
self.assertTrue(spray.household.visited)
def test_mda_district_performance(self):
"""Test district performance view.
This is done by confirming the data received in the response
context is being aggregated appropriately within the view
"""
# first we load our test data
data_setup()
self._load_fixtures()
rhc = Location.objects.get(name="Zemba")
district = rhc.parent
spray_operator = SprayOperator.objects.first()
team_leader = TeamLeader.objects.first()
spray_operator.team_leader = team_leader
spray_operator.rhc = rhc
spray_operator.district = rhc.parent
spray_operator.save()
# next we identify a SprayDay object for the spray operator
spray_day = SprayDay.objects.filter(spray_operator=spray_operator)
spray_day.update(sprayable=True)
# Create performance report objects from the submissions made
# by the particular sprayoperator.
performance_report(spray_operator)
report1 = PerformanceReport.objects.get(spray_operator=spray_operator)
report1.found = 7
report1.reported_sprayed = 16
report1.reported_found = 22
report1.district = district
report1.save()
report2 = PerformanceReport.objects.get(spray_operator=spray_operator)
report2.id = None
report2.sprayformid = 7658
report2.refused = 6
report2.found = 12
report2.reported_sprayed = 6
report1.district = district
report2.save()
factory = RequestFactory()
request = factory.get("/")
view = MDADistrictPerfomanceView.as_view()
response = view(request)
self.assertEqual(response.status_code, 200)
# Query obtains all data for the SprayOperator
# including submissions made and passes this to the serializer
queryset = Location.performance_queryset('sop_district', None)
serializer = MDADistrictPerformanceReportSerializer(queryset,
many=True)
self.assertEqual(response.context_data["data"], serializer.data)
def test_fetch_sensitization_visits(self, fetch_form_data):
"""Test fetching sensitization visit submissions."""
data_setup()
fetch_form_data.side_effect = [
[{"_id": 343725}],
SENSITIZATION_VISIT_DATA,
]
count = SensitizationVisit.objects.count()
with self.settings(SENSITIZATION_VISIT_FORM_ID=343725):
fetch_sensitization_visits()
self.assertEqual(SensitizationVisit.objects.count(), count + 1)
def test_fetch_mobilisation(self, fetch_form_data):
"""Test fetching mobilisation submissions."""
data_setup()
fetch_form_data.side_effect = [
[{"_id": 343725}],
MOBILISATION_VISIT_DATA,
]
count = Mobilisation.objects.count()
with self.settings(MOBILISATION_FORM_ID=343725):
fetch_mobilisation()
self.assertEqual(Mobilisation.objects.count(), count + 1)
def test_spray_areas_to_mopup(self):
"""Test calculating number of spray_areas that need mopup."""
data_setup()
self.assertEqual(
Location.objects.get(name="Lusaka",
level="district").spray_areas_to_mopup, 0)
load_spray_data()
self.assertEqual(
Location.objects.get(name="Lusaka",
level="district").spray_areas_to_mopup, 1)
def test_create_decision(self):
"""Test processing a decision visit via DecisionView.
"""
data_setup()
data = DECISION_VISIT_DATA
factory = RequestFactory()
view = DecisionView.as_view()
request = factory.post("/decision", data)
response = view(request)
self.assertEqual(response.status_code, 201)
visit = Decision.objects.get(submission_id=data["_id"])
self.assertTrue(visit.today is not None)
def test_health_facility_map(self):
"""Test the health facility map visualization."""
data_setup()
factory = RequestFactory()
health_facility = Location.objects.get(name='Mtendere')
view = TargetAreaView.as_view()
request = factory.get("/2/3")
response = view(
request,
district_pk=health_facility.parent_id,
slug=health_facility.id)
self.assertEqual(response.status_code, 200)
def test_link_mobilisation_visit_via_spatial_query(self):
"""Test create_mobilisation_visit() function."""
data_setup()
gps_data = MOBILISATION_VISIT_DATA.copy()
self.assertEqual(gps_data['spray_area'], '01_1')
gps_data["osmstructure:way:id"] = 525683350
gps_data['osmstructure:ctr:lat'] = -15.418780034209806
gps_data['osmstructure:ctr:lon'] = 28.35196267147328
mobilisation = create_mobilisation_visit(gps_data)
self.assertIsNotNone(mobilisation.spray_area)
self.assertIsInstance(mobilisation, Mobilisation)
self.assertEqual(mobilisation.spray_area.name, 'Akros_1')
def test_create_mobilisation(self):
"""Test processing a mobilisation visit via MobilisationView."""
data_setup()
data = MOBILISATION_VISIT_DATA
factory = RequestFactory()
view = MobilisationView.as_view()
request = factory.post("/mobilisation", data)
response = view(request)
self.assertEqual(response.status_code, 201)
visit = Mobilisation.objects.get(submission_id=data["_id"])
self.assertTrue(visit.is_mobilised)
response = view(request)
self.assertEqual(response.status_code, 202)
def test_structures_to_mopup(self):
"""Test calculating number of structures that need mopup."""
data_setup()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
self.assertEqual(akros_2.structures_to_mopup, 12)
load_spray_data()
akros_2.refresh_from_db()
akros_2 = Location.objects.get(name="Akros_2", level="ta")
# 90th percentile is 8 , sprayed is 5, difference is 3
self.assertEqual(akros_2.structures_to_mopup, 3)
lusaka = Location.objects.get(name="Lusaka", level="district")
self.assertEqual(lusaka.structures_to_mopup, 3)
def test_command(self):
"""Test load_locations_priority sets priority in the location."""
data_setup()
location = Location.objects.get(name="Akros_1")
self.assertIsNone(location.priority)
location = Location.objects.get(name="Akros_2")
self.assertIsNone(location.priority)
path = os.path.join(FIXTURES_DIR, "Lusaka", "priority.csv")
call_command("load_locations_priority", path)
location = Location.objects.get(name="Akros_1")
self.assertEqual(location.priority, 1)
location = Location.objects.get(name="Akros_2")
self.assertEqual(location.priority, 2)
def test_link_mobilisation_via_spray_area(self):
"""Test create_mobilisation_visit() function."""
data_setup()
gps_data = MOBILISATION_VISIT_DATA.copy()
self.assertEqual(gps_data['spray_area'], '01_1')
gps_data["osmstructure:way:id"] = 528516754
gps_data['osmstructure:ctr:lat'] = None
gps_data['osmstructure:ctr:lon'] = None
gps_data['spray_area'] = 'Akros_1'
mobilisation = create_mobilisation_visit(gps_data)
self.assertEqual(mobilisation.spray_area.name, 'Akros_1')
self.assertIsNotNone(mobilisation.spray_area)
self.assertIsInstance(mobilisation, Mobilisation)
def test_mopup_view(self):
"""Test mop-up view"""
data_setup()
factory = RequestFactory()
request = factory.get("/mop-up")
view = MopUpView.as_view()
response = view(request)
self.assertContains(response, "Mop-up", status_code=200)
self.assertContains(response, "Lusaka", 1, status_code=200)
# test targeted
lusaka = Location.objects.get(name="Lusaka")
lusaka.target = False
lusaka.save()
response = view(request)
self.assertContains(response, "Lusaka", 0, status_code=200)
def test_health_facility_mopup_view(self):
"""Test HealthFacilityMopUpView"""
data_setup()
load_spray_data()
health_facility = Location.objects.filter(level="RHC").first()
spray_area = health_facility.get_children().filter(
name='Akros_2').first()
factory = RequestFactory()
request = factory.get("/mopup-up/{}".format(health_facility.parent_id))
view = HealthFacilityMopUpView.as_view()
response = view(request, district=health_facility.parent_id)
self.assertDictEqual(
{
'structures_on_ground': 9,
'visited_sprayed': 5,
'structures_to_mopup': 3,
'mopup_days_needed': 0.022222222222222223
},
response.context_data['totals']
)
self.assertContains(response, health_facility.name, 1, 200)
self.assertContains(response, spray_area.name, 1, 200)
self.assertEqual(
reverse("mop-up", kwargs={"district": health_facility.parent_id}),
"/mop-up/{}".format(health_facility.parent_id),
)
# test targeted
spray_area.target = False
spray_area.save()
view = HealthFacilityMopUpView.as_view()
response = view(request, district=health_facility.parent_id)
self.assertContains(response, health_facility.name, 0, 200)
self.assertContains(response, spray_area.name, 0, 200)
self.assertDictEqual({
'structures_on_ground': 0,
'visited_sprayed': 0,
'structures_to_mopup': 0,
'mopup_days_needed': 0
}, response.context_data['totals'])
def test_mda_view(self):
"""Test MDAView"""
data_setup()
factory = RequestFactory()
request = factory.get("/mda")
view = MDAView.as_view()
response = view(request)
self.assertContains(response, "MDA", status_code=200)
self.assertContains(response, "Lusaka", 1, status_code=200)
# test uri
self.assertEqual(reverse("mda:index"), "/mda/")
# test targeted
lusaka = Location.objects.get(name="Lusaka")
lusaka.target = False
lusaka.save()
response = view(request)
self.assertContains(response, "Lusaka", 0, status_code=200)
