def test_path_signature_asserts():
test_router = Router()
match = "'item_id' is a path param, default not allowed"
with pytest.raises(AssertionError, match=match):
@test_router.get("/path/{item_id}")
def get_path_item_id(request, item_id="1"):
pass
def test_path_signature_warns_missing():
test_router = Router()
match = (r"Field\(s\) \('a_path_param', 'another_path_param'\) are in "
r"the view path, but were not found in the view signature.")
with pytest.warns(UserWarning, match=match):
@test_router.get("/path/{a_path_param}/{another_path_param}")
def get_path_item_id(request):
pass
def test_reuse_router_error():
test_api = NinjaAPI()
test_router = Router()
test_api.add_router("/", test_router)
# django debug server can attempt to import the urls twice when errors exist
# verify we get the correct error reported
match = "Router@'/another-path' has already been attached to API NinjaAPI:1.0.0"
with pytest.raises(ConfigError, match=match):
with mock.patch("ninja.main._imported_while_running_in_debug_server",
False):
test_api.add_router("/another-path", test_router)
# The error should be ignored under debug server to allow other errors to be reported
with mock.patch("ninja.main._imported_while_running_in_debug_server",
True):
test_api.add_router("/another-path", test_router)
from ninja import NinjaAPI, Router
import pytest
from ninja.testing import TestClient
api = NinjaAPI()
@api.get("/endpoint")
def global_op(request):
return "global"
first_router = Router()
@first_router.get("/endpoint")
def router_op1(request):
return "first"
second_router_one = Router()
@second_router_one.get("endpoint_1")
def router_op2(request):
return "second 1"
second_router_two = Router()
from ninja import Router, File
from ninja.files import UploadedFile
from ninja.renderers import BaseRenderer
from ninja.errors import ValidationError
from ninja.errors import HttpError
from ninja import errors
from ninja.params import Form
import json
import codecs
import time
import random
import asyncio
from asgiref.sync import sync_to_async,async_to_sync
api = Router()
# @api.get("/say-after",auth=None)
# async def say_after(request, delay: int, word: str):
# await asyncio.sleep(delay)
# return {"saying": word}
# @api.get("/say-sync",auth=None)
# def say_after_sync(request, delay: int, word: str):
# time.sleep(delay)
# return {"saying": word}
'''USER'''
@api.get("/users/{user_id}",response=schemas.UserSchema, tags=["users"])
async def get_user(request, user_id: int):
"""
author: @bugmaster
date: 2022-01-27
function: 项目管理
"""
from ninja import Router
from ninja import Schema, Path
from ninja.pagination import paginate, PaginationBase
from project.models import Project
from typing import List
from utils.pagination import CustomPagination
from utils.response import response, Error
router = Router(tags=["project"])
@router.get('/{project_id}/')
def get_project(request, project_id: int):
"""
获取项目详情
"""
try:
p = Project.objects.get(id=project_id, is_delete=False)
except Project.DoesNotExist:
return response(error=Error.PROJECT_ID_NULL)
data = {
"id": p.id, "name": p.name, "describe": p.describe, "status": p.status, "create_time": p.create_time
}
return response(data=data)
from ninja.testing import TestClient
class Auth(APIKeyQuery):
def __init__(self, secret):
self.secret = secret
super().__init__()
def authenticate(self, request, key):
if key == self.secret:
return key
api = NinjaAPI()
r1 = Router()
r2 = Router()
r2_1 = Router()
@r1.get("/test")
def operation1(request):
return request.auth
@r2.get("/test")
def operation2(request):
return request.auth
@r2_1.get("/test")
from ninja import NinjaAPI, Router
import pytest
from client import NinjaClient
second_router = Router()
first_router = Router()
api = NinjaAPI()
@api.get("/endpoint")
def global_op(request):
return "global"
@first_router.get("/endpoint")
def router_op(request):
return "first"
@second_router.get("/endpoint")
def router_op(request):
return "second"
first_router.add_router("/second", second_router)
api.add_router("/first", first_router)
client = NinjaClient(api)
@pytest.mark.parametrize(
from django.shortcuts import get_object_or_404
from ninja import Router
from ninja.security import HttpBearer
from .schemas import PostIn, PostOut
from .models import Post
from typing import List
from auth.jwt import AuthBearer, AuthBearerAdmin
router_blog = Router()
@router_blog.post('/post', auth=AuthBearer(), summary='Create a post')
def create_post(request, payload: PostIn):
pay = dict(payload)
post = Post.objects.create(owner=request.auth,
title=pay['title'],
content=pay['content'])
return {'id': post.id}
@router_blog.get('/post/{post_id}', response=PostOut, summary='Get a post')
def get_post(request, post_id: int):
post = get_object_or_404(Post, id=post_id)
return post
@router_blog.get('/posts/',
response=List[PostOut],
auth=AuthBearerAdmin(),
summary='Get all posts *admin only*')
def list_posts(request):
from typing import List
from django.shortcuts import get_object_or_404
from ninja import Router
from . import models, schemas
from auth.jwt import AuthBearer
blog = Router()
@blog.get("/category", response=List[schemas.CategoryParent])
def gat_category(request):
return models.Category.objects.filter(published=True)
@blog.get("/post", response=List[schemas.Post])
def gat_list_post(request):
return models.Post.objects.filter(published=True)
@blog.get("/post/{post_pk}", response=schemas.Post)
def gat_single_post(request, post_pk: int):
return get_object_or_404(models.Post, id=post_pk, published=True)
@blog.post("/comment", response=schemas.Comment, auth=AuthBearer())
def create_comment(request, comment: schemas.CreateComment):
return models.Comment.objects.create(user=request.auth, **comment.dict())
@blog.put("/comment/{comment_id}", response=schemas.Comment, auth=AuthBearer())
from django.core.mail import send_mail
from django.core.mail import EmailMessage
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.utils.encoding import force_bytes, force_text
from django.template.loader import render_to_string
from ninja import Router, File
from ninja.files import UploadedFile
from ninja.renderers import BaseRenderer
from ninja.errors import ValidationError
from ninja.errors import HttpError
import random
# Create your views here.
app = Router()
# USER
@app.get('/auth_user', auth=AuthBearer(), response=schemas.UserCreateSchemaOut)
def get_auth(request):
return request.auth, request.get_host()
@app.post("/user", response=schemas.UserCreateSchemaOut, tags=["users"])
def create_user(request, data: schemas.UserCreateSchemaIn):
user = models.User(email=data.email, phone=data.phone,
is_active=False) # User is django auth.User
user.set_password(data.password)
try:
NoteRequestBody,
PageListOut,
SendEmailAuthIn,
SendEmailAuthOut,
SignUpRequestIn,
SignUpRequestOut,
VerificationCodeCheck400Response,
VerificationCodeCheckResponse,
VerificationCodeRequestBody,
)
from ninja import NinjaAPI, Router
from .schema import CtrlfIssueStatus, IssueListOut, TopicListOut
api = NinjaAPI(title="CtrlF Mock API Doc")
api_auth = Router(tags=["인증(SignUp, Login, Logout)"])
api.add_router("/auth/", api_auth)
@api_auth.post("/signup", summary="회원가입", response={200: SignUpRequestOut, 400: ErrorSignUp400Response})
def signup(request, request_body: SignUpRequestIn):
return request_body
@api_auth.get(
"/signup/nickname/duplicate",
summary="닉네임 중복검사",
response={
200: NickNameDuplicateCheckOut,
400: ErrorduplicateNickName400Response,
404: ErrorduplicateNickName404Response,
import pytest
from ninja import NinjaAPI, Path, Router
from ninja.testing import TestClient
api = NinjaAPI()
router_with_path_type = Router()
router_without_path_type = Router()
router_with_multiple = Router()
@router_with_path_type.get("/metadata")
def get_item_metadata(request, item_id: int = Path(None)) -> int:
return item_id
@router_without_path_type.get("/")
def get_item_metadata_2(request, item_id: str = Path(None)) -> str:
return item_id
@router_without_path_type.get("/metadata")
def get_item_metadata_3(request, item_id: str = Path(None)) -> str:
return item_id
@router_without_path_type.get("/")
def get_item_metadata_4(request, item_id: str = Path(None)) -> str:
return item_id
from ninja import Router
from ninja.responses import codes_4xx
from server.response import Message
from server.views.example import basic_get, auth_get
from usecases.viewmodel.example import ExampleJWTTokenVM, ExampleDataVM
router = Router()
router.post(path="/",
auth=None,
response={
200: ExampleJWTTokenVM,
codes_4xx: Message
})(basic_get)
router.get(path="/", response=ExampleDataVM)(auth_get)
from ninja import NinjaAPI, Router
import pytest
from client import NinjaClient
api = NinjaAPI()
@api.get("/endpoint")
def global_op(request):
return "global"
first_router = Router()
@first_router.get("/endpoint")
def router_op(request):
return "first"
second_router_one = Router()
@second_router_one.get("endpoint_1")
def router_op(request):
return "second 1"
second_router_two = Router()
from django.contrib.auth.hashers import check_password
from django.contrib.auth.models import User
from django.shortcuts import get_object_or_404
from ninja import Form, Router
from auth.jwt import create_token
api_auth = Router()
@api_auth.post('login')
def login(request, username: str = Form(...), password: str = Form(...)):
user = get_object_or_404(User, username=username)
if check_password(password, user.password):
return create_token(user.id)
import datetime
from ninja import Router
from ninja import Schema, Path
from ninja.pagination import paginate, PaginationBase
from project.models import Project
from typing import List
from utils.pagination import CustomPagination
from utils.response import response, Error
router = Router(tags=["module"])
# @router.get('/{event_id}')
# def event_details(request, event_id: int):
# event = Event.objects.get(id=event_id)
# return {"title": event.title, "details": event.details}
@router.get("/hello")
def hello(request):
return "Hello world"
@router.get("/items/{item_id}")
def read_item(request, item_id: int):
return {"item_id": item_id}
class PathDate(Schema):
year: int
month: int
day: int
from datetime import date
from typing import Union
from ninja import Router
from ninja.testing import TestClient
router = Router()
@router.get("/test")
def view(request, value: Union[date, str]):
return [value, type(value).__name__]
client = TestClient(router)
def test_union():
assert client.get("/test?value=today").json() == ["today", "str"]
assert client.get("/test?value=2020-01-15").json() == [
"2020-01-15", "date"
]
# TODO: test also schema
from django.contrib.auth.hashers import check_password
from django.contrib.auth.models import User
from django.shortcuts import get_object_or_404
from ninja import Form, Router
from auth.jwt import create_token
views = Router()
@views.post('login/')
def login(request, username: str = Form(...), password: str = Form(...)):
user = get_object_or_404(User, username=username)
if check_password(password, user.password):
return create_token(user.id)
