✨ Test using the TestClient

{{cookiecutter.project_slug}}/backend/app/app/tests/api/api_v1/test_celery.py

@@ -1,16 +1,16 @@
 from typing import Dict
 
-import requests
+from fastapi.testclient import TestClient
 
 from app.core.config import settings
-from app.tests.utils.utils import get_server_api
 
 
-def test_celery_worker_test(superuser_token_headers: Dict[str, str]) -> None:
- server_api = get_server_api()
+def test_celery_worker_test(
+ client: TestClient, superuser_token_headers: Dict[str, str]
+) -> None:
  data = {"msg": "test"}
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/utils/test-celery/",
+ r = client.post(
+ f"{settings.API_V1_STR}/utils/test-celery/",
  json=data,
  headers=superuser_token_headers,
  )

{{cookiecutter.project_slug}}/backend/app/app/tests/api/api_v1/test_items.py

@@ -1,18 +1,16 @@
-import requests
+from fastapi.testclient import TestClient
 from sqlalchemy.orm import Session
 
 from app.core.config import settings
 from app.tests.utils.item import create_random_item
-from app.tests.utils.utils import get_server_api
 
 
-def test_create_item(superuser_token_headers: dict, db: Session) -> None:
- server_api = get_server_api()
+def test_create_item(
+ client: TestClient, superuser_token_headers: dict, db: Session
+) -> None:
  data = {"title": "Foo", "description": "Fighters"}
- response = requests.post(
- f"{server_api}{settings.API_V1_STR}/items/",
- headers=superuser_token_headers,
- json=data,
+ response = client.post(
+ f"{settings.API_V1_STR}/items/", headers=superuser_token_headers, json=data,
  )
  assert response.status_code == 200
  content = response.json()
@@ -22,12 +20,12 @@ def test_create_item(superuser_token_headers: dict, db: Session) -> None:
  assert "owner_id" in content
 
 
-def test_read_item(superuser_token_headers: dict, db: Session) -> None:
+def test_read_item(
+ client: TestClient, superuser_token_headers: dict, db: Session
+) -> None:
  item = create_random_item(db)
- server_api = get_server_api()
- response = requests.get(
- f"{server_api}{settings.API_V1_STR}/items/{item.id}",
- headers=superuser_token_headers,
+ response = client.get(
+ f"{settings.API_V1_STR}/items/{item.id}", headers=superuser_token_headers,
  )
  assert response.status_code == 200
  content = response.json()

{{cookiecutter.project_slug}}/backend/app/app/tests/api/api_v1/test_login.py

@@ -1,31 +1,27 @@
 from typing import Dict
 
-import requests
+from fastapi.testclient import TestClient
 
 from app.core.config import settings
-from app.tests.utils.utils import get_server_api
 
 
-def test_get_access_token() -> None:
- server_api = get_server_api()
+def test_get_access_token(client: TestClient) -> None:
  login_data = {
  "username": settings.FIRST_SUPERUSER,
  "password": settings.FIRST_SUPERUSER_PASSWORD,
  }
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/login/access-token", data=login_data
- )
+ r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data)
  tokens = r.json()
  assert r.status_code == 200
  assert "access_token" in tokens
  assert tokens["access_token"]
 
 
-def test_use_access_token(superuser_token_headers: Dict[str, str]) -> None:
- server_api = get_server_api()
- r = requests.post(
-  f"{server_api}{settings.API_V1_STR}/login/test-token",
- headers=superuser_token_headers,
+def test_use_access_token(
+ client: TestClient, superuser_token_headers: Dict[str, str]
+) -> None:
+ r = client.post(
+ f"{settings.API_V1_STR}/login/test-token", headers=superuser_token_headers,
  )
  result = r.json()
  assert r.status_code == 200

{{cookiecutter.project_slug}}/backend/app/app/tests/api/api_v1/test_users.py

@@ -1,47 +1,44 @@
 from typing import Dict
 
-import requests
+from fastapi.testclient import TestClient
 from sqlalchemy.orm import Session
 
 from app import crud
 from app.core.config import settings
 from app.schemas.user import UserCreate
-from app.tests.utils.utils import get_server_api, random_email, random_lower_string
+from app.tests.utils.utils import random_email, random_lower_string
 
 
-def test_get_users_superuser_me(superuser_token_headers: Dict[str, str]) -> None:
- server_api = get_server_api()
- r = requests.get(
- f"{server_api}{settings.API_V1_STR}/users/me", headers=superuser_token_headers
- )
+def test_get_users_superuser_me(
+ client: TestClient, superuser_token_headers: Dict[str, str]
+) -> None:
+ r = client.get(f"{settings.API_V1_STR}/users/me", headers=superuser_token_headers)
  current_user = r.json()
  assert current_user
  assert current_user["is_active"] is True
  assert current_user["is_superuser"]
  assert current_user["email"] == settings.FIRST_SUPERUSER
 
 
-def test_get_users_normal_user_me(normal_user_token_headers: Dict[str, str]) -> None:
- server_api = get_server_api()
- r = requests.get(
- f"{server_api}{settings.API_V1_STR}/users/me", headers=normal_user_token_headers
- )
+def test_get_users_normal_user_me(
+ client: TestClient, normal_user_token_headers: Dict[str, str]
+) -> None:
+ r = client.get(f"{settings.API_V1_STR}/users/me", headers=normal_user_token_headers)
  current_user = r.json()
  assert current_user
  assert current_user["is_active"] is True
  assert current_user["is_superuser"] is False
  assert current_user["email"] == settings.EMAIL_TEST_USER
 
 
-def test_create_user_new_email(superuser_token_headers: dict, db: Session) -> None:
- server_api = get_server_api()
+def test_create_user_new_email(
+ client: TestClient, superuser_token_headers: dict, db: Session
+) -> None:
  username = random_email()
  password = random_lower_string()
  data = {"email": username, "password": password}
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/users/",
- headers=superuser_token_headers,
- json=data,
+ r = client.post(
+ f"{settings.API_V1_STR}/users/", headers=superuser_token_headers, json=data,
  )
  assert 200 <= r.status_code < 300
  created_user = r.json()
@@ -50,16 +47,16 @@ def test_create_user_new_email(superuser_token_headers: dict, db: Session) -> No
  assert user.email == created_user["email"]
 
 
-def test_get_existing_user(superuser_token_headers: dict, db: Session) -> None:
- server_api = get_server_api()
+def test_get_existing_user(
+ client: TestClient, superuser_token_headers: dict, db: Session
+) -> None:
  username = random_email()
  password = random_lower_string()
  user_in = UserCreate(email=username, password=password)
  user = crud.user.create(db, obj_in=user_in)
  user_id = user.id
- r = requests.get(
- f"{server_api}{settings.API_V1_STR}/users/{user_id}",
- headers=superuser_token_headers,
+ r = client.get(
+ f"{settings.API_V1_STR}/users/{user_id}", headers=superuser_token_headers,
  )
  assert 200 <= r.status_code < 300
  api_user = r.json()
@@ -69,40 +66,37 @@ def test_get_existing_user(superuser_token_headers: dict, db: Session) -> None:
 
 
 def test_create_user_existing_username(
- superuser_token_headers: dict, db: Session
+ client: TestClient, superuser_token_headers: dict, db: Session
 ) -> None:
- server_api = get_server_api()
  username = random_email()
  # username = email
  password = random_lower_string()
  user_in = UserCreate(email=username, password=password)
  crud.user.create(db, obj_in=user_in)
  data = {"email": username, "password": password}
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/users/",
- headers=superuser_token_headers,
- json=data,
+ r = client.post(
+ f"{settings.API_V1_STR}/users/", headers=superuser_token_headers, json=data,
  )
  created_user = r.json()
  assert r.status_code == 400
  assert "_id" not in created_user
 
 
-def test_create_user_by_normal_user(normal_user_token_headers: Dict[str, str]) -> None:
- server_api = get_server_api()
+def test_create_user_by_normal_user(
+ client: TestClient, normal_user_token_headers: Dict[str, str]
+) -> None:
  username = random_email()
  password = random_lower_string()
  data = {"email": username, "password": password}
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/users/",
- headers=normal_user_token_headers,
- json=data,
+ r = client.post(
+ f"{settings.API_V1_STR}/users/", headers=normal_user_token_headers, json=data,
  )
  assert r.status_code == 400
 
 
-def test_retrieve_users(superuser_token_headers: dict, db: Session) -> None:
- server_api = get_server_api()
+def test_retrieve_users(
+ client: TestClient, superuser_token_headers: dict, db: Session
+) -> None:
  username = random_email()
  password = random_lower_string()
  user_in = UserCreate(email=username, password=password)
@@ -113,9 +107,7 @@ def test_retrieve_users(superuser_token_headers: dict, db: Session) -> None:
  user_in2 = UserCreate(email=username2, password=password2)
  crud.user.create(db, obj_in=user_in2)
 
- r = requests.get(
- f"{server_api}{settings.API_V1_STR}/users/", headers=superuser_token_headers
- )
+ r = client.get(f"{settings.API_V1_STR}/users/", headers=superuser_token_headers)
  all_users = r.json()
 
  assert len(all_users) > 1

{{cookiecutter.project_slug}}/backend/app/app/tests/conftest.py

@@ -1,29 +1,34 @@
-from typing import Dict, Iterator
+from typing import Dict, Generator
 
 import pytest
+from fastapi.testclient import TestClient
 from sqlalchemy.orm import Session
 
 from app.core.config import settings
 from app.db.session import SessionLocal
+from app.main import app
 from app.tests.utils.user import authentication_token_from_email
-from app.tests.utils.utils import get_server_api, get_superuser_token_headers
+from app.tests.utils.utils import get_superuser_token_headers
 
 
 @pytest.fixture(scope="session")
-def db() -> Iterator[Session]:
+def db() -> Generator:
  yield SessionLocal()
 
 
 @pytest.fixture(scope="module")
-def server_api() -> str:
- return get_server_api()
+def client() -> Generator:
+ with TestClient(app) as c:
+ yield c
 
 
 @pytest.fixture(scope="module")
-def superuser_token_headers() -> Dict[str, str]:
- return get_superuser_token_headers()
+def superuser_token_headers(client: TestClient) -> Dict[str, str]:
+ return get_superuser_token_headers(client)
 
 
 @pytest.fixture(scope="module")
-def normal_user_token_headers(db: Session) -> Dict[str, str]:
- return authentication_token_from_email(email=settings.EMAIL_TEST_USER, db=db)
+def normal_user_token_headers(client: TestClient, db: Session) -> Dict[str, str]:
+ return authentication_token_from_email(
+ client=client, email=settings.EMAIL_TEST_USER, db=db
+ )

{{cookiecutter.project_slug}}/backend/app/app/tests/utils/user.py

@@ -1,23 +1,21 @@
 from typing import Dict
 
-import requests
+from fastapi.testclient import TestClient
 from sqlalchemy.orm import Session
 
 from app import crud
 from app.core.config import settings
 from app.models.user import User
 from app.schemas.user import UserCreate, UserUpdate
-from app.tests.utils.utils import get_server_api, random_email, random_lower_string
+from app.tests.utils.utils import random_email, random_lower_string
 
 
 def user_authentication_headers(
- server_api: str, email: str, password: str
+ *, client: TestClient, email: str, password: str
 ) -> Dict[str, str]:
  data = {"username": email, "password": password}
 
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/login/access-token", data=data
- )
+ r = client.post(f"{settings.API_V1_STR}/login/access-token", data=data)
  response = r.json()
  auth_token = response["access_token"]
  headers = {"Authorization": f"Bearer {auth_token}"}
@@ -32,7 +30,9 @@ def create_random_user(db: Session) -> User:
  return user
 
 
-def authentication_token_from_email(*, email: str, db: Session) -> Dict[str, str]:
+def authentication_token_from_email(
+ *, client: TestClient, email: str, db: Session
+) -> Dict[str, str]:
  """
  Return a valid token for the user with given email.
 
@@ -47,4 +47,4 @@ def authentication_token_from_email(*, email: str, db: Session) -> Dict[str, str
  user_in_update = UserUpdate(password=password)
  user = crud.user.update(db, db_obj=user, obj_in=user_in_update)
 
- return user_authentication_headers(get_server_api(), email, password)
+ return user_authentication_headers(client=client, email=email, password=password)

{{cookiecutter.project_slug}}/backend/app/app/tests/utils/utils.py

@@ -2,7 +2,7 @@
 import string
 from typing import Dict
 
-import requests
+from fastapi.testclient import TestClient
 
 from app.core.config import settings
 
@@ -15,22 +15,13 @@ def random_email() -> str:
  return f"{random_lower_string()}@{random_lower_string()}.com"
 
 
-def get_server_api() -> str:
- server_name = f"http://{settings.SERVER_NAME}"
- return server_name
-
-
-def get_superuser_token_headers() -> Dict[str, str]:
- server_api = get_server_api()
+def get_superuser_token_headers(client: TestClient) -> Dict[str, str]:
  login_data = {
  "username": settings.FIRST_SUPERUSER,
  "password": settings.FIRST_SUPERUSER_PASSWORD,
  }
- r = requests.post(
- f"{server_api}{settings.API_V1_STR}/login/access-token", data=login_data
- )
+ r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data)
  tokens = r.json()
  a_token = tokens["access_token"]
  headers = {"Authorization": f"Bearer {a_token}"}
- # superuser_token_headers = headers
  return headers

{{cookiecutter.project_slug}}/backend/app/app/tests_pre_start.py

@@ -3,7 +3,6 @@
 from tenacity import after_log, before_log, retry, stop_after_attempt, wait_fixed
 
 from app.db.session import SessionLocal
-from app.tests.api.api_v1.test_login import test_get_access_token
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -23,8 +22,6 @@ def init() -> None:
  # Try to create session to check if DB is awake
  db = SessionLocal()
  db.execute("SELECT 1")
- # Wait for API to be awake, run one simple tests to authenticate
- test_get_access_token()
  except Exception as e:
  logger.error(e)
  raise e