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

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,36 +14,55 @@ 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),
+        error=lambda mock_context: __handle_mock_error(TestContext(context, mock_context)),
         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
         success=lambda mock_context: __handle_mock_success(TestContext(context, mock_context))
@@ -51,10 +72,28 @@ def __decorate_test_id(flow: MitmproxyHTTPFlow, test_response: TestShowResponse)
     if test_response.get('id'):
         flow.response.headers[custom_headers.TEST_ID] = str(test_response['id'])
 
+def __handle_mock_error(test_context: TestContext):
+    Logger.instance().warn(f"{LOG_ID}:TestStatus: Mock not enabled")
+
+    intercept_settings = test_context.intercept_settings
+
+    if intercept_settings.request_origin == request_origin.CLI:
+        return build_response(False, 'No test found')
+
+def __handle_mock_failure(test_context: TestContext) -> None:
+    Logger.instance().warn(f"{LOG_ID}:TestStatus: No test found")
+
+    intercept_settings = test_context.intercept_settings
+
+    if intercept_settings.request_origin == request_origin.CLI:
+        return build_response(False, 'No test found')
+
 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 +123,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
@@ -121,14 +155,6 @@ def __handle_mock_success(test_context: TestContext) -> None:
     
     return flow.response
 
-def __handle_mock_failure(test_context: TestContext) -> None:
-    Logger.instance().warn(f"{LOG_ID}:TestStatus: No test found")
-
-    intercept_settings = test_context.intercept_settings
-
-    if intercept_settings.request_origin == request_origin.CLI:
-        return build_response(False, 'No test found')
-
 def __override_response(flow: MitmproxyHTTPFlow, content: bytes):
     headers = { 'Content-Type': 'text/plain' }
     headers[custom_headers.CONTENT_TYPE] = custom_headers.CONTENT_TYPE_TEST_RESULTS
@@ -136,6 +162,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/custom_not_found_response_builder.py

@@ -12,4 +12,9 @@ class CustomNotFoundResponseBuilder():
   def build(self):
     self.__response.status_code = custom_response_codes.NOT_FOUND
     self.__response.raw = BytesIO('Request not found'.encode()) 
+    self.__response.headers = {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, OPTIONS, POST, PATCH, PUT, DELETE',
+      'Content-Type': 'text/plain',
+    }
     return self.__response

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,89 @@ 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 +111,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)]