{* ../../docs_src/handling_errors/tutorial002_py39.py hl[14] *}

## Install custom exception handlers { #install-custom-exception-handlers }

You can add custom exception handlers with <a href="https://www.starlette.dev/exceptions/" class="external-link" target="_blank">the same exception utilities from Starlette</a>.

Let's say you have a custom exception `UnicornException` that you (or a library you use) might `raise`.

    captured_exception.exception = None
    try:
        client.get("/items/")
    except Exception:
        pass

    assert captured_exception.exception is not None
    error_str = str(captured_exception.exception)
    assert "get_item" in error_str
    assert "/items/" in error_str


def test_websocket_validation_error_includes_endpoint_context():
    captured_exception.exception = None
    try:

from pydantic import BaseModel, create_model
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.exceptions import WebSocketException as StarletteWebSocketException


class EndpointContext(TypedDict, total=False):
    function: str
    path: str
    file: str
    line: int


class HTTPException(StarletteHTTPException):
    """
    An HTTP exception you can raise in your own code to show errors to the client.

Wenn Sie eine Exception in einer Abhängigkeit mit `yield` abfangen, sollten Sie – sofern Sie nicht eine andere `HTTPException` oder Ähnliches auslösen – **die ursprüngliche Exception erneut auslösen**.

Sie können dieselbe Exception mit `raise` erneut auslösen:

{* ../../docs_src/dependencies/tutorial008d_an_py39.py hl[17] *}

If you use a `try` block in a dependency with `yield`, you'll receive any exception that was thrown when using the dependency.

For example, if some code at some point in the middle, in another dependency or in a *path operation*, made a database transaction "rollback" or created any other exception, you would receive the exception in your dependency.

So, you can look for that specific exception inside the dependency with `except SomeException`.

     *
     * @param level the severity level of the message
     * @param message the message to be logged
     * @param error the associated exception, or null if not applicable
     */
    void log(@Nonnull Level level, @Nonnull String message, @Nullable Throwable error);

    /**
     * Logs a debug message without an associated exception.
     *

    }

    @Override
    @BeforeEach
    public void setUp() throws Exception {
        projectBuilder = getContainer().lookup(ProjectBuilder.class);
    }

    protected MavenProject getProject(Artifact pom, boolean allowStub) throws Exception {
        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();

                        false,
                        null,
                        true));

        // Verify that we get the same exception when the artifactId does not match the module name
        assertExceptionMessageContains("", "anotherArtifact");

        // Verify that no exception is thrown when the artifactId is the module name
        when(artifact.getArtifactId()).thenReturn("org.foo.bar");

        }

        @Test
        @DisplayName("should handle strategy exceptions gracefully")
        void shouldHandleStrategyExceptionsGracefully() throws Exception {
            UpgradeContext context = createMockContext();
            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), mock(Document.class));

            // Mock first strategy to throw exception
            when(mockStrategies.get(0).isApplicable(context)).thenReturn(true);

    }

    @BeforeEach
    @Override
    public void setUp() throws Exception {
        super.setUp();

        updateCheckManager = new DefaultUpdateCheckManager(
                new ConsoleLogger(Logger.LEVEL_DEBUG, "test"), new DefaultTrackingFileManager());
    }

    @Test
    void testArtifact() throws Exception {
        ArtifactRepository remoteRepository = remoteRepository();