stoobly-agent 1.10.2__py3-none-any.whl → 1.10.3__py3-none-any.whl

stoobly_agent/__init__.py

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

stoobly_agent/app/api/application_http_request_handler.py

@@ -134,7 +134,7 @@ class ApplicationHTTPRequestHandler(SimpleHTTPRequestHandler):
         for endpoint_handler in ROUTES[method]:
             path = endpoint_handler[0]
 
-            matches = self.path == path if isinstance(path, str) else bool(re.match(path, self.path))
+            matches = self.path == path if isinstance(path, str) else bool(re.fullmatch(path, self.path))
 
             if matches:
                 handler = endpoint_handler[1]

stoobly_agent/app/cli/helpers/validations.py

@@ -126,7 +126,7 @@ def validate_aliases(validations, **kwargs) -> Union[Alias, None]:
       handle_missing_alias(parsed_validation, kwargs.get('format'))
 
     if parsed_validation['value'] != None:
-      if not re.match(parsed_validation['value'], aliases_map[name]):
+      if not re.fullmatch(parsed_validation['value'], aliases_map[name]):
         handle_invalid_alias(parsed_validation, aliases_map[name], kwargs.get('format'))
 
 def filter_response(res, status: int):

stoobly_agent/app/cli/scaffold/app.py

@@ -111,7 +111,7 @@ class App():
 
               # Skip files that match the ignore list pattern, use regex
               for ignore_pattern in ignore:
-                  if re.match(os.path.join(src, ignore_pattern), src_file_path):
+                  if re.fullmatch(os.path.join(src, ignore_pattern), src_file_path):
                       ignored = True
                       break
 

stoobly_agent/app/cli/scaffold/service_dependency.py

@@ -37,7 +37,7 @@ class DockerImage:
             (?::(?P<tag>[^@]+))?             # optional :tag
             (?:@(?P<digest>.+))?             # optional @digest
         """
-        match = re.match(pattern, ref, re.VERBOSE)
+        match = re.fullmatch(pattern, ref, re.VERBOSE)
         if not match:
             raise ValueError(f"Invalid Docker image reference: {ref}")
         

stoobly_agent/app/cli/scaffold/templates/app/.docker-compose.base.yml

@@ -4,6 +4,6 @@ services:
       service: stoobly_base
     volumes:
       - ${CONTEXT_DIR}/.stoobly:/home/stoobly/.stoobly
-      - ${APP_DIR}/.stoobly/docker:/home/stoobly/.stoobly/docker
+      - ${APP_DIR}/.stoobly/services:/home/stoobly/.stoobly/services
   stoobly_base:
     image: stoobly.${USER_ID}

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -170,7 +170,7 @@ class MitmproxyRequestFacade(Request):
         pattern = rewrite_rule.pattern
 
         try:
-            url_matches = re.match(pattern, self.url)
+            url_matches = re.fullmatch(pattern, self.url)
         except re.error as e:
             Logger.instance().error(f"RegExp error '{e}' for {pattern}")
             return False

stoobly_agent/app/proxy/mock/eval_fixtures_service.py

@@ -58,12 +58,9 @@ def eval_fixtures(request: MitmproxyRequest, **options: MockOptions) -> Union[Re
             continue
         
         # Try to find the file in this directory
-        _fixture_path = os.path.join(dir_path_config['path'], request_path.lstrip('/'))
+        fixture_path = os.path.join(dir_path_config['path'], request_path.lstrip('/'))
         if request.headers.get('accept'):
-          fixture_path = __guess_file_path(_fixture_path, request.headers['accept'])
-        
-        if not fixture_path:
-          fixture_path = _fixture_path
+          fixture_path = __guess_file_path(fixture_path, request.headers['accept'])
         
         if os.path.isfile(fixture_path):
           break
@@ -74,15 +71,31 @@ def eval_fixtures(request: MitmproxyRequest, **options: MockOptions) -> Union[Re
         return
     else:
       fixture_path = fixture.get('path')
-      if not fixture_path or not os.path.isfile(fixture_path):
+      if not fixture_path:
         return
 
+      if os.path.isdir(fixture_path):
+        request_path = request.path
+        match = re.match(fixture.get('path_pattern', request_path), request_path)
+
+        if not match or match.end() == len(request_path):
+          sub_path = 'index'
+        else:
+          sub_path = request_path[match.end():]
+
+        fixture_path = os.path.join(fixture_path, sub_path.lstrip('/'))
+        if request.headers.get('accept'):
+          fixture_path = __guess_file_path(fixture_path, request.headers['accept'])
+        
+      if not os.path.isfile(fixture_path):
+        return
+        
       _headers = fixture.get('headers')
       headers = CaseInsensitiveDict(_headers if isinstance(_headers, dict) else {}) 
 
       if fixture.get('status_code'):
         status_code = fixture.get('status_code')
-    
+
   with open(fixture_path, 'rb') as fp:
     response = Response()
 
@@ -158,13 +171,13 @@ def __guess_content_type(file_path):
     return
   return mimetypes.types_map.get(file_extension)
 
-def __guess_file_path(file_path, content_type):
+def __guess_file_path(file_path: str, content_type):
   file_extension = os.path.splitext(file_path)[1]
   if file_extension:
     return file_path
 
   if not content_type:
-    return
+    return file_path
 
   content_types = __parse_accept_header(content_type)
 
@@ -178,6 +191,8 @@ def __guess_file_path(file_path, content_type):
     if os.path.isfile(_file_path):
       return _file_path
 
+  return file_path
+
 def __find_fixture_for_request(request: MitmproxyRequest, fixtures: dict, method: str):
   """Find a fixture for the given request in the provided fixtures."""
   if not fixtures:
@@ -193,7 +208,7 @@ def __find_fixture_in_routes(fixtures: dict, method: str, request_path: str):
     return None
 
   for path_pattern in routes:
-    if not re.match(path_pattern, request_path):
+    if not re.fullmatch(path_pattern, request_path):
       continue
       
     fixture = routes[path_pattern]
@@ -203,6 +218,7 @@ def __find_fixture_in_routes(fixtures: dict, method: str, request_path: str):
     path = fixture.get('path')
 
     if path:
+      fixture['path_pattern'] = path_pattern
       return fixture
   
   return None
@@ -211,6 +227,9 @@ def __choose_highest_priority_content_type(accept_header: str) -> Optional[str]:
     if not accept_header:
         return None
 
+    if accept_header == '*/*':
+      return 'text/plain'
+
     types = []
     for part in accept_header.split(","):
         media_range = part.strip()
@@ -234,9 +253,13 @@ def __choose_highest_priority_content_type(accept_header: str) -> Optional[str]:
     return types[0][0] if types else None
 
 def __origin_matches(pattern: str, request_origin: str) -> bool:
-    return bool(re.match(pattern, request_origin))
+    return bool(re.fullmatch(pattern, request_origin))
 
 def __parse_accept_header(accept_header):
+    # In the case accept_header is */*, default to html and json file types
+    if accept_header == '*/*':
+      return ['text/html', 'application/json']
+
     types = []
     for item in accept_header.split(","):
         parts = item.split(";")

stoobly_agent/app/proxy/mock/eval_request_service.py

@@ -202,7 +202,7 @@ def __filter_by_match_rules(request: MitmproxyRequest, match_rules: List[MatchRu
 
 def __matches(url: str, pattern: str):
     try:
-        return re.match(pattern, url)
+        return re.fullmatch(pattern, url)
     except re.error as e:
         Logger.instance().error(f"RegExp error '{e}' for {pattern}")
         return False

stoobly_agent/app/proxy/utils/allowed_request_service.py

@@ -80,7 +80,7 @@ def __include(request: MitmproxyRequest, patterns: List[str]) -> bool:
 
     for pattern in patterns:
         try:
-            if re.match(pattern, request.url):
+            if re.fullmatch(pattern, request.url):
                 return True
         except re.error as e:
             Logger.instance(LOG_ID).error(f"RegExp error '{e}' for {pattern}")
@@ -94,7 +94,7 @@ def __exclude(request: MitmproxyRequest, patterns: List[str]) -> bool:
 
     for pattern in patterns:
         try:
-            if re.match(pattern, request.url):
+            if re.fullmatch(pattern, request.url):
                 return True
         except re.error as e:
             Logger.instance(LOG_ID).error(f"RegExp error '{e}' for {pattern}")

stoobly_agent/lib/cache.py

@@ -32,7 +32,7 @@ class Cache:
         else:
             delete_list = []
             for key in self.data.keys():
-                if re.match(pattern, key):
+                if re.fullmatch(pattern, key):
                     delete_list.append(key)
             
             for key in delete_list:

stoobly_agent/test/app/models/schemas/.stoobly/db/VERSION

@@ -1 +1 @@
-1.10.1
+1.10.2

stoobly_agent/test/app/proxy/mitmproxy/request_facade_test.py

@@ -27,6 +27,24 @@ def mitmproxy_get_request():
     now + 1,
   )
 
+@pytest.fixture
+def mitmproxy_get_request_details():
+  now = time()
+  return MitmproxyRequest(
+    'stoobly.com',
+    443,
+    b'GET',
+    b'https',
+    b'stoobly.com:443',
+    b'/requests/1?project_id=1',
+    b'HTTP/1.1',
+    Headers(**{'access-token': b'123'}),
+    b'',
+    Headers(), # Trailers
+    now,
+    now + 1,
+  )
+
 @pytest.fixture
 def mitmproxy_post_request():
   now = time()
@@ -45,6 +63,28 @@ def mitmproxy_post_request():
     now + 1,
   )
 
+class TestDoesNotRewrite():
+
+  def test_does_not_rewrite_header(self, mitmproxy_get_request_details: MitmproxyRequest):
+    parameter_rule = {
+      'modes': [intercept_mode.RECORD],
+      'name': 'access-token',
+      'type': request_component.HEADER,
+      'value': '',
+    }
+    rewrite_rule = RewriteRule({
+      'methods': ['GET'],
+      'pattern': '.*?/requests',
+      'parameter_rules': [parameter_rule]
+    })
+
+    facade = MitmproxyRequestFacade(mitmproxy_get_request_details)
+    facade.with_parameter_rules([rewrite_rule])
+    facade.rewrite()
+
+    headers = facade.headers
+    assert headers['access-token'] != ''
+
 class TestRewriteParams():
 
   def test_rewrites_header(self, mitmproxy_get_request: MitmproxyRequest):
@@ -56,7 +96,7 @@ class TestRewriteParams():
     }
     rewrite_rule = RewriteRule({
       'methods': ['GET'],
-      'pattern': '.*?/requests',
+      'pattern': '.*?/requests(?:\?.*)?',
       'parameter_rules': [parameter_rule]
     })
 
@@ -76,7 +116,7 @@ class TestRewriteParams():
     }
     rewrite_rule = RewriteRule({
       'methods': ['GET'],
-      'pattern': '.*?/requests',
+      'pattern': '.*?/requests(?:\?.*)?',
       'parameter_rules': [parameter_rule]
     })
 
@@ -96,7 +136,7 @@ class TestRewriteParams():
     }
     rewrite_rule = RewriteRule({
       'methods': ['POST'],
-      'pattern': '.*?/users',
+      'pattern': '.*?/users(?:\?.*)?',
       'parameter_rules': [parameter_rule]
     })
 
@@ -118,7 +158,7 @@ class TestRewriteUrl():
     }
     rewrite_rule = RewriteRule({
       'methods': ['GET'],
-      'pattern': '.*?/requests',
+      'pattern': '.*?/requests(?:\?.*)?',
       'url_rules': [url_rule]
     })
 
@@ -139,7 +179,7 @@ class TestRewriteUrl():
     }
     rewrite_rule = RewriteRule({
       'methods': ['GET'],
-      'pattern': '.*?/requests',
+      'pattern': '.*?/requests(?:\?.*)?',
       'url_rules': [url_rule]
     })
 
@@ -162,7 +202,7 @@ class TestRewriteUrl():
     }
     rewrite_rule = RewriteRule({
       'methods': ['GET'],
-      'pattern': '.*?/requests',
+      'pattern': '.*?/requests(?:\?.*)?',
       'url_rules': [url_rule]
     })
 
@@ -185,7 +225,7 @@ class TestRewriteUrl():
     }
     rewrite_rule = RewriteRule({
       'methods': ['GET'],
-      'pattern': '.*?/requests',
+      'pattern': '.*?/requests(?:\?.*)?',
       'url_rules': [url_rule]
     })
 
@@ -215,7 +255,7 @@ class TestRewriteUrl():
       }
       rewrite_rule = RewriteRule({
         'methods': ['GET'],
-        'pattern': '.*?/requests',
+        'pattern': '.*?/requests(?:\?.*)?',
         'url_rules': [url_rule1, url_rule2]
       })
 

stoobly_agent/test/app/proxy/mock/eval_fixtures_service_test.py

@@ -51,10 +51,18 @@ class TestEvalFixturesService():
 
       return Request.last()
 
+    @pytest.fixture(scope='class')
+    def default_file_contents(self):
+      return b'Default'
+
     @pytest.fixture(scope='class')
     def not_found_file_contents(self):
       return b'Not Found'
 
+    @pytest.fixture(scope='class')
+    def user_file_contents(self):
+      return b'{"id": 1, "name": "John Doe"}'
+
     @pytest.fixture(scope='class')
     def public_directory(self):
       tmp_dir_path = DataDir.instance().tmp_dir_path
@@ -64,14 +72,28 @@ class TestEvalFixturesService():
       return public_dir_path
 
     @pytest.fixture(autouse=True, scope='class')
-    def not_found_file_path(self, public_directory: str, not_found_file_contents: str):
+    def not_found_file_path(self, public_directory: str, not_found_file_contents: bytes):
       path = os.path.join(public_directory, '404.html')
       with open(path, 'wb') as fp:
         fp.write(not_found_file_contents)
       return path
 
+    @pytest.fixture(autouse=True, scope='class')
+    def user_file_path(self, public_directory: str, user_file_contents: bytes):
+      path = os.path.join(public_directory, 'user.json')
+      with open(path, 'wb') as fp:
+        fp.write(user_file_contents)
+      return path
+
+    @pytest.fixture(autouse=True, scope='class')
+    def default_file_path(self, public_directory: str, default_file_contents: bytes):
+      path = os.path.join(public_directory, 'index.html')
+      with open(path, 'wb') as fp:
+        fp.write(default_file_contents)
+      return path
+
     @pytest.fixture(scope='class')
-    def response_fixtures(self, request_method: str, not_found_file_path: str) -> Fixtures:
+    def response_fixtures(self, public_directory: str, request_method: str, not_found_file_path: str) -> Fixtures:
       fixtures = {}
       fixtures[request_method] = {
         '/404.html': {
@@ -80,6 +102,9 @@ class TestEvalFixturesService():
           },
           'path': not_found_file_path,
           'status_code': 404,
+        },
+        '/.*?': {
+          'path': public_directory
         }
       }
       return fixtures
@@ -95,14 +120,31 @@ class TestEvalFixturesService():
       fixtures_file = os.path.join(tmp_dir_path, 'test_response_fixtures.yml')
       
       with open(fixtures_file, 'w') as f:
-        yaml.dump(response_fixtures, f)
-      
+        yaml.dump(response_fixtures, f, sort_keys=False)
+
       res: requests.Response = eval_fixtures(mitmproxy_request, response_fixtures_path=fixtures_file)
       assert res != None
       return res
 
+    @pytest.fixture()
+    def default_fixtures_response(self, mitmproxy_request: MitmproxyRequest, response_fixtures: Fixtures):
+      mitmproxy_request.path = '/'
+      mitmproxy_request.headers['accept'] = '*/*'
+
+      res: requests.Response = eval_fixtures(mitmproxy_request, response_fixtures=response_fixtures)
+      assert res != None
+      return res
+
+    @pytest.fixture()
+    def user_fixtures_response(self, mitmproxy_request: MitmproxyRequest, response_fixtures: Fixtures):
+      mitmproxy_request.path = '/user.json'
+      mitmproxy_request.headers['accept'] = 'application/json'
+      res: requests.Response = eval_fixtures(mitmproxy_request, response_fixtures=response_fixtures)
+      assert res != None
+      return res
+
     def test_it_sets_response(
-      self, fixtures_response: requests.Response, not_found_file_contents: str
+      self, fixtures_response: requests.Response, not_found_file_contents: bytes
     ):
       assert fixtures_response.raw.read() == not_found_file_contents
 
@@ -113,6 +155,12 @@ class TestEvalFixturesService():
     def test_it_sets_status_code(self,  fixtures_response: requests.Response):
       assert fixtures_response.status_code == 404
 
+    def test_fixture_directory(self, default_fixtures_response: requests.Response, default_file_contents: bytes):
+      assert default_fixtures_response.raw.read() == default_file_contents
+
+    def test_it_sets_user_response(self, user_fixtures_response: requests.Response, user_file_contents: bytes):
+      assert user_fixtures_response.raw.read() == user_file_contents
+
   class TestPublicDirectory():
     @pytest.fixture(scope='class')
     def request_method(self):
@@ -460,6 +508,404 @@ class TestEvalFixturesService():
       assert res is not None
       assert res.raw.read() == b'Hostname Port Content'
 
+  class TestErrorHandling():
+    """Test error handling and edge cases."""
+    
+    @pytest.fixture(scope='class')
+    def request_method(self):
+      return 'GET'
+
+    @pytest.fixture(scope='class')
+    def request_url(self):
+      return 'https://example.com/test'
+    
+    @pytest.fixture(scope='class')
+    def created_request(self, settings: Settings, request_method: str, request_url: str):
+      status = RequestBuilder(
+        method=request_method,
+        request_headers={'accept': 'application/json'},
+        response_body='',
+        status_code=200,
+        url=request_url,
+      ).with_settings(settings).build()[1]
+      assert status == 200
+      return Request.last()
+
+    @pytest.fixture()
+    def mitmproxy_request(self, created_request: Request) -> MitmproxyRequest:
+      return MitmproxyRequestAdapter(created_request).adapt()
+
+    def test_missing_path_pattern_in_fixture(self, mitmproxy_request: MitmproxyRequest):
+      """Test fixture without path_pattern key - should handle KeyError gracefully."""
+      # Create fixture without path_pattern
+      fixture_without_pattern = {
+        'GET': {
+          '/test': {
+            'path': '/tmp/nonexistent_dir'  # Directory that doesn't exist
+          }
+        }
+      }
+      
+      # This should not raise a KeyError when accessing fixture['path_pattern']
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture_without_pattern)
+      # Should return None since directory doesn't exist
+      assert res is None
+
+    def test_nonexistent_fixture_file(self, mitmproxy_request: MitmproxyRequest):
+      """Test fixture pointing to nonexistent file."""
+      fixture = {
+        'GET': {
+          '/test': {
+            'path': '/tmp/nonexistent_file.json'
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is None
+
+    def test_nonexistent_public_directory(self, mitmproxy_request: MitmproxyRequest):
+      """Test public directory that doesn't exist."""
+      res = eval_fixtures(mitmproxy_request, public_directory_path='/tmp/nonexistent_directory')
+      assert res is None
+
+    def test_invalid_yaml_in_response_fixtures_path(self, mitmproxy_request: MitmproxyRequest):
+      """Test handling of invalid YAML in response fixtures file."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      invalid_yaml_file = os.path.join(tmp_dir_path, 'invalid.yml')
+      
+      # Create file with invalid YAML
+      with open(invalid_yaml_file, 'w') as f:
+        f.write('invalid: yaml: content: [')
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures_path=invalid_yaml_file)
+      assert res is None
+
+    def test_empty_response_fixtures(self, mitmproxy_request: MitmproxyRequest):
+      """Test with empty response fixtures."""
+      res = eval_fixtures(mitmproxy_request, response_fixtures={})
+      assert res is None
+
+    def test_none_response_fixtures(self, mitmproxy_request: MitmproxyRequest):
+      """Test with None response fixtures."""
+      res = eval_fixtures(mitmproxy_request, response_fixtures=None)
+      assert res is None
+
+    def test_malformed_fixture_structure(self, mitmproxy_request: MitmproxyRequest):
+      """Test fixture with malformed structure."""
+      malformed_fixture = {
+        'GET': 'not_a_dict'  # Should be a dict
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=malformed_fixture)
+      assert res is None
+
+    def test_fixture_without_path(self, mitmproxy_request: MitmproxyRequest):
+      """Test fixture without path key."""
+      fixture_without_path = {
+        'GET': {
+          '/test': {
+            'status_code': 200
+            # Missing 'path' key
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture_without_path)
+      assert res is None
+
+    def test_directory_fixture_without_matching_subpath(self, mitmproxy_request: MitmproxyRequest):
+      """Test directory fixture when no matching subpath file exists."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      test_dir = os.path.join(tmp_dir_path, 'test_dir')
+      os.makedirs(test_dir, exist_ok=True)
+      
+      # Don't create any files in the directory
+      
+      fixture = {
+        'GET': {
+          '/test': {
+            'path': test_dir
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is None
+
+  class TestCustomHeaders():
+    """Test custom header handling."""
+    
+    @pytest.fixture(scope='class')
+    def request_method(self):
+      return 'GET'
+
+    @pytest.fixture(scope='class')
+    def request_url(self):
+      return 'https://example.com/test'
+    
+    @pytest.fixture(scope='class')
+    def test_file_contents(self):
+      return b'Test content'
+
+    @pytest.fixture(scope='class')
+    def test_file_path(self, test_file_contents: bytes):
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      file_path = os.path.join(tmp_dir_path, 'custom_headers_test.txt')
+      with open(file_path, 'wb') as f:
+        f.write(test_file_contents)
+      return file_path
+    
+    @pytest.fixture(scope='class')
+    def created_request(self, settings: Settings, request_method: str, request_url: str):
+      from stoobly_agent.config.constants.custom_headers import MOCK_FIXTURE_PATH
+      status = RequestBuilder(
+        method=request_method,
+        request_headers={MOCK_FIXTURE_PATH: '/custom/path'},
+        response_body='',
+        status_code=200,
+        url=request_url,
+      ).with_settings(settings).build()[1]
+      assert status == 200
+      return Request.last()
+
+    @pytest.fixture()
+    def mitmproxy_request(self, created_request: Request, test_file_path: str) -> MitmproxyRequest:
+      from stoobly_agent.config.constants.custom_headers import MOCK_FIXTURE_PATH
+      request = MitmproxyRequestAdapter(created_request).adapt()
+      # Override the custom header to point to our test file
+      request.headers[MOCK_FIXTURE_PATH] = test_file_path
+      return request
+
+    def test_custom_fixture_path_header(self, mitmproxy_request: MitmproxyRequest, test_file_contents: bytes):
+      """Test fixture path specified via custom header."""
+      res = eval_fixtures(mitmproxy_request)
+      assert res is not None
+      assert res.raw.read() == test_file_contents
+
+    def test_custom_fixture_path_header_nonexistent_file(self, mitmproxy_request: MitmproxyRequest):
+      """Test custom fixture path header pointing to nonexistent file."""
+      from stoobly_agent.config.constants.custom_headers import MOCK_FIXTURE_PATH
+      mitmproxy_request.headers[MOCK_FIXTURE_PATH] = '/tmp/nonexistent_file.txt'
+      
+      res = eval_fixtures(mitmproxy_request)
+      assert res is None
+
+  class TestContentTypeGuessing():
+    """Test content type guessing and file extension handling."""
+    
+    @pytest.fixture(scope='class')
+    def request_method(self):
+      return 'GET'
+
+    @pytest.fixture(scope='class')
+    def request_url(self):
+      return 'https://example.com/api/data'
+    
+    @pytest.fixture(scope='class')
+    def created_request(self, settings: Settings, request_method: str, request_url: str):
+      status = RequestBuilder(
+        method=request_method,
+        request_headers={'accept': 'application/json,text/html;q=0.9,*/*;q=0.8'},
+        response_body='',
+        status_code=200,
+        url=request_url,
+      ).with_settings(settings).build()[1]
+      assert status == 200
+      return Request.last()
+
+    @pytest.fixture()
+    def mitmproxy_request(self, created_request: Request) -> MitmproxyRequest:
+      return MitmproxyRequestAdapter(created_request).adapt()
+
+    def test_json_file_content_type(self, mitmproxy_request: MitmproxyRequest):
+      """Test that JSON files get correct content type."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      json_file = os.path.join(tmp_dir_path, 'test.json')
+      
+      with open(json_file, 'w') as f:
+        json.dump({'test': 'data'}, f)
+      
+      fixture = {
+        'GET': {
+          '/api/data': {
+            'path': json_file
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      assert res.headers.get('content-type') == 'application/json'
+
+    def test_html_file_content_type(self, mitmproxy_request: MitmproxyRequest):
+      """Test that HTML files get correct content type."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      html_file = os.path.join(tmp_dir_path, 'test.html')
+      
+      with open(html_file, 'w') as f:
+        f.write('<html><body>Test</body></html>')
+      
+      fixture = {
+        'GET': {
+          '/api/data': {
+            'path': html_file
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      assert res.headers.get('content-type') == 'text/html'
+
+    def test_unknown_extension_uses_accept_header(self, mitmproxy_request: MitmproxyRequest):
+      """Test that files with unknown extensions use accept header for content type."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      unknown_file = os.path.join(tmp_dir_path, 'test.unknown')
+      
+      with open(unknown_file, 'w') as f:
+        f.write('test content')
+      
+      fixture = {
+        'GET': {
+          '/api/data': {
+            'path': unknown_file
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      # Should use highest priority from accept header (application/json)
+      assert res.headers.get('content-type') == 'application/json'
+
+    def test_wildcard_accept_header_defaults(self, mitmproxy_request: MitmproxyRequest):
+      """Test that wildcard accept header gets reasonable defaults."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      test_file = os.path.join(tmp_dir_path, 'test_wildcard')
+      
+      with open(test_file, 'w') as f:
+        f.write('test content')
+      
+      # Set accept header to */*
+      mitmproxy_request.headers['accept'] = '*/*'
+      
+      fixture = {
+        'GET': {
+          '/api/data': {
+            'path': test_file
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      # Should default to text/html based on the wildcard handling
+      assert res.headers.get('content-type') == 'text/plain'
+
+  class TestRegexPatternMatching():
+    """Test regex pattern matching for fixture routes."""
+    
+    @pytest.fixture(scope='class')
+    def request_method(self):
+      return 'GET'
+
+    @pytest.fixture(scope='class')
+    def request_url(self):
+      return 'https://example.com/api/users/123'
+    
+    @pytest.fixture(scope='class')
+    def test_file_contents(self):
+      return b'User 123 data'
+
+    @pytest.fixture(scope='class')
+    def test_file_path(self, test_file_contents: bytes):
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      file_path = os.path.join(tmp_dir_path, 'user_data.json')
+      with open(file_path, 'wb') as f:
+        f.write(test_file_contents)
+      return file_path
+    
+    @pytest.fixture(scope='class')
+    def created_request(self, settings: Settings, request_method: str, request_url: str):
+      status = RequestBuilder(
+        method=request_method,
+        request_headers={'accept': 'application/json'},
+        response_body='',
+        status_code=200,
+        url=request_url,
+      ).with_settings(settings).build()[1]
+      assert status == 200
+      return Request.last()
+
+    @pytest.fixture()
+    def mitmproxy_request(self, created_request: Request) -> MitmproxyRequest:
+      return MitmproxyRequestAdapter(created_request).adapt()
+
+    def test_regex_pattern_matching(self, mitmproxy_request: MitmproxyRequest, test_file_path: str, test_file_contents: bytes):
+      """Test that regex patterns work for matching routes."""
+      fixture = {
+        'GET': {
+          r'/api/users/\d+': {  # Regex pattern to match user IDs
+            'path': test_file_path
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      assert res.raw.read() == test_file_contents
+
+    def test_exact_path_matching(self, mitmproxy_request: MitmproxyRequest, test_file_path: str, test_file_contents: bytes):
+      """Test exact path matching."""
+      fixture = {
+        'GET': {
+          '/api/users/123': {  # Exact path match
+            'path': test_file_path
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      assert res.raw.read() == test_file_contents
+
+    def test_non_matching_pattern(self, mitmproxy_request: MitmproxyRequest, test_file_path: str):
+      """Test that non-matching patterns return None."""
+      fixture = {
+        'GET': {
+          r'/api/posts/\d+': {  # Different pattern that shouldn't match
+            'path': test_file_path
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is None
+
+    def test_multiple_patterns_first_match_wins(self, mitmproxy_request: MitmproxyRequest, test_file_path: str):
+      """Test that first matching pattern is used."""
+      tmp_dir_path = DataDir.instance().tmp_dir_path
+      second_file = os.path.join(tmp_dir_path, 'second_file.json')
+      with open(second_file, 'w') as f:
+        f.write('Second file content')
+      
+      fixture = {
+        'GET': {
+          r'/api/users/\d+': {  # First pattern - should match
+            'path': test_file_path
+          },
+          r'/api/.*': {  # Second pattern - also matches but shouldn't be used
+            'path': second_file
+          }
+        }
+      }
+      
+      res = eval_fixtures(mitmproxy_request, response_fixtures=fixture)
+      assert res is not None
+      # Should use first matching pattern
+      assert res.raw.read() == b'User 123 data'
+
   class TestMultipleResponseFixtures():
     @pytest.fixture(scope='class')
     def request_method(self):
@@ -649,10 +1095,10 @@ class TestEvalFixturesService():
       }
       
       with open(api_fixtures_file, 'w') as f:
-        yaml.dump(api_fixtures_content, f)
+        yaml.dump(api_fixtures_content, f, sort_keys=False)
       
       with open(main_fixtures_file, 'w') as f:
-        yaml.dump(main_fixtures_content, f)
+        yaml.dump(main_fixtures_content, f, sort_keys=False)
       
       # Use response_fixtures_path with origin specification
       fixtures_paths = f"{api_fixtures_file}:https://api\\.example\\.com,{main_fixtures_file}:https://petstore\\.swagger\\.io"
@@ -681,7 +1127,7 @@ class TestEvalFixturesService():
       }
       
       with open(fallback_fixtures_file, 'w') as f:
-        yaml.dump(fallback_fixtures_content, f)
+        yaml.dump(fallback_fixtures_content, f, sort_keys=False)
       
       # Use a fixture file without origin specification (fallback)
       res: requests.Response = eval_fixtures(main_mitmproxy_request, response_fixtures_path=fallback_fixtures_file)
@@ -721,10 +1167,10 @@ class TestEvalFixturesService():
       }
       
       with open(api_fixtures_file, 'w') as f:
-        yaml.dump(api_fixtures_content, f)
+        yaml.dump(api_fixtures_content, f, sort_keys=False)
       
       with open(fallback_fixtures_file, 'w') as f:
-        yaml.dump(fallback_fixtures_content, f)
+        yaml.dump(fallback_fixtures_content, f, sort_keys=False)
       
       # Use response_fixtures_path with origin-specific first, fallback second
       fixtures_paths = f"{api_fixtures_file}:https://api\\.example\\.com,{fallback_fixtures_file}"
@@ -766,7 +1212,7 @@ class TestEvalFixturesService():
       }
       
       with open(wildcard_fixtures_file, 'w') as f:
-        yaml.dump(wildcard_fixtures_content, f)
+        yaml.dump(wildcard_fixtures_content, f, sort_keys=False)
       
       # Use regex wildcard pattern in response_fixtures_path
       fixtures_paths = f"{wildcard_fixtures_file}:https://.*\\.example\\.com"
@@ -795,7 +1241,7 @@ class TestEvalFixturesService():
       }
       
       with open(fixtures_file_path, 'w') as fp:
-        yaml.dump(fixtures_content, fp)
+        yaml.dump(fixtures_content, fp, sort_keys=False)
       
       # Test loading fixtures via response_fixtures_path
       res: requests.Response = eval_fixtures(api_mitmproxy_request, response_fixtures_path=fixtures_file_path)
@@ -834,10 +1280,10 @@ class TestEvalFixturesService():
       }
       
       with open(api_fixtures_file, 'w') as fp:
-        yaml.dump(api_fixtures_content, fp)
+        yaml.dump(api_fixtures_content, fp, sort_keys=False)
       
       with open(main_fixtures_file, 'w') as fp:
-        yaml.dump(main_fixtures_content, fp)
+        yaml.dump(main_fixtures_content, fp, sort_keys=False)
       
       # Test with comma-separated paths with origins
       fixtures_paths = f"{api_fixtures_file}:https://api\\.example\\.com,{main_fixtures_file}:https://petstore\\.swagger\\.io"
@@ -885,10 +1331,10 @@ class TestEvalFixturesService():
       }
       
       with open(first_fixtures_file, 'w') as fp:
-        yaml.dump(first_fixtures_content, fp)
+        yaml.dump(first_fixtures_content, fp, sort_keys=False)
       
       with open(second_fixtures_file, 'w') as fp:
-        yaml.dump(second_fixtures_content, fp)
+        yaml.dump(second_fixtures_content, fp, sort_keys=False)
       
       # Create an invalid YAML file that would cause an error if processed
       with open(invalid_fixtures_file, 'w') as fp:
@@ -936,10 +1382,10 @@ class TestEvalFixturesService():
       }
       
       with open(wrong_origin_file, 'w') as fp:
-        yaml.dump(wrong_origin_content, fp)
+        yaml.dump(wrong_origin_content, fp, sort_keys=False)
       
       with open(correct_origin_file, 'w') as fp:
-        yaml.dump(correct_origin_content, fp)
+        yaml.dump(correct_origin_content, fp, sort_keys=False)
       
       # Test with API request - wrong origin should be skipped, correct origin should be used
       fixtures_paths = f"{wrong_origin_file}:https://petstore\\.swagger\\.io,{correct_origin_file}:https://api\\.example\\.com"
@@ -974,7 +1420,7 @@ class TestEvalFixturesService():
         }
       }
       with open(api_fixtures_file, 'w') as f:
-        yaml.dump(fixtures_content, f)
+        yaml.dump(fixtures_content, f, sort_keys=False)
       
       # Test full URL with port
       status = RequestBuilder(
@@ -1015,7 +1461,7 @@ class TestEvalFixturesService():
         }
       }
       with open(api_fixtures_file, 'w') as f:
-        yaml.dump(fixtures_content, f)
+        yaml.dump(fixtures_content, f, sort_keys=False)
       
       # Test HTTP request
       status = RequestBuilder(
@@ -1056,7 +1502,7 @@ class TestEvalFixturesService():
         }
       }
       with open(wildcard_fixtures_file, 'w') as f:
-        yaml.dump(fixtures_content, f)
+        yaml.dump(fixtures_content, f, sort_keys=False)
       
       # Test subdomain request
       status = RequestBuilder(

{stoobly_agent-1.10.2.dist-info → stoobly_agent-1.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stoobly-agent
-Version: 1.10.2
+Version: 1.10.3
 Summary: Record, mock, and test HTTP(s) requests. CLI agent for Stoobly
 License: Apache-2.0
 License-File: LICENSE

{stoobly_agent-1.10.2.dist-info → stoobly_agent-1.10.3.dist-info}/RECORD

@@ -1,8 +1,8 @@
-stoobly_agent/__init__.py,sha256=CRXzbO8ujhHYHbvJS89guJ-Nk8RIZn8xmdumu_uAfBg,45
+stoobly_agent/__init__.py,sha256=G6RHX8ESNEXsGSpOUuCoZooxoXtbFgnLwqa8NHC683M,45
 stoobly_agent/__main__.py,sha256=tefOkFZeCFU4l3C-Y4R_lR9Yt-FETISiXGUnbh6Os54,146
 stoobly_agent/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stoobly_agent/app/api/__init__.py,sha256=NIgcbX7iiWrApsCITXlmhr4SYbWS0fwb01x-F3jTFdo,666
-stoobly_agent/app/api/application_http_request_handler.py,sha256=Tn1aUZr1EH4NtwG7el_ZH2P4baMBZSnS2qW3dkEw_FE,5359
+stoobly_agent/app/api/application_http_request_handler.py,sha256=h8y3gjPOgbFK3z0UIX3t6aGtRMAiQt3QH9qZ_Gduq_M,5363
 stoobly_agent/app/api/bodies_controller.py,sha256=tiuBIcLsRIUrVlStFwhGj_8AzsURSmW0E_MDQb09WXY,2267
 stoobly_agent/app/api/configs_controller.py,sha256=S8BYn5PHMlc_vdnJTU0qE6w0lL7A7swEiV5_LJJvMOU,4736
 stoobly_agent/app/api/headers_controller.py,sha256=qUM0U0WNn_87outx1y4r8Mfr6RqHO0UR91JP0-LNajc,2781
@@ -59,7 +59,7 @@ stoobly_agent/app/cli/helpers/test_facade.py,sha256=gRnbjYNxnzPmtvFp2J6TZgxaMSzD
 stoobly_agent/app/cli/helpers/test_replay_context.py,sha256=Tx5fenr14mXqHvCpl7o9c2qTJw8Kl9XgxzqqDhqFj1I,4754
 stoobly_agent/app/cli/helpers/trace_aliases.py,sha256=8N8pnsnONwVv-fabCTvDlXec-WbSu1zfCNHTuzl8Tzc,874
 stoobly_agent/app/cli/helpers/trace_context_facade.py,sha256=3MDjY_bdhvE2dad_B_w9gemCZZoiVjotbE8o9hrmVYo,1027
-stoobly_agent/app/cli/helpers/validations.py,sha256=nvcrEHvjMOAyHlJK0bQIwyzBUciJ0qNkNESa2zZ5ZFo,6232
+stoobly_agent/app/cli/helpers/validations.py,sha256=o9_DqlAIw98QcMNXGsAnELQ6DeXdSRa1TLiTZu3V7ns,6236
 stoobly_agent/app/cli/helpers/verify_raw_request_service.py,sha256=tmLeRBYhNgAQeJD-rF6Nj22F_TfVktVSb1wjRPFblBQ,658
 stoobly_agent/app/cli/intercept_cli.py,sha256=tgGtl1EZerIdcuMR8KKHdrrn_7-XWSg0D6XdTuSq8k0,6698
 stoobly_agent/app/cli/main_group.py,sha256=3UzBxin2f2p5KNqo6Oayo_I1VI2pHpqOoRexUnJ74a4,2187
@@ -67,7 +67,7 @@ stoobly_agent/app/cli/project_cli.py,sha256=EXjeLjbnq9PhfCjvyfZ0UnJ2tejeCS0SIAo3
 stoobly_agent/app/cli/report_cli.py,sha256=ZxJw0Xkx7KFZJn9e45BSKRKon8AD0Msrwy1fbPfbv0c,2543
 stoobly_agent/app/cli/request_cli.py,sha256=NVO6alj2acwaYLvU2445yB5qAQIK32Ll19tOErxzNR8,7863
 stoobly_agent/app/cli/scaffold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stoobly_agent/app/cli/scaffold/app.py,sha256=CRnYQbIee8vB6El8eOM1hlQ3wDlNtxRpZ7gy21ZiBqE,3918
+stoobly_agent/app/cli/scaffold/app.py,sha256=7d5nHnQwyBxEwSC2Jrvbk2U3dj9OnhaHrE2zmC37oOs,3922
 stoobly_agent/app/cli/scaffold/app_command.py,sha256=x--ejtVSBL0Jz8OiakBtxfI2IZFAWJWCwuSJo7TEU9Y,2386
 stoobly_agent/app/cli/scaffold/app_config.py,sha256=oG06y9yuAo05ROpOhDC_LFPJ0KKNrhfvYLOgHx5nE4Y,2788
 stoobly_agent/app/cli/scaffold/app_create_command.py,sha256=G4C-XSp4hN0FvaSKLpGGvTp8iXHqKYdqoxxRPHgO0a0,8253
@@ -110,7 +110,7 @@ stoobly_agent/app/cli/scaffold/service_command.py,sha256=j-lkG5Zth_CBHa6Z9Kv3dJw
 stoobly_agent/app/cli/scaffold/service_config.py,sha256=A8kQU3n3IhOn64PAQo-O_WHGYdjz8AAER1UF4z0KKPw,6977
 stoobly_agent/app/cli/scaffold/service_create_command.py,sha256=PwydEKBNodrGZVmfWifNjrYRDHifAnYR7gpeYMoTU3s,3726
 stoobly_agent/app/cli/scaffold/service_delete_command.py,sha256=_nBDQjm8eL62MQpzSCxgUHlW04ZXKG8MDlN1BXxlqww,986
-stoobly_agent/app/cli/scaffold/service_dependency.py,sha256=7fD7BMjyBs19ZsWvsV8z3ViBXbuBmt-ytYvUboaqsww,1851
+stoobly_agent/app/cli/scaffold/service_dependency.py,sha256=olr_s_cfn51Pz5FlIihlydEl7g4CHKn-YJT0EP2h8eA,1855
 stoobly_agent/app/cli/scaffold/service_docker_compose.py,sha256=fVUZ-oo-bn5GVZp8JgGq7AkiQQ6-JkxwK_OMlinS9WM,915
 stoobly_agent/app/cli/scaffold/service_update_command.py,sha256=oWusBKfvjt4RnK03_V3CJYWrfsCI4_LcR7W12eLXMR4,2579
 stoobly_agent/app/cli/scaffold/service_workflow.py,sha256=sQ_Edy_wGHKMXpD0DmhnOWkGEKz7gSgEGNI8f7aXOdg,444
@@ -118,7 +118,7 @@ stoobly_agent/app/cli/scaffold/service_workflow_validate_command.py,sha256=80pX8
 stoobly_agent/app/cli/scaffold/templates/__init__.py,sha256=x8C_a0VoO_vUbosp4_6IC1U7Ge9NnUdVKDPpVMtMkeY,171
 stoobly_agent/app/cli/scaffold/templates/app/.Dockerfile.context,sha256=9DQK-OXnRKjjKWsUSIRAio6dkR4eGxD1vizPT7Q5sp8,159
 stoobly_agent/app/cli/scaffold/templates/app/.Makefile,sha256=OnY_3D9nxl3HxfUxvCgk7PY3XntEbgO9j1myx_ETK7w,9161
-stoobly_agent/app/cli/scaffold/templates/app/.docker-compose.base.yml,sha256=6tFqXh3ine8vaD0FCL5TMoY5NjKx2wLUR8XpW3tJtew,245
+stoobly_agent/app/cli/scaffold/templates/app/.docker-compose.base.yml,sha256=SABod6_InBFyOm-uulK7r27SR0sWRUiL0h69g_jvNJA,249
 stoobly_agent/app/cli/scaffold/templates/app/.docker-compose.networks.yml,sha256=I4PbJpQjFHb5IbAUWNvYM6okDEtmwtKFDQg-yog05WM,141
 stoobly_agent/app/cli/scaffold/templates/app/Makefile,sha256=TEmPG7Bf0KZOnmfsgdzza3UdwcVMmM5Lj1YdLc4cgjA,79
 stoobly_agent/app/cli/scaffold/templates/app/build/.config.yml,sha256=8Wt8ZZ5irvBYYS44xGrR_EWlZDuXH9kyWmquzsh7s8g,19
@@ -361,15 +361,15 @@ stoobly_agent/app/proxy/mitmproxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 stoobly_agent/app/proxy/mitmproxy/flow_mock.py,sha256=YxQV3pXIzicvLOCFn7zmnSoAstAmR8fzONYOXAkYbT4,1153
 stoobly_agent/app/proxy/mitmproxy/request.py,sha256=niy38718CAe4Li4k40GXnWDDmUTCPkXesDZTaC8BeLc,878
 stoobly_agent/app/proxy/mitmproxy/request_body_facade.py,sha256=kMJ8YH2FKW9qV68QcUbOCLfiGgKrFV5krzt7usGf0as,649
-stoobly_agent/app/proxy/mitmproxy/request_facade.py,sha256=ab16pg551XipGyAvP_2GtY5gMrWihC1sBkSmU-s5NQ8,8533
+stoobly_agent/app/proxy/mitmproxy/request_facade.py,sha256=9yvTOPWQw7epg-wxvlT66lKR0-ZgLHEOVfX-xeumpJM,8537
 stoobly_agent/app/proxy/mitmproxy/response.py,sha256=BFaJlB1D98EOjrc-kUmunUCTUuiZsPDqq2QgAHDocQI,339
 stoobly_agent/app/proxy/mitmproxy/response_body_facade.py,sha256=vIu6cuCSiZDocvnMNyi0Zjf0qsC0enm2Glp671eWnb4,659
 stoobly_agent/app/proxy/mitmproxy/response_facade.py,sha256=0wCSzUULUhDDV93QXUgzMNxiiSZwcu-kUB2C5z1Ck0Y,4311
 stoobly_agent/app/proxy/mock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stoobly_agent/app/proxy/mock/context.py,sha256=vDo5_3WBL73mVFnsmQWvcxvPg5nWtRJbigSrE3zGc-o,794
 stoobly_agent/app/proxy/mock/custom_not_found_response_builder.py,sha256=0KWB3KFxVrnJOKDaYxm5eoJEccw7IpJZRyUvBX61-8k,697
-stoobly_agent/app/proxy/mock/eval_fixtures_service.py,sha256=qs_R87SV2ya6eQoJ3vMxqM87yNm-C-NSCZKloUVEPVM,11305
-stoobly_agent/app/proxy/mock/eval_request_service.py,sha256=A1tcE3wmrC1HwLpz0aRuRw-Nucn0dyHD_yHw5BeQEJU,8146
+stoobly_agent/app/proxy/mock/eval_fixtures_service.py,sha256=YNe1NnpmTvhtjfAXL2Vs3cmYmd4fcNCSVYeun4ANdoc,12068
+stoobly_agent/app/proxy/mock/eval_request_service.py,sha256=JLmFzMrtbphPGPfUznaGW-_cc6sMZDehhdqY3tXrgzI,8150
 stoobly_agent/app/proxy/mock/hashed_request_decorator.py,sha256=h1ma90fdaYI9LBWpMWMqWBz-RjNwI628O4VuS_uUBX4,5061
 stoobly_agent/app/proxy/mock/ignored_components_response_builder.py,sha256=E32_E1eSdmPn2SeM_e1jWnqu4xh5w_SnmOs32Shx99E,501
 stoobly_agent/app/proxy/mock/request_hasher.py,sha256=WeOeksmW_b5Ql0Xb0fL2WMH3MVHrm-9GYWYoKYS1teg,3755
@@ -422,7 +422,7 @@ stoobly_agent/app/proxy/test/matchers/fuzzy.py,sha256=tTnsPDaK0HFJ5ST5ThZIlHkZNz
 stoobly_agent/app/proxy/test/matchers/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stoobly_agent/app/proxy/test/test_service.py,sha256=EWDdrcoewgCzsuWmbra-dDEZLfuWBiX6X9LF_xwqglw,4314
 stoobly_agent/app/proxy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stoobly_agent/app/proxy/utils/allowed_request_service.py,sha256=VzT_l2lFXl8ErTr5vijt-DKhbjQG_15YNsK5Wazb3VE,3709
+stoobly_agent/app/proxy/utils/allowed_request_service.py,sha256=V977CB7Ee6kc566PX0V7rGk4pJsy0SgRmXm8CC78d6c,3717
 stoobly_agent/app/proxy/utils/minimize_headers.py,sha256=hL5-cpNgqilOXY0s7sjUL76Ixym4I1bUws9yDlrsXGs,1175
 stoobly_agent/app/proxy/utils/publish_change_service.py,sha256=ljKaVz1i3ClUNk0_UHvwpoJdUhapZhwQXs4UB13LsM8,1292
 stoobly_agent/app/proxy/utils/request_handler.py,sha256=VscAXf2_F1C1yrt2gNImPkatosuGj356pARTd_WnTUE,846
@@ -545,7 +545,7 @@ stoobly_agent/lib/api/stoobly_api.py,sha256=PacuNx3-RzqXHJSXwYXoKl9JAVhefd5A7Qqy
 stoobly_agent/lib/api/test_responses_resource.py,sha256=RdNj7N6xC7jW5zUoKfgNg8Nenk7wdSMaL4dv_DIXih0,541
 stoobly_agent/lib/api/tests_resource.py,sha256=EKyI0xTgzRSPyGdepgteVH3EHUkXIzrt3HXahBau6CY,855
 stoobly_agent/lib/api/users_resource.py,sha256=xR0ug5xifuvRw4jdF4cVjrWBdkFccmL9_fy8ZxOPX74,477
-stoobly_agent/lib/cache.py,sha256=nHQuo3xA9pFa5n9Fp9FwrSeSOb8CcdL_CfsFnCW6XZM,2262
+stoobly_agent/lib/cache.py,sha256=7sYq2wh6I5LmtKqvJYoY89h_PvZ21zvS9pCBCEutuCM,2266
 stoobly_agent/lib/logger.py,sha256=6s_8UxXLJt1jor-Ez0xCBWhuAD932sTEBQBnNXpFTtQ,1971
 stoobly_agent/lib/orm/__init__.py,sha256=UCAL40_L9qf1sUqvUWKzc551jKLR4HKqRNLPdOuXl2w,1199
 stoobly_agent/lib/orm/base.py,sha256=3PZx0OWK241vrr8pLLQL0GFhKxvYVDFyVMMdYzhxMPM,358
@@ -755,13 +755,13 @@ stoobly_agent/test/app/models/factories/resource/local_db/helpers/log_test.py,sh
 stoobly_agent/test/app/models/factories/resource/local_db/helpers/tiebreak_scenario_request_test.py,sha256=a1SFLyEyRRLuADvAw6ckQQKORFXvyK1lyrbkaLWx8oU,3399
 stoobly_agent/test/app/models/factories/resource/local_db/request_adapter_test.py,sha256=Pzq1cBPnP9oSWG-p0c-VoymoHxgp483QmNwmV1b78RA,8453
 stoobly_agent/test/app/models/factories/resource/local_db/response_adapter_test.py,sha256=9P95EKH5rZGOrmRkRIDlQZqtiLJHk9735og18Ffwpfw,2204
-stoobly_agent/test/app/models/schemas/.stoobly/db/VERSION,sha256=a1becxu6fSo0CzXh-GOeiAZjwhklQeSrgYlb8OHxF5g,6
+stoobly_agent/test/app/models/schemas/.stoobly/db/VERSION,sha256=NNWX20PKU7L9csy90a96D-I4wsC4Mh2tj0OhYTFD_GI,6
 stoobly_agent/test/app/models/schemas/.stoobly/db/stoobly_agent.sqlite3,sha256=ch8gNx6zIelLKQx65gwFx_LRNqUD3EC5xcHZ0ukIQiU,188416
 stoobly_agent/test/app/models/schemas/.stoobly/settings.yml,sha256=vLwMjweKOdod6tSLtIlyBefPQuNXq9wio4kBaODKtAU,726
 stoobly_agent/test/app/models/schemas/.stoobly/tmp/options.json,sha256=OTRzarwus48CTrItedXCrgQttJHSEZonEYc7R_knvYg,2212
 stoobly_agent/test/app/models/schemas/request_test.py,sha256=9SF43KXbjO-vMr2uObPJlyLeop_JQstl6Jrh0M1A70c,1116
-stoobly_agent/test/app/proxy/mitmproxy/request_facade_test.py,sha256=sXlzjKVvpORJ8fxEs5Qfc4IC0itTWxqDIzMujGjlW7I,5765
-stoobly_agent/test/app/proxy/mock/eval_fixtures_service_test.py,sha256=TZq0h0BlS7mjVyA-Z9_oPgercd1V1WU5Yo25UEYLfA8,42056
+stoobly_agent/test/app/proxy/mitmproxy/request_facade_test.py,sha256=z5_4VdSBVtcox5gZsiit-9EGgHfvqaPRHHsXSBXaVUc,6791
+stoobly_agent/test/app/proxy/mock/eval_fixtures_service_test.py,sha256=BMn1EmBSnkEUlFCbcz5BsQuBM_qCgLmAUPdnL5E7cL8,58429
 stoobly_agent/test/app/proxy/replay/body_parser_service_test.py,sha256=5clzjjkdve0Ctggnw-ZLmZSUtEfWK-Ejtf1x7zCu7z4,4994
 stoobly_agent/test/app/proxy/replay/rewrite_params_service_test.py,sha256=4KVaP48KjCeoZKqY3IdrFAP5Pnb3jO86k8L7ffvz2ZI,3770
 stoobly_agent/test/app/proxy/replay/trace_context_test.py,sha256=y0oBNC89sp3BG8biOBTiaTopk1LtqjThlA4d6BwAHzM,14462
@@ -797,8 +797,8 @@ stoobly_agent/test/mock_data/scaffold/docker-compose-local-service.yml,sha256=1W
 stoobly_agent/test/mock_data/scaffold/index.html,sha256=qJwuYajKZ4ihWZrJQ3BNObV5kf1VGnnm_vqlPJzdqLE,258
 stoobly_agent/test/mock_data/uspto.yaml,sha256=6U5se7C3o-86J4m9xpOk9Npias399f5CbfWzR87WKwE,7835
 stoobly_agent/test/test_helper.py,sha256=6v4AHeqYPw7vtRoxET_ubmRWPJoSmTR_DVHay3FxNbQ,1299
-stoobly_agent-1.10.2.dist-info/METADATA,sha256=XFNMBWLZRQ5Upii0fVCRJuMYTOInbrp9H_oR7yQYgt4,3203
-stoobly_agent-1.10.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-stoobly_agent-1.10.2.dist-info/entry_points.txt,sha256=aq5wix5oC8MDQtmyPGU0xaFrsjJg7WH28NmXh2sc3Z8,56
-stoobly_agent-1.10.2.dist-info/licenses/LICENSE,sha256=o93sj12cdoEOsTCjPaPFsw3Xq0SXs3pPcY-9reE2sEw,548
-stoobly_agent-1.10.2.dist-info/RECORD,,
+stoobly_agent-1.10.3.dist-info/METADATA,sha256=WOtXuRZ-PH8eZ38X2Z63_zddgLbLMbtLJ6Mbq3-vo6I,3203
+stoobly_agent-1.10.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+stoobly_agent-1.10.3.dist-info/entry_points.txt,sha256=aq5wix5oC8MDQtmyPGU0xaFrsjJg7WH28NmXh2sc3Z8,56
+stoobly_agent-1.10.3.dist-info/licenses/LICENSE,sha256=o93sj12cdoEOsTCjPaPFsw3Xq0SXs3pPcY-9reE2sEw,548
+stoobly_agent-1.10.3.dist-info/RECORD,,