X-Git-Url: http://git.veekun.com/zzz-pokedex.git/blobdiff_plain/ec65b5ae366174912cedf0e263d425378220d70b..1d789e2e9e790f11246e09d7ea17ececb4253af0:/pokedex/tests/test_schema.py diff --git a/pokedex/tests/test_schema.py b/pokedex/tests/test_schema.py index 88ee1e5..0518ed8 100644 --- a/pokedex/tests/test_schema.py +++ b/pokedex/tests/test_schema.py @@ -7,7 +7,8 @@ from sqlalchemy.orm.session import Session from sqlalchemy.ext.declarative import declarative_base from pokedex.db import tables, markdown -from pokedex.db.multilang import create_translation_table +from pokedex.db.multilang import MultilangScopedSession, MultilangSession, \ + create_translation_table def test_variable_names(): """We want pokedex.db.tables to export tables using the class name""" @@ -23,9 +24,19 @@ def test_variable_names(): classname = table.__name__ if classname and varname[0].isupper(): assert varname == classname, '%s refers to %s' % (varname, classname) - for table in tables.table_classes: + for table in tables.mapped_classes: assert getattr(tables, table.__name__) is table +def test_class_order(): + """The declarative classes should be defined in alphabetical order. + Except for Language which should be first. + """ + class_names = [table.__name__ for table in tables.mapped_classes] + def key(name): + return name != 'Language', name + print [(a,b) for (a,b) in zip(class_names, sorted(class_names, key=key)) if a!=b] + assert class_names == sorted(class_names, key=key) + 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 @@ -46,22 +57,17 @@ def test_i18n_table_creation(): __tablename__ = 'foos' __singlename__ = 'foo' id = Column(Integer, primary_key=True, nullable=False) + translation_classes = [] - FooText = create_translation_table('foo_text', Foo, + FooText = create_translation_table('foo_text', Foo, 'texts', language_class=Language, name = Column(String(100)), ) - class FauxSession(Session): - def execute(self, clause, params=None, *args, **kwargs): - if not params: - params = {} - params.setdefault('_default_language', 'en') - return super(FauxSession, self).execute(clause, params, *args, **kwargs) - # OK, create all the tables and gimme a session Base.metadata.create_all() - sess = sessionmaker(engine, class_=FauxSession)() + sm = sessionmaker(class_=MultilangSession) + sess = MultilangScopedSession(sm) # Create some languages and foos to bind together lang_en = Language(identifier='en') @@ -74,19 +80,23 @@ def test_i18n_table_creation(): foo = Foo() sess.add(foo) - # Commit so the above get primary keys filled in + # Commit so the above get primary keys filled in, then give the + # session the language id sess.commit() + # Note that this won't apply to sessions created in other threads, but that + # ought not be a problem! + sess.default_language_id = lang_en.id # Give our foo some names, as directly as possible foo_text = FooText() - foo_text.object_id = foo.id - foo_text.language_id = lang_en.id + foo_text.foreign_id = foo.id + foo_text.local_language_id = lang_en.id foo_text.name = 'english' sess.add(foo_text) foo_text = FooText() - foo_text.object_id = foo.id - foo_text.language_id = lang_jp.id + foo_text.foo_id = foo.id + foo_text.local_language_id = lang_jp.id foo_text.name = 'nihongo' sess.add(foo_text) @@ -116,7 +126,7 @@ def test_i18n_table_creation(): # THIS SHOULD WORK SOMEDAY # .options(joinedload(Foo.name)) \ foo = sess.query(Foo) \ - .options(joinedload(Foo.foo_text_local)) \ + .options(joinedload(Foo.texts_local)) \ .one() assert foo.name == 'english' @@ -127,7 +137,7 @@ def test_i18n_table_creation(): # THIS SHOULD ALSO WORK SOMEDAY # .options(joinedload(Foo.name_map)) \ foo = sess.query(Foo) \ - .options(joinedload(Foo.foo_text)) \ + .options(joinedload(Foo.texts)) \ .one() assert foo.name_map[lang_en] == 'english' @@ -152,15 +162,20 @@ def test_texts(): Mostly protects against copy/paste oversights and rebase hiccups. If there's a reason to relax the tests, do it """ - for table in sorted(tables.table_classes, key=lambda t: t.__name__): - if issubclass(table, tables.LanguageSpecific): + 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'): 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' - mapper = class_mapper(table) - for column in sorted(mapper.c, key=lambda c: c.name): + columns = sorted(cls.__table__.c, key=lambda c: c.name) + text_columns = [] + for column in columns: format = column.info.get('format', None) if format is not None: if format not in good_formats: @@ -172,6 +187,7 @@ def test_texts(): 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) + text_columns.append(column) else: if isinstance(column.type, (markdown.MarkdownColumn, tables.Unicode)): raise AssertionError('%s: text column without format' % column) @@ -179,17 +195,19 @@ def test_texts(): raise AssertionError('%s: non-plaintext name' % column) # No mention of English in the description assert 'English' not in column.info['description'], column + # If there's more than one text column in a translation table, + # they have to be nullable, to support missing translations + if hasattr(cls, 'local_language') and len(text_columns) > 1: + for column in text_columns: + assert column.nullable def test_identifiers_with_names(): """Test that named tables have identifiers, and non-named tables don't ...have either names or identifiers. """ - for table in sorted(tables.table_classes, key=lambda t: t.__name__): - if issubclass(table, tables.Named): - assert issubclass(table, tables.OfficiallyNamed) or issubclass(table, tables.UnofficiallyNamed), table + for table in sorted(tables.mapped_classes, key=lambda t: t.__name__): + if hasattr(table, 'name'): assert hasattr(table, 'identifier'), table else: assert not hasattr(table, 'identifier'), table - if not issubclass(table, tables.LanguageSpecific): - assert not hasattr(table, 'name'), table