def post_data_to_user_intent_endpoint(context, payload=None):
"""Post data into the REST API endpoint for user-intent."""
url = "/api/v1/user-intent"
if payload is not None:
context.response = requests.post(context.coreapi_url + url,
headers=authorization(context),
json=payload)
else:
context.response = requests.post(context.coreapi_url + url,
headers=authorization(context))
def finish_analysis_for_component(context,
ecosystem,
component,
version,
token='without'):
"""Try to wait for the component analysis to be finished.
Current API implementation returns just two HTTP codes:
200 OK : analysis is already finished
404 NOT FOUND: analysis is started or is in progress
"""
timeout = context.component_analysis_timeout # in seconds
sleep_amount = 10 # we don't have to overload the API with too many calls
use_token = parse_token_clause(token)
url = component_analysis_url(context, ecosystem, component, version)
for _ in range(timeout // sleep_amount):
if use_token:
status_code = requests.get(
url, headers=authorization(context)).status_code
else:
status_code = requests.get(url).status_code
if status_code == 200:
break
elif status_code != 404:
raise Exception('Bad HTTP status code {c}'.format(c=status_code))
time.sleep(sleep_amount)
else:
raise Exception('Timeout waiting for the component analysis results')
def get_next_untagged_component(context, ecosystem, use_token):
"""Call API endpoint get next untagged component."""
if use_token:
context.response = requests.post(get_next_untagged_component_url(context, ecosystem),
headers=authorization(context))
else:
context.response = requests.post(get_next_untagged_component_url(context, ecosystem))
def get_master_tag_list(context, ecosystem, use_token):
"""Call API endpoint master tag list."""
if use_token:
context.response = requests.get(master_tag_list_url(context, ecosystem),
headers=authorization(context))
else:
context.response = requests.get(master_tag_list_url(context, ecosystem))
def post_input_to_user_feedback(context, is_valid, endpoint, token):
"""Send feedback to user feedback endpoint."""
use_token = parse_token_clause(token)
api_url = urljoin(context.coreapi_url, endpoint)
if is_valid == "valid":
data = {
"request_id": "test_id",
"feedback": [{
"ques": "what",
"ans": "got it"
}]
}
elif is_valid == "invalid":
data = {"foo": "x", "bar": "y", "baz": []}
elif is_valid == "incomplete":
data = {"request_id": "test_id"}
elif is_valid == "empty":
data = {}
else:
data = None
if use_token:
response = requests.post(api_url,
json=data,
headers=authorization(context))
else:
response = requests.post(api_url, json=data)
context.response = response
def access_gemini_url(context, endpoint, token="without"):
"""Access the Gemini service API using the HTTP GET method."""
url = urljoin(context.gemini_api_url, endpoint)
use_token = parse_token_clause(token)
headers = {}
if use_token:
headers = authorization(context)
context.response = requests.get(url, headers=headers)
def perform_component_search(context, component, use_token):
"""Call API endpoint to search for component."""
path = "api/v1/component-search/{component}".format(component=component)
url = urljoin(context.coreapi_url, path)
if use_token:
context.response = requests.get(url, headers=authorization(context))
else:
context.response = requests.get(url)
def get_data(context, use_token):
"""Construct data for 3scale REST API POST call."""
if use_token:
token = authorization(context).get("Authorization", None)
token = token.split("Bearer ")[-1]
data = {"auth_token": token, "service_id": context.service_id[:-1]}
else:
data = {"service_id": context.service_id[:-1]}
return data
def post_input_to_user_feedback(context, is_valid, endpoint, token):
"""Send feedback to user feedback endpoint."""
use_token = parse_token_clause(token)
api_url = urljoin(context.coreapi_url, endpoint)
data = generate_data_for_user_feedback(is_valid)
if use_token:
response = requests.post(api_url, json=data,
headers=authorization(context))
else:
response = requests.post(api_url, json=data)
context.response = response
def check_submit_feedback_without_valid_values(context, url):
"""Access the submit-feedback API using the HTTP POST method with invalid payload."""
payload = {
"stack_id": "1234-569586048",
"recommendation_type": "companion",
"package_name": "blah-blah",
"feedback_type": True,
"ecosystem": None
}
context.response = requests.post(context.coreapi_url + url,
headers=authorization(context),
data=payload)
def read_analysis_for_component(context,
ecosystem,
component,
version,
token='without'):
"""Read component analysis (or an error message) for the selected ecosystem."""
url = component_analysis_url(context, ecosystem, component, version)
use_token = parse_token_clause(token)
if use_token:
context.response = requests.get(url, headers=authorization(context))
else:
context.response = requests.get(url)
def wait_for_stack_analysis_completion(context, version=3, token="without"):
"""Try to wait for the stack analysis to be finished.
This step assumes that stack analysis has been started previously and
thus that the job ID is known
Current API implementation returns just three HTTP codes:
200 OK : analysis is already finished
202 Accepted: analysis is started or is in progress (or other state!)
401 UNAUTHORIZED : missing or improper authorization token
"""
context.duration = None
start_time = time.time()
timeout = context.stack_analysis_timeout # in seconds
sleep_amount = 10 # we don't have to overload the API with too many calls
use_token = parse_token_clause(token)
id = context.response.json().get("id")
context.stack_analysis_id = id
# log.info("REQUEST ID: {}\n\n".format(context.stack_analysis_id))
url = urljoin(stack_analysis_endpoint(context, version), id)
# log.info("RECOMMENDER API URL: {}\n\n".format(url))
for _ in range(timeout // sleep_amount):
if use_token:
context.response = requests.get(url,
headers=authorization(context))
else:
context.response = requests.get(url)
status_code = context.response.status_code
# log.info("%r" % context.response.json())
if status_code == 200:
json_resp = context.response.json()
if contains_alternate_node(json_resp):
# log.info('Recommendation found')
break
# 401 code should be checked later
elif status_code == 401:
break
elif status_code != 202:
raise Exception('Bad HTTP status code {c}'.format(c=status_code))
time.sleep(sleep_amount)
else:
raise Exception('Timeout waiting for the stack analysis results')
end_time = time.time()
# compute the duration
# plase note that duration==None in case of any errors (which is to be expected)
context.duration = end_time - start_time
def send_payload_to_license_analysis(context, directory, filename, endpoint,
use_token):
"""Send the selected file to the license analysis service to be processed."""
filename = '{directory}/{filename}'.format(directory=directory,
filename=filename)
path_to_file = os.path.abspath(filename)
url = url_to_endpoint(context.license_service_url, endpoint)
with open(path_to_file) as json_data:
if use_token:
response = requests.post(url,
data=json_data,
headers=authorization(context))
else:
response = requests.post(url, data=json_data)
context.response = response
def read_analysis_for_component(context,
ecosystem,
component,
version,
token='without'):
"""Read component analysis (or an error message) for the selected ecosystem."""
context.duration = None
start_time = time.time()
url = component_analysis_url(context, ecosystem, component, version)
use_token = parse_token_clause(token)
if use_token:
context.response = requests.get(url, headers=authorization(context))
else:
context.response = requests.get(url)
end_time = time.time()
# compute the duration
# plase note that duration==None in case of any errors (which is to be expected)
context.duration = end_time - start_time
def send_manifest_to_stack_analysis(context, manifest, name, endpoint,
use_token):
"""Send the selected manifest file to stack analysis."""
filename = 'data/{manifest}'.format(manifest=manifest)
manifest_file_dir = os.path.dirname(filename)
path_to_manifest_file = os.path.abspath(manifest_file_dir)
# please note that the trick with (None, path_to_manifest_file) has to be
# used here so the REST API call would work properly. It is similar to use
# curl -F 'manifest[]=@filename' -F 'filePath[]=PATH_TO_FILE'
files = {
'manifest[]': (name, open(filename, 'rb')),
'filePath[]': (None, path_to_manifest_file)
}
if use_token:
response = requests.post(endpoint,
files=files,
headers=authorization(context))
else:
response = requests.post(endpoint, files=files)
context.response = response
def call_backbone_api(context,
method="get",
endpoint="/api/v1/register",
token="without"):
"""Get or post data to gemini API."""
use_token = parse_token_clause(token)
headers = {}
if use_token:
headers = authorization(context)
headers['Content-Type'] = 'application/json'
headers['Accept'] = 'application/json'
headers['git-url'] = "https://github.com/heroku/node-js-sample.git"
if method == 'post':
content = {'git-url': context.url, 'git-sha': context.sha}
if endpoint == "/api/v1/user-repo/notify":
content.update({"epv_list": context.epv_list})
url = '{}/{}'.format(context.gemini_api_url, endpoint)
if endpoint == '/api/v1/user-repo/scan':
content = read_data_gemini()
headers['git-url'] = "https://github.com/heroku/node-js-sample.git"
headers.pop('Accept', None)
context.response = requests.post(url,
data=json.dumps(content),
headers=headers)
else:
context.response = requests.post(url,
json=content,
headers=headers)
else:
api_url = "{api_url}/{endpoint}?git-url={git_url}&git-sha={git_sha}".format(
api_url=context.gemini_api_url,
endpoint=endpoint,
git_url=context.url,
git_sha=context.sha)
context.response = requests.get(api_url, headers=headers)
def start_analysis_for_component(context,
ecosystem,
component,
version,
token='without'):
"""Start the component analysis.
Start the analysis for given component and version in selected ecosystem.
Current API implementation returns just two HTTP codes:
200 OK : analysis is already finished
202 ACCEPTED: analysis is not finished, might be planned (or not)
400 BAD REQUST: unknown ecosystem etc. etc.
401 UNAUTHORIZED : missing or inproper authorization token
404 NOT FOUND : analysis is started or is in progress
It means that this test step should check if 200 OK is NOT returned.
"""
url = component_analysis_url(context, ecosystem, component, version)
use_token = parse_token_clause(token)
# first check that the analysis is really new
if use_token:
response = requests.get(url, headers=authorization(context))
else:
response = requests.get(url)
# remember the response for further test steps
context.response = response
if response.status_code == 200:
raise Exception('Bad state: the analysis for component has been '
'finished already')
elif response.status_code not in (202, 400, 401, 404):
raise Exception(
'Improper response: expected HTTP status code 401 or 404, '
'received {c}'.format(c=response.status_code))
def access_url_put_method_with_authorization(context, url):
"""Access the service API using the HTTP PUT method and authorization token."""
context.response = requests.put(context.coreapi_url + url,
headers=authorization(context))
def access_url_with_authorization_token(context, url):
"""Access the service API using the HTTP GET method."""
context.response = requests.get(context.coreapi_url + url,
headers=authorization(context))
def check_submit_feedback_with_empty_payload(context, url):
"""Access the submit-feedback API using the HTTP POST method with empty payload."""
payload = {}
context.response = requests.post(context.coreapi_url + url,
headers=authorization(context),
data=payload)
def access_license_service_with_authorization_token(context):
"""Access the licence analysis service using the authorization token."""
context.response = requests.get(context.license_service_url,
headers=authorization(context))
def post_invalid_input_to_set_tags(context):
"""Set tags REST API call with invalid json input."""
input_json = {"ecosystem": "maven"} # component and tags are missing.
context.response = requests.post(context.coreapi_url + 'api/v1/set-tags',
data=input_json,
headers=authorization(context))
