def test_finished_experiment(self): port = 15127 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") self.mock_server.return_values['finished_experiment'] = None client.finished_experiment(expected_sess_id) self.assertEquals( expected_sess_id.id, self.mock_server.arguments['finished_experiment'][0] ) finally: self.rfs.stop()
class AbstractFederatedWebLabDeustoTestCase(object): def setUp(self): # Clean the global registry of servers GLOBAL_REGISTRY.clear() CONSUMER_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/consumer/' PROVIDER1_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/provider1/' PROVIDER2_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/provider2/' self.consumer_handler = load_dir(CONSUMER_CONFIG_PATH).load_process('consumer_machine', 'main_instance' ) self.provider1_handler = load_dir(PROVIDER1_CONFIG_PATH).load_process('provider1_machine', 'main_instance' ) self.provider2_handler = load_dir(PROVIDER2_CONFIG_PATH).load_process('provider2_machine', 'main_instance' ) self.consumer_client = WebLabDeustoClient("http://127.0.0.1:%s/weblab/" % 18345) self.provider1_client = WebLabDeustoClient("http://127.0.0.1:%s/weblab/" % 28345) self.provider2_client = WebLabDeustoClient("http://127.0.0.1:%s/weblab/" % 38345) # dummy1: deployed in consumer, provider1, provider2 self.dummy1 = ExperimentId("dummy1", "Dummy experiments") # dummy2: deployed in consumer self.dummy2 = ExperimentId("dummy2", "Dummy experiments") # dummy3: deployed in provider1 as "dummy3_with_other_name" self.dummy3 = ExperimentId("dummy3", "Dummy experiments") # dummy4: deployed in provider2 self.dummy4 = ExperimentId("dummy4", "Dummy experiments") def tearDown(self): self.consumer_handler.stop() self.provider1_handler.stop() self.provider2_handler.stop() time.sleep(1) # # This test may take even 20-30 seconds; therefore it is not splitted # into subtests (the setup and teardown are long) # def test_federated_experiment(self): debug("Test test_federated_experiment starts") ####################################################### # # Local testing (to check that everything is right) # # We enter as a student of Consumer, and we ask for an # experiment that only the Consumer university has # (dummy2). # session_id = self.consumer_client.login('fedstudent1', 'password') reservation_id = self._test_reservation(session_id, self.dummy2, 'Consumer', True, True) self._wait_multiple_reservations(20, session_id, [ reservation_id ], [0]) reservation_result = self.consumer_client.get_experiment_use_by_id(session_id, reservation_id) self.assertTrue(reservation_result.is_finished()) self._find_command(reservation_result, 'Consumer') ####################################################### # # Simple federation # # Now we ask for an experiment that only Provider 1 # has. There is no load balance, neither # subcontracting # reservation_id = self._test_reservation(session_id, self.dummy3, 'Provider 1', True, True) self._wait_multiple_reservations(20, session_id, [ reservation_id ], [0]) reservation_result = self.consumer_client.get_experiment_use_by_id(session_id, reservation_id) self.assertTrue(reservation_result.is_finished()) self._find_command(reservation_result, 'Provider 1') ####################################################### # # Subcontracted federation # # Now we ask for an experiment that only Provider 2 # has. There is no load balance, but Consumer will # contact Provider 1, which will contact Provider 2 # reservation_id = self._test_reservation(session_id, self.dummy4, 'Provider 2', True, True) self._wait_multiple_reservations(20, session_id, [ reservation_id ], [0]) reservation_result = self.consumer_client.get_experiment_use_by_id(session_id, reservation_id) self.assertTrue(reservation_result.is_finished()) self._find_command(reservation_result, 'Provider 2') ####################################################### # # Cross-domain load balancing # # Now we ask for an experiment that Consumer has, # but also Provider 1 and Provider 2. # reservation_id1 = self._test_reservation(session_id, self.dummy1, 'Consumer', True, False, user_agent = 'Chrome') reservation_id2 = self._test_reservation(session_id, self.dummy1, 'Provider 1', True, False, user_agent = 'Firefox') reservation_id3 = self._test_reservation(session_id, self.dummy1, 'Provider 2', True, False, user_agent = 'Safari') reservation_ids = (reservation_id1, reservation_id2, reservation_id3) reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids) self.assertEquals(RunningReservationResult(), reservation_results[0]) self.assertEquals(RunningReservationResult(), reservation_results[1]) self.assertEquals(RunningReservationResult(), reservation_results[2]) # # What if one of them goes out and another comes? Is the load of experiments balanced correctly? # self.consumer_client.finished_experiment(reservation_id2) # Wait a couple of seconds to check that it has been propagated self._wait_multiple_reservations(20, session_id, reservation_ids, [1]) reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids) # The other two are still running self.assertEquals(RunningReservationResult(), reservation_results[0]) self.assertEquals(RunningReservationResult(), reservation_results[2]) # But the one finished is actually finished self.assertTrue( reservation_results[1].is_finished() ) self.assertEquals('Firefox', reservation_results[1].experiment_use.request_info['user_agent']) self.assertEquals(4, len(reservation_results[1].experiment_use.commands)) self.assertEquals('Provider 1', reservation_results[1].experiment_use.commands[2].response.commandstring) reservation_id2b = self._test_reservation(session_id, self.dummy1, 'Provider 1', True, False) self.consumer_client.finished_experiment(reservation_id1) self._test_reservation(session_id, self.dummy1, 'Consumer', True, False) reservation_status = self.consumer_client.get_reservation_status(reservation_id3) provider2_reservation_id = reservation_status.remote_reservation_id self.consumer_client.finished_experiment(reservation_id3) self._test_reservation(session_id, self.dummy1, 'Provider 2', True, False) # Check for the other uses self._wait_multiple_reservations(70, session_id, reservation_ids, [0,2]) reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids) self.assertTrue( reservation_results[0].is_finished() ) self.assertEquals('Chrome', reservation_results[0].experiment_use.request_info['user_agent']) self.assertEquals('Consumer', reservation_results[0].experiment_use.commands[2].response.commandstring) self.assertTrue( reservation_results[2].is_finished() ) self.assertEquals('Safari', reservation_results[2].experiment_use.request_info['user_agent']) self.assertEquals('Provider 2', reservation_results[2].experiment_use.commands[2].response.commandstring) provider2_session_id = self.provider2_client.login('provider1', 'password') provider2_result = self.provider2_client.get_experiment_use_by_id(provider2_session_id, provider2_reservation_id) self.assertTrue(provider2_result.is_finished()) self.assertEquals('Safari', provider2_result.experiment_use.request_info['user_agent']) # # What if another 2 come in? What is the position of their queues? # reservation_4 = self._test_reservation(session_id, self.dummy1, '', False, False) reservation_status = self.consumer_client.get_reservation_status(reservation_4) self.assertEquals(Reservation.WAITING, reservation_status.status) self.assertEquals(0, reservation_status.position) reservation_5 = self._test_reservation(session_id, self.dummy1, '', False, False) reservation_status = self.consumer_client.get_reservation_status(reservation_5) self.assertEquals(Reservation.WAITING, reservation_status.status) self.assertEquals(1, reservation_status.position) # # Once again, freeing a session affects them? # self.consumer_client.finished_experiment(reservation_id2b) self._wait_reservation(reservation_4, 'Provider 1', True) self.consumer_client.finished_experiment(reservation_4) self._wait_reservation(reservation_5, 'Provider 1', True) # Check for the other uses for _ in range(50): time.sleep(0.5) # Checking every half second results = self.consumer_client.get_experiment_uses_by_id(session_id, (reservation_id2b, reservation_4)) if results[0].is_finished() and results[1].is_finished(): break final_reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, (reservation_id2b, reservation_4)) self.assertTrue(final_reservation_results[0].is_finished()) self.assertTrue(final_reservation_results[1].is_finished()) self.assertEquals('Provider 1', final_reservation_results[0].experiment_use.commands[2].response.commandstring) self.assertEquals('Provider 1', final_reservation_results[1].experiment_use.commands[2].response.commandstring) debug("Test test_federated_experiment finishes successfully") def _wait_multiple_reservations(self, times, session_id, reservation_ids, reservations_to_wait): for _ in range(times): time.sleep(0.5) # Checking every half second results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids) all_finished = True for reservation_to_wait in reservations_to_wait: all_finished = all_finished and results[reservation_to_wait].is_finished() if all_finished: break def _find_command(self, reservation_result, expected_response): found = False commands = reservation_result.experiment_use.commands for command in commands: if command.command.commandstring == 'server_info': found = True response = command.response.commandstring self.assertEquals(expected_response, response, "Message %s not found in commands %s; instead found %s" % (expected_response, commands, response)) self.assertTrue(found, "server_info not found in commands") def _test_reservation(self, session_id, experiment_id, expected_server_info, wait, finish, user_agent = None): debug("Reserving with session_id %r a experiment %r; will I wait? %s; will I finish? %s" % (session_id, experiment_id, wait, finish)) reservation_status = self.consumer_client.reserve_experiment(session_id, experiment_id, "{}", "{}", user_agent = user_agent) reservation_id = reservation_status.reservation_id if not wait: if finish: debug("Finishing... %r" % reservation_id) self.consumer_client.finished_experiment(reservation_id) debug("Not waiting... %r" % reservation_id) return reservation_id reservation_id = self._wait_reservation(reservation_id, expected_server_info, finish) debug("Finished waiting... %r" % 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
class AbstractFederatedWebLabDeustoTestCase(object): def setUp(self): # Clean the global registry of servers GLOBAL_REGISTRY.clear() CONSUMER_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/consumer/' PROVIDER1_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/provider1/' PROVIDER2_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/provider2/' self.consumer_handler = load_dir(CONSUMER_CONFIG_PATH).load_process( 'consumer_machine', 'main_instance') self.provider1_handler = load_dir(PROVIDER1_CONFIG_PATH).load_process( 'provider1_machine', 'main_instance') self.provider2_handler = load_dir(PROVIDER2_CONFIG_PATH).load_process( 'provider2_machine', 'main_instance') self.consumer_client = WebLabDeustoClient( "http://127.0.0.1:%s/weblab/" % 18345) self.provider1_client = WebLabDeustoClient( "http://127.0.0.1:%s/weblab/" % 28345) self.provider2_client = WebLabDeustoClient( "http://127.0.0.1:%s/weblab/" % 38345) # dummy1: deployed in consumer, provider1, provider2 self.dummy1 = ExperimentId("dummy1", "Dummy experiments") # dummy2: deployed in consumer self.dummy2 = ExperimentId("dummy2", "Dummy experiments") # dummy3: deployed in provider1 as "dummy3_with_other_name" self.dummy3 = ExperimentId("dummy3", "Dummy experiments") # dummy4: deployed in provider2 self.dummy4 = ExperimentId("dummy4", "Dummy experiments") def tearDown(self): self.consumer_handler.stop() self.provider1_handler.stop() self.provider2_handler.stop() time.sleep(1) # # This test may take even 20-30 seconds; therefore it is not splitted # into subtests (the setup and teardown are long) # def test_federated_experiment(self): debug("Test test_federated_experiment starts") ####################################################### # # Local testing (to check that everything is right) # # We enter as a student of Consumer, and we ask for an # experiment that only the Consumer university has # (dummy2). # session_id = self.consumer_client.login('fedstudent1', 'password') reservation_id = self._test_reservation(session_id, self.dummy2, 'Consumer', True, True) self._wait_multiple_reservations(20, session_id, [reservation_id], [0]) reservation_result = self.consumer_client.get_experiment_use_by_id( session_id, reservation_id) self.assertTrue(reservation_result.is_finished()) self._find_command(reservation_result, 'Consumer') ####################################################### # # Simple federation # # Now we ask for an experiment that only Provider 1 # has. There is no load balance, neither # subcontracting # reservation_id = self._test_reservation(session_id, self.dummy3, 'Provider 1', True, True) self._wait_multiple_reservations(20, session_id, [reservation_id], [0]) reservation_result = self.consumer_client.get_experiment_use_by_id( session_id, reservation_id) self.assertTrue(reservation_result.is_finished()) self._find_command(reservation_result, 'Provider 1') ####################################################### # # Subcontracted federation # # Now we ask for an experiment that only Provider 2 # has. There is no load balance, but Consumer will # contact Provider 1, which will contact Provider 2 # reservation_id = self._test_reservation(session_id, self.dummy4, 'Provider 2', True, True) self._wait_multiple_reservations(20, session_id, [reservation_id], [0]) reservation_result = self.consumer_client.get_experiment_use_by_id( session_id, reservation_id) self.assertTrue(reservation_result.is_finished()) self._find_command(reservation_result, 'Provider 2') ####################################################### # # Cross-domain load balancing # # Now we ask for an experiment that Consumer has, # but also Provider 1 and Provider 2. # reservation_id1 = self._test_reservation(session_id, self.dummy1, 'Consumer', True, False, user_agent='Chrome') reservation_id2 = self._test_reservation(session_id, self.dummy1, 'Provider 1', True, False, user_agent='Firefox') reservation_id3 = self._test_reservation(session_id, self.dummy1, 'Provider 2', True, False, user_agent='Safari') reservation_ids = (reservation_id1, reservation_id2, reservation_id3) reservation_results = self.consumer_client.get_experiment_uses_by_id( session_id, reservation_ids) self.assertEquals(RunningReservationResult(), reservation_results[0]) self.assertEquals(RunningReservationResult(), reservation_results[1]) self.assertEquals(RunningReservationResult(), reservation_results[2]) # # What if one of them goes out and another comes? Is the load of experiments balanced correctly? # self.consumer_client.finished_experiment(reservation_id2) # Wait a couple of seconds to check that it has been propagated self._wait_multiple_reservations(20, session_id, reservation_ids, [1]) reservation_results = self.consumer_client.get_experiment_uses_by_id( session_id, reservation_ids) # The other two are still running self.assertEquals(RunningReservationResult(), reservation_results[0]) self.assertEquals(RunningReservationResult(), reservation_results[2]) # But the one finished is actually finished self.assertTrue(reservation_results[1].is_finished()) self.assertEquals( 'Firefox', reservation_results[1].experiment_use.request_info['user_agent']) self.assertEquals(4, len(reservation_results[1].experiment_use.commands)) self.assertEquals( 'Provider 1', reservation_results[1].experiment_use.commands[2]. response.commandstring) reservation_id2b = self._test_reservation(session_id, self.dummy1, 'Provider 1', True, False) self.consumer_client.finished_experiment(reservation_id1) self._test_reservation(session_id, self.dummy1, 'Consumer', True, False) reservation_status = self.consumer_client.get_reservation_status( reservation_id3) provider2_reservation_id = reservation_status.remote_reservation_id self.consumer_client.finished_experiment(reservation_id3) self._test_reservation(session_id, self.dummy1, 'Provider 2', True, False) # Check for the other uses self._wait_multiple_reservations(70, session_id, reservation_ids, [0, 2]) reservation_results = self.consumer_client.get_experiment_uses_by_id( session_id, reservation_ids) self.assertTrue(reservation_results[0].is_finished()) self.assertEquals( 'Chrome', reservation_results[0].experiment_use.request_info['user_agent']) self.assertEquals( 'Consumer', reservation_results[0].experiment_use.commands[2]. response.commandstring) self.assertTrue(reservation_results[2].is_finished()) self.assertEquals( 'Safari', reservation_results[2].experiment_use.request_info['user_agent']) self.assertEquals( 'Provider 2', reservation_results[2].experiment_use.commands[2]. response.commandstring) provider2_session_id = self.provider2_client.login( 'provider1', 'password') provider2_result = self.provider2_client.get_experiment_use_by_id( provider2_session_id, provider2_reservation_id) self.assertTrue(provider2_result.is_finished()) self.assertEquals( 'Safari', provider2_result.experiment_use.request_info['user_agent']) # # What if another 2 come in? What is the position of their queues? # reservation_4 = self._test_reservation(session_id, self.dummy1, '', False, False) reservation_status = self.consumer_client.get_reservation_status( reservation_4) self.assertEquals(Reservation.WAITING, reservation_status.status) self.assertEquals(0, reservation_status.position) reservation_5 = self._test_reservation(session_id, self.dummy1, '', False, False) reservation_status = self.consumer_client.get_reservation_status( reservation_5) self.assertEquals(Reservation.WAITING, reservation_status.status) self.assertEquals(1, reservation_status.position) # # Once again, freeing a session affects them? # self.consumer_client.finished_experiment(reservation_id2b) self._wait_reservation(reservation_4, 'Provider 1', True) self.consumer_client.finished_experiment(reservation_4) self._wait_reservation(reservation_5, 'Provider 1', True) # Check for the other uses for _ in range(50): time.sleep(0.5) # Checking every half second results = self.consumer_client.get_experiment_uses_by_id( session_id, (reservation_id2b, reservation_4)) if results[0].is_finished() and results[1].is_finished(): break final_reservation_results = self.consumer_client.get_experiment_uses_by_id( session_id, (reservation_id2b, reservation_4)) self.assertTrue(final_reservation_results[0].is_finished()) self.assertTrue(final_reservation_results[1].is_finished()) self.assertEquals( 'Provider 1', final_reservation_results[0].experiment_use. commands[2].response.commandstring) self.assertEquals( 'Provider 1', final_reservation_results[1].experiment_use. commands[2].response.commandstring) debug("Test test_federated_experiment finishes successfully") def _wait_multiple_reservations(self, times, session_id, reservation_ids, reservations_to_wait): for _ in range(times): time.sleep(0.5) # Checking every half second results = self.consumer_client.get_experiment_uses_by_id( session_id, reservation_ids) all_finished = True for reservation_to_wait in reservations_to_wait: all_finished = all_finished and results[ reservation_to_wait].is_finished() if all_finished: break def _find_command(self, reservation_result, expected_response): found = False commands = reservation_result.experiment_use.commands for command in commands: if command.command.commandstring == 'server_info': found = True response = command.response.commandstring self.assertEquals( expected_response, response, "Message %s not found in commands %s; instead found %s" % (expected_response, commands, response)) self.assertTrue(found, "server_info not found in commands") def _test_reservation(self, session_id, experiment_id, expected_server_info, wait, finish, user_agent=None): debug( "Reserving with session_id %r a experiment %r; will I wait? %s; will I finish? %s" % (session_id, experiment_id, wait, finish)) reservation_status = self.consumer_client.reserve_experiment( session_id, experiment_id, "{}", "{}", user_agent=user_agent) reservation_id = reservation_status.reservation_id if not wait: if finish: debug("Finishing... %r" % reservation_id) self.consumer_client.finished_experiment(reservation_id) debug("Not waiting... %r" % reservation_id) return reservation_id reservation_id = self._wait_reservation(reservation_id, expected_server_info, finish) debug("Finished waiting... %r" % 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 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 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)