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

stoobly_agent/__init__.py

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

stoobly_agent/app/api/bodies_controller.py

@@ -41,12 +41,12 @@ class BodiesController:
 
         accepted_headers = ['content-encoding', 'content-length', 'content-type']
         for header, val in request.headers.items():
-            decoded_header = header.decode().lower()
+            decoded_header = header.lower()
 
             if decoded_header not in accepted_headers:
                 continue 
 
-            headers[decoded_header] = val.decode()
+            headers[decoded_header] = val
 
         context.render(
             data = request.data,

stoobly_agent/app/api/requests_controller.py

@@ -1,4 +1,6 @@
+import json
 import pdb
+import requests
 
 from datetime import datetime
 from time import time
@@ -7,15 +9,15 @@ from urllib.parse import urlparse
 from stoobly_agent.app.api.simple_http_request_handler import SimpleHTTPRequestHandler
 from stoobly_agent.app.cli.helpers.context import ReplayContext
 from stoobly_agent.app.models.adapters.joined_request_adapter import JoinedRequestAdapter
-from stoobly_agent.app.models.adapters.mitmproxy_request_adapter import MitmproxyRequestAdapter
-from stoobly_agent.app.models.adapters.mitmproxy_response_adapter import MitmproxyResponseAdapter
+from stoobly_agent.app.models.adapters.python import PythonRequestAdapterFactory, PythonResponseAdapterFactory
 from stoobly_agent.app.models.adapters.raw_http_request_adapter import RawHttpRequestAdapter
 from stoobly_agent.app.models.adapters.raw_http_response_adapter import RawHttpResponseAdapter
 from stoobly_agent.app.models.request_model import RequestModel
 from stoobly_agent.app.models.schemas.request import Request
-from stoobly_agent.app.proxy.replay.replay_request_service import replay_with_rewrite
+from stoobly_agent.app.proxy.replay.replay_request_service import replay
 from stoobly_agent.app.proxy.upload.upload_request_service import upload_staged_request
 from stoobly_agent.app.settings import Settings
+from stoobly_agent.config.constants import mode
 from stoobly_agent.lib.orm.replayed_response import ReplayedResponse
 from stoobly_agent.lib.orm.request import Request as OrmRequest
 
@@ -52,8 +54,8 @@ class RequestsController:
         request_adapter = RawHttpRequestAdapter(joined_request.request_string.get())
         response_adapter = RawHttpResponseAdapter(joined_request.response_string.get())
 
-        mitmproxy_request = MitmproxyRequestAdapter(request_adapter.protocol, request_adapter.to_request()).adapt()
-        mitmproxy_response = MitmproxyResponseAdapter(response_adapter.protocol, response_adapter.to_response()).adapt()
+        mitmproxy_request = PythonRequestAdapterFactory(request_adapter.to_request()).mitmproxy_request(request_adapter.protocol)
+        mitmproxy_response = PythonResponseAdapterFactory(response_adapter.to_response()).mitmproxy_response()
 
         class MitmproxyFlowMock():
             def __init__(self, request, response):
@@ -66,6 +68,7 @@ class RequestsController:
         request = request_model.create(**{
             'flow': mitmproxy_flow_mock,
             'joined_request': joined_request,
+            'scenario_id': body_params.get('scenario_id'),
         })
 
         if not request:
@@ -201,29 +204,21 @@ class RequestsController:
             return context.bad_request(f"Could not find request {request_id}")
 
         replay_context = ReplayContext(Request(request_response))
-
-        now = time()
-        res = replay_with_rewrite(replay_context)
-        received_at = time()
-
-        replayed_response = ReplayedResponse()
-        replayed_response.request_id = request_id
-        replayed_response.with_python_response(res)
-        replayed_response.latency = (received_at - now) * 1000 # ms
-        replayed_response.save()
-
-        context.render(
-            data = res.raw.data,
-            headers = res.headers,
-            status = res.status_code
-        )
+        self.__replay(context, replay_context)
 
     # PUT /requests/send
     def send(self, context: SimpleHTTPRequestHandler):
+        headers = []
+
+        try:
+            headers = json.load(context.params.get('headers'))
+        except Exception as e:
+            pass
+
         url = urlparse(context.params.get('url'))
         request_response = {
             'body': context.params.get('body'),
-            'headers': context.params.get('headers'),
+            'headers': headers,
             'method': context.params.get('method'),
             'path': url.path,
             'password': url.password,
@@ -234,16 +229,43 @@ class RequestsController:
         }
 
         replay_context = ReplayContext(Request(request_response))
-        res = replay_with_rewrite(replay_context)
+        self.__send(context, replay_context)
+
+    def export(self, context: SimpleHTTPRequestHandler):
+        context.parse_path_params({
+            'id': 1
+        })
+        request_id = int(context.params.get('id'))
+
+    def __request_model(self, context: SimpleHTTPRequestHandler):
+        request_model = RequestModel(Settings.instance())
+        request_model.as_remote() if context.headers.get('access-token') else request_model.as_local()
+        return request_model
+
+    def __replay(self, context: SimpleHTTPRequestHandler, replay_context: ReplayContext):
+        save = bool(context.params.get('save'))
+        callback = self.__create_replayed_response if save else None
+
+        self.__send(context, replay_context, callback) 
+
+    def __send(self, context: SimpleHTTPRequestHandler, replay_context: ReplayContext, callback = None):
+        now = time()
+        res = replay(replay_context, { 'mode': mode.REPLAY })
+        received_at = time()
+
+        if callback:
+            callback(context, res, int((received_at - now) * 1000))
 
         context.render(
-            data = res.raw.data,
+            data = res.raw.data if hasattr(res, 'raw') else res.content,
             headers = res.headers,
             status = res.status_code
         )
 
-
-    def __request_model(self, context: SimpleHTTPRequestHandler):
-        request_model = RequestModel(Settings.instance())
-        request_model.as_remote() if context.headers.get('access-token') else request_model.as_local()
-        return request_model
+    def __create_replayed_response(self, context: SimpleHTTPRequestHandler, res: requests.Response, latency: int):   
+        request_id = int(context.params.get('id'))
+        replayed_response = ReplayedResponse()
+        replayed_response.request_id = request_id
+        replayed_response.with_python_response(res)
+        replayed_response.latency = latency # ms
+        replayed_response.save()

stoobly_agent/app/api/simple_http_request_handler.py

@@ -62,7 +62,7 @@ class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
         headers = self.filter_headers(kwargs.get('headers'), {
             'TRANSFER-ENCODING': 'CHUNKED',
         })
-        headers['Content-Length'] = len(body)
+        headers['Content-Length'] = str(len(body))
 
         self.enable_cors(headers)
         self.render_headers(headers)

stoobly_agent/app/cli/ca_cert_installer.py

@@ -7,19 +7,22 @@ class CACertInstaller():
         home_dir = os.path.expanduser('~')
         self.mitmproxy_certs_dir = os.path.join(home_dir, '.mitmproxy')
         self.pem_file_name = 'mitmproxy-ca-cert.pem'
+        self.cer_file_name = 'mitmproxy-ca-cert.cer'
         self.crt_file_name = 'mitmproxy-ca-cert.crt'
 
+    @property
+    def mitm_crt_absolute_path(self):
+        return os.path.join(self.mitmproxy_certs_dir, self.crt_file_name)
+
     # https://askubuntu.com/a/94861
     def handle_debian(self):
         extra_ca_certs_dir = '/usr/local/share/ca-certificates/extra'
-        mitm_pem_absolute_path = os.path.join(self.mitmproxy_certs_dir, self.pem_file_name)
-        mitm_crt_absolute_path = os.path.join(self.mitmproxy_certs_dir, self.crt_file_name)
+        mitm_cer_absolute_path = os.path.join(self.mitmproxy_certs_dir, self.cer_file_name)
         extra_crt_absolute_path = os.path.join(extra_ca_certs_dir, self.crt_file_name)
 
         subprocess.run(f"sudo mkdir -p {extra_ca_certs_dir}".split(), check=True)
-        subprocess.run(f"openssl x509 -in {mitm_pem_absolute_path} -inform PEM -out {mitm_crt_absolute_path}".split(), check=True)
-        subprocess.run(f"sudo cp {mitm_crt_absolute_path} {extra_crt_absolute_path}".split(), check=True)
-        subprocess.run('sudo update-ca-certificates'.split(), check=True)
+        subprocess.run(f"sudo cp {mitm_cer_absolute_path} {extra_crt_absolute_path}".split(), check=True)
+        subprocess.run("sudo update-ca-certificates".split(), check=True)
 
     # https://www.dssw.co.uk/reference/security.html
     def handle_darwin(self):
@@ -27,3 +30,11 @@ class CACertInstaller():
         mitm_pem_absolute_path = os.path.join(self.mitmproxy_certs_dir, self.pem_file_name)
 
         subprocess.run(f"sudo security add-trusted-cert -d -p ssl -p basic -k {system_keychain_path} {mitm_pem_absolute_path}".split(), check=True)
+
+    def handle_rhel(self):
+        ca_trust_dir = '/etc/pki/ca-trust/source/anchors'
+        mitm_cer_absolute_path = os.path.join(self.mitmproxy_certs_dir, self.cer_file_name)
+        ca_trust_crt_absolute_path = os.path.join(ca_trust_dir, self.crt_file_name)
+
+        subprocess.run(f"sudo cp {mitm_cer_absolute_path} {ca_trust_crt_absolute_path}".split(), check=True)
+        subprocess.run("sudo update-ca-trust extract".split(), check=True)

stoobly_agent/app/cli/config_cli.py

@@ -12,6 +12,8 @@ from stoobly_agent.config.constants import mode
 from stoobly_agent.lib.api.keys import ProjectKey, ScenarioKey
 from stoobly_agent.lib.logger import Logger
 
+from .helpers import  ProjectFacade, ScenarioFacade
+from .helpers.print_service import print_projects, print_scenarios, select_print_options
 from .helpers.validations import *
 
 @click.group(
@@ -42,170 +44,234 @@ def dump(**kwargs):
     else:
         print(output)
 
-is_remote = Settings.instance().cli.features.remote
-if is_remote:
-    @click.group(
-        help="Manage active scenario."
-    )
-    @click.pass_context
-    def scenario(ctx):
-        pass
+### Scenario
 
-    @scenario.command(
-        help="Set active scenario."
-    )
-    @click.argument('scenario_key')
-    def set(**kwargs):
-        settings = Settings.instance()
+@click.group(
+    help="Manage active scenario"
+)
+@click.pass_context
+def scenario(ctx):
+    pass
 
-        scenario_key = ScenarioKey(kwargs['scenario_key'])
-        validate_scenario_key(scenario_key)
+@scenario.command(
+    help="Describe scenario"
+)
+@click.option('--select', multiple=True, help='Select column(s) to display.')
+@click.option('--without-headers', is_flag=True, default=False, help='Disable printing column headers.')
+def show(**kwargs):
+    settings = Settings.instance()
+    print_options = select_print_options(kwargs)
 
-        project_key = settings.proxy.intercept.project_key
-        validate_project_key(project_key)
-        project_key = ProjectKey(project_key)
+    project_key = __project_key(settings)
+    data_rule = settings.proxy.data.data_rules(project_key.id)
 
-        if scenario_key.project_id != project_key.id:
-            return print("Please provide a scenario that belongs to the current project.\n")
+    if not data_rule.scenario_key or len(data_rule.scenario_key) == 0:
+        return
 
-        data_rule = settings.proxy.data.data_rules(project_key.id)
-        data_rule.scenario_key = kwargs['scenario_key']
-        settings.commit()
+    kwargs['key'] = data_rule.scenario_key
 
-        print("Scenario updated!")
 
-    @click.group(
-        help="Manage active project."
-    )
-    @click.pass_context
-    def project(ctx):
-        pass
+    scenario_key = resolve_scenario_key_and_validate(kwargs, settings)
+    scenario = ScenarioFacade(settings)
 
-    @project.command(
-        help="Set active project."
-    )
-    @click.argument('project_key')
-    def set(**kwargs):
-        settings = Settings.instance()
+    try:
+        scenario_response = scenario.show(scenario_key)
+    except AssertionError as e:
+        return print(e, file=sys.stderr)
 
-        project_key = kwargs['project_key']
-        validate_project_key(project_key)
-        _project_key = ProjectKey(project_key)
+    print_scenarios([scenario_response], **print_options)
 
-        data_rule = settings.proxy.data.data_rules(_project_key.id)
-        scenario_key = data_rule.scenario_key
+@scenario.command(
+    help="Set active scenario."
+)
+@click.argument('scenario_key')
+def set(**kwargs):
+    validate_scenario_key(kwargs['scenario_key'])
+    scenario_key = ScenarioKey(kwargs['scenario_key'])
 
-        if scenario_key:
-            validate_scenario_key(scenario_key)
-            scenario_key = ScenarioKey(scenario_key)
+    settings = Settings.instance()
+    project_key = __project_key(settings)
 
-            if project_key.id != scenario_key.project_id:
-                data_rule.scenario_key = None
-                print("Current scenario does not belong to current project, unsetting current scenario.\n")
+    if scenario_key.project_id != project_key.id:
+        return print("Please provide a scenario that belongs to the current project.\n")
 
-        settings.proxy.intercept.project_key = project_key 
-        settings.commit()
+    data_rule = settings.proxy.data.data_rules(project_key.id)
+    data_rule.scenario_key = kwargs['scenario_key']
+    settings.commit()
 
-        print("Project updated!")
+    print("Scenario updated!")
 
-    @click.group(
-        help="Manage API key."
-    )
-    @click.pass_context
-    def api_key(ctx):
-        pass
+@scenario.command(
+    help="Clear active scenario."
+)
+def clear(**kwargs):
+    settings = Settings.instance()
 
-    @api_key.command(
-        help="Set API Key"
-    )
-    @click.argument('api_key')
-    def set(**kwargs):
-        settings = Settings.instance()
+    project_key = __project_key(settings) 
+
+    data_rule = settings.proxy.data.data_rules(project_key.id)
+    data_rule.scenario_key = ''
+    settings.commit()
+
+    print("Scenario cleared!")
+
+### Rewrite
+
+@click.group(
+    help="Manage rewrite rules"
+)
+@click.pass_context
+def rewrite(ctx):
+    pass
+
+@rewrite.command(
+    help="Set rewrite rule."
+)
+@click.option(
+    '--method', 
+    multiple=True, 
+    required=True,
+    type=click.Choice(['GET', 'POST', 'DELETE', 'OPTIONS', 'PUT']), 
+    help='HTTP methods.'
+)
+@click.option(
+    '--mode',
+    multiple=True,
+    required=True,
+    type=click.Choice([mode.MOCK, mode.RECORD, mode.REPLAY, mode.TEST])
+)
+@click.option('--name', required=True, help='Name of the request component.')
+@click.option('--pattern', required=True, help='URLs pattern.')
+@click.option('--project_key', help='Project to add rewrite rule to.')
+@click.option(
+    '--type', 
+    required=True,
+    type=click.Choice([request_component.BODY_PARAM, request_component.HEADER, request_component.QUERY_PARAM]), 
+    help='Request component type.'
+)
+@click.option('--value', required=True, help='Rewrite value.')
+def set(**kwargs):
+    settings = Settings.instance()
+    project_key_str = resolve_project_key_and_validate(kwargs, settings)
+    project_key = ProjectKey(project_key_str)
+
+    methods = list(kwargs['method'])
+    modes = list(kwargs['mode'])
+
+    rewrite_rules = settings.proxy.rewrite.rewrite_rules(project_key.id)
+
+    rewrite_rule_filter = lambda rule: rule.pattern == kwargs['pattern'] and rule.methods == methods
+    filtered_rewrite_rules: List[RewriteRule] = list(filter(rewrite_rule_filter, rewrite_rules))
+
+    if len(filtered_rewrite_rules) == 0:
+        rewrite_rule = RewriteRule({
+            'methods': methods,
+            'pattern': kwargs['pattern'],
+            'parameter_rules': [__select_parameter_rule(kwargs)]
+        })
+        rewrite_rules.append(rewrite_rule)
+        settings.proxy.rewrite.set_rewrite_rules(project_key.id, rewrite_rules)
+    else:
+        parameter_rule_filter = lambda rule: rule.name == kwargs['name'] and rule.type == kwargs['type'] and rule.modes == modes
+        for rewrite_rule in filtered_rewrite_rules:
+            parameter_rules = rewrite_rule.parameter_rules
+            filtered_parameter_rules: List[ParameterRule] = list(filter(parameter_rule_filter, parameter_rules))
+            parameter_rule_dict = __select_parameter_rule(kwargs)
+
+            if len(filtered_parameter_rules) == 0:
+                parameter_rule = ParameterRule(parameter_rule_dict)
+                parameter_rules.append(parameter_rule)
+                rewrite_rule.parameter_rules = parameter_rules
+            else:
+                for parameter_rule in filtered_parameter_rules:
+                    parameter_rule.update(parameter_rule_dict)
+
+    settings.commit()
+
+    Logger.instance().debug(f"Rewrite {kwargs['name']} -> {kwargs['value']} set!")
+
+### API Key
+
+@click.group(
+    help="Manage API key"
+)
+@click.pass_context
+def api_key(ctx):
+    pass
 
-        api_key = kwargs['api_key']
-        settings.remote.api_key = api_key
+@api_key.command(
+    help="Set API Key"
+)
+@click.argument('api_key')
+def set(**kwargs):
+    settings = Settings.instance()
+
+    api_key = kwargs['api_key']
+    settings.remote.api_key = api_key
 
-        settings.commit()
+    settings.commit()
 
-        print("API Key updated!")
+    print("API Key updated!")
 
+is_remote = Settings.instance().cli.features.remote
+if is_remote:
     @click.group(
-        help="Manage rewrite rules."
+        help="Manage active project"
     )
     @click.pass_context
-    def rewrite(ctx):
+    def project(ctx):
         pass
 
-    @rewrite.command(
-        help="Set rewrite rule."
-    )
-    @click.option(
-        '--method', 
-        multiple=True, 
-        required=True,
-        type=click.Choice(['GET', 'POST', 'DELETE', 'OPTIONS', 'PUT']), 
-        help='HTTP methods.'
+    @project.command(
+        help="Use local project."
     )
-    @click.option(
-        '--mode',
-        multiple=True,
-        required=True,
-        type=click.Choice([mode.MOCK, mode.RECORD, mode.REPLAY, mode.TEST])
+    def local(**kwargs):
+        project_key = ProjectKey.local_key
+        __set_project_key(project_key)
+
+        print("Using local project!")
+
+    @project.command(
+        help="Describe project."
     )
-    @click.option('--name', required=True, help='Name of the request component.')
-    @click.option('--pattern', required=True, help='URLs pattern.')
-    @click.option('--project_key', help='Project to add rewrite rule to.')
-    @click.option(
-        '--type', 
-        required=True,
-        type=click.Choice([request_component.BODY_PARAM, request_component.HEADER, request_component.QUERY_PARAM]), 
-        help='Request component type.'
+    @click.option('--select', multiple=True, help='Select column(s) to display.')
+    @click.option('--without-headers', is_flag=True, default=False, help='Disable printing column headers.')
+    def show(**kwargs):
+        settings = Settings.instance()
+        print_options = select_print_options(kwargs)
+
+        project_key = __project_key(settings)
+        if project_key.is_local:
+            return print('Using local project')
+
+        kwargs['project_key'] = project_key.raw
+
+        project_key = resolve_project_key_and_validate(kwargs, settings)
+        project = ProjectFacade(settings)
+
+        try:
+            project_response = project.show(project_key)
+        except AssertionError as e:
+            return print(e, file=sys.stderr)
+
+        print_projects([project_response], **print_options)
+
+    @project.command(
+        help="Set active project."
     )
-    @click.option('--value', required=True, help='Rewrite value.')
+    @click.argument('project_key')
     def set(**kwargs):
-        settings = Settings.instance()
-        project_key_str = resolve_project_key_and_validate(kwargs, settings)
-        project_key = ProjectKey(project_key_str)
-
-        methods = list(kwargs['method'])
-        modes = list(kwargs['mode'])
-    
-        rewrite_rules = settings.proxy.rewrite.rewrite_rules(project_key.id)
-
-        rewrite_rule_filter = lambda rule: rule.pattern == kwargs['pattern'] and rule.methods == methods
-        filtered_rewrite_rules: List[RewriteRule] = list(filter(rewrite_rule_filter, rewrite_rules))
-
-        if len(filtered_rewrite_rules) == 0:
-            rewrite_rule = RewriteRule({
-                'methods': methods,
-                'pattern': kwargs['pattern'],
-                'parameter_rules': [__select_parameter_rule(kwargs)]
-            })
-            rewrite_rules.append(rewrite_rule)
-            settings.proxy.rewrite.set_rewrite_rules(project_key.id, rewrite_rules)
-        else:
-            parameter_rule_filter = lambda rule: rule.name == kwargs['name'] and rule.type == kwargs['type'] and rule.modes == modes
-            for rewrite_rule in filtered_rewrite_rules:
-                parameter_rules = rewrite_rule.parameter_rules
-                filtered_parameter_rules: List[ParameterRule] = list(filter(parameter_rule_filter, parameter_rules))
-                parameter_rule_dict = __select_parameter_rule(kwargs)
-
-                if len(filtered_parameter_rules) == 0:
-                    parameter_rule = ParameterRule(parameter_rule_dict)
-                    parameter_rules.append(parameter_rule)
-                    rewrite_rule.parameter_rules = parameter_rules
-                else:
-                    for parameter_rule in filtered_parameter_rules:
-                        parameter_rule.update(parameter_rule_dict)
-
-        settings.commit()
-
-        Logger.instance().debug(f"Rewrite {kwargs['name']} -> {kwargs['value']} set!")
-
-    config.add_command(api_key)
+        project_key = kwargs['project_key']
+
+        __set_project_key(project_key)
+
+        print("Project updated!")
+
     config.add_command(project)
-    config.add_command(rewrite)
-    config.add_command(scenario)
+
+config.add_command(api_key)
+config.add_command(rewrite)
+config.add_command(scenario)
 
 def __select_parameter_rule(kwargs):
     return {
@@ -213,4 +279,28 @@ def __select_parameter_rule(kwargs):
         'name': kwargs['name'],
         'value': kwargs['value'],
         'type': kwargs['type'],
-    }
+    }
+
+def __project_key(settings):
+    project_key = settings.proxy.intercept.project_key
+    validate_project_key(project_key)
+    return ProjectKey(project_key)
+
+def __set_project_key(project_key: str):
+    settings = Settings.instance()
+    validate_project_key(project_key)
+    _project_key = ProjectKey(project_key)
+
+    data_rule = settings.proxy.data.data_rules(_project_key.id)
+    scenario_key = data_rule.scenario_key
+
+    if scenario_key:
+        validate_scenario_key(scenario_key)
+        scenario_key = ScenarioKey(scenario_key)
+
+        if project_key.id != scenario_key.project_id:
+            data_rule.scenario_key = None
+            print("Current scenario does not belong to current project, unsetting current scenario.\n")
+
+    settings.proxy.intercept.project_key = project_key 
+    settings.commit()

stoobly_agent/app/cli/dev_tools_cli.py

@@ -1,5 +1,7 @@
 import click
 import pdb
+
+from stoobly_agent import VERSION
 from stoobly_agent.app.proxy.replay.body_parser_service import decode_response
 from stoobly_agent.app.models.adapters.raw_http_response_adapter import RawHttpResponseAdapter
 from stoobly_agent.lib.orm.migrate_service import migrate as database_migrate, rollback as database_rollback
@@ -26,7 +28,7 @@ def debug(**kwargs):
 
 @dev_tools.command()
 def migrate():
-  database_migrate()
+  database_migrate(VERSION)
 
 @dev_tools.command()
 def rollback():

stoobly_agent/app/cli/helpers/__init__.py

@@ -1,2 +1,3 @@
 from .project_facade import ProjectFacade
-from .run_command_service import run_command, run_command_with_proxy_export
+from .run_command_service import run_command, run_command_with_proxy_export
+from .scenario_facade import ScenarioFacade

stoobly_agent/app/cli/helpers/context.py

@@ -1,6 +1,8 @@
+import pdb
 import requests
 import time
 
+from stoobly_agent.app.models.adapters.python import PythonRequestAdapterFactory
 from stoobly_agent.app.models.schemas.request import Request
 
 class ReplayContext():
@@ -14,6 +16,11 @@ class ReplayContext():
 
     self.__sequence = None
 
+  @classmethod
+  def from_python_request(cls, request: requests.Request):
+    stoobly_request = PythonRequestAdapterFactory(request).stoobly_request()
+    return cls(Request(stoobly_request))
+
   @property
   def end_time(self):
     return self.__end_time

stoobly_agent/app/cli/helpers/handle_mock_service.py

@@ -0,0 +1,14 @@
+import requests
+
+from stoobly_agent.app.models.adapters.python import PythonResponseAdapterFactory
+from stoobly_agent.app.proxy.mitmproxy.response_facade import MitmproxyResponseFacade
+from stoobly_agent.app.proxy.upload.response_string import ResponseString
+
+RAW_FORMAT = 'raw'
+
+def print_raw_response(response: requests.Response):
+  mitmproxy_response = PythonResponseAdapterFactory(response).mitmproxy_response()
+  facade = MitmproxyResponseFacade(mitmproxy_response)
+  response_string = ResponseString(facade, None)
+
+  print(response_string.get().decode())