def test_get_scores_resolution(self):
flumodel = FluModel()
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = '1.23'
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
with self.app.app_context():
flumodel.save()
model_function.save()
response = self.client().get(
'/scores?id=1&startDate=2018-05-30&endDate=2018-06-30&resolution=week'
)
result = response.get_json()
self.assertEqual(len(result['model_data'][0]['data_points']), 4)
def test_no_missing_google_range(self):
"""
Scenario: Test run function to calculate model score for 2 consecutive dates
Given requested Google dates already exist for such dates
And the model score exist for one date
Then the model score for the missing date is stored
"""
with self.app.app_context():
google_date_1 = GoogleDate(1, date(2018, 1, 1))
google_date_1.save()
google_date_2 = GoogleDate(1, date(2018, 1, 2))
google_date_2.save()
model_function = ModelFunction()
model_function.flu_model_id = 1
model_function.function_name = 'matlab_function'
model_function.average_window_size = 1
model_function.has_confidence_interval = False
model_function.save()
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date(2018, 1, 1)
model_score.score_value = 0.5
model_score.region = 'e'
model_score.save()
with patch.multiple('scheduler.score_calculator',
build_calculator=DEFAULT) as mock_dict:
matlab_client = mock_dict[
'build_calculator'].return_value = Mock()
matlab_client.calculate_model_score.return_value = 1.0
result_before = ModelScore.query.filter_by(
flu_model_id=1).all()
self.assertListEqual(result_before, [model_score])
score_calculator.run(1, date(2018, 1, 1), date(2018, 1, 2))
result_after = ModelScore.query.filter_by(flu_model_id=1).all()
self.assertEqual(len(result_after), 2)
def test_get_flu_model_for_model_id_and_dates(self):
"""
Scenario: Get model data and scores for model_id and dates
"""
with self.app.app_context():
flu_model = FluModel()
flu_model.id = 1
flu_model.is_displayed = True
flu_model.is_public = True
flu_model.calculation_parameters = ''
flu_model.name = 'Model 1'
flu_model.source_type = 'google'
flu_model.save()
model_function = ModelFunction()
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
model_function.function_name = 'Function name'
model_function.average_window_size = 7
model_function.save()
for i in range(1, 32):
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date(2018, 1, i)
model_score.score_value = i / (10 + i)
model_score.region = 'e'
model_score.save()
result = get_flu_model_for_model_id_and_dates(
1, date(2018, 1, 2), date(2018, 1, 31))
self.assertEqual(result[0]['average_score'], 0.5723146873461765)
self.assertEqual(result[0]['start_date'], date(2018, 1, 2))
self.assertEqual(result[0]['end_date'], date(2018, 1, 31))
self.assertEqual(result[0]['name'], 'Model 1')
self.assertEqual(result[0]['has_confidence_interval'], True)
self.assertEqual(result[0]['id'], 1)
self.assertEqual(len(result[1]), 30)
def test_runsched_fetch_google_scores(self, mock_verify, mock_client):
"""
Evaluate parameters passed to fetch_google_scores and set_and_verify_google_dates
functions in _run_sched_for_model_no_set_dates
"""
last_date = date.today() - timedelta(days=4)
end_date = date.today() - timedelta(days=3)
with self.app.app_context():
google_date = GoogleDate(1, last_date)
google_date.save()
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = end_date
model_score.score_value = 0.5
model_score.region = 'e'
model_score.save()
google_term = GoogleTerm()
google_term.id = 1
google_term.term = 'Term 1'
google_term.save()
flu_model_google_term = FluModelGoogleTerm()
flu_model_google_term.flu_model_id = 1
flu_model_google_term.google_term_id = 1
flu_model_google_term.save()
patched_api_client = mock_client.return_value
score_calculator.runsched([1], self.app)
patched_api_client.fetch_google_scores.assert_called_with(
['Term 1'], last_date, end_date)
mock_verify.assert_called_with(1, [end_date])
def test_run_model(self):
"""
Given FluModel can be found
Then Scheduler executes run_model for that particular FluModel id
"""
flumodel = FluModel()
flumodel.id = 1
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
datapoint = ModelScore()
datapoint.region = 'e'
datapoint.score_date = date(2018, 6, 29)
datapoint.calculation_timestamp = datetime.now()
datapoint.score_value = '1.23'
flumodel.model_scores = [datapoint]
with self.app.app_context():
flumodel.save()
with patch.object(Scheduler, '__init__', return_value=None):
scheduler = Scheduler()
scheduler.flask_app = self.app
from apscheduler.schedulers.background import BackgroundScheduler
scheduler.scheduler = BackgroundScheduler()
scheduler.run_model([flumodel.id], "* * * * *")
def test_get_rool(self):
flumodel = FluModel()
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
datapoint = ModelScore()
datapoint.region = 'e'
datapoint.score_date = date(2018, 6, 29)
datapoint.calculation_timestamp = datetime.now()
datapoint.score_value = 1.23
datapoint.confidence_interval_lower = 0.81
datapoint.confidence_interval_upper = 1.65
flumodel.model_scores = [datapoint]
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
default_model = DefaultFluModel()
default_model.flu_model_id = 1
with self.app.app_context():
flumodel.save()
model_function.save()
DB.session.add(default_model)
DB.session.commit()
response = self.client().get('/')
result = response.get_json()
expected = {
'model_list': [{
'id': 1,
'name': 'Test Model'
}],
'rate_thresholds': {},
'model_data': [{
'id':
1,
'name':
'Test Model',
'average_score':
1.23,
'start_date':
'2018-06-29',
'end_date':
'2018-06-29',
'has_confidence_interval':
True,
'data_points': [{
'score_date': '2018-06-29',
'score_value': 1.23,
'confidence_interval_lower': 0.81,
'confidence_interval_upper': 1.65
}]
}]
}
self.assertEqual(result, expected)
self.assertEqual(response.status_code, 200)
def set_model_score(model_id: int, score_date: date, score_value: float):
""" Persists a model score entity """
model_score = ModelScore()
model_score.flu_model_id = model_id
model_score.region = 'e' # Default for Google data
model_score.score_date = score_date
model_score.score_value = score_value
model_score.save()
def test_get_scores_for_model(self):
flumodel = FluModel()
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 3, 20), date(2018, 5, 20), date(2018, 6, 20)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = '1.23'
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = False
with self.app.app_context():
flumodel.save()
model_function.save()
response = self.client().get(
'/scores?id=1&startDate=2018-05-30&endDate=2018-06-30')
result = response.get_json()
expected = {
'model_data': [{
'id':
1,
'name':
'Test Model',
'average_score':
1.23,
'has_confidence_interval':
False,
'start_date':
'2018-06-20',
'end_date':
'2018-06-20',
'data_points': [{
'score_date': '2018-06-20',
'score_value': 1.23,
'confidence_interval_lower': None,
'confidence_interval_upper': None
}]
}]
}
self.assertEqual(result, expected)
self.assertEqual(response.status_code, 200)
response = self.client().get(
'/scores?id=1&startDate=2018-07-30&endDate=2018-06-30')
self.assertEqual(response.status_code, 400)
def test_get_scores_smoothing(self):
flumodel = FluModel()
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1 + 10 / d.day
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
with self.app.app_context():
flumodel.save()
model_function.save()
response = self.client().get(
'/scores?id=1&startDate=2018-06-10&endDate=2018-06-10&smoothing=3')
result = response.get_json()
expected = {
'model_data': [{
'id':
1,
'name':
'Test Model',
'data_points': [{
'score_value': 2.0067340067340065,
'score_date': '2018-06-10',
'confidence_interval_lower': 0.0, # should be None
'confidence_interval_upper': 0.0 # should be None
}],
'has_confidence_interval':
True,
'start_date':
'2018-06-10',
'end_date':
'2018-06-10',
'average_score':
2.0
}]
}
self.assertEqual(result, expected)
def set_model_score_confidence_interval(
model_id: int,
score_date: date,
score_value: float,
confidence_interval: Tuple[float, float]
):
""" Persists a model score entity including its confidence interval """
model_score = ModelScore()
model_score.flu_model_id = model_id
model_score.region = 'e' # Default for Google data
model_score.score_date = score_date
model_score.score_value = score_value
model_score.confidence_interval_lower = confidence_interval[0]
model_score.confidence_interval_upper = confidence_interval[1]
model_score.save()
def test_get_existing_model_dates(self):
"""
Scenario: Get list of existing dates from ModelScore
Given a ModelScore.flu_model_id value of 1 exists
And ModelScore.score_date with values '2018-01-02', '2018-01-03', '2018-01-05'
When model_id = 1, start = '2018-01-01', end = '2018-01-02'
Then the list contains one tuple for date '2018-01-02'
"""
with self.app.app_context():
for day in (2, 3, 5):
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date(2018, 1, day)
model_score.score_value = 0.1 + day
model_score.region = 'e'
model_score.save()
result = get_existing_model_dates(1, date(2018, 1, 1),
date(2018, 1, 2))
self.assertListEqual(result, [(date(2018, 1, 2), )])
def test_runsched(self):
"""
Scenario: Test runsched function to calculate model scores
Given a last score_date of date.today() - timedelta(days=5)
Then score_calculator.run is called with a start date of date.today() - timedelta(days=3)
And end date of date.today() - timedelta(days=4)
"""
with self.app.app_context():
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date.today() - timedelta(days=5)
model_score.score_value = 0.5
model_score.region = 'e'
model_score.save()
with patch(
'scheduler.score_calculator._run_sched_for_model_no_set_dates'
) as patched_run:
score_calculator.runsched([1], self.app)
patched_run.assert_called_with(1)
def test_runsched_get_google_batch(self):
"""
Evaluate parameters passed to get_google_batch function in
_run_sched_for_model_no_set_dates
"""
last_date = date.today() - timedelta(days=4)
end_date = date.today() - timedelta(days=3)
with self.app.app_context():
google_date = GoogleDate(1, last_date)
google_date.save()
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = end_date
model_score.score_value = 0.5
model_score.region = 'e'
model_score.save()
with patch('scheduler.score_calculator.get_google_batch'
) as patched_call:
patched_call.return_value = []
score_calculator.runsched([1], self.app)
patched_call.assert_called_with(1, [(end_date, end_date)])
def test_build_scores_response(self):
data_points = [{
'score_date': '2019-01-01',
'score_value': 0.2,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}, {
'score_date': '2019-01-02',
'score_value': 0.4,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}]
model_data = [{
'id': 1,
'name': 'Test Model',
'start_date': '2019-01-01',
'end_date': '2019-01-02',
'average_score': 0.3,
'has_confidence_interval': True,
'data_points': data_points
}]
expected = {'model_data': model_data}
flu_model_score_1, flu_model_score_2 = ModelScore(), ModelScore()
flu_model_score_1.score_date, flu_model_score_2.score_date = date(
2019, 1, 1), date(2019, 1, 2)
flu_model_score_1.score_value, flu_model_score_2.score_value = 0.2, 0.4
flu_model_score_1.confidence_interval_lower, flu_model_score_2.confidence_interval_lower = 0.1, 0.1
flu_model_score_1.confidence_interval_upper, flu_model_score_2.confidence_interval_upper = 0.5, 0.5
flu_model_data = [({
'id': 1,
'name': 'Test Model',
'start_date': date(2019, 1, 1),
'end_date': date(2019, 1, 2),
'has_confidence_interval': True,
'average_score': 0.3
}, [flu_model_score_1, flu_model_score_2])]
result = build_scores_response(flu_model_data)
self.assertDictEqual(result, expected)
def test_runsched_google_scores_get_date_ranges(self):
"""
Evaluate parameters passed to get_date_ranges_google_score function within
_run_sched_for_model_no_set_dates
"""
last_date = date.today() - timedelta(days=4)
with self.app.app_context():
google_date = GoogleDate(1, last_date)
google_date.save()
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date.today() - timedelta(days=3)
model_score.score_value = 0.5
model_score.region = 'e'
model_score.save()
with patch(
'scheduler.score_calculator.get_date_ranges_google_score'
) as patched_call:
patched_call.return_value = (None, None)
score_calculator.runsched([1], self.app)
patched_call.assert_called_with(
1, last_date + timedelta(days=1),
date.today() - timedelta(days=3))
def test_get_default_model_30days(self):
"""
Scenario: Get the last 30 days of data of the default flu model
"""
with self.app.app_context():
flu_model = FluModel()
flu_model.id = 1
flu_model.is_displayed = True
flu_model.is_public = True
flu_model.calculation_parameters = ''
flu_model.name = 'Model 1'
flu_model.source_type = 'google'
flu_model.save()
default_model = DefaultFluModel()
default_model.flu_model_id = 1
model_function = ModelFunction()
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
model_function.function_name = 'Function name'
model_function.average_window_size = 7
model_function.save()
DB.session.add(default_model)
DB.session.commit()
for i in range(1, 32):
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date(2018, 1, i)
model_score.score_value = i / (10 + i)
model_score.region = 'e'
model_score.save()
result = get_default_flu_model_30days()
self.assertEqual(result[0]['average_score'], 0.5723146873461765)
self.assertEqual(result[0]['start_date'], date(2018, 1, 2))
self.assertEqual(result[0]['end_date'], date(2018, 1, 31))
self.assertEqual(result[0]['name'], 'Model 1')
self.assertEqual(result[0]['id'], 1)
self.assertEqual(len(result[1]), 30)
def test_csv(self):
flumodel = FluModel()
flumodel.id = 1
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1 + 10 / d.day
entry.confidence_interval_lower = 0
entry.confidence_interval_upper = 2
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
with self.app.app_context():
flumodel.save()
model_function.save()
response = self.client().get(
'/csv?id=1&tartDate=2018-06-01&endDate=2018-06-07&resolution=week'
)
expected_header = r'attachment; filename=RawScores-\d{13}\.csv'
expected_data = b'score_date,score_Test Model\r\n2018-06-03,4.333333333333334\r\n'
self.assertEquals(response.data, expected_data)
self.assertRegexpMatches(response.headers['Content-Disposition'],
expected_header)
def test_get_days_missing_model(self):
"""
Scenario: Get the number of days with missing model scores
Given a FluModel with an id value of 1 exists
And ModelScores with score dates '2018-01-02', '2018-01-03', '2018-01-05'
When start = '2018-01-01' and end = '2018-01-05'
Then dates missing are '2018-01-01', '2018-01-04'
"""
with self.app.app_context():
for day in (2, 3, 5):
model_score = ModelScore()
model_score.flu_model_id = 1
model_score.score_date = date(2018, 1, day)
model_score.score_value = 0.1 + day
model_score.region = 'e'
model_score.save()
result = get_dates_missing_model_score(1, date(2018, 1, 1),
date(2018, 1, 5))
expected = [date(2018, 1, 1), date(2018, 1, 4)]
self.assertListEqual(result, expected)
result = get_dates_missing_model_score(1, date(2018, 1, 6),
date(2018, 1, 7))
expected = [date(2018, 1, 6), date(2018, 1, 7)]
self.assertListEqual(result, expected)
def test_build_root_plink_twlink_response(self):
model_list = [{
'id': 1,
'name': 'Test Model'
}, {
'id': 2,
'name': 'Another Test Model'
}]
rate_thresholds = {
'very_high_value': {
'label': 'Very high epidemic rate',
'value': 0.4
},
'high_value': {
'label': 'High epidemic rate',
'value': 0.3
},
'medium_value': {
'label': 'Medium epidemic rate',
'value': 0.2
},
'low_value': {
'label': 'Low epidemic rate',
'value': 0.1
}
}
data_points = [{
'score_date': '2019-01-01',
'score_value': 0.2,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}, {
'score_date': '2019-01-02',
'score_value': 0.4,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}]
model_data = [{
'id': 1,
'name': 'Test Model',
'start_date': '2019-01-01',
'end_date': '2019-01-02',
'average_score': 0.3,
'has_confidence_interval': True,
'data_points': data_points
}]
expected = {
'model_list': model_list,
'rate_thresholds': rate_thresholds,
'model_data': model_data
}
flu_model_1, flu_model_2 = FluModel(), FluModel()
flu_model_1.id, flu_model_2.id = 1, 2
flu_model_1.name, flu_model_2.name = 'Test Model', 'Another Test Model'
flu_model_list = [flu_model_1, flu_model_2]
flu_model_score_1, flu_model_score_2 = ModelScore(), ModelScore()
flu_model_score_1.score_date, flu_model_score_2.score_date = date(
2019, 1, 1), date(2019, 1, 2)
flu_model_score_1.score_value, flu_model_score_2.score_value = 0.2, 0.4
flu_model_score_1.confidence_interval_lower, flu_model_score_2.confidence_interval_lower = 0.1, 0.1
flu_model_score_1.confidence_interval_upper, flu_model_score_2.confidence_interval_upper = 0.5, 0.5
flu_model_data = [({
'id': 1,
'name': 'Test Model',
'start_date': date(2019, 1, 1),
'end_date': date(2019, 1, 2),
'has_confidence_interval': True,
'average_score': 0.3
}, [flu_model_score_1, flu_model_score_2])]
result = build_root_plink_twlink_response(flu_model_list,
rate_thresholds,
flu_model_data)
self.assertEquals(result, expected)
def test_get_plink_smoothing(self):
with self.app.app_context():
for idx in [1, 2]:
flumodel = FluModel()
flumodel.name = 'Test Model %d' % idx
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1.23 / d.day
entry.confidence_interval_lower = 0.81
entry.confidence_interval_upper = 1.65
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = idx
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = idx
model_function.has_confidence_interval = True
flumodel.save()
model_function.save()
default_model = DefaultFluModel()
default_model.flu_model_id = 1
rate_thresholds = RateThresholdSet()
rate_thresholds.low_value = 0.1
rate_thresholds.medium_value = 0.2
rate_thresholds.high_value = 0.3
rate_thresholds.very_high_value = 0.4
rate_thresholds.valid_from = date(2010, 1, 1)
rate_thresholds.save()
DB.session.add(default_model)
DB.session.commit()
response = self.client().get(
'/plink?id=1&id=2&startDate=2018-06-01&endDate=2018-06-05&smoothing=3'
)
self.assertListEqual(response.get_json()['model_list'],
[{
'id': 1,
'name': 'Test Model 1'
}, {
'id': 2,
'name': 'Test Model 2'
}])
self.assertEqual(
len(response.get_json()['model_data'][0]['data_points']), 5)
self.assertEqual(
len(response.get_json()['model_data'][1]['data_points']), 5)
expected = {
'low_value': {
'label': 'Low epidemic rate',
'value': 0.1
},
'medium_value': {
'label': 'Medium epidemic rate',
'value': 0.2
},
'high_value': {
'label': 'High epidemic rate',
'value': 0.3
},
'very_high_value': {
'label': 'Very high epidemic rate',
'value': 0.4
}
}
self.assertDictEqual(response.get_json()['rate_thresholds'], expected)
list_expected = [0.252833, 0.321167, 0.444167, 0.751667, 0.922500]
list_result = [
round(s['score_value'], 6)
for s in response.get_json()['model_data'][0]['data_points']
]
self.assertListEqual(list_result, list_expected)
def test_get_twlink_current_link(self):
flumodel = FluModel()
flumodel.id = 1
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
flumodel.model_region_id = '1-e'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1.23
entry.confidence_interval_lower = 0.81
entry.confidence_interval_upper = 1.65
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
default_model = DefaultFluModel()
default_model.flu_model_id = 1
rate_thresholds = RateThresholdSet()
rate_thresholds.low_value = 0.1
rate_thresholds.medium_value = 0.2
rate_thresholds.high_value = 0.3
rate_thresholds.very_high_value = 0.4
rate_thresholds.valid_from = date(2010, 1, 1)
with self.app.app_context():
flumodel.save()
model_function.save()
rate_thresholds.save()
DB.session.add(default_model)
DB.session.commit()
response = self.client().get(
'/twlink?id=1&start=2018-06-01&end=2018-06-10')
self.assertListEqual(response.get_json()['model_list'],
[{
'id': 1,
'name': 'Test Model'
}])
self.assertEqual(
len(response.get_json()['model_data'][0]['data_points']), 10)
expected = {
'low_value': {
'label': 'Low epidemic rate',
'value': 0.1
},
'medium_value': {
'label': 'Medium epidemic rate',
'value': 0.2
},
'high_value': {
'label': 'High epidemic rate',
'value': 0.3
},
'very_high_value': {
'label': 'Very high epidemic rate',
'value': 0.4
}
}
self.assertDictEqual(response.get_json()['rate_thresholds'], expected)
