def test_set_framework_result_returns_error_message_if_update_fails(
mock_data_client):
mock_data_client.set_framework_result.side_effect = [
HTTPError(), HTTPError(Mock(status_code=400))
]
assert framework_helpers.set_framework_result(mock_data_client, 'g-whizz-6', 123456, True, 'user') == \
" Error inserting result for 123456 (True): Unknown request failure in dmapiclient (status: 503)"
assert framework_helpers.set_framework_result(mock_data_client, 'digital-stuff', 567890, False, 'script-user') == \
" Error inserting result for 567890 (False): Unknown request failure in dmapiclient (status: 400)"
def test_should_not_send_email_if_bad_supplier_id(self, data_api_client,
send_email,
generate_token):
data_api_client.get_supplier.side_effect = HTTPError(Response(404))
data_api_client.find_users.side_effect = HTTPError(Response(404))
res = self.client.post("/admin/suppliers/1234/invite-user",
data={
'email_address': '*****@*****.**',
})
self.assertFalse(data_api_client.find_users.called)
self.assertFalse(send_email.called)
self.assertFalse(generate_token.called)
self.assertEqual(res.status_code, 404)
def test_service_edit_when_API_returns_error(self,
upload_service_documents,
data_api_client):
data_api_client.get_service.return_value = {
'services': {
'id': 1,
'supplierId': 2,
'lot': 'SCS',
'frameworkSlug': 'g-cloud-7',
'pricingDocumentURL':
"http://assets/documents/1/2-pricing.pdf",
'sfiaRateDocumentURL': None
}
}
upload_service_documents.return_value = ({}, {})
data_api_client.update_service.side_effect = HTTPError(
None, {'sfiaRateDocumentURL': 'required'})
response = self.client.post('/admin/services/1/edit/documents',
data={
'pricingDocumentURL':
(BytesIO("doc".encode()), 'test.pdf'),
'sfiaRateDocumentURL':
(BytesIO("doc".encode()), 'test.txt'),
'termsAndConditionsDocumentURL':
(BytesIO(), 'test.pdf'),
'csrf_token':
FakeCsrf.valid_token,
})
self.assertIn('There was a problem with the answer to this question',
response.get_data(as_text=True))
def test_publish_draft_service_retries_republish_api_error(
self, logger_mock):
mock_response = mock.Mock(status_code=400)
mock_response.json.return_value = {
"error": "Cannot re-publish a submitted service"
}
self.mock_data_api_client.publish_draft_service.side_effect = HTTPError(
response=mock_response)
assert publish_draft_service(
self.mock_data_api_client,
self.draft_service,
dry_run=False,
) == ("500400200", True)
assert self.mock_data_api_client.publish_draft_service.call_args_list == [
mock.call(987654, user='******')
]
assert self.mock_data_api_client.get_draft_service.call_args_list == [
mock.call(987654)
]
assert logger_mock.return_value.info.call_args_list == [
mock.call("supplier %s: draft %s: publishing", 999, 987654)
]
assert logger_mock.return_value.warning.call_args_list == [
mock.call(
"supplier %s: draft %s: failed publishing - has service id: %s",
999,
987654,
"500400200",
)
]
def test_create_new_brief_response_error_message_for_normal_question_empty(
self, data_api_client):
data_api_client.get_brief.return_value = self.brief
data_api_client.get_framework.return_value = self.framework
data_api_client.create_brief_response.side_effect = HTTPError(
mock.Mock(status_code=400), {'availability': 'answer_required'})
incomplete_brief_form_submission = brief_form_submission.copy()
incomplete_brief_form_submission.pop('availability')
res = self.client.post(
'/suppliers/opportunities/1234/responses/create',
data=incomplete_brief_form_submission,
follow_redirects=True)
doc = html.fromstring(res.get_data(as_text=True))
assert len(
doc.xpath(
'//*[@id="validation-masthead-heading"]'
'[contains(text(), "There was a problem with your answer to:")]'
)) == 1
assert doc.xpath('//*[@id="content"]//a[@href="#availability"]')[
0].text_content() == 'Date the specialist can start work'
assert len(
doc.xpath(
'//h1[contains(text(), "Apply for ‘I need a thing to do a thing’")]'
)) == 1
assert len(
doc.xpath(
'//h2[contains(text(), "Do you have the essential skills and experience?")]'
)) == 1
assert len(
doc.xpath(
'//h2[contains(text(), "Do you have any of the nice-to-have skills and experience?")]'
)) == 1
self._test_breadcrumbs_on_brief_response_page(res)
def test_get_stats_page_when_API_is_down(self, data_api_client):
api_response = mock.Mock()
api_response.status_code = 500
data_api_client.req.metrics().applications().history(
).get.side_effect = HTTPError(api_response)
response = self.client.get('/admin/statistics/applications')
self.assertEqual(500, response.status_code)
def test_should_return_an_error_if_supplier_user_exists(self):
self.data_api_client.create_user.side_effect = HTTPError(
mock.Mock(status_code=409))
token = self._generate_token(role='supplier')
res = self.client.post('/user/create/{}'.format(token),
data={
'password': '******',
'name': 'valid name'
})
self.data_api_client.create_user.assert_called_once_with({
'role':
'supplier',
'password':
'******',
'emailAddress':
'*****@*****.**',
'name':
'valid name',
'supplierId':
'12345'
})
assert res.status_code == 400
def test_should_return_an_error_if_user_exists(self, data_api_client):
data_api_client.create_user.side_effect = HTTPError(
mock.Mock(status_code=409))
token = self._generate_token()
res = self.client.post(self.url_for('main.submit_create_user',
token=token),
data={
'csrf_token': FakeCsrf.valid_token,
'password': '******',
'name': 'valid name',
'accept_terms': 'y',
})
assert res.status_code == 400
data_api_client.create_user.assert_called_once_with({
'role':
'supplier',
'password':
'******',
'emailAddress':
'*****@*****.**',
'name':
'valid name',
'supplierCode':
1234
})
def test_should_search_by_prefix(self, data_api_client):
data_api_client.find_suppliers.side_effect = HTTPError(Response(404))
self.client.get(
"/admin/suppliers?supplier_name_prefix=foo&per_page=1000")
data_api_client.find_suppliers.assert_called_once_with(prefix='foo',
per_page=1000)
def test_brief_indexer_create_index_raises_on_other_api_errors(self):
self.search_api_client.return_value.create_index.side_effect = HTTPError(
'disaster')
indexer = BriefIndexer('briefs', self.data_api_client.return_value,
self.search_api_client.return_value, 'myIndex')
with pytest.raises(HTTPError) as e:
indexer.create_index('myMapping')
assert e.message == 'disaster'
def test_submit_clarification_question_requires_existing_brief_id(
self, data_api_client):
self.login()
data_api_client.get_brief.side_effect = HTTPError(
mock.Mock(status_code=404))
res = self.client.post('/suppliers/opportunities/1/ask-a-question')
assert res.status_code == 404
def test_q_and_a_session_details_requires_existing_brief_id(
self, data_api_client):
self.login()
data_api_client.get_brief.side_effect = HTTPError(
mock.Mock(status_code=404))
res = self.client.get(
'/suppliers/opportunities/1/question-and-answer-session')
assert res.status_code == 404
def test_q_and_a_session_details_requires_existing_brief_id(
self, data_api_client):
self.login(application_id=1)
data_api_client.get_brief.side_effect = HTTPError(
mock.Mock(status_code=404))
res = self.client.get(
self.url_for('main.question_and_answer_session', brief_id=1))
assert res.status_code == 404
def test_raises_original_error_if_not_404(self):
data_api_client_mock = mock.Mock()
data_api_client_mock.get_framework.side_effect = HTTPError(mock.Mock(status_code=400), 'Original exception')
with pytest.raises(HTTPError) as original_exception:
get_framework_or_500(data_api_client_mock, 'g-cloud-7')
assert original_exception.value.message == 'Original exception'
assert original_exception.value.status_code == 400
def test_should_be_a_503_if_api_fails(self):
self.data_api_client.create_user.side_effect = HTTPError("bad email")
token = self._generate_token(role='buyer')
res = self.client.post('/user/create/{}'.format(token),
data={
'password': '******',
'name': 'valid name'
})
assert res.status_code == 503
def test_create_user_fails(self, decode_user_token, data_api_client):
decode_user_token.return_value = {'name': 'joe', 'email_address': '*****@*****.**'}
data_api_client.create_user.side_effect = HTTPError('fail')
res = self.client.post(
self.url_for('main.create_application', token='test'),
data={'csrf_token': FakeCsrf.valid_token, 'password': '******'}
)
assert res.status_code == 503
def test_add_framework_info_fails_on_non_404_error(mock_data_client):
mock_data_client.get_supplier_framework_info.side_effect = HTTPError(
Mock(status_code=400))
with pytest.raises(HTTPError):
framework_helpers.add_framework_info(mock_data_client,
'framework-slug', {
'supplier_id': 123,
'foo': 'bar'
})
def test_should_display_a_useful_message_if_no_brief_found(self):
self.data_api_client.get_brief.side_effect = HTTPError(
Response(status_code=404))
response = self.client.get('admin/buyers?brief_id=1')
document = html.fromstring(response.get_data(as_text=True))
banner_message = document.xpath(
'//p[@class="banner-message"]//text()')[0].strip()
assert banner_message == "There are no opportunities with ID 1"
def test_should_ignore_index_delete_error(self, search_api_client):
search_api_client.delete.side_effect = HTTPError()
response = self.client.post('/services/{0}/status/{1}'.format(
self.services['published']['id'], 'enabled'),
data=json.dumps({'updated_by':
'joeblogs'}),
content_type='application/json')
assert_equal(response.status_code, 200)
def test_aborts_with_500_if_framework_not_found(self, abort):
data_api_client_mock = mock.Mock()
data_api_client_mock.get_framework.side_effect = HTTPError(mock.Mock(status_code=404), 'Framework not found')
abort.side_effect = CustomAbortException()
with pytest.raises(CustomAbortException):
get_framework_or_500(data_api_client_mock, 'g-cloud-7')
assert abort.call_args_list == [
mock.call(500, 'Framework not found: g-cloud-7')
]
def test_redirect_with_flash_for_api_client_404(self, data_api_client):
response = mock.Mock()
response.status_code = 404
data_api_client.get_service.side_effect = HTTPError(response)
response1 = self.client.get('/admin/services/1')
self.assertEqual(302, response1.status_code)
self.assertEqual(response1.location, 'http://localhost/admin')
response2 = self.client.get(response1.location)
self.assertIn(b'Error trying to retrieve service with ID: 1',
response2.data)
def test_should_be_a_404_if_supplier_code_not_found(self, data_api_client):
data_api_client.get_supplier.side_effect = HTTPError(Response(404))
response = self.client.post('/admin/suppliers/1234/invite-user',
data={'csrf_token': FakeCsrf.valid_token},
follow_redirects=True)
data_api_client.get_supplier.assert_called_with(1234)
self.assertFalse(data_api_client.find_users.called)
self.assertEqual(404, response.status_code)
def test_award_brief_post_raises_500_on_api_error_and_displays_generic_error_message(self):
self.data_api_client.update_brief_award_brief_response.side_effect = HTTPError(
mock.Mock(status_code=500),
{"title": "BriefResponse cannot be awarded for this Brief"}
)
self.login_as_buyer()
res = self.client.post(self.url.format(brief_id=1234), data={'brief_response': 2})
document = html.fromstring(res.get_data(as_text=True))
assert res.status_code == 500
error_span = document.xpath('//h1')[0]
assert self._strip_whitespace(error_span.text_content()) == "Sorry,we’reexperiencingtechnicaldifficulties"
def test_should_be_a_503_if_api_fails(self, data_api_client):
with self.app.app_context():
data_api_client.create_user.side_effect = HTTPError("bad email")
token = self._generate_token()
res = self.client.post('/suppliers/create-user/{}'.format(token),
data={
'password': '******',
'name': 'valid name'
})
assert res.status_code == 503
def test_should_be_a_404_if_supplier_users_not_found(
self, data_api_client):
data_api_client.get_supplier.return_value = self.load_example_listing(
"supplier_response")
data_api_client.find_users.side_effect = HTTPError(Response(404))
response = self.client.post("/admin/suppliers/1234/invite-user",
data={},
follow_redirects=True)
data_api_client.get_supplier.assert_called_with(1234)
data_api_client.find_users.assert_called_with(1234)
self.assertEquals(404, response.status_code)
def test_calls_logger_if_provided(self, abort):
data_api_client_mock = mock.Mock()
logger_mock = mock.Mock()
data_api_client_mock.get_framework.side_effect = HTTPError(mock.Mock(status_code=404), 'An error from the API')
get_framework_or_500(data_api_client_mock, 'g-cloud-7', logger_mock)
assert logger_mock.error.call_args_list == [
mock.call(
'Framework not found. Error: {error}, framework_slug: {framework_slug}',
extra={'error': 'An error from the API (status: 404)', 'framework_slug': 'g-cloud-7'},
)
]
def test_aborts_with_404_if_framework_not_found(self):
self.data_api_client_mock.get_framework.side_effect = HTTPError(
mock.Mock(status_code=404), 'Framework not found')
@return_404_if_applications_closed(lambda: self.data_api_client_mock)
def view_function(framework_slug):
pass
with pytest.raises(HTTPError) as e:
view_function(framework_slug='not_a_framework')
assert e.value.status_code == 404
assert e.value.message == "Framework not found"
def test_should_return_503_if_api_error(self, data_api_client):
with self.client.session_transaction() as sess:
sess['email_address'] = "email_address"
sess['phone_number'] = "phone_number"
sess['contact_name'] = "contact_name"
sess['duns_number'] = "duns_number"
sess['company_name'] = "company_name"
sess['account_email_address'] = "account_email_address"
data_api_client.create_supplier.side_effect = HTTPError("gone bad")
res = self.client.post(self.url_for('main.submit_company_summary'),
data=csrf_only_request)
assert_equal(res.status_code, 503)
def test_should_ignore_index_error_on_service_put(self, search_api_client):
with self.app.app_context():
search_api_client.index.side_effect = HTTPError()
payload = self.load_example_listing("G6-IaaS")
payload['id'] = "1234567890123456"
response = self.client.put('/services/1234567890123456',
data=json.dumps({
'updated_by': 'joeblogs',
'services': payload
}),
content_type='application/json')
assert_equal(response.status_code, 201)
def test_brief_not_found_flash_message_injection(self):
"""
Asserts that raw HTML in a bad brief ID cannot be injected into a flash message.
"""
# impl copied from test_should_display_a_useful_message_if_no_brief_found
self.data_api_client.get_brief.side_effect = HTTPError(
Response(status_code=404))
response = self.client.get(
'admin/buyers?brief_id=1%3Cimg%20src%3Da%20onerror%3Dalert%281%29%3E'
)
assert response.status_code == 404
html_response = response.get_data(as_text=True)
assert "1<img src=a onerror=alert(1)>" not in html_response
assert "1<img src=a onerror=alert(1)>" in html_response
