def test_get_experiment_uses_by_id_notfound(self):
reservations, usages = self._store_two_reservations()
reservation1 = self._reserve_experiment()
reservation2 = self._reserve_experiment()
db_sess_id = ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id=sess_id):
experiment_results = core_api.get_experiment_uses_by_id(
(reservations[0], reservation1, reservation2))
self.assertEquals(3, len(experiment_results))
# reservation_id1 is for student1, so it returns a real object (with a real experiment_use_id)
self.assertTrue(experiment_results[0].is_finished())
experiment_results[0].experiment_use.experiment_use_id = None
self.assertEquals(
FinishedReservationResult(usages[0].load_files('.')),
experiment_results[0])
# reservation_id2 is for student2, and the session is for student1, so it returns None
self.assertTrue(experiment_results[1].is_alive())
self.assertTrue(experiment_results[2].is_alive())
def test_kickout_from_ups(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
methods.kickout_from_ups.call(sess_id.id)
with wlcontext(self.ups, session_id = sess_id):
self.assertRaises( core_exc.SessionNotFoundError, core_api.get_reservation_status)
def test_reserve_experiment(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
exp_id = ExperimentId('this does not experiment','this neither')
with wlcontext(self.ups, session_id = sess_id):
self.assertRaises(
coreExc.UnknownExperimentIdError,
core_api.reserve_experiment, exp_id, "{}", "{}" )
exp_id = ExperimentId('ud-dummy','Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.translate('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = core_api.reserve_experiment(exp_id, "{}", "{}")
self.assertTrue( isinstance(reservation,Reservation.Reservation))
core_api.logout()
def test_reserve_experiment(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
exp_id = ExperimentId('this does not experiment', 'this neither')
with wlcontext(self.ups, session_id=sess_id):
self.assertRaises(coreExc.UnknownExperimentIdError,
core_api.reserve_experiment, exp_id, "{}", "{}")
exp_id = ExperimentId('ud-dummy', 'Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.translate('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = core_api.reserve_experiment(exp_id, "{}", "{}")
self.assertTrue(isinstance(reservation, Reservation.Reservation))
core_api.logout()
def test_kickout_from_ups(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
methods.kickout_from_ups.call(sess_id.id)
with wlcontext(self.ups, session_id = sess_id):
self.assertRaises( core_exc.SessionNotFoundError, core_api.get_reservation_status)
def test_ldap_user_right(self):
mockr = mocker.Mocker()
ldap_auth._ldap_provider.ldap_module = mockr.mock()
with wlcontext(self.core_server):
session_id = core_api.login(fake_ldap_user, fake_ldap_passwd)
self.assertTrue( isinstance(session_id, SessionId) )
self.assertTrue( len(session_id.id) > 5 )
def test_valid_user_and_invalid_password(self):
login_manager.LOGIN_FAILED_DELAY = 0.2
with wlcontext(self.core_server):
self.assertRaises(
LoginErrors.InvalidCredentialsError,
core_api.login,
fake_right_user,
fake_wrong_passwd
)
def test_reserve_session(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
session_manager = self.ups._session_manager
sess = session_manager.get_session(sess_id)
self.assertEquals(sess['db_session_id'].username, db_sess_id.username)
with wlcontext(self.ups, session_id=sess_id):
core_api.logout()
def test_reserve_session(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
session_manager = self.ups._session_manager
sess = session_manager.get_session(sess_id)
self.assertEquals(sess['db_session_id'].username, db_sess_id.username)
with wlcontext(self.ups, session_id = sess_id):
core_api.logout()
def test_kickout_from_coordinator(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
status = core_api.reserve_experiment(ExperimentId( experiment, category ), "{}", "{}")
reservation_session_id = status.reservation_id
with wlcontext(self.ups, reservation_id = reservation_session_id, session_id = sess_id):
status = core_api.get_reservation_status()
self.assertNotEquals( None, status )
reservation_id = methods.get_reservation_id.call(sess_id.id)
methods.kickout_from_coordinator.call(reservation_id)
self.assertRaises( core_exc.NoCurrentReservationError, core_api.get_reservation_status)
def test_kickout_from_coordinator(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
status = core_api.reserve_experiment(ExperimentId( experiment, category ), "{}", "{}")
reservation_session_id = status.reservation_id
with wlcontext(self.ups, reservation_id = reservation_session_id, session_id = sess_id):
status = core_api.get_reservation_status()
self.assertNotEquals( None, status )
reservation_id = methods.get_reservation_id.call(sess_id.id)
methods.kickout_from_coordinator.call(reservation_id)
self.assertRaises( core_exc.NoCurrentReservationError, core_api.get_reservation_status)
def test_get_reservation_id_one_user(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
core_api.reserve_experiment(ExperimentId( experiment, category ), "{}", "{}")
reservation_id = methods.get_reservation_id.call(sess_id.id)
self.assertNotEquals(None, reservation_id)
def test_get_reservation_id_one_user(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
core_api.reserve_experiment(ExperimentId( experiment, category ), "{}", "{}")
reservation_id = methods.get_reservation_id.call(sess_id.id)
self.assertNotEquals(None, reservation_id)
def test_get_user_information(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id=sess_id):
user = core_api.get_user_information()
self.assertEquals("student2", user.login)
self.assertEquals("Name of student 2", user.full_name)
self.assertEquals("*****@*****.**", user.email)
core_api.logout()
def test_get_user_information(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
user = core_api.get_user_information()
self.assertEquals("student2",user.login)
self.assertEquals("Name of student 2",user.full_name)
self.assertEquals("*****@*****.**",user.email)
core_api.logout()
def test_list_experiments(self):
# student1
db_sess_id1 = ValidDatabaseSessionId('student1', "student")
sess_id1, _ = self.ups._reserve_session(db_sess_id1)
with wlcontext(self.ups, session_id=sess_id1):
experiments = core_api.list_experiments()
self.assertLessEqual(5, len(experiments))
experiment_names = list(
(experiment.experiment.name for experiment in experiments))
self.assertTrue('ud-dummy' in experiment_names)
self.assertTrue('ud-logic' in experiment_names)
self.assertTrue('ud-fpga' in experiment_names)
self.assertTrue('flashdummy' in experiment_names)
self.assertTrue('javadummy' in experiment_names)
core_api.logout()
# student2
db_sess_id2 = ValidDatabaseSessionId('student2', "student")
sess_id2, _ = self.ups._reserve_session(db_sess_id2)
with wlcontext(self.ups, session_id=sess_id2):
experiments = core_api.list_experiments()
self.assertEquals(7, len(experiments))
experiment_names = list(
(experiment.experiment.name for experiment in experiments))
self.assertTrue('ud-dummy' in experiment_names)
self.assertTrue('ud-fpga' in experiment_names)
self.assertTrue('ud-pld' in experiment_names)
self.assertTrue('ud-gpib' in experiment_names)
self.assertTrue('ud-logic' in experiment_names)
self.assertTrue('javadummy' in experiment_names)
self.assertTrue('flashdummy' in experiment_names)
core_api.logout()
def test_get_experiment_use_by_id_found(self):
reservations, usages = self._store_two_reservations()
db_sess_id = ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
finished_result = core_api.get_experiment_use_by_id(reservations[0])
self.assertTrue( finished_result.is_finished() )
# reservation_id1 is for student1, so it returns a real object (with a real experiment_use_id)
finished_result.experiment_use.experiment_use_id = None
self.assertEquals(FinishedReservationResult(usages[0].load_files('.')), finished_result)
def test_list_experiments(self):
# student1
db_sess_id1 = ValidDatabaseSessionId('student1', "student")
sess_id1, _ = self.ups._reserve_session(db_sess_id1)
with wlcontext(self.ups, session_id = sess_id1):
experiments = core_api.list_experiments()
self.assertLessEqual(5, len(experiments) )
experiment_names = list(( experiment.experiment.name for experiment in experiments ))
self.assertTrue( 'ud-dummy' in experiment_names )
self.assertTrue( 'ud-logic' in experiment_names )
self.assertTrue( 'ud-fpga' in experiment_names )
self.assertTrue( 'flashdummy' in experiment_names )
self.assertTrue( 'javadummy' in experiment_names )
core_api.logout()
# student2
db_sess_id2 = ValidDatabaseSessionId('student2', "student")
sess_id2, _ = self.ups._reserve_session(db_sess_id2)
with wlcontext(self.ups, session_id = sess_id2):
experiments = core_api.list_experiments()
self.assertEquals(7, len(experiments) )
experiment_names = list(( experiment.experiment.name for experiment in experiments ))
self.assertTrue( 'ud-dummy' in experiment_names )
self.assertTrue( 'ud-fpga' in experiment_names )
self.assertTrue( 'ud-pld' in experiment_names )
self.assertTrue( 'ud-gpib' in experiment_names )
self.assertTrue( 'ud-logic' in experiment_names )
self.assertTrue( 'javadummy' in experiment_names )
self.assertTrue( 'flashdummy' in experiment_names )
core_api.logout()
def test_get_reservation_info(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
exp_id = ExperimentId('ud-dummy','Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.translate('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
with wlcontext(self.ups, session_id = sess_id):
reservation = core_api.reserve_experiment( exp_id, "{}", "{}")
with wlcontext(self.ups, reservation_id = reservation.reservation_id):
reservation_info = core_api.get_reservation_info()
self.assertEquals('ud-dummy', reservation_info.exp_name)
self.assertEquals('Dummy experiments', reservation_info.cat_name)
with wlcontext(self.ups, session_id = sess_id):
core_api.logout()
def test_get_reservation_info(self):
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
exp_id = ExperimentId('ud-dummy', 'Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.translate('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
with wlcontext(self.ups, session_id=sess_id):
reservation = core_api.reserve_experiment(exp_id, "{}", "{}")
with wlcontext(self.ups, reservation_id=reservation.reservation_id):
reservation_info = core_api.get_reservation_info()
self.assertEquals('ud-dummy', reservation_info.exp_name)
self.assertEquals('Dummy experiments', reservation_info.cat_name)
with wlcontext(self.ups, session_id=sess_id):
core_api.logout()
def test_login_delay(self):
login_manager.LOGIN_FAILED_DELAY = 0.2
#Sometimes it's 0.999323129654
#0.001 should be ok, but just in case
ERROR_MARGIN = 0.01
start_time = time.time()
with wlcontext(self.core_server):
self.assertRaises(
LoginErrors.InvalidCredentialsError,
core_api.login,
fake_wrong_user,
fake_wrong_passwd
)
finish_time = time.time()
self.assertTrue((finish_time + ERROR_MARGIN - start_time) >= login_manager.LOGIN_FAILED_DELAY)
def _reserve_experiment(self):
db_sess_id = ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id=sess_id):
exp_id = ExperimentId('ud-dummy', 'Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.translate('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = core_api.reserve_experiment(exp_id, "{}", "{}")
return reservation.reservation_id
def test_get_experiment_use_by_id_found(self):
reservations, usages = self._store_two_reservations()
db_sess_id = ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id=sess_id):
finished_result = core_api.get_experiment_use_by_id(
reservations[0])
self.assertTrue(finished_result.is_finished())
# reservation_id1 is for student1, so it returns a real object (with a real experiment_use_id)
finished_result.experiment_use.experiment_use_id = None
self.assertEquals(
FinishedReservationResult(usages[0].load_files('.')),
finished_result)
def _reserve_experiment(self):
db_sess_id = ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
exp_id = ExperimentId('ud-dummy','Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.translate('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = core_api.reserve_experiment(exp_id, "{}", "{}")
return reservation.reservation_id
def test_ldap_user_invalid(self):
mockr = mocker.Mocker()
ldap_object = mockr.mock()
ldap_object.simple_bind_s(fake_ldap_user + '@cdk.deusto.es', fake_ldap_invalid_passwd)
mockr.throw(ldap.INVALID_CREDENTIALS)
ldap_module = mockr.mock()
ldap_module.initialize('ldaps://castor.cdk.deusto.es')
mockr.result(ldap_object)
ldap_auth._ldap_provider.ldap_module = ldap_module
with wlcontext(self.core_server):
with mockr:
self.assertRaises(
LoginErrors.InvalidCredentialsError,
core_api.login,
fake_ldap_user,
fake_ldap_invalid_passwd
)
def test_get_experiment_uses_by_id_found(self):
reservations, usages = self._store_two_reservations()
db_sess_id = ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
with wlcontext(self.ups, session_id = sess_id):
experiment_results = core_api.get_experiment_uses_by_id(reservations)
self.assertEquals(2, len(experiment_results))
self.assertTrue( experiment_results[0].is_finished() )
# reservation_id1 is for student1, so it returns a real object (with a real experiment_use_id)
experiment_results[0].experiment_use.experiment_use_id = None
self.assertEquals(FinishedReservationResult(usages[0].load_files('.')), experiment_results[0])
# reservation_id2 is for student2, and the session is for student1, so it is forbidden
self.assertTrue(experiment_results[1].is_forbidden())
def test_get_experiment_ups_session_ids(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
#
# It returns only the sessions_ids of the experiments
#
result = methods.get_experiment_ups_session_ids.call(category, experiment)
self.assertEquals( [], result )
with wlcontext(self.ups, session_id = sess_id):
status = core_api.reserve_experiment(ExperimentId( experiment, category ), "{}", "{}")
result = methods.get_experiment_ups_session_ids.call(category, experiment)
self.assertEquals( 1, len(result) )
session_id, login, reservation_id = result[0]
self.assertEquals( status.reservation_id.id.split(';')[0], session_id )
self.assertEquals( "student2", login )
def test_get_experiment_ups_session_ids(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups._reserve_session(db_sess_id)
#
# It returns only the sessions_ids of the experiments
#
result = methods.get_experiment_ups_session_ids.call(category, experiment)
self.assertEquals( [], result )
with wlcontext(self.ups, session_id = sess_id):
status = core_api.reserve_experiment(ExperimentId( experiment, category ), "{}", "{}")
result = methods.get_experiment_ups_session_ids.call(category, experiment)
self.assertEquals( 1, len(result) )
session_id, login, reservation_id = result[0]
self.assertEquals( status.reservation_id.id.split(';')[0], session_id )
self.assertEquals( "student2", login )
def test_right_session(self):
with wlcontext(self.core_server):
session_id = core_api.login(fake_right_user, fake_right_passwd)
self.assertTrue( isinstance(session_id, SessionId) )
self.assertTrue( len(session_id.id) > 5 )
