def create_and_validate_account(token, post_data):
"""
Create an account and validate that all entries have been correctly made.
:param str token: authentication token
:param dict post_data: JSON string of account values
"""
response = send_request('post', ATSServiceApiUrl.ACCOUNTS, token,
post_data)
assert response.status_code == codes.CREATED
account_id = response.headers['location'].split('/')[-1]
response = send_request('get',
ATSServiceApiUrl.ACCOUNT % account_id,
token, {},
verify=False)
assert response.status_code == codes.OK
values = response.json()
assert values['credentials'] == post_data['ats_credentials']
# Get all ATS - there should only be one - then validate the first (and only) one
response = send_request('get',
ATSServiceApiUrl.ATS,
token, {},
verify=False)
assert response.status_code == codes.OK
values = response.json()
# This fails occasionally in parallel tests due to a race condition.
# assert len(values) == 1
assert values['ats_list'][0]['login_url'] == post_data['ats_login']
return account_id
def create_and_validate_candidate(token, account_id, post_data):
"""
Create a candidate and validate that all entries have been correctly made.
:param str token: authentication token
:param int account_id: primary key of the account
:param dict post_data: JSON string of candidate values
"""
# Grab a candidate field value to test
profile_dict = json.loads(post_data['profile_json'])
# Create an ATS account for the candidate to belong to
response = send_request('post', ATSServiceApiUrl.CANDIDATES % account_id,
token, post_data)
assert response.status_code == codes.CREATED
values = response.json()
candidate_id = values['id']
# Now fetch all the candidates from the account
response = send_request('get',
ATSServiceApiUrl.CANDIDATES % account_id,
token, {},
verify=False)
assert response.status_code == codes.OK
values = response.json()
assert len(values['candidate_list']) == 1
# Extract the returned field
key = values['candidate_list'][0].keys()[0]
profile = json.loads(values['candidate_list'][0][key]['profile_json'])
assert profile['some'] == profile_dict.values()[0]
return candidate_id
def test_unlink_ats_candidate(self, access_token_first, account_post_data,
candidate_post_data, candidate_first):
"""
POST /v1/ats-candidates/:account_id
DELETE /v1/ats-candidates/link/:candidate_id/:ats_candidate_id
GET /v1/ats-candidates/:account_id/:candidate_id
:param str access_token_first: authentication token
:param dict account_post_data: values for creating an ATS account
:param dict candidate_post_data: values for creating an ATS account
"""
account_id, gt_candidate_id, ats_candidate_id = link_candidates(
access_token_first, account_post_data, candidate_post_data,
candidate_first)
response = send_request(
'delete', ATSServiceApiUrl.CANDIDATE_LINK %
(gt_candidate_id, ats_candidate_id), access_token_first)
assert response.status_code == codes.OK
response = send_request('get',
ATSServiceApiUrl.CANDIDATE %
(account_id, ats_candidate_id),
access_token_first, {},
verify=False)
assert response.status_code == codes.OK
values = json.loads(response.text)
assert values['gt_candidate_id'] is None
def test_update_ats_account(self, access_token_first, account_post_data):
"""
POST /v1/ats-accounts Test creating an account
PUT /v1/ats-accounts/:account_id Test updating an account
GET /v1/ats-accounts/:account_id Test fetching an account
Update and verify new data of account.
:param str access_token_first: authentication token
:param dict account_post_data: values for creating an ATS account
"""
account_id = create_and_validate_account(access_token_first,
account_post_data)
key = 'ats_homepage'
value = 'https://someotherhost.com/authenticate'
new_data = {key: value}
response = send_request('put', ATSServiceApiUrl.ACCOUNT % account_id,
access_token_first, new_data)
assert response.status_code == codes.CREATED
response = send_request('get',
ATSServiceApiUrl.ACCOUNT % account_id,
access_token_first, {},
verify=False)
assert response.status_code == codes.OK
# TODO: Normalize service output text between endpoints
values = json.loads(response.text)
assert values[key] == value
def test_post_account_without_auth(self, account_post_data):
"""
POST /v1/ats-accounts
Test authentication failure.
:param dict account_post_data: values for creating an ATS account
"""
response = send_request('post', ATSServiceApiUrl.ACCOUNTS,
'bad_bad_token', account_post_data)
assert response.status_code == codes.UNAUTHORIZED
def verify_nonexistant_account(token, account_id):
"""
Verify that an account does not exist.
:param str token: authentication token
:param int account_id: primary key of the account
"""
response = send_request('get',
ATSServiceApiUrl.ACCOUNT % account_id,
token, {},
verify=False)
assert response.status_code == codes.NOT_FOUND
def missing_field_test(data, key, token):
"""
This function sends a POST request to the ATS account api with data which has one required field missing.
:param dict data: ATS data
:param string key: field key
:param string token: auth token
"""
del data[key]
response = send_request('post', ATSServiceApiUrl.ACCOUNTS, token, data)
assert response.status_code == codes.BAD_REQUEST
response = response.json()
error = response['error']
assert error['missing_fields'] == [key]
def test_update_ats_candidate(self, access_token_first, account_post_data,
candidate_post_data):
"""
POST /v1/ats-candidates/:account_id
PUT /v1/ats-candidates/:account_id/:candidate_id
GET /v1/ats-candidates/:account_id/:candidate_id
Test updating an existing candidate's profile.
:param str access_token_first: authentication token
:param dict account_post_data: values for creating an ATS account
:param dict candidate_post_data: values for creating an ATS account
"""
account_id = create_and_validate_account(access_token_first,
account_post_data)
candidate_id = create_and_validate_candidate(access_token_first,
account_id,
candidate_post_data)
response = send_request('get',
ATSServiceApiUrl.CANDIDATE %
(account_id, candidate_id),
access_token_first, {},
verify=False)
assert response.status_code == codes.OK
values = json.loads(response.text)
new_value = '{ "some_other" : "json" }'
values['profile_json'] = new_value
response = send_request(
'put', ATSServiceApiUrl.CANDIDATE % (account_id, candidate_id),
access_token_first, values)
assert response.status_code == codes.CREATED
response = send_request('get',
ATSServiceApiUrl.CANDIDATE %
(account_id, candidate_id),
access_token_first, {},
verify=False)
values = json.loads(response.text)
assert values['profile_json'] == new_value
def verify_nonexistant_candidate(token, account_id, candidate_id):
"""
Verify that a candidate does not exist.
:param str token: authentication token
:param int account_id: primary key of the account
:param int candidate_id: primary key of the candidate
"""
response = send_request('get',
ATSServiceApiUrl.CANDIDATE %
(account_id, candidate_id),
token, {},
verify=False)
assert response.status_code == codes.NOT_FOUND
def test_ats_gt_match_empty(self, access_token_first, account_post_data):
"""
PATCH /v1/ats-candidates/match-link/:account_id/:match-method
Test that no matches are found.
:param str access_token_first: authentication token
:param dict account_post_data: values for creating an ATS account
"""
account_id = create_and_validate_account(access_token_first,
account_post_data)
response = send_request(
'patch', ATSServiceApiUrl.MATCH_AND_LINK % (account_id, u'email'),
access_token_first, {})
assert response.status_code == codes.OK
values = json.loads(response.text)
assert values['matches'] == 0
response = send_request(
'patch', ATSServiceApiUrl.MATCH_AND_LINK % (account_id, u'phone'),
access_token_first, {})
assert response.status_code == codes.OK
values = json.loads(response.text)
assert values['matches'] == 0
response = send_request(
'patch',
ATSServiceApiUrl.MATCH_AND_LINK % (account_id, u'email-and-phone'),
access_token_first, {})
assert response.status_code == codes.OK
values = json.loads(response.text)
assert values['matches'] == 0
response = send_request(
'patch',
ATSServiceApiUrl.MATCH_AND_LINK % (account_id, u'email-or-phone'),
access_token_first, {})
assert response.status_code == codes.OK
values = json.loads(response.text)
assert values['matches'] == 0
def link_candidates(token, account_data, candidate_data, gt_candidate):
"""
Link a GT candidate to an ATS candidate and validate the link.
:param str token: authentication token
:param dict account_data: data to create an account with
:param dict candidate_data: data to create an ATS candidate
:param Candidate gt_candidate: candidate object
"""
account_id = create_and_validate_account(token, account_data)
candidate_id = create_and_validate_candidate(token, account_id,
candidate_data)
url = ATSServiceApiUrl.CANDIDATE_LINK % (gt_candidate.id, candidate_id)
response = send_request('post', url, token, {})
assert response.status_code == codes.CREATED
response = send_request('get',
ATSServiceApiUrl.CANDIDATE %
(account_id, candidate_id),
token, {},
verify=False)
assert response.status_code == codes.OK
values = response.json()
assert gt_candidate.id == int(values['gt_candidate_id'])
return account_id, gt_candidate.id, candidate_id
def test_delete_ats_account(self, access_token_first, account_post_data):
"""
POST /v1/ats-accounts Test creating an account
DELETE /v1/ats-accounts/:account_id
Verify deletion of account.
:param str access_token_first: authentication token
:param dict account_post_data: values for creating an ATS account
"""
account_id = create_and_validate_account(access_token_first,
account_post_data)
response = send_request('delete',
ATSServiceApiUrl.ACCOUNT % account_id,
access_token_first)
assert response.status_code == codes.OK
values = json.loads(response.text)
assert values['delete'] == 'success'
verify_nonexistant_account(access_token_first, account_id)
def test_delete_ats_candidate(self, access_token_first, account_post_data,
candidate_post_data):
"""
POST /v1/ats-candidates/:account_id
GET /v1/ats-candidates/:account_id/:candidate_id
DELETE /v1/ats-candidates/:account_id/:candidate_id
Create an account, insert a candidate, then delete it and verify that it's gone.
:param str access_token_first: authentication token
:param dict account_post_data: values for creating an ATS account
:param dict candidate_post_data: values for creating an ATS account
"""
account_id = create_and_validate_account(access_token_first,
account_post_data)
candidate_id = create_and_validate_candidate(access_token_first,
account_id,
candidate_post_data)
response = send_request(
'delete', ATSServiceApiUrl.CANDIDATE % (account_id, candidate_id),
access_token_first)
assert response.status_code == codes.OK
verify_nonexistant_candidate(access_token_first, account_id,
candidate_id)