Vert.x WebSocket returning 200 instead of 101

I'm trying to set up a basic HTTP and WebSocket Vert.x server, but the WebSocket route is always returning a 200 instead of a 101.

public class PhilTheServer extends AbstractVerticle {

    private final static int PORT = 8080;

    @Override
    public void start(Future<Void> fut) {
        // Create a router object.
        Router router = Router.router(vertx);

        // We need cookies, sessions and request bodies
        router.route().handler(CookieHandler.create());
        router.route().handler(BodyHandler.create());

        router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));

        // Simple auth service which uses a properties file for user/role info
        AuthProvider authProvider = ShiroAuth.create(vertx, new ShiroAuthOptions()
                .setType(ShiroAuthRealmType.PROPERTIES)
                .setConfig(new JsonObject()
                    .put("properties_path", "src/main/resources/vertx-users.properties")));

        // We need a user session handler too to make sure the user is stored in the session between requests
        router.route().handler(UserSessionHandler.create(authProvider));

        // Serve the static private pages from directory "webroot"
        router.route("/static/*").handler(StaticHandler.create("webroot/static").setCachingEnabled(false));

        // Public Index Page
        router.get("/").handler(ctx -> {
            ctx.response().sendFile("webroot/index.html");
        });

        router.mountSubRouter("/api", APIRoutes.get(vertx, authProvider));

        // Default non-handled requests:
        router.route().handler(ctx -> {
            ctx.fail(404);
        });

        // WEBSOCKET:

        BridgeOptions opts = new BridgeOptions()
            .addInboundPermitted(new PermittedOptions().setAddressRegex("*"))
            .addOutboundPermitted(new PermittedOptions().setAddressRegex("*"));

        // Create the event bus bridge and add it to the router.
        SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts, event -> {
            if (event.type() == BridgeEventType.SOCKET_CREATED) {
                System.out.println("A socket was created");
            } else {
                System.out.println(event.type());
            }

            event.complete(true);
        });

        router.route("/eventbus/*").handler(ebHandler);

        // Create the HTTP server and pass the "accept" method to the request handler.
        vertx
            .createHttpServer()
            .requestHandler(router::accept)
            .listen(
                    // Retrieve the port from the configuration,
                    // default to 8080.
                    config().getInteger("http.port", 8080),
                    result -> {
                        if (result.succeeded()) {
                            fut.complete();
                        } else {
                            fut.fail(result.cause());
                        }
                    }
            );
    }
}

Instead of adding a SockJSHanlder, I have tried to use websocketHandler on the HttpServer, and that's working fine, but I would like to do it the other way around.

My test code:

HttpClient httpClient = client.websocket(PORT, "localhost", "/eventbus", headers, ws -> {
    ws.handler(buffer -> {
        JsonObject message = new JsonObject(buffer.toString());

        assertTrue(message.containsKey("type"));

        ws.close();

        async.complete();
    });

    ws.write(Buffer.buffer("{ \"type\": \"test\"}"));
});