From 542aa670ae0a2d080955e0f3293ae4c3df9604ab Mon Sep 17 00:00:00 2001 From: Eevee Date: Fri, 18 Mar 2011 18:22:18 -0700 Subject: [PATCH] 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 | 6 +- pokedex/tests/test_schema.py | 110 ++++++++++++++++++++++++++++++++++- 2 files changed, 112 insertions(+), 4 deletions(-) diff --git a/pokedex/db/tables.py b/pokedex/db/tables.py index d52c921..828b902 100644 --- a/pokedex/db/tables.py +++ b/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, ), ), diff --git a/pokedex/tests/test_schema.py b/pokedex/tests/test_schema.py index f1583a7..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 @@ -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.