Added a test for the i18n dynamic table generation.

It fails spectacularly, but hopefully documents what I'm ultimately
going for.

pokedex/db/tables.py

@@ -1862,7 +1862,7 @@ VersionGroup.pokedex = relation(Pokedex, back_populates='version_groups')
 
 default_lang = u'en'
 
-def makeTextTable(foreign_table_class, table_suffix_plural, table_suffix_singular, columns, lazy):
+def makeTextTable(foreign_table_class, table_suffix_plural, table_suffix_singular, columns, lazy, Language=Language):
     # With "Language", we'd have two language_id. So, rename one to 'lang'
     foreign_key_name = foreign_table_class.__singlename__
     if foreign_key_name == 'language':
@@ -1882,7 +1882,7 @@ def makeTextTable(foreign_table_class, table_suffix_plural, table_suffix_singula
             # one by one without the DB complaining about missing values
             column.default = ColumnDefault(u'')
 
-    table = Table(table_name, metadata,
+    table = Table(table_name, foreign_table_class.__table__.metadata,
             Column(foreign_key_name + '_id', Integer, ForeignKey(foreign_table_class.id),
                     primary_key=True, nullable=False),
             Column('language_id', Integer, ForeignKey(Language.id),
@@ -1899,7 +1899,7 @@ def makeTextTable(foreign_table_class, table_suffix_plural, table_suffix_singula
             foreign_key_name: relation(foreign_table_class,
                 primaryjoin=(foreign_table_class.id == table.c[foreign_key_name + "_id"]),
                 backref=backref(table_suffix_plural,
-                    collection_class=attribute_mapped_collection('language'),
+                    collection_class=attribute_mapped_collection('_language_identifier'),
                     lazy=lazy,
                 ),
             ),

pokedex/tests/test_schema.py

@@ -1,7 +1,9 @@
 # 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.ext.declarative import declarative_base
 
 from pokedex.db import tables, markdown
 
@@ -22,6 +24,112 @@ def test_variable_names():
     for table in tables.table_classes:
         assert getattr(tables, table.__name__) is table
 
+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:")
+
+    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)
+
+    FooText = tables.makeTextTable(
+        foreign_table_class=Foo,
+        table_suffix_plural='blorp',
+        table_suffix_singular='klink',
+        columns=[
+            ('name', 'names', Column(String(100))),
+        ],
+        lazy='select',
+        Language=Language,
+    )
+
+    # OK, create all the tables and gimme a session
+    Base.metadata.create_all()
+    sess = sessionmaker(engine)()
+
+    # 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)
+
+    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.object_id = foo.id
+    foo_text.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.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).one()
+
+    # Dictionary of language identifiers => names
+    assert foo.names['en'] == 'english'
+    assert foo.names['jp'] == 'nihongo'
+
+    # Default language, currently English
+    assert foo.name == 'english'
+
+    sess.expire_all()
+
+    ### Test 2: joinedload on the default name should appear to work
+    foo = sess.query(Foo) \
+        .options(joinedload(Foo.name)) \
+        .first
+
+    assert foo.name == 'english'
+
+    sess.expire_all()
+
+    ### Test 3: joinedload on all the names should appear to work
+    foo = sess.query(Foo) \
+        .options(joinedload(Foo.names)) \
+        .first
+
+    assert foo.names['en'] == 'english'
+    assert foo.names['jp'] == 'nihongo'
+
+    sess.expire_all()
+
+    ### Test 4: Mutating the dict collection should work
+    foo = sess.query(Foo).first
+
+    foo.names['en'] = 'different english'
+    del foo.names['jp']
+
+    sess.commit()
+
+    assert foo.names['en'] == 'different english'
+    assert 'jp' not in foo.names
+
 def test_texts():
     """Check DB schema for integrity of text columns & translations.