def __init__(self, *args, **kwargs): super(MicroServiceHosts, self).__init__(*args, **kwargs) self.profile_service_client = HttpSession( base_url=os.getenv("PROFILE_SVC_URL", "http://localhost:8080") ) self.transaction_service_client = HttpSession( base_url=os.getenv("TRANSACTION_SVC_URL", "http://localhost:5050") ) self.transfer_service_client = HttpSession( base_url=os.getenv("TRANSFER_SVC_URL", "http://localhost:5000") )
def on_start(self): """ 测试数据初始化 1.创建session会话,提供给后面的请求 2.初始化请求头的信息 3.初始化用户信息(用户信息参数化) 4.引用自定义日志 """ self.session = HttpSession(base_url="http://*****:*****@qq.com", "123456"], 1: ["*****@*****.**", "123456"], 2: ["*****@*****.**", "123456"] } self.log = MyLog.MyLog().get_logger()
def __init__(self, *, user: HttpUser, size: Optional[int] = None): """ Connection pool for the HttpUser, the user will use the connections in round robin style for every HTTP request. Args: user (HttpUser): Instance of a HttpUser, pass in self in most circumstances size (int, optional): [description]. Override for the pool size, value defaults to the input from the command line. """ if size: self.size = size else: self.size = user.environment.parsed_options.pool_size # type: ignore self._pool: List[HttpSession] = [] self.request_name = None for _ in range(self.size): self._pool.append( HttpSession( base_url=user.host, request_event=user.environment.events.request, user=user # type: ignore ) ) self.pool = cycle(self._pool)
def test_token_work(self,count): mobiles =self.get_mobile(count) Worktoken = list() Lovetoken = list() lifetoken = list() url = "http://"+K8sServer+":10001" t = HttpSession(url) header = {"Content-Type": "application/json"} for i in mobiles: data = {"Uid": "string", "DeviceName": "string", "Lat": 0, "Lon": 0, "Mobile": i, "Password": 123456} obj = t.post('/v1/logins/users', data=json.dumps(data), headers=header) WorkAuthorization = json.loads(obj.text).get('WorkAuthorization') if WorkAuthorization: Worktoken.append(WoAuthorization) Worktoken.append('\n') LoveAuthorization = json.loads(obj.text).get('LoveAuthorization') if LoveAuthorization: Lovetoken.append(LoAuthorization) Lovetoken.append('\n') LifeAuthorization = json.loads(obj.text).get('LifeAuthorization') if LoveAuthorization: lifetoken.append(LiAuthorization) lifetoken.append('\n') with open('token/WoAuthorization.txt', 'w') as f: f.writelines(Wotoken) with open('token/LoAuthorization.txt','w') as l: l.writelines(Lotoken) with open('token/LiAuthorization.txt', 'w') as i: i.writelines(litoken)
def __init__(self): super(HttpLocust, self).__init__() if self.host is None: raise LocustError("You must specify the base host. Either in the host attribute in the \ Locust class, or on the command line using the --host option.") self.client = HttpSession(base_url=self.host)
def __init__(self, *args, **kwargs): global _currentUser, _userLock, _users, _userTokens, _userEnvironment, _userNames super(Locust, self) TOKEN_INDEX = 0 USERNAME_INDEX = 1 ENVIRONMENT_INDEX = 2 usenv = os.getenv("USER_TOKENS") lines = usenv.split('\n') _users = len(lines) for u in lines: up = u.split(';') _userTokens.append(up[TOKEN_INDEX]) _userNames.append(up[USERNAME_INDEX]) _userEnvironment.append(up[ENVIRONMENT_INDEX]) # Async lock user to prevent two threads runing with the same user _userLock.acquire() self.taskUser = _currentUser self.taskUserToken = _userTokens[_currentUser] self.taskUserName = _userNames[_currentUser] self.taskUserEnvironment = _userEnvironment[_currentUser] print("Spawning user ["+str(self.taskUser)+"] on ["+self.taskUserEnvironment+"]") if _currentUser < _users - 1: _currentUser += 1 else: _currentUser = 0 _userLock.release() # User lock released, critical section end host = "https://che.prod-preview.openshift.io" if "prod-preview" in self.taskUserEnvironment else "https://che.openshift.io" self.client = HttpSession(base_url=host)
def test_slow_redirect(self): s = HttpSession("http://127.0.0.1:%i" % self.port) url = "/redirect?url=/redirect?delay=0.5" r = s.get(url) stats = global_stats.get(url, method="GET") self.assertEqual(1, stats.num_requests) self.assertGreater(stats.avg_response_time, 500)
def test_request(self): session = HttpSession(self.url) for interface_ in self.if_dict_list: if isinstance(interface_['step_list'], list): for interface in interface_['step_list']: if interface['method'] in ["post", "put"]: if interface['data_type'] == 'json': res = session.request(method=interface['method'], url=interface['url'], json=interface['body'], headers=interface['header']) elif interface['data_type'] == 'data': res = session.request(method=interface['method'], url=interface['url'], data=interface['body'], headers=interface['header']) elif interface['method'] in ["get", "delete"]: if interface['is_sign']: if interface['sign_type'] == 4: res = session.request( method=interface['method'], url=interface['url'], params={'data': interface['body']}, headers=interface['header']) else: res = session.request(method=interface['method'], url=interface['url'], params=interface['body'], headers=interface['header']) log.info(res.text)
def __init__(self, *args, **kwargs): super(OAuth2Locust, self).__init__(*args, **kwargs) credentials, project_id = google.auth.default(scopes=API_SCOPES) auth = SimpleOAuth2(credentials) self.client = HttpSession(base_url='') self.client.auth = auth
def setup(self): NormalUserTasks.session = HttpSession(MyLocust.host) # get verification uri = '/verification/generate' NormalUserTasks.session.get(uri) # login username = '******' password = '******' verification = '1234' load = { "email": username, "password": password, "verificationCode": verification } uri = '/login' # response = self.client.post(uri, json=load, cookies=NormalUserTasks.cookies) # print(response.cookies, response.headers) response = NormalUserTasks.session.post(uri, json=load) NormalUserTasks.loginId = response.cookies["loginId"] NormalUserTasks.loginToken = response.cookies["loginToken"]
def set_locust_host(self, host): if not host.startswith('http'): host = 'http://' + host from locust.clients import HttpSession self.HttpSession = HttpSession(host) print('set session ok:' + host) return self
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # client self.node_session = HttpSession( base_url="http://128.199.13.131:9000", request_success=self.environment.events.request_success, request_failure=self.environment.events.request_failure, ) # platform self.platform_session = HttpSession( base_url="http://128.199.14.196:80", request_success=self.environment.events.request_success, request_failure=self.environment.events.request_failure, )
def create_purchase(self): session = HttpSession(self.base_url) # self.client.post('/api/v0.9/reservation/', reservation_body) reservation_response = session.post('/api/v0.9/reservation/', data=reservation_body) if reservation_response.status_code != 201: return if reservation_response.status_code == 409: raise StopLocust('No available tickets.') checkout_response = session.post('/api/v0.9/reservation/_checkout', data=checkout_body) if checkout_response.status_code != 200: return purchase = checkout_response.json()['purchase'] completion_response = session.post( '/api/v0.9/purchases/_complete', json.dumps( dict(purchase_id=purchase['purchase_id'], hash=purchase['completion_params']['hash'], processor=purchase['completion_params']['processor'], payment_ref=purchase['completion_params']['order_ref'])))
def get_credential_client(self): """ New property added for using LocustEdxRestApiClient. Default locust client will remain same for using auto_auth(). """ return LocustEdxRestApiClient( CREDENTIAL_API_URL, session=HttpSession(base_url=self.locust.host), jwt=self._get_token())
def get_client(self, base_url=None): if base_url is None: base_url = "http://127.0.0.1:%i" % self.port return HttpSession( base_url=base_url, request_success=self.environment.events.request_success, request_failure=self.environment.events.request_failure, )
def get_client(self, base_url=None): if base_url is None: base_url = "http://127.0.0.1:%i" % self.port return HttpSession( base_url=base_url, request_event=self.environment.events.request, user=None, )
def on_start(self): self.dataset = self.parent.dataset self.client.verify = False self.api_less_client = HttpSession( base_url=self.client.base_url.replace("api.", "").replace("cellxgene/", ""), request_success=self.client.request_success, request_failure=self.client.request_failure, )
def test_options(self): s = HttpSession("http://127.0.0.1:%i" % self.port) r = s.options("/request_method") self.assertEqual(200, r.status_code) self.assertEqual("", r.content.decode()) self.assertEqual( set(["OPTIONS", "DELETE", "PUT", "GET", "POST", "HEAD", "PATCH"]), set(r.headers["allow"].split(", ")), )
def __init__(self, host, min_wait, max_wait, tests_type): self.host = host self.min_wait = min_wait self.max_wait = max_wait influxdbstring = env["INFLUXDB"] influxport = influxdbstring.split(":").pop() try: influxport = int(influxport) except ValueError: print("Invalid port number given ({}), defaulting to 8086").format( influxport) influxport = 8086 influxhost = influxdbstring.split(":") influxhost.pop() influxhost = influxhost.pop().replace("//", "") self._client = InfluxDBClient(host=influxhost, port=influxport, database='data', username='******', password='******') self._user_count = locust.runners.locust_runner.num_clients # self._run_id = env["RUN_ID"] # self._team = env["TEAM"] self._hostname = socket.gethostname() self._finished = False self._points = [] self._ps = ps.PSStats() self.sanity_test() self._client.create_database('data') self.tests_type = tests_type session = HttpSession(base_url="") statement = session.get(self.host + "/metadata").json() self.test_uuid = str(uuid.uuid4()) self.test_start = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S') if 'software' in statement: self.server_version = statement['software']['version'] self.server_name = statement['software']['name'] else: self.server_version = 'unavailable' self.fhir_version = statement['fhirVersion'] self.test_name = '{} {} v{} f{}'.format(env["TEST_DATE"], self.server_name, self.server_version, self.fhir_version) self.write_start_annotation(tests_type) self._background = gevent.spawn( self._run) # handle to your greenlet (think threads)
def __init__(self, *args: Any, **kwargs: Any) -> None: if kwargs.get('integration_url'): self.client = HttpSession(kwargs.get('integration_url'), events.request_success, events.request_failure) if kwargs.get('record_mode'): setattr(self.client, 'record_mode', kwargs.get('record_mode')) else: self.client = MockClient()
def delete(port, url, au): http = HttpSession(base + ":" + port) data = http.delete(url, headers={ 'Authorization': au, 'Content-Type': 'application/json', 'accept': 'application/json' }) return data
def get_credential_client(self): """ New property added for using LocustEdxRestApiClient. Default locust client will remain same for using auto_auth(). """ return LocustEdxRestApiClient( settings.data['credentials']['url']['api'], session=HttpSession(base_url=self.locust.host), jwt=self.get_access_token() )
def __init__(self, api_prefix='/data/v3/ed-fi'): self.API_PREFIX = api_prefix host = get_config_value('host') self._http_client = HttpSession(host) # Suppress exceptions thrown in the Test Lab environment # when self-signed certificates are used. self._http_client.verify = False if self._token is None: self._token = self.login()
def test_post_redirect(self): s = HttpSession("http://127.0.0.1:%i" % self.port) url = "/redirect" r = s.post(url) self.assertEqual(200, r.status_code) post_stats = global_stats.get(url, method="POST") get_stats = global_stats.get(url, method="GET") self.assertEqual(1, post_stats.num_requests) self.assertEqual(0, get_stats.num_requests)
def put(port, url, data, au): http = HttpSession(base + ":" + port) data = http.put(url, data=json.dumps(data), headers={ 'Authorization': au, 'Content-Type': 'application/json', 'accept': 'application/json' }) return data
def LoadResources(self,URL): session = HttpSession(path) response = session.get(path) resource_urls = set() soup = BeautifulSoup(response.text, "html.parser") print(soup) for response in soup.find_all(src=True): url = response['src'] resource_urls.add(URL) print ("Reading src-- > : " + url)
def create_purchase(self): session = HttpSession(self.base_url) # self.client.post('/api/v0.9/reservation/', reservation_body) reservation_response = session.post('/api/v0.9/reservation/', data=reservation_body) if reservation_response.status_code != 201: return checkout_response = session.post('/api/v0.9/reservation/_checkout', data=checkout_body)
def endpoint_sanity_test(self): session = HttpSession(base_url="") with session.get(self.host + "/Patient?given=Mariano451&family=Bashirian129", catch_response=True, name="Sanity test") as response: try: test.checkResponse(response.status_code, 200) bundle = response.json() test.checkTotalAboveZero(self, bundle, True) except ResponseError: sys.exit('Sanity test failed, /Patient?given=Mariano451&family=Bashirian129 returned nothing. Have you uploaded the test dataset?')
def test_wrong_url(self): for url, exception in ( (u"http://\x94", InvalidURL), ("telnet://127.0.0.1", InvalidSchema), ("127.0.0.1", MissingSchema), ): s = HttpSession(url) try: self.assertRaises(exception, s.get, "/") except KeyError: self.fail("Invalid URL %s was not propagated" % url)
def __init__(self, *args, **kwargs): super(HttpUser, self).__init__(*args, **kwargs) if self.host is None: raise LocustError("You must specify the base host. Either in the host attribute in the User class, or on the command line using the --host option.") session = HttpSession( base_url=self.host, request_success=self.environment.events.request_success, request_failure=self.environment.events.request_failure, ) session.trust_env = False self.client = session