def test_latest_query(self):
""" Test the latest query"""
db_util.insert_cases(self.db_session, "latest_test")
start_date = datetime(2017, 1, 1)
end_date = datetime(2017, 1, 12)
result = data_query.latest_query(self.db, "test_2", "test_1", start_date,
end_date, 1)
self.assertEqual(result["total"], 7)
self.assertEqual(result["clinic"][7], 7)
self.assertEqual(result["clinic"][8], 0)
self.assertEqual(result["district"][4], 7)
self.assertEqual(result["region"][2], 7)
start_date = datetime(2017, 1, 1)
end_date = datetime(2017, 1, 8) # Exclude the last record
result = data_query.latest_query(self.db, "test_2", "test_1", start_date,
end_date, 1)
self.assertEqual(result["total"], 12)
self.assertEqual(result["clinic"][7], 7)
self.assertEqual(result["clinic"][8], 5)
self.assertEqual(result["district"][4], 12)
self.assertEqual(result["region"][2], 12)
start_date = datetime(2017, 1, 1)
end_date = datetime(2017, 1, 12)
result = data_query.latest_query(self.db, "test_2", "test_1", start_date,
end_date, 1, weeks=True)
self.assertEqual(result["total"], 12)
self.assertEqual(result["weeks"][1], 12)
self.assertEqual(result["weeks"][2], 0)
self.assertEqual(result["clinic"][7]["weeks"][1], 7)
self.assertEqual(result["clinic"][8]["weeks"][1], 5)
self.assertEqual(result["clinic"][8]["weeks"][2], 0)
self.assertEqual(result["district"][4]["total"], 12)
self.assertEqual(result["region"][2]["total"], 12)
def setUp(self):
"""Setup for testing"""
self._mock_epi_week_abacus_logic()
db_util.insert_codes(self.db_session)
db_util.insert_locations(self.db_session)
db_util.insert_cases(self.db_session, "public_health_report")
pseudo_db = namedtuple("pseudo_db", ["session", "engine"])
self.db = pseudo_db(session=self.db_session, engine=db_util.engine)
def setUp(self):
"""Setup for testing"""
meerkat_api.app.config['TESTING'] = True
meerkat_api.app.config['API_KEY'] = ""
self.app = meerkat_api.app.test_client()
self.db = db_util.session
db_util.insert_codes(self.db)
db_util.insert_locations(self.db)
db_util.insert_cases(self.db, "alerts")
def setUp(self):
"""Setup for testing"""
meerkat_api.app.config['TESTING'] = True
meerkat_api.app.config['API_KEY'] = "should-work-even-with-api-key"
self.app = meerkat_api.app.test_client()
session = db_util.session
db_util.insert_codes(session)
db_util.insert_locations(session)
db_util.insert_cases(session, "frontpage", "2016-07-02")
self.session = session
def setUp(self):
"""Setup for testing"""
meerkat_api.app.config['TESTING'] = True
meerkat_api.app.config['API_KEY'] = ""
self.app = meerkat_api.app.test_client()
session = db_util.session
db_util.insert_codes(session)
db_util.insert_locations(session)
db_util.insert_cases(session, "map_test", date="2016-07-02")
def test_non_reporting(self):
"""Check non_reporting"""
db_util.insert_cases(self.db_session, "completeness", "2016-07-02")
rv = self.app.get('/non_reporting/reg_1/1', headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [10, 11])
rv = self.app.get('/non_reporting/reg_2/1', headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [7, 8, 10, 11])
rv = self.app.get('/non_reporting/reg_1/2', headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [10])
rv = self.app.get('/non_reporting/reg_1/4', headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [])
rv = self.app.get('/non_reporting/reg_1/6', headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [11])
# Test with include/exclude
rv = self.app.get('/non_reporting/reg_1/1/0/foreigner',
headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [11])
rv = self.app.get('/non_reporting/reg_1/1/0/foreigner,mh',
headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [])
rv = self.app.get('/non_reporting/reg_1/1/0/0/foreigner',
headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [10])
rv = self.app.get('/non_reporting/reg_1/1/0/0/foreigner,mh',
headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [10, 11])
rv = self.app.get('/non_reporting/reg_2/1/0/0/0/Refugee/0',
headers=settings.header)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 200)
self.assertEqual(sorted(data["clinics"]), [7, 11])
def test_get_variable_count_for_device_id(self):
db_util.insert_cases(self.db_session, "public_health_report")
device_id = "1"
variable_id = "gen_1"
actual = DeviceResourceBase._get_variable_count_for_deivce_id(
device_id, variable_id, [])
expected = {
'deviceId': device_id,
'variable': variable_id,
'submissionsCount': 3
}
self.assertEqual(expected, actual)
def test_refugee_page(self):
""" test the refugee page """
db_util.insert_cases(self.session, "refugee_data")
rv = self.app.get('/refugee_page')
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
data = sorted(data, key=lambda k: k["location_id"])
self.assertEqual(data[0]["location_id"], 7)
self.assertEqual(data[0]["value"], 12)
self.assertEqual(data[1]["location_id"], 11)
self.assertEqual(data[1]["value"], 77)
def _prepare_week_level(self, mock_authenticate, mock_request):
self.session.query(model.Data).delete()
self.session.commit()
db_util.insert_cases(self.session, "completeness")
mock_authenticate.return_value = 'meerkatjwt'
date = datetime.datetime.today()
start_date = datetime.datetime(date.year, 1, 1)
end_date = datetime.datetime(date.year, 12, 31)
rv = self.app.get(
'/completeness/reg_1/1/4/1/5,6/reg_1/{}?sublevel=clinic'.format(
end_date.isoformat()),
headers={**settings.header})
result_mock = MagicMock()
result_mock.json = MagicMock(
return_value=json.loads(rv.data.decode("utf-8")))
mock_request.return_value = result_mock
return date, start_date, end_date
def setUp(self):
"""Setup for testing"""
meerkat_api.app.config['TESTING'] = True
meerkat_api.app.config['API_KEY'] = ""
celery_app.conf.CELERY_ALWAYS_EAGER = True
self.app = meerkat_api.app.test_client()
self.session = db_util.session
for table in model.form_tables():
self.session.query(model.form_tables()[table]).delete()
self.session.query(model.Locations).delete()
self.session.commit()
db_util.insert_codes(self.session)
db_util.insert_locations(self.session)
db_util.insert_cases(self.session, "public_health_report")
current_directory = os.path.dirname(__file__)
form_data = []
for d in util.read_csv(current_directory + "/test_data/" +
"demo_case.csv"):
form_data.append(d)
data_import.add_rows_to_db(
"demo_case",
form_data,
db_util.session,
db_util.engine,
deviceids=["1", "2", "3", "4", "5", "6"],
)
dr_name = config.country_config["tables"][1]
form_data = []
for d in util.read_csv(current_directory + "/test_data/" +
"demo_alert.csv"):
form_data.append(d)
data_import.add_rows_to_db("demo_alert",
form_data,
db_util.session,
db_util.engine,
deviceids=["1", "2", "3", "4", "5", "6"])
def test_completness(self):
"""Test completeness"""
db_util.insert_cases(self.db_session, "completeness", "2016-07-02")
rv = self.app.get('completeness/reg_1/1/5', headers=settings.header)
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(sorted(data.keys()), [
"clinic_score", "clinic_yearly_score", "dates_not_reported",
"score", "timeline", "yearly_score"
])
self.assertEqual(data["score"]["1"], 4 / 10 * 100)
self.assertAlmostEqual(data["score"]["2"], 4 / 10 * 100)
self.assertEqual(data["clinic_score"]["7"], 60)
self.assertEqual(data["clinic_score"]["8"], 20)
today = date.today()
today = datetime(today.year, today.month, today.day)
freq = "W-FRI"
epi_year_weekday = 4
start = datetime(today.year, 1, 1)
offset = today.weekday() - epi_year_weekday
if offset < 0:
offset = 7 + offset
end = today - timedelta(days=offset + 1)
dates = pd.date_range(start, end, freq=freq)
dates_iso = [d.isoformat() for d in dates.to_pydatetime()]
self.assertEqual(data["timeline"]["1"]["weeks"], dates_iso)
self.assertEqual(data["timeline"]["1"]["values"][-1], 2)
self.assertEqual(data["timeline"]["1"]["values"][-2], 0.5)
self.assertAlmostEqual(data["timeline"]["2"]["values"][-1], 4 / 2)
self.assertAlmostEqual(data["timeline"]["2"]["values"][-2], 1 / 2)
rv = self.app.get('completeness/reg_1/4/5', headers=settings.header)
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(data["score"]["4"], 4 / 10 * 100)
self.assertAlmostEqual(data["score"]["7"], 60)
self.assertEqual(data["score"]["8"], 20)
self.assertEqual(data["timeline"]["4"]["values"][-1], 2)
self.assertEqual(data["timeline"]["4"]["values"][-2], 0.5)
self.assertAlmostEqual(data["timeline"]["7"]["values"][-1], 3)
self.assertAlmostEqual(data["timeline"]["7"]["values"][-2], 1)
self.assertAlmostEqual(data["timeline"]["8"]["values"][-1], 1)
self.assertAlmostEqual(data["timeline"]["8"]["values"][-2], 0)
start2 = datetime(today.year, 2, 1)
dates2 = pd.date_range(start2, end, freq=freq)
dates_iso2 = [d.isoformat() for d in dates2.to_pydatetime()]
self.assertEqual(data["timeline"]["7"]["weeks"], dates_iso2)
rv = self.app.get('completeness/reg_1/7/5', headers=settings.header)
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(data["clinic_score"], {})
self.assertAlmostEqual(data["score"]["7"], 60)
self.assertAlmostEqual(data["timeline"]["7"]["values"][-1], 3)
self.assertAlmostEqual(data["timeline"]["7"]["values"][-2], 1)
offset = today.weekday() - start.weekday()
if offset < 0:
offset = 7 + offset
record_dates = []
for i in [1, 2, 3, 8]:
record_dates.append(today - timedelta(days=i + offset))
dates_to_check = pd.date_range(start2, end, freq="D")
for d in dates_to_check.to_pydatetime():
if d.weekday() not in [5, 6] and d not in record_dates:
self.assertIn(d.isoformat(), data["dates_not_reported"])
rv = self.app.get('completeness/reg_1/7/5/1/uff/4,5',
headers=settings.header)
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
for d in dates_to_check.to_pydatetime():
if d.weekday() not in [4, 5] and d not in record_dates:
self.assertIn(d.isoformat(), data["dates_not_reported"])
# Test with exclude and include_case_types
rv = self.app.get('completeness/reg_1/1/5?inc_case_types=["mh"]',
headers=settings.header)
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(data["score"]["1"], 3 / 5 * 100)
self.assertNotIn("8", data["clinic_score"])
self.assertIn("7", data["clinic_score"])
self.assertEqual(data["clinic_score"]["7"], 60)
rv = self.app.get('completeness/reg_1/1/5?exc_case_types=["mh"]',
headers=settings.header)
self.assertEqual(rv.status_code, 200)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(data["score"]["1"], 1 / 5 * 100)
self.assertNotIn("7", data["clinic_score"])
self.assertIn("8", data["clinic_score"])
self.assertEqual(data["clinic_score"]["8"], 20)
def setUp(self):
"""Setup for testing"""
self._mock_epi_week_abacus_logic()
db_util.insert_codes(self.db_session)
db_util.insert_locations(self.db_session)
db_util.insert_cases(self.db_session, "public_health_report")
def setUp(self):
"""Setup for testing"""
celery_app.conf.CELERY_ALWAYS_EAGER = True
db_util.insert_calculation_parameters(self.db_session)
db_util.insert_codes(self.db_session)
db_util.insert_locations(self.db_session)
db_util.insert_cases(self.db_session, "public_health_report",
delete=True)
db_util.insert_cases(self.db_session,
"ncd_public_health_report", delete=False)
db_util.insert_cases(self.db_session, "ncd_report",
delete=False)
db_util.insert_cases(self.db_session, "pip_report",
delete=False)
db_util.insert_cases(self.db_session, "refugee_data",
delete=False)
db_util.insert_cases(self.db_session, "frontpage", delete=False)
db_util.insert_cases(self.db_session, "map_test", delete=False)
db_util.insert_cases(self.db_session, "epi_monitoring",
delete=False)
db_util.insert_cases(self.db_session, "malaria", delete=False)
db_util.insert_cases(self.db_session, "alerts", delete=False)
db_util.insert_cases(self.db_session, "cd_report", delete=False)
db_util.insert_cases(self.db_session, "vaccination_report",
delete=False)
db_util.insert_cases(self.db_session, "completeness",
delete=False)
db_util.insert_cases(self.db_session, "oms_report",
delete=False)
db_util.insert_cases(self.db_session, "mental_health",
delete=False)
self.locations = {1: {"name": "Demo"}}
self.variables = {1: {"name": "Total"}}
def setUp(self):
db_util.insert_cases(self.db_session, "public_health_report")