stoobly-agent 0.33.7__py3-none-any.whl → 0.34.1__py3-none-any.whl

stoobly_agent/__init__.py

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

stoobly_agent/app/cli/dev_tools_cli.py

@@ -5,6 +5,7 @@ import sys
 from stoobly_agent import VERSION
 from stoobly_agent.app.proxy.replay.body_parser_service import decode_response, is_traversable
 from stoobly_agent.app.models.adapters.raw_http_response_adapter import RawHttpResponseAdapter
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
 from stoobly_agent.lib.orm.migrate_service import migrate as database_migrate, rollback as database_rollback
 from stoobly_agent.lib.orm.replayed_response import ReplayedResponse
 from stoobly_agent.lib.orm.request import Request

stoobly_agent/app/cli/endpoint_cli.py

@@ -1,4 +1,4 @@
-import click
+import click, sys
 
 from stoobly_agent.app.models.types import OPENAPI_FORMAT
 from stoobly_agent.app.settings import Settings
@@ -7,6 +7,7 @@ from stoobly_agent.lib.utils.conditional_decorator import ConditionalDecorator
 
 from .helpers.endpoint_facade import EndpointFacade
 from .helpers.endpoints_apply_context import EndpointsApplyContext
+from .helpers.endpoints_import_context import EndpointsImportContext
 from .helpers.feature_flags import local, remote
 from .helpers.validations import validate_project_key, validate_scenario_key
 
@@ -46,7 +47,7 @@ def apply(**kwargs):
   context.with_lifecycle_hooks_path(kwargs.get('lifecycle_hooks_path'))
   context.with_source(kwargs.get('source_path'), kwargs.get('source_format'))
 
-  endpoint_handler = lambda endpoint: print(f"{bcolors.OKBLUE}Applying Endpoint: {endpoint['path']}{bcolors.ENDC}")
+  endpoint_handler = lambda endpoint: print(f"{bcolors.OKBLUE}Applying Endpoint {endpoint['method']} {endpoint['path']}{bcolors.ENDC}")
   context.with_endpoint_handler(endpoint_handler)
 
   request_handler = lambda request, endpoint: print(request.url)
@@ -54,3 +55,25 @@ def apply(**kwargs):
 
   facade = EndpointFacade(settings)
   facade.apply(context)
+
+@endpoint.command(
+  "import",
+  help="Import endpoints"
+)
+@click.option('--source-format', required=True, type=click.Choice([OPENAPI_FORMAT]), help="Spec file format.")
+@click.option('--source-path', help='Path to spec file.')
+def import_endpoint(**kwargs):
+  context = EndpointsImportContext()
+
+  project_key = settings.proxy.intercept.project_key
+  if project_key:
+    project_key = validate_project_key(project_key)
+    context.with_project(project_key.id)
+  
+  context.with_source(kwargs.get('source_path'), kwargs.get('source_format'))
+
+  endpoint_handler = lambda endpoint: print(f"{bcolors.OKBLUE}Importing Endpoint {endpoint['method']} {endpoint['path']}{bcolors.ENDC}")
+  context.with_endpoint_handler(endpoint_handler)
+  
+  facade = EndpointFacade(settings)
+  facade.import_endpoints(context)

stoobly_agent/app/cli/helpers/endpoint_facade.py

@@ -2,9 +2,17 @@ import pdb
 
 from stoobly_agent.app.models.factories.resource.request import RequestResourceFactory
 from stoobly_agent.app.settings import Settings
+from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
+from stoobly_agent.lib.api.header_names_resource import HeaderNamesResource
+from stoobly_agent.lib.api.body_param_names_resource import BodyParamNamesResource
+from stoobly_agent.lib.api.query_param_names_resource import QueryParamNamesResource
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
+from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderNamesResource
 
 from .endpoints_apply_context import EndpointsApplyContext
+from .endpoints_import_context import EndpointsImportContext
 from .endpoints_apply_service import apply_endpoints
+from .endpoints_import_service import import_endpoints
 from .synchronize_request_service import SynchronizeRequestService
 
 class EndpointFacade():
@@ -22,4 +30,17 @@ class EndpointFacade():
     )
     context.with_request_handler(request_handler)
 
-    apply_endpoints(context)
+    apply_endpoints(context)
+  
+  def import_endpoints(self, context: EndpointsImportContext):
+    api_url = self.__settings.remote.api_url
+    api_key = self.__settings.remote.api_key
+
+    context.with_endpoint_resource(EndpointsResource(api_url, api_key))
+    context.with_header_name_resource(HeaderNamesResource(api_url, api_key))
+    context.with_body_param_name_resource(BodyParamNamesResource(api_url, api_key))
+    context.with_query_param_name_resource(QueryParamNamesResource(api_url, api_key))
+    context.with_response_param_name_resource(ResponseParamNamesResource(api_url, api_key))
+    context.with_response_header_name_resource(ResponseHeaderNamesResource(api_url, api_key))
+
+    import_endpoints(context)

stoobly_agent/app/cli/helpers/endpoints_import_context.py

@@ -0,0 +1,57 @@
+from typing import Callable, TypedDict
+
+from .openapi_endpoint_adapter import OpenApiEndpointAdapter
+from stoobly_agent.app.models.types import OPENAPI_FORMAT
+from stoobly_agent.lib.api.body_param_names_resource import BodyParamNamesResource
+from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
+from stoobly_agent.lib.api.header_names_resource import HeaderNamesResource
+from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
+from stoobly_agent.lib.api.query_param_names_resource import QueryParamNamesResource
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
+from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderNamesResource
+
+class EndpointsImportContext:
+  def __init__(self):
+    self.endpoints = []
+    self.endpoint_handlers = []
+    self.resources = {}
+    self.project_id = None
+
+  def with_endpoint_handler(self, handler: Callable[[EndpointShowResponse], None]):
+    self.endpoint_handlers.append(handler)
+    return self
+  
+  def with_project(self, project_id: int):
+    self.project_id = project_id
+    return self
+  
+  def with_endpoint_resource(self, resource: EndpointsResource):
+    self.resources['endpoint'] = resource
+    return self
+  
+  def with_header_name_resource(self, resource: HeaderNamesResource):
+    self.resources['header_name'] = resource
+    return self
+
+  def with_body_param_name_resource(self, resource: BodyParamNamesResource):
+    self.resources['body_param_name'] = resource
+    return self
+
+  def with_query_param_name_resource(self, resource: QueryParamNamesResource):
+    self.resources['query_param_name'] = resource
+    return self
+
+  def with_response_param_name_resource(self, resource: ResponseParamNamesResource):
+    self.resources['response_param_name'] = resource
+    return self
+  
+  def with_response_header_name_resource(self, resource: ResponseHeaderNamesResource):
+    self.resources['response_header_name'] = resource
+    return self
+
+  def with_source(self, path: str, format: str):
+    if format == OPENAPI_FORMAT:
+      endpoint_adapter = OpenApiEndpointAdapter()
+      self.endpoints += endpoint_adapter.adapt_from_file(path)
+
+    return self

stoobly_agent/app/cli/helpers/endpoints_import_service.py

@@ -0,0 +1,152 @@
+import json
+import requests
+import sys
+from typing import Dict
+
+from .endpoints_import_context import EndpointsImportContext
+from stoobly_agent.app.models.types import ENDPOINT_COMPONENT_NAMES
+from stoobly_agent.lib.api.body_param_names_resource import BodyParamNamesResource
+from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
+from stoobly_agent.lib.api.header_names_resource import HeaderNamesResource
+from stoobly_agent.lib.api.interfaces.endpoints import BodyParamName
+from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
+from stoobly_agent.lib.api.interfaces.endpoints import RequestComponentName
+from stoobly_agent.lib.api.query_param_names_resource import QueryParamNamesResource
+from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderNamesResource
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
+from stoobly_agent.lib.logger import bcolors
+
+def import_endpoints(context: EndpointsImportContext):
+    for endpoint in context.endpoints:
+        for endpoint_handler in context.endpoint_handlers:
+            endpoint_handler(endpoint)
+
+        try:
+            res = import_endpoint(context.project_id, context.resources['endpoint'], endpoint)
+        except requests.HTTPError as e:
+            error_handler(e, f"Failed to import endpoint: {endpoint['method']} {endpoint['path']}")
+            return
+        
+        if res.status_code == 409: # Endpoint already created
+            continue
+
+        endpoint_id = res.json()['id']
+        try:
+            res = import_component_names(context.project_id, endpoint_id, endpoint, context.resources)
+        except requests.HTTPError as e:
+            error_handler(e, f"Failed to import endpoint: {endpoint['method']} {endpoint['path']}")
+
+            try:
+                cleanup_endpoint(context.project_id, endpoint_id, context.resources['endpoint'])
+            except requests.HTTPError as e:
+                error_handler(e, f"Failed to delete endpoint: {endpoint['method']} {endpoint['path']}, id {endpoint_id}")
+            return
+
+def import_endpoint(project_id: int, endpoint_resource: EndpointsResource, endpoint: EndpointShowResponse):
+    res: requests.Response = endpoint_resource.create(**{
+        'host': endpoint.get('host'),
+        'method': endpoint.get('method'),
+        'path_segments': json.dumps(endpoint.get('path_segment_names', [])),
+        'path': endpoint.get('path'),
+        'port': endpoint.get('port'),
+        'project_id': project_id,
+    })
+
+    if res.ok or res.status_code == 409: # Endpoint already created
+        return res
+    
+    res.raise_for_status()
+
+def import_header_name(project_id: int, endpoint_id: int, header_name_resource: HeaderNamesResource, header_name: RequestComponentName): 
+    res: requests.Response = header_name_resource.create(endpoint_id, {
+        'name': header_name.get('name'),
+        'is_deterministic': header_name.get('is_deterministic', True),
+        'is_required': header_name.get('is_required', False),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,  
+    })
+
+    res.raise_for_status()
+
+def import_body_param_name(project_id: int, endpoint_id: int, body_param_name_resource: BodyParamNamesResource, body_param_name: BodyParamName):
+    res: requests.Response = body_param_name_resource.create(endpoint_id, {
+        'name': body_param_name.get('name'),
+        'is_deterministic': body_param_name.get('is_deterministic', True),
+        'is_required': body_param_name.get('is_required', False),
+        'inferred_type': body_param_name.get('inferred_type'),
+        'query': body_param_name.get('query'),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,
+    })
+
+    res.raise_for_status()
+
+def import_query_param_name(project_id: int, endpoint_id: int, query_param_name_resource: QueryParamNamesResource, query_param_name: RequestComponentName):
+    res: requests.Response = query_param_name_resource.create(endpoint_id, {
+        'name': query_param_name.get('name'),
+        'is_deterministic': query_param_name.get('is_deterministic', True),
+        'is_required': query_param_name.get('is_required', False),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,
+    })
+
+    res.raise_for_status()
+
+def import_response_param_name(project_id: int, endpoint_id: int, response_param_name_resource: ResponseParamNamesResource, response_param_name: RequestComponentName):
+    res: requests.Response = response_param_name_resource.create(endpoint_id, {
+        'name': response_param_name.get('name'),
+        'is_deterministic': response_param_name.get('is_deterministic', True),
+        'is_required': response_param_name.get('is_required', False),
+        'inferred_type': response_param_name.get('inferred_type'),
+        'query': response_param_name.get('query'),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,
+    })
+
+    res.raise_for_status()
+
+def import_response_header_name(project_id: int, endpoint_id: int, response_header_name_resource: ResponseHeaderNamesResource, response_header_name: RequestComponentName):
+    res: requests.Response = response_header_name_resource.create(endpoint_id, {
+        'name': response_header_name.get('name'),
+        'is_deterministic': response_header_name.get('is_deterministic', True),
+        'is_required': response_header_name.get('is_required', False),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,  
+    })
+
+    res.raise_for_status()
+
+component_name_import_dispatch = {
+    ENDPOINT_COMPONENT_NAMES[0]: import_header_name,
+    ENDPOINT_COMPONENT_NAMES[1]: import_body_param_name,
+    ENDPOINT_COMPONENT_NAMES[2]: import_query_param_name,
+    ENDPOINT_COMPONENT_NAMES[3]: import_response_header_name,
+    ENDPOINT_COMPONENT_NAMES[4]: import_response_param_name
+}
+
+def process_import(component_name: str, *args):
+    return component_name_import_dispatch[component_name](*args)
+
+def import_component_names(project_id: int, endpoint_id: int, endpoint: EndpointShowResponse, resources: Dict[str, EndpointsResource]):
+    for component_name in ENDPOINT_COMPONENT_NAMES:
+        for component in endpoint.get(f'{component_name}s', {}):
+            resource = resources[component_name]
+            process_import(component_name, project_id, endpoint_id, resource, component)
+
+def cleanup_endpoint(project_id: int, endpoint_id: int, resource: EndpointsResource):
+    print(f"{bcolors.OKBLUE}Cleaning up partial import...{bcolors.ENDC}")
+    res: requests.Response = resource.destroy(endpoint_id, **{
+        'project_id': project_id
+    })
+
+    res.raise_for_status()
+
+def error_handler(error: requests.HTTPError, message = ''):
+    if message:
+        print(
+            f"{bcolors.FAIL}{message}{bcolors.ENDC}",
+            file=sys.stderr
+        )
+
+    print(error.response.text, file=sys.stderr)
+    print(f"Error {error.response.status_code} {error.response.reason}", file=sys.stderr)

stoobly_agent/app/cli/helpers/openapi_endpoint_adapter.py

@@ -73,19 +73,32 @@ class OpenApiEndpointAdapter():
           endpoint: EndpointShowResponse = {}
           endpoint['id'] = endpoint_counter
           endpoint['method'] = http_method.upper()
-          endpoint['host'] = parsed_url.netloc
+          endpoint['host'] = '-' if parsed_url.netloc == '' else parsed_url.netloc
 
           joined_path = self.__urljoin(parsed_url.path, path_name)
           split_parts = joined_path.split('/')
           pattern_path = []
+          segment_names = []
           for part in split_parts:
             sanitized_part = part
+            segment_name = part
             if part.startswith('{') and part.endswith('}'):
               sanitized_part = '%' 
+              segment_name = f":{part[1:-1]}"
             pattern_path.append(sanitized_part)
+            segment_names.append(segment_name)
           pattern_path_str = '/'.join(pattern_path)
           endpoint['match_pattern'] = pattern_path_str
           endpoint['path'] = joined_path
+
+          endpoint['path_segment_names'] = []
+          for segment_name in segment_names:
+            if segment_name == "":
+              continue
+            path_component_name: RequestComponentName = {}
+            path_component_name['name'] = segment_name
+            path_component_name['type'] = "alias" if segment_name.startswith(':') else "static"
+            endpoint['path_segment_names'].append(path_component_name)
           
           endpoint['port'] = str(parsed_url.port)
           if endpoint['port'] is None or endpoint['port'] == 'None':
@@ -94,7 +107,7 @@ class OpenApiEndpointAdapter():
             elif parsed_url.scheme == 'http':
               endpoint['port'] = '80'
             else:
-              endpoint['port'] = ''
+              endpoint['port'] = '0'
 
           alias_counter = 0
           header_param_counter = 0
@@ -142,7 +155,10 @@ class OpenApiEndpointAdapter():
                   param_value = self.__open_api_to_default_python_type(open_api_type)
 
               literal_query_param = {
-                parameter['name']: {'value': param_value}
+                parameter['name']: {
+                  'value': param_value,
+                  'required': parameter.get('required', False),
+                }
               }
 
               if not endpoint.get('literal_query_params'):
@@ -238,6 +254,11 @@ class OpenApiEndpointAdapter():
             else:
               self.__convert_literal_component_param(endpoint, required_body_params, [literal_body_params], 'body_param_name', 'literal_body_params')
 
+          # Responses -> construct lists of response header and response param name resources
+          responses = operation.get('responses', {})
+          if responses:
+            self.__parse_responses(endpoint, responses, components)
+
           endpoints.append(endpoint)
     
     return endpoints
@@ -391,11 +412,30 @@ class OpenApiEndpointAdapter():
       component_name = component_data[1]
       component = components.get(component_type, {})
 
+      # If component_type is 'headers'
+      # Example: '#components/headers/X-RateLimit-Limit'
+      if component_type == "headers":
+        # In this case, literal_body_params represents a header rather than request or response body params
+        literal_body_params['name'] = component_name
+        header_example = component.get('example')
+        if header_example:
+          literal_body_params['values'].append(header_example)
+        literal_body_params['is_required'] = component.get('is_required', False)
+        literal_body_params['is_deterministic'] = True
+        return literal_body_params
+
       # Example: {'type': 'object', 'required': ['name'], 'properties': {'name': {'type': 'string'}, 'tag': {'type': 'string'}}}
       body_spec = component.content()[component_name]
       required_body_params += body_spec.get('required', [])
 
-      param_properties = body_spec.get('properties')
+      param_properties = {}
+      schema_type = body_spec.get('type')
+      if schema_type:
+        if schema_type == 'object':
+          param_properties = body_spec.get('properties', {})
+        elif schema_type == 'array':
+          param_properties = {'tmp': body_spec['items']}
+
       all_of = body_spec.get('allOf')
       any_of = body_spec.get('anyOf')
       one_of = body_spec.get('oneOf')
@@ -421,7 +461,7 @@ class OpenApiEndpointAdapter():
       # elif any_of or one_of:
 
       return param_properties 
-
+  
   def __convert_literal_component_param(self, endpoint: EndpointShowResponse,
       required_component_params: List[str], literal_component_params: Union[dict, list],
       component_name: str, literal_component_name: str) -> None:
@@ -444,7 +484,11 @@ class OpenApiEndpointAdapter():
       else:
         param['is_required'] = False
 
-    endpoint[component_name + 's'] = built_params_list
+    if not endpoint.get(component_name + 's'):
+      endpoint[component_name + 's'] = built_params_list
+    else:
+      endpoint[component_name + 's'].extend(built_params_list)
+
     del endpoint[literal_component_name]
 
   # urllib.parse.urljoin() doesn't work for some of our edge cases
@@ -557,3 +601,64 @@ class OpenApiEndpointAdapter():
     
     return result
 
+  def __parse_responses(self, endpoint: EndpointShowResponse, responses: Spec, components: Spec):
+    for response_code, response_definition in responses.items():
+      # Construct response param name components
+      literal_response_params = {}
+      response_body_array = False
+      required_response_params = []
+      response_content = response_definition.get('content', {})
+      for mimetype, media_type in response_content.items():
+        param_properties = {}
+        schema = media_type['schema']
+        
+        if '$ref' in schema:
+          reference = schema['$ref']
+          self.__dereference(components, reference, required_response_params, literal_response_params)
+        else:
+          schema_type = schema.get('type')
+          if schema_type:
+            if schema_type == 'object':
+              param_properties = schema.get('properties', {})
+            elif schema_type == 'array':
+              response_body_array = True
+              param_properties = {'tmp': schema['items']}
+        
+        for property_key, property_value in param_properties.items():
+          if property_key in required_response_params:
+            param_properties[property_key]['required'] = True
+          
+        self.__extract_param_properties(components, None, required_response_params, param_properties, literal_response_params)
+
+        if literal_response_params:
+          endpoint['literal_response_params'] = literal_response_params
+
+        # Only support first media type
+        break
+      
+      literal_response_params = endpoint.get('literal_response_params')
+      if literal_response_params:
+        if not response_body_array:
+          self.__convert_literal_component_param(endpoint, required_response_params, literal_response_params, 'response_param_name', 'literal_response_params')
+        else:
+          self.__convert_literal_component_param(endpoint, required_response_params, [literal_response_params], 'response_param_name', 'literal_response_params')
+
+      # Construct response header name components
+      response_headers = response_definition.get('headers', {})
+      for header_name, header_definition in response_headers.items():
+        response_header_name: RequestComponentName = {}
+        response_header_name['name'] = header_name
+        
+        if '$ref' in header_definition:
+          reference = header_definition['$ref']
+          self.__dereference(components, reference, [], response_header_name)
+        else:
+          header_example = header_definition.get('example')
+          if header_example:
+            response_header_name['values'].append(header_example)
+          response_header_name['is_required'] = header_definition.get('is_required', False)
+          response_header_name['is_deterministic'] = True
+          
+        if not endpoint.get('response_header_names'):
+          endpoint['response_header_names'] = []
+        endpoint['response_header_names'].append(response_header_name)	  

stoobly_agent/app/cli/helpers/replay_facade.py

@@ -17,7 +17,9 @@ class ReplayCliOptions(TypedDict):
   lifecycle_hooks_path: str
   on_response: Callable
   project_key: str
+  public_directory_path: str
   record: bool
+  response_fixtures_path: str
   scenario_key: str
   scheme: str
   trace: Trace
@@ -57,7 +59,9 @@ class ReplayFacade():
       'host': cli_options.get('host'),
       'lifecycle_hooks_path': cli_options.get('lifecycle_hooks_path'),
       'overwrite': cli_options.get('overwrite'),
+      'public_directory_path': cli_options.get('public_directory_path'),
       'request_origin': request_origin.CLI,
+      'response_fixtures_path': cli_options.get('response_fixtures_path'),
       'save': cli_options.get('save'),
       'scheme': cli_options.get('scheme'),
       'trace_context': trace_context,

stoobly_agent/app/cli/request_cli.py

@@ -134,8 +134,10 @@ if not is_remote:
     Configure which tests to print. Defaults to {test_output_level.PASSED}.
   '''
 )
+@click.option('--public-directory-path', help='Path to public files. Used for mocking requests.')
 @ConditionalDecorator(lambda f: click.option('--remote-project-key', help='Use remote project for endpoint definitions.')(f), is_remote and is_local)
 @ConditionalDecorator(lambda f: click.option('--report-key', help='Save to report.')(f), is_remote)
+@click.option('--response-fixtures-path', help='Path to response fixtures yaml. Used for mocking requests.')
 @ConditionalDecorator(lambda f: click.option('--save', is_flag=True, default=False, help='Saves test results.')(f), is_remote)
 @click.option('--scheme', type=click.Choice(['http', 'https']), help='Rewrite request scheme.')
 @click.option('--strategy', default=test_strategy.DIFF, type=click.Choice([test_strategy.CONTRACT, test_strategy.CUSTOM, test_strategy.DIFF, test_strategy.FUZZY]), help='How to test responses.')

stoobly_agent/app/cli/scenario_cli.py

@@ -158,8 +158,10 @@ if is_local:
     Configure which tests to print. Defaults to {test_output_level.PASSED}.
   '''
 )
+@click.option('--public-directory-path', help='Path to public files. Used for mocking requests.')
 @ConditionalDecorator(lambda f: click.option('--remote-project-key', help='Use remote project for endpoint definitions.')(f), is_remote)
 @ConditionalDecorator(lambda f: click.option('--report-key', help='Save results to report.')(f), is_remote)
+@click.option('--response-fixtures-path', help='Path to response fixtures yaml. Used for mocking requests.')
 @ConditionalDecorator(lambda f: click.option('--save', is_flag=True, default=False, help='Save results.')(f), is_remote)
 @click.option('--scheme', help='Rewrite request scheme.')
 @click.option(

stoobly_agent/app/cli/types/test.py

@@ -15,8 +15,10 @@ class TestOptions(TypedDict):
   lifecycle_hooks_path: str
   log_level: logger.LogLevel
   output_level: test_output_level.TestOutputLevel
+  public_directory_path: str
   remote_project_key: str
   report_key: str
+  response_fixtures_path: str
   save: str
   scheme: str
   strategy: test_strategy.TestStrategy

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

@@ -35,7 +35,7 @@ class RequestBuilder():
 
   @property
   def request_body(self):
-    return self.__properties.get('request_body')
+    return self.__properties.get('request_body') or b''
 
   @property
   def request_headers(self):

stoobly_agent/app/models/types/endpoint.py

@@ -1,7 +1,33 @@
-from typing import Literal, TypedDict
+from typing import TypedDict
 
 OPENAPI_FORMAT = 'openapi'
 
+ENDPOINT_COMPONENT_NAMES = [
+  "header_name",
+  "body_param_name",
+  "query_param_name",
+  "response_header_name",
+  "response_param_name"
+]
+
 class EndpointCreateParams(TypedDict):
-  format: Literal[f"{OPENAPI_FORMAT}"]
+  host: str
+  method: str
+  path_segments: str
   path: str
+  port: str
+  project_id: str
+
+class HeaderNameCreateParams(TypedDict):
+  name: str
+  is_required: bool
+  is_deterministic: bool
+  project_id: str
+  endpoint_id: int
+	
+class ParamNameCreateParams(TypedDict):
+  name: str
+  project_id: str
+  endpoint_id: int
+  inferred_type: str
+  query: str

stoobly_agent/app/proxy/handle_mock_service.py

@@ -14,6 +14,7 @@ from stoobly_agent.lib.logger import Logger
 
 from .constants import custom_response_codes
 from .mock.context import MockContext
+from .mock.eval_fixtures_service import eval_fixtures
 from .mock.eval_request_service import inject_eval_request
 from .utils.allowed_request_service import get_active_mode_policy
 from .utils.request_handler import reverse_proxy
@@ -65,14 +66,14 @@ def handle_request_mock_generic(context: MockContext, **options: MockOptions):
         if handle_failure:
             res = handle_failure(context)
     elif policy == mock_policy.ALL:
-        res = eval_request_with_retry(eval_request, request, **options) 
+        res = eval_request_with_retry(context, eval_request, **options) 
 
         context.with_response(res)
 
         if handle_success:
             res = handle_success(context) or res
     elif policy == mock_policy.FOUND:
-        res = eval_request_with_retry(eval_request, request, **options) 
+        res = eval_request_with_retry(context, eval_request, **options) 
 
         context.with_response(res)
 
@@ -93,7 +94,8 @@ def handle_request_mock_generic(context: MockContext, **options: MockOptions):
 
     return pass_on(context.flow, res)
 
-def eval_request_with_retry(eval_request, request, **options: MockOptions):
+def eval_request_with_retry(context: MockContext, eval_request, **options: MockOptions):
+    request = context.flow.request
     infer = bool(options.get('infer'))
     ignored_components = options['ignored_components'] if 'ignored_components' in options else []
 
@@ -103,6 +105,16 @@ def eval_request_with_retry(eval_request, request, **options: MockOptions):
         ignored_components.append(res.content)
         res = eval_request(request, ignored_components, infer=infer, retry=1)
 
+    if res.status_code == custom_response_codes.NOT_FOUND:
+        intercept_settings = context.intercept_settings
+        fixture = eval_fixtures(
+            request,
+            public_directory_path=intercept_settings.public_directory_path,
+            response_fixtures=intercept_settings.response_fixtures
+        )
+        if fixture:
+            res = fixture
+
     return res
 
 def handle_request_mock(context: MockContext):