stoobly-agent 1.4.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

stoobly_agent/app/proxy/handle_test_service.py

@@ -1,7 +1,9 @@
 import pdb
 
+from copy import deepcopy
 from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow
 
+from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 from stoobly_agent.app.proxy.replay.body_parser_service import encode_response
 from stoobly_agent.app.proxy.replay.context import ReplayContext
 from stoobly_agent.app.proxy.utils.request_handler import build_response
@@ -12,35 +14,53 @@ from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
 from stoobly_agent.lib.api.interfaces.tests import TestShowResponse
 from stoobly_agent.lib.logger import Logger
 
-from .handle_mock_service import handle_request_mock_generic
-from .handle_replay_service import handle_request_replay
+from .handle_mock_service import handle_request_mock_generic_without_rewrite
+from .handle_replay_service import handle_request_replay_without_rewrite
 from .mock.context import MockContext
 from .test.helpers.test_results_builder import TestResultsBuilder
 from .test.helpers.upload_test_service import inject_upload_test
 from .test.context_abc import TestContextABC as TestContext
 from .test.test_service import test
+from .utils.rewrite import rewrite_request, rewrite_response, rewrite_request_response
 
 LOG_ID = 'HandleTest'
 
+###
+#
+# 1. Rewrites test request
+# 2. BEFORE_REPLAY gets triggered
+#
 def handle_request_test(context: ReplayContext) -> None:
-    handle_request_replay(context)
+    __rewrite_request(context)
+    handle_request_replay_without_rewrite(context)
 
 ###
 #
-# Mock and Test modes share the same policies
+# 1.  Rewrites test response (response from live service)
+# 2.  AFTER_REPLAY gets triggered
+# 3.  Uses rewritten test request to obtain mock response
+# 4.  BEFORE_MOCK gets triggered
+# 5.  AFTER_MOCK gets triggered
+# 6.  BEFORE_TEST gets triggered
+# 7.  Tests against rewritten test response and mock response (expected response)
+# 8.  Rewrites a copy of request and response
+# 9.  BEFORE_RECORD gets triggered (if not from CLI)
+# 10. AFTER_RECORD gets triggered (if not from CLI)
+# 11. AFTER_TEST gets triggered 
 #
 def handle_response_test(context: ReplayContext) -> None:
     from .test.context import TestContext
 
     flow: MitmproxyHTTPFlow = context.flow
-    intercept_settings = context.intercept_settings
-
     disable_transfer_encoding(flow.response)
 
-    # At this point, the request may already been rewritten during replay
-    # Request will be rewritten again for mocking purposes
+    __rewrite_response(context)
+    __test_hook(lifecycle_hooks.AFTER_REPLAY, context)
 
-    handle_request_mock_generic(
+    intercept_settings = context.intercept_settings
+
+    # At this point, the request may already been rewritten during replay, do not rewrite again
+    handle_request_mock_generic_without_rewrite(
         MockContext(flow, intercept_settings),
         failure=lambda mock_context: __handle_mock_failure(TestContext(context, mock_context)),
         #infer=intercept_settings.test_strategy == test_strategy.FUZZY, # For fuzzy testing we can use an inferred response
@@ -53,8 +73,10 @@ def __decorate_test_id(flow: MitmproxyHTTPFlow, test_response: TestShowResponse)
 
 def __handle_mock_success(test_context: TestContext) -> None:
     flow: MitmproxyHTTPFlow = test_context.flow
-    settings = Settings.instance()
 
+    __test_hook(lifecycle_hooks.AFTER_MOCK, test_context.mock_context)
+
+    settings: Settings = Settings.instance()
     test_context.with_endpoints_resource(EndpointsResource(settings.remote.api_url, settings.remote.api_key))
 
     __test_hook(lifecycle_hooks.BEFORE_TEST, test_context)
@@ -84,13 +106,8 @@ def __handle_mock_success(test_context: TestContext) -> None:
         if not is_cli or test_context.save:
             # Re-serialize expected response since it was rewritten
             upload_test_data['expected_response'] = encode_response(expected, test_context.expected_response.content_type)
-            upload_test = inject_upload_test(None, intercept_settings)
 
-            # Commit test to API
-            res = upload_test(
-                flow,
-                **upload_test_data
-            )
+            res = __record_handler(test_context, upload_test_data) 
 
             if is_cli:
                 # If the origin was from a CLI, send test ID in response header
@@ -136,6 +153,48 @@ def __override_response(flow: MitmproxyHTTPFlow, content: bytes):
     flow.response.set_content(content)
     flow.response.status_code = 200
 
+def __record_handler(context: TestContext, upload_test_data):
+    flow = context.flow
+    flow_copy = deepcopy(flow) # Deep copy flow to prevent response modifications from persisting
+    intercept_settings = context.intercept_settings
+
+    context.flow = flow_copy 
+
+    # Since we are "uploading" the request, use record_write_rules
+    rewrite_request_response(flow_copy, intercept_settings.record_rewrite_rules)
+    __test_hook(lifecycle_hooks.BEFORE_RECORD, context)
+
+    # Commit test to API
+    upload_test = inject_upload_test(None, intercept_settings)
+    res = upload_test(
+        flow_copy, **upload_test_data
+    )
+
+    __test_hook(lifecycle_hooks.AFTER_RECORD, context)
+    context.flow = flow
+
+    return res
+
+def __rewrite_request(replay_context: ReplayContext):
+    """
+    Before replaying a request, see if the request needs to be rewritten
+    """
+    intercept_settings: InterceptSettings = replay_context.intercept_settings
+    rewrite_rules = intercept_settings.test_rewrite_rules
+
+    if len(rewrite_rules) > 0:
+        rewrite_request(replay_context.flow, rewrite_rules)
+
+def __rewrite_response(replay_context: ReplayContext):
+    """
+    After replaying a request, see if the request needs to be rewritten
+    """
+    intercept_settings: InterceptSettings = replay_context.intercept_settings
+    rewrite_rules = intercept_settings.test_rewrite_rules
+
+    if len(rewrite_rules) > 0:
+        rewrite_response(replay_context.flow, rewrite_rules)
+
 def __test_hook(hook: str, context: TestContext):
     intercept_settings = context.intercept_settings
     lifecycle_hooks_module = intercept_settings.lifecycle_hooks

stoobly_agent/app/proxy/intercept_handler.py

@@ -33,6 +33,7 @@ def request(flow: MitmproxyHTTPFlow):
     if not intercept_settings.active:
         return
 
+    __disable_web_cache(request)
     __intercept_hook(lifecycle_hooks.BEFORE_REQUEST, flow, intercept_settings)
 
     active_mode = intercept_settings.mode
@@ -42,7 +43,7 @@ def request(flow: MitmproxyHTTPFlow):
         context = MockContext(flow, intercept_settings)
         handle_request_mock(context)
     elif active_mode == mode.RECORD:
-        __disable_web_cache(request)
+        pass
     elif active_mode == mode.REPLAY:
         context = ReplayContext(flow, intercept_settings)
         handle_request_replay(context)
@@ -65,35 +66,29 @@ def response(flow: MitmproxyHTTPFlow):
     if not intercept_settings.active:
         return
 
-    __intercept_hook(lifecycle_hooks.BEFORE_RESPONSE, flow, intercept_settings)
-
     active_mode = intercept_settings.mode
 
     if active_mode == mode.MOCK:
         context = MockContext(flow, intercept_settings)
-        return handle_response_mock(context)
+        handle_response_mock(context)
     elif active_mode == mode.RECORD:
         context = RecordContext(flow, intercept_settings)
-        return handle_response_record(context)
+        handle_response_record(context)
     elif active_mode == mode.REPLAY:
         context = ReplayContext(flow, intercept_settings)
-        return handle_response_replay(context)
+        handle_response_replay(context)
     elif active_mode == mode.TEST:
         context = ReplayContext(flow, intercept_settings)
-        return handle_response_test(context)
+        handle_response_test(context)
+
+    __intercept_hook(lifecycle_hooks.BEFORE_RESPONSE, flow, intercept_settings)
 
 ### PRIVATE
 
+# Prevent 304 status
+# Because this header will get recorded, should add during mocking as well in the case where headers are used for matching
 def __disable_web_cache(request: MitmproxyRequest) -> None:
-    request.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
-    request.headers['Expires'] = '0'
-    request.headers['Pragma'] = 'no-cache'
-
-    if 'IF-NONE-MATCH' in request.headers:
-        del request.headers['IF-NONE-MATCH']
-
-    if 'IF-MODIFIED-SINCE' in request.headers:
-        del request.headers['IF-MODIFIED-SINCE']
+    request.headers['Cache-Control'] = 'no-cache, no-store'
 
 # Fix issue where multi-value cookies become comma separated
 def __patch_cookie(request: MitmproxyRequest):

stoobly_agent/app/proxy/intercept_settings.py

@@ -41,6 +41,11 @@ class InterceptSettings:
     self.__response_fixtures = None
     self.__initialize_response_fixtures()
 
+    self._mock_rewrite_rules = None
+    self._record_rewrite_rules = None
+    self._replay_rewrite_rules = None
+    self._test_rewrite_rules = None
+
   @property
   def settings(self):
     return self.__settings
@@ -200,19 +205,27 @@ class InterceptSettings:
 
   @property
   def record_rewrite_rules(self) -> List[RewriteRule]:
-    return self.__select_rewrite_rules(mode.RECORD)
+    if not self._record_rewrite_rules:
+      self._record_rewrite_rules = self.__select_rewrite_rules(mode.RECORD)
+    return self._record_rewrite_rules
 
   @property
   def mock_rewrite_rules(self) -> List[RewriteRule]:
-    return self.__select_rewrite_rules(mode.MOCK)
+    if not self._mock_rewrite_rules:
+      self._mock_rewrite_rules = self.__select_rewrite_rules(mode.MOCK)
+    return self._mock_rewrite_rules
 
   @property
   def replay_rewrite_rules(self) -> List[RewriteRule]:
-    return self.__select_rewrite_rules(mode.REPLAY)
+    if not self._replay_rewrite_rules:
+      self._replay_rewrite_rules = self.__select_rewrite_rules(mode.REPLAY)
+    return self._replay_rewrite_rules
 
   @property
   def test_rewrite_rules(self) -> List[RewriteRule]:
-    return self.__select_rewrite_rules(mode.TEST)
+    if not self._test_rewrite_rules:
+      self._test_rewrite_rules = self.__select_rewrite_rules(mode.TEST)
+    return self._test_rewrite_rules
 
   @property
   def upstream_url(self):

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -239,7 +239,7 @@ class MitmproxyRequestFacade(Request):
         content_type = self.content_type
         parsed_content = self.__body.get(content_type)
 
-        if not isinstance(parsed_content, dict) and not isinstance(parsed_content, multidict.MultiDictView):
+        if not self.__is_iterable(parsed_content):
             content_type = 'application/json'
             self.request.headers['content-type'] = content_type
             parsed_content = {}
@@ -265,4 +265,7 @@ class MitmproxyRequestFacade(Request):
 
             _request_headers.pop(name)
 
-        return _request_headers
+        return _request_headers
+
+    def __is_iterable(self, v):
+        return isinstance(v, dict) or isinstance(v, multidict.MultiDictView) or isinstance(v, list)

stoobly_agent/app/proxy/mitmproxy/response_facade.py

@@ -95,10 +95,8 @@ class MitmproxyResponseFacade(Response):
         content_type = self.content_type
         parsed_content = self.__body.get(content_type)
 
-        if not isinstance(parsed_content, dict) and not isinstance(parsed_content, multidict.MultiDictView):
-            content_type = 'application/json'
-            self.response.headers['content-type'] = content_type
-            parsed_content = {}
+        if not self.__is_iterable(parsed_content):
+            return 
 
         self.__apply_rewrites(parsed_content, rewrites, handler)
         self.__body.set(parsed_content, content_type)
@@ -122,3 +120,6 @@ class MitmproxyResponseFacade(Response):
             _response_headers.pop(name)
 
         return _response_headers
+
+    def __is_iterable(self, v):
+        return isinstance(v, dict) or isinstance(v, multidict.MultiDictView) or isinstance(v, list)

stoobly_agent/app/proxy/mock/eval_fixtures_service.py

@@ -1,3 +1,4 @@
+import mimetypes
 import os
 import pdb
 import re
@@ -5,6 +6,7 @@ import re
 from io import BytesIO
 from mitmproxy.http import Request as MitmproxyRequest
 from requests import Response
+from requests.structures import CaseInsensitiveDict
 from typing import Union
 
 from stoobly_agent.lib.logger import bcolors, Logger
@@ -19,45 +21,88 @@ class Options():
 
 def eval_fixtures(request: MitmproxyRequest, **options: Options) -> Union[Response, None]:
   fixture_path = None
-  headers = {}
+  headers = CaseInsensitiveDict()
+  status_code = 200
 
   response_fixtures = options.get('response_fixtures')
-  fixture = __eval_response_fixtures(request, response_fixtures)
+  fixture: dict = __eval_response_fixtures(request, response_fixtures)
 
   if not fixture:
     public_directory_path = options.get('public_directory_path')
 
-    if public_directory_path and os.path.exists(public_directory_path):
-      static_file_path = os.path.join(public_directory_path, request.path.lstrip('/'))
+    if not public_directory_path:
+      return
 
-      if os.path.exists(static_file_path):
-        fixture_path = static_file_path
+    request_path = 'index' if request.path == '/' else request.path
+    _fixture_path = os.path.join(public_directory_path, request_path.lstrip('/'))
+    if request.headers.get('accept'):
+      fixture_path = __guess_file_path(_fixture_path, request.headers['accept'])
+
+    if not fixture_path:
+      fixture_path = _fixture_path
+      if not os.path.isfile(fixture_path):
+        return
   else:
     fixture_path = fixture.get('path')
-    headers = fixture.get('headers') or {}
+    if not fixture_path or not os.path.isfile(fixture_path):
+      return
 
-  if not fixture_path:
-    return
+    _headers = fixture.get('headers')
+    headers = CaseInsensitiveDict(_headers if isinstance(_headers, dict) else {}) 
+
+    if fixture.get('status_code'):
+      status_code = fixture.get('status_code')
 
   with open(fixture_path, 'rb') as fp:
     response = Response()
 
-    response.status_code = 200
+    response.status_code = status_code
     response.raw = BytesIO(fp.read()) 
     response.headers = headers
 
+    if not response.headers.get('content-type'):
+      content_type = __guess_content_type(fixture_path)
+      if content_type:
+        response.headers['content-type'] = content_type
+
     Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE}Resolved{bcolors.ENDC} fixture {fixture_path}")
 
     return response
 
+def __guess_content_type(file_path):
+  file_extension = os.path.splitext(file_path)[1]
+  if not file_extension:
+    return
+  return mimetypes.types_map.get(file_extension)
+
+def __guess_file_path(file_path, content_type):
+  file_extension = os.path.splitext(file_path)[1]
+  if file_extension:
+    return file_path
+
+  if not content_type:
+    return
+
+  content_types = __parse_accept_header(content_type)
+
+  for content_type in content_types:
+    file_extension = mimetypes.guess_extension(content_type)
+
+    if not file_extension:
+      continue
+
+    _file_path = f"{file_path}{file_extension}"
+    if os.path.isfile(_file_path):
+      return _file_path
+
 def __eval_response_fixtures(request: MitmproxyRequest, response_fixtures: Fixtures):
-  if not response_fixtures:
+  if not isinstance(response_fixtures, dict):
     return
 
   method = request.method
   routes = response_fixtures.get(method)
 
-  if not routes:
+  if not isinstance(routes, dict):
     return
 
   for path_pattern in routes:
@@ -65,7 +110,26 @@ def __eval_response_fixtures(request: MitmproxyRequest, response_fixtures: Fixtu
       continue
       
     fixture = routes[path_pattern]
+    if not isinstance(fixture, dict):
+      continue
+
     path = fixture.get('path')
 
-    if path and os.path.exists(path):
-      return fixture
+    if path:
+      return fixture
+
+def __parse_accept_header(accept_header):
+    types = []
+    for item in accept_header.split(","):
+        parts = item.split(";")
+        content_type = parts[0].strip()
+        q_value = 1.0  # Default quality value
+        if len(parts) > 1 and parts[1].strip().startswith("q="):
+            try:
+                q_value = float(parts[1].strip()[2:])
+            except ValueError:
+                pass  # Keep default q_value if parsing fails
+        types.append((content_type, q_value))
+
+    # Sort by quality factor in descending order
+    return [content_type for content_type, _ in sorted(types, key=lambda x: x[1], reverse=True)]

stoobly_agent/app/proxy/mock/eval_request_service.py

@@ -149,9 +149,9 @@ def __filter_by_match_rules(request: MitmproxyRequest, match_rules: List[MatchRu
     method = request.method.upper()
 
     keep = {
-        request_component.BODY_PARAM: True,
+        request_component.BODY_PARAM: False,
         request_component.HEADER: False,
-        request_component.QUERY_PARAM: True,
+        request_component.QUERY_PARAM: False,
     }
 
     match_rules = list(filter(lambda rule: method in rule.methods, match_rules))

stoobly_agent/app/proxy/record/join_request_service.py

@@ -1,10 +1,14 @@
 import pdb
+
 from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow
+from typing import List
 
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
+from stoobly_agent.app.settings.rewrite_rule import RewriteRule
 
 from ..mitmproxy.request_facade import MitmproxyRequestFacade
 from ..mitmproxy.response_facade import MitmproxyResponseFacade
+from ..utils.rewrite import rewrite_request_response
 from .joined_request import JoinedRequest
 from .proxy_request import ProxyRequest
 
@@ -18,15 +22,10 @@ def join_request(
     # Create JoinedRequest
     return JoinedRequest(proxy_request).with_response(adapted_response)
 
-def join_rewritten_request(flow: MitmproxyHTTPFlow, intercept_settings: InterceptSettings) -> JoinedRequest:
-    # Adapt flow.request
+def join_request_from_flow(
+    flow: MitmproxyHTTPFlow, intercept_settings: InterceptSettings
+) -> JoinedRequest:
     request = MitmproxyRequestFacade(flow.request)
-
-    # Adapt flow.response
     response = MitmproxyResponseFacade(flow.response)
-    rewrite_rules = intercept_settings.record_rewrite_rules
-
-    request.with_parameter_rules(rewrite_rules).with_url_rules(rewrite_rules).rewrite()
-    response.with_parameter_rules(rewrite_rules, request).rewrite()
 
     return join_request(request, response, intercept_settings)

stoobly_agent/app/proxy/record/upload_request_service.py

@@ -17,7 +17,7 @@ from stoobly_agent.lib.logger import Logger, bcolors
 from stoobly_agent.lib.orm.request import Request
 
 from ..utils.publish_change_service import publish_requests_modified
-from .join_request_service import join_rewritten_request
+from .join_request_service import join_request_from_flow
 
 AGENT_STATUSES = {
     'REQUESTS_MODIFIED': 'requests-modified'
@@ -50,7 +50,7 @@ def upload_request(
 ):
     Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Recording{bcolors.ENDC} {flow.request.url}")
 
-    joined_request = join_rewritten_request(flow, intercept_settings)
+    joined_request = join_request_from_flow(flow, intercept_settings)
 
     project_key = intercept_settings.project_key
     scenario_key = intercept_settings.scenario_key

stoobly_agent/app/proxy/replay/replay_request_service.py

@@ -32,6 +32,7 @@ class ReplayRequestOptions(TypedDict):
   report_key: Union[str, None] 
   request_origin: Union[request_origin.CLI, None] 
   response_fixtures_path: str
+  response_mode: Union[mode.RECORD, None]
   scenario_key: Union[str, None] 
   scheme: str
   test_filter: test_filter.TestFilter
@@ -83,6 +84,9 @@ def replay(context: ReplayContext, options: ReplayRequestOptions) -> requests.Re
   if options.get('response_fixtures_path'):
     __handle_path_header(custom_headers.RESPONSE_FIXTURES_PATH, options['response_fixtures_path'], headers)
 
+  if options.get('response_mode'):
+    headers[custom_headers.RESPONSE_PROXY_MODE] = options['response_mode']
+
   if options.get('scenario_key'):
     headers[custom_headers.SCENARIO_KEY] = options['scenario_key']
 
@@ -173,10 +177,6 @@ def __handle_mode_option(_mode, request: Request, headers):
       headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
 
     headers[custom_headers.MOCK_POLICY] = mock_policy.ALL
-  elif _mode == mode.RECORD:
-    # If recording, then it's actually a replay and record
-    headers[custom_headers.PROXY_MODE] = mode.REPLAY
-    headers[custom_headers.RESPONSE_PROXY_MODE] = mode.RECORD
 
 def __create_replayed_response(request_id: int, res: requests.Response, latency: int):   
   replayed_response_model = ReplayedResponseModel(Settings.instance())

stoobly_agent/app/proxy/test/helpers/upload_test_service.py

@@ -11,7 +11,7 @@ from stoobly_agent.lib.logger import Logger, bcolors
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 
 from ...intercept_settings import InterceptSettings
-from ...record.join_request_service import join_rewritten_request
+from ...record.join_request_service import join_request_from_flow
 
 LOG_ID = 'Test'
 
@@ -43,7 +43,7 @@ def upload_test(
   flow: MitmproxyHTTPFlow, 
   **kwargs: UploadTestData
 ) -> Response:
-    joined_request = join_rewritten_request(flow, intercept_settings)
+    joined_request = join_request_from_flow(flow, intercept_settings)
 
     Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Uploading{bcolors.ENDC} test results for {joined_request.proxy_request.url()}")
 

stoobly_agent/app/proxy/utils/allowed_request_service.py

@@ -6,7 +6,7 @@ from typing import List
 
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 from stoobly_agent.app.settings.firewall_rule import FirewallRule
-from stoobly_agent.config.constants import mock_policy, request_origin
+from stoobly_agent.config.constants import intercept_policy, request_origin
 from stoobly_agent.lib.logger import bcolors, Logger
 
 LOG_ID = 'Firewall'
@@ -18,8 +18,8 @@ def get_active_mode_policy(request: MitmproxyRequest, intercept_settings: Interc
     if allowed_request(request, intercept_settings):
         return intercept_settings.policy
     else:
-        # If the request path does not match accepted paths, do not mock
-        return mock_policy.NONE
+        # If the request path does not match accepted paths, do not intercept
+        return intercept_policy.NONE
 
 def allowed_request(request: MitmproxyRequest, intercept_settings: InterceptSettings) -> bool:
     # If an exclude rule(s) exists, then only requests not matching these pattern(s) are allowed

stoobly_agent/app/proxy/utils/response_handler.py

@@ -36,8 +36,6 @@ def bad_request(flow: MitmproxyHTTPFlow, message: str):
         {'Content-Type': 'text/plain'}  # (optional) headers
     )
 
-    return False
-
 # Without deleting this header, causes parsing issues when reading response
 def disable_transfer_encoding(response: MitmproxyResponse) -> None:
     header_name = 'Transfer-Encoding'

stoobly_agent/app/proxy/utils/rewrite.py

@@ -0,0 +1,72 @@
+from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow
+from typing import List
+
+from stoobly_agent.app.settings.constants.request_component import REQUEST_COMPONENTS, RESPONSE_COMPONENTS
+from stoobly_agent.app.settings.rewrite_rule import RewriteRule
+
+from ..mitmproxy.request_facade import MitmproxyRequestFacade
+from ..mitmproxy.response_facade import MitmproxyResponseFacade
+
+def select_request_rewrite_rules(rewrite_rules: List[RewriteRule]):
+  rules = []
+
+  for rewrite_rule in rewrite_rules:
+    parameter_rules = list(filter(
+      lambda parameter: parameter.type in REQUEST_COMPONENTS and parameter.name, 
+      rewrite_rule.parameter_rules or []
+    ))
+
+    if len(parameter_rules) > 0:
+      rewrite_rule = RewriteRule(rewrite_rule.to_dict())
+      rewrite_rule.url_rules = rewrite_rule.url_rules
+      rewrite_rule.parameter_rules = parameter_rules
+      rules.append(rewrite_rule)
+
+  return rules
+
+def select_response_rewrite_rules(rewrite_rules: List[RewriteRule]):
+  rules = []
+
+  for rewrite_rule in rewrite_rules:
+    parameter_rules = list(filter(
+      lambda parameter: parameter.type in RESPONSE_COMPONENTS and parameter.name, 
+      rewrite_rule.parameter_rules or []
+    ))
+
+    if len(parameter_rules) > 0:
+      rewrite_rule = RewriteRule(rewrite_rule.to_dict())
+      rewrite_rule.url_rules = [] 
+      rewrite_rule.parameter_rules = parameter_rules
+      rules.append(rewrite_rule)
+
+  return rules
+
+def rewrite_request_response(flow: MitmproxyHTTPFlow, rewrite_rules: List[RewriteRule]):
+  request = rewrite_request(flow, rewrite_rules)
+  response = rewrite_response(flow, rewrite_rules, request)
+  return request, response
+
+def rewrite_request(flow: MitmproxyHTTPFlow, rewrite_rules: List[RewriteRule]):
+  request = None
+
+  # Adapt flow.request
+  request = MitmproxyRequestFacade(flow.request)
+
+  _rewrite_rules = select_request_rewrite_rules(rewrite_rules) 
+  if len(_rewrite_rules):
+    request.with_parameter_rules(_rewrite_rules).with_url_rules(_rewrite_rules).rewrite()
+
+  return request
+
+def rewrite_response(flow: MitmproxyHTTPFlow, rewrite_rules: List[RewriteRule], request = None):
+  # Adapt flow.request
+  request = request or MitmproxyRequestFacade(flow.request)
+
+  # Adapt flow.response
+  response = MitmproxyResponseFacade(flow.response)
+
+  _rewrite_rules = select_response_rewrite_rules(rewrite_rules)
+  if len(_rewrite_rules):
+    response.with_parameter_rules(_rewrite_rules, request).rewrite()
+
+  return response

stoobly_agent/app/settings/constants/request_component.py

@@ -6,4 +6,7 @@ QUERY_PARAM = 'Query Param'
 RESPONSE_HEADER = 'Response Header'
 RESPONSE_PARAM = 'Response Param'
 
-RequestComponent = Literal[BODY_PARAM, HEADER, QUERY_PARAM, RESPONSE_HEADER, RESPONSE_PARAM]
+REQUEST_COMPONENTS = [BODY_PARAM, HEADER, QUERY_PARAM]
+RESPONSE_COMPONENTS = [RESPONSE_HEADER, RESPONSE_PARAM]
+
+RequestComponent = Literal[BODY_PARAM, HEADER, QUERY_PARAM, RESPONSE_HEADER, RESPONSE_PARAM]