Minor backend housekeeping #17
|
@ -0,0 +1,9 @@
|
|||
import amanuensis.backend.article as artiq
|
||||
import amanuensis.backend.character as charq
|
||||
import amanuensis.backend.index as indq
|
||||
import amanuensis.backend.lexicon as lexiq
|
||||
import amanuensis.backend.membership as memq
|
||||
import amanuensis.backend.post as postq
|
||||
import amanuensis.backend.user as userq
|
||||
|
||||
__all__ = ["artiq", "charq", "indq", "lexiq", "memq", "postq", "userq"]
|
|
@ -7,7 +7,7 @@ from typing import Optional
|
|||
from sqlalchemy import select
|
||||
|
||||
from amanuensis.db import *
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def create(
|
||||
|
@ -21,11 +21,11 @@ def create(
|
|||
"""
|
||||
# Verify argument types are correct
|
||||
if not isinstance(lexicon_id, int):
|
||||
raise ArgumentError("lexicon_id")
|
||||
raise BackendArgumentTypeError(int, lexicon_id=lexicon_id)
|
||||
if not isinstance(user_id, int):
|
||||
raise ArgumentError("user_id")
|
||||
raise BackendArgumentTypeError(int, user_id=user_id)
|
||||
if character_id is not None and not isinstance(character_id, int):
|
||||
raise ArgumentError("character_id")
|
||||
raise BackendArgumentTypeError(int, character_id=character_id)
|
||||
|
||||
# Check that the user is a member of this lexicon
|
||||
mem: Membership = db(
|
||||
|
|
|
@ -7,7 +7,7 @@ from typing import Optional
|
|||
from sqlalchemy import select, func
|
||||
|
||||
from amanuensis.db import *
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def create(
|
||||
|
@ -22,13 +22,13 @@ def create(
|
|||
"""
|
||||
# Verify argument types are correct
|
||||
if not isinstance(lexicon_id, int):
|
||||
raise ArgumentError("lexicon_id")
|
||||
raise BackendArgumentTypeError(int, lexicon_id=lexicon_id)
|
||||
if not isinstance(user_id, int):
|
||||
raise ArgumentError("user_id")
|
||||
raise BackendArgumentTypeError(int, user_id=user_id)
|
||||
if not isinstance(name, str):
|
||||
raise ArgumentError("name")
|
||||
raise BackendArgumentTypeError(str, name=name)
|
||||
if signature is not None and not isinstance(signature, str):
|
||||
raise ArgumentError("signature")
|
||||
raise BackendArgumentTypeError(str, signature=signature)
|
||||
|
||||
# Verify character name is valid
|
||||
if not name.strip():
|
||||
|
|
|
@ -6,7 +6,7 @@ import re
|
|||
from typing import Optional
|
||||
|
||||
from amanuensis.db import DbContext, ArticleIndex, IndexType
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def create(
|
||||
|
@ -23,17 +23,17 @@ def create(
|
|||
"""
|
||||
# Verify argument types are correct
|
||||
if not isinstance(lexicon_id, int):
|
||||
raise ArgumentError("lexicon_id")
|
||||
raise BackendArgumentTypeError(int, lexicon_id=lexicon_id)
|
||||
if not isinstance(index_type, IndexType):
|
||||
raise ArgumentError("index_type")
|
||||
raise BackendArgumentTypeError(IndexType, index_type=index_type)
|
||||
if not isinstance(pattern, str):
|
||||
raise ArgumentError("pattern")
|
||||
raise BackendArgumentTypeError(str, pattern=pattern)
|
||||
if not isinstance(logical_order, int):
|
||||
raise ArgumentError("logical_order")
|
||||
raise BackendArgumentTypeError(int, logical_order=logical_order)
|
||||
if not isinstance(display_order, int):
|
||||
raise ArgumentError("display_order")
|
||||
raise BackendArgumentTypeError(int, display_order=display_order)
|
||||
if capacity is not None and not isinstance(capacity, int):
|
||||
raise ArgumentError("capacity")
|
||||
raise BackendArgumentTypeError(int, capacity=capacity)
|
||||
|
||||
# Verify the pattern is valid for the index type:
|
||||
if index_type == IndexType.CHAR:
|
||||
|
|
|
@ -8,7 +8,7 @@ from typing import Sequence, Optional
|
|||
from sqlalchemy import select, func
|
||||
|
||||
from amanuensis.db import DbContext, Lexicon, Membership
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
RE_ALPHANUM_DASH_UNDER = re.compile(r"^[A-Za-z0-9-_]*$")
|
||||
|
@ -25,7 +25,7 @@ def create(
|
|||
"""
|
||||
# Verify name
|
||||
if not isinstance(name, str):
|
||||
raise ArgumentError("Lexicon name must be a string")
|
||||
raise BackendArgumentTypeError(str, name=name)
|
||||
if not name.strip():
|
||||
raise ArgumentError("Lexicon name must not be blank")
|
||||
if not RE_ALPHANUM_DASH_UNDER.match(name):
|
||||
|
@ -34,12 +34,12 @@ def create(
|
|||
)
|
||||
|
||||
# Verify title
|
||||
if title is not None and not isinstance(name, str):
|
||||
raise ArgumentError("Lexicon name must be a string")
|
||||
if title is not None and not isinstance(title, str):
|
||||
raise BackendArgumentTypeError(str, title=title)
|
||||
|
||||
# Verify prompt
|
||||
if not isinstance(prompt, str):
|
||||
raise ArgumentError("Lexicon prompt must be a string")
|
||||
raise BackendArgumentTypeError(str, prompt=prompt)
|
||||
|
||||
# Query the db to make sure the lexicon name isn't taken
|
||||
if db(select(func.count(Lexicon.id)).where(Lexicon.name == name)).scalar() > 0:
|
||||
|
@ -55,11 +55,6 @@ def create(
|
|||
return new_lexicon
|
||||
|
||||
|
||||
def from_name(db: DbContext, name: str) -> Lexicon:
|
||||
"""Get a lexicon by its name."""
|
||||
return db(select(Lexicon).where(Lexicon.name == name)).scalar_one()
|
||||
|
||||
|
||||
def get_all(db: DbContext) -> Sequence[Lexicon]:
|
||||
"""Get all lexicons."""
|
||||
return db(select(Lexicon)).scalars()
|
||||
|
@ -75,3 +70,8 @@ def get_joined(db: DbContext, user_id: int) -> Sequence[Lexicon]:
|
|||
def get_public(db: DbContext) -> Sequence[Lexicon]:
|
||||
"""Get all publicly visible lexicons."""
|
||||
return db(select(Lexicon).where(Lexicon.public == True)).scalars()
|
||||
|
||||
|
||||
def try_from_name(db: DbContext, name: str) -> Optional[Lexicon]:
|
||||
"""Get a lexicon by its name, or None if no such lexicon was found."""
|
||||
return db(select(Lexicon).where(Lexicon.name == name)).scalar_one_or_none()
|
||||
|
|
|
@ -6,7 +6,7 @@ from sqlalchemy import select, func
|
|||
|
||||
from amanuensis.db import DbContext, Membership
|
||||
from amanuensis.db.models import Lexicon
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def create(
|
||||
|
@ -20,11 +20,11 @@ def create(
|
|||
"""
|
||||
# Verify argument types are correct
|
||||
if not isinstance(user_id, int):
|
||||
raise ArgumentError("user_id")
|
||||
raise BackendArgumentTypeError(int, user_id=user_id)
|
||||
if not isinstance(lexicon_id, int):
|
||||
raise ArgumentError("lexicon_id")
|
||||
raise BackendArgumentTypeError(int, lexicon_id=lexicon_id)
|
||||
if not isinstance(is_editor, bool):
|
||||
raise ArgumentError("is_editor")
|
||||
raise BackendArgumentTypeError(bool, is_editor=is_editor)
|
||||
|
||||
# Verify user has not already joined lexicon
|
||||
if (
|
||||
|
|
|
@ -8,7 +8,7 @@ from sqlalchemy import select
|
|||
|
||||
from amanuensis.db import DbContext, Post
|
||||
from amanuensis.db.models import Lexicon
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def create(
|
||||
|
@ -23,15 +23,15 @@ def create(
|
|||
|
||||
# Verify lexicon id
|
||||
if not isinstance(lexicon_id, int):
|
||||
raise ArgumentError("Lexicon id must be an integer.")
|
||||
raise BackendArgumentTypeError(int, lexicon_id=lexicon_id)
|
||||
|
||||
# Verify user_id
|
||||
if not (isinstance(user_id, int) or user_id is None):
|
||||
raise ArgumentError("User id must be an integer.")
|
||||
if user_id is not None and not isinstance(user_id, int):
|
||||
raise BackendArgumentTypeError(int, user_id=user_id)
|
||||
|
||||
# Verify body
|
||||
if not isinstance(body, str):
|
||||
raise ArgumentError("Post body must be a string.")
|
||||
raise BackendArgumentTypeError(str, body=body)
|
||||
if not body.strip():
|
||||
raise ArgumentError("Post body cannot be empty.")
|
||||
|
||||
|
|
|
@ -10,7 +10,7 @@ from sqlalchemy import select, func, update
|
|||
from werkzeug.security import generate_password_hash, check_password_hash
|
||||
|
||||
from amanuensis.db import DbContext, User
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
RE_NO_LETTERS = re.compile(r"^[0-9-_]*$")
|
||||
|
@ -30,7 +30,7 @@ def create(
|
|||
"""
|
||||
# Verify username
|
||||
if not isinstance(username, str):
|
||||
raise ArgumentError("Username must be a string")
|
||||
raise BackendArgumentTypeError(str, username=username)
|
||||
if len(username) < 3 or len(username) > 32:
|
||||
raise ArgumentError("Username must be between 3 and 32 characters")
|
||||
if RE_NO_LETTERS.match(username):
|
||||
|
@ -42,18 +42,18 @@ def create(
|
|||
|
||||
# Verify password
|
||||
if not isinstance(password, str):
|
||||
raise ArgumentError("Password must be a string")
|
||||
raise BackendArgumentTypeError(str, password=password)
|
||||
|
||||
# Verify display name
|
||||
if display_name is not None and not isinstance(display_name, str):
|
||||
raise ArgumentError("Display name must be a string")
|
||||
raise BackendArgumentTypeError(str, display_name=display_name)
|
||||
# If display name is not provided, use the username
|
||||
if not display_name or not display_name.strip():
|
||||
display_name = username
|
||||
|
||||
# Verify email
|
||||
if not isinstance(email, str):
|
||||
raise ArgumentError("Email must be a string")
|
||||
raise BackendArgumentTypeError(str, email=email)
|
||||
|
||||
# Query the db to make sure the username isn't taken
|
||||
if db(select(func.count(User.id)).where(User.username == username)).scalar() > 0:
|
||||
|
@ -71,24 +71,6 @@ def create(
|
|||
return new_user
|
||||
|
||||
|
||||
def from_id(db: DbContext, user_id: int) -> Optional[User]:
|
||||
"""
|
||||
Get a user by the user's id.
|
||||
Returns None if no user was found.
|
||||
"""
|
||||
user: User = db(select(User).where(User.id == user_id)).scalar_one_or_none()
|
||||
return user
|
||||
|
||||
|
||||
def from_username(db: DbContext, username: str) -> Optional[User]:
|
||||
"""
|
||||
Get a user by the user's username.
|
||||
Returns None if no user was found.
|
||||
"""
|
||||
user: User = db(select(User).where(User.username == username)).scalar_one_or_none()
|
||||
return user
|
||||
|
||||
|
||||
def get_all(db: DbContext) -> Sequence[User]:
|
||||
"""Get all users."""
|
||||
return db(select(User)).scalars()
|
||||
|
@ -109,6 +91,16 @@ def password_check(db: DbContext, username: str, password: str) -> bool:
|
|||
return check_password_hash(user_password_hash, password)
|
||||
|
||||
|
||||
def try_from_id(db: DbContext, user_id: int) -> Optional[User]:
|
||||
"""Get a user by the user's id, or None is no such user was found."""
|
||||
return db(select(User).where(User.id == user_id)).scalar_one_or_none()
|
||||
|
||||
|
||||
def try_from_username(db: DbContext, username: str) -> Optional[User]:
|
||||
"""Get a user by the user's username, or None is no such user was found."""
|
||||
return db(select(User).where(User.username == username)).scalar_one_or_none()
|
||||
|
||||
|
||||
def update_logged_in(db: DbContext, username: str) -> None:
|
||||
"""Bump the value of the last_login column for a user."""
|
||||
db(
|
||||
|
|
|
@ -2,9 +2,7 @@ import logging
|
|||
|
||||
from sqlalchemy import update
|
||||
|
||||
import amanuensis.backend.lexicon as lexiq
|
||||
import amanuensis.backend.membership as memq
|
||||
import amanuensis.backend.user as userq
|
||||
from amanuensis.backend import lexiq, memq, userq
|
||||
from amanuensis.db import DbContext, Lexicon
|
||||
|
||||
from .helpers import add_argument
|
||||
|
@ -24,9 +22,12 @@ def command_add(args) -> int:
|
|||
Add a user to a lexicon.
|
||||
"""
|
||||
db: DbContext = args.get_db()
|
||||
lexicon = lexiq.from_name(db, args.lexicon)
|
||||
user = userq.from_username(db, args.user)
|
||||
assert user is not None
|
||||
lexicon = lexiq.try_from_name(db, args.lexicon)
|
||||
if not lexicon:
|
||||
raise ValueError("Lexicon does not exist")
|
||||
user = userq.try_from_username(db, args.user)
|
||||
if not user:
|
||||
raise ValueError("User does not exist")
|
||||
memq.create(db, user.id, lexicon.id, args.editor)
|
||||
LOG.info(f"Added {args.user} to lexicon {args.lexicon}")
|
||||
return 0
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
import logging
|
||||
from typing import Optional
|
||||
|
||||
import amanuensis.backend.user as userq
|
||||
from amanuensis.backend import userq
|
||||
from amanuensis.db import DbContext, User
|
||||
|
||||
from .helpers import add_argument
|
||||
|
@ -29,7 +29,7 @@ def command_create(args) -> int:
|
|||
def command_promote(args) -> int:
|
||||
"""Make a user a site admin."""
|
||||
db: DbContext = args.get_db()
|
||||
user: Optional[User] = userq.from_username(db, args.username)
|
||||
user: Optional[User] = userq.try_from_username(db, args.username)
|
||||
if user is None:
|
||||
args.parser.error("User not found")
|
||||
return -1
|
||||
|
@ -46,7 +46,7 @@ def command_promote(args) -> int:
|
|||
def command_demote(args):
|
||||
"""Revoke a user's site admin status."""
|
||||
db: DbContext = args.get_db()
|
||||
user: Optional[User] = userq.from_username(db, args.username)
|
||||
user: Optional[User] = userq.try_from_username(db, args.username)
|
||||
if user is None:
|
||||
args.parser.error("User not found")
|
||||
return -1
|
||||
|
|
|
@ -4,8 +4,21 @@ Submodule of custom exception types
|
|||
|
||||
|
||||
class AmanuensisError(Exception):
|
||||
"""Base class for exceptions in amanuensis"""
|
||||
"""Base class for exceptions in Amanuensis"""
|
||||
|
||||
|
||||
class ArgumentError(AmanuensisError):
|
||||
"""An internal call was made with invalid arguments"""
|
||||
"""An internal call was made with invalid arguments."""
|
||||
|
||||
|
||||
class BackendArgumentTypeError(ArgumentError):
|
||||
"""
|
||||
A call to a backend function was made with a value of an invalid type for the parameter.
|
||||
Specify the invalid parameter and value as a kwarg.
|
||||
"""
|
||||
def __init__(self, obj_type, **kwarg):
|
||||
if not kwarg:
|
||||
raise ValueError("Missing kwarg")
|
||||
param, value = next(iter(kwarg.items()))
|
||||
msg = f"Expected {param} of type {obj_type}, got {type(value)}"
|
||||
super().__init__(msg)
|
||||
|
|
|
@ -2,16 +2,33 @@ from datetime import datetime, timezone
|
|||
import json
|
||||
import os
|
||||
|
||||
from flask import Flask, g
|
||||
from flask import Flask, g, url_for
|
||||
|
||||
import amanuensis.backend.lexicon
|
||||
import amanuensis.backend.user
|
||||
from amanuensis.backend import lexiq, userq, memq
|
||||
from amanuensis.config import AmanuensisConfig, CommandLineConfig
|
||||
from amanuensis.db import DbContext
|
||||
from amanuensis.parser import filesafe_title
|
||||
import amanuensis.server.auth as auth
|
||||
import amanuensis.server.home as home
|
||||
|
||||
|
||||
def date_format(dt: datetime, formatstr="%Y-%m-%d %H:%M:%S%z") -> str:
|
||||
"""Convert datetime to human-readable string"""
|
||||
if dt is None:
|
||||
return "never"
|
||||
# Cast db time to UTC, then convert to local timezone
|
||||
adjusted = dt.replace(tzinfo=timezone.utc).astimezone()
|
||||
return adjusted.strftime(formatstr)
|
||||
|
||||
|
||||
def article_link(title):
|
||||
"""Get the url for a lexicon by its title"""
|
||||
return url_for(
|
||||
'lexicon.article',
|
||||
name=g.lexicon.name,
|
||||
title=filesafe_title(title))
|
||||
|
||||
|
||||
def get_app(
|
||||
config: AmanuensisConfig,
|
||||
db: DbContext = None,
|
||||
|
@ -49,20 +66,12 @@ def get_app(
|
|||
app.teardown_appcontext(db_teardown)
|
||||
|
||||
# Configure jinja options
|
||||
app.jinja_options.update(trim_blocks=True, lstrip_blocks=True)
|
||||
|
||||
def date_format(dt: datetime, formatstr="%Y-%m-%d %H:%M:%S%z") -> str:
|
||||
if dt is None:
|
||||
return "never"
|
||||
# Cast db time to UTC, then convert to local timezone
|
||||
adjusted = dt.replace(tzinfo=timezone.utc).astimezone()
|
||||
return adjusted.strftime(formatstr)
|
||||
|
||||
app.template_filter("date")(date_format)
|
||||
|
||||
def include_backend():
|
||||
return {"db": db, "lexiq": amanuensis.backend.lexicon, "userq": amanuensis.backend.user}
|
||||
return {"db": db, "lexiq": lexiq, "userq": userq, "memq": memq}
|
||||
|
||||
app.jinja_options.update(trim_blocks=True, lstrip_blocks=True)
|
||||
app.template_filter("date")(date_format)
|
||||
app.template_filter("articlelink")(article_link)
|
||||
app.context_processor(include_backend)
|
||||
|
||||
# Set up Flask-Login
|
||||
|
|
|
@ -17,7 +17,7 @@ from flask_login import (
|
|||
LoginManager,
|
||||
)
|
||||
|
||||
import amanuensis.backend.user as userq
|
||||
from amanuensis.backend import userq
|
||||
from amanuensis.db import User
|
||||
|
||||
from .forms import LoginForm
|
||||
|
@ -39,7 +39,7 @@ def get_login_manager() -> LoginManager:
|
|||
user_id = int(user_id_str)
|
||||
except:
|
||||
return None
|
||||
return userq.from_id(g.db, user_id)
|
||||
return userq.try_from_id(g.db, user_id)
|
||||
|
||||
login_manager.user_loader(load_user)
|
||||
|
||||
|
@ -58,7 +58,7 @@ def login():
|
|||
# POST with valid data
|
||||
username: str = form.username.data
|
||||
password: str = form.password.data
|
||||
user: User = userq.from_username(g.db, username)
|
||||
user: User = userq.try_from_username(g.db, username)
|
||||
if not user or not userq.password_check(g.db, username, password):
|
||||
# Bad creds
|
||||
flash("Login not recognized")
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
from flask import Blueprint, render_template, g
|
||||
|
||||
import amanuensis.backend.user as userq
|
||||
import amanuensis.backend.lexicon as lexiq
|
||||
from amanuensis.backend import userq, lexiq
|
||||
|
||||
# from .forms import LexiconCreateForm
|
||||
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
import pytest
|
||||
import time
|
||||
|
||||
from amanuensis.db import DbContext
|
||||
from amanuensis.db.models import Character, Lexicon, User
|
||||
import amanuensis.backend.article as artiq
|
||||
from amanuensis.backend import artiq
|
||||
from amanuensis.db import DbContext, Character, Lexicon, User
|
||||
|
||||
from amanuensis.errors import ArgumentError
|
||||
from tests.conftest import ObjectFactory
|
||||
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
import pytest
|
||||
|
||||
from amanuensis.backend import charq
|
||||
from amanuensis.db import *
|
||||
import amanuensis.backend.character as charq
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def test_create_character(db: DbContext, lexicon_with_editor, make):
|
||||
|
@ -20,13 +20,13 @@ def test_create_character(db: DbContext, lexicon_with_editor, make):
|
|||
kwargs: dict
|
||||
|
||||
# Bad argument types
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "name": b"bytestring"}
|
||||
charq.create(**kwargs)
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "name": None}
|
||||
charq.create(**kwargs)
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "signature": b"bytestring"}
|
||||
charq.create(**kwargs)
|
||||
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
from amanuensis.db.models import IndexType
|
||||
import pytest
|
||||
|
||||
import amanuensis.backend.index as indq
|
||||
from amanuensis.db import DbContext, Lexicon, User
|
||||
from amanuensis.backend import indq
|
||||
from amanuensis.db import DbContext, Lexicon
|
||||
|
||||
from amanuensis.errors import ArgumentError
|
||||
|
||||
|
|
|
@ -3,9 +3,9 @@ import time
|
|||
|
||||
import pytest
|
||||
|
||||
import amanuensis.backend.lexicon as lexiq
|
||||
from amanuensis.backend import lexiq
|
||||
from amanuensis.db import DbContext, Lexicon, User
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
from tests.conftest import ObjectFactory
|
||||
|
||||
|
||||
|
@ -20,7 +20,7 @@ def test_create_lexicon(db: DbContext):
|
|||
kwargs: dict
|
||||
|
||||
# Test name constraints
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "name": None}
|
||||
lexiq.create(**kwargs)
|
||||
with pytest.raises(ArgumentError):
|
||||
|
@ -58,8 +58,8 @@ def test_lexicon_from(db: DbContext, make: ObjectFactory):
|
|||
"""Test lexiq.from_*."""
|
||||
lexicon1: Lexicon = make.lexicon()
|
||||
lexicon2: Lexicon = make.lexicon()
|
||||
assert lexiq.from_name(db, lexicon1.name) == lexicon1
|
||||
assert lexiq.from_name(db, lexicon2.name) == lexicon2
|
||||
assert lexiq.try_from_name(db, lexicon1.name) == lexicon1
|
||||
assert lexiq.try_from_name(db, lexicon2.name) == lexicon2
|
||||
|
||||
|
||||
def test_get_lexicon(db: DbContext, make: ObjectFactory):
|
||||
|
|
|
@ -2,9 +2,9 @@ import pytest
|
|||
|
||||
from sqlalchemy import select
|
||||
|
||||
from amanuensis.backend import memq
|
||||
from amanuensis.db import *
|
||||
from amanuensis.errors import ArgumentError
|
||||
import amanuensis.backend.membership as memq
|
||||
|
||||
|
||||
def test_create_membership(db: DbContext, make):
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
import pytest
|
||||
|
||||
from amanuensis.backend import postq
|
||||
from amanuensis.db import DbContext
|
||||
import amanuensis.backend.post as postq
|
||||
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def test_create_post(db: DbContext, lexicon_with_editor):
|
||||
|
@ -20,19 +20,16 @@ def test_create_post(db: DbContext, lexicon_with_editor):
|
|||
kwargs: dict
|
||||
|
||||
# ids are integers
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "user_id": "zero"}
|
||||
postq.create(**kwargs)
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "lexicon_id": "zero"}
|
||||
postq.create(**kwargs)
|
||||
|
||||
# empty arguments don't work
|
||||
with pytest.raises(ArgumentError):
|
||||
kwargs = {**defaults, "lexicon_id": ""}
|
||||
postq.create(**kwargs)
|
||||
with pytest.raises(ArgumentError):
|
||||
kwargs = {**defaults, "user_id": ""}
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "lexicon_id": None}
|
||||
postq.create(**kwargs)
|
||||
with pytest.raises(ArgumentError):
|
||||
kwargs = {**defaults, "body": ""}
|
||||
|
|
|
@ -2,9 +2,9 @@ import os
|
|||
|
||||
import pytest
|
||||
|
||||
import amanuensis.backend.user as userq
|
||||
from amanuensis.backend import userq
|
||||
from amanuensis.db import DbContext, User
|
||||
from amanuensis.errors import ArgumentError
|
||||
from amanuensis.errors import ArgumentError, BackendArgumentTypeError
|
||||
|
||||
|
||||
def test_create_user(db: DbContext):
|
||||
|
@ -33,7 +33,7 @@ def test_create_user(db: DbContext):
|
|||
userq.create(**kwargs)
|
||||
|
||||
# No password
|
||||
with pytest.raises(ArgumentError):
|
||||
with pytest.raises(BackendArgumentTypeError):
|
||||
kwargs = {**defaults, "password": None}
|
||||
userq.create(**kwargs)
|
||||
|
||||
|
@ -57,10 +57,10 @@ def test_user_from(db: DbContext, make):
|
|||
"""Test userq.from_*."""
|
||||
user1: User = make.user()
|
||||
user2: User = make.user()
|
||||
assert userq.from_id(db, user1.id) == user1
|
||||
assert userq.from_username(db, user1.username) == user1
|
||||
assert userq.from_id(db, user2.id) == user2
|
||||
assert userq.from_username(db, user2.username) == user2
|
||||
assert userq.try_from_id(db, user1.id) == user1
|
||||
assert userq.try_from_username(db, user1.username) == user1
|
||||
assert userq.try_from_id(db, user2.id) == user2
|
||||
assert userq.try_from_username(db, user2.username) == user2
|
||||
|
||||
|
||||
def test_user_password(db: DbContext, make):
|
||||
|
|
|
@ -10,10 +10,7 @@ from bs4 import BeautifulSoup
|
|||
from flask.testing import FlaskClient
|
||||
from sqlalchemy.orm.session import close_all_sessions
|
||||
|
||||
import amanuensis.backend.character as charq
|
||||
import amanuensis.backend.lexicon as lexiq
|
||||
import amanuensis.backend.membership as memq
|
||||
import amanuensis.backend.user as userq
|
||||
from amanuensis.backend import charq, lexiq, memq, userq
|
||||
from amanuensis.config import AmanuensisConfig
|
||||
from amanuensis.db import DbContext, User, Lexicon, Membership, Character
|
||||
from amanuensis.server import get_app
|
||||
|
@ -45,7 +42,7 @@ class UserClient:
|
|||
|
||||
def login(self, client: FlaskClient):
|
||||
"""Log the user in."""
|
||||
user: Optional[User] = userq.from_id(self.db, self.user_id)
|
||||
user: Optional[User] = userq.try_from_id(self.db, self.user_id)
|
||||
assert user is not None
|
||||
|
||||
# Set the user's password so we know what it is later
|
||||
|
|
Loading…
Reference in New Issue