stoobly-agent 0.34.8__py3-none-any.whl → 0.34.10__py3-none-any.whl

stoobly_agent/app/cli/helpers/schema_builder.py

@@ -16,97 +16,20 @@ class SchemaBuilder:
     self.param_column_name: str = param_column_name
 
   def build(self, params):
-    self.param_names_created = {}
-    self.__traverse('', params, None)
-    return self.param_names_created.values()
-
-  ###
-  #
-  # @param name [String] name of current param
-  # @param value [Object] value of current param
-  # @param param [QueryParamName, BodyParamName, ResponseParamName] parent param record
-  #
-  def __traverse(self, name: str, value, param: RequestComponentName):
-    if type(value) is list:
-      self.__traverse_array(name, value, param)
-    elif type(value) is dict:
-      self.__traverse_hash(name, value, param)
-
-  def __traverse_array(self, name: str, value, parent_param: RequestComponentName):
-    columns = {
-      'endpoint_id': self.endpoint_id,
-      'name':  f"{name.capitalize()}Element",
-      'query': f"{parent_param.get('query')}[*]" if parent_param else '[*]'
-    }
-    columns[self.param_column_name + '_id'] = parent_param['id'] if parent_param else None
-
-    # Iterate
-    types = {}
-
-    for e in value:
-      # Example of e = {'id': {'value': 0, 'required': False}}
-      type_value = None
-      if e.get('value') is not None:
-        type_value = e.get('value')
-      else:
-        type_value = e
-
-      _type = self.__infer_type(type_value)
-
-      if types.get(_type) is None:
-        columns['inferred_type'] = convert(_type)
-        types[_type] = self.__find_or_create_by(columns)
-    
-      self.__traverse('', type_value, types[_type])
-
-  def __traverse_hash(self, name, value, parent_param: RequestComponentName):
-    # Iterate
-    for k, v in value.items():
-      columns = {
+    params_list = []
+    for literal_param in params:
+      param: RequestComponentName = {
         'endpoint_id': self.endpoint_id,
-        'inferred_type': convert(self.__infer_type(v['value'])),
-        'is_required': v.get('required') is True,
-
+        'name': literal_param['name'],
+        'query': literal_param['query'],
+        'is_required': literal_param['required'],
+        'inferred_type': convert(self.__infer_type(literal_param['value'])),
         'is_deterministic': True,
-        'name': k,
-        'query': f"{parent_param.get('query')}.{k}" if parent_param else k, 
+        'id': literal_param['id'],
+        f"{self.param_column_name}_id": literal_param['parent_id']
       }
-      columns[self.param_column_name + '_id'] = parent_param['id'] if parent_param else None
-      param = self.__find_or_create_by(columns)
-
-      self.__traverse(k, v['value'], param)
-
-  def __find_or_create_by(self, columns):
-    param = self.__find_by(columns) 
-
-    if param is None:
-      param = self.__create(columns)
-
-    return param
-
-  def __find_by(self, columns) -> Union[RequestComponentName, None]:
-    for id, param_name in self.param_names_created.items():
-      matches = True
-
-      for key in columns:
-        if key not in param_name:
-          matches = False
-          break
-
-        if param_name[key] != columns[key]:
-          matches = False
-          break
-      
-      if matches:
-        return param_name
-
-  def __create(self, columns):
-    param: RequestComponentName = columns.copy()
-    param['id'] = len(self.param_names_created.keys()) + 1
-
-    self.param_names_created[param['id']] = param
-
-    return param
+      params_list.append(param)
+    return params_list
 
   def __infer_type(self, val) -> str:
     return str(val.__class__)

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

@@ -5,6 +5,8 @@ from typing import List
 from stoobly_agent.lib.cache import Cache
 from stoobly_agent.lib.orm.request import Request
 
+PREFIX = 'last_request_id'
+
 def access_request(session_id: str, request_id: int, timeout = None):
   cache = Cache.instance()
   _last_request_id_key = __last_request_id_key(session_id)
@@ -18,6 +20,9 @@ def generate_session_id(query: dict):
 
   return hashlib.md5(b'.'.join(toks)).hexdigest()
 
+def reset():
+  Cache.instance().clear(f".+\.{PREFIX}")
+
 def tiebreak_scenario_request(session_id: str, requests: List[Request]):
   if len(requests) == 0:
     return None
@@ -43,4 +48,4 @@ def tiebreak_scenario_request(session_id: str, requests: List[Request]):
 
 def __last_request_id_key(_key = None):
   _key = _key or generate_session_id()
-  return f"{_key}.last_request_id"
+  return f"{_key}.{PREFIX}"

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

@@ -112,6 +112,7 @@ class LocalDBRequestAdapter(LocalDBAdapter):
 
     headers = {}
     headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
+    headers[custom_headers.MOCK_REQUEST_KEY] = request.key()
     headers[custom_headers.RESPONSE_LATENCY] = str(request.latency)
 
     return (

stoobly_agent/app/proxy/handle_mock_service.py

@@ -10,7 +10,7 @@ from stoobly_agent.app.models.request_model import RequestModel
 from stoobly_agent.app.proxy.mitmproxy.request_facade import MitmproxyRequestFacade
 from stoobly_agent.app.proxy.utils.rewrite_rules_to_ignored_components_service import rewrite_rules_to_ignored_components
 from stoobly_agent.config.constants import custom_headers, env_vars, lifecycle_hooks, mock_policy, request_origin
-from stoobly_agent.lib.logger import Logger
+from stoobly_agent.lib.logger import bcolors, Logger
 
 from .constants import custom_response_codes
 from .mock.context import MockContext
@@ -131,6 +131,11 @@ def __handle_mock_success(context: MockContext) -> None:
     if os.environ.get(env_vars.AGENT_SIMULATE_LATENCY):
         __simulate_latency(response.headers.get(custom_headers.RESPONSE_LATENCY), start_time)
 
+    request_key = response.headers.get(custom_headers.MOCK_REQUEST_KEY)
+    if request_key:
+        request = context.flow.request
+        Logger.instance().info(f"{bcolors.OKCYAN}Mocked{bcolors.ENDC} {request.url} -> {request_key}")
+
 def __handle_mock_failure(context: MockContext) -> None:
     req = context.flow.request
     intercept_settings = context.intercept_settings

stoobly_agent/app/proxy/replay/body_parser_service.py

@@ -76,7 +76,7 @@ def parse_multipart_form_data(content, content_type) -> Dict[bytes, bytes]:
 
     params_array = []
     for ele in decoded_multipart:
-        params_array.append((decode(ele[0]), decode(ele[1])))
+        params_array.append((decode(ele[0]), ele[1]))
  
     return MultiDict(params_array)
 

stoobly_agent/app/proxy/run.py

@@ -58,7 +58,6 @@ def __get_intercept_handler_path():
 def __with_static_options(config: MitmproxyConfig, cli_options):
     options = (
         'block_global=false',
-        'flow_detail=1',
         f"scripts={__get_intercept_handler_path()}",
         'upstream_cert=false'
     )

stoobly_agent/cli.py

@@ -86,7 +86,16 @@ def init(**kwargs):
   Passphrase for decrypting the private key provided in the --cert option. Note that passing cert_passphrase on the command line makes your passphrase visible in your system's process list. Specify it in
   config.yaml to avoid this.
 ''')
+@click.option('--confdir', default=os.path.join(os.path.expanduser('~'), '.mitmproxy'), help='Location of the default mitmproxy configuration files.')
 @click.option('--connection-strategy', help=', '.join(CONNECTION_STRATEGIES), type=click.Choice(CONNECTION_STRATEGIES))
+@click.option('--flow-detail', default='1', type=click.Choice(['1', '2', '3', '4']), help='''
+  The display detail level for flows in mitmdump: 0 (quiet) to 4 (very verbose).
+  0: no output
+  1: shortened request URL with response status code
+  2: full request URL with response status code and HTTP headers
+  3: 2 + truncated response content, content of WebSocket and TCP messages (content_view_lines_cutoff: 512)
+  4: 3 + nothing is truncated
+''')
 @click.option('--headless', is_flag=True, default=False, help='Disable starting UI.')
 @click.option('--intercept', is_flag=True, default=False, help='Enable intercept on run.')
 @click.option('--log-level', default=logger.INFO, type=click.Choice([logger.DEBUG, logger.INFO, logger.WARNING, logger.ERROR]), help='''
@@ -218,7 +227,7 @@ def __build_request_from_curl(**kwargs):
 
     if len(toks) != 2:
       continue
-    
+
     headers[toks[0].strip()] = toks[1].strip()
 
   return requests.Request(
@@ -226,4 +235,4 @@ def __build_request_from_curl(**kwargs):
     headers=headers,
     method=kwargs['request'],
     url=kwargs['url']
-  )
+  )

stoobly_agent/config/constants/custom_headers.py

@@ -5,6 +5,7 @@ REMOTE_PROJECT_KEY = 'X-Stoobly-Endpoints-Project-Id'
 MOCK_POLICY = 'X-Mock-Policy'
 MOCK_REQUEST_ID = 'X-Stoobly-Request-Id'
 MOCK_REQUEST_ENDPOINT_ID = 'X-Stoobly-Request-Endpoint-Id'
+MOCK_REQUEST_KEY = 'X-Stoobly-Request-Key'
 DO_PROXY = 'X-Do-Proxy'
 LIFECYCLE_HOOKS_PATH = 'X-Stoobly-Lifecycle-Hooks-Path'
 PROJECT_KEY = 'X-Project-Key'

stoobly_agent/lib/cache.py

@@ -1,5 +1,6 @@
 import pdb
 import random
+import re
 
 from time import time
 
@@ -23,10 +24,19 @@ class Cache:
 
         return cls._instance
 
-    def clear(self):
-        self.data = {}
-        self.dataVersions = {}
-        self.version += 1
+    def clear(self, pattern: str = None):
+        if not pattern:
+            self.data = {}
+            self.dataVersions = {}
+            self.version += 1
+        else:
+            delete_list = []
+            for key in self.data.keys():
+                if re.match(pattern, key):
+                    delete_list.append(key)
+            
+            for key in delete_list:
+                self.delete(key)
 
     def read(self, key):
         if key in self.timeouts:
@@ -48,9 +58,10 @@ class Cache:
 
     def read_all(self):
         data = []
-
-        for key in self.data.keys():
+        
+        for key in list(self.data.keys()):
             datum = self.read(key)
+
             if datum:
                 data.append(datum)
 
@@ -73,7 +84,13 @@ class Cache:
         self.version += 1
 
     def delete(self, key):
-        del self.data[key]
-        del self.dataVersions[key]
-        del self.timeouts[key]
+        if key in self.data:
+            del self.data[key]
+
+        if key in self.dataVersions:
+            del self.dataVersions[key]
+
+        if key in self.timeouts:
+            del self.timeouts[key]
+
         self.version += 1