def test_return_get_experiment_use_by_id(self):
expected_sess_id = SessionId.SessionId("whatever")
expected_alive_result = WaitingReservationResult()
self.mock_ups.return_values[
'get_experiment_use_by_id'] = expected_alive_result
alive_result = self.rfm.get_experiment_use_by_id(
expected_sess_id, SessionId.SessionId('reservation'))
self.assertEquals(expected_alive_result.status, alive_result.status)
def _fake_simple_lab_response(self):
self.lab_mock.reserve_experiment(
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
"{}", mocker.ANY)
self.mocker.result((SessionId.SessionId('my_lab_session_id'), 'ok',
'servexp:inst@mach'))
self.lab_mock.resolve_experiment_address('my_lab_session_id')
self.mocker.result(CoordAddress.CoordAddress("exp", "inst", "mach"))
self.lab_mock.should_experiment_finish(
SessionId.SessionId('my_lab_session_id'))
self.mocker.result(0)
self.mocker.replay()
def test_return_reserve_experiment(self):
expected_sess_id = SessionId.SessionId("whatever")
experimentA, _ = _generate_two_experiments()
expected_reservation = Reservation.ConfirmedReservation(
"reservation_id", 100, "{}", 'http://www.weblab.deusto.es/...', '')
self.mock_ups.return_values[
'reserve_experiment'] = expected_reservation
self.assertEquals(
expected_reservation,
self.rfm.reserve_experiment(expected_sess_id,
experimentA.to_experiment_id(), "{}",
"{}"))
self.assertEquals(expected_sess_id.id,
self.mock_ups.arguments['reserve_experiment'][0].id)
self.assertEquals(
experimentA.name,
self.mock_ups.arguments['reserve_experiment'][1].exp_name)
self.assertEquals(
experimentA.category.name,
self.mock_ups.arguments['reserve_experiment'][1].cat_name)
self.assertEquals("{}",
self.mock_ups.arguments['reserve_experiment'][2])
def test_send_file(self):
self.configurationManager._set_value(self.rfs.FACADE_ZSI_PORT, 14129)
self.rfs.start()
try:
wds = UserProcessingWebLabDeustoSOAP("http://localhost:14129/weblab/soap/")
expected_sess_id = SessionId.SessionId("whatever")
expected_content = 'my file'
expected_result = 'hello there'
file_info = 'program'
self.mock_server.return_values['send_file' ] = Command.Command(expected_result)
result = wds.send_file(expected_sess_id, expected_content, file_info)
self.assertEquals(
expected_sess_id.id,
self.mock_server.arguments['send_file'][0]
)
self.assertEquals(
expected_content,
self.mock_server.arguments['send_file'][1]
)
self.assertEquals(
expected_result,
result.commandstring
)
finally:
self.rfs.stop()
def test_confirm_experiment(self):
lab_session_id = SessionId.SessionId("samplesession_id")
mock_laboratory = self.mocker.mock()
mock_laboratory.reserve_experiment(ExperimentInstanceId('inst1','exp1','cat1'), '"sample initial data"', mocker.ANY)
self.mocker.result((lab_session_id, None, 'server:inst@mach'))
self.mock_locator.real_mock = self.mocker.mock()
self.mock_locator.real_mock.get_server_from_coordaddress(
self.coord_address,
coord_addr(self.lab_address),
ServerType.Laboratory,
'all'
)
self.mocker.result((mock_laboratory,))
self.mocker.count(min=1,max=None)
self.mocker.replay()
status, reservation1_id = self.coordinator.reserve_experiment(ExperimentId('exp1','cat1'), 30, 5, True, 'sample initial data', DEFAULT_REQUEST_INFO, {})
now = datetime.datetime.fromtimestamp(int(time.time())) # Remove milliseconds as MySQL do
self.coordinator.confirmer._confirm_handler.join()
self.assertEquals( None, self.confirmer._confirm_handler.raised_exc )
status = self.coordinator.get_reservation_status(reservation1_id)
expected_status = WSS.LocalReservedStatus(reservation1_id, CoordAddress.CoordAddress.translate_address(self.lab_address), lab_session_id, 30, '{}', now, now, True, 30, 'http://www.weblab.deusto.es/weblab/client/adfas')
self.assertTrue(hasattr(status, 'timestamp_before'), "Unexpected status. Expected\n %s\n, but the obtained does not have timestamp_before:\n %s\n" % (status, expected_status))
self.assertTrue(status.timestamp_before >= now and status.timestamp_before <= now + datetime.timedelta(seconds=10),
"Unexpected status due to timestamp_before: %s; expected something like %s" % (status, expected_status))
self.assertTrue(status.timestamp_after >= now and status.timestamp_after <= now + datetime.timedelta(seconds=10),
"Unexpected status due to timestamp_after: %s; expected something like %s" % (status, expected_status))
status.timestamp_before = now
status.timestamp_after = now
self.assertEquals( expected_status, status )
def _free_experiment(self, lab_coordaddress, reservation_id,
lab_session_id, experiment_instance_id):
try:
initial_time = datetime.datetime.now()
try:
labserver = self.locator[lab_coordaddress]
experiment_response = labserver.free_experiment(
SessionId.SessionId(lab_session_id))
except Exception as e:
if DEBUG:
traceback.print_exc()
log.log(ReservationConfirmer, log.level.Error,
"Exception freeing experiment: %s" % e)
log.log_exc(ReservationConfirmer, log.level.Warning)
self.coordinator.mark_experiment_as_broken(
experiment_instance_id, [str(e)])
else: # Everything went fine
end_time = datetime.datetime.now()
self.coordinator.confirm_resource_disposal(
lab_coordaddress.address, reservation_id, lab_session_id,
experiment_instance_id, experiment_response, initial_time,
end_time)
except:
if DEBUG:
traceback.print_exc()
log.log(ReservationConfirmer, log.level.Critical,
"Unexpected exception freeing experiment")
log.log_exc(ReservationConfirmer, log.level.Critical)
def test_list_experiments(self):
self.configurationManager._set_value(self.rfs.FACADE_ZSI_PORT, 14125)
self.rfs.start()
try:
wds = UserProcessingWebLabDeustoSOAP("http://localhost:14125/weblab/soap/")
expected_sess_id = SessionId.SessionId("whatever")
expected_experiments = self._generate_experiments_allowed()
self.mock_server.return_values['list_experiments'] = expected_experiments
experiments = wds.list_experiments(expected_sess_id)
self.assertEquals(
expected_sess_id.id,
self.mock_server.arguments['list_experiments'][0]
)
self.assertEquals(
len(expected_experiments),
len(experiments)
)
self.assertEquals(
expected_experiments[0].experiment.name,
experiments[0].experiment.name
)
self.assertEquals(
expected_experiments[0].experiment.category.name,
experiments[0].experiment.category.name
)
finally:
self.rfs.stop()
def test_send_file_ok(self):
file_content = "SAMPLE CONTENT"
lab_response = Command.Command("LAB RESPONSE")
file_info = 'program'
self._return_reserved()
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
response = self.reservation_processor.send_file(
file_content, file_info)
self.assertEquals(lab_response, response)
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_logout(self):
self.configurationManager._set_value(self.rfs.FACADE_ZSI_PORT, 14124)
self.rfs.start()
try:
wds = UserProcessingWebLabDeustoSOAP("http://localhost:14124/weblab/soap/")
expected_sess_id = SessionId.SessionId("whatever")
MESSAGE = 'my message'
self.mock_server.return_values['logout'] = expected_sess_id
wds.logout(expected_sess_id)
self.assertEquals(
expected_sess_id.id,
self.mock_server.arguments['logout'][0]
)
self.mock_server.exceptions['logout'] = coreExc.SessionNotFoundError(MESSAGE)
try:
wds.logout(expected_sess_id)
self.fail('exception expected')
except ZSI.FaultException as e:
self.assertEquals(
UserProcessingRFCodes.CLIENT_SESSION_NOT_FOUND_EXCEPTION_CODE,
e.fault.code[1]
)
self.assertEquals(
MESSAGE,
e.fault.string
)
finally:
self.rfs.stop()
def test_send_command_ok(self):
self._return_reserved()
command = Command.Command("Your command")
lab_response = Command.Command("LAB RESPONSE")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'),
command)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
response = self.reservation_processor.send_command(command)
self.assertEquals(lab_response, response)
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_exception_send_file(self):
MESSAGE = "The exception message"
expected_sess_id = SessionId.SessionId("whatever")
FILE_CONTENT = 'whatever'
self._test_exception(
'send_file', (
expected_sess_id,
FILE_CONTENT,
'program',
), coreExc.SessionNotFoundError, MESSAGE, 'ZSI:' +
UserProcessingRFCodes.CLIENT_SESSION_NOT_FOUND_EXCEPTION_CODE,
MESSAGE)
self._test_exception(
'send_file', (
expected_sess_id,
FILE_CONTENT,
'program',
), coreExc.NoCurrentReservationError, MESSAGE, 'ZSI:' +
UserProcessingRFCodes.CLIENT_NO_CURRENT_RESERVATION_EXCEPTION_CODE,
MESSAGE)
self._test_general_exceptions('send_file', expected_sess_id,
FILE_CONTENT, 'program')
def test_get_reservation_status(self):
port = 15128
self.configurationManager._set_value(self.rfs.FACADE_JSON_PORT, port)
self.rfs.start()
try:
client = WebLabDeustoClient("http://localhost:%s/weblab/" % port)
expected_sess_id = SessionId.SessionId("whatever")
NUMBER = 5
expected_confirmed_reservation = Reservation.ConfirmedReservation("reservation_id", NUMBER, "{}", 'http://www.weblab.deusto.es/...', '')
self.mock_server.return_values['get_reservation_status'] = expected_confirmed_reservation
confirmed_reservation = client.get_reservation_status(expected_sess_id)
self.assertEquals(
expected_sess_id.id,
self.mock_server.arguments['get_reservation_status'][0]
)
self.assertEquals(
expected_confirmed_reservation.time,
confirmed_reservation.time
)
self.assertEquals(
expected_confirmed_reservation.status,
confirmed_reservation.status
)
finally:
self.rfs.stop()
def test_send_file_failed_to_send(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.FailedToInteractError,
self.reservation_processor.send_file, file_content,
file_info)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_command(self):
port = 15130
self.configurationManager._set_value(self.rfs.FACADE_JSON_PORT, port)
self.rfs.start()
try:
client = WebLabDeustoClient("http://localhost:%s/weblab/" % port)
expected_sess_id = SessionId.SessionId("whatever")
expected_request_command = Command.Command('my request command')
expected_response_command = Command.Command('my response command')
self.mock_server.return_values['send_command'] = expected_response_command
obtained_response_command = client.send_command(expected_sess_id, expected_request_command)
self.assertEquals(
expected_sess_id.id,
self.mock_server.arguments['send_command'][0]
)
self.assertEquals(
expected_request_command.get_command_string(),
self.mock_server.arguments['send_command'][1].get_command_string()
)
self.assertEquals(
expected_response_command.get_command_string(),
obtained_response_command.get_command_string()
)
finally:
self.rfs.stop()
def test_get_reservation_status(self):
self.configurationManager._set_value(self.rfs.FACADE_ZSI_PORT, 14128)
self.rfs.start()
try:
wds = UserProcessingWebLabDeustoSOAP("http://localhost:14128/weblab/soap/")
expected_sess_id = SessionId.SessionId("whatever")
NUMBER = 5
expected_confirmed_reservation = Reservation.ConfirmedReservation("reservation_id", NUMBER, "{}", 'http://www.weblab.deusto.es/...', '')
self.mock_server.return_values['get_reservation_status'] = expected_confirmed_reservation
confirmed_reservation = wds.get_reservation_status(expected_sess_id)
self.assertEquals(
expected_sess_id.id,
self.mock_server.arguments['get_reservation_status'][0]
)
self.assertEquals(
expected_confirmed_reservation.time,
confirmed_reservation.time
)
self.assertEquals(
expected_confirmed_reservation.status,
confirmed_reservation.status
)
finally:
self.rfs.stop()
def test_reserve_experiment(self):
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
exp_id = ExperimentId('this does not experiment','this neither')
self.assertRaises(
coreExc.UnknownExperimentIdError,
self.ups.reserve_experiment,
sess_id, exp_id, "{}", "{}", ClientAddress.ClientAddress("127.0.0.1")
)
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.CoordAddress.translate_address('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = self.ups.reserve_experiment(
sess_id, exp_id, "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
self.assertTrue( isinstance(reservation,Reservation.Reservation))
self.ups.logout(sess_id)
def test_get_reservation_info(self):
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_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.CoordAddress.translate_address('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = self.ups.reserve_experiment(
sess_id, exp_id, "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
reservation_info = self.ups.get_reservation_info(reservation.reservation_id)
self.assertEquals('ud-dummy', reservation_info.exp_name)
self.assertEquals('Dummy experiments', reservation_info.cat_name)
self.ups.logout(sess_id)
def test_send_async_command_session_not_found_in_lab(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_async_command(
SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError(
"problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.NoCurrentReservationError,
self.reservation_processor.send_async_command,
command)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_return_logout(self):
expected_sess_id = SessionId.SessionId("whatever")
self.mock_ups.return_values['logout'] = expected_sess_id
self.assertEquals(expected_sess_id.id,
self.rfm.logout(expected_sess_id).id)
self.assertEquals(expected_sess_id.id,
self.mock_ups.arguments['logout'][0].id)
def test_return_list_experiments(self):
expected_sess_id = SessionId.SessionId("whatever")
experiments_allowed = _generate_experiments_allowed()
self.mock_ups.return_values['list_experiments'] = experiments_allowed
self.assertEquals(experiments_allowed,
self.rfm.list_experiments(expected_sess_id))
self.assertEquals(expected_sess_id.id,
self.mock_ups.arguments['list_experiments'][0].id)
def test_return_extensible_login(self):
expected_sess_id = SessionId.SessionId("whatever")
self.mock_login.return_values[
'login_based_on_other_credentials'] = expected_sess_id
return_value = self.rfm.login_based_on_other_credentials(
"facebook", "(my credentials)")
self.assertEquals(expected_sess_id, return_value)
def test_return_login(self):
expected_sess_id = SessionId.SessionId("whatever")
expected_username = "******"
expected_password = "******"
self.mock_login.return_values['login'] = expected_sess_id
return_value = self.rfm.login(expected_username, expected_password)
self.assertEquals(expected_sess_id, return_value)
def test_get_experiment_use_by_id(self):
port = 15129
self.configurationManager._set_value(self.rfs.FACADE_JSON_PORT, port)
self.rfs.start()
try:
client = WebLabDeustoClient("http://localhost:%s/weblab/" % port)
expected_sess_id = SessionId.SessionId("whatever")
expected_reservation_id = SessionId.SessionId("foobar")
expected_alive_result = RunningReservationResult()
self.mock_server.return_values['get_experiment_use_by_id'] = expected_alive_result
obtained_result = client.get_experiment_use_by_id(expected_sess_id, expected_reservation_id)
self.assertEquals(RunningReservationResult(), obtained_result)
finally:
self.rfs.stop()
def _return_reserved(self):
self.lab_mock.reserve_experiment(
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
"{}", mocker.ANY)
self.mocker.result((SessionId.SessionId('my_lab_session_id'), 'ok',
'servexp:inst@mach'))
self.lab_mock.resolve_experiment_address('my_lab_session_id')
self.mocker.result(CoordAddress.CoordAddress("exp", "inst", "mach"))
self.mocker.count(1, 2)
def test_return_poll(self):
expected_sess_id = SessionId.SessionId("whatever")
self.mock_ups.return_values['poll'] = None
self.rfm.poll(expected_sess_id)
self.assertEquals(expected_sess_id.id,
self.mock_ups.arguments['poll'][0].id)
def test_return_finished_experiment(self):
expected_sess_id = SessionId.SessionId("whatever")
self.mock_ups.return_values['finished_experiment'] = None
self.rfm.finished_experiment(expected_sess_id)
self.assertEquals(expected_sess_id.id,
self.mock_ups.arguments['finished_experiment'][0].id)
def setUp(self):
self._cfg_manager = ConfigurationManager.ConfigurationManager()
self._cfg_manager.append_module(configuration_module)
self.RESERVATION_ID = "my_reservation_id"
self.RESERVATION_SESS_ID = SessionId.SessionId(self.RESERVATION_ID)
self.LAB_SESS_ID = "my_lab_sess_id"
self.ANY_COORD_ADDR = CoordAddress.CoordAddress.translate_address(
'myserver:myprocess@mymachine')
self.LAB_COORD_ADDR = self.ANY_COORD_ADDR
def test_exception_get_user_information(self):
MESSAGE = "The exception message"
expected_sess_id = SessionId.SessionId("whatever")
self._test_exception(
'get_user_information', (expected_sess_id, ),
coreExc.SessionNotFoundError, MESSAGE, 'ZSI:' +
UserProcessingRFCodes.CLIENT_SESSION_NOT_FOUND_EXCEPTION_CODE,
MESSAGE)
self._test_general_exceptions('get_user_information', expected_sess_id)
def do_retrieve_results(self, session_id):
sess_id = SessionId.SessionId(session_id)
session = self._session_manager.get_session_locking(sess_id)
try:
proxy_session_handler = self._load_proxy_session_handler(session)
try:
return proxy_session_handler.retrieve_results()
finally:
proxy_session_handler.update_latest_timestamp()
finally:
self._session_manager.delete_session_unlocking(sess_id)
def create_reservation_processor(self, faking_response=False):
if faking_response:
self._fake_simple_lab_response()
status = self.user_processor.reserve_experiment(
ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
self.reservation_processor = ReservationProcessor(
self.cfg_manager,
SessionId.SessionId(status.reservation_id.split(';')[0]), {
'session_polling':
(time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET),
'latest_timestamp':
0,
'experiment_id':
ExperimentId('ud-dummy', 'Dummy experiments'),
'creator_session_id':
'',
'reservation_id':
SessionId.SessionId(status.reservation_id.split(';')[0]),
}, self.coordinator, self.locator, self.commands_store)
