def invalid_data_test(method, url, token):
"""
This functions sends http request to a given URL with different
invalid data and checks for InvalidUsage (400 status code)
:param http_method method: http method e.g. POST, PUT, DELETE
:param string url: api url
:param string token: auth token
"""
data_set = [None, {}, get_fake_dict(), '', ' ', []]
for data in data_set:
response = send_request(method, url, token, data, is_json=False)
assert response.status_code == codes.BAD_REQUEST
response = send_request(method, url, token, data, is_json=True)
assert response.status_code == codes.BAD_REQUEST
def invalid_value_test(url,
data,
key,
values,
token,
method='post',
expected_status=(codes.BAD_REQUEST, )):
"""
This function sends a request to given url with required field
having an invalid value and checks that it returns InvalidUsage 400
:param dict data: campaign data
:param string url: api endpoint url
:param string key: field key
:param list values: possible invalid values
:param string token: auth token
:param http_method method: http request method, post/put
:param tuple(int) expected_status: what can be possible expected status for this request
:Example:
>>> invalid_values = ['', ' ', {}, [], None, True]
>>> invalid_value_test(URL, campaign_data, 'body_text', invalid_values, token_first)
"""
for val in values:
data[key] = val
response = send_request(method, url, token, data)
assert response.status_code in expected_status, 'Invalid field %s with value %s' % (
key, val)
def create_candidate(talent_pool_id, token, expected_status=(201, )):
"""
This method sends a POST request to Candidate API to create a candidate.
:type talent_pool_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
data = {
"candidates": [{
"first_name":
fake.first_name(),
"middle_name":
fake.user_name(),
"last_name":
fake.last_name(),
"talent_pool_ids": {
"add": [talent_pool_id]
},
"emails": [{
"label": "Primary",
"address": fake.safe_email(),
"is_default": True
}]
}]
}
response = send_request('post',
CandidateApiUrl.CANDIDATES,
token,
data=data)
print('common_tests : create_candidate: ', response.content)
assert response.status_code in expected_status
return response.json()
def create_talent_pipelines(token,
talent_pool_id,
count=1,
expected_status=(200, )):
"""
This method sends a POST request to CandidatePool API to create a talent pipeline.
:type token: string
:type talent_pool_id: int | long
:type count: int
:type expected_status: tuple[int]
:rtype dict
"""
data = {"talent_pipelines": []}
for index in xrange(count):
talent_pipeline = {
"name":
random_word(30),
"description":
fake.paragraph(),
"talent_pool_id":
talent_pool_id,
"date_needed":
(datetime.now() + timedelta(days=100)).strftime("%Y-%m-%d")
}
data["talent_pipelines"].append(talent_pipeline)
response = send_request('post',
CandidatePoolApiUrl.TALENT_PIPELINES,
token,
data=data)
print('common_tests : create_talent_pipelines: ', response.content)
assert response.status_code in expected_status
return response.json()
def unauthorize_test(method, url, data=None):
"""
This method is used to test for unauthorized requests (401).
:param http_method method: http method
:param string url: target url
:param (dict | None) data: dictionary payload
:return:
"""
response = send_request(method, url, 'invalid_token', data)
print('common_tests : unauthorize_test: ', response.content)
assert response.status_code == codes.UNAUTHORIZED
def delete_scheduler_task(task_id, token, expected_status=(200, )):
"""
This method sends a DELETE request to Scheduler API to delete a scheduled task.
:type task_id: string
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request('delete', SchedulerApiUrl.TASK % task_id, token)
print('common_tests : delete_scheduler: ', response.content)
assert response.status_code in expected_status
return response.json()
def delete_candidate(candidate_id, token, expected_status=(200, )):
"""
This method sends a DELETE request to Candidate API to delete a candidate given by candidate_id.
:type candidate_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request('delete', CandidateApiUrl.CANDIDATE % candidate_id,
token)
print('common_tests : delete_candidate: ', response.content)
assert response.status_code in expected_status
def unexpected_field_test(method, url, data, token):
"""
This function send a request to given URL with an unexpected field in request body.
API should raise InvalidUsage 400
:param http_method method: request method, POST/PUT
:param string url: API resource url
:param dict data: request data
:param string token: access token
"""
fake_word = fake.word()
data[fake_word] = fake_word
response = send_request(method, url, token, data)
assert response.status_code == codes.BAD_REQUEST, 'Unexpected field name: %s' % fake_word
def invalid_data_test(method, url, token):
"""
This functions sends http request to a given url with different
invalid data and checks for InvalidUsage
:param http_method method: http method e.g. POST, PUT
:param string url: api url
:param string token: auth token
:return:
"""
data = None
response = send_request(method, url, token, data, is_json=True)
assert response.status_code == codes.BAD_REQUEST
response = send_request(method, url, token, data, is_json=False)
assert response.status_code == codes.BAD_REQUEST
data = {}
response = send_request(method, url, token, data, is_json=True)
assert response.status_code == codes.BAD_REQUEST
response = send_request(method, url, token, data, is_json=False)
assert response.status_code == codes.BAD_REQUEST
data = get_fake_dict()
response = send_request(method, url, token, data, is_json=False)
assert response.status_code == codes.BAD_REQUEST
def get_talent_pipeline(talent_pipeline_id, token, expected_status=(200, )):
"""
This method sends a GET request to CandidatePool API to get talent pipeline.
:type talent_pipeline_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request(
'get', CandidatePoolApiUrl.TALENT_PIPELINE % talent_pipeline_id, token)
print('common_tests : get_talent_pipeline: ', response.content)
assert response.status_code in expected_status
return response.json()
def get_and_assert_zero(url, key, token, sleep_time=SLEEP_TIME):
"""
This function gets list of objects from given url and asserts that length of objects under a given key is zero.
It keeps on retrying this process until it founds some records or sleep_time is over
:param string url: URL of requested resource
:param string key: key in response that has resource list
:param string token: user access token
:param int sleep_time: maximum time to wait
"""
attempts = sleep_time / SLEEP_INTERVAL
for _ in retrier(attempts=attempts, sleeptime=SLEEP_INTERVAL,
sleepscale=1):
assert len(send_request('get', url, token).json()[key]) == 0
def get_candidate(candidate_id, token, expected_status=(200, )):
"""
This method sends a GET request to Candidate API to get a candidate info.
:type candidate_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request('get', CandidateApiUrl.CANDIDATE % candidate_id,
token)
print('common_tests : get_candidate: ', response.content)
assert response.status_code in expected_status
return response.json()
def remove_roles(user_id, roles, token):
"""
This method sends a DELETE request to UserService to remove given roles to given user
:param (int | long) user_id: id of user
:param list[>0] roles: permissions list
:param string token: auth token
"""
data = {"roles": roles}
response = send_request('delete',
UserServiceApiUrl.USER_ROLES_API % user_id,
token,
data=data)
print('common_tests : remove_roles: ', response.content)
assert response.status_code in [codes.OK, codes.BAD_REQUEST]
def delete_talent_pool(talent_pool_id, token, expected_status=(200, )):
"""
This method sends a DELETE request to CandidatePool API to delete a talent pool.
:type talent_pool_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request('delete',
CandidatePoolApiUrl.TALENT_POOL % talent_pool_id,
token)
print('common_tests : delete_talent_pool: ', response.content)
assert response.status_code in expected_status
return response.json()
def get_user(user_id, token):
"""
This utility is used to get user info from UserService
:param user_id: user unique identifier
:type user_id: int | long
:param token: authentication token for user
:type token: string
:return: user dictionary
:rtype: dict
"""
response = send_request('get', UserServiceApiUrl.USER % user_id, token)
print('common_tests : get_user: '******'user']
def delete_smartlist(smartlist_id, token, expected_status=(200, )):
"""
This method sends a DELETE request to CandidatePool API to delete a smartlist.
:type smartlist_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request('delete',
CandidatePoolApiUrl.SMARTLIST % smartlist_id,
token)
print('common_tests : delete_smartlist: ', response.content)
assert response.status_code in expected_status
return response.json()
def get_candidate_devices(candidate_id, token, expected_status=(200, )):
"""
This method sends a GET request to Candidate API to get all associated OneSignal Device Ids to a candidate.
:type candidate_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request('get', CandidateApiUrl.DEVICES % candidate_id,
token)
print('tests : get_candidate_devices: %s', response.content)
assert response.status_code in expected_status
return response.json()
def missing_keys_test(url, data, keys, token, method='post'):
"""
This function sends a request to given url after removing required field from given (valid) data.
We are expecting that API should raise InvalidUsage error (400 status code)
:param string url: api endpoint url
:param dict data: request body data
:param list | tuple keys: required fields
:param string token: auth token
:param http_method method: http request method, post/put
"""
for key in keys:
new_data = data.copy()
new_data.pop(key)
response = send_request(method, url, token, new_data)
assert response.status_code == codes.BAD_REQUEST, 'Test failed for key: %s' % key
def search_candidates(candidate_ids, token, expected_status=(200, )):
"""
This method sends a GET request to Candidate Search API to get candidates from CloudSearch.
:type candidate_ids: list|tuple
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
params = {'candidate_ids': candidate_ids}
response = send_request('get',
CandidateApiUrl.CANDIDATE_SEARCH_URI,
token,
data=params)
print('common_tests : get_candidate: ', response.content)
assert response.status_code in expected_status
return response.json()
def get_smartlist_candidates(smartlist_id,
token,
expected_status=(200, ),
count=None):
"""
This method sends a GET request to CandidatePool API to get list of candidates associated to a smartlist.
:type smartlist_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
response = send_request(
'get', CandidatePoolApiUrl.SMARTLIST_CANDIDATES % smartlist_id, token)
print('common_tests : get_smartlist_candidates: ', response.content)
assert response.status_code in expected_status
response = response.json()
if count:
assert len(response['candidates']) == count,\
'Expecting {} candidates, Found:{}'.format(count, len(response['candidates']))
return response
def add_roles(user_id, roles, token):
"""
This method sends a POST request to UserService to add given roles to given user
:param ((int | long), >0) user_id: user unique id in gt database
:param list | tuple roles: permissions list
:param string token: auth token
"""
assert roles, 'roles should be a non-empty list or tuple, given: %s' % roles
assert token, 'token should be a non-empty string, given: %s' % token
for role in roles:
data = {"roles": [role]}
response = send_request('post',
UserServiceApiUrl.USER_ROLES_API % user_id,
token,
data=data)
if response.status_code == codes.BAD_REQUEST:
assert response.json(
)['error']['code'] == ErrorCodes.ROLE_ALREADY_EXISTS
else:
assert response.status_code == codes.OK
def get_activity(type_id,
source_id,
source_table,
token,
expected_status=(200, )):
"""
This method sends a GET request to Activity Service API to get specific activity.
:param int | long type_id: activity type id, like 4 for campaign creation
:param int | long source_id: id of source object like push campaign id
:param string source_table: source table name, like push_campaign
:param string token: access token
:type expected_status: tuple[int]
:rtype dict
"""
url = "{}?type={}&source_id={}&source_table={}".format(
ActivityApiUrl.ACTIVITIES, type_id, source_id, source_table)
response = send_request('get', url, token)
print('common_tests : get_activity: ', response.content)
assert response.status_code in expected_status
return response.json()
def delete_candidate_device(candidate_id,
device_id,
token,
expected_status=(200, )):
"""
This method sends a DELETE request to Candidate API to delete OneSignal Device that is associated to a candidate.
:type candidate_id: int | long
:type device_id: string
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
data = {'one_signal_device_id': device_id}
response = send_request('delete',
CandidateApiUrl.DEVICES % candidate_id,
token,
data=data)
print('tests : delete_candidate_devices: %s', response.content)
assert response.status_code in expected_status
return response.json()
def associate_device_to_candidate(candidate_id,
device_id,
token,
expected_status=(201, )):
"""
This method sends a POST request to Candidate API to associate a OneSignal Device Id to a candidate.
:type candidate_id: int | long
:type device_id: string
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
data = {'one_signal_device_id': device_id}
response = send_request('post',
CandidateApiUrl.DEVICES % candidate_id,
token,
data=data)
print('tests : associate_device_to_candidate: %s', response.content)
assert response.status_code in expected_status
return response.json()
def add_test_venue(token, user, social_network):
social_network_id = social_network['id']
venue = {
"social_network_id": social_network_id,
"user_id": user['id'],
"zip_code": "54600",
"address_line_2": "H# 163, Block A",
"address_line_1": "New Muslim Town",
"latitude": 0,
"longitude": 0,
"state": "Punjab",
"city": "Lahore",
"country": "Pakistan"
}
response_post = send_request('POST',
SocialNetworkApiUrl.VENUES,
access_token=token,
data=venue)
assert response_post.status_code == codes.created, response_post.text
venue_id = response_post.json()['id']
return {'id': venue_id}
def create_talent_pools(token, count=1, expected_status=(200, )):
"""
This method sends a POST request to CandidatePool API to create a talent pool.
:type token: string
:type count: int | long
:type expected_status: tuple[int]
:rtype dict
"""
data = {"talent_pools": []}
for index in xrange(count):
talent_pool = {
"name": str(uuid.uuid4())[:20],
"description": fake.paragraph()
}
data["talent_pools"].append(talent_pool)
response = send_request('post',
CandidatePoolApiUrl.TALENT_POOLS,
token,
data=data)
print('common_tests : create_talent_pools: ', response.content)
assert response.status_code in expected_status
return response.json()
def create_smartlist(candidate_ids,
talent_pipeline_id,
token,
expected_status=(201, )):
"""
This method sends a POST request to CandidatePool API to create a smartlist.
:type candidate_ids: list|tuple
:type talent_pipeline_id: int | long
:type token: string
:type expected_status: tuple[int]
:rtype dict
"""
data = {
'candidate_ids': candidate_ids,
'name': fake.word(),
"talent_pipeline_id": talent_pipeline_id
}
response = send_request('post',
CandidatePoolApiUrl.SMARTLISTS,
token,
data=data)
print('common_tests : create_smartlist: ', response.content)
assert response.status_code in expected_status
return response.json()
