Middleware at outer level?

[oTree-org]

Starlette puts ServerErrorMiddleware outside of all user middleware, but I have a middleware for commit/rollback of DB transaction that needs to be at the very outer level, because I want my custom error page to show the state of my SQLAlchemy instances before the transaction was rolled back.

In Starlette 0.14.1, reversing the order worked fine, but now, it causes the test client to break. Anytime an exception is raised in my endpoint, my test client just gets the HTML of the 500 page, rather than raising the exception that tells me what went wrong. This makes my assertRaises assertions fail. Below is an MRE showing this silent failure.

from starlette.applications import Starlette
from starlette.endpoints import HTTPEndpoint
from starlette.responses import HTMLResponse
from starlette.routing import Route
from starlette.testclient import TestClient
from starlette.middleware.errors import ServerErrorMiddleware
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.middleware import Middleware

def db_commit(): pass
def db_rollback(): pass


class CommitTransactionMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        response = await call_next(request)
        if response.status_code < 400:
            db_commit()
        else:
            db_rollback()
        return response


class Homepage(HTTPEndpoint):
    async def get(self, request):
    	1/0


class MyStarlette(Starlette):
    def build_middleware_stack(self):

        debug = self.debug
        error_handler = None
        exception_handlers = {}

        for key, value in self.exception_handlers.items():
            if key in (500, Exception):
                error_handler = value
            else:
                exception_handlers[key] = value

        middlewares = [
            # if i reverse the order, the program behaves as expected.
            Middleware(CommitTransactionMiddleware),
            Middleware(ServerErrorMiddleware, handler=error_handler, debug=debug),
        ]

        app = self.router
        for cls, options in reversed(middlewares):
            app = cls(app=app, **options)
        return app


app = MyStarlette(debug=True, routes=[
    Route('/', Homepage),
])


def test_it():
    client = TestClient(app)
    # this should raise ZeroDivisionError, but doesn't.
    response = client.get('/')


test_it()

Any advice on how to write a middleware that propagates exceptions properly?

[adriangb]

Can you do app: ASGIApp = MyMiddleware(Starlette(...)))?

[oTree-org]

Thank you for the reply! I will give it a try soon :)