140 lines
3.7 KiB
Python
140 lines
3.7 KiB
Python
"""
|
|
pytest test fixtures
|
|
"""
|
|
import pytest
|
|
|
|
from amanuensis.db import DbContext
|
|
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.config import AmanuensisConfig
|
|
from amanuensis.server import get_app
|
|
|
|
|
|
@pytest.fixture
|
|
def db() -> DbContext:
|
|
"""Provides an initialized database in memory."""
|
|
db = DbContext(uri="sqlite:///:memory:", echo=False)
|
|
db.create_all()
|
|
return db
|
|
|
|
|
|
@pytest.fixture
|
|
def make_user(db: DbContext):
|
|
"""Provides a factory function for creating users, with valid default values."""
|
|
|
|
def user_factory(state={"nonce": 1}, **kwargs):
|
|
default_kwargs = {
|
|
"username": f'test_user_{state["nonce"]}',
|
|
"password": "password",
|
|
"display_name": None,
|
|
"email": "user@example.com",
|
|
"is_site_admin": False,
|
|
}
|
|
state["nonce"] += 1
|
|
updated_kwargs = {**default_kwargs, **kwargs}
|
|
return userq.create(db, **updated_kwargs)
|
|
|
|
return user_factory
|
|
|
|
|
|
@pytest.fixture
|
|
def make_lexicon(db: DbContext):
|
|
"""Provides a factory function for creating lexicons, with valid default values."""
|
|
|
|
def lexicon_factory(state={"nonce": 1}, **kwargs):
|
|
default_kwargs = {
|
|
"name": f'Test_{state["nonce"]}',
|
|
"title": None,
|
|
"prompt": f'Test Lexicon game {state["nonce"]}',
|
|
}
|
|
state["nonce"] += 1
|
|
updated_kwargs = {**default_kwargs, **kwargs}
|
|
lex = lexiq.create(db, **updated_kwargs)
|
|
lex.joinable = True
|
|
db.session.commit()
|
|
return lex
|
|
|
|
return lexicon_factory
|
|
|
|
|
|
@pytest.fixture
|
|
def make_membership(db: DbContext):
|
|
"""Provides a factory function for creating memberships, with valid default values."""
|
|
|
|
def membership_factory(**kwargs):
|
|
default_kwargs = {
|
|
"is_editor": False,
|
|
}
|
|
updated_kwargs = {**default_kwargs, **kwargs}
|
|
return memq.create(db, **updated_kwargs)
|
|
|
|
return membership_factory
|
|
|
|
|
|
@pytest.fixture
|
|
def make_character(db: DbContext):
|
|
"""Provides a factory function for creating characters, with valid default values."""
|
|
|
|
def character_factory(state={"nonce": 1}, **kwargs):
|
|
default_kwargs = {
|
|
"name": f'Character {state["nonce"]}',
|
|
"signature": None,
|
|
}
|
|
state["nonce"] += 1
|
|
updated_kwargs = {**default_kwargs, **kwargs}
|
|
return charq.create(db, **updated_kwargs)
|
|
|
|
return character_factory
|
|
|
|
|
|
class TestFactory:
|
|
def __init__(self, db, **factories):
|
|
self.db = db
|
|
self.factories = factories
|
|
|
|
def __getattr__(self, name):
|
|
return self.factories[name]
|
|
|
|
|
|
@pytest.fixture
|
|
def make(
|
|
db: DbContext, make_user, make_lexicon, make_membership, make_character
|
|
) -> TestFactory:
|
|
"""Fixture that groups all factory fixtures together."""
|
|
return TestFactory(
|
|
db,
|
|
user=make_user,
|
|
lexicon=make_lexicon,
|
|
membership=make_membership,
|
|
character=make_character,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def lexicon_with_editor(make):
|
|
"""Shortcut setup for a lexicon game with an editor."""
|
|
editor = make.user()
|
|
assert editor
|
|
lexicon = make.lexicon()
|
|
assert lexicon
|
|
membership = make.membership(
|
|
user_id=editor.id, lexicon_id=lexicon.id, is_editor=True
|
|
)
|
|
assert membership
|
|
return (lexicon, editor)
|
|
|
|
|
|
class TestConfig(AmanuensisConfig):
|
|
TESTING = True
|
|
SECRET_KEY = "secret key"
|
|
DATABASE_URI = "sqlite:///:memory:"
|
|
|
|
|
|
@pytest.fixture
|
|
def app(db):
|
|
"""Provides an application running on top of the test database."""
|
|
server_app = get_app(TestConfig, db)
|
|
return server_app
|