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)