Fix ASGI scope caching bug: treat method as dynamic field

The scope cache was keyed by path but method was not in the dynamic
fields list. This caused incorrect method values when the same path
was accessed with different HTTP methods (e.g., GET /path then POST
/path would return method="GET" for both).

Changes:
- Add ATOM_ASGI_METHOD for efficient map lookup
- Update method in update_dynamic_scope_fields()
- Remove method from cached template in get_cached_scope()
- Add unit test to verify method caching behavior

Author: benoitc

c_src/py_asgi.c

@@ -55,6 +55,7 @@ ERL_NIF_TERM ATOM_ASGI_PATH;
 ERL_NIF_TERM ATOM_ASGI_HEADERS;
 ERL_NIF_TERM ATOM_ASGI_CLIENT;
 ERL_NIF_TERM ATOM_ASGI_QUERY_STRING;
+ERL_NIF_TERM ATOM_ASGI_METHOD;
 
 /* Resource type for zero-copy body buffers */
 ErlNifResourceType *ASGI_BUFFER_RESOURCE_TYPE = NULL;
@@ -1128,7 +1129,7 @@ static void asgi_cleanup_scope_cache(void) {
 /**
  * @brief Update dynamic fields in a cloned scope
  *
- * Updates client, headers, and query_string which vary per request.
+ * Updates client, headers, query_string, and method which vary per request.
  */
 static int update_dynamic_scope_fields(ErlNifEnv *env, PyObject *scope,
                                         ERL_NIF_TERM scope_map) {
@@ -1237,6 +1238,20 @@ static int update_dynamic_scope_fields(ErlNifEnv *env, PyObject *scope,
         }
     }
 
+    /* Update method - use Erlang atom for map lookup */
+    if (enif_get_map_value(env, scope_map, ATOM_ASGI_METHOD, &value)) {
+        ErlNifBinary method_bin;
+        if (enif_inspect_binary(env, value, &method_bin)) {
+            PyObject *py_method = asgi_get_method((char *)method_bin.data, method_bin.size);
+            if (py_method == NULL) return -1;
+            if (PyDict_SetItem(scope, state->key_method, py_method) < 0) {
+                Py_DECREF(py_method);
+                return -1;
+            }
+            Py_DECREF(py_method);
+        }
+    }
+
     return 0;
 }
 
@@ -2378,6 +2393,7 @@ static PyObject *get_cached_scope(ErlNifEnv *env, ERL_NIF_TERM scope_map) {
         PyDict_DelItem(template, state->key_client);
         PyDict_DelItem(template, state->key_headers);
         PyDict_DelItem(template, state->key_query_string);
+        PyDict_DelItem(template, state->key_method);
         PyErr_Clear();  /* DelItem may fail if key doesn't exist */
 
         /* If replacing entry from different interpreter, release old reference

c_src/py_asgi.h

@@ -115,6 +115,7 @@ extern ERL_NIF_TERM ATOM_ASGI_PATH;
 extern ERL_NIF_TERM ATOM_ASGI_HEADERS;
 extern ERL_NIF_TERM ATOM_ASGI_CLIENT;
 extern ERL_NIF_TERM ATOM_ASGI_QUERY_STRING;
+extern ERL_NIF_TERM ATOM_ASGI_METHOD;
 
 /* Resource type for zero-copy body buffers */
 extern ErlNifResourceType *ASGI_BUFFER_RESOURCE_TYPE;

c_src/py_nif.c

@@ -1782,6 +1782,7 @@ static int load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info) {
     ATOM_ASGI_HEADERS = enif_make_atom(env, "headers");
     ATOM_ASGI_CLIENT = enif_make_atom(env, "client");
     ATOM_ASGI_QUERY_STRING = enif_make_atom(env, "query_string");
+    ATOM_ASGI_METHOD = enif_make_atom(env, "method");
 
     /* ASGI buffer resource type for zero-copy body handling */
     ASGI_BUFFER_RESOURCE_TYPE = enif_open_resource_type(

test/py_SUITE.erl

@@ -53,6 +53,7 @@
     test_asgi_header_caching/1,
     test_asgi_status_codes/1,
     test_asgi_scope_caching/1,
+    test_asgi_scope_method_caching/1,
     test_asgi_zero_copy_buffer/1,
     test_asgi_lazy_headers/1
 ]).
@@ -102,6 +103,7 @@ all() ->
         test_asgi_header_caching,
         test_asgi_status_codes,
         test_asgi_scope_caching,
+        test_asgi_scope_method_caching,
         test_asgi_zero_copy_buffer,
         test_asgi_lazy_headers
     ].
@@ -1045,6 +1047,65 @@ test_asgi_scope_caching(_Config) ->
     ct:pal("Scope caching test passed~n"),
     ok.
 
+%% Test that method is correctly updated when scope cache is hit
+%% This verifies the fix for the bug where method was cached with the path
+%% causing GET /path followed by POST /path to return method="GET"
+test_asgi_scope_method_caching(_Config) ->
+    %% This test uses the NIF directly to verify scope caching behavior.
+    %% The scope cache keys on path, so we need to verify that method
+    %% is treated as a dynamic field and updated on cache hits.
+
+    %% Build first scope with GET method
+    Scope1Map = #{
+        type => <<"http">>,
+        asgi => #{version => <<"3.0">>, spec_version => <<"2.3">>},
+        http_version => <<"1.1">>,
+        method => <<"GET">>,
+        scheme => <<"http">>,
+        path => <<"/api/test">>,
+        raw_path => <<"/api/test">>,
+        query_string => <<>>,
+        root_path => <<>>,
+        headers => [{<<"host">>, <<"localhost">>}],
+        server => {<<"localhost">>, 8080},
+        client => {<<"127.0.0.1">>, 12345}
+    },
+    {ok, ScopeRef1} = py_nif:asgi_build_scope(Scope1Map),
+
+    %% Build second scope with POST method on same path (should hit cache)
+    Scope2Map = Scope1Map#{
+        method => <<"POST">>,
+        headers => [{<<"content-type">>, <<"application/json">>}],
+        client => {<<"127.0.0.1">>, 12346}
+    },
+    {ok, ScopeRef2} = py_nif:asgi_build_scope(Scope2Map),
+
+    %% Build third scope with PUT method on same path
+    Scope3Map = Scope1Map#{
+        method => <<"PUT">>,
+        headers => [{<<"content-type">>, <<"text/plain">>}],
+        client => {<<"127.0.0.1">>, 12347}
+    },
+    {ok, ScopeRef3} = py_nif:asgi_build_scope(Scope3Map),
+
+    %% Verify each scope has the correct method by extracting from Python dict
+    {ok, <<"GET">>} = py:eval(<<"scope['method']">>, #{scope => ScopeRef1}),
+    {ok, <<"POST">>} = py:eval(<<"scope['method']">>, #{scope => ScopeRef2}),
+    {ok, <<"PUT">>} = py:eval(<<"scope['method']">>, #{scope => ScopeRef3}),
+
+    %% Also verify other dynamic fields are correctly set
+    {ok, {<<"127.0.0.1">>, 12345}} = py:eval(<<"tuple(scope['client'])">>, #{scope => ScopeRef1}),
+    {ok, {<<"127.0.0.1">>, 12346}} = py:eval(<<"tuple(scope['client'])">>, #{scope => ScopeRef2}),
+    {ok, {<<"127.0.0.1">>, 12347}} = py:eval(<<"tuple(scope['client'])">>, #{scope => ScopeRef3}),
+
+    %% Verify static fields are shared correctly (path should be same)
+    {ok, <<"/api/test">>} = py:eval(<<"scope['path']">>, #{scope => ScopeRef1}),
+    {ok, <<"/api/test">>} = py:eval(<<"scope['path']">>, #{scope => ScopeRef2}),
+    {ok, <<"/api/test">>} = py:eval(<<"scope['path']">>, #{scope => ScopeRef3}),
+
+    ct:pal("Scope method caching test passed~n"),
+    ok.
+
 %% Test zero-copy buffer handling for large bodies
 test_asgi_zero_copy_buffer(_Config) ->
     %% This test verifies that large bodies are handled correctly