class ModelRunServiceDeleteTest(TestWithFullModelRun):
def setUp(self):
super(ModelRunServiceDeleteTest, self).setUp()
self.job_runner_client = JobRunnerClient(config)
self.model_run_service = ModelRunService(job_runner_client=self.job_runner_client)
self.clean_database()
def test_GIVEN_model_doesnot_exist_WHEN_delete_THEN_not_found(self):
# Add a user who doesn't have any model runs
with session_scope(Session) as session:
user = User()
user.name = 'Has No Model Runs'
session.add(user)
# Get the users model runs
with self.assertRaises(NoResultFound, msg="Should have thrown a NoResultFound exception"):
model_runs = self.model_run_service.delete_run_model(10000, user)
def test_GIVEN_model_belongs_to_someone_else_WHEN_delete_THEN_not_found(self):
# Add a user who doesn't have any model runs
other_user = self.login("other_user")
model = self.create_run_model(10, "test", other_user)
with session_scope(Session) as session:
user = User()
user.name = 'Has No Model Runs'
session.add(user)
# Get the users model runs
with self.assertRaises(NoResultFound, msg="Should have thrown a NoResultFound exception"):
self.model_run_service.delete_run_model(model.id, user)
def test_GIVEN_model_WHEN_delete_THEN_model_delete_job_runner_called(self):
# Add a user who doesn't have any model runs
user = self.login()
model = self.create_run_model(10, "test", user)
self.job_runner_client.delete = Mock()
self.model_run_service.delete_run_model(model.id, user)
assert_that(self.job_runner_client.delete.called, is_(True), "Job runner called")
with self.assertRaises(NoResultFound):
self.model_run_service.get_model_by_id(user, model.id)
def test_GIVEN_model_belongs_to_someone_else_and_user_is_an_admin_WHEN_delete_THEN_delete_model(self):
# Add a user who doesn't have any model runs
self.job_runner_client.delete = Mock()
other_user = self.login("other_user")
model = self.create_run_model(10, "test", other_user)
user = self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
self.model_run_service.delete_run_model(model.id, user)
with self.assertRaises(NoResultFound):
self.model_run_service.get_model_by_id(user, model.id)
def test_GIVEN_model_belongs_to_someone_else_and_is_published_and_user_is_an_admin_WHEN_delete_THEN_delete_model(self):
self.job_runner_client.delete = Mock()
# Add a user who doesn't have any model runs
other_user = self.login("other_user")
model = self.create_run_model(10, "test", other_user, constants.MODEL_RUN_STATUS_PUBLISHED)
user = self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
self.model_run_service.delete_run_model(model.id, user)
with self.assertRaises(NoResultFound):
self.model_run_service.get_model_by_id(user, model.id)
def test_GIVEN_model_belongs_to_someone_else_and_is_public_and_user_is_an_admin_WHEN_delete_THEN_delete_model(self):
self.job_runner_client.delete = Mock()
# Add a user who doesn't have any model runs
other_user = self.login("other_user")
model = self.create_run_model(10, "test", other_user, constants.MODEL_RUN_STATUS_PUBLIC)
user = self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
self.model_run_service.delete_run_model(model.id, user)
with self.assertRaises(NoResultFound):
self.model_run_service.get_model_by_id(user, model.id)
def test_GIVEN_model_and_is_public_and_user_is_not_an_admin_WHEN_delete_THEN_raise(self):
self.job_runner_client.delete = Mock()
# Add a user who doesn't have any model runs
user = self.login("user")
model = self.create_run_model(10, "test", user, constants.MODEL_RUN_STATUS_PUBLIC)
assert_that(calling(self.model_run_service.delete_run_model).with_args(model.id, user),
raises(ModelPublished))
def test_GIVEN_full_model_WHEN_delete_THEN_model_is_deleted(self):
user = self.login('')
self.create_model_run_ready_for_submit()
with session_scope(Session) as session:
dataset_count = session.query(Dataset).count()
model = self.model_run_service.get_models_for_user(user)[0]
dataset = Dataset()
dataset.model_run_id = model.id
session.add(dataset)
region_count = session.query(LandCoverAction).count()
session.add(LandCoverAction(model_run_id=model.id))
model_not_to_delete = self.create_run_model(0, "test", user, constants.MODEL_RUN_STATUS_PUBLISHED)
self.job_runner_client.delete = Mock()
self.model_run_service.delete_run_model(model.id, user)
with session_scope(Session) as session:
count = session.query(ModelRun).filter(ModelRun.id == model.id).count()
assert_that(count, is_(0), 'Count(Model)')
with session_scope(Session) as session:
count = session.query(ModelRun).filter(ModelRun.id == model_not_to_delete.id).count()
assert_that(count, is_(1), 'Count(Model)')
with session_scope(Session) as session:
count = session.query(Dataset).count()
assert_that(count, is_(dataset_count), 'Count(Datasets)is same as before creating model')
with session_scope(Session) as session:
count = session.query(LandCoverAction).count()
assert_that(count, is_(region_count), 'Count(LandCoverAction)is same as before creating model')
def test_GIVEN_full_model_WHEN_delete_THEN_parameter_values_are_deleted(self):
user = self.login('')
with session_scope(Session) as session:
pv_count = session.query(ParameterValue).count()
self.create_model_run_ready_for_submit()
with session_scope(Session) as session:
model = self.model_run_service.get_models_for_user(user)[0]
assert_that(session.query(ParameterValue).count(), greater_than(pv_count), "Creating model run adds parameters")
self.job_runner_client.delete = Mock()
self.model_run_service.delete_run_model(model.id, user)
with session_scope(Session) as session:
assert_that(session.query(ParameterValue).count(), is_(pv_count), "Parameter values is same as before model was created")
