def test_message_get_retry_after(self): response = HTTPResponse(reason="too many requests") response.headers.add('Retry-After', '63') influx_db_error = InfluxDBError(response=response) self.assertEqual("too many requests", str(influx_db_error)) self.assertEqual("63", influx_db_error.retry_after) influx_db_error = InfluxDBError(response=HTTPResponse( reason="too many requests")) self.assertEqual("too many requests", str(influx_db_error)) self.assertEqual(None, influx_db_error.retry_after)
def test_cache(self, tmpdir, send_returns): """ L{IntersphinxCache.get} caches responses to the file system. """ url = u"https://cache.example/objects.inv" content = b'content' send_returns( HTTPResponse( body=ClosingBytesIO(content), headers={ 'date': 'Sun, 06 Nov 1994 08:49:37 GMT', }, status=200, preload_content=False, decode_content=False, ), ) loadsCache = sphinx.IntersphinxCache.fromParameters( sessionFactory=requests.Session, cachePath=str(tmpdir), maxAgeDictionary={"weeks": 1} ) assert loadsCache.get(url) == content # Now the response contains different data that will not be # returned when the cache is enabled. send_returns( HTTPResponse( body=ClosingBytesIO(content * 2), headers={ 'date': 'Sun, 06 Nov 1994 08:49:37 GMT', }, status=200, preload_content=False, decode_content=False, ), ) assert loadsCache.get(url) == content readsCacheFromFileSystem = sphinx.IntersphinxCache.fromParameters( sessionFactory=requests.Session, cachePath=str(tmpdir), maxAgeDictionary={"weeks": 1} ) assert readsCacheFromFileSystem.get(url) == content
def test_logging(self): response = HTTPResponse( body= '{"code":"too many requests","message":"org 04014de4ed590000 has exceeded limited_write plan limit"}' ) response.headers.add('Retry-After', '63') with self.assertLogs('influxdb_client.client.write.retry', level='WARNING') as cm: WritesRetry(total=5, backoff_factor=1, max_retry_delay=15) \ .increment(response=response) \ .increment(error=Exception("too many requests")) \ .increment(url='http://localhost:9999') self.assertEqual( "WARNING:influxdb_client.client.write.retry:The retriable error occurred during request. " "Reason: 'org 04014de4ed590000 has exceeded limited_write plan limit'. Retry in 63s.", cm.output[0]) self.assertEqual( "WARNING:influxdb_client.client.write.retry:The retriable error occurred during request. " "Reason: 'too many requests'.", cm.output[1]) self.assertEqual( "WARNING:influxdb_client.client.write.retry:The retriable error occurred during request. " "Reason: 'Failed request to: http://localhost:9999'.", cm.output[2])
def get_object_side_effect(bucket, object_name): file = ( file_data.unsupported if object_name.endswith(".unsupported") else file_data.png ) return HTTPResponse(body=BytesIO(file), preload_content=False,)
def test_get_offers_on_device_decisioning_emits_notifications(self): get_offers_opts = { "request": EXECUTE_REQUEST, "session_id": "dummy_session" } client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value client_opts["target_location_hint"] = "28" # send_notifications call with patch.object(DeliveryApi, "execute", return_value=create_delivery_response({})) \ as mock_delivery_api: with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE)) artifact_instance.request.return_value = artifact_response client = TargetClient.create(client_opts) self.assertEqual(mock_artifact_provider.call_count, 1) result = client.get_offers(get_offers_opts) self.assertIsNotNone(result.get("response")) self.assertEqual(result.get("response").status, OK) self.assertIsNotNone(result.get("response").execute) time.sleep(1) # notifications sent async self.assertEqual(mock_delivery_api.call_count, 1) notification_request = to_dict(mock_delivery_api.call_args[0][2]) expect_to_match_object(notification_request, EXPECTED_NOTIFICATION_REQUEST)
def test_run_next_exception(self, mock_get_kube_client, mock_kubernetes_job_watcher): # When a quota is exceeded this is the ApiException we get r = HTTPResponse() r.body = { "kind": "Status", "apiVersion": "v1", "metadata": {}, "status": "Failure", "message": "pods \"podname\" is forbidden: " + "exceeded quota: compute-resources, " + "requested: limits.memory=4Gi, " + "used: limits.memory=6508Mi, " + "limited: limits.memory=10Gi", "reason": "Forbidden", "details": { "name": "podname", "kind": "pods" }, "code": 403 }, r.status = 403 r.reason = "Forbidden" # A mock kube_client that throws errors when making a pod mock_kube_client = mock.patch('kubernetes.client.CoreV1Api', autospec=True) mock_kube_client.create_namespaced_pod = mock.MagicMock( side_effect=ApiException(http_resp=r)) mock_get_kube_client.return_value = mock_kube_client kubernetesExecutor = KubernetesExecutor() kubernetesExecutor.start() # Execute a task while the Api Throws errors try_number = 1 kubernetesExecutor.execute_async(key=('dag', 'task', datetime.utcnow(), try_number), command='command', executor_config={}) kubernetesExecutor.sync() kubernetesExecutor.sync() assert mock_kube_client.create_namespaced_pod.called self.assertFalse(kubernetesExecutor.task_queue.empty()) # Disable the ApiException mock_kube_client.create_namespaced_pod.side_effect = None # Execute the task without errors should empty the queue kubernetesExecutor.sync() assert mock_kube_client.create_namespaced_pod.called self.assertTrue(kubernetesExecutor.task_queue.empty())
def stub_get_namespaced_multus_network(**args): with open( resource_root + '/stub_results/stub_get_namespaced_multus_network.txt', 'rb') as infile: body = infile.read() return_http_response = HTTPResponse(body=body, status=200) return return_http_response
def _parse_to_tables(data: str): fp = BytesIO(str.encode(data)) _parser = FluxCsvParser( response=HTTPResponse(fp, preload_content=False), serialization_mode=FluxSerializationMode.tables) list(_parser.generator()) tables = _parser.tables return tables
def http_response_mock(body="", headers=None, status=200): if headers is None: headers = {} if not six.PY2: body = body.encode("UTF-8") return HTTPResponse(body, HTTPHeaderDict(headers), status=status)
def test_get_retry_after_jitter(self): response = HTTPResponse() response.headers.add('Retry-After', '5') retry = WritesRetry(jitter_interval=2) retry_after = retry.get_retry_after(response) self.assertGreater(retry_after, 5) self.assertLessEqual(retry_after, 7)
def urllib3_http_response_from_exception(exception: Exception) -> HTTPResponse: """On exceptions, we want to create our own HTTPResponse with exception's message to set it to response.raw to be read later.""" return HTTPResponse( body=io.BytesIO(str(exception).encode('utf-8', errors='replace')), # https://github.com/requests/requests/issues/2635#issuecomment-112270117 preload_content=False, )
def _provide_ssl_auth_required(self): """ Provide ssl auth response :return: urllib3.HTTPResponse """ response = HTTPResponse() response.status = self.DEFAULT_SSL_CERT_REQUIRED_STATUSES response.__setattr__('_body', ' ') return response
def test_run_next_exception(self, mock_get_kube_client, mock_kubernetes_job_watcher): import sys path = sys.path[ 0] + '/tests/kubernetes/pod_generator_base_with_secrets.yaml' # When a quota is exceeded this is the ApiException we get response = HTTPResponse( body= '{"kind": "Status", "apiVersion": "v1", "metadata": {}, "status": "Failure", ' '"message": "pods \\"podname\\" is forbidden: exceeded quota: compute-resources, ' 'requested: limits.memory=4Gi, used: limits.memory=6508Mi, limited: limits.memory=10Gi", ' '"reason": "Forbidden", "details": {"name": "podname", "kind": "pods"}, "code": 403}' ) response.status = 403 response.reason = "Forbidden" # A mock kube_client that throws errors when making a pod mock_kube_client = mock.patch('kubernetes.client.CoreV1Api', autospec=True) mock_kube_client.create_namespaced_pod = mock.MagicMock( side_effect=ApiException(http_resp=response)) mock_get_kube_client.return_value = mock_kube_client mock_api_client = mock.MagicMock() mock_api_client.sanitize_for_serialization.return_value = {} mock_kube_client.api_client = mock_api_client config = { ('kubernetes', 'pod_template_file'): path, } with conf_vars(config): kubernetes_executor = self.kubernetes_executor kubernetes_executor.start() # Execute a task while the Api Throws errors try_number = 1 kubernetes_executor.execute_async( key=('dag', 'task', datetime.utcnow(), try_number), queue=None, command=['airflow', 'tasks', 'run', 'true', 'some_parameter'], ) kubernetes_executor.sync() kubernetes_executor.sync() assert mock_kube_client.create_namespaced_pod.called assert not kubernetes_executor.task_queue.empty() # Disable the ApiException mock_kube_client.create_namespaced_pod.side_effect = None # Execute the task without errors should empty the queue kubernetes_executor.sync() assert mock_kube_client.create_namespaced_pod.called assert kubernetes_executor.task_queue.empty()
def response(): response = requests.Response() response._content = b'{"id": 5}' response.status_code = 201 response.headers["Content-Type"] = "application/json" response.raw = HTTPResponse( body=io.BytesIO(response._content), status=response.status_code, headers=response.headers ) response.request = requests.PreparedRequest() response.request.prepare(method="POST", url="http://example.com", headers={"Content-Type": "application/json"}) return response
def test_client_recovers_if_location_hint_request_fails(self): get_offers_opts = { "request": TARGET_REQUEST, "session_id": "dummy_session" } client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value with patch("delivery_api_client.rest.urllib3.PoolManager") as mock_delivery_api: delivery_instance = mock_delivery_api.return_value delivery_response = HTTPResponse(status=503) delivery_instance.request.return_value = delivery_response with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE)) artifact_instance.request.return_value = artifact_response client = TargetClient.create(client_opts) result = client.get_offers(get_offers_opts) # on-device self.assertIsNone(result.get("target_location_hint_cookie"))
def responses(): iterator = iter(snapshots) while True: items = take(page_size, iterator) yield HTTPResponse(status=200, body=json.dumps({ 'total': len(snapshots), 'filteredTotal': len(snapshots), 'items': list(items) })) if not items: break
def test_get_offers_hybrid_does_remote_request_if_necessary(self): get_offers_opts = { "request": TARGET_REQUEST_DICT, "session_id": "dummy_session" } get_offers_opts["request"]["prefetch"] = { "mboxes": [{ "name": "mbox-feature-flags", "index": 1 }, { "name": "remote-only-mbox-a", "index": 2 }, { "name": "remote-only-mbox-b", "index": 2 }] } get_offers_opts["request"] = create_delivery_request( get_offers_opts["request"]) client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.HYBRID.value with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(DELIVERY_RESPONSE)) \ as mock_delivery_api: with patch( "target_decisioning_engine.artifact_provider.urllib3.PoolManager" ) as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse( status=OK, body=json.dumps(FEATURE_FLAG_ARTIFACT)) artifact_instance.request.return_value = artifact_response client = TargetClient.create(client_opts) self.assertEqual(mock_artifact_provider.call_count, 1) result = client.get_offers(get_offers_opts) self.assertEqual(mock_delivery_api.call_count, 1) self.assertEqual(result["response"].status, OK) self.assertIsNotNone(result["response"].prefetch) self.assertEqual(result["meta"]["decisioning_method"], DecisioningMethod.HYBRID.value) self.assertSetEqual( set(result["meta"]["remote_mboxes"]), set(["remote-only-mbox-a", "remote-only-mbox-b"])) self.assertEqual(result["meta"]["remote_views"], [])
def _mock_urlopen(http_client, method, url, *, headers, **kwargs): nonlocal called self.assertEqual(method, 'GET') self.assertEqual(str(furl(url).remove(query=True)), tdr_client._repository_endpoint('snapshots')) headers = {k.capitalize(): v for k, v in headers.items()} token = headers['Authorization'].split('Bearer ').pop() response = HTTPResponse( status=200, body=json.dumps({ 'total': 1, 'filteredTotal': 1, 'items': [] if called else self._mock_snapshots(token) })) called = True return response
def setUp(self): self.headers = { "x-geo-latitude": 37.773972, "x-geo-longitude": -122.431297, "x-geo-country-code": "US", "x-geo-region-code": "CA", "x-geo-city": "SANFRANCISCO" } self.config = DecisioningConfig("myClient", "myOrgId") geo_values = { "x-geo-longitude": -122.4, "x-geo-latitude": 37.75, "x-geo-city": "SAN FRANCISCO", "x-geo-region-code": "CA", "x-geo-country-code": "US" } self.mock_geo_response = HTTPResponse(body=json.dumps(geo_values), status=OK)
def test_create_decisioning_method_on_device(self): client_ready_mock = Mock() client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value client_opts["events"] = { "client_ready": client_ready_mock } with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_pool_manager: instance = mock_pool_manager.return_value mock_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_BLANK)) instance.request.return_value = mock_response with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)): client = TargetClient.create(client_opts) self.assertIsNotNone(client.decisioning_engine) self.assertTrue(callable(client.decisioning_engine.get_offers)) self.assertEqual(client_ready_mock.call_count, 1)
def test_get_offers_on_device_partial_returns_206_and_remote_mbox_names( self): get_offers_opts = { "request": TARGET_REQUEST_DICT, "session_id": "dummy_session" } get_offers_opts["request"]["prefetch"] = { "mboxes": [{ "name": "mbox-feature-flags", "index": 1 }, { "name": "remote-only-mbox-a", "index": 2 }, { "name": "remote-only-mbox-b", "index": 2 }] } get_offers_opts["request"] = create_delivery_request( get_offers_opts["request"]) client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value with patch( "target_decisioning_engine.artifact_provider.urllib3.PoolManager" ) as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse( status=OK, body=json.dumps(FEATURE_FLAG_ARTIFACT)) artifact_instance.request.return_value = artifact_response client = TargetClient.create(client_opts) self.assertEqual(mock_artifact_provider.call_count, 1) result = client.get_offers(get_offers_opts) self.assertEqual(result["response"].status, PARTIAL_CONTENT) self.assertIsNotNone(result["response"].prefetch) self.assertEqual(result["meta"]["decisioning_method"], DecisioningMethod.ON_DEVICE.value) self.assertSetEqual( set(result["meta"]["remote_mboxes"]), set(["remote-only-mbox-a", "remote-only-mbox-b"])) self.assertEqual(result["meta"]["remote_views"], [])
def test_get_offers_valid_on_device_decisioning_response(self): get_offers_opts = { "request": PREFETCH_REQUEST, "session_id": "dummy_session" } client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value client_opts["target_location_hint"] = "28" with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE)) artifact_instance.request.return_value = artifact_response with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)): client = TargetClient.create(client_opts) result = client.get_offers(get_offers_opts) result_dict = to_dict(result) expect_to_match_object(result_dict, EXPECTED_PREFETCH_RESULT)
def test_top_level_request_with_timeout(self) -> None: with mock.patch("urllib3.poolmanager.RequestMethods.request") as mockRequest: mockRequest.return_value = HTTPResponse(status=200) r = request("GET", f"{self.base_url}/redirect", timeout=2.5) assert r.status == 200 mockRequest.assert_called_with( "GET", f"{self.base_url}/redirect", body=None, fields=None, headers=None, preload_content=True, decode_content=True, redirect=True, retries=None, timeout=2.5, json=None, )
def test_valid_geo_request_non_200_response(self): artifact = deepcopy(ARTIFACT_BLANK) artifact["geoTargetingEnabled"] = True geo_provider = GeoProvider(self.config, artifact) mock_bad_response = HTTPResponse(body="Bad Request", status=BAD_REQUEST) with patch.object(geo_provider.pool_manager, "request", return_value=mock_bad_response) as mock_http_call: geo_input = Geo(ip_address="12.21.1.40") result = geo_provider.valid_geo_request_context(geo_input) time.sleep(1) self.assertEqual(result, None) self.assertEqual(mock_http_call.call_count, 1) self.assertEqual(mock_http_call.call_args[0][1], "https://assets.adobetarget.com/v1/geo") self.assertEqual( mock_http_call.call_args[1].get("headers").get( HTTP_HEADER_FORWARDED_FOR), "12.21.1.40")
def test_client_preemptively_fetches_target_location_hint(self): get_offers_opts = { "request": TARGET_REQUEST, "session_id": "dummy_session" } client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE)) artifact_instance.request.return_value = artifact_response with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)): client = TargetClient.create(client_opts) result = client.get_offers(get_offers_opts) # on-device self.assertEqual(result.get("target_location_hint_cookie"), { "name": "mboxEdgeCluster", "value": "28", "maxAge": 1860 })
def test_client_uses_location_hint_from_config(self): get_offers_opts = { "request": TARGET_REQUEST, "session_id": "dummy_session" } client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value client_opts["target_location_hint"] = "28" with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider: artifact_instance = mock_artifact_provider.return_value artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE)) artifact_instance.request.return_value = artifact_response client = TargetClient.create(client_opts) result = client.get_offers(get_offers_opts) self.assertEqual(result.get("target_location_hint_cookie"), { "name": "mboxEdgeCluster", "value": "28", "maxAge": 1860 })
def test_get_offers_artifact_retrieval_failed(self): client_ready_mock = Mock() artifact_failed_mock = Mock() artifact_success_mock = Mock() client_opts = dict(CONFIG) client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value client_opts["events"] = { "client_ready": client_ready_mock, "artifact_download_failed": artifact_failed_mock, "artifact_download_succeeded": artifact_success_mock } with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_pool_manager: instance = mock_pool_manager.return_value mock_response = HTTPResponse(status=403) instance.request.return_value = mock_response with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)): client = TargetClient.create(client_opts) self.assertEqual(client_ready_mock.call_count, 0) self.assertEqual(artifact_success_mock.call_count, 0) self.assertEqual(artifact_failed_mock.call_count, 1) self.assertEqual(artifact_failed_mock.call_args[0][0].get("type"), "artifact_download_failed") self.assertIsNotNone(artifact_failed_mock.call_args[0][0].get("artifact_location")) self.assertIsNotNone(artifact_failed_mock.call_args[0][0].get("error")) get_offers_opts = { "request": TARGET_REQUEST, "session_id": "dummy_session" } with self.assertRaises(Exception) as err: client.get_offers(get_offers_opts) self.assertEqual(str(err.exception), DECISIONING_ENGINE_NOT_READY)
def test_message(self): response = HTTPResponse() response.headers.add('X-Platform-Error-Code', 'too many requests 1') self.assertEqual("too many requests 1", str(InfluxDBError(response=response))) response = HTTPResponse() response.headers.add('X-Influx-Error', 'too many requests 2') self.assertEqual("too many requests 2", str(InfluxDBError(response=response))) response = HTTPResponse() response.headers.add('X-InfluxDb-Error', 'too many requests 3') self.assertEqual("too many requests 3", str(InfluxDBError(response=response))) response = HTTPResponse( body= '{"code":"too many requests","message":"org 04014de4ed590000 has exceeded limited_write plan limit"}' ) response.headers.add('X-InfluxDb-Error', 'error 3') self.assertEqual( "org 04014de4ed590000 has exceeded limited_write plan limit", str(InfluxDBError(response=response))) response = HTTPResponse( body='org 04014de4ed590000 has exceeded limited_write plan limit') response.headers.add('X-InfluxDb-Error', 'error 3') self.assertEqual( "org 04014de4ed590000 has exceeded limited_write plan limit", str(InfluxDBError(response=response))) response = HTTPResponse(reason='too many requests 4') self.assertEqual("too many requests 4", str(InfluxDBError(response=response)))
import cloudinary import six from cloudinary import uploader, api, utils from urllib3 import disable_warnings, HTTPResponse from .test_helper import * MOCK_HEADERS = HTTPHeaderDict({ "x-featureratelimit-limit": '0', "x-featureratelimit-reset": 'Sat, 01 Apr 2017 22:00:00 GMT', "x-featureratelimit-remaining": '0', }) if six.PY2: MOCK_RESPONSE = HTTPResponse(body='{"foo":"bar"}', headers=MOCK_HEADERS) else: MOCK_RESPONSE = HTTPResponse(body='{"foo":"bar"}'.encode("UTF-8"), headers=MOCK_HEADERS) disable_warnings() UNIQUE_TAG = 'api_{}'.format(UNIQUE_TAG) API_TEST_TAG = "api_test_{}_tag".format(SUFFIX) API_TEST_PREFIX = "api_test_{}".format(SUFFIX) API_TEST_ID = "api_test_{}".format(SUFFIX) API_TEST_ID2 = "api_test_{}2".format(SUFFIX) API_TEST_ID3 = "api_test_{}3".format(SUFFIX) API_TEST_ID4 = "api_test_{}4".format(SUFFIX) API_TEST_ID5 = "api_test_{}5".format(SUFFIX) API_TEST_TRANS = "api_test_transformation_{}".format(SUFFIX)
def test_response(self): response = HTTPResponse() self.assertEqual(response, InfluxDBError(response=response).response)