insightconnect-plugin-runtime 5.4.9__py3-none-any.whl → 5.5.1__py3-none-any.whl

insightconnect_plugin_runtime/api/endpoints.py

@@ -83,7 +83,17 @@ def handle_errors(error: HTTPException):
 
 
 class Endpoints:
-    def __init__(self, logger, plugin, spec, debug, workers, threads, master_pid, config_options=None):
+    def __init__(
+        self,
+        logger,
+        plugin,
+        spec,
+        debug,
+        workers,
+        threads,
+        master_pid,
+        config_options=None,
+    ):
         self.plugin = plugin
         self.logger = structlog.get_logger("plugin")
         self.spec = spec
@@ -167,7 +177,9 @@ class Endpoints:
             Endpoints.validate_action_trigger_task_name(input_message, name, "task")
             # No validation on the plugin custom config to leave this as configurable as possible.
             # `add_plugin_custom_config` will pass any available values to the plugin for interpretation.
-            input_message = self.add_plugin_custom_config(input_message, request.headers.get(ORG_ID))
+            input_message = self.add_plugin_custom_config(
+                input_message, request.headers.get(ORG_ID)
+            )
             output = self.run_action_trigger_task(input_message)
             self.logger.info("Plugin task finished execution...")
             return output
@@ -750,7 +762,9 @@ class Endpoints:
 
         return version
 
-    def add_plugin_custom_config(self, input_data: Dict[str, Any], org_id: str) -> Dict[str, Any]:
+    def add_plugin_custom_config(
+        self, input_data: Dict[str, Any], org_id: str
+    ) -> Dict[str, Any]:
         """
         Using the retrieved configs pulled from komand-props, pass the configuration that matches the requesting
         Org ID which is passed to the task via a header (`X-IPIMS-ORGID`) from the plugin sidecar.
@@ -763,17 +777,27 @@ class Endpoints:
         - all orgs for default runs will poll back 12 hours.
         - all orgs in lookback mode will be 100 hours (task triggered with no state).
         """
-        additional_config = self.config_options.get(org_id) or self.config_options.get("*")
+        additional_config = self.config_options.get(org_id) or self.config_options.get(
+            "*"
+        )
         if additional_config:
-            self.logger.info("Found config options; adding this to the request parameters...")
-            additional_config = additional_config.copy()  # copy to preserve the referenced value in self.config_options
+            self.logger.info(
+                "Found config options; adding this to the request parameters..."
+            )
+            additional_config = (
+                additional_config.copy()
+            )  # copy to preserve the referenced value in self.config_options
             # As a safeguard we only pass the lookback config params if the plugin has no state
             # This means we still need to manually delete the state for plugins on a per org basis.
             # This also means first time customers for their 'initial' lookup would get the lookback value passed in.
-            if input_data.get("body", {}).get("state") and additional_config.get("lookback"):
-                self.logger.info("Found an existing plugin state, not passing lookback value...")
+            if input_data.get("body", {}).get("state") and additional_config.get(
+                "lookback"
+            ):
+                self.logger.info(
+                    "Found an existing plugin state, not passing lookback value..."
+                )
                 del additional_config["lookback"]
-            input_data.get("body", {}).update({'custom_config': additional_config})
+            input_data.get("body", {}).update({"custom_config": additional_config})
             self.logger.info(f"Custom config being sent to plugin: {additional_config}")
 
         return input_data

insightconnect_plugin_runtime/clients/aws_client.py

@@ -29,13 +29,13 @@ class PaginationHelper:
     """
 
     def __init__(
-            self,
-            input_token: List[str],
-            output_token: List[str],
-            result_key: List[str],
-            limit_key: str = None,
-            more_results: str = None,
-            non_aggregate_keys: List[str] = None,
+        self,
+        input_token: List[str],
+        output_token: List[str],
+        result_key: List[str],
+        limit_key: str = None,
+        more_results: str = None,
+        non_aggregate_keys: List[str] = None,
     ):
         self.input_token = input_token
         self.output_token = output_token
@@ -70,9 +70,9 @@ class PaginationHelper:
         is_paginated = False
 
         if (
-                self.more_results
-                and self.more_results in output.keys()
-                and output[self.more_results]
+            self.more_results
+            and self.more_results in output.keys()
+            and output[self.more_results]
         ):
             is_paginated = True
 
@@ -84,10 +84,10 @@ class PaginationHelper:
         return is_paginated
 
     def merge_responses(
-            self,
-            input_: Dict[str, Any],
-            response_1: Dict[str, Any],
-            response_2: Dict[str, Any],
+        self,
+        input_: Dict[str, Any],
+        response_1: Dict[str, Any],
+        response_2: Dict[str, Any],
     ) -> Tuple[Dict[str, Any], bool]:
         """
         Merges two output dictionaries together.
@@ -112,7 +112,8 @@ class PaginationHelper:
                 if len(response_1[response]) >= input_[self.limit_key]:
                     max_hit = True
                     response_1[response] = response_1[response][
-                                           : input_[self.limit_key]]
+                        : input_[self.limit_key]
+                    ]
 
         return response_1, max_hit
 
@@ -302,7 +303,7 @@ class ActionHelper:
 
     @classmethod
     def format_output(
-            cls, output_schema: Union[Dict[str, Any], None], output: Dict[str, Any]
+        cls, output_schema: Union[Dict[str, Any], None], output: Dict[str, Any]
     ) -> Any:
         """
         Formats a botocore response into a correct Komand response.
@@ -333,14 +334,14 @@ class AWSAction(Action):
     """
 
     def __init__(
-            self,
-            name: str,
-            description: str,
-            input_: insightconnect_plugin_runtime.Input,
-            output: insightconnect_plugin_runtime.Output,
-            aws_service: str,
-            aws_command: str,
-            pagination_helper: PaginationHelper = None,
+        self,
+        name: str,
+        description: str,
+        input_: insightconnect_plugin_runtime.Input,
+        output: insightconnect_plugin_runtime.Output,
+        aws_service: str,
+        aws_command: str,
+        pagination_helper: PaginationHelper = None,
     ):
         """
 
@@ -362,7 +363,7 @@ class AWSAction(Action):
         self.pagination_helper = pagination_helper
 
     def _handle_botocore_function(
-            self, client_function: Callable, params: Dict
+        self, client_function: Callable, params: Dict
     ) -> Dict:
         try:
             response = client_function(**params)
@@ -480,11 +481,11 @@ class AWSAction(Action):
             client_function = getattr(client, self.aws_command)
         except AttributeError:
             error_message = (
-                    'Unable to find the command "'
-                    + self.aws_service
-                    + " "
-                    + self.aws_command
-                    + '"'
+                'Unable to find the command "'
+                + self.aws_service
+                + " "
+                + self.aws_command
+                + '"'
             )
             self.logger.error(error_message)
             raise PluginException(cause=error_message)
@@ -533,17 +534,21 @@ class AWSAction(Action):
 
     @staticmethod
     def try_to_assume_role(
-            service_name: str,
-            assume_role_params: Dict[str, str],
-            auth_params: Dict[str, str],
+        service_name: str,
+        assume_role_params: Dict[str, str],
+        auth_params: Dict[str, str],
     ):
         session_name = str(uuid.uuid1())
         sts_client = boto3.client("sts", **auth_params)
         try:
             assumed_role_object = sts_client.assume_role(
-                **clean({"RoleArn": assume_role_params.get(ROLE_ARN),
-                         "RoleSessionName": session_name,
-                         "ExternalId": assume_role_params.get(EXTERNAL_ID)})
+                **clean(
+                    {
+                        "RoleArn": assume_role_params.get(ROLE_ARN),
+                        "RoleSessionName": session_name,
+                        "ExternalId": assume_role_params.get(EXTERNAL_ID),
+                    }
+                )
             )
         except ClientError as error:
             raise PluginException(

insightconnect_plugin_runtime/exceptions.py

@@ -1,6 +1,56 @@
 # -*- coding: utf-8 -*-
-import structlog
-logger = structlog.get_logger("plugin")
+class ResponseExceptionData:
+    RESPONSE_TEXT = "response_text"
+    RESPONSE_JSON = "response_json"
+    RESPONSE = "response"
+    EXCEPTION = "exception"
+
+
+class HTTPStatusCodes:
+
+    # 4xx Client Errors
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    PAYLOAD_TOO_LARGE = 413
+    URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    I_AM_A_TEAPOT = 418
+    MISDIRECTED_REQUEST = 421
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    TOO_EARLY = 425
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
+
+    # 5xx Server Errors
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
 
 
 class ClientException(Exception):
@@ -65,6 +115,10 @@ class ConnectionTestException(Exception):
         TIMEOUT = "timeout"
         BAD_REQUEST = "bad_request"
         INVALID_CREDENTIALS = "invalid_credentials"
+        METHOD_NOT_ALLOWED = "method_not_allowed"
+        CONFLICT = "conflict"
+        CONNECTION_ERROR = "connection_error"
+        REDIRECT_ERROR = "redirect_error"
 
     # Dictionary of cause messages
     causes = {
@@ -82,6 +136,10 @@ class ConnectionTestException(Exception):
         Preset.TIMEOUT: "The connection timed out.",
         Preset.BAD_REQUEST: "The server is unable to process the request.",
         Preset.INVALID_CREDENTIALS: "Authentication failed: invalid credentials.",
+        Preset.METHOD_NOT_ALLOWED: "The request method is not allowed for this resource.",
+        Preset.CONFLICT: "Request cannot be completed due to a conflict with the current state of the resource.",
+        Preset.CONNECTION_ERROR: "Failed to connect to the server.",
+        Preset.REDIRECT_ERROR: "Request redirected more than the set limit for the server.",
     }
 
     # Dictionary of assistance/remediation messages
@@ -103,6 +161,10 @@ class ConnectionTestException(Exception):
         Preset.BAD_REQUEST: "Verify your plugin input is correct and not malformed and try again. "
         "If the issue persists, please contact support.",
         Preset.INVALID_CREDENTIALS: "Please verify the credentials for your account and try again.",
+        Preset.METHOD_NOT_ALLOWED: "Please try a supported method for this resource.",
+        Preset.CONFLICT: "Please check your request, and try again.",
+        Preset.CONNECTION_ERROR: "Please check your network connection and try again.",
+        Preset.REDIRECT_ERROR: "Please check your request and try again.",
     }
 
     def __init__(self, cause=None, assistance=None, data=None, preset=None):
@@ -124,12 +186,6 @@ class ConnectionTestException(Exception):
 
         self.data = str(data) if data else ""
 
-        # Safeguard to ensure the exception is logged across all plugins even if the plugin
-        # itself does not call `self.logger.error(<error info>)`
-        params = ["cause", "assistance", "data", "preset"]
-        info_log = ", ".join([f"{atr}='{getattr(self, atr)}'" for atr in params if getattr(self, atr)])
-        logger.error(f"Plugin exception instantiated. {info_log}")
-
     def __str__(self):
         if self.data:
             return "Connection test failed!\n\n{cause} {assistance} Response was: {data}".format(

insightconnect_plugin_runtime/helper.py

@@ -10,20 +10,278 @@ import subprocess
 import time
 from datetime import datetime, timedelta
 from io import IOBase
-from typing import Any, Callable, Dict, List, Union
+from typing import Any, Callable, Dict, List, Union, Tuple
 from urllib import request
+from hashlib import sha1
+from json import JSONDecodeError
 
 import requests
 
-from insightconnect_plugin_runtime.exceptions import PluginException
+from insightconnect_plugin_runtime.exceptions import (
+    PluginException,
+    HTTPStatusCodes,
+    ResponseExceptionData,
+)
 
 CAMEL_CASE_REGEX = r"\b[a-z0-9]+([A-Z][a-z]+[0-9]*)*\b"
 CAMEL_CASE_ACRONYM_REGEX = r"\b[a-z0-9]+([A-Z]+[0-9]*)*\b"
 PASCAL_CASE_REGEX = r"\b[A-Z][a-z]+[0-9]*([A-Z][a-z]+[0-9]*)*\b"
+ENCODE_TYPE = "utf-8"
 
 DEFAULTS_HOURS_AGO = 24
 
 
+def hash_sha1(log: dict) -> str:
+    """
+    Iterate through a dictionary and hash each value.
+    :param log: Dictionary to be hashed.
+    :type dict:
+    :return: Hex digest of hash.
+    :rtype: str
+    """
+    hash_ = sha1()  # nosec B303
+    for key, value in log.items():
+        hash_.update(f"{key}{value}".encode(ENCODE_TYPE))
+    return hash_.hexdigest()
+
+
+def compare_and_dedupe_hashes(
+    previous_logs_hashes: list, new_logs: list
+) -> Tuple[list, list]:
+    """
+    Iterate through two lists of values, hashing each. Compare hash value to a list of existing hash values.
+    If the hash exists, return both it and the value in separate lists once iterated.
+    :param previous_logs_hashes: List of existing hashes to compare against.
+    :type list:
+    :param new_logs: New values to hash and compare to existing list of hashes.
+    :type list:
+    :return: Hex digest of hash.
+    :rtype: Tuple[list, list]
+    """
+    new_logs_hashes = []
+    logs_to_return = []
+    for log in new_logs:
+        hash_ = hash_sha1(log)
+        if hash_ not in previous_logs_hashes:
+            new_logs_hashes.append(hash_)
+            logs_to_return.append(log)
+    logging.info(
+        f"Original number of logs:{len(new_logs)}. Number of logs after de-duplication:{len(logs_to_return)}"
+    )
+    return logs_to_return, new_logs_hashes
+
+
+def make_request(
+    _request: requests.Request,
+    timeout: int = 60,
+    verify: bool = True,
+    cert: Union[str, Tuple]=None,
+    stream: bool = False,
+    allow_redirects: bool = True,
+    exception_custom_configs: Dict[int, Exception]={},
+    exception_data_location: str = None,
+    allowed_status_codes: list[str] = [],
+) -> Tuple[requests.Response, dict]:
+    """
+    Makes a HTTP request while checking for RequestErrors and JSONDecodeErrors
+    Returns the request response and the response JSON if required.
+    :param _request: Request object to utilize in request
+    :type Request:
+    :param timeout: Requests timeout paramater
+    :type int:
+    :param verify: Whether to verify the server's TLS certificate
+    :type bool:
+    :param cert: Certificate to include with request, str location or key/value pair
+    :type Union[str, dict]:
+    :param stream: Whether to immediately download the response content
+    :type bool:
+    :param allow_redirects: Set to true by default
+    :type bool:
+    :param exception_custom_configs: Custom exception values to be raised per HTTPStatusCode.
+    :type Dict[str, Exception]:
+    :param exception_data_location: Where the returned data should be retrieved. Can provide ResponseExceptionData values.
+    :type str:
+    :param allowed_status_codes: Status codes that will not raise an exception.
+    :type list[str]:
+
+    :return: The request response and the response JSON.
+    :rtype: Tuple[Response, dict]
+    """
+    try:
+        with requests.Session() as session:
+            prepared_request = session.prepare_request(request=_request)
+            response = session.send(
+                prepared_request,
+                verify=verify,
+                timeout=timeout,
+                allow_redirects=allow_redirects,
+                cert=cert,
+                stream=stream,
+            )
+    except requests.exceptions.Timeout as exception:
+        raise PluginException(
+            preset=PluginException.Preset.TIMEOUT, data=str(exception)
+        )
+    except requests.exceptions.ConnectionError as exception:
+        raise PluginException(
+            preset=PluginException.Preset.CONNECTION_ERROR, data=str(exception)
+        )
+    except requests.exceptions.TooManyRedirects as exception:
+        raise PluginException(
+            preset=PluginException.Preset.REDIRECT_ERROR, data=str(exception)
+        )
+    except requests.exceptions.RequestException as exception:
+        if not isinstance(exception, requests.exceptions.HTTPError):
+            raise PluginException(
+                preset=PluginException.Preset.UNKNOWN, data=str(exception)
+            )
+    response_handler(response, exception_custom_configs, exception_data_location, allowed_status_codes)
+    return response
+
+
+def extract_json(response: requests.Response) -> dict:
+    """Extract JSON from a request object while error handling a JSONDecodeError.
+    :param response: Response object ot utilize in extract
+    :type Response:
+    :returns: Dictionary of response JSON
+    :rtype: Dict
+    """
+    try:
+        response_json = response.json()
+        return response_json
+    except JSONDecodeError as exception:
+        raise PluginException(
+            preset=PluginException.Preset.INVALID_JSON, data=str(exception)
+        )
+
+
+def request_error_handling() -> Union[Any, None]:
+    """request_error_handling. This decorator allows a method that makes a request to complete with error handling.
+    A plugin exception will be raised whenever an error is caught. Response.raise_for_status() must be called in the
+    wrapped method to handle HTTPErrors.
+
+    :returns: API call function data or None.
+    :rtype: Union[Any, None]
+    """
+
+    def _decorate(func: Callable):
+        def _wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except requests.exceptions.Timeout as exception:
+                raise PluginException(
+                    preset=PluginException.Preset.TIMEOUT, data=str(exception)
+                )
+            except requests.exceptions.ConnectionError as exception:
+                raise PluginException(
+                    preset=PluginException.Preset.CONNECTION_ERROR, data=str(exception)
+                )
+            except requests.exceptions.TooManyRedirects as exception:
+                raise PluginException(
+                    preset=PluginException.Preset.REDIRECT_ERROR, data=str(exception)
+                )
+            except requests.exceptions.RequestException as exception:
+                if isinstance(exception, requests.exceptions.HTTPError):
+                    response_handler(exception.response)
+                else:
+                    raise PluginException(
+                        preset=PluginException.Preset.UNKNOWN, data=str(exception)
+                    )
+
+        return _wrapper
+
+    return _decorate
+
+
+def response_handler(
+    response: requests.Response,
+    custom_configs: Dict[int, Exception]={},
+    data_location: str = None,
+    allowed_status_codes: list[str] = [],
+) -> None:
+    """
+    Check response status codes and return a generic PluginException preset if a HTTPError is raised.
+    Excetion cause, assistance, and data can be overwritten by supplied parameters.
+
+    :param response: Response object whose status should be checked.
+    :type Response:
+    :param custom_configs: Custom exception values to be raised per HTTPStatusCode.
+    :type Dict[str, Exception]:
+    :param data_location: Where the returned data should be retrieved. Can provide ResponseExceptionData values.
+    :type str:
+    :param allowed_status_codes: Status codes that will not raise an exception.
+    :type list[str]:
+
+    :return: None.
+    :rtype: None
+    """
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as exception:
+
+        data = _return_response_data(response, exception, data_location)
+        status_code = response.status_code
+        if status_code in allowed_status_codes:
+            return
+        status_code_presets = {
+            HTTPStatusCodes.BAD_REQUEST: PluginException.Preset.BAD_REQUEST,
+            HTTPStatusCodes.UNAUTHORIZED: PluginException.Preset.INVALID_CREDENTIALS,
+            HTTPStatusCodes.FORBIDDEN: PluginException.Preset.UNAUTHORIZED,
+            HTTPStatusCodes.NOT_FOUND: PluginException.Preset.NOT_FOUND,
+            HTTPStatusCodes.METHOD_NOT_ALLOWED: PluginException.Preset.METHOD_NOT_ALLOWED,
+            HTTPStatusCodes.REQUEST_TIMEOUT: PluginException.Preset.TIMEOUT,
+            HTTPStatusCodes.CONFLICT: PluginException.Preset.CONFLICT,
+            HTTPStatusCodes.TOO_MANY_REQUESTS: PluginException.Preset.RATE_LIMIT,
+            HTTPStatusCodes.INTERNAL_SERVER_ERROR: PluginException.Preset.SERVER_ERROR,
+            HTTPStatusCodes.SERVICE_UNAVAILABLE: PluginException.Preset.SERVICE_UNAVAILABLE,
+        }
+        status_code_preset = status_code_presets.get(status_code)
+        exception = PluginException(preset=PluginException.Preset.UNKNOWN, data=data)
+        logging.info(f"Request to {response.url} failed. Status code: {status_code}")
+        if status_code in custom_configs.keys():
+            exception = custom_configs.get(status_code)
+            if hasattr(exception, "data") and data is not None:
+                exception.data = data
+        elif status_code_preset:
+            exception = PluginException(preset=status_code_preset, data=data)
+
+        raise exception
+
+
+def _return_response_data(
+    response: requests.Response,
+    exception: requests.HTTPError,
+    data_location: str = None,
+) -> str:
+    """
+    Retrieve data from HTTP Error given a provided data location
+
+    :param response: Response object whose status should be checked.
+    :type Response:
+    :param exception: HTTPError exception to retrieve data.
+    :type HTTPError:
+    :param data_location: Where the returned data should be retrieved. Can provide ResponseExceptionData values.
+    :type str:
+
+    :return: Exception data.
+    :rtype: str
+    """
+    data = None
+    if data_location == ResponseExceptionData.EXCEPTION:
+        data = str(exception)
+    elif data_location == ResponseExceptionData.RESPONSE:
+        data = response
+    elif data_location == ResponseExceptionData.RESPONSE_TEXT:
+        data = response.text
+    elif data_location == ResponseExceptionData.RESPONSE_JSON:
+        try:
+            data = response.json()
+        except JSONDecodeError:
+            # Return full exception if JSON cannot be resolved
+            data = exception
+    return data
+
+
 def extract_value(begin, key, end, s):
     """
     Returns a string from a given key/pattern using provided regular expressions.

insightconnect_plugin_runtime/plugin.py

@@ -18,7 +18,12 @@ from insightconnect_plugin_runtime.exceptions import (
     PluginException,
 )
 from insightconnect_plugin_runtime.metrics import MetricsBuilder
-from insightconnect_plugin_runtime.util import is_running_in_cloud, flush_logging_handlers
+from insightconnect_plugin_runtime.util import (
+    is_running_in_cloud,
+    flush_logging_handlers,
+)
+
+logger = structlog.get_logger("plugin")
 
 message_output_type = {
     "action_start": "action_event",
@@ -222,7 +227,9 @@ class Plugin(object):
         if status_code is not None:
             output_message["status_code"] = status_code
 
-        if error_object is not None and isinstance(error_object, (ConnectionTestException, PluginException)):
+        if error_object is not None and isinstance(
+            error_object, (ConnectionTestException, PluginException)
+        ):
             output_message["exception"] = {
                 "cause": error_object.cause,
                 "assistance": error_object.assistance,
@@ -236,6 +243,9 @@ class Plugin(object):
 
             if ex:
                 if isinstance(ex, ConnectionTestException):
+                    error_data = ex.data if ex.data else None
+                    info_log = f"cause={ex.cause}, assistance={ex.assistance}, data={error_data}"
+                    logger.error(f"Plugin exception raised. {info_log}")
                     output_message["exception"] = {
                         "cause": ex.cause,
                         "assistance": ex.assistance,
@@ -441,7 +451,13 @@ class Plugin(object):
                         is_debug,
                     )
                 else:
-                    output, state, has_more_pages, status_code, error_object = self.start_step(
+                    (
+                        output,
+                        state,
+                        has_more_pages,
+                        status_code,
+                        error_object,
+                    ) = self.start_step(
                         input_message["body"],
                         "task",
                         struct_logger,
@@ -571,7 +587,9 @@ class Plugin(object):
                     if step_key == "task":
                         state = message_body["state"]
                         step.state.validate(state)
-                        custom_config = message_body.get("custom_config", {})  # we don't validate this for now
+                        custom_config = message_body.get(
+                            "custom_config", {}
+                        )  # we don't validate this for now
 
                     # Validate required inputs
                     # Step inputs will be checked against schema for required properties existence
@@ -611,7 +629,9 @@ class Plugin(object):
             parameters = inspect.signature(func)
             if len(parameters.parameters) > 0:
                 if step_key == "task" and not is_test:
-                    output, state, has_more_pages, status_code, error_object = func(params, state, custom_config)
+                    output, state, has_more_pages, status_code, error_object = func(
+                        params, state, custom_config
+                    )
                 else:
                     output = func(params)
             else:

insightconnect_plugin_runtime/server.py

@@ -14,7 +14,13 @@ from gunicorn.arbiter import Arbiter
 import structlog
 from pythonjsonlogger.jsonlogger import JsonFormatter
 from requests import get as request_get
-from requests.exceptions import HTTPError, MissingSchema, Timeout, JSONDecodeError, ConnectionError
+from requests.exceptions import (
+    HTTPError,
+    MissingSchema,
+    Timeout,
+    JSONDecodeError,
+    ConnectionError,
+)
 from time import sleep
 from werkzeug.utils import secure_filename
 
@@ -43,8 +49,12 @@ OPEN_API_VERSION = "2.0"
 VERSION_MAPPING = {"legacy": "/", "v1": "/api/v1"}
 CPS_RETRY = 5
 RETRY_SLEEP = 10
-CPS_ENDPOINT = os.getenv("CPS_ENDPOINT")  # endpoint to retrieve plugin custom configs (set in cloud deployments.tf)
-DEFAULT_SCHEDULE_INTERVAL_MINUTES = 3  # default to 3 as most integrations run on 5 minute interval
+CPS_ENDPOINT = os.getenv(
+    "CPS_ENDPOINT"
+)  # endpoint to retrieve plugin custom configs (set in cloud deployments.tf)
+DEFAULT_SCHEDULE_INTERVAL_MINUTES = (
+    3  # default to 3 as most integrations run on 5 minute interval
+)
 
 
 class PluginServer(gunicorn.app.base.BaseApplication):
@@ -185,32 +195,48 @@ class PluginServer(gunicorn.app.base.BaseApplication):
         # Call out to komand-props to get configurations related to only the plugin pod running.
         if is_running_in_cloud() and self.plugin.tasks:
             for attempt in range(1, CPS_RETRY + 1):
-                self.logger.info(f"Getting plugin configuration information... (attempt {attempt}/{CPS_RETRY})")
+                self.logger.info(
+                    f"Getting plugin configuration information... (attempt {attempt}/{CPS_RETRY})"
+                )
                 try:
                     request_response = request_get(CPS_ENDPOINT, timeout=30)
                     resp_json = request_response.json()
-                    plugin = self.plugin.name.lower().replace(" ", "_")  # match how we name our images
+                    plugin = self.plugin.name.lower().replace(
+                        " ", "_"
+                    )  # match how we name our images
                     plugin_config = resp_json.get("plugins", {}).get(plugin, {})
 
                     self.config_options = plugin_config
                     self.logger.info("Plugin configuration successfully retrieved...")
                     return
                 except MissingSchema as missing_schema:
-                    self.logger.error(f"Invalid URL being requested: {CPS_ENDPOINT}, error={missing_schema}")
+                    self.logger.error(
+                        f"Invalid URL being requested: {CPS_ENDPOINT}, error={missing_schema}"
+                    )
                 except Timeout as timeout:
-                    self.logger.error(f"Connection timeout hit. CPS={CPS_ENDPOINT}, error={timeout}")
+                    self.logger.error(
+                        f"Connection timeout hit. CPS={CPS_ENDPOINT}, error={timeout}"
+                    )
                 except HTTPError as http_error:
-                    self.logger.error(f"Connection error when trying to reach CPS. CPS={CPS_ENDPOINT}, error={http_error}")
+                    self.logger.error(
+                        f"Connection error when trying to reach CPS. CPS={CPS_ENDPOINT}, error={http_error}"
+                    )
                 except JSONDecodeError as bad_json:
-                    self.logger.error(f"Got bad JSON back. Response content={request_response.content}, error={bad_json}")
+                    self.logger.error(
+                        f"Got bad JSON back. Response content={request_response.content}, error={bad_json}"
+                    )
                 except ConnectionError as http_connection_pool_error:
                     self.logger.info(
                         "Connection refused when trying to reach CPS, retrying as the connection is still establishing."
                     )
                 except Exception as error:
-                    self.logger.error(f"Hit an unexpected error when retrieving plugin custom configs, error={error}")
+                    self.logger.error(
+                        f"Hit an unexpected error when retrieving plugin custom configs, error={error}"
+                    )
                 sleep(RETRY_SLEEP)
-            self.logger.error(f"Unable to reach CPS after {CPS_RETRY} attempts. CPS={CPS_ENDPOINT}")
+            self.logger.error(
+                f"Unable to reach CPS after {CPS_RETRY} attempts. CPS={CPS_ENDPOINT}"
+            )
 
     def register_api_spec(self):
         """Register all swagger schema definitions and path objects"""

insightconnect_plugin_runtime/util.py

@@ -32,7 +32,9 @@ class OutputMasker:
         if connection and isinstance(connection, dict):
             for key, value in connection.items():
                 if isinstance(value, dict):
-                    connection_values.extend(OutputMasker.extract_connection_values(value))
+                    connection_values.extend(
+                        OutputMasker.extract_connection_values(value)
+                    )
                 elif isinstance(value, str) and value and key in keys_to_check:
                     connection_values.append(value)
         return sorted(set(connection_values))

{insightconnect_plugin_runtime-5.4.9.dist-info → insightconnect_plugin_runtime-5.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: insightconnect-plugin-runtime
-Version: 5.4.9
+Version: 5.5.1
 Summary: InsightConnect Plugin Runtime
 Home-page: https://github.com/rapid7/komand-plugin-sdk-python
 Author: Rapid7 Integrations Alliance
@@ -12,7 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Topic :: Software Development :: Build Tools
 Description-Content-Type: text/markdown
-Requires-Dist: requests ==2.31.0
+Requires-Dist: requests ==2.32.0
 Requires-Dist: python-jsonschema-objects ==0.5.2
 Requires-Dist: jsonschema ==4.21.1
 Requires-Dist: certifi ==2024.2.2
@@ -211,6 +211,8 @@ contributed. Black is installed as a test dependency and the hook can be initial
 after cloning this repository.
 
 ## Changelog
+* 5.5.1 - Address bug with typing for type `Tuple` in Python 3.8
+* 5.5.0 - Updated helper class to add `make_request`, `response_handler`, `extract_json`, and `request_error_handling` for HTTP requests, and `hash_sha1` and `compare_and_dedupe_hashes` to provide support for hash comparisons | Add `METHOD_NOT_ALLOWED`, `CONFLICT`, `REDIRECT_ERROR`, and `CONNECTION_ERROR` to PluginException presets
 * 5.4.9 - Updated aws_client to clean assume role json object to remove any none or empty string values.
 * 5.4.8 - Address vulnerabilities within `gunicorn` and `idna` python packages.
 * 5.4.7 - Address vulnerabilities within `insightconnect-python-3-plugin` image.

{insightconnect_plugin_runtime-5.4.9.dist-info → insightconnect_plugin_runtime-5.5.1.dist-info}/RECORD

@@ -3,22 +3,22 @@ insightconnect_plugin_runtime/action.py,sha256=8gsOONf7mzY83O3DNjCBIafk7C7acnf7m
 insightconnect_plugin_runtime/cli.py,sha256=Pb-Janu-XfRlSXxPHh30OIquljWptrhhS51C3clJqh4,8939
 insightconnect_plugin_runtime/connection.py,sha256=4bHHV2B0UFGsAtvLu1fiYQRwx7fissUakHPUyjLQO0E,2340
 insightconnect_plugin_runtime/dispatcher.py,sha256=ru7njnyyWE1-oD-VbZJ-Z8tELwvDf69rM7Iezs4rbnw,1774
-insightconnect_plugin_runtime/exceptions.py,sha256=rC74M9aCSrY7J-nq9ttsccLkNbHR0gbZ2SRvXlCgLx0,6507
-insightconnect_plugin_runtime/helper.py,sha256=m5PxN04-NPXM1X10S2wwjqmiLvnNntd6TnwLoW4nnus,21108
+insightconnect_plugin_runtime/exceptions.py,sha256=7aYNoGgmV6SugHAQqeQYm1zo2LZm0vgXEGqHmYD7NCo,8260
+insightconnect_plugin_runtime/helper.py,sha256=EXPqe-2tG7Er_vOwEzQCPmGpBgauNbUIU0G_R-tWKgk,31155
 insightconnect_plugin_runtime/metrics.py,sha256=hf_Aoufip_s4k4o8Gtzz90ymZthkaT2e5sXh5B4LcF0,3186
-insightconnect_plugin_runtime/plugin.py,sha256=0IcyhAxklL8lMX7qRXBJ0V6rCt56b5VyrqBG3RAOatU,23573
+insightconnect_plugin_runtime/plugin.py,sha256=9k01QqEh78OTs0pMRfnwZcRr-vFe7iyAtLz_QBa23e4,24127
 insightconnect_plugin_runtime/schema.py,sha256=jTNc6KAMqFpaDVWrAYhkVC6e8I63P3X7uVlJkAr1hiY,583
-insightconnect_plugin_runtime/server.py,sha256=6iwfnSCWSwBn0D0_eRZQRvQu1CiY8QPsD2MsseFjFws,12195
+insightconnect_plugin_runtime/server.py,sha256=09fxsbKf2ZZvSqRP2Bv9e9-fspDyEFR8_YgIFeMnXqQ,12578
 insightconnect_plugin_runtime/step.py,sha256=KdERg-789-s99IEKN61DR08naz-YPxyinPT0C_T81C4,855
 insightconnect_plugin_runtime/task.py,sha256=d-H1EAzVnmSdDEJtXyIK5JySprxpF9cetVoFGtWlHrg,123
 insightconnect_plugin_runtime/trigger.py,sha256=Zq3cy68N3QxAGbNZKCID6CZF05Zi7YD2sdy_qbedUY8,874
-insightconnect_plugin_runtime/util.py,sha256=msLDZrVDNaOY_lnkZghZk-GKsKpJHOpxz5iYIE8DnQ8,8398
+insightconnect_plugin_runtime/util.py,sha256=qPkZ3LA55nYuNYdansEbnCnBccQkpzIpp9NA1B64Kvw,8444
 insightconnect_plugin_runtime/variables.py,sha256=7FjJGnU7KUR7m9o-_tRq7Q3KiaB1Pp0Apj1NGgOwrJk,3056
 insightconnect_plugin_runtime/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-insightconnect_plugin_runtime/api/endpoints.py,sha256=HjiGmYlg8T7_Q_2JHiywMWnE3_mrLfnmbLSj9zFwoSE,31445
+insightconnect_plugin_runtime/api/endpoints.py,sha256=57pSoVSyZU6ERPZ6joMUf6eTDXVRCROLJkmtw4DJhUg,31720
 insightconnect_plugin_runtime/api/schemas.py,sha256=jRmDrwLJTBl-iQOnyZkSwyJlCWg4eNjAnKfD9Eko4z0,2754
 insightconnect_plugin_runtime/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-insightconnect_plugin_runtime/clients/aws_client.py,sha256=SbBVgCAZ0OWXwBDk4kiycteAu33beCJf3B445ri22bU,20508
+insightconnect_plugin_runtime/clients/aws_client.py,sha256=p_s7YLYOeSrBnJl-1gStuNwse6nw4_sl7kz6AKThboY,20465
 insightconnect_plugin_runtime/clients/oauth.py,sha256=bWtAGRMwdK4dw9vMPcw9usklyIHBDtZh55kMZ7sWROc,2453
 insightconnect_plugin_runtime/data/input_message_schema.json,sha256=7_BcHi6UOBiVWGrrJHHn5IoddteXjL7GOKETdO9T2DE,1770
 insightconnect_plugin_runtime/data/output_message_schema.json,sha256=Qya6U-NR5MfOlw4V98VpQzGBVq75eGMUQhI-j3yxOHI,1137
@@ -68,7 +68,7 @@ tests/unit/test_aws_action.py,sha256=uerrNB_cH0J9lnxEaVuVaMxTFZoPXuT9lmtpcwoG34Y
 tests/unit/test_custom_encoder.py,sha256=KLYyVOTq9MEkZXyhVHqjm5LVSW6uJS4Davgghsw9DGk,2207
 tests/unit/test_endpoints.py,sha256=LuXOfLBu47rDjGa5YEsOwTZBEdvQdl_C6-r46oxWZA8,6401
 tests/unit/test_exceptions.py,sha256=t8c67n3ZQPpyzzYPN6TZHpNeE8uKlOSfHJPk71QONuU,4668
-tests/unit/test_helpers.py,sha256=jtgPLQWhi_EXGxWLDwoneexbZalFaTVPx3FqyH9pOQw,8542
+tests/unit/test_helpers.py,sha256=NaZBnVVsQuRb_0uxPjCyptEd5408Ok_AIPjhetGLPjk,16043
 tests/unit/test_metrics.py,sha256=PjjTrB9w7uQ2Q5UN-893-SsH3EGJuBseOMHSD1I004s,7979
 tests/unit/test_oauth.py,sha256=nbFG0JH1x04ExXqSe-b5BGdt_hJs7DP17eUa6bQzcYI,2093
 tests/unit/test_plugin.py,sha256=ZTNAZWwZhDIAbxkVuWhnz9FzmojbijgMmsLWM2mXQI0,4160
@@ -77,8 +77,8 @@ tests/unit/test_server_cloud_plugins.py,sha256=PuMDHTz3af6lR9QK1BtPScr7_cRbWheto
 tests/unit/test_server_spec.py,sha256=je97BaktgK0Fiz3AwFPkcmHzYtOJJNqJV_Fw5hrvqX4,644
 tests/unit/test_trigger.py,sha256=E53mAUoVyponWu_4IQZ0IC1gQ9lakBnTn_9vKN2IZfg,1692
 tests/unit/test_variables.py,sha256=OUEOqGYZA3Nd5oKk5GVY3hcrWKHpZpxysBJcO_v5gzs,291
-tests/unit/utils.py,sha256=g_phxLH96rNwsdrry8Y7SjT9oZCps7ussI-ofc9K_xw,478
-insightconnect_plugin_runtime-5.4.9.dist-info/METADATA,sha256=zCagpw_oMqVKkl9BbsO_LydWcYj7X4v0jjcPdIgMhxs,13173
-insightconnect_plugin_runtime-5.4.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-insightconnect_plugin_runtime-5.4.9.dist-info/top_level.txt,sha256=AJtyJOpiFzHxsbHUICTcUKXyrGQ3tZxhrEHsPjJBvEA,36
-insightconnect_plugin_runtime-5.4.9.dist-info/RECORD,,
+tests/unit/utils.py,sha256=VooVmfpIgxmglNdtmT32AkEDFxHxyRHLK8RsCWjjYRY,2153
+insightconnect_plugin_runtime-5.5.1.dist-info/METADATA,sha256=-BI5OWO_Kg7Im2iXx12G2otyOjy_Noob-MUAF4ZGjLg,13572
+insightconnect_plugin_runtime-5.5.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+insightconnect_plugin_runtime-5.5.1.dist-info/top_level.txt,sha256=AJtyJOpiFzHxsbHUICTcUKXyrGQ3tZxhrEHsPjJBvEA,36
+insightconnect_plugin_runtime-5.5.1.dist-info/RECORD,,

tests/unit/test_helpers.py

@@ -1,7 +1,16 @@
 import pytest
 from insightconnect_plugin_runtime import helper
+from insightconnect_plugin_runtime.exceptions import (
+    HTTPStatusCodes,
+    ResponseExceptionData,
+    PluginException,
+)
 import requests
 import os
+from unittest import TestCase
+from unittest.mock import patch
+from tests.unit.utils import mock_request
+from parameterized import parameterized
 
 
 def test_extract_value_successful():
@@ -306,3 +315,209 @@ def test_get_url_content_disposition_success():
     }
 
     assert "test.html" == helper.get_url_content_disposition(headers)
+
+
+class TestRequestsHelpers(TestCase):
+    def test_response_handler(self):
+        response = requests.Response()
+        response._content = (
+            b'{"message": "Unauthorized", "error": "invalid_credentials"}'
+        )
+        response.url = "https://example.com"
+        response.reason = "UNAUTHORIZED"
+        response.status_code = 401
+        response.headers["Content-Type"] = "application/json"
+        custom_configs = {
+            HTTPStatusCodes.UNAUTHORIZED: PluginException(
+                cause="Unauthorized custom", assistance="Check permissions custom"
+            )
+        }
+        response = helper.response_handler(
+            response, custom_configs, ResponseExceptionData.RESPONSE_JSON, [401]
+        )
+        self.assertEqual(response, None)
+
+    def test_response_handler_error(self):
+        response = requests.Response()
+        response._content = (
+            b'{"message": "Unauthorized", "error": "invalid_credentials"}'
+        )
+        response.url = "https://example.com"
+        response.reason = "UNAUTHORIZED"
+        response.status_code = 401
+        response.headers["Content-Type"] = "application/json"
+        custom_configs = {
+            HTTPStatusCodes.UNAUTHORIZED: PluginException(
+                cause="Unauthorized custom", assistance="Check permissions custom"
+            )
+        }
+        with self.assertRaises(PluginException) as assertion:
+            helper.response_handler(
+                response, custom_configs, ResponseExceptionData.RESPONSE_JSON
+            )
+        self.assertEqual(
+            assertion.exception.cause,
+            "Unauthorized custom",
+        )
+        self.assertEqual(
+            assertion.exception.assistance,
+            "Check permissions custom",
+        )
+        self.assertEqual(
+            assertion.exception.data,
+            {"message": "Unauthorized", "error": "invalid_credentials"},
+        )
+
+    @patch("requests.Session.send", side_effect=mock_request)
+    def test_make_request(self, mock_request):
+        request = requests.Request(
+            method="GET",
+            url="https://example.com/success",
+            params={"sample": "value"},
+            data={"sample": "value"},
+            json={"sample": "value"},
+            headers={"Content-Type": "application/json"},
+        )
+        response = helper.make_request(_request=request)
+        expected = {
+            "json": {"example": "sample"},
+            "status_code": 200,
+            "content": b"example",
+            "url": "https://example.com/success",
+        }
+        self.assertEqual(response.content, expected.get("content"))
+        self.assertEqual(response.status_code, expected.get("status_code"))
+        self.assertEqual(response.url, expected.get("url"))
+
+    @parameterized.expand(
+        [
+            ["401", "GET", "https://example.com/401", {}, PluginException],
+            [
+                "timeout",
+                "GET",
+                "https://example.com/timeout",
+                {},
+                requests.exceptions.Timeout,
+            ],
+            [
+                "connectionerror",
+                "GET",
+                "https://example.com/connectionerror",
+                {},
+                requests.exceptions.ConnectionError,
+            ],
+            [
+                "toomanyredirects",
+                "GET",
+                "https://example.com/toomanyredirects",
+                {},
+                requests.exceptions.TooManyRedirects,
+            ],
+            [
+                "unknownerror",
+                "GET",
+                "https://example.com/unknownerror",
+                {},
+                PluginException,
+            ],
+            [
+                "custom404",
+                "GET",
+                "https://example.com/404",
+                {
+                    404: PluginException(
+                        cause="CustomCause", assistance="CustomAssistance"
+                    )
+                },
+                PluginException,
+            ],
+        ]
+    )
+    @patch("requests.Session.send", side_effect=mock_request)
+    def test_make_request_error_handling(
+        self, test_name, method, url, exp_config, exception_type, mock_request
+    ):
+        request = requests.Request(method=method, url=url, json=None)
+        with self.assertRaises(PluginException) as error:
+            helper.make_request(_request=request, exception_custom_configs=exp_config)
+        assert (isinstance(error, exception_type), True)
+        if test_name == "custom404":
+            self.assertEqual(
+                error.exception.cause,
+                "CustomCause",
+            )
+            self.assertEqual(
+                error.exception.assistance,
+                "CustomAssistance",
+            )
+
+    @parameterized.expand(
+        [
+            ["401", "https://example.com/401", PluginException],
+            [
+                "timeout",
+                "https://example.com/timeout",
+                requests.exceptions.Timeout,
+            ],
+            [
+                "connectionerror",
+                "https://example.com/connectionerror",
+                requests.exceptions.ConnectionError,
+            ],
+            [
+                "toomanyredirects",
+                "https://example.com/toomanyredirects",
+                requests.exceptions.TooManyRedirects,
+            ],
+            [
+                "unknownerror",
+                "https://example.com/unknownerror",
+                PluginException,
+            ],
+        ]
+    )
+    @patch("requests.request", side_effect=mock_request)
+    def test_request_error_handling(self, test_name, url, exception_type, mock_request):
+        @helper.request_error_handling()
+        def dummy_request(self):
+            response = requests.request("GET", url)
+            response.raise_for_status()
+
+        with self.assertRaises(PluginException) as error:
+            dummy_request(self)
+        assert (isinstance(error, exception_type), True)
+
+    def test_extract_json(self):
+        with self.assertRaises(PluginException) as error:
+            response = requests.Response()
+            response._content = (
+                b'{"message": "Unauthorized", "error": "invalid_credentials'
+            )
+            response.url = "https://example.com"
+            response.reason = "UNAUTHORIZED"
+            response.status_code = 401
+            response.headers["Content-Type"] = "application/json"
+            helper.extract_json(response)
+        assert (isinstance(error, PluginException), True)
+        self.assertEqual(
+            error.exception.cause, "Received an unexpected response from the server."
+        )
+
+
+def test_hash_sha1():
+    log = {"example": "value", "sample": "value"}
+    assert "2e1ccc1a95e9b2044f13546c25fe380bbd039293" == helper.hash_sha1(log)
+
+
+def test_compare_and_dedupe_hashes():
+    hashes = ["2e1ccc1a95e9b2044f13546c25fe380bbd039293"]
+    logs = [
+        {
+            "example": "value",
+            "sample": "value",
+        },
+        {"specimen": "new_value"},
+    ]
+    assert [{"specimen": "new_value"}], [
+        "ad6ae80c0356e02b1561cb58408ee678eb1070bb"
+    ] == helper.compare_and_dedupe_hashes(hashes, logs)

tests/unit/utils.py

@@ -1,5 +1,9 @@
+import requests
+
+
 class MockResponse:
-    """ Mocked response from CPS """
+    """Mocked response from CPS"""
+
     def __init__(self, value):
         self.json_value = value
 
@@ -9,6 +13,7 @@ class MockResponse:
 
 class Logger:
     """Mocked logger to easily find last log triggered from SDK server."""
+
     def __init__(self):
         self.last_error = []
         self.last_info = []
@@ -18,3 +23,56 @@ class Logger:
 
     def error(self, log: str):
         self.last_error.append(log)
+
+
+def get_mock_response(
+    status_code: int, url: str, reason: str, content: str = None, data: dict = {}
+):
+    response = requests.Response()
+    response.status_code = status_code
+    bytes_string = content.encode("utf-8")
+    response._content = bytes_string
+    response.url = url
+    response.reason = reason
+
+    def return_json():
+        return data
+
+    response.json = return_json
+    return response
+
+
+def mock_request(*args, **kwargs):
+    if isinstance(args[0], requests.PreparedRequest):
+        url = args[0].url
+    else:
+        url = args[1]
+    if url == "https://example.com/success?sample=value":
+        return get_mock_response(
+            200, "https://example.com/success", None, "example", {"example": "sample"}
+        )
+    if url == "https://example.com/401":
+        return get_mock_response(
+            401,
+            "https://example.com/401",
+            "UNAUTHORIZED",
+            "example",
+            {"example": "sample"},
+        )
+    if url == "https://example.com/404":
+        return get_mock_response(
+            404,
+            "https://example.com/404",
+            "NOT_FOUND",
+            "example",
+            {"example": "sample"},
+        )
+    if url == "https://example.com/timeout":
+        raise requests.exceptions.Timeout()
+    if url == "https://example.com/connectionerror":
+        raise requests.exceptions.ConnectionError()
+    if url == "https://example.com/toomanyredirects":
+        raise requests.exceptions.TooManyRedirects()
+    if url == "https://example.com/unknownerror":
+        raise requests.exceptions.ContentDecodingError
+    raise NotImplementedError("Not implemented")