stoobly-agent 1.9.11__py3-none-any.whl → 1.10.0__py3-none-any.whl

stoobly_agent/lib/logger.py

@@ -27,6 +27,7 @@ LogLevel = Literal[DEBUG, ERROR, INFO, WARNING]
 
 class Logger:
     _instance = None
+    _instances = {}
 
     def __init__(self):
         raise RuntimeError('Call instance() instead')
@@ -34,14 +35,23 @@ class Logger:
     @classmethod
     def instance(cls, name = None):
         if cls._instance is None:
+            logging.getLogger("mitmproxy").setLevel(logging.ERROR)
             cls._instance = cls.__new__(cls)
-
-        cls._instance.load()
+            cls._instance.load()
 
         if not name:
-            return logging
-        else:
-            return logging.getLogger(name)
+            name = 'root'
+
+        logger = logging.getLogger(name)
+
+        if name not in cls._instances:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter(f"[%(levelname)s] {name} %(message)s"))
+            logger.addHandler(handler)
+            logger.propagate = False
+            cls._instances[name] = logger
+
+        return logger
 
     @classmethod
     def reload(cls):

stoobly_agent/test/app/cli/intercept/intercept_configure_test.py

@@ -7,8 +7,10 @@ from stoobly_agent.test.test_helper import reset
 
 from stoobly_agent.cli import config, intercept, scenario
 from stoobly_agent.lib.orm.scenario import Scenario
+from stoobly_agent.app.settings import Settings
+from stoobly_agent.lib.api.keys.project_key import ProjectKey
 
-from stoobly_agent.config.constants import mode, record_order
+from stoobly_agent.config.constants import mode, mock_policy, record_order, record_policy, record_strategy, replay_policy, test_strategy
 
 @pytest.fixture(scope='module')
 def runner():
@@ -51,3 +53,231 @@ class TestInterceptConfigure():
           assert configure_result.exit_code == 0
 
           assert not Scenario.find(scenario.id).overwritable
+
+  class TestPolicy():
+
+    class TestMockPolicy():
+
+      def test_policy_mock_mode_all(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', mock_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.mock_policy == mock_policy.ALL
+
+      def test_policy_mock_mode_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', mock_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.mock_policy == mock_policy.FOUND
+
+      def test_policy_without_mode_mock_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.MOCK])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', mock_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.mock_policy == mock_policy.ALL
+
+    class TestRecordPolicy():
+
+      def test_policy_record_mode_all(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.ALL
+
+      def test_policy_record_mode_api(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.API])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.API
+
+      def test_policy_record_mode_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.FOUND
+
+      def test_policy_record_mode_not_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.NOT_FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.NOT_FOUND
+
+      def test_policy_without_mode_record_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.RECORD])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', record_policy.API])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.API
+
+    class TestReplayPolicy():
+
+      def test_policy_replay_mode_all(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.REPLAY, '--policy', replay_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.replay_policy == replay_policy.ALL
+
+      def test_policy_without_mode_replay_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.REPLAY])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', replay_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.replay_policy == replay_policy.ALL
+
+    class TestTestPolicy():
+
+      def test_policy_test_mode_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--policy', mock_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_policy == mock_policy.FOUND
+
+      def test_policy_without_mode_test_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.TEST])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', mock_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_policy == mock_policy.FOUND
+
+    class TestInvalidPolicyInput():
+      # Since all modes use 'all', we need to check what's unique to each mode
+
+      def test_policy_invalid_for_mock_mode(self, runner: CliRunner):
+        # Use record_policy.API which is not valid for MOCK mode
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', record_policy.API])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+      def test_policy_invalid_for_record_mode(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', record_policy.NOT_FOUND])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+      def test_policy_invalid_for_replay_mode(self, runner: CliRunner):
+        # Use record_policy.API which is not valid for REPLAY mode
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.REPLAY, '--policy', record_policy.API])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+      def test_policy_invalid_for_test_mode(self, runner: CliRunner):
+        # Use record_policy.API which is not valid for TEST mode
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--policy', record_policy.API])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+  class TestStrategy():
+
+    class TestRecordStrategy():
+
+      def test_strategy_record_mode_full(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_strategy == record_strategy.FULL
+
+      def test_strategy_record_mode_minimal(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--strategy', record_strategy.MINIMAL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_strategy == record_strategy.MINIMAL
+
+      def test_strategy_without_mode_record_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.RECORD])
+        configure_result = runner.invoke(intercept, ['configure', '--strategy', record_strategy.MINIMAL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_strategy == record_strategy.MINIMAL
+
+    @pytest.mark.skip(reason="Switching modes during tests is finnicky and leads to test failures")
+    class TestTestStrategy():
+
+      def test_strategy_test_mode_contract(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--strategy', test_strategy.CONTRACT])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_strategy == test_strategy.CONTRACT
+
+      def test_strategy_test_mode_diff(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--strategy', test_strategy.DIFF])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_strategy == test_strategy.DIFF
+
+      def test_strategy_without_mode_test_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.TEST])
+        configure_result = runner.invoke(intercept, ['configure', '--strategy', test_strategy.FUZZY])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_strategy == test_strategy.FUZZY
+
+    class TestInvalidInput():
+      def test_strategy_mock_mode_error(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 1
+        assert "Error: set --strategy to a intercept mode that supports the strategy option" in configure_result.output
+
+      def test_strategy_replay_mode_error(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.REPLAY, '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 1
+        assert "Error: set --strategy to a intercept mode that supports the strategy option" in configure_result.output
+
+      def test_strategy_without_mode_unsupported_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.MOCK])
+        configure_result = runner.invoke(intercept, ['configure', '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 1
+        assert "Error: set --strategy to a intercept mode that supports the strategy option" in configure_result.output

stoobly_agent/test/app/cli/scaffold/cli_invoker.py

@@ -66,14 +66,15 @@ class ScaffoldCliInvoker():
     if https == True:
       scheme = 'https'
       port = '443'
-    proxy_mode_reverse_spec = f"reverse:{scheme}://{hostname}:8080"
 
     result = runner.invoke(scaffold, ['service', 'create',
       '--app-dir-path', app_dir_path,
       '--hostname', hostname,
       '--scheme', scheme,
       '--port', port,
-      '--proxy-mode', proxy_mode_reverse_spec,
+      '--proxy-mode', 'reverse',
+      '--upstream-hostname', hostname,
+      '--upstream-port', 8080,
       '--detached',
       '--quiet',
       '--workflow', 'test',

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

@@ -1 +1 @@
-1.9.6
+1.9.12

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

@@ -2,6 +2,7 @@ import os
 import pdb
 import pytest
 import requests
+import shutil
 
 from click.testing import CliRunner
 from mitmproxy.http import Request as MitmproxyRequest
@@ -156,6 +157,14 @@ class TestEvalFixturesService():
       assert res != None
       return res
 
+    @pytest.fixture()
+    def public_directory_default_response(self, index_file_path: str, mitmproxy_request: MitmproxyRequest, public_directory: str):
+      path = os.path.join(public_directory, 'index')
+      shutil.move(index_file_path, path)
+      res: requests.Response = eval_fixtures(mitmproxy_request, public_directory_path=public_directory)
+      assert res != None
+      return res
+
     def test_it_sets_contents(
       self, public_directory_response: requests.Response, index_file_contents: str
     ):
@@ -164,5 +173,8 @@ class TestEvalFixturesService():
     def test_it_headers(self, public_directory_response: requests.Response):
       assert public_directory_response.headers['Content-Type'] == 'text/html'
     
-    def test_it_sets_status_code(self,  public_directory_response: requests.Response):
-      assert public_directory_response.status_code == 200
+    def test_it_sets_status_code(self, public_directory_response: requests.Response):
+      assert public_directory_response.status_code == 200
+
+    def test_default_it_headers(self, public_directory_default_response: requests.Response):
+      assert public_directory_default_response.headers['Content-Type'] == 'application/json'

stoobly_agent/test/app/proxy/utils/minimize_headers_test.py

@@ -0,0 +1,342 @@
+import copy
+import time
+
+from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow
+from mitmproxy.http import Request, Response, Headers
+from stoobly_agent.app.proxy.utils.minimize_headers import (
+    minimize_headers, 
+    minimize_request_headers, 
+    minimize_response_headers,
+    REQUEST_HEADERS_ALLOWLIST,
+    RESPONSE_HEADERS_ALLOWLIST,
+)
+
+
+class TestMinimizeHeaders():
+
+    def test_minimize_request_headers(self):
+        headers_stub = [
+            # Essential headers (should be preserved)
+            (b"Host", b"api.example.com"),
+            (b"User-Agent", b"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"),
+            (b"Accept", b"application/json, text/plain, */*"),
+            (b"Accept-Language", b"en-US,en;q=0.9"),
+            (b"Accept-Encoding", b"gzip, deflate, br"),
+            (b"Content-Type", b"application/json"),
+            (b"Content-Length", b"42"),
+            (b"Origin", b"https://example.com"),
+            (b"Referer", b"https://example.com/page"),
+            
+            # Headers that should be removed
+            (b"Cookie", b"session=abc123; user=john"),
+            (b"Authorization", b"Bearer token123"),
+            (b"X-Request-ID", b"req-uuid-123"),
+            (b"X-Forwarded-For", b"192.168.1.1"),
+            (b"X-Custom-Header", b"custom-value"),
+            (b"Sec-Fetch-Mode", b"cors"),
+            (b"Sec-Fetch-Dest", b"empty"),
+            (b"DNT", b"1"),
+        ]
+        headers = Headers(headers_stub)
+
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = Request(
+            host="api.example.com",
+            port=443,
+            method="POST",
+            scheme="https",
+            authority="api.example.com",
+            path="/api/v1/data",
+            http_version="HTTP/1.1",
+            headers=headers,
+            content=b'{"data": "test"}',
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+
+        old_headers = copy.deepcopy(flow_stub.request.headers)
+
+        minimize_request_headers(flow_stub)
+
+        new_headers = flow_stub.request.headers
+
+        # Non-essential headers should be removed
+        assert old_headers != new_headers
+        assert "Cookie" in old_headers
+        assert "Cookie" not in new_headers
+        assert "Authorization" not in new_headers
+        assert "X-Request-ID" not in new_headers
+        assert "X-Forwarded-For" not in new_headers
+        assert "X-Custom-Header" not in new_headers
+        assert "Sec-Fetch-Mode" not in new_headers
+        assert "Sec-Fetch-Dest" not in new_headers
+        assert "DNT" not in new_headers
+
+        # Essential headers should remain
+        assert "Host" in new_headers
+        assert "User-Agent" in new_headers
+        assert "Accept" in new_headers
+        assert "Accept-Language" in new_headers
+        assert "Accept-Encoding" in new_headers
+        assert "Content-Type" in new_headers
+        assert "Content-Length" in new_headers
+        assert "Origin" in new_headers
+        assert "Referer" in new_headers
+
+    def test_minimize_response_headers(self):
+        headers_stub = [
+            # Essential headers (should be preserved)
+            (b"Content-Type", b"application/json"),
+            (b"Content-Length", b"1234"),
+            (b"Date", b"Wed, 21 Oct 2015 07:28:00 GMT"),
+            (b"Server", b"nginx/1.18.0"),
+            (b"Transfer-Encoding", b"chunked"),
+            
+            # Headers that should be removed
+            (b"Set-Cookie", b"session=new; HttpOnly; Secure"),
+            (b"X-Powered-By", b"Express"),
+            (b"X-Request-ID", b"resp-uuid-456"),
+            (b"Access-Control-Allow-Origin", b"*"),
+            (b"Vary", b"Accept-Encoding"),
+            (b"ETag", b'"abc123"'),
+            (b"Last-Modified", b"Tue, 20 Oct 2015 07:28:00 GMT"),
+        ]
+        headers = Headers(headers_stub)
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.response = Response(
+            http_version="HTTP/1.1",
+            status_code=200,
+            reason="OK",
+            headers=headers,
+            content=b"{}",
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        old_headers = copy.deepcopy(flow_stub.response.headers)
+
+        minimize_response_headers(flow_stub)
+        
+        new_headers = flow_stub.response.headers
+        # Non-essential headers should be removed
+        assert old_headers != new_headers
+        assert "Set-Cookie" in old_headers
+        assert "Set-Cookie" not in new_headers
+        assert "X-Powered-By" not in new_headers
+        assert "X-Request-ID" not in new_headers
+        assert "Access-Control-Allow-Origin" not in new_headers
+        assert "Vary" not in new_headers
+        assert "ETag" not in new_headers
+        assert "Last-Modified" not in new_headers
+        
+        # Essential headers should remain
+        assert "Content-Type" in new_headers
+        assert "Content-Length" in new_headers
+        assert "Date" in new_headers
+        assert "Server" in new_headers
+        assert "Transfer-Encoding" in new_headers
+        
+        # Verify exact header count (Content-Type, Content-Length, Date, Server, Transfer-Encoding)
+        assert len(new_headers) == 5
+
+    def test_minimize_headers(self):
+        req_headers = Headers([
+            (b"Host", b"example.com"),
+            (b"X-Remove-Me", b"bye")
+        ])
+        res_headers = Headers([
+            (b"Content-Type", b"text/html"),
+            (b"X-Remove-Me", b"bye")
+        ])
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = Request(
+            host="example.com",
+            port=80,
+            method="GET",
+            scheme="http",
+            authority="example.com",
+            path="/",
+            http_version="HTTP/1.1",
+            headers=req_headers,
+            content=None,
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        flow_stub.response = Response(
+            http_version="HTTP/1.1",
+            status_code=200,
+            reason="OK",
+            headers=res_headers,
+            content=b"<html></html>",
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        old_req_headers = copy.deepcopy(flow_stub.request.headers)
+        old_res_headers = copy.deepcopy(flow_stub.response.headers)
+        
+        minimize_headers(flow_stub)
+        
+        # Verify changes occurred
+        assert old_req_headers != flow_stub.request.headers
+        assert old_res_headers != flow_stub.response.headers
+        
+        # Verify specific header removal and retention
+        assert "X-Remove-Me" not in flow_stub.request.headers
+        assert "X-Remove-Me" not in flow_stub.response.headers
+        assert "Host" in flow_stub.request.headers
+        assert "Content-Type" in flow_stub.response.headers
+        
+        # Verify header counts
+        assert len(flow_stub.request.headers) == 1
+        assert len(flow_stub.response.headers) == 1
+
+    def test_empty_headers(self):
+        """Test minimize functions with empty headers"""
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = Request(
+            host="example.com",
+            port=80,
+            method="GET",
+            scheme="http",
+            authority="example.com",
+            path="/",
+            http_version="HTTP/1.1",
+            headers=Headers(),
+            content=None,
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        flow_stub.response = Response(
+            http_version="HTTP/1.1",
+            status_code=200,
+            reason="OK",
+            headers=Headers(),
+            content=b"",
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        
+        # Should not raise any errors
+        minimize_headers(flow_stub)
+        assert len(flow_stub.request.headers) == 0
+        assert len(flow_stub.response.headers) == 0
+
+    def test_case_sensitivity(self):
+        """Test that header matching is case-insensitive"""
+        headers_stub = [
+            (b"host", b"example.com"),  # lowercase
+            (b"USER-AGENT", b"test-agent"),  # uppercase
+            (b"Content-Type", b"application/json"),  # mixed case
+            (b"x-remove-me", b"bye"),  # should be removed
+        ]
+        headers = Headers(headers_stub)
+        
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = Request(
+            host="example.com",
+            port=80,
+            method="POST",
+            scheme="http",
+            authority="example.com",
+            path="/",
+            http_version="HTTP/1.1",
+            headers=headers,
+            content=b'{"test": "data"}',
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        
+        minimize_request_headers(flow_stub)
+        
+        # Case-insensitive matching should preserve these headers
+        assert "host" in flow_stub.request.headers
+        assert "USER-AGENT" in flow_stub.request.headers
+        assert "Content-Type" in flow_stub.request.headers
+        
+        # Non-allowed header should be removed regardless of case
+        assert "x-remove-me" not in flow_stub.request.headers
+
+    def test_minimize_headers_no_response(self):
+        """Test minimize_headers when response is None"""
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = Request(
+            host="example.com",
+            port=80,
+            method="GET",
+            scheme="http",
+            authority="example.com",
+            path="/",
+            http_version="HTTP/1.1",
+            headers=Headers([(b"Host", b"example.com"), (b"X-Remove", b"me")]),
+            content=None,
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        flow_stub.response = None
+        
+        # Should not raise an error when response is None
+        minimize_request_headers(flow_stub)
+        assert "Host" in flow_stub.request.headers
+        assert "X-Remove" not in flow_stub.request.headers
+
+    def test_minimize_headers_no_request(self):
+        """Test minimize_headers when request is None"""
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = None
+        flow_stub.response = Response(
+            http_version="HTTP/1.1",
+            status_code=200,
+            reason="OK",
+            headers=Headers([(b"Content-Type", b"text/html"), (b"X-Remove", b"me")]),
+            content=b"<html></html>",
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        
+        # Should not raise an error when request is None
+        minimize_response_headers(flow_stub)
+        assert "Content-Type" in flow_stub.response.headers
+        assert "X-Remove" not in flow_stub.response.headers
+
+    def test_header_ordering_preserved(self):
+        """Test that header ordering is preserved after minimization"""
+        headers_stub = [
+            (b"Host", b"example.com"),
+            (b"User-Agent", b"test-agent"),
+            (b"Accept", b"application/json"),
+            (b"X-Remove-1", b"bye"),
+            (b"Content-Type", b"application/json"),
+            (b"X-Remove-2", b"bye"),
+        ]
+        headers = Headers(headers_stub)
+        
+        flow_stub = MitmproxyHTTPFlow(client_conn=None, server_conn=None)
+        flow_stub.request = Request(
+            host="example.com",
+            port=80,
+            method="POST",
+            scheme="http",
+            authority="example.com",
+            path="/",
+            http_version="HTTP/1.1",
+            headers=headers,
+            content=b'{"test": "data"}',
+            trailers=None,
+            timestamp_start=time.time(),
+            timestamp_end=time.time() + 1,
+        )
+        
+        minimize_request_headers(flow_stub)
+        
+        # Check that remaining headers maintain relative order
+        remaining_headers = list(flow_stub.request.headers.keys())
+        expected_order = ["Host", "User-Agent", "Accept", "Content-Type"]
+        assert remaining_headers == expected_order