stoobly-agent 0.21.0__py3-none-any.whl → 0.22.3__py3-none-any.whl

stoobly_agent/app/models/header_model.py

@@ -2,12 +2,12 @@ import pdb
 import requests
 
 from typing import Union
-from stoobly_agent.app.models.adapters.header_adapter_factory import HeaderAdapterFactory
 
 from stoobly_agent.app.models.types.request_components import HeaderIndexResponse
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
+from .factories.resource.header import HeaderResourceFactory
 from .model import Model
 
 class HeaderModel(Model):
@@ -16,7 +16,7 @@ class HeaderModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-    self.adapter =  HeaderAdapterFactory(self.settings.remote).local_db()
+    self.adapter =  HeaderResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
     # raise('Not yet supported.')

stoobly_agent/app/models/query_param_model.py

@@ -7,7 +7,7 @@ from stoobly_agent.app.models.types.request_components import QueryParamIndexRes
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
-from .adapters.query_param_adapter_factory import QueryParamAdapterFactory
+from .factories.resource.query_param import QueryParamResourceFactory
 from .model import Model
 
 class QueryParamModel(Model):
@@ -16,7 +16,7 @@ class QueryParamModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-    self.adapter =  QueryParamAdapterFactory(self.settings.remote).local_db()
+    self.adapter =  QueryParamResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
     #raise('Not yet supported.')

stoobly_agent/app/models/replayed_response_model.py

@@ -1,10 +1,10 @@
 import pdb
 import requests
 
-from stoobly_agent.app.models.adapters.replayed_response_adapter_factory import ReplayedResponseAdapterFactory
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
+from .factories.resource.replayed_response import ReplayedResponseResourceFactory
 from .model import Model
 
 class ReplayedResponseModel(Model):
@@ -13,7 +13,7 @@ class ReplayedResponseModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-    self.adapter =  ReplayedResponseAdapterFactory(self.settings.remote).local_db()
+    self.adapter =  ReplayedResponseResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
     # raise('Not yet supported.')

stoobly_agent/app/models/request_model.py

@@ -8,10 +8,9 @@ from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.api.interfaces import RequestShowResponse
 from stoobly_agent.lib.logger import Logger
 
-from .adapters.request_adapter_factory import RequestAdapterFactory
-from .adapters.types import RequestCreateParams, RequestShowParams
+from .factories.resource.request import RequestResourceFactory
 from .model import Model
-from .types.requests_model_index import RequestsModelIndex
+from .types import RequestCreateParams, RequestShowParams, RequestsModelIndex
 
 class RequestModel(Model):
 
@@ -19,10 +18,10 @@ class RequestModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-      self.adapter = RequestAdapterFactory(self.settings.remote).local_db()
+      self.adapter = RequestResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
-      self.adapter = RequestAdapterFactory(self.settings.remote).stoobly()
+      self.adapter = RequestResourceFactory(self.settings.remote).stoobly()
 
   def create(self, **body_params: RequestCreateParams) -> Union[RequestsModelIndex, None]:
     try:

stoobly_agent/app/models/response_header_model.py

@@ -7,7 +7,7 @@ from stoobly_agent.app.models.types.request_components import ResponseHeaderInde
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
-from .adapters.response_header_adapter_factory import ResponseHeaderAdapterFactory
+from .factories.resource.response_header import ResponseHeaderResourceFactory
 from .model import Model
 
 class ResponseHeaderModel(Model):
@@ -16,7 +16,7 @@ class ResponseHeaderModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-    self.adapter =  ResponseHeaderAdapterFactory(self.settings.remote).local_db()
+    self.adapter =  ResponseHeaderResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
     # raise('Not yet supported.')

stoobly_agent/app/models/response_model.py

@@ -1,10 +1,10 @@
 import pdb
 import requests
 
-from stoobly_agent.app.models.adapters.response_adapter_factory import ResponseAdapterFactory
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
+from .factories.resource.response import ResponseResourceFactory
 from .model import Model
 
 class ResponseModel(Model):
@@ -13,7 +13,7 @@ class ResponseModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-    self.adapter =  ResponseAdapterFactory(self.settings.remote).local_db()
+    self.adapter = ResponseResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
     # raise('Not yet supported.')

stoobly_agent/app/models/scenario_model.py

@@ -7,8 +7,8 @@ from stoobly_agent.lib.logger import Logger
 from stoobly_agent.lib.api.interfaces.scenarios import ScenarioShowResponse, ScenariosIndexResponse
 from stoobly_agent.app.settings import Settings
 
-from .adapters.scenario_adapter_factory import ScenarioAdapterFactory
-from .adapters.types import ScenarioCreateParams
+from .types import ScenarioCreateParams
+from .factories.resource.scenario import ScenarioResourceFactory
 from .model import Model
 
 class ScenarioModel(Model):
@@ -17,10 +17,10 @@ class ScenarioModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-      self.adapter = ScenarioAdapterFactory(self.settings.remote).local_db()
+      self.adapter = ScenarioResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
-      self.adapter = ScenarioAdapterFactory(self.settings.remote).stoobly()
+      self.adapter = ScenarioResourceFactory(self.settings.remote).stoobly()
 
   def create(self, **body_params: ScenarioCreateParams) -> Union[ScenarioShowResponse, None]:
     try:

stoobly_agent/app/models/schemas/request.py

@@ -96,6 +96,10 @@ class Request():
   def headers(self, v: MultiDict):
     self.__set_dict('headers', v)
 
+  @property
+  def query(self) -> str:
+    return urlencode(self.query_params)
+
   @property
   def query_params(self) -> MultiDict:
     query_params = MultiDict()
@@ -115,7 +119,10 @@ class Request():
     if not encoded_body:
       return ''
 
-    return base64.b64decode(encoded_body)
+    try:
+      return base64.b64decode(encoded_body)
+    except Exception as e:
+      return encoded_body
 
   @body.setter
   def body(self, v: Union[bytes, str]):

stoobly_agent/app/models/types/__init__.py

@@ -0,0 +1,6 @@
+from .replayed_response import *
+from .request_components import *
+from .request_create_params import *
+from .request_show_params import *
+from .requests_model_index import *
+from .scenario_create_params import *

stoobly_agent/app/proxy/__init__.py

@@ -83,10 +83,6 @@ def __commit_options(options: dict):
     if options.get('proxy_host') and options.get('proxy_port'):
         settings.proxy.url = f"http://{options.get('proxy_host')}:{options.get('proxy_port')}"
 
-    if options.get('intercept_mode'):
-        settings.proxy.intercept.mode = options['intercept_mode']
-        settings.proxy.intercept.active = True
-
     settings.ui.active = not options.get('headless')
 
     settings.commit()
@@ -112,7 +108,6 @@ def __filter_options(options):
     if 'ui_port' in options:
         del options['ui_port']
 
-    del options['intercept_mode']
     del options['log_level']
     del options['proxy_host']
     del options['proxy_mode']

stoobly_agent/app/proxy/handle_mock_service.py

@@ -2,15 +2,12 @@ import requests
 import time
 import pdb
 
-from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow
 from mitmproxy.http import Request as MitmproxyRequest
 from typing import Callable, TypedDict
 
 from stoobly_agent.app.models.request_model import RequestModel
-from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 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.app.settings import intercept_settings
 from stoobly_agent.config.constants import custom_headers, mock_policy
 from stoobly_agent.lib.logger import Logger
 

stoobly_agent/app/proxy/handle_test_service.py

@@ -13,7 +13,7 @@ from stoobly_agent.lib.logger import Logger
 
 from .handle_mock_service import handle_request_mock_generic
 from .mock.context import MockContext
-from .test.context import TestContext
+from .test.context_abc import TestContextABC as TestContext
 from .test.test_service import test
 from .upload.upload_test_service import inject_upload_test
 

stoobly_agent/app/proxy/intercept_handler.py

@@ -28,7 +28,6 @@ LOG_ID = 'InterceptHandler'
 
 def request(flow: MitmproxyHTTPFlow):
     request: MitmproxyRequest = flow.request
-
     intercept_settings = InterceptSettings(Settings.instance(), request)
 
     active_mode = intercept_settings.mode

stoobly_agent/app/proxy/mitmproxy/flow_mock.py

@@ -0,0 +1,35 @@
+import requests
+
+from mitmproxy.http import Request as MitmproxyRequest, Response as MitmproxyResponse
+from typing import Union
+
+from stoobly_agent.app.models.adapters.python import PythonRequestAdapterFactory, PythonResponseAdapterFactory
+from stoobly_agent.app.models.adapters.raw_http_request_adapter import DEFAULT_HTTP_VERSION
+
+class MitmproxyFlowMock():
+
+  def __init__(self):
+    self.__request: MitmproxyRequest = None
+    self.__response: MitmproxyResponse = None
+
+  @property
+  def request(self):
+    return self.__request
+
+  @property
+  def response(self):
+    return self.__response
+
+  @request.setter
+  def request(self, _request: Union[MitmproxyRequest, requests.Request]):
+    if isinstance(_request, requests.Request):
+      self.__request = PythonRequestAdapterFactory(_request).mitmproxy_request(DEFAULT_HTTP_VERSION)
+    else:
+      self.__request = _request
+
+  @response.setter
+  def response(self, _response: Union[MitmproxyResponse, requests.Response]):
+    if isinstance(_response, requests.Response):
+      self.__response = PythonResponseAdapterFactory(_response).mitmproxy_response()
+    else:
+      self.__response = _response

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -5,6 +5,7 @@ from mitmproxy.http import Headers, Request as MitmproxyRequest
 from mitmproxy.coretypes import multidict
 from typing import Callable, List, Union
 from urllib.parse import urlparse
+import requests
 
 from stoobly_agent.app.settings.constants import request_component
 from stoobly_agent.app.settings.rewrite_rule import RewriteRule, ParameterRule
@@ -53,7 +54,7 @@ class MitmproxyRequestFacade(Request):
 
     @property
     def body(self):
-        content = self.request.raw_content
+        content = self.request.raw_content or ''
 
         try:
             if isinstance(content, bytes):
@@ -96,6 +97,14 @@ class MitmproxyRequestFacade(Request):
     def rewrite_rules(self) -> List[ParameterRule]:
         return self.__rewrite_rules
 
+    def to_python_request(self):
+        return requests.Request(
+            method=self.request.method,
+            url=self.request.url,
+            headers=self.request.headers,
+            data=self.request.content
+        )
+
     def with_rewrite_rules(self, rules: List[RewriteRule]):
         if type(rules) == list:
             self.__rewrite_rules = self.select_parameter_rules(rules)
@@ -154,7 +163,7 @@ class MitmproxyRequestFacade(Request):
             })
 
     def __rewrite_handler(self, rewrite: ParameterRule) -> str:
-        Logger.instance().debug(f"{bcolors.OKCYAN}Rewriting{bcolors.ENDC} {rewrite.name} => {rewrite.value}")
+        Logger.instance().info(f"{bcolors.OKCYAN}Rewriting {rewrite.type.lower()}{bcolors.ENDC} {rewrite.name} => {rewrite.value}")
         return rewrite.value
 
     def __rewrite_headers(self, rewrites: List[ParameterRule]):

stoobly_agent/app/proxy/mock/hashed_request_decorator.py

@@ -86,8 +86,8 @@ class HashedRequestDecorator:
     def body_text_hash(self):
         text = self.request.body
 
-        if len(text) == 0:
-            return text
+        if not text or len(text) == 0:
+            return ''
 
         return self.__hash(text)
 

stoobly_agent/app/proxy/replay/replay_request_service.py

@@ -5,16 +5,17 @@ import requests
 from http.cookies import SimpleCookie
 from typing import Callable, TypedDict, Union
 
+from stoobly_agent.app.cli.ca_cert_installer import CACertInstaller
 from stoobly_agent.app.cli.helpers.context import ReplayContext
 from stoobly_agent.app.models.schemas.request import Request
 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.trace_context import TraceContext
+from stoobly_agent.app.proxy.simulate_intercept_service import simulate_intercept
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.config.constants import alias_resolve_strategy, custom_headers, request_origin, test_filter, test_strategy
 from stoobly_agent.config.mitmproxy import MitmproxyConfig
-from stoobly_agent.config.constants import mode
-from stoobly_agent.lib.api.api import Api
+from stoobly_agent.config.constants import mock_policy, mode
 
 class ReplayRequestOptions(TypedDict):
   alias_resolve_strategy: alias_resolve_strategy.AliasResolveStrategy
@@ -25,6 +26,7 @@ class ReplayRequestOptions(TypedDict):
   before_replay: Union[Callable[[ReplayContext], None], None]
   after_replay: Union[Callable[[ReplayContext], Union[requests.Response, None]], None]
   project_key: Union[str, None]
+  proxies: dict
   report_key: Union[str, None] 
   request_origin: Union[request_origin.CLI, None] 
   scenario_key: Union[str, None] 
@@ -37,17 +39,14 @@ def replay_with_trace(context: ReplayContext, trace_context: TraceContext, optio
   trace_context.alias_resolve_strategy = options.get('alias_resolve_strategy')
   return trace_context.with_replay_context(context, lambda context: replay(context, options))
 
-def replay_with_rewrite(context: ReplayContext) -> requests.Response:
-  return replay(context, {
-      'before_replay': __handle_before_replay
-  })
-
 def replay(context: ReplayContext, options: ReplayRequestOptions) -> requests.Response:
   if 'before_replay' in options and callable(options['before_replay']):
     options['before_replay'](context)
 
   request = context.request
   headers = request.headers
+  method = request.method
+  cookies = __get_cookies(headers)
 
   if options.get('host'):
     request.host = options['host']
@@ -56,48 +55,70 @@ def replay(context: ReplayContext, options: ReplayRequestOptions) -> requests.Re
   if options.get('scheme'):
     request.scheme = options['scheme']
 
-  if 'alias_resolve_strategy' in options:
+  if options.get('alias_resolve_strategy'):
     headers[custom_headers.ALIAS_RESOLVE_STRATEGY] = options['alias_resolve_strategy']
 
-  if 'lifecycle_hooks_script_path' in options:
+  if options.get('lifecycle_hooks_script_path'):
     __handle_lifecycle_hooks_script_path(options['lifecycle_hooks_script_path'], headers) 
 
-  if 'mode' in options:
+  if options.get('mode'):
     __handle_mode_option(options['mode'], request, headers)
 
-  if 'project_key' in options:
+  if options.get('project_key'):
     headers[custom_headers.PROJECT_KEY] = options['project_key']
 
-  if 'report_key' in options:
+  if options.get('report_key'):
     headers[custom_headers.REPORT_KEY] = options['report_key']
 
-  if 'request_origin' in options:
+  if options.get('request_origin'):
     headers[custom_headers.REQUEST_ORIGIN] = options['request_origin']
 
-  if 'scenario_key' in options:
+  if options.get('scenario_key'):
     headers[custom_headers.SCENARIO_KEY] = options['scenario_key']
 
-  if 'test_filter' in options:
+  if options.get('test_filter'):
     headers[custom_headers.TEST_FILTER] = options['test_filter']
 
-  if 'test_strategy' in options:
+  if options.get('test_strategy'):
     headers[custom_headers.TEST_STRATEGY] = options['test_strategy']
 
-  method = request.method
-  handler = getattr(requests, method.lower())
-  cookies = __get_cookies(request.headers)
-
-  # Set proxy env vars to ensure request gets sent to proxy
-  res: requests.Response = Api().with_proxy(lambda: handler(
-    request.url, 
-    allow_redirects = True,
-    cookies = cookies,
-    data=request.body,
-    headers=headers, 
-    #params=request.query_params, # Do not send query params, they should be a part of the URL
-    stream = True,
-    verify = not MitmproxyConfig.instance().get('ssl_insecure')
-  ))
+  request_config = {
+    'allow_redirects': True,
+    'stream': True,
+    'verify': not MitmproxyConfig.instance().get('ssl_insecure')
+  }
+  request_dict = {
+    'cookies': cookies,
+    'data': request.body,
+    'headers': headers, 
+    #'params': request.query_params, # Do not send query params, they should be a part of the URL
+  }
+
+  res: requests.Response = None
+  if not options.get('proxy'):
+    request = requests.Request(**{
+      **request_dict,
+      'method': method,
+      'url': request.url,
+    })
+
+    res = simulate_intercept(request, **request_config)
+  else:
+    settings = Settings.instance()
+    handler = getattr(requests, method.lower())
+
+    res = handler(
+      request.url, 
+      **{
+        **request_config,
+        **request_dict,
+        'proxies': {
+          'http': settings.proxy.url,
+          'https': settings.proxy.url,
+        },
+        'verify': CACertInstaller().mitm_crt_absolute_path if request_config['verify'] else False,
+      }
+    )
 
   if 'after_replay' in options and callable(options['after_replay']):
     context.with_response(res)
@@ -119,18 +140,15 @@ def __handle_mode_option(_mode, request: Request, headers):
 
   if _mode == mode.MOCK or _mode == mode.TEST:
     # If mocking or testing, we already know which request to get response from 
-    headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
+    if request.id:
+      headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
+
+    headers[custom_headers.MOCK_POLICY] = mock_policy.ALL
   elif _mode == mode.RECORD:
     # If recording, then it's actually a replay and record
     headers[custom_headers.PROXY_MODE] = mode.REPLAY
     headers[custom_headers.RESPONSE_PROXY_MODE] = mode.RECORD
 
 def __get_cookies(headers: Request.headers):
-  return SimpleCookie(headers.get('Cookie'))
-
-def __handle_before_replay(context: ReplayContext):
-  request = context.request
-  request_facade = MitmproxyRequestFacade(request)
-  intercept_settings = InterceptSettings(Settings.instance())
-  rewrite_rules = intercept_settings.replay_rewrite_rules
-  request_facade.with_rewrite_rules(rewrite_rules).rewrite()
+  cookies = SimpleCookie(headers.get('Cookie')).items()
+  return {k: v.value for k, v in cookies}

stoobly_agent/app/proxy/simulate_intercept_service.py

@@ -0,0 +1,30 @@
+import pdb
+import requests
+
+from mitmproxy.http import Request as MitmproxyRequest
+
+from stoobly_agent.app.proxy.mitmproxy.flow_mock import MitmproxyFlowMock
+from stoobly_agent.app.models.adapters.mitmproxy import MitmproxyRequestAdapterFactory, MitmproxyResponseAdapterFactory
+
+from .intercept_handler import request as handle_request, response as handle_response
+
+def simulate_intercept(request: requests.Request, **config):
+  flow = MitmproxyFlowMock()
+
+  flow.request = request
+
+  handle_request(flow)
+
+  if not flow.response:
+    session = requests.Session()
+    prepared_request = __prepare_mitmproxy_request(flow.request)
+    res = session.send(prepared_request, **config)
+    flow.response = res
+
+  handle_response(flow)
+
+  return MitmproxyResponseAdapterFactory(flow.response).python_response()
+
+def __prepare_mitmproxy_request(request: MitmproxyRequest) -> requests.Request:
+  _request = MitmproxyRequestAdapterFactory(request).python_request()
+  return _request.prepare()

stoobly_agent/app/proxy/test/__init__.py

@@ -1,2 +1,3 @@
 from .context import TestContext
+from .context_abc import TestContextABC
 from .context_response import TestContextResponse

stoobly_agent/app/proxy/test/context.py

@@ -20,10 +20,11 @@ from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
 from stoobly_agent.lib.orm.trace import Trace
 
 from .context_response import TestContextResponse
+from .context_abc import TestContextABC
 
 FuzzyContent = Union[dict, list, str]
 
-class TestContext():
+class TestContext(TestContextABC):
   def __init__(self, replay_context: ReplayContext, mock_context: MockContext):
     self.__flow = mock_context.flow
     self.__intercept_settings = mock_context.intercept_settings