from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient

from docs_src.dependencies.tutorial010_py39 import get_db


def test_get_db():
    app = FastAPI()

    @app.get("/")
    def read_root(c: Annotated[Any, Depends(get_db)]):
        return {"c": str(c)}

    client = TestClient(app)

    dbsession_mock = Mock()

    with patch(

        @Override
        public InputStream getInputStream() throws IOException {
            if (!connected) {
                connect();
            }
            try {
                final Blob blobObj = getBlob();
                if (blobObj == null) {
                    throw new IOException("Object not found: bucket=" + bucketName + ", object=" + objectName);
                }

@pytest.fixture(name="app")
def app_fixture(call_counter: dict[str, int]):
    def get_db():
        call_counter["count"] += 1
        return f"db_{call_counter['count']}"

    def get_user(db: Annotated[str, Depends(get_db)]):
        return "user"

    app = FastAPI()

    @app.get("/")
    def endpoint(
        db: Annotated[str, Depends(get_db)],
        user: Annotated[str, Security(get_user, scopes=["read"])],
    ):

import asyncio
from contextlib import asynccontextmanager
from unittest.mock import Mock, patch

from docs_src.dependencies.tutorial007_py39 import get_db


def test_get_db():  # Just for coverage
    async def test_async_gen():
        cm = asynccontextmanager(get_db)
        async with cm() as db_session:
            return db_session

    dbsession_moock = Mock()

    with patch(

async def get_db():
    db = DBSession()
    try:
        yield db
    finally:

    def __init__(self):
        self.db = DBSession()

    def __enter__(self):
        return self.db

    def __exit__(self, exc_type, exc_value, traceback):
        self.db.close()


async def get_db():
    with MySuperContextManager() as db:

    return {"message": "Hello World"}


app.add_api_route("/non_decorated_route", non_decorated_route)


@app.get("/text")
def get_text():
    return "Hello World"


@app.get("/path/{item_id}")
def get_id(item_id):
    return item_id


@app.get("/path/str/{item_id}")
def get_str_id(item_id: str):
    return item_id


@app.get("/path/int/{item_id}")
def get_int_id(item_id: int):
    return item_id

) -> Any:
    await websocket.accept()
    await websocket.send_json(
        {"func_is_open": function_session.open, "req_is_open": request_session.open}
    )


@app.websocket("/sub")
async def get_sub(websocket: WebSocket, sessions: NamedSessionsDep) -> Any:
    await websocket.accept()
    await websocket.send_json(
        {"named_session_open": sessions[0].open, "session_open": sessions[1].open}
    )

        yield json.dumps(
            {"func_is_open": function_session.open, "req_is_open": request_session.open}
        )

    return StreamingResponse(iter_data())


@app.get("/sub")
def get_sub(sessions: NamedSessionsDep) -> Any:
    def iter_data():
        yield json.dumps(
            {"named_session_open": sessions[0].open, "session_open": sessions[1].open}
        )

            final String path = paths[1];
            if (logger.isDebugEnabled()) {
                logger.debug("Parsed GCS path: bucket={}, objectPath={}", bucketName, path);
            }
            final Blob blob = getBlob(bucketName, path);
            if (blob == null) {
                final Set<RequestData> requestDataSet = new HashSet<>();