def private_locations(self):
"""
:rtype: BZAObjectsList[BZAObject]
"""
params = {"workspaceId": self['id']}
res = self._request(self.address + '/api/v4/private-locations?' + urlencode(params))
return BZAObjectsList([BZAObject(self, x) for x in res['result']])
def _get_request_path(self, request, scenario):
parsed_url = parse.urlparse(request.url)
if not self._target.get("scheme"):
self._target["scheme"] = parsed_url.scheme
if not self._target.get("netloc"):
self._target["netloc"] = parsed_url.netloc
if parsed_url.scheme != self._target["scheme"] or parsed_url.netloc != self._target["netloc"]:
raise TaurusConfigError("Address port and host must be the same")
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
else:
if request.method == "GET" and isinstance(request.body, dict):
path += "?" + urlencode(request.body)
if not parsed_url.netloc:
default_addr = scenario.get('default-address', None)
if default_addr is None:
default_addr = ''
parsed_url = parse.urlparse(default_addr)
self.hostname = parsed_url.netloc.split(':')[0] if ':' in parsed_url.netloc else parsed_url.netloc
self.use_ssl = parsed_url.scheme == 'https'
if parsed_url.port:
self.port = parsed_url.port
else:
self.port = 443 if self.use_ssl else 80
return path if len(path) else '/'
def _build_request(self, request, scenario):
path = self._get_request_path(request, scenario)
http = "%s %s HTTP/1.1\r\n" % (request.method, path)
headers = BetterDict()
headers.merge({"Host": self.hostname})
if not scenario.get("keepalive", True):
headers.merge({"Connection": 'close'}) # HTTP/1.1 implies keep-alive by default
body = ""
if isinstance(request.body, dict):
if request.method != "GET":
body = urlencode(request.body)
elif isinstance(request.body, string_types):
body = request.body
elif request.body:
raise ValueError("Cannot handle 'body' option of type %s: %s" % (type(request.body), request.body))
if body:
headers.merge({"Content-Length": len(body)})
headers.merge(scenario.get("headers"))
headers.merge(request.headers)
for header, value in iteritems(headers):
http += "%s: %s\r\n" % (header, value)
http += "\r\n%s" % (body,)
return http
def start_online(self, test_id, session_name):
"""
Start online test
:type test_id: str
:return:
"""
self.log.info("Initiating data feeding...")
data = urlencode({})
if self.token:
url = self.address + "/api/latest/tests/%s/start-external" % test_id
else:
url = self.address + "/api/latest/sessions"
resp = self._request(url, data)
self.active_session_id = str(resp['result']['session']['id'])
self.data_signature = str(resp['result']['signature'])
self.test_id = test_id
self.user_id = str(resp['result']['session']['userId'])
if self.token:
self.results_url = self.address + '/app/#reports/%s' % self.active_session_id
if session_name:
url = self.address + "/api/latest/sessions/%s" % self.active_session_id
self._request(url, to_json({"name": str(session_name)}),
headers={"Content-Type": "application/json"}, method='PATCH')
else:
self.test_id = resp['result']['session']['testId']
self.results_url = resp['result']['publicTokenUrl']
return self.results_url
def _get_request_path(self, request, scenario):
parsed_url = parse.urlparse(request.url)
if not self._target.get("scheme"):
self._target["scheme"] = parsed_url.scheme
if not self._target.get("netloc"):
self._target["netloc"] = parsed_url.netloc
if parsed_url.scheme != self._target["scheme"] or parsed_url.netloc != self._target["netloc"]:
raise ValueError("Address port and host must be the same")
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
else:
if request.method == "GET" and isinstance(request.body, dict):
path += "?" + urlencode(request.body)
if not parsed_url.netloc:
parsed_url = parse.urlparse(scenario.get("default-address", ""))
self.hostname = parsed_url.netloc.split(':')[0] if ':' in parsed_url.netloc else parsed_url.netloc
self.use_ssl = parsed_url.scheme == 'https'
if parsed_url.port:
self.port = parsed_url.port
else:
self.port = 443 if self.use_ssl else 80
return path if len(path) else '/'
def start_online(self, test_id):
"""
Start online test
:type test_id: str
:return:
"""
self.log.info("Initiating data feeding...")
data = urlencode({})
if self.token:
url = self.address + "/api/latest/tests/%s/start-external" % test_id
else:
url = self.address + "/api/latest/sessions"
resp = self._request(url, data)
self.active_session_id = str(resp['result']['session']['id'])
self.data_signature = str(resp['result']['signature'])
self.test_id = test_id
self.user_id = str(resp['result']['session']['userId'])
if self.token:
self.results_url = self.address + '/app/#reports/%s' % self.active_session_id
else:
self.test_id = resp['result']['session']['testId']
self.results_url = resp['result']['publicTokenUrl']
return self.results_url
def _build_request(self, request, scenario):
path = self._get_request_path(request, scenario)
http = "%s %s HTTP/1.1\r\n" % (request.method, path)
headers = BetterDict()
headers.merge({"Host": self.hostname})
if not scenario.get("keepalive", True):
headers.merge({"Connection": 'close'}) # HTTP/1.1 implies keep-alive by default
body = ""
if isinstance(request.body, dict):
if request.method != "GET":
body = urlencode(request.body)
elif isinstance(request.body, string_types):
body = request.body
elif request.body:
msg = "Cannot handle 'body' option of type %s: %s"
raise TaurusConfigError(msg % (type(request.body), request.body))
if body:
headers.merge({"Content-Length": len(body)})
headers.merge(scenario.get_headers())
headers.merge(request.headers)
for header, value in iteritems(headers):
http += "%s: %s\r\n" % (header, value)
http += "\r\n%s" % (body,)
return http
def private_locations(self):
"""
:rtype: BZAObjectsList[BZAObject]
"""
params = {"workspaceId": self['id']}
res = self._request(self.address + '/api/v4/private-locations?' +
urlencode(params))
return BZAObjectsList([BZAObject(self, x) for x in res['result']])
def workspaces(self):
"""
:rtype: BZAObjectsList[Workspace]
"""
params = {"accountId": self['id']}
res = self._request(self.address + '/api/v4/workspaces?' +
urlencode(params))
return BZAObjectsList([Workspace(self, x) for x in res['result']])
def workspaces(self):
"""
:rtype: BZAObjectsList[Workspace]
"""
params = {"accountId": self['id'], 'enabled': 'true', 'limit': 100}
params = OrderedDict(sorted(params.items(), key=lambda t: t[0]))
res = self._request(self.address + '/api/v4/workspaces?' +
urlencode(params))
return BZAObjectsList(
[Workspace(self, x) for x in res['result'] if x['enabled']])
def _get_url(self):
params = [('target', field) for field in self.config.get(
'metrics', ValueError("Metrics list required"))]
from_t = int(
dehumanize_time(self.config.get('from', self.interval * 1000)))
until_t = int(dehumanize_time(self.config.get('until', 0)))
params += [('from', '-%ss' % from_t), ('until', '-%ss' % until_t),
('format', 'json')]
url = self.address + '/render?' + urlencode(params)
if not url.startswith('http'):
url = 'http://' + url
return url
def _get_url(self):
params = [('target', field) for field in self.config.get('metrics', ValueError("Metrics list required"))]
from_t = int(dehumanize_time(self.config.get('from', self.interval * 1000)))
until_t = int(dehumanize_time(self.config.get('until', 0)))
params += [
('from', '-%ss' % from_t),
('until', '-%ss' % until_t),
('format', 'json')
]
url = self.address + '/render?' + urlencode(params)
if not url.startswith('http'):
url = 'http://' + url
return url
def get_kpis(self, master_id, min_ts):
params = [
("interval", 1),
("from", min_ts),
("master_ids[]", master_id),
]
for item in ('t', 'lt', 'by', 'n', 'ec', 'ts', 'na'):
params.append(("kpis[]", item))
labels = self.get_labels(master_id)
for label in labels:
params.append(("labels[]", label['id']))
url = self.address + "/api/latest/data/kpis?" + urlencode(params)
res = self._request(url)
return res['result']
def get_kpis(self, min_ts):
params = [
("interval", 1),
("from", min_ts),
("master_ids[]", self['id']),
]
for item in ('t', 'lt', 'by', 'n', 'ec', 'ts', 'na'):
params.append(("kpis[]", item))
labels = self.get_labels()
for label in labels:
params.append(("labels[]", label['id']))
url = self.address + "/api/v4/data/kpis?" + urlencode(params)
res = self._request(url)
return res['result']
def multi_tests(self, name=None):
"""
:rtype: BZAObjectsList[MultiTest]
"""
params = OrderedDict({"projectId": self['id']})
if name is not None:
params["name"] = name
res = self._request(self.address + '/api/v4/multi-tests?' +
urlencode(params))
tests = BZAObjectsList()
for item in res['result']:
if name is not None and item['name'] != name:
continue
tests.append(MultiTest(self, item))
return tests
def start_taurus(self, test_id):
"""
Start online test
:type test_id: str
:return:
"""
self.log.info("Initiating cloud test with %s ...", self.address)
data = urlencode({})
url = self.address + "/api/latest/tests/%s/start" % test_id
resp = self._request(url, data)
self.log.debug("Response: %s", resp['result'])
self.active_session_id = str(resp['result']['id'])
self.results_url = self.address + '/app/#reports/%s' % self.active_session_id
return self.results_url
def start_taurus(self, test_id):
"""
Start online test
:type test_id: str
:return:
"""
self.log.info("Initiating cloud test with %s ...", self.address)
data = urlencode({})
url = self.address + "/api/latest/tests/%s/start" % test_id
resp = self._request(url, data)
self.log.debug("Response: %s", resp['result'])
self.active_session_id = str(resp['result']['id'])
self.results_url = self.address + '/app/#reports/%s' % self.active_session_id
return self.results_url
def projects(self, name=None, proj_id=None):
"""
:rtype: BZAObjectsList[Project]
"""
params = {"workspaceId": self['id']}
res = self._request(self.address + '/api/v4/projects?' +
urlencode(params))
projects = BZAObjectsList()
for item in res['result']:
if name is not None and item['name'] != name:
continue
if proj_id is not None and item['id'] != proj_id:
continue
projects.append(Project(self, item))
return projects
def projects(self, name=None, ident=None):
"""
:rtype: BZAObjectsList[Project]
"""
params = OrderedDict()
params.update({"workspaceId": self['id']})
params.update({"limit": 99999})
res = self._request(self.address + '/api/v4/projects?' + urlencode(params))
projects = BZAObjectsList()
for item in res['result']:
if name is not None and item['name'] != name:
continue
if ident is not None and item['id'] != ident:
continue
projects.append(Project(self, item))
return BZAObjectsList(projects)
def projects(self, name=None, ident=None):
"""
:rtype: BZAObjectsList[Project]
"""
params = OrderedDict()
params.update({"workspaceId": self['id']})
params.update({"limit": 99999})
res = self._request(self.address + '/api/v4/projects?' + urlencode(params))
projects = BZAObjectsList()
for item in res['result']:
if name is not None and item['name'] != name:
continue
if ident is not None and item['id'] != ident:
continue
projects.append(Project(self, item))
return BZAObjectsList(projects)
def get_kpis(self, min_ts):
params = [
("interval", 1),
("from", min_ts),
("master_ids[]", self['id']),
]
for item in ('t', 'lt', 'by', 'n', 'ec', 'ts', 'na'):
params.append(("kpis[]", item))
labels = self.get_labels()[:100]
if len(labels) == 100 and not self.warned_of_too_much_labels:
self.log.warn("Using only first 100 labels, while test has more labels")
self.warned_of_too_much_labels = True
for label in labels:
params.append(("labels[]", label['id']))
url = self.address + "/api/v4/data/kpis?" + urlencode(params)
res = self._request(url)
return res['result']
def get_kpis(self, min_ts):
params = [
("interval", 1),
("from", min_ts),
("master_ids[]", self['id']),
]
for item in ('t', 'lt', 'by', 'n', 'ec', 'ts', 'na'):
params.append(("kpis[]", item))
labels = self.get_labels()[:100]
if len(labels) == 100 and not self.warned_of_too_much_labels:
self.log.warn("Using only first 100 labels, while test has more labels")
self.warned_of_too_much_labels = True
for label in labels:
params.append(("labels[]", label['id']))
url = self.address + "/api/v4/data/kpis?" + urlencode(params)
res = self._request(url)
return res['result']
def multi_tests(self, name=None, ident=None):
"""
:rtype: BZAObjectsList[MultiTest]
"""
params = OrderedDict({"projectId": self['id']})
if name is not None:
params["name"] = name
if ident is not None:
params["id"] = ident
res = self._request(self.address + '/api/v4/multi-tests?' + urlencode(params))
tests = BZAObjectsList()
for item in res['result']:
if ident is not None and item['id'] != ident:
continue
if name is not None and item['name'] != name:
continue
tests.append(MultiTest(self, item))
return tests
def workspaces(self, ident=None, name=None):
"""
:rtype: BZAObjectsList[Workspace]
"""
params = {"accountId": self['id'], 'enabled': 'true', 'limit': 100}
params = OrderedDict(sorted(params.items(), key=lambda t: t[0]))
res = self._request(self.address + '/api/v4/workspaces?' + urlencode(params))
workspaces = []
for wksp in res['result']:
if not wksp['enabled']:
continue
if name is not None and wksp['name'] != name:
continue
if ident is not None and wksp['id'] != ident:
continue
workspaces.append(Workspace(self, wksp))
return BZAObjectsList(workspaces)
def tests(self, name=None, test_type=None):
"""
:rtype: BZAObjectsList[Test]
"""
params = OrderedDict({"projectId": self['id']})
if name is not None:
params["name"] = name
res = self._request(self.address + '/api/v4/tests?' +
urlencode(params))
tests = BZAObjectsList()
for item in res['result']:
if name is not None and item['name'] != name:
continue
if test_type is not None and item['configuration'][
'type'] != test_type:
continue
tests.append(Test(self, item))
return tests
def workspaces(self, ident=None, name=None):
"""
:rtype: BZAObjectsList[Workspace]
"""
params = {"accountId": self['id'], 'enabled': 'true', 'limit': 100}
params = OrderedDict(sorted(params.items(), key=lambda t: t[0]))
res = self._request(self.address + '/api/v4/workspaces?' + urlencode(params))
workspaces = []
for wksp in res['result']:
if not wksp['enabled']:
continue
if name is not None and wksp['name'] != name:
continue
if ident is not None and wksp['id'] != ident:
continue
workspaces.append(Workspace(self, wksp))
return BZAObjectsList(workspaces)
def tests(self, name=None, ident=None, test_type=None):
"""
:rtype: BZAObjectsList[Test]
"""
params = OrderedDict({"workspaceId": self['id']})
if name is not None:
params["name"] = name
if ident is not None:
params["id"] = ident
res = self._request(self.address + '/api/v4/tests?' + urlencode(params))
tests = BZAObjectsList()
for item in res['result']:
if ident is not None and item['id'] != ident:
continue
if name is not None and item['name'] != name:
continue
if test_type is not None and item['configuration']['type'] != test_type:
continue
tests.append(Test(self, item))
return tests
def get_files(self):
path = self.address + "/api/v4/web/elfinder/%s" % self['id']
query = urlencode(OrderedDict({'cmd': 'open', 'target': 's1_Lw'}))
url = path + '?' + query
response = self._request(url)
return response["files"]
def get_labels(self, ):
url = self.address + "/api/v4/data/labels?" + urlencode({'master_id': self['id']})
res = self._request(url)
return res['result']
def _embed_query_in_path(self, path, query_dict):
self.log.info(query_dict)
parts = parse.urlparse(path)
query = urlencode(query_dict)
replaced = parts._replace(query=query)
return parse.urlunparse(replaced)
def get_labels(self, master_id):
url = self.address + "/api/latest/data/labels?" + urlencode({'master_id': master_id})
res = self._request(url)
return res['result']
def get_files(self):
path = self.address + "/api/v4/web/elfinder/%s" % self['id']
query = urlencode(OrderedDict({'cmd': 'open', 'target': 's1_Lw'}))
url = path + '?' + query
response = self._request(url)
return response["files"]
def get_labels(self, master_id):
url = self.address + "/api/latest/data/labels?" + urlencode(
{'master_id': master_id})
res = self._request(url)
return res['result']
def get_labels(self, ):
url = self.address + "/api/v4/data/labels?" + urlencode(
{'master_id': self['id']})
res = self._request(url)
return res['result']
def _embed_query_in_path(self, path, query_dict):
self.log.debug("Query dict: %s", query_dict)
parts = parse.urlparse(path)
query = urlencode(query_dict)
replaced = parts._replace(query=query)
return parse.urlunparse(replaced)
