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)