2011-03-12 15:59:01 +00:00
|
|
|
# encoding: utf8
|
|
|
|
from nose.tools import *
|
|
|
|
import unittest
|
2011-03-19 01:22:18 +00:00
|
|
|
from sqlalchemy import Column, Integer, String, create_engine
|
|
|
|
from sqlalchemy.orm import class_mapper, joinedload, sessionmaker
|
2011-03-20 08:06:45 +00:00
|
|
|
from sqlalchemy.orm.session import Session
|
2011-03-19 01:22:18 +00:00
|
|
|
from sqlalchemy.ext.declarative import declarative_base
|
2011-03-12 15:59:01 +00:00
|
|
|
|
|
|
|
from pokedex.db import tables, markdown
|
2011-03-22 00:54:28 +00:00
|
|
|
from pokedex.db.multilang import create_translation_table
|
2011-03-12 15:59:01 +00:00
|
|
|
|
|
|
|
def test_variable_names():
|
|
|
|
"""We want pokedex.db.tables to export tables using the class name"""
|
|
|
|
for varname in dir(tables):
|
|
|
|
if not varname[0].isupper():
|
|
|
|
continue
|
|
|
|
table = getattr(tables, varname)
|
|
|
|
try:
|
|
|
|
if not issubclass(table, tables.TableBase) or table is tables.TableBase:
|
|
|
|
continue
|
|
|
|
except TypeError:
|
|
|
|
continue
|
|
|
|
classname = table.__name__
|
|
|
|
if classname and varname[0].isupper():
|
|
|
|
assert varname == classname, '%s refers to %s' % (varname, classname)
|
2011-03-29 17:44:43 +00:00
|
|
|
for table in tables.mapped_classes:
|
2011-03-12 15:59:01 +00:00
|
|
|
assert getattr(tables, table.__name__) is table
|
|
|
|
|
2011-03-19 01:22:18 +00:00
|
|
|
def test_i18n_table_creation():
|
|
|
|
"""Creates and manipulates a magical i18n table, completely independent of
|
|
|
|
the existing schema and data. Makes sure that the expected behavior of the
|
|
|
|
various proxies and columns works.
|
|
|
|
"""
|
|
|
|
Base = declarative_base()
|
2011-03-20 08:06:45 +00:00
|
|
|
engine = create_engine("sqlite:///:memory:", echo=True)
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
Base.metadata.bind = engine
|
|
|
|
|
|
|
|
# Need this for the foreign keys to work!
|
|
|
|
class Language(Base):
|
|
|
|
__tablename__ = 'languages'
|
|
|
|
id = Column(Integer, primary_key=True, nullable=False)
|
|
|
|
identifier = Column(String(2), nullable=False, unique=True)
|
|
|
|
|
|
|
|
class Foo(Base):
|
|
|
|
__tablename__ = 'foos'
|
|
|
|
__singlename__ = 'foo'
|
|
|
|
id = Column(Integer, primary_key=True, nullable=False)
|
2011-03-29 17:44:43 +00:00
|
|
|
translation_classes = []
|
2011-03-19 01:22:18 +00:00
|
|
|
|
2011-03-29 17:44:43 +00:00
|
|
|
FooText = create_translation_table('foo_text', Foo, 'texts',
|
2011-03-22 05:32:52 +00:00
|
|
|
language_class=Language,
|
2011-03-20 08:06:45 +00:00
|
|
|
name = Column(String(100)),
|
2011-03-19 01:22:18 +00:00
|
|
|
)
|
|
|
|
|
2011-03-22 05:32:52 +00:00
|
|
|
class FauxSession(Session):
|
2011-03-20 08:06:45 +00:00
|
|
|
def execute(self, clause, params=None, *args, **kwargs):
|
|
|
|
if not params:
|
|
|
|
params = {}
|
|
|
|
params.setdefault('_default_language', 'en')
|
2011-03-22 05:32:52 +00:00
|
|
|
return super(FauxSession, self).execute(clause, params, *args, **kwargs)
|
2011-03-20 08:06:45 +00:00
|
|
|
|
2011-03-19 01:22:18 +00:00
|
|
|
# OK, create all the tables and gimme a session
|
|
|
|
Base.metadata.create_all()
|
2011-03-22 05:32:52 +00:00
|
|
|
sess = sessionmaker(engine, class_=FauxSession)()
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
# Create some languages and foos to bind together
|
|
|
|
lang_en = Language(identifier='en')
|
|
|
|
sess.add(lang_en)
|
|
|
|
lang_jp = Language(identifier='jp')
|
|
|
|
sess.add(lang_jp)
|
2011-03-20 08:06:45 +00:00
|
|
|
lang_ru = Language(identifier='ru')
|
|
|
|
sess.add(lang_ru)
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
foo = Foo()
|
|
|
|
sess.add(foo)
|
|
|
|
|
|
|
|
# Commit so the above get primary keys filled in
|
|
|
|
sess.commit()
|
|
|
|
|
|
|
|
# Give our foo some names, as directly as possible
|
|
|
|
foo_text = FooText()
|
2011-03-29 17:44:43 +00:00
|
|
|
foo_text.foreign_id = foo.id
|
|
|
|
foo_text.local_language_id = lang_en.id
|
2011-03-19 01:22:18 +00:00
|
|
|
foo_text.name = 'english'
|
|
|
|
sess.add(foo_text)
|
|
|
|
|
|
|
|
foo_text = FooText()
|
2011-03-29 17:44:43 +00:00
|
|
|
foo_text.foo_id = foo.id
|
|
|
|
foo_text.local_language_id = lang_jp.id
|
2011-03-19 01:22:18 +00:00
|
|
|
foo_text.name = 'nihongo'
|
|
|
|
sess.add(foo_text)
|
|
|
|
|
|
|
|
# Commit! This will expire all of the above.
|
|
|
|
sess.commit()
|
|
|
|
|
|
|
|
### Test 1: re-fetch foo and check its attributes
|
2011-03-20 08:06:45 +00:00
|
|
|
foo = sess.query(Foo).params(_default_language='en').one()
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
# Dictionary of language identifiers => names
|
2011-03-22 00:54:28 +00:00
|
|
|
assert foo.name_map[lang_en] == 'english'
|
|
|
|
assert foo.name_map[lang_jp] == 'nihongo'
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
# Default language, currently English
|
|
|
|
assert foo.name == 'english'
|
|
|
|
|
|
|
|
sess.expire_all()
|
|
|
|
|
2011-03-22 00:54:28 +00:00
|
|
|
### Test 2: querying by default language name should work
|
|
|
|
foo = sess.query(Foo).filter_by(name='english').one()
|
|
|
|
|
|
|
|
assert foo.name == 'english'
|
|
|
|
|
|
|
|
sess.expire_all()
|
|
|
|
|
|
|
|
### Test 3: joinedload on the default name should appear to work
|
2011-03-20 08:06:45 +00:00
|
|
|
# THIS SHOULD WORK SOMEDAY
|
|
|
|
# .options(joinedload(Foo.name)) \
|
2011-03-19 01:22:18 +00:00
|
|
|
foo = sess.query(Foo) \
|
2011-03-29 17:44:43 +00:00
|
|
|
.options(joinedload(Foo.texts_local)) \
|
2011-03-20 08:06:45 +00:00
|
|
|
.one()
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
assert foo.name == 'english'
|
|
|
|
|
|
|
|
sess.expire_all()
|
|
|
|
|
2011-03-22 00:54:28 +00:00
|
|
|
### Test 4: joinedload on all the names should appear to work
|
2011-03-20 08:06:45 +00:00
|
|
|
# THIS SHOULD ALSO WORK SOMEDAY
|
|
|
|
# .options(joinedload(Foo.name_map)) \
|
2011-03-19 01:22:18 +00:00
|
|
|
foo = sess.query(Foo) \
|
2011-03-29 17:44:43 +00:00
|
|
|
.options(joinedload(Foo.texts)) \
|
2011-03-20 08:06:45 +00:00
|
|
|
.one()
|
2011-03-19 01:22:18 +00:00
|
|
|
|
2011-03-22 00:54:28 +00:00
|
|
|
assert foo.name_map[lang_en] == 'english'
|
|
|
|
assert foo.name_map[lang_jp] == 'nihongo'
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
sess.expire_all()
|
|
|
|
|
2011-03-22 00:54:28 +00:00
|
|
|
### Test 5: Mutating the dict collection should work
|
2011-03-20 08:06:45 +00:00
|
|
|
foo = sess.query(Foo).one()
|
2011-03-19 01:22:18 +00:00
|
|
|
|
2011-03-22 00:54:28 +00:00
|
|
|
foo.name_map[lang_en] = 'different english'
|
|
|
|
foo.name_map[lang_ru] = 'new russian'
|
2011-03-19 01:22:18 +00:00
|
|
|
|
|
|
|
sess.commit()
|
|
|
|
|
2011-03-22 00:54:28 +00:00
|
|
|
assert foo.name_map[lang_en] == 'different english'
|
|
|
|
assert foo.name_map[lang_ru] == 'new russian'
|
2011-03-19 01:22:18 +00:00
|
|
|
|
2011-03-12 15:59:01 +00:00
|
|
|
def test_texts():
|
|
|
|
"""Check DB schema for integrity of text columns & translations.
|
|
|
|
|
|
|
|
Mostly protects against copy/paste oversights and rebase hiccups.
|
|
|
|
If there's a reason to relax the tests, do it
|
|
|
|
"""
|
2011-03-29 17:44:43 +00:00
|
|
|
classes = []
|
|
|
|
for cls in tables.mapped_classes:
|
|
|
|
classes.append(cls)
|
|
|
|
classes += cls.translation_classes
|
|
|
|
for cls in classes:
|
|
|
|
if hasattr(cls, 'local_language') or hasattr(cls, 'language'):
|
2011-03-12 15:59:01 +00:00
|
|
|
good_formats = 'markdown plaintext gametext'.split()
|
|
|
|
assert_text = '%s is language-specific'
|
|
|
|
else:
|
|
|
|
good_formats = 'identifier latex'.split()
|
|
|
|
assert_text = '%s is not language-specific'
|
2011-03-29 17:44:43 +00:00
|
|
|
columns = sorted(cls.__table__.c, key=lambda c: c.name)
|
|
|
|
for column in columns:
|
2011-03-12 15:59:01 +00:00
|
|
|
format = column.info.get('format', None)
|
|
|
|
if format is not None:
|
|
|
|
if format not in good_formats:
|
|
|
|
raise AssertionError(assert_text % column)
|
|
|
|
is_markdown = isinstance(column.type, markdown.MarkdownColumn)
|
|
|
|
if is_markdown != (format == 'markdown'):
|
|
|
|
raise AssertionError('%s: markdown format/column type mismatch' % column)
|
|
|
|
if (format != 'identifier') and (column.name == 'identifier'):
|
|
|
|
raise AssertionError('%s: identifier column name/type mismatch' % column)
|
|
|
|
if column.info.get('official', None) and format not in 'gametext plaintext':
|
|
|
|
raise AssertionError('%s: official text with bad format' % column)
|
|
|
|
else:
|
|
|
|
if isinstance(column.type, (markdown.MarkdownColumn, tables.Unicode)):
|
|
|
|
raise AssertionError('%s: text column without format' % column)
|
|
|
|
if column.name == 'name' and format != 'plaintext':
|
|
|
|
raise AssertionError('%s: non-plaintext name' % column)
|
|
|
|
# No mention of English in the description
|
|
|
|
assert 'English' not in column.info['description'], column
|
|
|
|
|
|
|
|
def test_identifiers_with_names():
|
|
|
|
"""Test that named tables have identifiers, and non-named tables don't
|
|
|
|
|
|
|
|
...have either names or identifiers.
|
|
|
|
"""
|
2011-03-29 17:44:43 +00:00
|
|
|
for table in sorted(tables.mapped_classes, key=lambda t: t.__name__):
|
|
|
|
if hasattr(table, 'name'):
|
2011-03-12 15:59:01 +00:00
|
|
|
assert hasattr(table, 'identifier'), table
|
|
|
|
else:
|
|
|
|
assert not hasattr(table, 'identifier'), table
|