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
