def __check_limits(self): if self.locust_start_time is None: self.locust_start_time = time.time() # Only raise an exception if the actual test is running if self.locust_stop_time is None: if time.time() - self.locust_start_time >= self.locust_duration: raise StopUser('Duration limit reached') if self.num_requests <= 0: raise StopUser('Request limit reached')
def on_start(self): #Get username /pwd self.userName="" self.Password="" self.userName = random.choice(my_reader)['UserName'] self.Password = random.choice(my_reader)['Password'] with self.client.get("/", name="launchURL", catch_response=True) as resp: time.sleep(2) if resp.status_code == 200: resp.success() logger.info("URL Launched") else: resp.failure("failed to launch URL") logger.critical("failed to launch URL") #Exit test run self.parent.environment.runner.quit() with self.client.post("/login.php", name="login", data={"action": "process","userName": self.userName, "password": self.Password,"login.x": "41","login.y": "12"}, catch_response=True) as resp: time.sleep(2) if ("Find a Flight") in resp.text: resp.success() logger.info("login successful \t" +self.userName) else: resp.failure("failed to login") logger.critical("login failed \t" +self.userName) #Exit User raise StopUser()
def wrap_for_locust(request_type, name, func, *args, **kwargs): """ Wrap Selenium activity function with Locust's event fail/success method :param request_type: the type of request :param name: name to be reported to events.request_*.fire :param func: callable to be timed and logged :return result: Result of the provided function if doesn't raise exception """ try: start_time = time.time() result = func(*args, **kwargs) except Exception as event_exception: total_time = int((time.time() - start_time) * 1000) events.request_failure.fire(request_type=request_type, name=name, response_time=total_time, response_length=0, exception=event_exception) raise StopUser() else: total_time = int((time.time() - start_time) * 1000) events.request_success.fire(request_type=request_type, name=name, response_time=total_time, response_length=0) return result
def wait(self): """ Make the running user sleep for a duration defined by the Locust.wait_time function (or TaskSet.wait_time function if it's been defined). The user can also be killed gracefully while it's sleeping, so calling this method within a task makes it possible for a user to be killed mid-task, even if you've set a stop_timeout. If this behaviour is not desired you should make the user wait using gevent.sleep() instead. """ if self.user._state == LOCUST_STATE_STOPPING: raise StopUser() self.user._state = LOCUST_STATE_WAITING self._sleep(self.wait_time()) if self.user._state == LOCUST_STATE_STOPPING: raise StopUser() self.user._state = LOCUST_STATE_RUNNING
def run(self): if self.environment.runner: self.host = self.environment.runner.dmt_test_url self.logged_user = self.environment.runner.dmt_logged_user if self.host is None: raise StopUser("DMT: test_url for " + self.__class__.__name__ + " is None.") super(DMTUser, self).run()
def add_item_to_order(session, item_idx: int): with session.client.post( f"{ORDER_URL}/orders/addItem/{session.order_id}/{session.item_ids[item_idx]}", name="/orders/addItem/[order_id]/[item_id]", json={}, catch_response=True) as response: if 400 <= response.status_code < 500: response.failure(response.text) raise StopUser() else: response.success()
def on_start(self): # load single hh per user self.zmq_consumer = ZMQRequester(FEEDER_ADDR) data = self.zmq_consumer.await_data() if data == {}: logging.info("No more data. Stopping user.") raise StopUser() else: self.household = data self.pgp_pair = create_test_gpg_keypair( self.household['pds_card_number'])
def wrapped(self, task): if runner.iterations_started == options.iterations: if not runner.iteration_target_reached: runner.iteration_target_reached = True logging.info( f"Iteration limit reached ({options.iterations}), stopping Users at the start of their next task run" ) if runner.user_count == 1: logging.info("Last user stopped, quitting runner") runner.quit() raise StopUser() runner.iterations_started = runner.iterations_started + 1 method(self, task)
def execute_next_task_with_iteration_limit(self: TaskSet): if runner.iterations_started == environment.parsed_options.iterations: if not runner.iteration_target_reached: runner.iteration_target_reached = True logging.info( f"Iteration limit reached ({environment.parsed_options.iterations}), stopping Users at the start of their next task run" ) if runner.user_count == 1: logging.debug("Last user stopped, quitting runner") runner.quit() raise StopUser() runner.iterations_started = runner.iterations_started + 1 _execute_next_task(self)
def get_questions_16(self): request_body = {"data": "Going to work is more dangerous than going to war."} with self.client.post("/questions", json=request_body, catch_response=True) as response: if response.text is None or not response.text.strip(): logging.error(inspect.stack()[0][3] + " Failed: response is None") response.failure(inspect.stack()[0][3] + " Failed: response is None") else: logging.info(inspect.stack()[0][3] + ": " + response.text) response_data = response.json() if not response_data["success"]: logging.error(inspect.stack()[0][3] + " Failed: " + response_data['message']) response.failure(inspect.stack()[0][3] + " Failed: " + response_data['message']) raise StopUser()
def get_paraphrase_15(self): request_body = [ "water and mercury can exist in all the three states of matter", "Going to work is more dangerous than going to war.", "The Burj Khalifa is so tall you can see two sunsets from it in one day."] with self.client.post("/paraphrases", json=request_body, catch_response=True) as response: if response.text is None or not response.text.strip(): logging.error(inspect.stack()[0][3] + " Failed: response is None") response.failure(inspect.stack()[0][3] + " Failed: response is None") else: logging.info(inspect.stack()[0][3] + ": " + response.text) response_data = response.json() if not response_data["success"]: logging.error(inspect.stack()[0][3] + " Failed: " + response_data['message']) response.failure(inspect.stack()[0][3] + " Failed: " + response_data['message']) raise StopUser()
def dso_login(env='dev'): with open(get_config_file_path(), 'r') as f: properties = yaml.load(f.read(), yaml.SafeLoader) env_property = properties[env] url = env_property['login_url'] header = { "Authorization": env_property['login_authorization'], "Content-Type": "application/x-www-form-urlencoded" } body = { "grant_type": env_property['login_grant_type'], "scope": env_property['login_scope'] } response = requests.post(url, data=body, headers=header) if response.status_code == 200: return response else: print(response.status_code.__str__() + " : " + response.text) raise StopUser()
def get_config_templates(self): with self.client.get( "/api/bot/templates/config", headers={"Authorization": self.user.auth_token}, catch_response=True) as response: if response.text is None or not response.text.strip(): logging.error(inspect.stack()[0][3] + " Failed: response is None") response.failure(inspect.stack()[0][3] + " Failed: response is None") else: logging.info(inspect.stack()[0][3] + ": " + response.text) response_data = response.json() if not response_data["success"]: logging.error(inspect.stack()[0][3] + " Failed: " + response_data['message']) response.failure(inspect.stack()[0][3] + " Failed: " + response_data['message']) raise StopUser()
def run(self): try: self.on_start() except InterruptTaskSet as e: if e.reschedule: raise RescheduleTaskImmediately(e.reschedule).with_traceback( e.__traceback__) else: raise RescheduleTask(e.reschedule).with_traceback( e.__traceback__) while True: try: if not self._task_queue: self.schedule_task(self.get_next_task()) try: if self.user._state == LOCUST_STATE_STOPPING: raise StopUser() self.execute_next_task() except RescheduleTaskImmediately: pass except RescheduleTask: self.wait() else: self.wait() except InterruptTaskSet as e: self.on_stop() if e.reschedule: raise RescheduleTaskImmediately(e.reschedule) from e else: raise RescheduleTask(e.reschedule) from e except (StopUser, GreenletExit): self.on_stop() raise except Exception as e: self.user.environment.events.user_error.fire( user_instance=self, exception=e, tb=e.__traceback__) if self.user.environment.catch_exceptions: logger.error("%s\n%s", e, traceback.format_exc()) self.wait() else: raise
def login(self, email, password): url = "/api/v1/login" headers = {'Content-Type': "application/json"} body = { "email": email, "password": password, } response = self.post(url, body, headers) if response.status_code != 200: print( f'StopUser: Login Request Failed: {url}, {email}, {response.status_code}, {response.text}' ) raise StopUser() token = response.json()["token"] self.default_headers = { 'Content-Type': "application/json", "Authorization": "Bearer " + token }
def reserve_tickets(self, tickets): # Make sure we have a clean session self.client.cookies.clear() self.client.get("/") resp = self.client.get("/tickets") html = lxml.html.fromstring(resp.content) form = html.get_element_by_id("choose_tickets") amounts = { i.label.text_content(): i.name for i in form.inputs if i.name.endswith("-amount") } data = dict(**form.fields) for display_name, count in tickets.items(): data[amounts[display_name]] = count self.client.post("/tickets", data) raise StopUser()
def index_page(self): # self.client.get("/") from selenium import webdriver from selenium.webdriver.common.keys import Keys from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC options = webdriver.ChromeOptions() options.add_argument('window-size=1200x600') options.add_argument('headless') options.add_argument("no-sandbox") driver = webdriver.Chrome(options=options) driver.get('http://65.0.168.78:8000') element = WebDriverWait(driver, 20).until( EC.presence_of_element_located((By.CLASS_NAME, "terminal")) ) terminal = driver.find_element_by_xpath("//div[@class='terminal']") terminal.send_keys('ls' + Keys.ENTER) terminal.send_keys('touch file.txt' + Keys.ENTER) terminal.send_keys('git clone https://github.com/vedavidhbudimuri/ib-mini-projects' + Keys.ENTER) terminal.send_keys('cat file.txt' + Keys.ENTER) raise StopUser()
def subtask(self): state[0] = 1 raise StopUser()
def request(self, exception, **_kwargs): if exception: raise StopUser()
def t(self): self.test_state = 1 sleep(0.1) raise StopUser()
def t2(self): self.t2_executed = True raise StopUser()
def t(self): log.append(0) self.wait() log.append(1) raise StopUser()
def overwrite_user(self): try: self.user = "******" except AttributeError: MyTaskSet.raised_attribute_error = True raise StopUser()
def stop(self): raise StopUser()
def _check_stop_condition(self): if self.user._state == LOCUST_STATE_STOPPING: raise StopUser()
def t1(self): v[0] = 1 raise StopUser()
def will_stop(self): raise StopUser()
def stop(self): self.interrupt(False) raise StopUser()
def request_failure(self, request_type, name, response_time, response_length, exception, **_kwargs): raise StopUser()
def t(self): self.client.get("/") raise StopUser()