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

stoobly_agent/app/proxy/handle_mock_service.py

@@ -19,6 +19,7 @@ from .mock.eval_request_service import inject_eval_request
 from .utils.allowed_request_service import get_active_mode_policy
 from .utils.request_handler import reverse_proxy
 from .utils.response_handler import bad_request, pass_on
+from .utils.rewrite import rewrite_request, rewrite_response
 
 LOG_ID = 'Mock'
 
@@ -26,77 +27,77 @@ class MockOptions(TypedDict):
     failure: Callable
     ignored_components: list 
     infer: bool
+    no_rewrite: bool
     success: Callable
 
+def handle_request_mock_generic_without_rewrite(context: MockContext, **options: MockOptions):
+    options['no_rewrite'] = True
+    handle_request_mock_generic(context, **options)
+
 ###
 #
+# 1. Rewrites mock request by default
+# 2. BEFORE_MOCK gets triggered
+# 3. AFTER_MOCK gets triggered
+#
 # @param request [mitmproxy.http.Request]
 # @param settings [Dict]
 #
 def handle_request_mock_generic(context: MockContext, **options: MockOptions):
-    __mock_hook(lifecycle_hooks.BEFORE_MOCK, context)
-
     intercept_settings = context.intercept_settings
     request: MitmproxyRequest = context.flow.request
-    request_model = RequestModel(intercept_settings.settings)
-
-    policy = get_active_mode_policy(request, intercept_settings)
-
-    rewrite_rules = intercept_settings.mock_rewrite_rules
-    if len(rewrite_rules) > 0:
-        # Rewrite request with paramter rules for mock
-        request: MitmproxyRequest = context.flow.request
-        request_facade = MitmproxyRequestFacade(request)
-        request_facade.with_parameter_rules(rewrite_rules).with_url_rules(rewrite_rules).rewrite()
-
-    # If ignore rules are set, then ignore specified request parameters
-    ignore_rules = intercept_settings.ignore_rules
-    if len(ignore_rules) > 0:
-        request_facade = MitmproxyRequestFacade(request)
-        _ignore_rules = request_facade.select_parameter_rules(ignore_rules)
-        ignored_components = rewrite_rules_to_ignored_components(_ignore_rules)
-        options['ignored_components'] += ignored_components  if 'ignored_components' in options else ignored_components
-
     handle_success = options['success'] if 'success' in options and callable(options['success']) else None
     handle_failure = options['failure'] if 'failure' in options and callable(options['failure']) else None
-    
-    eval_request = inject_eval_request(request_model, intercept_settings)
- 
+
+    policy = get_active_mode_policy(request, intercept_settings)
     if policy == mock_policy.NONE:
         if handle_failure:
             res = handle_failure(context)
-    elif policy == mock_policy.ALL:
-        res = eval_request_with_retry(context, eval_request, **options) 
-
-        context.with_response(res)
-
-        if handle_success:
-            # TODO: rewrite response, see #332
-            res = handle_success(context) or res
-    elif policy == mock_policy.FOUND:
-        res = eval_request_with_retry(context, eval_request, **options) 
-
-        context.with_response(res)
-
-        if res.status_code in [custom_response_codes.NOT_FOUND, custom_response_codes.IGNORE_COMPONENTS]:
-            if handle_failure:
-                try:
-                    res = handle_failure(context)
-                except RuntimeError:
-                    # Do nothing, return custom error response
-                    pass
-        else:
-            if handle_success:
-                # TODO: rewrite response, see #332
-                res = handle_success(context) or res
     else:
-        return bad_request(
-            context.flow,
-            "Valid env MOCK_POLICY: %s, Got: %s" %
-            ([mock_policy.ALL, mock_policy.FOUND, mock_policy.NONE], policy)
-        )
+        if not options.get('no_rewrite'):
+            __rewrite_request(context)
+
+        __mock_hook(lifecycle_hooks.BEFORE_MOCK, context)
+
+        # If ignore rules are set, then ignore specified request parameters
+        ignore_rules = intercept_settings.ignore_rules
+        if len(ignore_rules) > 0:
+            request_facade = MitmproxyRequestFacade(request)
+            _ignore_rules = request_facade.select_parameter_rules(ignore_rules)
+            ignored_components = rewrite_rules_to_ignored_components(_ignore_rules)
+            options['ignored_components'] += ignored_components if 'ignored_components' in options else ignored_components 
+ 
+        request_model = RequestModel(intercept_settings.settings)
+        eval_request = inject_eval_request(request_model, intercept_settings)
+
+        if policy == mock_policy.ALL:
+            res = eval_request_with_retry(context, eval_request, **options) 
+
+            context.with_response(res)
 
-    __mock_hook(lifecycle_hooks.AFTER_MOCK, context)
+            if handle_success:
+                res = handle_success(context) or res
+        elif policy == mock_policy.FOUND:
+            res = eval_request_with_retry(context, eval_request, **options) 
+
+            context.with_response(res)
+
+            if res.status_code in [custom_response_codes.NOT_FOUND, custom_response_codes.IGNORE_COMPONENTS]:
+                if handle_failure:
+                    try:
+                        res = handle_failure(context)
+                    except RuntimeError:
+                        # Do nothing, return custom error response
+                        pass
+            else:
+                if handle_success:
+                    res = handle_success(context) or res
+        else:
+            return bad_request(
+                context.flow,
+                "Valid env MOCK_POLICY: %s, Got: %s" %
+                ([mock_policy.ALL, mock_policy.FOUND, mock_policy.NONE], policy)
+            )
 
     return pass_on(context.flow, res)
 
@@ -130,6 +131,11 @@ def handle_request_mock(context: MockContext):
         success=lambda context: __handle_mock_success(context)
     )
 
+###
+#
+# 1. Rewrites mock response (if mock found)
+# 2. AFTER_MOCK gets triggered (if mock found)
+#
 def handle_response_mock(context: MockContext):
     response = context.flow.response
     request_key = response.headers.get(custom_headers.MOCK_REQUEST_KEY)
@@ -138,6 +144,9 @@ def handle_response_mock(context: MockContext):
         request = context.flow.request
         Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Mocked{bcolors.ENDC} {request.url} -> {request_key}")
 
+        __rewrite_response(context)
+        __mock_hook(lifecycle_hooks.AFTER_MOCK, context)
+
 def __handle_mock_success(context: MockContext) -> None:
     if os.environ.get(env_vars.AGENT_SIMULATE_LATENCY):
         response = context.response
@@ -160,6 +169,24 @@ def __handle_mock_failure(context: MockContext) -> None:
 
     reverse_proxy(req, upstream_url, {})
 
+def __rewrite_request(context: MockContext):
+    # Rewrite request with paramter rules for mock
+
+    intercept_settings = context.intercept_settings
+    rewrite_rules = intercept_settings.mock_rewrite_rules
+
+    if len(rewrite_rules) > 0:
+        rewrite_request(context.flow, rewrite_rules) 
+
+def __rewrite_response(context: MockContext):
+    # Rewrite request with paramter rules for mock
+
+    intercept_settings = context.intercept_settings
+    rewrite_rules = intercept_settings.mock_rewrite_rules
+
+    if len(rewrite_rules) > 0:
+        rewrite_response(context.flow, rewrite_rules) 
+
 ###
 #
 # Try to simulate expected response latency

stoobly_agent/app/proxy/handle_record_service.py

@@ -2,6 +2,7 @@ import os
 import pdb
 import threading
 
+from copy import deepcopy
 from mitmproxy.http import Request as MitmproxyRequest
 
 from stoobly_agent.app.settings.constants.mode import TEST
@@ -18,15 +19,20 @@ from .record.overwrite_scenario_service import overwrite_scenario
 from .record.upload_request_service import inject_upload_request
 from .utils.allowed_request_service import get_active_mode_policy
 from .utils.response_handler import bad_request, disable_transfer_encoding 
+from .utils.rewrite import rewrite_request_response
 
 LOG_ID = 'Record'
 
+###
+#
+# 1. Rewrites a copy of request and response
+# 2. BEFORE_RECORD gets triggered
+# 3. AFTER_RECORD gets triggered
+#
 def handle_response_record(context: RecordContext):
     flow = context.flow
     disable_transfer_encoding(flow.response)
 
-    __record_hook(lifecycle_hooks.BEFORE_RECORD, context)
-
     intercept_settings = context.intercept_settings
     request: MitmproxyRequest = flow.request
     request_model = RequestModel(intercept_settings.settings)
@@ -60,11 +66,17 @@ def handle_response_record(context: RecordContext):
 
 def __record_handler(context: RecordContext, request_model: RequestModel):
     flow = context.flow
+    flow_copy = deepcopy(flow)
     intercept_settings = context.intercept_settings
 
-    inject_upload_request(request_model, intercept_settings)(flow)
+    context.flow = flow_copy # Deep copy flow to prevent response modifications from persisting
+    rewrite_request_response(flow_copy, intercept_settings.record_rewrite_rules) 
+    __record_hook(lifecycle_hooks.BEFORE_RECORD, context)
+
+    inject_upload_request(request_model, intercept_settings)(flow_copy)
 
     __record_hook(lifecycle_hooks.AFTER_RECORD, context)
+    context.flow = flow # Reset flow
 
 def __record_request(context: RecordContext, request_model: RequestModel):
     if os.environ.get(ENV) == TEST:

stoobly_agent/app/proxy/handle_replay_service.py

@@ -1,46 +1,72 @@
 import pdb
 
 from mitmproxy.http import Request as MitmproxyRequest
+from typing import TypedDict
 
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
-from stoobly_agent.app.proxy.mitmproxy.request_facade import MitmproxyRequestFacade
 from stoobly_agent.app.proxy.replay.context import ReplayContext
 from stoobly_agent.config.constants import lifecycle_hooks, replay_policy
 
 from .utils.allowed_request_service import get_active_mode_policy
+from .utils.rewrite import rewrite_request, rewrite_response
 
 LOG_ID = 'HandleReplay'
 
-def handle_request_replay(replay_context: ReplayContext):
-  __replay_hook(lifecycle_hooks.BEFORE_REPLAY, replay_context)
+class ReplayOptions(TypedDict):
+    no_rewrite: bool
 
-  request: MitmproxyRequest = replay_context.flow.request
-  intercept_settings: InterceptSettings = replay_context.intercept_settings
+###
+#
+# 1. Rewrites replay request by default
+# 2. BEFORE_REPLAY gets triggered
+#
+def handle_request_replay_without_rewrite(replay_context: ReplayContext):
+    options = { 'no_rewrite': True }
+    handle_request_replay(replay_context, **options)
 
-  policy = get_active_mode_policy(request, intercept_settings)
-  if policy != replay_policy.NONE:
-    __replay_request(replay_context)
+def handle_request_replay(replay_context: ReplayContext, **options: ReplayOptions):
+    request: MitmproxyRequest = replay_context.flow.request
+    intercept_settings: InterceptSettings = replay_context.intercept_settings
+
+    policy = get_active_mode_policy(request, intercept_settings)
+    if policy != replay_policy.NONE:
+        if not options.get('no_rewrite'):
+            __rewrite_request(replay_context)
 
+        __replay_hook(lifecycle_hooks.BEFORE_REPLAY, replay_context)
+
+###
+#
+# 1. Rewrites replay response
+# 2. AFTER_REPLAY gets triggered
+#
 def handle_response_replay(replay_context: ReplayContext):
+    __rewrite_response(replay_context)
     __replay_hook(lifecycle_hooks.AFTER_REPLAY, replay_context)
 
-    # TODO: rewrite response, see #332
+def __replay_hook(hook: str, replay_context: ReplayContext):
+    intercept_settings: InterceptSettings = replay_context.intercept_settings
+
+    lifecycle_hooks_module = intercept_settings.lifecycle_hooks
+    if hook in lifecycle_hooks_module:
+        lifecycle_hooks_module[hook](replay_context)
 
-def __replay_request(replay_context: ReplayContext):
+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.rewrite_rules
+    rewrite_rules = intercept_settings.replay_rewrite_rules
 
     if len(rewrite_rules) > 0:
-        request: MitmproxyRequest = replay_context.flow.request
-        request_facade = MitmproxyRequestFacade(request)
-        request_facade.with_parameter_rules(rewrite_rules).with_url_rules(rewrite_rules).rewrite()
+        rewrite_request(replay_context.flow, rewrite_rules)
 
-def __replay_hook(hook: str, replay_context: ReplayContext):
+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.replay_rewrite_rules
 
-    lifecycle_hooks_module = intercept_settings.lifecycle_hooks
-    if hook in lifecycle_hooks_module:
-        lifecycle_hooks_module[hook](replay_context)
+    if len(rewrite_rules) > 0:
+        rewrite_response(replay_context.flow, rewrite_rules)

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)