 
     assert {_parts, stack} = Server.handle_head(stack, request)
 
-    assert [{Meddler, [response_body: "foo"]}, {NoOp, {:config, :head}}] ==
+    assert [{Meddler, [response_body: "foo"]}, {TrackStages, {:config, :head}}] ==
              Stack.get_middlewares(stack)
 
     assert {SpyServer, 1} == Stack.get_server(stack)
 
     {_parts, stack} = Server.handle_data(stack, "z")
 
-    assert [{Meddler, [response_body: "foo"]}, {NoOp, {:head, :data}}] ==
+    assert [{Meddler, [response_body: "foo"]}, {TrackStages, {:head, :data}}] ==
              Stack.get_middlewares(stack)
 
     assert {SpyServer, 2} == Stack.get_server(stack)
 
     {_parts, stack} = Server.handle_data(stack, "zz")
 
-    assert [{Meddler, [response_body: "foo"]}, {NoOp, {:data, :data}}] ==
+    assert [{Meddler, [response_body: "foo"]}, {TrackStages, {:data, :data}}] ==
              Stack.get_middlewares(stack)
 
     assert {SpyServer, 3} == Stack.get_server(stack)
 
     {_parts, stack} = Server.handle_tail(stack, [{"x-foo", "bar"}])
-    assert [{Meddler, _}, {NoOp, {:data, :tail}}] = Stack.get_middlewares(stack)
+    assert [{Meddler, _}, {TrackStages, {:data, :tail}}] = Stack.get_middlewares(stack)
     assert {SpyServer, -3} == Stack.get_server(stack)
   end
 

  end

  defmodule AlwaysForbidden do
    @behaviour Middleware

    @impl Middleware
    def process_head(_request, _config, inner_server) do


      {[response], nil, inner_server}
    end
  end

  # This test also checks that the default callbacks from `use` macro can be overridden.
  test "middlewares can \"short circuit\" processing (not call through)" do
    middlewares = [{TrackStages, nil}, {AlwaysForbidden, nil}]
    stack = make_stack(middlewares, SpyServer, :whatever)
    request = Raxx.request(:GET, "/")

