def test_complex_model_types_available(self):
with app.app_context():
model_types_names = ['CombProb', 'SearchSeg']
for mt in model_types_names:
model_type = ModelType.query.filter_by(name=mt).first()
self.assertIsNotNone(model_type.id)
self.assertTrue(model_type.complex)
def test_model_weight_for_complex_must_be_none(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
comb_model = add_complex_model_comb(db.session, analysis.id)
with self.assertRaises(AssertionError):
comb_model.create_weights(weight=3)
def test_analysis_with_profiles(self):
with app.app_context():
action = Action(name='Example', lost_time=datetime.datetime.now())
db.session.add(action)
db.session.flush()
analysis = Analysis(name='Some basic analysis',
action_id=action.id,
ipp_longitude=80,
ipp_latitude=70,
rp_latitude=30,
rp_longitude=80)
db.session.add(analysis)
db.session.flush()
person_type_tourist = PersonType.query.filter_by(
name='tourist').first()
person_type_climber = PersonType.query.filter_by(
name='climber').first()
self.assertIsNotNone(person_type_tourist.id)
self.assertIsNotNone(person_type_climber.id)
tourist = Profile(analysis_id=analysis.id,
person_type_id=person_type_tourist.id,
weight=random.randint(1, 10))
climber = Profile(analysis_id=analysis.id,
person_type_id=person_type_climber.id,
weight=random.randint(1, 10))
db.session.add(tourist)
db.session.add(climber)
db.session.flush()
self.assertIsNotNone(tourist.id)
self.assertIsNotNone(climber.id)
self.assertEquals(analysis.profiles.count(), 2)
def test_starting_analysis_with_complex_models(self):
result_ids = {
"HorDistIPP": "3897890975230495710",
"ElevChgIPP": "4709831647259734695",
"HorChgIPP": "4375692374598762347",
"TrackOffset": "3476273469987234659",
"DispAngle": "3892345235423495710",
"FindLocation": "4709831647263434695",
"Mobility": "4375692374598762346",
}
expected_content = {
"CombProb": "3897890975230495710",
"SearchSeg": "3476273469987234659",
}
httpretty.register_uri(httpretty.POST,
server_path('complex_analysis'),
body=json.dumps(expected_content),
content_type="application/json")
with app.app_context():
action = add_simple_action(db.session)
analysis = add_complex_models_analysis(db.session, action.id)
for model in analysis.simple_models():
model.update_result(result_ids[model.name])
draft_simple_models = analysis.draft_models().join(
Model.model_type).filter(ModelType.complex == False)
assert draft_simple_models.count() == 0
analysis.start_computation()
for model in analysis.complex_models():
self.assertEquals(model.result_id,
expected_content[model.name])
def test_cs_profiles_representation(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
person_type_tourist = PersonType.query.filter_by(
name='tourist').first()
person_type_climber = PersonType.query.filter_by(
name='climber').first()
weight_tourist, weight_climber = 3, 7
tourist = Profile(analysis_id=analysis.id,
person_type_id=person_type_tourist.id,
weight=weight_tourist)
climber = Profile(analysis_id=analysis.id,
person_type_id=person_type_climber.id,
weight=weight_climber)
db.session.add(tourist)
db.session.add(climber)
db.session.flush()
expected = {'tourist': weight_tourist, 'climber': weight_climber}
self.assertEquals(len(analysis.cs_profiles()), 2)
self.assertEquals(analysis.cs_profiles(), expected)
def setUp(self):
self.app = app.test_client()
with app.app_context():
db.session.close()
db.drop_all()
db.create_all()
setup_db(db.session)
def test_updating_layers(self):
expected_content = {
"status": "finished",
"layer_ids": ["432542345", "785642345", "434567678", "969824586"]
}
layers_count = 4
result_id = "3897890975230495710"
path = server_path('analysis/%s' % result_id)
httpretty.register_uri(httpretty.GET,
path,
body=json.dumps(expected_content),
content_type="application/json")
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model = add_simple_model(db.session, analysis.id)
# mocking starting computation
model.update_result(result_id)
analysis.update_result()
finished_id = ModelStatus.by_name(ModelStatus.FINISHED).id
assert model.status_id == finished_id
assert analysis.analysis_status_id == finished_id
assert len(model.layer_urls()) == layers_count
layer_paths = [
layer_path(layers_id)
for layers_id in expected_content['layer_ids']
]
for l in model.layer_urls():
assert l in layer_paths
def test_adding_analysis(self):
with app.app_context():
action = Action(name='Example', lost_time=datetime.datetime.now())
db.session.add(action)
db.session.flush()
analysis = Analysis(name='Basic', action_id=action.id)
db.session.add(analysis)
db.session.flush()
self.assertIsNotNone(analysis.id)
def test_duplicating_analysis_deep(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_simple_models_analysis(db.session, action.id)
duplicated = analysis.duplicate({'name': 'Another'})
self.assertNotEqual(analysis.id, duplicated.id)
self.assertEqual(analysis.lost_time, duplicated.lost_time)
self.assertEqual(analysis.models.count(),
duplicated.models.count())
def test_duplicating_analysis_shallow(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
duplicated = analysis.duplicate({'ipp_latitude': 10})
self.assertNotEqual(analysis.id, duplicated.id)
self.assertEqual(analysis.name, duplicated.name)
self.assertEqual(analysis.lost_time, duplicated.lost_time)
self.assertNotEqual(duplicated.ipp_latitude, analysis.ipp_latitude)
self.assertEqual(duplicated.ipp_latitude, 10)
def test_analysis_updating_unfinished(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_simple_models_analysis(db.session, action.id)
processing_id = ModelStatus.by_name(ModelStatus.PROCESSING).id
for model in analysis.models:
model.status_id = processing_id
with self.assertRaises(ValueError):
analysis_data = {'ipp_latitude': 1123123}
analysis.update(analysis_data, None, None)
def test_simple_model_types_available(self):
with app.app_context():
model_types_names = [
'HorDistIPP', 'ElevChgIPP', 'HorChgIPP', 'DispAngle',
'TrackOffset', 'FindLocation', 'Mobility'
]
for mt in model_types_names:
model_type = ModelType.query.filter_by(name=mt).first()
self.assertIsNotNone(model_type.id)
self.assertFalse(model_type.complex)
def test_model_default_status(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model_type = ModelType.query.filter_by(complex=False).first()
model = Model(analysis_id=analysis.id, model_type_id=model_type.id)
db.session.add(model)
db.session.flush()
model_status = ModelStatus.query.filter_by(name='draft').one()
self.assertEquals(model.status_id, model_status.id)
def setUp(self):
self.app = app.test_client()
with app.app_context():
db.session.close()
db.drop_all()
db.create_all()
setup_db(db.session)
app.config['MONTRACKER_SERVER_ADDR'] = 'http://127.0.0.1:10000'
app.config['MONTRACKER_SERVER_API_VERSION'] = 'v1'
app.config['ARCGIS_PATH_PREFIX'] = 'http://127.0.0.1:11000'
app.config['ARCGIS_PATH_SUFFIX'] = '/maps'
def test_model_weight_for_complex_types(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model_type = ModelType.query.filter_by(complex=True).first()
model = Model(analysis_id=analysis.id, model_type_id=model_type.id)
db.session.add(model)
db.session.flush()
self.assertEquals(analysis.models.count(), 1)
self.assertIsNone(model.weight)
with self.assertRaises(AssertionError):
model.create_weights()
def test_model_weight_must_be_associated_with_non_complex_types(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model_type = ModelType.query.filter_by(complex=False).first()
model = Model(analysis_id=analysis.id, model_type_id=model_type.id)
db.session.add(model)
db.session.flush()
self.assertEquals(analysis.models.count(), 1)
self.assertEquals(model.model_weights.count(), 0)
with self.assertRaises(AssertionError):
getattr(model, 'weight')
def test_action_status_id_no_analyses(self):
with app.app_context():
action = add_simple_action(db.session)
analyses_count = Analysis.query.count()
# only one analysis, no models
self.assertEquals(analyses_count, 0)
draft_id = ModelStatus.draft_id()
# and the one has status draft on class level
draft_count = Action.query.filter(
Action.action_status_id == draft_id).count()
self.assertEquals(draft_count, 1)
# as well as on instance level
self.assertEquals(action.action_status_id, draft_id)
def test_analysis_inheriting_action_coordinates(self):
with app.app_context():
action = Action(name='Example', lost_time=datetime.datetime.now())
db.session.add(action)
db.session.flush()
analysis = Analysis(name='Basic', action_id=action.id)
db.session.add(analysis)
db.session.flush()
self.assertIsNone(analysis.ipp_latitude)
self.assertIsNotNone(analysis.lost_time)
self.assertEquals(analysis.lost_time, action.lost_time)
example_ipp_latitude = 50
action.ipp_latitude = example_ipp_latitude
self.assertEquals(analysis.ipp_latitude, example_ipp_latitude)
def test_analysis_status_id_finished(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_simple_models_analysis(db.session, action.id)
finished_id = ModelStatus.by_name(ModelStatus.FINISHED).id
for model in analysis.models:
model.status_id = finished_id
# only one analysis, all finished
analyses_count = Analysis.query.count()
self.assertEquals(analyses_count, 1)
# and the one has status finished on class level
analyses_status_count = Analysis.query.filter(
Analysis.analysis_status_id == finished_id).count()
self.assertEquals(analyses_status_count, 1)
# as well as on instance level
self.assertEquals(analysis.analysis_status_id, finished_id)
def test_analysis_status_id_draft(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_simple_models_analysis(db.session, action.id)
analyses_count = Analysis.query.count()
draft_id = ModelStatus.draft_id()
for model in analysis.models:
model.status_id = draft_id
# only one analysis, no models
self.assertEquals(analyses_count, 1)
# and the one has status draft on class level
draft_count = Analysis.query.filter(
Analysis.analysis_status_id == draft_id).count()
self.assertEquals(draft_count, 1)
# as well as on instance level
self.assertEquals(analysis.analysis_status_id, draft_id)
def test_updating_state(self):
expected_content = {
"status": "converting",
}
result_ids = {
"HorDistIPP": "3897890975230495710",
"ElevChgIPP": "4709831647259734695",
"HorChgIPP": "4375692374598762347",
"TrackOffset": "3476273469987234659",
"DispAngle": "3892345235423495710",
"FindLocation": "4709831647263434695",
"Mobility": "4375692374598762346",
"CombProb": "3897890975230495710",
"SearchSeg": "3476273469987234659",
}
for id in result_ids.values():
path = server_path('analysis/%s' % id)
httpretty.register_uri(httpretty.GET,
path,
body=json.dumps(expected_content),
content_type="application/json")
with app.app_context():
action = add_simple_action(db.session)
analysis = add_complex_models_analysis(db.session, action.id)
draft_id = ModelStatus.draft_id()
for model in analysis.models:
assert model.model_status.id == draft_id
assert analysis.analysis_status_id == draft_id
for model in analysis.models:
model.update_result(result_ids[model.name])
waiting_status_id = ModelStatus.by_name(ModelStatus.WAITING).id
for model in analysis.models:
assert model.status_id == waiting_status_id
assert analysis.analysis_status_id == waiting_status_id
analysis.update_result()
processing_id = ModelStatus.by_name(ModelStatus.PROCESSING).id
for model in analysis.models:
assert model.status_id == processing_id
assert analysis.analysis_status_id == processing_id
def test_model_weight_for_non_complex_types(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model_type = ModelType.query.filter_by(complex=False).first()
model = Model(analysis_id=analysis.id, model_type_id=model_type.id)
db.session.add(model)
db.session.flush()
model.create_weights()
db.session.flush()
self.assertEquals(analysis.models.count(), 1)
self.assertEquals(model.model_weights.count(), 1)
self.assertEquals(model.weight, app.config['DEFAULT_WEIGHT'])
new_weight = 5
model.update_weights(new_weight)
self.assertEquals(model.model_weights.count(), 1)
self.assertEquals(model.weight, new_weight)
def test_model_weight_for_multiple_complex_analyses(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model = add_simple_model(db.session, analysis.id)
comb_model = add_complex_model_comb(db.session, analysis.id)
seg_model = add_complex_model_seg(db.session, analysis.id)
model.create_weights(parent_model_id=comb_model.id)
model.create_weights(parent_model_id=seg_model.id)
db.session.flush()
self.assertEquals(analysis.models.count(), 3)
self.assertEquals(model.model_weights.count(), 2)
self.assertEquals(model.child_model_weights.count(), 0)
self.assertEquals(comb_model.model_weights.count(), 0)
self.assertEquals(seg_model.model_weights.count(), 0)
self.assertEquals(comb_model.child_model_weights.count(), 1)
self.assertEquals(seg_model.child_model_weights.count(), 1)
def test_action_status_id_error(self):
with app.app_context():
action = add_simple_action(db.session)
waiting_id = ModelStatus.by_name(ModelStatus.WAITING).id
error_id = ModelStatus.by_name(ModelStatus.ERROR).id
analysis = add_simple_models_analysis(db.session, action.id)
for model in analysis.models:
model.status_id = waiting_id
analysis = add_simple_models_analysis(db.session, action.id)
for model in analysis.models:
model.status_id = error_id
action_status_count = Action.query.filter(
Action.action_status_id == error_id).count()
self.assertEquals(action_status_count, 1)
self.assertEquals(action.action_status_id, error_id)
def test_action_status_id_processing(self):
with app.app_context():
action = add_simple_action(db.session)
processing_id = ModelStatus.by_name(ModelStatus.PROCESSING).id
finished_id = ModelStatus.by_name(ModelStatus.FINISHED).id
analysis = add_simple_models_analysis(db.session, action.id)
for model in analysis.models:
model.status_id = finished_id
analysis = add_simple_models_analysis(db.session, action.id)
for model in analysis.models:
model.status_id = processing_id
action_status_count = Action.query.filter(
Action.action_status_id == processing_id).count()
self.assertEquals(action_status_count, 1)
self.assertEquals(action.action_status_id, processing_id)
def test_analysis_status_id_waiting(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_simple_models_analysis(db.session, action.id)
processing_id = ModelStatus.by_name(ModelStatus.PROCESSING).id
waiting_id = ModelStatus.by_name(ModelStatus.WAITING).id
for model in analysis.models:
model.status_id = processing_id
analysis.models.first().status_id = waiting_id
# only one analysis, all processing but one waiting
analyses_count = Analysis.query.count()
self.assertEquals(analyses_count, 1)
# and the one has status waiting on class level
analyses_status_count = Analysis.query.filter(
Analysis.analysis_status_id == waiting_id).count()
self.assertEquals(analyses_status_count, 1)
# as well as on instance level
self.assertEquals(analysis.analysis_status_id, waiting_id)
def test_adding_analysis_with_basic_model(self):
with app.app_context():
action = Action(name='Example', lost_time=datetime.datetime.now())
db.session.add(action)
db.session.flush()
analysis = Analysis(name='Some basic analysis',
action_id=action.id,
ipp_longitude=80,
ipp_latitude=70,
rp_latitude=30,
rp_longitude=80)
db.session.add(analysis)
db.session.flush()
model_type = ModelType.query.filter_by(complex=False).first()
self.assertIsNotNone(model_type.id)
model = Model(analysis_id=analysis.id, model_type_id=model_type.id)
db.session.add(model)
db.session.flush()
self.assertIsNotNone(model.id)
self.assertEquals(analysis.models.count(), 1)
def test_model_weight_for_child_model(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
model_type = ModelType.query.filter_by(complex=False).first()
complex_model_type = ModelType.query.filter_by(
complex=True).first()
model = Model(analysis_id=analysis.id, model_type_id=model_type.id)
complex_model = Model(analysis_id=analysis.id,
model_type_id=complex_model_type.id)
db.session.add(model)
db.session.add(complex_model)
db.session.flush()
model.create_weights(parent_model_id=complex_model.id)
db.session.flush()
self.assertEquals(analysis.models.count(), 2)
self.assertEquals(model.model_weights.count(), 1)
self.assertEquals(model.child_model_weights.count(), 0)
self.assertEquals(complex_model.model_weights.count(), 0)
self.assertEquals(complex_model.child_model_weights.count(), 1)
def test_cs_simple_models_representation(self):
with app.app_context():
action = add_simple_action(db.session)
analysis = add_analysis_with_coordinates(db.session, action.id)
# add simple models
model_type_names = [
'HorDistIPP', 'ElevChgIPP', 'HorChgIPP', 'DispAngle',
'TrackOffset', 'FindLocation', 'Mobility'
]
for mtn in model_type_names:
model_type = ModelType.query.filter_by(name=mtn).first()
model = Model(analysis_id=analysis.id,
model_type_id=model_type.id)
db.session.add(model)
db.session.flush()
expected = model_type_names
self.assertEquals(len(analysis.cs_simple_models()), len(expected))
self.assertEquals(analysis.cs_simple_models(), expected)
def test_starting_analysis_with_simple_models(self):
expected_content = {
"HorDistIPP": "3897890975230495710",
"ElevChgIPP": "4709831647259734695",
"HorChgIPP": "4375692374598762347",
"TrackOffset": "3476273469987234659",
"DispAngle": "3892345235423495710",
"FindLocation": "4709831647263434695",
"Mobility": "4375692374598762346",
}
httpretty.register_uri(httpretty.POST,
server_path('analysis'),
body=json.dumps(expected_content),
content_type="application/json")
with app.app_context():
action = add_simple_action(db.session)
analysis = add_simple_models_analysis(db.session, action.id)
analysis.start_computation()
for model in analysis.simple_models():
self.assertEquals(model.result_id,
expected_content[model.name])
