X-Git-Url: http://git.veekun.com/zzz-pokedex.git/blobdiff_plain/492c9c72081add3b6ebfe36743906e6c6f82ce92..2fee7534634e0f96094500811ae88b2bfae94fc6:/pokedex/tests/test_schema.py

diff --git a/pokedex/tests/test_schema.py b/pokedex/tests/test_schema.py
index f1583a7..804e3c8 100644
--- a/pokedex/tests/test_schema.py
+++ b/pokedex/tests/test_schema.py
@@ -1,9 +1,13 @@
 # encoding: utf8
 from nose.tools import *
 import unittest
-from sqlalchemy.orm import class_mapper
+from sqlalchemy import Column, Integer, String, create_engine
+from sqlalchemy.orm import class_mapper, joinedload, sessionmaker
+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
 
 def test_variable_names():
     """We want pokedex.db.tables to export tables using the class name"""
@@ -19,24 +23,159 @@ 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
+    various proxies and columns works.
+    """
+    Base = declarative_base()
+    engine = create_engine("sqlite:///:memory:", echo=True)
+
+    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)
+        translation_classes = []
+
+    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)()
+
+    # 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)
+    lang_ru = Language(identifier='ru')
+    sess.add(lang_ru)
+
+    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()
+    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.foo_id = foo.id
+    foo_text.local_language_id = lang_jp.id
+    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
+    foo = sess.query(Foo).params(_default_language='en').one()
+
+    # Dictionary of language identifiers => names
+    assert foo.name_map[lang_en] == 'english'
+    assert foo.name_map[lang_jp] == 'nihongo'
+
+    # Default language, currently English
+    assert foo.name == 'english'
+
+    sess.expire_all()
+
+    ### 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
+    # THIS SHOULD WORK SOMEDAY
+    #    .options(joinedload(Foo.name)) \
+    foo = sess.query(Foo) \
+        .options(joinedload(Foo.texts_local)) \
+        .one()
+
+    assert foo.name == 'english'
+
+    sess.expire_all()
+
+    ### Test 4: joinedload on all the names should appear to work
+    # THIS SHOULD ALSO WORK SOMEDAY
+    #    .options(joinedload(Foo.name_map)) \
+    foo = sess.query(Foo) \
+        .options(joinedload(Foo.texts)) \
+        .one()
+
+    assert foo.name_map[lang_en] == 'english'
+    assert foo.name_map[lang_jp] == 'nihongo'
+
+    sess.expire_all()
+
+    ### Test 5: Mutating the dict collection should work
+    foo = sess.query(Foo).one()
+
+    foo.name_map[lang_en] = 'different english'
+    foo.name_map[lang_ru] = 'new russian'
+
+    sess.commit()
+
+    assert foo.name_map[lang_en] == 'different english'
+    assert foo.name_map[lang_ru] == 'new russian'
+
 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
     """
-    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)
+        for column in columns:
             format = column.info.get('format', None)
             if format is not None:
                 if format not in good_formats:
@@ -61,11 +200,8 @@ def test_identifiers_with_names():
 
     ...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