stoobly-agent 1.8.5__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.5'
+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/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/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/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
 
@@ -222,7 +222,7 @@ class Apply():
     for request_snapshot in request_snapshots:
       raw_request = request_snapshot.request
       
-      toks = raw_request.split(REQUEST_STRING_CLRF.encode(), 1)
+      toks = raw_request.split(REQUEST_STRING_CLRF, 1)
 
       if len(toks) != 2:
         return f"{snapshot.requests_path} contains an invalid request", 400

stoobly_agent/app/proxy/handle_mock_service.py

@@ -3,7 +3,7 @@ import pdb
 import requests
 import time
 
-from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow, Request as MitmproxyRequest
+from mitmproxy.http import Request as MitmproxyRequest
 from typing import Callable, TypedDict
 
 from stoobly_agent.app.models.request_model import RequestModel
@@ -64,7 +64,7 @@ def handle_request_mock_generic(context: MockContext, **options: MockOptions):
 
         return bad_request(
             context.flow,
-            "Valid env MOCK_POLICY: %s, Got: %s" %
+            "Valid mock policies: %s, Got: %s" %
             ([mock_policy.ALL, mock_policy.FOUND, mock_policy.NONE], policy)
         )
 
@@ -88,18 +88,20 @@ def handle_request_mock_generic(context: MockContext, **options: MockOptions):
         res = eval_request_with_retry(context, eval_request, **options) 
 
         context.with_response(res)
+        res = __after_mock_not_found(context)
     elif policy == mock_policy.FOUND:
         res = eval_request_with_retry(context, eval_request, **options) 
 
         context.with_response(res)
+        res = __after_mock_not_found(context)
 
-        if res.status_code in [custom_response_codes.NOT_FOUND, custom_response_codes.IGNORE_COMPONENTS]:
+        if res.status_code == custom_response_codes.NOT_FOUND:
             try:
                 return __handle_found_policy(context) # Continue proxying the request
             except RuntimeError:
                 # Do nothing, return custom error response
-                pass
-    
+                pass 
+
     if res.status_code == custom_response_codes.NOT_FOUND:
         if handle_failure:
             res = handle_failure(context) or res
@@ -241,4 +243,15 @@ def __mock_hook(hook: str, context: MockContext):
     lifecycle_hooks_module = intercept_settings.lifecycle_hooks
 
     if hook in lifecycle_hooks_module:
-        lifecycle_hooks_module[hook](context)
+        lifecycle_hooks_module[hook](context)
+
+def __after_mock_not_found(context: MockContext):
+    res = context.response
+
+    if res.status_code == custom_response_codes.NOT_FOUND:
+        __mock_hook(lifecycle_hooks.AFTER_MOCK_NOT_FOUND, context)
+
+        # context.response may have been modified by the hook
+        res = context.response
+
+    return res

stoobly_agent/app/proxy/handle_record_service.py

@@ -9,7 +9,7 @@ from stoobly_agent.app.settings.constants.mode import TEST
 from stoobly_agent.app.models.request_model import RequestModel
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 from stoobly_agent.config.constants.env_vars import ENV
-from stoobly_agent.config.constants import lifecycle_hooks, record_policy
+from stoobly_agent.config.constants import lifecycle_hooks, record_order, record_policy
 from stoobly_agent.lib.logger import Logger
 
 from .constants import custom_response_codes
@@ -17,6 +17,7 @@ from .mock.eval_request_service import inject_eval_request
 from .record.context import RecordContext
 from .record.overwrite_scenario_service import overwrite_scenario
 from .record.upload_request_service import inject_upload_request
+from .replay.body_parser_service import is_json, is_xml
 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
@@ -42,6 +43,13 @@ def handle_response_record(context: RecordContext):
 
     if active_record_policy == record_policy.ALL:
         __record_request(context, request_model)
+    elif active_record_policy == record_policy.API:
+        response = flow.response
+        content_type: str = response.headers.get('content-type')
+
+        if content_type:
+            if is_json(content_type) or is_xml(content_type) or content_type.startswith('text/plain'):
+                __record_request(context, request_model)
     elif active_record_policy == record_policy.FOUND:
         res = inject_eval_request(request_model, intercept_settings)(request, [])
 
@@ -52,16 +60,12 @@ def handle_response_record(context: RecordContext):
 
         if res.status_code == custom_response_codes.NOT_FOUND:
             __record_request(context, request_model)
-    elif active_record_policy == record_policy.OVERWRITE:
-        overwrite_scenario(intercept_settings.scenario_key)
-
-        __record_request(context, request_model)
     else:
         if active_record_policy != record_policy.NONE:
             return bad_request(
                 flow,
-                "Valid env RECORD_POLICY: %s, Got: %s" %
-                ([record_policy.ALL, record_policy.FOUND, record_policy.NOT_FOUND], active_record_policy)
+                "Valid record policies: %s, Got: %s" %
+                ([record_policy.ALL, record_policy.API, record_policy.FOUND, record_policy.NOT_FOUND], active_record_policy)
             )
 
 def __record_handler(context: RecordContext, request_model: RequestModel):
@@ -79,6 +83,11 @@ def __record_handler(context: RecordContext, request_model: RequestModel):
     context.flow = flow # Reset flow
 
 def __record_request(context: RecordContext, request_model: RequestModel):
+    intercept_settings = context.intercept_settings
+
+    if intercept_settings.order == record_order.OVERWRITE:
+        overwrite_scenario(intercept_settings.scenario_key)
+
     if os.environ.get(ENV) == TEST:
         __record_handler(context, request_model)
     else:

stoobly_agent/app/proxy/intercept_settings.py

@@ -166,6 +166,10 @@ class InterceptSettings:
     if self.__headers and custom_headers.REPORT_KEY in self.__headers:
       return self.__headers[custom_headers.REPORT_KEY]
 
+  @property
+  def order(self):
+    return self.__order(self.mode)
+
   @property
   def policy(self):
     return self.__policy(self.mode)
@@ -339,7 +343,11 @@ class InterceptSettings:
             self.__response_fixtures = yaml.safe_load(stream)
         except yaml.YAMLError as exc:
             Logger.instance().error(exc)
-        
+
+  def __order(self, mode):
+    if mode == intercept_mode.RECORD:
+      return self.__data_rules.record_order
+    
   def __policy(self, mode):
     if mode == intercept_mode.MOCK:
       if self.__headers and custom_headers.MOCK_POLICY in self.__headers:
@@ -352,6 +360,9 @@ class InterceptSettings:
 
       return self.__data_rules.record_policy
     elif mode == intercept_mode.TEST:
+      if self.__headers and custom_headers.TEST_POLICY in self.__headers:
+        return self.__headers[custom_headers.TEST_POLICY]
+
       return self.__data_rules.test_policy
     elif mode == intercept_mode.REPLAY:
       return self.__data_rules.replay_policy

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -72,7 +72,7 @@ class MitmproxyRequestFacade(Request):
     def body(self):
         content = self.request.raw_content or b''
 
-        return decode(content)
+        return content
 
     @property
     def parsed_body(self):

stoobly_agent/app/proxy/record/request_string.py

@@ -9,7 +9,7 @@ from stoobly_agent.lib.utils.decode import decode
 from .proxy_request import ProxyRequest
 from .request_string_control import RequestStringControl
 
-CLRF = "\r\n"
+CLRF = b"\r\n"
 
 class RequestString:
     ENCODING = 'utf-8'
@@ -36,20 +36,19 @@ class RequestString:
 
     def get(self, **kwargs):
         if kwargs.get('control'):
-            return CLRF.join([self.control] + self.lines).encode(self.ENCODING)
+            return CLRF.join([self.control] + self.lines)
         else:
-            return CLRF.join(self.lines).encode(self.ENCODING)
+            return CLRF.join(self.lines)
 
     def set(self, s: bytes):
-        decoded_s = decode(s, self.ENCODING)
-        self.lines = decoded_s.split(CLRF)
+        self.lines = s.split(CLRF)
 
     @property
     def control(self):
         control = RequestStringControl()
         control.id = self.request_id
         control.timestamp = self.__current_time
-        return control.serialize()
+        return control.serialize().encode(self.ENCODING)
 
     @control.setter
     def control(self, c: str):
@@ -58,20 +57,27 @@ class RequestString:
         self.__current_time = control.timestamp
 
     def __request_line(self):
-        self.lines.append("{} {} HTTP/1.1".format(self.request.method, self.proxy_request.url()))
+        line = "{} {} HTTP/1.1".format(self.request.method, self.proxy_request.url())
+        self.lines.append(line.encode(self.ENCODING))
 
     def __headers(self):
         headers = self.request.headers
 
         for name, val in headers.items():
+            if 'content-encoding' in headers:
+                # self.request.body will decode content-encoding
+                # to maintain internal consistency, remove this header since it will be decoded
+                print(self.request.body)
+                pass
+
             line = ' '.join([
                 "{}:".format(self.__to_header_case(self.__to_str(name))), 
                 self.__to_str(val)
             ])
-            self.lines.append(line)
+            self.lines.append(line.encode(self.ENCODING))
 
     def __body(self):
-        self.lines.append("{}{}".format(CLRF, self.request.body))
+        self.lines.append(CLRF + self.request.body)
 
     def __to_header_case(self, header: str) -> str:
         toks = header.split('_')

stoobly_agent/app/proxy/replay/body_parser_service.py

@@ -14,6 +14,7 @@ from .multipart import decode as multipart_decode, encode as multipart_encode
 JSON = 'application/json'
 MULTIPART_FORM = 'multipart/form-data'
 WWW_FORM_URLENCODED = 'application/x-www-form-urlencoded'
+XML = 'application/xml'
 
 def compress(body: Union[bytes, str], content_encoding: Union[None, str]) -> Union[bytes, str]:
     if content_encoding:
@@ -113,14 +114,24 @@ def normalize_header(header):
 def is_traversable(content):
     return isinstance(content, list) or isinstance(content, dict) or isinstance(content, MultiDict)
 
-def is_json(content_type):
-   _content_type = content_type.lower()
-   return _content_type == JSON or _content_type.startswith('application/x-amz-json') 
+def is_json(content_type: str):
+    if not content_type:
+        return False
+
+    _content_type = content_type.lower().split(';')[0]
+    # e.g. custom json content-type: application/x-amz-json
+    return _content_type == JSON or (_content_type.startswith('application/') and _content_type.endswith('json'))
 
+def is_xml(content_type: str):
+    if not content_type:
+        return False
+
+    _content_type = content_type.lower().split(';')[0]
+    # e.g. custom json content-type: application/x-amz-json
+    return _content_type == XML or (_content_type.startswith('application/') and _content_type.endswith('xml'))
 
 def __parse_separated_header(header: str):
     # Adapted from https://peps.python.org/pep-0594/#cgi
     message = Message()
     message['content-type'] = header 
     return message.get_content_type()
-

stoobly_agent/app/proxy/replay/replay_request_service.py

@@ -150,6 +150,7 @@ def replay(context: ReplayContext, options: ReplayRequestOptions) -> requests.Re
     if options.get('save') or options.get('overwrite'):
       replayed_response, status = __create_replayed_response(context.request.id, res, latency)
 
+      # TODO: allow overwriting if status is the same
       if status < 400 and options.get('overwrite'):
         __overwrite_response(replayed_response.get('id'))
 

stoobly_agent/app/settings/data_rules.py

@@ -1,4 +1,4 @@
-from stoobly_agent.config.constants import mock_policy, record_policy, replay_policy, test_strategy
+from stoobly_agent.config.constants import mock_policy, record_order, record_policy, replay_policy, test_strategy
 
 from .types.proxy_settings import DataRules as IDataRules
 
@@ -8,6 +8,7 @@ class DataRules:
     self.__data_rules = data_rules or {}
 
     self.__mock_policy = self.__data_rules.get('mock_policy') or mock_policy.FOUND
+    self.__record_order = self.__data_rules.get('record_order') or record_order.APPEND
     self.__record_policy = self.__data_rules.get('record_policy') or record_policy.ALL
     self.__replay_policy = self.__data_rules.get('replay_policy') or replay_policy.ALL
     self.__scenario_key = self.__data_rules.get('scenario_key')
@@ -32,6 +33,19 @@ class DataRules:
     self.__record_policy = v
     self.__data_rules['record_policy'] = v
 
+  @property
+  def record_order(self):
+    return self.__record_order
+
+  @record_order.setter
+  def record_order(self, v):
+    valid_orders = [record_order.APPEND, record_order.OVERWRITE]
+    if v not in valid_orders:
+      raise TypeError(f"record_order has to be one of {valid_orders}, got {v}")
+
+    self.__record_order = v
+    self.__data_rules['record_order'] = v
+
   @property
   def replay_policy(self):
     return self.__replay_policy
@@ -68,6 +82,7 @@ class DataRules:
   def to_dict(self) -> IDataRules:
     return {
       'mock_policy': self.__mock_policy,
+      'record_order': self.__record_order,
       'record_policy': self.__record_policy,
       'replay_policy': self.__replay_policy,
       'scenario_key': self.__scenario_key,

stoobly_agent/config/constants/custom_headers.py

@@ -23,6 +23,7 @@ SESSION_ID = 'X-Stoobly-Session-Id'
 SERVICE_URL = 'X-Stoobly-Service-Url'
 TEST_FILTER = 'X-Stoobly-Test-Filter'
 TEST_ID = 'X-Stoobly-Test-Id'
+TEST_POLICY = 'X-Stoobly-Test-Policy'
 TEST_SAVE_RESULTS = 'X-Stoobly-Test-Save-Results'
 TEST_SKIP = 'X-Stoobly-Test-Skip'
 TEST_STRATEGY = 'X-Stoobly-Test-Strategy'

stoobly_agent/config/constants/lifecycle_hooks.py

@@ -1,4 +1,5 @@
 AFTER_MOCK = 'handle_after_mock'
+AFTER_MOCK_NOT_FOUND = 'handle_after_mock_not_found'
 AFTER_RECORD = 'handle_after_record'
 AFTER_REPLAY = 'handle_after_replay'
 AFTER_TEST = 'handle_after_test'

stoobly_agent/config/constants/record_order.py

@@ -0,0 +1,6 @@
+from typing import Literal
+
+APPEND = 'append'
+OVERWRITE = 'overwrite'
+
+RecordOrder = Literal[APPEND, OVERWRITE]

stoobly_agent/config/constants/record_policy.py

@@ -1,7 +1,7 @@
 from .intercept_policy import ALL as INTERCEPT_ALL, NONE as INTERCEPT_NONE
 
 ALL = INTERCEPT_ALL
+API = 'api'
 FOUND = 'found'
 NONE = INTERCEPT_NONE
-NOT_FOUND = 'not_found'
-OVERWRITE = 'overwrite'
+NOT_FOUND = 'not_found'