def test_httpretty_socket():
"""
Using raw sockets will also fail with ``httpretty``.
"""
# Define HTTP request details.
method = 'POST'
url = 'http://127.0.0.1/api/data'
data = {'hello': 'world'}
# Mock HTTP conversation.
httpretty.register_uri(httpretty.POST,
url,
body=json.dumps({'status': 'ok'}))
# Invoke HTTP request.
send_request(url, method, json=data)
# Proof everything is in place.
# Check response.
#assert response.json() == {'status': 'ok'}
# Check request.
assert len(httpretty.latest_requests()) == 1
assert httpretty.last_request() == httpretty.latest_requests()[0]
assert httpretty.last_request().body == json.dumps(data).encode()
def test_periodic(mock_send_request, telemetry_writer):
"""tests that periodic() sends queued app-started and integration events to the agent"""
# add 1 event to the queue
telemetry_writer.app_started_event()
# queue two integrations
telemetry_writer.add_integration("integration-1", True)
telemetry_writer.add_integration("integration-2", False)
with mock.patch("ddtrace.internal.telemetry.writer.log") as log:
# send all events to the agent proxy
telemetry_writer.periodic()
# assert no warning logs were generated while sending telemetry requests
log.warning.assert_not_called()
# ensure one app-started and one app-integrations-change event was sent
assert len(httpretty.latest_requests()) == 2
# queue 2 more integrations
telemetry_writer.add_integration("integration-3", True)
telemetry_writer.add_integration("integration-4", False)
with mock.patch("ddtrace.internal.telemetry.writer.log") as log:
# send both integrations to the agent proxy
telemetry_writer.periodic()
# assert no warning logs were generated while sending telemetry requests
log.warning.assert_not_called()
# ensure one more app-integrations-change events was sent
# 2 requests were sent in the previous flush
assert len(httpretty.latest_requests()) == 3
def test_latest_requests():
"""httpretty.all_request() correctly returns all requests made"""
httpretty.latest_requests().should.equal([])
httpretty.httpretty.latest_requests = [HTTPrettyRequestEmpty(), HTTPrettyRequestEmpty()]
httpretty.latest_requests().should.equal(httpretty.httpretty.latest_requests)
httpretty.httpretty.latest_requests = []
def test_httpretty_cpython_requests():
"""
Using the ``requests`` module works perfectly.
"""
# Define HTTP request details.
url = 'http://127.0.0.1/api/data'
data = {'hello': 'world'}
# Mock HTTP conversation.
httpretty.register_uri(httpretty.POST,
url,
body=json.dumps({'status': 'ok'}))
# Invoke HTTP request.
response = requests.post(url, json=data)
# Proof everything is in place.
# Check response.
assert response.json() == {'status': 'ok'}
# Check request.
assert len(httpretty.latest_requests()) == 1
assert httpretty.last_request() == httpretty.latest_requests()[0]
assert httpretty.last_request().body == json.dumps(data).encode()
def test_get_transcript__create_consent_cookie_if_needed(self):
httpretty.register_uri(
httpretty.GET,
'https://www.youtube.com/watch',
body=load_asset('youtube_consent_page.html.static'))
YouTubeTranscriptApi.get_transcript('F1xioXWb8CY')
self.assertEqual(len(httpretty.latest_requests()), 3)
for request in httpretty.latest_requests()[1:]:
self.assertEqual(request.headers['cookie'],
'CONSENT=YES+cb.20210328-17-p0.de+FX+119')
def test_add_app_closing_event(mock_time, mock_send_request, telemetry_writer):
"""asserts that shutdown() queues and sends an app-closing telemetry request"""
# send app closed event
telemetry_writer.shutdown()
# assert that one request was sent
assert len(httpretty.latest_requests()) == 1
# ensure an app closing event was sent
headers = httpretty.last_request().headers
assert "DD-Telemetry-Request-Type" in headers
assert headers["DD-Telemetry-Request-Type"] == "app-closing"
# ensure a valid request body was sent
assert len(httpretty.latest_requests()) == 1
assert httpretty.last_request().parsed_body == _get_request_body(
{}, "app-closing")
def shutdown_server(test_calls):
"""Shutdown server and test request calls"""
httpretty.latest_requests().should.have.length_of(len(test_calls))
for expected_test_call, test_call in zip(test_calls,
httpretty.latest_requests()):
expected_test_call["method"].should.equal(test_call.method)
expected_test_call["uri"].should.equal(test_call.path)
if "rq" in expected_test_call:
expected_body = expected_test_call["rq"]
real_body = test_call.parse_request_body(test_call.body)
if type(expected_body) == str and type(real_body) != str:
expected_body = json.loads(expected_body)
expected_body.should.equal(real_body)
httpretty.disable()
httpretty.reset()
def test_return_failure_immediately_when_response_is_in_fail_on_code():
"""Test raise ignore retries and returns responses immediately."""
httpretty.register_uri(httpretty.GET, "http://test.com/test", status=404)
result = spintest(
["http://test.com"],
[{
"method": "GET",
"route": "/test",
"expected": {
"body": {
"resource": "CREATED"
},
},
"fail_on": [{
"code": 404
}],
"retry": 1,
"delay": 0, # Make test quicker
}],
)
expected_call_nb = 1 # First call (404)
assert expected_call_nb == len(httpretty.latest_requests())
assert result is False
def test_max_retries(self):
session = Session("https://example.com",
max_retries=5,
backoff_factor=0)
httpretty.register_uri(
httpretty.GET,
"https://example.com/",
responses=[
httpretty.Response(
body="",
status=500,
),
httpretty.Response(
body="",
status=500,
),
httpretty.Response(
body="",
status=500,
),
],
)
with self.assertRaises(RetryError):
_ = session.get("")
self.assertEqual(6, len(httpretty.latest_requests()))
def test_backoff_factor(self):
backoff_factor = 0.5
max_retries = 4
total_delay = sum(backoff_factor * (2**n)
for n in range(1, max_retries))
session = Session(
"https://example.com",
max_retries=max_retries,
backoff_factor=backoff_factor,
)
httpretty.register_uri(
httpretty.GET,
"https://example.com/",
responses=[
httpretty.Response(
body="",
status=500,
) for _ in range(max_retries)
],
)
start_time = time.time()
with self.assertRaises(RetryError):
_ = session.get("")
end_time = time.time()
time_diff = end_time - start_time
self.assertAlmostEqual(time_diff, total_delay, places=0)
self.assertEqual(max_retries + 1, len(httpretty.latest_requests()))
def test_fail_on_in_strict_mode():
for _i in range(2):
httpretty.register_uri(
httpretty.GET,
"http://test.com/test",
body=json.dumps({"keys": ["ko", "waiting"]}),
status=200,
)
result = spintest(
["http://test.com"],
[{
"method": "GET",
"route": "/test",
"expected": {
"code": 200,
"body": {
"keys": ["ok"]
},
"expected_match": "strict",
},
"fail_on": [{
"body": {
"keys": ["ko"]
},
"expected_match": "strict",
}],
"retry": 1,
"delay": 0, # Make test quicker
}],
)
assert False is result
expected_call_nb = 2 # First call and then retry
assert expected_call_nb == len(httpretty.latest_requests())
def test_slack_api__client_5xx_doesnt_raise(mock_sleep, mock_secret_reader):
"""Don't raise an exception if the max retries aren't reached."""
uri_args = (httpretty.POST, 'https://www.slack.com/api/users.list')
uri_kwargs_failure = {
'body': json.dumps({
'ok': 'false',
'error': 'internal_error'
}),
'status': 500
}
uri_kwargs_success = {'body': json.dumps({'ok': 'true'}), 'status': 200}
# These are registered LIFO (3 failures and then 1 success)
httpretty.register_uri(*uri_args, **uri_kwargs_success)
httpretty.register_uri(*uri_args, **uri_kwargs_failure)
httpretty.register_uri(*uri_args, **uri_kwargs_failure)
httpretty.register_uri(*uri_args, **uri_kwargs_failure)
slack_client = SlackApi('workspace', {
'path': 'some/path',
'field': 'some-field'
},
init_usergroups=False)
slack_client._sc.api_call('users.list')
assert len(httpretty.latest_requests()) == 4
def assert_index_deleted(path):
delete_requests = [
request
for request in httpretty.latest_requests()
if request.method == "DELETE" and request.path == f"{path}index.html"
]
assert len(delete_requests) == 1
def test_add_integration(mock_time, mock_send_request, telemetry_writer):
"""asserts that add_integration() queues a valid telemetry request"""
# queue integrations
telemetry_writer.add_integration("integration-t", True)
telemetry_writer.add_integration("integration-f", False)
# send integrations to the agent
telemetry_writer.periodic()
# assert integration change telemetry request was sent
assert len(httpretty.latest_requests()) == 1
headers = httpretty.last_request().headers
assert "DD-Telemetry-Request-Type" in headers
assert headers["DD-Telemetry-Request-Type"] == "app-integrations-change"
# assert that the request had a valid request body
expected_payload = {
"integrations": [
{
"name": "integration-t",
"version": "",
"enabled": True,
"auto_enabled": True,
"compatible": True,
"error": "",
},
{
"name": "integration-f",
"version": "",
"enabled": True,
"auto_enabled": False,
"compatible": True,
"error": "",
},
]
}
assert httpretty.last_request().parsed_body == _get_request_body(
expected_payload, "app-integrations-change")
def test_get_user_fails_when_uncommon_http_error_received(kentik_api) -> None:
# given
httpretty.register_uri(
httpretty.GET,
f"{FAKE_API_URL}/user/{DUMMY_USER_ID}",
status=418,
body='{"error":"I\'m a Teapot"}',
)
# when
with pytest.raises(ProtocolError) as exc_info:
kentik_api.users.get(DUMMY_USER_ID)
# then
assert len(httpretty.latest_requests()) == 1
assert len(httpretty.last_request().querystring) == 0
assert httpretty.last_request().headers.get(
AUTH_EMAIL_KEY) == DUMMY_AUTH_EMAIL
assert httpretty.last_request().headers.get(
AUTH_API_TOKEN_KEY) == DUMMY_TOKEN
assert len(httpretty.last_request().body) == 0
assert exc_info.value.protocol == "HTTP"
assert exc_info.value.status_code == 418
assert str(exc_info.value) == '{"error":"I\'m a Teapot"}'
def assert_index_created_correctly(
items, path, site_name="foo-bucket", title=None, root_index=False
):
if not title:
title = path
regular_expressions = [
f"<title>Index of {re.escape(site_name)}{re.escape(title)}</title>",
f"<h1>Index of {re.escape(site_name)}{re.escape(title)}</h1>",
'<address style="font-size:small;">Generated by <a href="https://github.com/hmrc/bucket-dir">bucket-dir</a>.</address>',
]
if not root_index:
regular_expressions.append(
'<tr>\n*\s*<td><a href="\.\.\/" class="parent_link">\.\.\/<\/a><\/td>\n*\s*<td><\/td>\n*\s*<td><\/td>\n*\s*<\/tr>'
)
for item in items:
encoded_name = item.get("encoded_name", item["name"])
regular_expressions.append(
f"<tr>\n*\s*<td><a href=\"{re.escape(encoded_name)}\" class=\"item_link\">{re.escape(item['name'])}<\/a><\/td>\n*\s*<td>{item['last_modified']}<\/td>\n*\s*<td>{item['size']}<\/td>\n*\s*<\/tr>"
)
put_requests = [
request
for request in httpretty.latest_requests()
if request.method == "PUT" and request.path == f"{path}index.html"
]
assert len(put_requests) == 1
captured_request = put_requests[0]
body = captured_request.body.decode()
for regular_expression in regular_expressions:
assert re.search(
regular_expression, body, flags=re.MULTILINE
), f"{regular_expression} != {body}"
assert len(items) == body.count(
'class="item_link"'
), f"number of items in index file did not match expected {body}"
def test_no_retry_on_400_and_exception_is_raised(self):
httpretty.register_uri(httpretty.GET,
self.ch_client.search_companies_url,
status=400,
match_querystring=False)
self.assertRaises(CompaniesHouseApiException,
self.ch_client.search_companies,
search_term='Company 1')
self.assertEqual(len(httpretty.latest_requests()), 1)
def test_no_retry_on_400_and_dnb_exception_is_raised(self):
httpretty.register_uri(httpretty.POST,
self.dnb_service_client.company_url,
status=400,
match_querystring=False)
self.assertRaises(DnbServiceClientException,
self.dnb_service_client.get_company,
duns_number=1)
self.assertEqual(len(httpretty.latest_requests()), 1)
def test_disables_snapshots_when_the_healthcheck_errors(self):
# no mocks will cause the request to throw an error
with patch('builtins.print') as mock_print:
percy_snapshot(self.driver, 'Snapshot 1')
percy_snapshot(self.driver, 'Snapshot 2')
mock_print.assert_called_with(f'{LABEL} Percy is not running, disabling snapshots')
self.assertEqual(len(httpretty.latest_requests()), 0)
def test_add_event_disabled_writer(mock_send_request,
telemetry_writer_disabled):
"""asserts that add_event() does not create a telemetry request when telemetry writer is disabled"""
payload = {"test": "123"}
payload_type = "test-event"
# ensure events are not queued when telemetry is disabled
telemetry_writer_disabled.add_event(payload, payload_type)
# ensure no request were sent
telemetry_writer_disabled.periodic()
assert len(httpretty.latest_requests()) == 0
def test_posts_snapshots_to_the_local_percy_server(self):
mock_healthcheck()
mock_snapshot()
percy_snapshot(self.driver, 'Snapshot 1')
percy_snapshot(self.driver, 'Snapshot 2', enable_javascript=True)
self.assertEqual(httpretty.last_request().path, '/percy/snapshot')
s1 = httpretty.latest_requests()[2].parsed_body
self.assertEqual(s1['name'], 'Snapshot 1')
self.assertEqual(s1['url'], 'http://localhost:8000/')
self.assertEqual(s1['dom_snapshot'], '<html><head></head><body>Snapshot Me</body></html>')
self.assertRegex(s1['client_info'], r'percy-selenium-python/\d+')
self.assertRegex(s1['environment_info'][0], r'selenium/\d+')
self.assertRegex(s1['environment_info'][1], r'python/\d+')
s2 = httpretty.latest_requests()[3].parsed_body
self.assertEqual(s2['name'], 'Snapshot 2')
self.assertEqual(s2['enable_javascript'], True)
def test_datastore_migrate_redis_empty(m_utils, m_sh, mocker):
m_utils.ctx_opts.return_value.dry_run = False
httpretty.register_uri(
httpretty.GET,
'http://localhost:5984/_all_dbs',
body=json.dumps(['unused'
]), # no known databases found -> nothing migrated
adding_headers={'ContentType': 'application/json'},
)
update.datastore_migrate_redis()
assert len(httpretty.latest_requests()) == 1
def test_test_ssl_bad_handshake():
# Reproduces https://github.com/gabrielfalcao/HTTPretty/issues/242
url_http = 'http://httpbin.org/status/200'
url_https = 'https://github.com/gabrielfalcao/HTTPretty'
httpretty.register_uri(httpretty.GET, url_http, body='insecure')
httpretty.register_uri(httpretty.GET, url_https, body='encrypted')
requests.get(url_http).text.should.equal('insecure')
requests.get(url_https).text.should.equal('encrypted')
httpretty.latest_requests().should.have.length_of(2)
insecure_request, secure_request = httpretty.latest_requests()[:2]
insecure_request.protocol.should.be.equal('http')
secure_request.protocol.should.be.equal('https')
insecure_request.url.should.be.equal(url_http)
secure_request.url.should.be.equal(url_https)
def test_skip_auto_load_if_disabled(self):
httpretty.register_uri(httpretty.GET,
self.base_domain,
body=self.api_description,
status=200)
expected_version = DEFAULT_API_VERSION
client = GeocodioClient(self.TEST_API_KEY, auto_load_api_version=False)
self.assertEqual(client.version, expected_version)
self.assertTrue(
client.BASE_URL.startswith("{domain}/v{version}".format(
domain=self.base_domain, version=expected_version)))
self.assertEqual(len(httpretty.latest_requests()), 0)
def test_get_all_requests():
httpretty.register_uri(httpretty.POST, 'http://127.0.0.1:5001/notification')
httpretty.enable()
requests.post('http://127.0.0.1:5001/notification')
requests.post('http://127.0.0.1:5001/notification?test=2')
calls = httpretty.latest_requests()
assert len(calls) == 2
assert calls[0].querystring == {}
assert calls[1].querystring == {u'test': [u'2']}
httpretty.disable()
def test_return_failure_immediately_when_response_is_in_the_second_fail_on_body(
):
"""Test raise ignore retries and returns responses immediately."""
fake_responses = [
{
"resource": "FAILED"
},
{
"resource": "FAILED"
},
{
"resource": "CREATING"
},
]
for data in fake_responses:
httpretty.register_uri(httpretty.GET,
"http://test.com/test",
body=json.dumps(data))
result = spintest(
["http://test.com"],
[{
"method":
"GET",
"route":
"/test",
"expected": {
"body": {
"resource": "CREATED"
},
},
"fail_on": [
{
"body": {
"resource": "ERROR"
}
},
{
"body": {
"resource": "FAILED"
}
},
],
"retry":
2,
"delay":
0, # Make test quicker
}],
)
expected_call_nb = 2 # First call (CREATING) and retry (FAILED)
assert expected_call_nb == len(httpretty.latest_requests())
assert result is False
def test_has_a_backwards_compatible_function(self):
mock_healthcheck()
mock_snapshot()
percySnapshot(browser=self.driver, name='Snapshot')
self.assertEqual(httpretty.last_request().path, '/percy/snapshot')
s1 = httpretty.latest_requests()[2].parsed_body
self.assertEqual(s1['name'], 'Snapshot')
self.assertEqual(s1['url'], 'http://localhost:8000/')
self.assertEqual(s1['dom_snapshot'], '<html><head></head><body>Snapshot Me</body></html>')
def test_retry_on_500(self):
httpretty.register_uri(httpretty.POST,
self.dnb_service_client.company_url,
match_querystring=False,
responses=[
httpretty.Response(status=500, body=''),
httpretty.Response(status=200,
body=json.dumps(
self.get_response))
])
dnb_company = self.dnb_service_client.get_company(duns_number=1)
self.assertEqual(dnb_company['primary_name'], 'name-1')
self.assertEqual(len(httpretty.latest_requests()), 2)
def test_backoff_success():
data = {'count': 0, 'next': None, 'previous': None, 'results': []}
httpretty.register_uri(httpretty.GET,
api_url('rasters/'),
responses=[
httpretty.Response(body=None, status=429),
httpretty.Response(body=None, status=502),
httpretty.Response(body=json.dumps(data),
status=200)
])
client = _client(max_retries=2)
client.list_rasters()
assert len(httpretty.latest_requests()) == 3
def test_retry_on_500(self):
httpretty.register_uri(httpretty.GET,
self.ch_client.search_companies_url,
match_querystring=False,
responses=[
httpretty.Response(status=500, body=''),
httpretty.Response(
status=200,
body=json.dumps(self.search_response))
])
companies = self.ch_client.search_companies(search_term='Company 1')
self.assertListEqual(companies, self.search_response['items'])
self.assertEqual(len(httpretty.latest_requests()), 2)
def test_backoff_failure():
httpretty.register_uri(httpretty.GET,
api_url('rasters/'),
responses=[
httpretty.Response(
body=None,
status=429,
),
httpretty.Response(body=None, status=502),
httpretty.Response(body=None, status=502)
])
client = _client(max_retries=1)
with pytest.raises(ConnectionError):
client.list_rasters()
assert len(httpretty.latest_requests()) == 2
def test_copy_influx_measurement_victoria(m_utils, m_sh, mocker):
m_utils.host_url.return_value = 'https://localhost'
m_utils.sh_stream.side_effect = partial(csv_data_stream, {})
mocker.patch(TESTED + '.NamedTemporaryFile',
wraps=migration.NamedTemporaryFile)
mocker.patch(TESTED + '._influx_line_count', return_value=1000)
httpretty.register_uri(
httpretty.GET,
'https://localhost/victoria/write',
)
migration._copy_influx_measurement('sparkey', 'today', '1d', 'victoria')
assert len(httpretty.latest_requests()) == 3
assert m_sh.call_count == 0
def test_latest_requests(original):
("httpretty.latest_requests() should return httpretty.core.latest_requests")
httpretty.latest_requests().should.equal(original.latest_requests)
