stoobly-agent 1.8.4__py3-none-any.whl → 1.9.0__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '1.8.4'
+VERSION = '1.9.0'

stoobly_agent/app/api/configs_controller.py

@@ -4,7 +4,7 @@ from mergedeep import merge
 
 from stoobly_agent.app.api.simple_http_request_handler import SimpleHTTPRequestHandler
 from stoobly_agent.app.cli.helpers.handle_config_update_service import (
-    context as handle_context, handle_intercept_active_update, handle_policy_update, handle_project_update, handle_scenario_update
+    context as handle_context, handle_intercept_active_update, handle_order_update, handle_project_update, handle_scenario_update
 ) 
 from stoobly_agent.app.models.scenario_model import ScenarioModel
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
@@ -41,7 +41,7 @@ class ConfigsController:
             )
         elif active_mode == mode.RECORD:
             context.render(
-                json = [record_policy.ALL, record_policy.FOUND, record_policy.NOT_FOUND, record_policy.OVERWRITE],
+                json = [record_policy.ALL, record_policy.API, record_policy.FOUND, record_policy.NOT_FOUND],
                 status = 200
             )
         elif active_mode == mode.REPLAY:
@@ -112,7 +112,7 @@ class ConfigsController:
         _handle_context = handle_context()
 
         handle_intercept_active_update(settings, _handle_context)
-        handle_policy_update(settings, _handle_context)
+        handle_order_update(settings, _handle_context)
         handle_project_update(settings, _handle_context)
         handle_scenario_update(settings, _handle_context)
 

stoobly_agent/app/api/headers_controller.py

@@ -86,7 +86,7 @@ class HeadersController:
 
         context.render(
             plain = '',
-            status = 200
+            status = 204
         )
 
     def __header_model(self, context: SimpleHTTPRequestHandler):

stoobly_agent/app/api/query_params_controller.py

@@ -103,13 +103,13 @@ class QueryParamsController:
 
         if context.filter_response(query_param, status):
             return
-        
+
         context.render(
-            plain = query_param,
-            status = status
+            plain = '',
+            status = 204
         )
 
     def __query_param_model(self, context: SimpleHTTPRequestHandler):
         access_token = context.headers.get('access-token')
         query_param_model = QueryParamModel(Settings.instance(), access_token=access_token)
-        return query_param_model
+        return query_param_model

stoobly_agent/app/cli/helpers/handle_config_update_service.py

@@ -6,7 +6,7 @@ from stoobly_agent.app.models.scenario_model import ScenarioModel
 from stoobly_agent.app.settings.constants import intercept_mode
 from stoobly_agent.app.settings.constants.intercept_mode import Mode
 from stoobly_agent.app.settings import ProxySettings, Settings
-from stoobly_agent.config.constants import record_policy
+from stoobly_agent.config.constants import record_order
 from stoobly_agent.lib.api.keys.project_key import ProjectKey
 from stoobly_agent.lib.api.keys.scenario_key import ScenarioKey
 
@@ -28,15 +28,15 @@ def handle_intercept_active_update(new_settings: Settings, context: Context = No
 
   if not was_active and is_active:
     if _mode == intercept_mode.RECORD:
-      new_policy = data_rule.record_policy
+      new_order = data_rule.record_order
       scenario_key = data_rule.scenario_key
       _scenario_key = __parse_scenario_key(scenario_key)
 
       if _scenario_key:
         scenario_model = ScenarioModel(new_settings)
 
-        if new_policy == record_policy.OVERWRITE:
-          # If policy is overwrite when recording, whenever intercept is enabled,
+        if new_order == record_order.OVERWRITE:
+          # If order is overwrite when recording, whenever intercept is enabled,
           # set active scenario to be overwritable
           scenario_model.update(_scenario_key.id, **{ 'overwritable': True })[1]
         else:
@@ -44,16 +44,16 @@ def handle_intercept_active_update(new_settings: Settings, context: Context = No
   elif was_active and not is_active:
     if _mode == intercept_mode.RECORD:
       old_proxy_settings = __current_proxy_settings(context)
-      old_policy = __data_rule(old_proxy_settings).record_policy
+      old_order = __data_rule(old_proxy_settings).record_order
 
-      if old_policy == record_policy.OVERWRITE:
+      if old_order == record_order.OVERWRITE:
         scenario_key = data_rule.scenario_key
         _scenario_key = __parse_scenario_key(scenario_key)
 
         if _scenario_key:
           scenario_model = ScenarioModel(new_settings)
 
-          # If policy is overwrite when recording, whenever intercept is disabled,
+          # If order is overwrite when recording, whenever intercept is disabled,
           # set active scenario to not be overwritable
           scenario_model.update(_scenario_key.id, **{ 'overwritable': False })[1]
     elif _mode == intercept_mode.MOCK:
@@ -73,7 +73,7 @@ def handle_scenario_update(new_settings: Settings, context = None):
   if old_scenario_key != new_scenario_key:
     data_rule = __data_rule(new_settings.proxy)
 
-    if data_rule.record_policy == record_policy.OVERWRITE:
+    if data_rule.record_order == record_order.OVERWRITE:
       scenario_model = ScenarioModel(new_settings)
 
       _old_scenario_key = __parse_scenario_key(old_scenario_key)
@@ -108,7 +108,7 @@ def handle_project_update(new_settings: Settings, context: Context = None):
     if _project_key.id != _new_scenario_key.project_id:
       data_rule.scenario_key = None
 
-def handle_policy_update(new_settings: Settings, context: Context = None):
+def handle_order_update(new_settings: Settings, context: Context = None):
   data_rule = __data_rule(new_settings.proxy)
   _mode = context['mode'] if context and context.get('mode') else new_settings.proxy.intercept.mode
 
@@ -116,10 +116,10 @@ def handle_policy_update(new_settings: Settings, context: Context = None):
   old_data_rule = __data_rule(old_proxy_settings)
 
   if _mode == intercept_mode.RECORD:
-    new_policy = data_rule.record_policy
-    old_policy = old_data_rule.record_policy
+    new_order = data_rule.record_order
+    old_order = old_data_rule.record_order
 
-    if new_policy != old_policy and old_policy == record_policy.OVERWRITE:
+    if new_order != old_order and old_order == record_order.OVERWRITE:
       scenario_key = data_rule.scenario_key
       _scenario_key = __parse_scenario_key(scenario_key)
 

stoobly_agent/app/cli/intercept_cli.py

@@ -3,10 +3,10 @@ import pdb
 import sys
 
 from stoobly_agent.app.settings import Settings
-from stoobly_agent.config.constants import mode, mock_policy, record_policy, replay_policy
+from stoobly_agent.config.constants import mode, mock_policy, record_order, record_policy, replay_policy
 from stoobly_agent.lib.api.keys.project_key import ProjectKey
 
-from .helpers.handle_config_update_service import handle_intercept_active_update, handle_policy_update
+from .helpers.handle_config_update_service import handle_intercept_active_update, handle_order_update
 
 settings = Settings.instance()
 
@@ -17,16 +17,25 @@ if settings.cli.features.remote:
 
 active_mode = settings.proxy.intercept.mode
 
+def __get_order_options(active_mode):
+    if active_mode == mode.RECORD:
+        return [record_order.APPEND, record_order.OVERWRITE]
+    else:
+        return []
+
 def __get_policy_options(active_mode):
     if active_mode == mode.MOCK:
         return [mock_policy.ALL, mock_policy.FOUND]
     elif active_mode == mode.RECORD:
-        return [record_policy.ALL, record_policy.FOUND, record_policy.NOT_FOUND,record_policy.OVERWRITE]
+        return [record_policy.ALL, record_policy.API, record_policy.FOUND, record_policy.NOT_FOUND]
     elif active_mode == mode.REPLAY:
         return [replay_policy.ALL]
     elif active_mode == mode.TEST:
         return [mock_policy.FOUND]
+    else:
+        return []
 
+order_options = __get_order_options(active_mode)
 policy_options = __get_policy_options(active_mode)
 
 @click.group(
@@ -69,11 +78,12 @@ def disable(**kwargs):
     help="Configure intercept"
 )
 @click.option('--mode', type=click.Choice(mode_options))
+@click.option('--order', type=click.Choice(order_options))
 @click.option('--policy', type=click.Choice(policy_options))
 def configure(**kwargs):
-    settings = Settings.instance()
+    settings: Settings = Settings.instance()
 
-    if not kwargs['mode'] and not kwargs['policy']:
+    if not kwargs['mode'] and not kwargs['order'] and not kwargs['policy']:
         print("Error: Missing an option")
         sys.exit(1)
 
@@ -89,6 +99,21 @@ def configure(**kwargs):
 
     _mode = kwargs['mode'] or settings.proxy.intercept.mode 
 
+    if kwargs['order']:
+        active_mode = settings.proxy.intercept.mode
+
+        if active_mode == mode.RECORD:
+            project_key = ProjectKey(settings.proxy.intercept.project_key)
+            data_rule = settings.proxy.data.data_rules(project_key.id)
+            data_rule.record_order = kwargs['order']
+        else:
+            print("Error: set --mode to a intercept mode that supports the order option", file=sys.stderr)
+            sys.exit(1)
+
+        handle_order_update(settings)
+
+        print(f"Updating {_mode} order to {kwargs['order']}")
+
     if kwargs['policy']:
         active_mode = settings.proxy.intercept.mode
         valid_policies = __get_policy_options(active_mode)
@@ -109,8 +134,6 @@ def configure(**kwargs):
         elif active_mode == mode.TEST:
             data_rule.test_policy = kwargs['policy']
 
-        handle_policy_update(settings)
-
         print(f"Updating {_mode} policy to {kwargs['policy']}")
 
     settings.commit()

stoobly_agent/app/cli/scaffold/templates/app/.Dockerfile.context

@@ -1,4 +1,4 @@
-FROM stoobly/agent:1.8
+FROM stoobly/agent:1.9
 
 ARG USER_ID
 

stoobly_agent/app/cli/scaffold/templates/app/.Makefile

@@ -143,6 +143,12 @@ scenario/list:
 	@export EXEC_COMMAND=.list && \
 	export EXEC_OPTIONS="$(options)" && \
 	$(stoobly_exec)
+scenario/overwrite:
+# Overwrite a scenario
+	@export EXEC_COMMAND=.overwrite && \
+	export EXEC_OPTIONS="$(options)" && \
+	export EXEC_ARGS="$(key)" && \
+	$(stoobly_exec)
 scenario/reset:
 # Resets a scenario to its last snapshot
 	@export EXEC_COMMAND=.reset && \:

stoobly_agent/app/cli/scaffold/templates/build/workflows/exec/.overwrite

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+scenario_key=$1
+
+if [ ! "$scenario_key" ]; then 
+    echo "Missing argument 'scenario_key'"
+    stoobly-agent scenario list
+    exit
+fi
+
+stoobly-agent config scenario set "$scenario_key"
+stoobly-agent intercept configure --mode record --order overwrite
+stoobly-agent intercept disable

stoobly_agent/app/cli/scaffold/templates/workflow/record/bin/configure

@@ -22,6 +22,14 @@ stoobly-agent config firewall set \
 
 # Rewrite
 echo "Configuring rewrite rules..."
+stoobly-agent config rewrite set \
+  --method GET --method POST --method OPTIONS --method PUT --method DELETE \
+  --mode record \
+  --name authorization \
+  --pattern "$origin/?.*?" \
+  --type Header \
+  --value '' \
+
 stoobly-agent config rewrite set \
   --method GET --method POST --method OPTIONS --method PUT --method DELETE \
   --mode record \
@@ -29,3 +37,11 @@ stoobly-agent config rewrite set \
   --pattern "$origin/?.*?" \
   --type Header \
   --value '' \
+
+stoobly-agent config rewrite set \
+  --method GET --method POST --method OPTIONS --method PUT --method DELETE \
+  --mode record \
+  --name set-cookie \
+  --pattern "$origin/?.*?" \
+  --type 'Response Header' \
+  --value '' \

stoobly_agent/app/cli/snapshot_cli.py

@@ -20,6 +20,7 @@ from stoobly_agent.lib.api.keys import RequestKey, ScenarioKey
 
 from .helpers.print_service import FORMATS, print_snapshots, select_print_options
 from .helpers.verify_raw_request_service import verify_raw_request
+from .types.snapshot_migration import SnapshotMigration
 
 @click.group(
     epilog="Run 'stoobly-agent project COMMAND --help' for more information on a command.",
@@ -91,6 +92,62 @@ def _list(**kwargs):
     if len(formatted_events):
       print_snapshots(formatted_events, **print_options)
 
+@snapshot.command(
+  help="Migrate snapshots."
+)
+@click.option('--scenario-key', help='Apply migration to specific scenario.')
+@click.argument('lifecycle_hooks_path')
+def migrate(**kwargs):
+  from runpy import run_path
+  from stoobly_agent.config.constants.lifecycle_hooks import BEFORE_MIGRATE
+
+  scenario_key = None
+  if kwargs['scenario_key']:
+    scenario_key = ScenarioKey(kwargs['scenario_key'])
+
+  try:
+    lifecycle_hooks = run_path(kwargs['lifecycle_hooks_path'])
+  except Exception as e:
+    lifecycle_hooks = {}
+
+  before_migrate_hook = None
+  if BEFORE_MIGRATE not in lifecycle_hooks:
+    sys.exit(1)
+  else:
+    before_migrate_hook = lifecycle_hooks[BEFORE_MIGRATE]
+
+  log = Log()
+
+  request_snapshots = []
+  for event in log.resource_events:
+    if event.is_scenario():
+      # If scenario_key is set, only consider that scenario
+      if scenario_key and event.resource_uuid != scenario_key.id:
+        continue
+
+      scenario_snapshot: ScenarioSnapshot = event.snapshot()
+      _request_snapshots = scenario_snapshot.request_snapshots
+
+      for request_snapshot in _request_snapshots:
+        # Scenario requests will have the same log event
+        request_snapshots.append((request_snapshot, event))
+    elif event.is_request():
+      # If scenario_key is set, only consider that scenario
+      if scenario_key:
+        continue
+
+      request_snapshot: RequestSnapshot = event.snapshot()
+      request_snapshots.append((request_snapshot, event))
+
+  snapshot_migrations = {}
+  for request_snapshot, event in request_snapshots:
+    if request_snapshot.uuid not in snapshot_migrations:
+      snapshot_migration = SnapshotMigration(request_snapshot, event)
+      snapshot_migrations[request_snapshot.uuid] = snapshot_migration
+      
+      if before_migrate_hook(snapshot_migration):
+        break
+
 @snapshot.command(
   help="Prune deleted snapshots."
 )

stoobly_agent/app/cli/types/snapshot_migration.py

@@ -0,0 +1,61 @@
+from mitmproxy.http import Request, Response
+
+from stoobly_agent.app.models.factories.resource.local_db.helpers.log import Log
+from stoobly_agent.app.models.factories.resource.local_db.helpers.log_event import LogEvent
+from stoobly_agent.app.models.factories.resource.local_db.helpers.request_snapshot import RequestSnapshot
+from stoobly_agent.app.proxy.record.join_request_service import join_request_from_request_response
+
+class SnapshotMigration():
+  _request: Request
+  _response: Response
+  _snapshot: RequestSnapshot
+
+  def __init__(self, snapshot: RequestSnapshot, log_event: LogEvent, log: Log = None):
+    self._event = log_event
+    self._log = log or Log()
+    self._request = snapshot.mitmproxy_request
+    self._response = snapshot.mitmproxy_response
+    self._snapshot = snapshot
+
+  @property
+  def request(self):
+    return self._request
+
+  @request.setter
+  def request(self, v: Request):
+    if not isinstance(v, Request):
+      raise TypeError('Invalid type.')
+    self._request = v
+
+  @property
+  def response(self):
+    return self._response
+
+  @response.setter
+  def response(self, v: Response):
+    if not isinstance(v, Response):
+      raise TypeError('Invalid type.')
+    self._response = v
+
+  @property
+  def snapshot(self):
+    return self._snapshot
+
+  @property
+  def uuid(self):
+    return self.snapshot.uuid
+
+  def delete(self, log: Log = None):
+    log = log or self._log
+    new_event = self._event.duplicate_as_delete()
+    log.append(str(new_event))
+
+  def save(self, log: Log = None):
+    log = log or self._log
+    request_uuid = self.snapshot.uuid
+    joined_request = join_request_from_request_response(self.request, self.response, id=request_uuid)
+    raw_request = joined_request.build()
+    self.snapshot.write_raw(raw_request)
+    new_event = self._event.duplicate()
+    log.append(str(new_event))
+    return new_event

stoobly_agent/app/models/adapters/joined_request_adapter.py

@@ -46,7 +46,7 @@ class JoinedRequestAdapter():
   def build_request_string(self):
     request_string = RequestString(None)
 
-    delimitter = RequestStringCLRF.encode()
+    delimitter = RequestStringCLRF
     request_string_toks = self.__split_joined_request_string[0].split(delimitter)
     request_string.set(self.raw_request_string or delimitter.join(request_string_toks[1:]))
     request_string.control = request_string_toks[0]

stoobly_agent/app/models/adapters/orm/request/mitmproxy_adapter.py

@@ -15,4 +15,4 @@ class MitmproxyRequestAdapter():
     protocol = raw_http_request_adapter.protocol
     http_version = protocol.split('/')[1]
 
-    return PythonRequestMitmproxyRequestAdapter(http_version, python_request).adapt()
+    return PythonRequestMitmproxyRequestAdapter(python_request, http_version).adapt()

stoobly_agent/app/models/adapters/python/request/__init__.py

@@ -13,10 +13,10 @@ class PythonRequestAdapterFactory():
     self.__request = request
 
   def mitmproxy_request(self, http_version: str = 'HTTP/1.1'):
-    return MitmproxyRequestAdapter(http_version, self.__request).adapt()
+    return MitmproxyRequestAdapter(self.__request, http_version).adapt()
 
   def raw_request(self, http_version: str = 'HTTP/1.1'):
-    return RawRequestAdapter(http_version, self.__request).adapt()
+    return RawRequestAdapter(self.__request, http_version).adapt()
 
   def stoobly_request(self):
     return StooblyRequestAdapter(self.__request).adapt()

stoobly_agent/app/models/adapters/python/request/mitmproxy_adapter.py

@@ -8,7 +8,7 @@ from stoobly_agent.lib.utils.decode import decode
 
 class MitmproxyRequestAdapter():
 
-  def __init__(self, http_version: str, request: requests.Request):
+  def __init__(self, request: requests.Request, http_version: str = 'HTTP/1.1'):
     self.__http_version = http_version
     self.__request = request
 

stoobly_agent/app/models/adapters/python/request/raw_adapter.py

@@ -9,12 +9,12 @@ from .mitmproxy_adapter import MitmproxyRequestAdapter
 
 class RawRequestAdapter():
 
-  def __init__(self, http_version: str, request: requests.Request):
+  def __init__(self, request: requests.Request, http_version: str):
     self.__http_version = http_version
     self.__request = request
 
   def adapt(self):
-    mitmproxy_request = MitmproxyRequestAdapter(self.__http_version, self.__request).adapt()
+    mitmproxy_request = MitmproxyRequestAdapter(self.__request, self.__http_version).adapt()
     adapted_request = MitmproxyRequestFacade(mitmproxy_request)
     proxy_request = ProxyRequest(adapted_request)
     request_string = RequestString(proxy_request) 

stoobly_agent/app/models/factories/resource/local_db/helpers/log.py

@@ -82,6 +82,13 @@ class Log():
 
     return self.remove_processed_events(events, version_uuids)
 
+  @property
+  def resource_events(self) -> List[LogEvent]:
+    events = self.target_events
+    events = self.remove_dangling_events(events, events)
+
+    return list(filter(lambda e: e.action != DELETE_ACTION, events))
+
   @property
   def version(self):
     version_file_path = DataDir.instance().snapshosts_version_path

stoobly_agent/app/models/factories/resource/local_db/helpers/log_event.py

@@ -84,6 +84,16 @@ class LogEvent():
     toks[4] = str(int(time.time() * 1000))
     return LogEvent(COLUMN_DELIMITTER.join(toks))
 
+  def duplicate_as_delete(self):
+    event = self.duplicate()
+    event.action = DELETE_ACTION
+    return event
+
+  def duplicate_as_put(self):
+    event = self.duplicate()
+    event.action = PUT_ACTION
+    return event
+
   def is_request(self):
     return self.resource == REQUEST_RESOURCE
 

stoobly_agent/app/models/factories/resource/local_db/helpers/request_snapshot.py

@@ -34,6 +34,26 @@ class RequestSnapshot(Snapshot):
     with open(request_file_path, 'rb') as fp:
       return fp.read()
 
+  @property
+  def mitmproxy_request(self):
+    from stoobly_agent.app.models.adapters.python.request.mitmproxy_adapter import MitmproxyRequestAdapter
+    return MitmproxyRequestAdapter(self.python_request).adapt()
+
+  @property
+  def mitmproxy_response(self):
+    from stoobly_agent.app.models.adapters.python.response.mitmproxy_adapter import MitmproxyResponseAdapter
+    return MitmproxyResponseAdapter(self.python_response).adapt()
+
+  @property
+  def python_request(self):
+    from stoobly_agent.app.models.adapters.raw_joined.request.python_adapter import PythonRequestAdapter
+    return PythonRequestAdapter(self.request).adapt()
+
+  @property
+  def python_response(self):
+    from stoobly_agent.app.models.adapters.raw_joined.response.python_adapter import PythonResponseAdapter
+    return PythonResponseAdapter(self.request).adapt()
+
   @property
   def path(self):
     dir_path = os.path.join(self.__requests_dir_path, self.uuid[0:2])

stoobly_agent/app/models/factories/resource/local_db/helpers/scenario_snapshot.py

@@ -3,7 +3,7 @@ import os
 import pdb
 import shutil
 
-from typing import Callable
+from typing import Callable, List
 
 from stoobly_agent.lib.orm.scenario import Scenario
 
@@ -46,6 +46,13 @@ class ScenarioSnapshot(Snapshot):
   def metadata_path(self):
     return os.path.join(self.__scenarios_dir_path, self.uuid)
 
+  @property
+  def request_snapshots(self) -> List[RequestSnapshot]:
+    snapshots = []
+    handler = lambda request_snapshot: snapshots.append(request_snapshot)
+    self.iter_request_snapshots(handler)
+    return snapshots
+
   @property
   def requests(self):
     requests_file_path = self.requests_path

stoobly_agent/app/models/factories/resource/local_db/helpers/snapshot.py

@@ -7,7 +7,7 @@ class Snapshot():
 
   def __init__(self, uuid: str):
     self.__uuid = uuid
-    self.__data_dir = DataDir.instance()
+    self.__data_dir: DataDir = DataDir.instance()
 
   @property
   def uuid(self):

stoobly_agent/app/models/factories/resource/local_db/query_param_adapter.py

@@ -122,10 +122,10 @@ class LocalDBQueryParamAdapter(LocalDBAdapter):
     parsed_url = parsed_url._replace(query=urlencode(_query_params, True))
     request = LocalDBRequestAdapter(self.__request_orm).update(request_id, url=parsed_url.geturl())
 
-    return {
+    return self.success({
       'name': name,
       'value': value,
-    }
+    }) 
 
   def __decode_id(self, id: str):
     id = base64.b64decode(id)

stoobly_agent/app/models/helpers/apply.py

@@ -3,7 +3,7 @@ import pdb
 from stoobly_agent.app.models.factories.resource.local_db.helpers.log import Log
 from stoobly_agent.app.models.factories.resource.local_db.helpers.request_snapshot import RequestSnapshot
 from stoobly_agent.app.models.factories.resource.local_db.helpers.scenario_snapshot import ScenarioSnapshot
-from stoobly_agent.app.proxy.record import REQUEST_STRING_CLRF, RequestStringControl
+from stoobly_agent.app.proxy.record import REQUEST_STRING_CLRF
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import bcolors
 
@@ -218,15 +218,16 @@ class Apply():
 
     snapshot_requests = {}
 
-    raw_requests = snapshot.requests
-    for raw_request in raw_requests:
-      toks = raw_request.split(REQUEST_STRING_CLRF.encode(), 1)
+    request_snapshots = snapshot.request_snapshots
+    for request_snapshot in request_snapshots:
+      raw_request = request_snapshot.request
+      
+      toks = raw_request.split(REQUEST_STRING_CLRF, 1)
 
       if len(toks) != 2:
         return f"{snapshot.requests_path} contains an invalid request", 400
 
-      control = RequestStringControl(toks[0])
-      uuid = control.id
+      uuid = request_snapshot.uuid
       res, status = self.__put_request(uuid, raw_request, scenario_id=scenario['id'])
 
       if status != 200:

stoobly_agent/app/models/helpers/create_request_params_service.py

@@ -4,7 +4,7 @@ import requests
 from stoobly_agent.app.models.adapters import JoinedRequestAdapter, RawHttpRequestAdapter, RawHttpResponseAdapter
 from stoobly_agent.app.models.adapters.python import PythonRequestAdapterFactory, PythonResponseAdapterFactory
 
-from stoobly_agent.app.proxy.record.join_request_service import InterceptSettings, join_request, MitmproxyRequestFacade, MitmproxyResponseFacade
+from stoobly_agent.app.proxy.record.join_request_service import InterceptSettings, join_request_from_request_response 
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
@@ -40,7 +40,9 @@ def build_params_from_python(request: requests.Request, response: requests.Respo
   mitmproxy_response = PythonResponseAdapterFactory(response).mitmproxy_response()
 
   intercept_settings = InterceptSettings(Settings.instance(), mitmproxy_request)
-  joined_request = join_request(MitmproxyRequestFacade(mitmproxy_request), MitmproxyResponseFacade(mitmproxy_response), intercept_settings)
+  joined_request = join_request_from_request_response(
+    mitmproxy_request, mitmproxy_response, intercept_settings=intercept_settings
+  )
 
   mitmproxy_flow_mock = MitmproxyFlowMock(mitmproxy_request, mitmproxy_response)