assert response.status_code == 400
    assert response.json() == {"detail": "Invalid X-Token header"}


def test_read_nonexistent_item():
    response = client.get("/items/baz", headers={"X-Token": "coneofsilence"})
    assert response.status_code == 404
    assert response.json() == {"detail": "Item not found"}


def test_create_item():
    response = client.post(
        "/items/",

                "HTTPValidationError": {
                    "title": "HTTPValidationError",
                    "type": "object",
                    "properties": {
                        "detail": {
                            "title": "Detail",
                            "type": "array",
                            "items": {"$ref": "#/components/schemas/ValidationError"},
                        }
                    },

     * Finally, return the result of the last expression part's resolution.</p>
     *
     * <p><b>NOTE:</b> The object-graph navigation actually takes place via the
     * {@link ReflectionValueExtractor} class.</p>
     */
    @Override
    public Object getValue(String expression) {
        if (expression == null || expression.trim().isEmpty()) {
            return null;
        }

        try {

            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Not authenticated",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return user


async def get_current_active_user(current_user: User = Depends(get_current_user)):
    if current_user.disabled:
        raise HTTPException(status_code=400, detail="Inactive user")
    return current_user


@app.post("/token")

            try:
                return await original_route_handler(request)
            except RequestValidationError as exc:
                body = await request.body()
                detail = {"errors": exc.errors(), "body": body.decode()}
                raise HTTPException(status_code=422, detail=detail)

        return custom_route_handler


app = FastAPI()

    )
    assert response.status_code == 404
    assert response.json() == {"detail": "Item not found"}


def test_items_plumbus_with_no_token(client: TestClient):
    response = client.get(
        "/items/plumbus", headers={"X-Token": "fake-super-secret-token"}
    )
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",

    }

    /**
     * Tests whether the output stream is currently open.
     *
     * @return whether the stream is open
     */
    public boolean isOpen() {
        return this.handle != null && this.handle.isValid();
    }

    /**
     * Ensures that the file handle is open and returns it.
     *
     * @return the open file handle
     * @throws CIFSException if an error occurs opening the file
     */

from .main import app

client = TestClient(app)


def test_query():
    response = client.get("/query")
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",
                "loc": ["query", "query"],
                "msg": "Field required",
                "input": None,
            }
        ]
    }

                "HTTPValidationError": {
                    "title": "HTTPValidationError",
                    "type": "object",
                    "properties": {
                        "detail": {
                            "title": "Detail",
                            "type": "array",
                            "items": {"$ref": "#/components/schemas/ValidationError"},
                        }
                    },

    return mod


def get_access_token(
    *, username="johndoe", password="secret", scope=None, client: TestClient
):
    data = {"username": username, "password": password}
    if scope:
        data["scope"] = scope
    response = client.post("/token", data=data)
    content = response.json()
    access_token = content.get("access_token")
    return access_token