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 _wait_reservation(self, reservation_id, expected_server_info, finish): max_timeout = 10 initial_time = time.time() reservation_status = self.consumer_client.get_reservation_status( reservation_id) while reservation_status.status in (Reservation.WAITING, Reservation.WAITING_CONFIRMATION): if time.time() - initial_time > max_timeout: self.fail("Waiting too long in the queue for %s" % expected_server_info) time.sleep(0.1) reservation_status = self.consumer_client.get_reservation_status( reservation_id) self.assertEquals(Reservation.CONFIRMED, reservation_status.status) experiment_reservation_id = reservation_status.remote_reservation_id if experiment_reservation_id.id == '': experiment_reservation_id = reservation_id client = WebLabDeustoClient(reservation_status.url) response = client.send_command(experiment_reservation_id, Command("server_info")) self.assertEquals(expected_server_info, response.get_command_string()) if finish: self.consumer_client.finished_experiment(reservation_id) return reservation_id
def _wait_reservation(self, reservation_id, expected_server_info, finish): max_timeout = 10 initial_time = time.time() reservation_status = self.consumer_client.get_reservation_status(reservation_id) while reservation_status.status in (Reservation.WAITING, Reservation.WAITING_CONFIRMATION): if time.time() - initial_time > max_timeout: self.fail("Waiting too long in the queue for %s" % expected_server_info) time.sleep(0.1) reservation_status = self.consumer_client.get_reservation_status(reservation_id) self.assertEquals(Reservation.CONFIRMED, reservation_status.status) experiment_reservation_id = reservation_status.remote_reservation_id if experiment_reservation_id.id == '': experiment_reservation_id = reservation_id client = WebLabDeustoClient( reservation_status.url ) response = client.send_command(experiment_reservation_id, Command("server_info")) self.assertEquals(expected_server_info, response.get_command_string()) if finish: self.consumer_client.finished_experiment(reservation_id) return reservation_id
def do_full_experiment_use(): """ Uses the configured experiment trying to resemble the way a human would do it. This method will block for a while. :return: """ wc = WebLabDeustoClient(config.WEBLAB_BASE_URL) sessionid = wc.login(config.LOGIN, config.PASSWORD) if not sessionid: raise Exception("Wrong login") # Reserve the flash dummy experiment. experiment_id = ExperimentId(config.EXP_NAME, config.EXP_CATEGORY) waiting = wc.reserve_experiment(sessionid, experiment_id, "{}", "{}", None) # print "Reserve response: %r" % waiting reservation_id = waiting.reservation_id while True: status = wc.get_reservation_status(reservation_id) # print "Reservation status: %r" % status if type(status) is WaitingReservation: time.sleep(0.5) elif type(status) is ConfirmedReservation: break elif type(status) is WaitingConfirmationReservation: time.sleep(0.5) else: print "Unknown reservation status." print "Experiment reserved." global users_in users_in += 1 # Send some commands. for i in range(config.COMMANDS_PER_USER): # What's commandstring actually for?? cmd = Command(config.COMMAND) result = wc.send_command(reservation_id, cmd) if not result.commandstring.startswith("Received command"): raise Exception("Unrecognized command response") # print "Command result: %r" % result time.sleep(config.TIME_BETWEEN_COMMANDS) users_in -= 1 result = wc.logout(sessionid) print "Logout result: %r" % result
class IntegrationNoConcurrencyTestCase(object): def setUp(self): self.global_config = load_dir(self.DEPLOYMENT_DIR) self.process_handlers = [] for process in self.PROCESSES: process_handler = self.global_config.load_process('myhost', process) self.process_handlers.append(process_handler) self.core_server = GLOBAL_REGISTRY[self.CORE_ADDRESS] self.experiment_dummy1 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY1] self.experiment_dummy2 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY2] self.core_config = self.core_server.config self.client = WebLabDeustoClient('http://localhost:%s/weblab/' % self.core_config[configuration_doc.CORE_FACADE_PORT]) def tearDown(self): GLOBAL_REGISTRY.clear() for process_handler in self.process_handlers: process_handler.stop() def test_simple_single_uses(self): for _ in range(1): self._single_use() self._single_use() self._single_use() def _single_use(self, logout = True, plus_async_use = True): """ Will use an experiment. @param logout If true, the user will be logged out after the use. Otherwise not. @param plus_async_use If true, after using the experiment synchronously, it will use it again using the asynchronous versions of the send_command and send_file requests. """ self._single_sync_use(logout) if plus_async_use: self._single_async_use(logout) def _single_sync_use(self, logout = True): session_id, reservation_id = self._get_reserved() CONTENT = "content of the program FPGA" response = self.client.send_file(reservation_id, ExperimentUtil.serialize(CONTENT), 'program') self.assertEquals(response.commandstring, 'ack') response = self.client.send_command(reservation_id, Command.Command("STATE")) self.assertEquals(response.commandstring, 'STATE') response = self.client.send_command(reservation_id, Command.Command("ChangeSwitch on 0")) self.assertEquals(response.commandstring, "ChangeSwitch on 0") if logout: self.client.logout(session_id) def _get_reserved(self): session_id = self.client.login('intstudent1', 'password') user_information = self.client.get_user_information(session_id) self.assertEquals( 'intstudent1', user_information.login) self.assertEquals( 'Name of integration test 1', user_information.full_name) self.assertEquals( '*****@*****.**', user_information.email) experiments = self.client.list_experiments(session_id) self.assertEquals( 2, len(experiments)) dummy1_experiments = [ exp.experiment for exp in experiments if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy1_experiments), 1) dummy1_experiment = dummy1_experiments[0] status = self.client.reserve_experiment(session_id, dummy1_experiment.to_experiment_id(), "{}", "{}") reservation_id = status.reservation_id # wait until it is reserved short_time = 0.1 # Time extended from 9.0 to 15.0 because at times the test failed, possibly for that reason. times = 15.0 / short_time while times > 0: new_status = self.client.get_reservation_status(reservation_id) if not isinstance(new_status, Reservation.WaitingConfirmationReservation) and not isinstance(new_status, Reservation.WaitingReservation): break times -= 1 time.sleep(short_time) reservation = self.client.get_reservation_status(reservation_id) self.assertTrue( isinstance(reservation, Reservation.ConfirmedReservation), "Reservation %s is not Confirmed, as expected by this time" % reservation ) return session_id, reservation_id def _single_async_use(self, logout = True): session_id, reservation_id = self._get_reserved() # send the program again, but asynchronously. Though this should work, it is not really very customary # to send_file more than once in the same session. In fact, it is a feature which might get removed in # the future. When/if that happens, this will need to be modified. CONTENT = "content of the program FPGA" reqid = self.client.send_async_file(reservation_id, ExperimentUtil.serialize(CONTENT), 'program') # Wait until send_async_file query is actually finished. #self._get_async_response(session_id, reqid) self._wait_async_done(reservation_id, (reqid,)) # We need to wait for the programming to finish, while at the same # time making sure that the tests don't dead-lock. reqid = self.client.send_async_command(reservation_id, Command.Command("STATE")) respcmd = self._get_async_response(reservation_id, reqid) response = respcmd.get_command_string() # Check that the current state is "Ready" self.assertEquals("STATE", response) reqid = self.client.send_async_command(reservation_id, Command.Command("ChangeSwitch on 0")) self._wait_async_done(reservation_id, (reqid,)) reqid = self.client.send_async_command(reservation_id, Command.Command("ClockActivation on 250")) self._wait_async_done(reservation_id, (reqid,)) if logout: self.client.logout(session_id) def _wait_async_done(self, reservation_id, reqids): """ _wait_async_done(session_id, reqids) Helper methods that waits for the specified asynchronous requests to be finished, and which asserts that they were successful. Note that it doesn't actually return their responses. @param reqids Tuple containing the request ids for the commands to check. @return Nothing """ # Wait until send_async_file query is actually finished. reqsl = list(reqids) max_count = 15 while len(reqsl) > 0: time.sleep(0.1) max_count -= 1 if max_count == 0: raise Exception("Maximum time spent waiting async done") requests = self.client.check_async_command_status(reservation_id, tuple(reqsl)) self.assertEquals(len(reqsl), len(requests)) for rid, req in six.iteritems(requests): status = req[0] self.assertTrue(status in ("running", "ok", "error")) if status != "running": self.assertEquals("ok", status, "Contents: " + req[1]) reqsl.remove(rid) def _get_async_response(self, reservation_id, reqid): """ _get_async_response(reqids) Helper method that synchronously gets the response for the specified async request, asserting that it was successful. @param reqid The request identifier for the async request whose response we want @return Response to the request, if successful. None, otherwise. """ # Wait until send_async_file query is actually finished. max_counter = 15 while True: max_counter -= 1 if max_counter == 0: raise Exception("Maximum times running get_async_response") time.sleep(0.1) requests = self.client.check_async_command_status(reservation_id, (reqid,)) self.assertEquals(1, len(requests)) self.assertTrue(reqid in requests) req = requests[reqid] status = req[0] self.assertTrue(status in ("running", "ok", "error")) if status != "running": self.assertEquals("ok", status, "Contents: " + req[1]) return Command.Command(req[1]) def test_single_uses_timeout(self): core_experiment_poll_time = 1.5 core_time_between_checks = 1.5 self.core_config._set_value('core_experiment_poll_time', core_experiment_poll_time) self.core_config._set_value('core_time_between_checks', core_time_between_checks) self._single_use(logout = False, plus_async_use = False) time.sleep(core_experiment_poll_time + 0.3 + core_time_between_checks) self._single_use(logout = False, plus_async_use = False) def test_two_multiple_uses_of_different_devices(self): user1_session_id = self.client.login('intstudent1','password') user1_experiments = self.client.list_experiments(user1_session_id) self.assertEquals( 2, len(user1_experiments)) dummy1_experiments = [ exp.experiment for exp in user1_experiments if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy1_experiments), 1) # reserve it status = self.client.reserve_experiment( user1_session_id, dummy1_experiments[0].to_experiment_id(), "{}", "{}") user1_reservation_id = status.reservation_id user2_session_id = self.client.login('intstudent2','password') user2_experiments = self.client.list_experiments(user2_session_id) self.assertEquals( 2, len(user2_experiments)) dummy2_experiments = [ exp.experiment for exp in user2_experiments if exp.experiment.name == 'dummy2' ] self.assertEquals( len(dummy2_experiments), 1) # reserve it status = self.client.reserve_experiment(user2_session_id, dummy2_experiments[0].to_experiment_id(), "{}", "{}") user2_reservation_id = status.reservation_id short_time = 0.1 times = 9.0 / short_time while times > 0: time.sleep(short_time) new_status1 = self.client.get_reservation_status(user1_reservation_id) new_status2 = self.client.get_reservation_status(user2_reservation_id) if not isinstance(new_status1, Reservation.WaitingConfirmationReservation): if not isinstance(new_status2, Reservation.WaitingConfirmationReservation): break times -= 1 self.assertTrue(isinstance(self.client.get_reservation_status(user1_reservation_id), Reservation.ConfirmedReservation)) self.assertTrue(isinstance(self.client.get_reservation_status(user2_reservation_id), Reservation.ConfirmedReservation)) # send a program CONTENT1 = "content of the program DUMMY1" response = self.client.send_file(user1_reservation_id, ExperimentUtil.serialize(CONTENT1), 'program') self.assertEquals('ack', response.commandstring) # We need to wait for the programming to finish. respcmd = self.client.send_command(user1_reservation_id, Command.Command("STATE DUMMY1")) response = respcmd.get_command_string() # Check that the current state is "Ready" self.assertEquals("STATE DUMMY1", response) CONTENT2 = "content of the program PLD" response = self.client.send_file(user2_reservation_id, ExperimentUtil.serialize(CONTENT2), 'program') self.assertEquals('ack', response.commandstring) # We need to wait for the programming to finish. respcmd = self.client.send_command(user2_reservation_id, Command.Command("STATE DUMMY2")) # Check that the current state is "Ready" self.assertEquals("STATE DUMMY2", respcmd.commandstring) # end session self.client.logout(user1_session_id) self.client.logout(user2_session_id)
def run(self): assertions = [] times = [] print "Starting process" reservation_id = None try: weblab = WebLabDeustoClient(self.url) session_id = weblab.login(self.username, self.password) reservation = weblab.reserve_experiment(session_id, ExperimentId("visir", "Visir experiments"), "{}", "{}") while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING): time.sleep(1) reservation = weblab.get_reservation_status( reservation.reservation_id ) if reservation.status != Reservation.CONFIRMED: raise Exception("Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status)) print "Confirmed reservation, starting..." reservation_id = reservation.reservation_id response = weblab.send_command(reservation_id, Command("GIVE_ME_SETUP_DATA")) cookie = json.loads(response.commandstring)['cookie'] login_response = weblab.send_command(reservation_id, Command(visir_commands.visir_login_request % cookie)) visir_sessionid = visir_commands.parse_login_response(login_response) for _ in xrange(self.executions): before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_11k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) assertions.append(AssertionResult(11000.0, 200, result)) times.append(after - before) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_rectifier % visir_sessionid)) after = time.time() # Don't know how to measure the response, but at least check that the response is a valid VISIR response result = visir_commands.parse_command_response(response, 'dmm_resolution') assertions.append(AssertionResult(3.5, 200, result)) times.append(after - before) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_900 % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) assertions.append(AssertionResult(900.0, 200, result)) times.append(after - before) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_1k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) assertions.append(AssertionResult(1000.0, 200, result)) times.append(after - before) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_10k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) assertions.append(AssertionResult(10000.0, 200, result)) times.append(after - before) weblab.finished_experiment(reservation_id) except Exception as exception: if reservation_id is not None: try: weblab.finished_experiment(reservation_id) loggedout = True except: loggedout = False else: loggedout = "no id provided" print "Finished with exception and logged out: %s" % loggedout traceback.print_exc() return TesterResult(True, assertions, exception, times) else: print "Finished without exception" return TesterResult(any(map(lambda assertion : assertion.failed, assertions)), assertions, None, times)
class IntegrationNoConcurrencyTestCase(object): def setUp(self): GLOBAL_REGISTRY.clear() self.global_config = load_dir(self.DEPLOYMENT_DIR) self.process_handlers = [] for process in self.PROCESSES: process_handler = self.global_config.load_process( 'myhost', process) self.process_handlers.append(process_handler) self.core_server = GLOBAL_REGISTRY[self.CORE_ADDRESS] self.experiment_dummy1 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY1] self.experiment_dummy2 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY2] self.core_config = self.core_server.config self.client = WebLabDeustoClient( 'http://localhost:%s/weblab/' % self.core_config[configuration_doc.CORE_FACADE_PORT]) def tearDown(self): GLOBAL_REGISTRY.clear() for process_handler in self.process_handlers: process_handler.stop() def test_simple_single_uses(self): for _ in range(1): self._single_use() self._single_use() self._single_use() def _single_use(self, logout=True, plus_async_use=True): """ Will use an experiment. @param logout If true, the user will be logged out after the use. Otherwise not. @param plus_async_use If true, after using the experiment synchronously, it will use it again using the asynchronous versions of the send_command and send_file requests. """ self._single_sync_use(logout) if plus_async_use: self._single_async_use(logout) def _single_sync_use(self, logout=True): session_id, reservation_id = self._get_reserved() CONTENT = "content of the program FPGA" response = self.client.send_file(reservation_id, ExperimentUtil.serialize(CONTENT), 'program') self.assertEquals(response.commandstring, 'ack') response = self.client.send_command(reservation_id, Command.Command("STATE")) self.assertEquals(response.commandstring, 'STATE') response = self.client.send_command( reservation_id, Command.Command("ChangeSwitch on 0")) self.assertEquals(response.commandstring, "ChangeSwitch on 0") if logout: self.client.logout(session_id) def _get_reserved(self): session_id = self.client.login('intstudent1', 'password') user_information = self.client.get_user_information(session_id) self.assertEquals('intstudent1', user_information.login) self.assertEquals('Name of integration test 1', user_information.full_name) self.assertEquals('*****@*****.**', user_information.email) experiments = self.client.list_experiments(session_id) self.assertEquals(2, len(experiments)) dummy1_experiments = [ exp.experiment for exp in experiments if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy1_experiments), 1) dummy1_experiment = dummy1_experiments[0] status = self.client.reserve_experiment( session_id, dummy1_experiment.to_experiment_id(), "{}", "{}") reservation_id = status.reservation_id # wait until it is reserved short_time = 0.1 # Time extended from 9.0 to 15.0 because at times the test failed, possibly for that reason. times = 15.0 / short_time while times > 0: new_status = self.client.get_reservation_status(reservation_id) if not isinstance( new_status, Reservation.WaitingConfirmationReservation ) and not isinstance(new_status, Reservation.WaitingReservation): break times -= 1 time.sleep(short_time) reservation = self.client.get_reservation_status(reservation_id) self.assertTrue( isinstance(reservation, Reservation.ConfirmedReservation), "Reservation %s is not Confirmed, as expected by this time" % reservation) return session_id, reservation_id def _single_async_use(self, logout=True): session_id, reservation_id = self._get_reserved() # send the program again, but asynchronously. Though this should work, it is not really very customary # to send_file more than once in the same session. In fact, it is a feature which might get removed in # the future. When/if that happens, this will need to be modified. CONTENT = "content of the program FPGA" reqid = self.client.send_async_file(reservation_id, ExperimentUtil.serialize(CONTENT), 'program') # Wait until send_async_file query is actually finished. #self._get_async_response(session_id, reqid) self._wait_async_done(reservation_id, (reqid, )) # We need to wait for the programming to finish, while at the same # time making sure that the tests don't dead-lock. reqid = self.client.send_async_command(reservation_id, Command.Command("STATE")) respcmd = self._get_async_response(reservation_id, reqid) response = respcmd.get_command_string() # Check that the current state is "Ready" self.assertEquals("STATE", response) reqid = self.client.send_async_command( reservation_id, Command.Command("ChangeSwitch on 0")) self._wait_async_done(reservation_id, (reqid, )) reqid = self.client.send_async_command( reservation_id, Command.Command("ClockActivation on 250")) self._wait_async_done(reservation_id, (reqid, )) if logout: self.client.logout(session_id) def _wait_async_done(self, reservation_id, reqids): """ _wait_async_done(session_id, reqids) Helper methods that waits for the specified asynchronous requests to be finished, and which asserts that they were successful. Note that it doesn't actually return their responses. @param reqids Tuple containing the request ids for the commands to check. @return Nothing """ # Wait until send_async_file query is actually finished. reqsl = list(reqids) max_count = 15 while len(reqsl) > 0: time.sleep(0.1) max_count -= 1 if max_count == 0: raise Exception("Maximum time spent waiting async done") requests = self.client.check_async_command_status( reservation_id, tuple(reqsl)) self.assertEquals(len(reqsl), len(requests)) for rid, req in six.iteritems(requests): status = req[0] self.assertTrue(status in ("running", "ok", "error")) if status != "running": self.assertEquals("ok", status, "Contents: " + req[1]) reqsl.remove(rid) def _get_async_response(self, reservation_id, reqid): """ _get_async_response(reqids) Helper method that synchronously gets the response for the specified async request, asserting that it was successful. @param reqid The request identifier for the async request whose response we want @return Response to the request, if successful. None, otherwise. """ # Wait until send_async_file query is actually finished. max_counter = 15 while True: max_counter -= 1 if max_counter == 0: raise Exception("Maximum times running get_async_response") time.sleep(0.1) requests = self.client.check_async_command_status( reservation_id, (reqid, )) self.assertEquals(1, len(requests)) self.assertTrue(reqid in requests) req = requests[reqid] status = req[0] self.assertTrue(status in ("running", "ok", "error")) if status != "running": self.assertEquals("ok", status, "Contents: " + req[1]) return Command.Command(req[1]) def test_single_uses_timeout(self): core_experiment_poll_time = 1.5 core_time_between_checks = 1.5 self.core_config._set_value('core_experiment_poll_time', core_experiment_poll_time) self.core_config._set_value('core_time_between_checks', core_time_between_checks) self._single_use(logout=False, plus_async_use=False) time.sleep(core_experiment_poll_time + 0.3 + core_time_between_checks) self._single_use(logout=False, plus_async_use=False) def test_two_multiple_uses_of_different_devices(self): user1_session_id = self.client.login('intstudent1', 'password') user1_experiments = self.client.list_experiments(user1_session_id) self.assertEquals(2, len(user1_experiments)) dummy1_experiments = [ exp.experiment for exp in user1_experiments if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy1_experiments), 1) # reserve it status = self.client.reserve_experiment( user1_session_id, dummy1_experiments[0].to_experiment_id(), "{}", "{}") user1_reservation_id = status.reservation_id user2_session_id = self.client.login('intstudent2', 'password') user2_experiments = self.client.list_experiments(user2_session_id) self.assertEquals(2, len(user2_experiments)) dummy2_experiments = [ exp.experiment for exp in user2_experiments if exp.experiment.name == 'dummy2' ] self.assertEquals(len(dummy2_experiments), 1) # reserve it status = self.client.reserve_experiment( user2_session_id, dummy2_experiments[0].to_experiment_id(), "{}", "{}") user2_reservation_id = status.reservation_id short_time = 0.1 times = 9.0 / short_time while times > 0: time.sleep(short_time) new_status1 = self.client.get_reservation_status( user1_reservation_id) new_status2 = self.client.get_reservation_status( user2_reservation_id) if not isinstance(new_status1, Reservation.WaitingConfirmationReservation): if not isinstance(new_status2, Reservation.WaitingConfirmationReservation): break times -= 1 self.assertTrue( isinstance( self.client.get_reservation_status(user1_reservation_id), Reservation.ConfirmedReservation)) self.assertTrue( isinstance( self.client.get_reservation_status(user2_reservation_id), Reservation.ConfirmedReservation)) # send a program CONTENT1 = "content of the program DUMMY1" response = self.client.send_file(user1_reservation_id, ExperimentUtil.serialize(CONTENT1), 'program') self.assertEquals('ack', response.commandstring) # We need to wait for the programming to finish. respcmd = self.client.send_command(user1_reservation_id, Command.Command("STATE DUMMY1")) response = respcmd.get_command_string() # Check that the current state is "Ready" self.assertEquals("STATE DUMMY1", response) CONTENT2 = "content of the program PLD" response = self.client.send_file(user2_reservation_id, ExperimentUtil.serialize(CONTENT2), 'program') self.assertEquals('ack', response.commandstring) # We need to wait for the programming to finish. respcmd = self.client.send_command(user2_reservation_id, Command.Command("STATE DUMMY2")) # Check that the current state is "Ready" self.assertEquals("STATE DUMMY2", respcmd.commandstring) # end session self.client.logout(user1_session_id) self.client.logout(user2_session_id)
class IntegrationMultipleUsersTestCase(object): def setUp(self): self.global_config = load_dir(self.DEPLOYMENT_DIR) self.process_handlers = [] for process in self.PROCESSES: process_handler = self.global_config.load_process('myhost', process) self.process_handlers.append(process_handler) self.core_server = GLOBAL_REGISTRY[self.CORE_ADDRESS] self.experiment_dummy1 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY1] self.experiment_dummy2 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY2] self.core_config = self.core_server.config self.client = WebLabDeustoClient('http://localhost:%s/weblab/' % self.core_config[configuration_doc.CORE_FACADE_PORT]) def tearDown(self): GLOBAL_REGISTRY.clear() for process_handler in self.process_handlers: process_handler.stop() def test_single_uses_timeout(self): # 6 users get into the system session_id1 = self.client.login('intstudent1','password') session_id2 = self.client.login('intstudent2','password') session_id3 = self.client.login('intstudent3','password') session_id4 = self.client.login('intstudent4','password') session_id5 = self.client.login('intstudent5','password') session_id6 = self.client.login('intstudent6','password') # they all have access to the ud-fpga experiment experiments1 = self.client.list_experiments(session_id1) dummy_experiments1 = [ exp.experiment for exp in experiments1 if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy_experiments1), 1 ) experiments2 = self.client.list_experiments(session_id2) dummy_experiments2 = [ exp.experiment for exp in experiments2 if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy_experiments2), 1 ) experiments3 = self.client.list_experiments(session_id3) dummy_experiments3 = [ exp.experiment for exp in experiments3 if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy_experiments3), 1 ) experiments4 = self.client.list_experiments(session_id4) dummy_experiments4 = [ exp.experiment for exp in experiments4 if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy_experiments4), 1 ) experiments5 = self.client.list_experiments(session_id5) dummy_experiments5 = [ exp.experiment for exp in experiments5 if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy_experiments5), 1 ) experiments6 = self.client.list_experiments(session_id6) dummy_experiments6 = [ exp.experiment for exp in experiments6 if exp.experiment.name == 'dummy1' ] self.assertEquals( len(dummy_experiments6), 1 ) # 3 users try to reserve the experiment status1 = self.client.reserve_experiment(session_id1, dummy_experiments1[0].to_experiment_id(), "{}", "{}") reservation_id1 = status1.reservation_id status2 = self.client.reserve_experiment(session_id2, dummy_experiments2[0].to_experiment_id(), "{}", "{}") reservation_id2 = status2.reservation_id status3 = self.client.reserve_experiment(session_id3, dummy_experiments3[0].to_experiment_id(), "{}", "{}") reservation_id3 = status3.reservation_id # wait until it is reserved short_time = 0.1 times = 10.0 / short_time while times > 0: time.sleep(short_time) new_status = self.client.get_reservation_status(reservation_id1) if not isinstance(new_status, Reservation.WaitingConfirmationReservation): break times -= 1 # first user got the device. The other two are in WaitingReservation reservation1 = self.client.get_reservation_status(reservation_id1) self.assertTrue(isinstance(reservation1, Reservation.ConfirmedReservation)) reservation2 = self.client.get_reservation_status(reservation_id2) self.assertTrue(isinstance(reservation2, Reservation.WaitingReservation)) self.assertEquals( 0, reservation2.position) reservation3 = self.client.get_reservation_status(reservation_id3) self.assertTrue(isinstance(reservation3, Reservation.WaitingReservation)) self.assertEquals( 1, reservation3.position) # Another user tries to reserve the experiment. He goes to the WaitingReservation, position 2 status4 = self.client.reserve_experiment(session_id4, dummy_experiments4[0].to_experiment_id(), "{}", "{}") reservation_id4 = status4.reservation_id reservation4 = self.client.get_reservation_status(reservation_id4) self.assertTrue(isinstance( reservation4, Reservation.WaitingReservation)) self.assertEquals( 2, reservation4.position) # The state of other users does not change reservation1 = self.client.get_reservation_status(reservation_id1) self.assertTrue(isinstance( reservation1, Reservation.ConfirmedReservation)) reservation2 = self.client.get_reservation_status(reservation_id2) self.assertTrue(isinstance( reservation2, Reservation.WaitingReservation)) self.assertEquals( 0, reservation2.position) reservation3 = self.client.get_reservation_status(reservation_id3) self.assertTrue(isinstance(reservation3, Reservation.WaitingReservation)) self.assertEquals( 1, reservation3.position ) # The user number 2 frees the experiment self.client.finished_experiment(reservation_id2) # Whenever he tries to do poll or send_command, he receives an exception try: time.sleep(1) self.client.poll(reservation_id2) self.client.poll(reservation_id2) self.client.poll(reservation_id2) except Exception as e: pass # All right :-) self.assertTrue("does not have any experiment" in repr(e)) else: self.fail("Expected exception when polling") # send a program CONTENT = "content of the program DUMMY1" self.client.send_file(reservation_id1, ExperimentUtil.serialize(CONTENT), 'program') # We need to wait for the programming to finish. response = self.client.send_command(reservation_id1, Command.Command("STATE")) self.assertEquals("STATE", response.commandstring) self.client.logout(session_id1)
while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING): time.sleep(1) reservation = weblab.get_reservation_status( reservation.reservation_id ) print ".", sys.stdout.flush() if reservation.status != Reservation.CONFIRMED: raise Exception("Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status)) print "[done]" sys.stdout.flush() print "Confirmed reservation, programming file..." sys.stdout.flush() reservation_id = reservation.reservation_id # # This code here is Robot dependent. Replace it with your code to check it. # response = weblab.send_command(reservation_id, Command("program:Interactive Demo")) if response == 'File sended & running': print "File programmed. Exiting." sys.stdout.flush() weblab.finished_experiment(reservation_id) print "Finished testing %s times" % N
def run(self): assertions = [] times = [] print "Starting process" reservation_id = None try: weblab = WebLabDeustoClient(self.url) session_id = weblab.login(self.username, self.password) reservation = weblab.reserve_experiment( session_id, ExperimentId(VISIR_EXPERIMENT, "Visir experiments"), "{}", "{}") while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING): time.sleep(1) reservation = weblab.get_reservation_status( reservation.reservation_id) if reservation.status != Reservation.CONFIRMED: raise Exception( "Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status)) print "Confirmed reservation, starting..." reservation_id = reservation.reservation_id initial_config = reservation.initial_configuration cookie = json.loads(initial_config)['cookie'] login_response = weblab.send_command( reservation_id, Command(visir_commands.visir_login_request % cookie)) visir_sessionid = visir_commands.parse_login_response( login_response) iteration = 0 for _ in xrange(self.executions): before = time.time() response = weblab.send_command( reservation_id, Command(visir_commands.visir_request_11k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar1 = AssertionResult(11000.0, 11000.0 * 0.2, result) if DEBUG and ar1.failed: print "[Failed at 1st]" + str(ar1) if not IGNORE_ASSERTIONS: assertions.append(ar1) times.append(after - before) # This command is currently commented out because it does not seem to be compatible with lxi_visir. # before = time.time() # response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_rectifier % visir_sessionid)) # after = time.time() # # Don't know how to measure the response, but at least check that the response is a valid VISIR response # result = visir_commands.parse_command_response(response, 'dmm_resolution') # assertions.append(AssertionResult(3.5, 200, result)) # times.append(after - before) time.sleep(1) before = time.time() response = weblab.send_command( reservation_id, Command(visir_commands.visir_request_900 % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar3 = AssertionResult(900.0, 900.0 * 0.2, result) if DEBUG and ar3.failed: print "[Failed at 3rd]" + str(ar3) if not IGNORE_ASSERTIONS: assertions.append(ar3) times.append(after - before) time.sleep(1) before = time.time() response = weblab.send_command( reservation_id, Command(visir_commands.visir_request_1k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar4 = AssertionResult(1000.0, 1000 * 0.2, result) if DEBUG and ar4.failed: print "[Failed at 4th]" + str(ar4) if not IGNORE_ASSERTIONS: assertions.append(ar4) times.append(after - before) time.sleep(1) before = time.time() response = weblab.send_command( reservation_id, Command(visir_commands.visir_request_10k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar5 = AssertionResult(10000.0, 10000 * 0.2, result) if DEBUG and ar5.failed: print "[Failed at 5th]" + str(ar5) if not IGNORE_ASSERTIONS: assertions.append(ar5) times.append(after - before) iteration += 1 time.sleep(1) weblab.finished_experiment(reservation_id) except Exception as exception: if reservation_id is not None: try: weblab.finished_experiment(reservation_id) loggedout = True except: loggedout = False else: loggedout = "no id provided" print "Finished with exception and logged out: %s" % loggedout traceback.print_exc() return TesterResult(True, assertions, exception, times) else: print "Finished without exception" return TesterResult( any(map(lambda assertion: assertion.failed, assertions)), assertions, None, times)
class IntegrationMultipleUsersTestCase(object): def setUp(self): self.global_config = load_dir(self.DEPLOYMENT_DIR) self.process_handlers = [] for process in self.PROCESSES: process_handler = self.global_config.load_process( 'myhost', process) self.process_handlers.append(process_handler) self.core_server = GLOBAL_REGISTRY[self.CORE_ADDRESS] self.experiment_dummy1 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY1] self.experiment_dummy2 = GLOBAL_REGISTRY[self.EXPERIMENT_DUMMY2] self.core_config = self.core_server.config self.client = WebLabDeustoClient( 'http://localhost:%s/weblab/' % self.core_config[configuration_doc.CORE_FACADE_PORT]) def tearDown(self): GLOBAL_REGISTRY.clear() for process_handler in self.process_handlers: process_handler.stop() def test_single_uses_timeout(self): # 6 users get into the system session_id1 = self.client.login('intstudent1', 'password') session_id2 = self.client.login('intstudent2', 'password') session_id3 = self.client.login('intstudent3', 'password') session_id4 = self.client.login('intstudent4', 'password') session_id5 = self.client.login('intstudent5', 'password') session_id6 = self.client.login('intstudent6', 'password') # they all have access to the ud-fpga experiment experiments1 = self.client.list_experiments(session_id1) dummy_experiments1 = [ exp.experiment for exp in experiments1 if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy_experiments1), 1) experiments2 = self.client.list_experiments(session_id2) dummy_experiments2 = [ exp.experiment for exp in experiments2 if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy_experiments2), 1) experiments3 = self.client.list_experiments(session_id3) dummy_experiments3 = [ exp.experiment for exp in experiments3 if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy_experiments3), 1) experiments4 = self.client.list_experiments(session_id4) dummy_experiments4 = [ exp.experiment for exp in experiments4 if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy_experiments4), 1) experiments5 = self.client.list_experiments(session_id5) dummy_experiments5 = [ exp.experiment for exp in experiments5 if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy_experiments5), 1) experiments6 = self.client.list_experiments(session_id6) dummy_experiments6 = [ exp.experiment for exp in experiments6 if exp.experiment.name == 'dummy1' ] self.assertEquals(len(dummy_experiments6), 1) # 3 users try to reserve the experiment status1 = self.client.reserve_experiment( session_id1, dummy_experiments1[0].to_experiment_id(), "{}", "{}") reservation_id1 = status1.reservation_id status2 = self.client.reserve_experiment( session_id2, dummy_experiments2[0].to_experiment_id(), "{}", "{}") reservation_id2 = status2.reservation_id status3 = self.client.reserve_experiment( session_id3, dummy_experiments3[0].to_experiment_id(), "{}", "{}") reservation_id3 = status3.reservation_id # wait until it is reserved short_time = 0.1 times = 10.0 / short_time while times > 0: time.sleep(short_time) new_status = self.client.get_reservation_status(reservation_id1) if not isinstance(new_status, Reservation.WaitingConfirmationReservation): break times -= 1 # first user got the device. The other two are in WaitingReservation reservation1 = self.client.get_reservation_status(reservation_id1) self.assertTrue( isinstance(reservation1, Reservation.ConfirmedReservation)) reservation2 = self.client.get_reservation_status(reservation_id2) self.assertTrue( isinstance(reservation2, Reservation.WaitingReservation)) self.assertEquals(0, reservation2.position) reservation3 = self.client.get_reservation_status(reservation_id3) self.assertTrue( isinstance(reservation3, Reservation.WaitingReservation)) self.assertEquals(1, reservation3.position) # Another user tries to reserve the experiment. He goes to the WaitingReservation, position 2 status4 = self.client.reserve_experiment( session_id4, dummy_experiments4[0].to_experiment_id(), "{}", "{}") reservation_id4 = status4.reservation_id reservation4 = self.client.get_reservation_status(reservation_id4) self.assertTrue( isinstance(reservation4, Reservation.WaitingReservation)) self.assertEquals(2, reservation4.position) # The state of other users does not change reservation1 = self.client.get_reservation_status(reservation_id1) self.assertTrue( isinstance(reservation1, Reservation.ConfirmedReservation)) reservation2 = self.client.get_reservation_status(reservation_id2) self.assertTrue( isinstance(reservation2, Reservation.WaitingReservation)) self.assertEquals(0, reservation2.position) reservation3 = self.client.get_reservation_status(reservation_id3) self.assertTrue( isinstance(reservation3, Reservation.WaitingReservation)) self.assertEquals(1, reservation3.position) # The user number 2 frees the experiment self.client.finished_experiment(reservation_id2) # Whenever he tries to do poll or send_command, he receives an exception try: time.sleep(1) self.client.poll(reservation_id2) self.client.poll(reservation_id2) self.client.poll(reservation_id2) except Exception as e: pass # All right :-) self.assertTrue("does not have any experiment" in repr(e)) else: self.fail("Expected exception when polling") # send a program CONTENT = "content of the program DUMMY1" self.client.send_file(reservation_id1, ExperimentUtil.serialize(CONTENT), 'program') # We need to wait for the programming to finish. response = self.client.send_command(reservation_id1, Command.Command("STATE")) self.assertEquals("STATE", response.commandstring) self.client.logout(session_id1)
def run(self): assertions = [] times = [] print "Starting process" reservation_id = None try: weblab = WebLabDeustoClient(self.url) session_id = weblab.login(self.username, self.password) reservation = weblab.reserve_experiment(session_id, ExperimentId(VISIR_EXPERIMENT, "Visir experiments"), "{}", "{}") while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING): time.sleep(1) reservation = weblab.get_reservation_status( reservation.reservation_id ) if reservation.status != Reservation.CONFIRMED: raise Exception("Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status)) print "Confirmed reservation, starting..." reservation_id = reservation.reservation_id initial_config = reservation.initial_configuration cookie = json.loads(initial_config)['cookie'] login_response = weblab.send_command(reservation_id, Command(visir_commands.visir_login_request % cookie)) visir_sessionid = visir_commands.parse_login_response(login_response) iteration = 0 for _ in xrange(self.executions): before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_11k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar1 = AssertionResult(11000.0, 11000.0 * 0.2, result) if DEBUG and ar1.failed: print "[Failed at 1st]" + str(ar1) if not IGNORE_ASSERTIONS: assertions.append(ar1) times.append(after - before) # This command is currently commented out because it does not seem to be compatible with lxi_visir. # before = time.time() # response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_rectifier % visir_sessionid)) # after = time.time() # # Don't know how to measure the response, but at least check that the response is a valid VISIR response # result = visir_commands.parse_command_response(response, 'dmm_resolution') # assertions.append(AssertionResult(3.5, 200, result)) # times.append(after - before) time.sleep(1) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_900 % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar3 = AssertionResult(900.0, 900.0 * 0.2, result) if DEBUG and ar3.failed: print "[Failed at 3rd]" + str(ar3) if not IGNORE_ASSERTIONS: assertions.append(ar3) times.append(after - before) time.sleep(1) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_1k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar4 = AssertionResult(1000.0, 1000 * 0.2, result) if DEBUG and ar4.failed: print "[Failed at 4th]" + str(ar4) if not IGNORE_ASSERTIONS: assertions.append(ar4) times.append(after - before) time.sleep(1) before = time.time() response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_10k % visir_sessionid)) after = time.time() result = visir_commands.parse_command_response(response) ar5 = AssertionResult(10000.0, 10000 * 0.2, result) if DEBUG and ar5.failed: print "[Failed at 5th]" + str(ar5) if not IGNORE_ASSERTIONS: assertions.append(ar5) times.append(after - before) iteration += 1 time.sleep(1) weblab.finished_experiment(reservation_id) except Exception as exception: if reservation_id is not None: try: weblab.finished_experiment(reservation_id) loggedout = True except: loggedout = False else: loggedout = "no id provided" print "Finished with exception and logged out: %s" % loggedout traceback.print_exc() return TesterResult(True, assertions, exception, times) else: print "Finished without exception" return TesterResult(any(map(lambda assertion : assertion.failed, assertions)), assertions, None, times)