X-Git-Url: http://git.veekun.com/zzz-pokedex.git/blobdiff_plain/31634e7159d8c385b5382ed47037972e88478358..ac248d586cbc7b919835cb7f39dd741d79283229:/pokedex/tests/test_schema.py

diff --git a/pokedex/tests/test_schema.py b/pokedex/tests/test_schema.py
index 5a03777..c050c87 100644
--- a/pokedex/tests/test_schema.py
+++ b/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
 
@@ -19,16 +21,122 @@ 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.all_tables():
+    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.
 
     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.all_tables(), key=lambda t: t.__name__):
+    for table in sorted(tables.table_classes, key=lambda t: t.__name__):
         if issubclass(table, tables.LanguageSpecific):
             good_formats = 'markdown plaintext gametext'.split()
             assert_text = '%s is language-specific'
@@ -61,7 +169,7 @@ def test_identifiers_with_names():
 
     ...have either names or identifiers.
     """
-    for table in sorted(tables.all_tables(), key=lambda t: t.__name__):
+    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
             assert hasattr(table, 'identifier'), table