From: Mike Bayer Date: Sat, 26 Mar 2011 23:03:11 +0000 (-0400) Subject: - remove @testing.resolve_artifact_names, replace with direct attribute X-Git-Tag: rel_0_7b4~61 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=14a2fae2398fb05f7ced56cec25e6f98307356f4;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git - remove @testing.resolve_artifact_names, replace with direct attribute access to the cls/self.tables/classes registries - express orm/_base.py ORMTest in terms of engine/_base.py TablesTest, factor out common steps into TablesTest, remove AltEngineTest as a separate class. will further consolidate these base classes --- diff --git a/test/aaa_profiling/test_orm.py b/test/aaa_profiling/test_orm.py index d028fa715e..d39a954dbc 100644 --- a/test/aaa_profiling/test_orm.py +++ b/test/aaa_profiling/test_orm.py @@ -30,21 +30,27 @@ class MergeTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Child, Parent, parent, child = (cls.classes.Child, + cls.classes.Parent, + cls.tables.parent, + cls.tables.child) + mapper(Parent, parent, properties={'children' : relationship(Child, backref='parent')}) mapper(Child, child) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + parent, child = cls.tables.parent, cls.tables.child + parent.insert().execute({'id': 1, 'data': 'p1'}) child.insert().execute({'id': 1, 'data': 'p1c1', 'parent_id' : 1}) - @testing.resolve_artifact_names def test_merge_no_load(self): + Parent = self.classes.Parent + sess = sessionmaker()() sess2 = sessionmaker()() p1 = sess.query(Parent).get(1) @@ -68,8 +74,9 @@ class MergeTest(_base.MappedTest): p3 = go() @testing.only_on('sqlite', 'Call counts tailored to pysqlite') - @testing.resolve_artifact_names def test_merge_load(self): + Parent = self.classes.Parent + sess = sessionmaker()() sess2 = sessionmaker()() p1 = sess.query(Parent).get(1) @@ -133,15 +140,20 @@ class LoadManyToOneFromIdentityTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Child, Parent, parent, child = (cls.classes.Child, + cls.classes.Parent, + cls.tables.parent, + cls.tables.child) + mapper(Parent, parent, properties={ 'child': relationship(Child)}) mapper(Child, child) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + parent, child = cls.tables.parent, cls.tables.child + child.insert().execute([ {'id':i, 'data':'c%d' % i} for i in xrange(1, 251) @@ -155,8 +167,9 @@ class LoadManyToOneFromIdentityTest(_base.MappedTest): for i in xrange(1, 1000) ]) - @testing.resolve_artifact_names def test_many_to_one_load_no_identity(self): + Parent = self.classes.Parent + sess = Session() parents = sess.query(Parent).all() @@ -167,8 +180,9 @@ class LoadManyToOneFromIdentityTest(_base.MappedTest): p.child go() - @testing.resolve_artifact_names def test_many_to_one_load_identity(self): + Parent, Child = self.classes.Parent, self.classes.Child + sess = Session() parents = sess.query(Parent).all() children = sess.query(Child).all() diff --git a/test/dialect/test_postgresql.py b/test/dialect/test_postgresql.py index 74f6c0e558..60a10b4b41 100644 --- a/test/dialect/test_postgresql.py +++ b/test/dialect/test_postgresql.py @@ -242,8 +242,9 @@ class FloatCoercionTest(TablesTest, AssertsExecutionResults): ) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + data_table = cls.tables.data_table + data_table.insert().execute( {'data':3}, {'data':5}, @@ -257,8 +258,9 @@ class FloatCoercionTest(TablesTest, AssertsExecutionResults): {'data':9}, ) - @testing.resolve_artifact_names def test_float_coercion(self): + data_table = self.tables.data_table + for type_, result in [ (Numeric, decimal.Decimal('140.381230939')), (Float, 140.381230939), diff --git a/test/engine/_base.py b/test/engine/_base.py index b55ffcadb1..ead668782c 100644 --- a/test/engine/_base.py +++ b/test/engine/_base.py @@ -1,6 +1,7 @@ import sqlalchemy as sa from test.lib import testing from test.lib.testing import adict +from test.lib.engines import drop_all_tables class TablesTest(testing.TestBase): @@ -21,25 +22,26 @@ class TablesTest(testing.TestBase): # 'once', 'each', None run_dispose_bind = None - _artifact_registries = ('tables', 'other_artifacts') - bind = None metadata = None tables = None - other_artifacts = None + other = None @classmethod def setup_class(cls): - if cls.run_setup_bind is None: - assert cls.bind is not None - assert cls.run_deletes in (None, 'each') - if cls.run_inserts == 'once': - assert cls.run_deletes is None + cls._init_class() + + cls._setup_once_tables() + + cls._setup_once_inserts() + + @classmethod + def _init_class(cls): + if cls.other is None: + cls.other = adict() if cls.tables is None: cls.tables = adict() - if cls.other_artifacts is None: - cls.other_artifacts = adict() if cls.bind is None: setattr(cls, 'bind', cls.setup_bind()) @@ -50,34 +52,34 @@ class TablesTest(testing.TestBase): if cls.metadata.bind is None: cls.metadata.bind = cls.bind - if cls.run_define_tables == 'once': - cls.define_tables(cls.metadata) - cls.metadata.create_all() - cls.tables.update(cls.metadata.tables) - + @classmethod + def _setup_once_inserts(cls): if cls.run_inserts == 'once': cls._load_fixtures() cls.insert_data() - def setup(self): - cls = self.__class__ - - if self.setup_bind == 'each': - setattr(cls, 'bind', self.setup_bind()) + @classmethod + def _setup_once_tables(cls): + if cls.run_define_tables == 'once': + cls.define_tables(cls.metadata) + cls.metadata.create_all() + cls.tables.update(cls.metadata.tables) + def _setup_each_tables(self): if self.run_define_tables == 'each': self.tables.clear() - self.metadata.drop_all() + drop_all_tables(self.metadata) self.metadata.clear() self.define_tables(self.metadata) self.metadata.create_all() self.tables.update(self.metadata.tables) + def _setup_each_inserts(self): if self.run_inserts == 'each': self._load_fixtures() self.insert_data() - def teardown(self): + def _teardown_each_tables(self): # no need to run deletes if tables are recreated on setup if self.run_define_tables != 'each' and self.run_deletes: for table in reversed(self.metadata.sorted_tables): @@ -87,14 +89,28 @@ class TablesTest(testing.TestBase): print >> sys.stderr, "Error emptying table %s: %r" % ( table, ex) + def _setup_each_bind(self): + if self.setup_bind == 'each': + setattr(cls, 'bind', self.setup_bind()) + + def _teardown_each_bind(self): if self.run_dispose_bind == 'each': self.dispose_bind(self.bind) + def setup(self): + self._setup_each_bind() + self._setup_each_tables() + self._setup_each_inserts() + + def teardown(self): + self._teardown_each_tables() + self._teardown_each_bind() + @classmethod - def teardown_class(cls): + def _teardown_once_metadata_bind(cls): cls.metadata.drop_all() - if cls.dispose_bind: + if cls.run_dispose_bind == 'once': cls.dispose_bind(cls.bind) cls.metadata.bind = None @@ -102,6 +118,10 @@ class TablesTest(testing.TestBase): if cls.run_setup_bind is not None: cls.bind = None + @classmethod + def teardown_class(cls): + cls._teardown_once_metadata_bind() + @classmethod def setup_bind(cls): return testing.db @@ -115,7 +135,7 @@ class TablesTest(testing.TestBase): @classmethod def define_tables(cls, metadata): - raise NotImplementedError() + pass @classmethod def fixtures(cls): @@ -148,20 +168,3 @@ class TablesTest(testing.TestBase): for column_values in rows[table]]) -class AltEngineTest(testing.TestBase): - engine = None - - @classmethod - def setup_class(cls): - cls.engine = cls.create_engine() - super(AltEngineTest, cls).setup_class() - - @classmethod - def teardown_class(cls): - cls.engine.dispose() - cls.engine = None - super(AltEngineTest, cls).teardown_class() - - @classmethod - def create_engine(cls): - raise NotImplementedError diff --git a/test/ext/test_associationproxy.py b/test/ext/test_associationproxy.py index 186c75a69e..ea30b1fb22 100644 --- a/test/ext/test_associationproxy.py +++ b/test/ext/test_associationproxy.py @@ -1069,8 +1069,16 @@ class ComparatorTest(_base.MappedTest): self.value = value @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, Keyword, UserKeyword, singular, userkeywords, User, keywords, Singular = (cls.tables.users, + cls.classes.Keyword, + cls.classes.UserKeyword, + cls.tables.singular, + cls.tables.userkeywords, + cls.classes.User, + cls.tables.keywords, + cls.classes.Singular) + mapper(User, users, properties={ 'singular':relationship(Singular) }) @@ -1087,8 +1095,12 @@ class ComparatorTest(_base.MappedTest): }) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + UserKeyword, User, Keyword, Singular = (cls.classes.UserKeyword, + cls.classes.User, + cls.classes.Keyword, + cls.classes.Singular) + session = sessionmaker()() words = ( 'quick', 'brown', @@ -1114,8 +1126,9 @@ class ComparatorTest(_base.MappedTest): def _equivalent(self, q_proxy, q_direct): eq_(q_proxy.all(), q_direct.all()) - @testing.resolve_artifact_names def test_filter_any_kwarg_ul_nul(self): + UserKeyword, User = self.classes.UserKeyword, self.classes.User + self._equivalent(self.session.query(User). filter(User.keywords.any(keyword='jumped' )), @@ -1124,8 +1137,9 @@ class ComparatorTest(_base.MappedTest): UserKeyword.keyword.has(keyword='jumped' )))) - @testing.resolve_artifact_names def test_filter_has_kwarg_nul_nul(self): + UserKeyword, Keyword = self.classes.UserKeyword, self.classes.Keyword + self._equivalent(self.session.query(Keyword). filter(Keyword.user.has(name='user2' )), @@ -1134,8 +1148,9 @@ class ComparatorTest(_base.MappedTest): UserKeyword.user.has(name='user2' )))) - @testing.resolve_artifact_names def test_filter_has_kwarg_nul_ul(self): + User, Singular = self.classes.User, self.classes.Singular + self._equivalent( self.session.query(User).\ filter(User.singular_keywords.any(keyword='jumped')), @@ -1147,8 +1162,11 @@ class ComparatorTest(_base.MappedTest): ) ) - @testing.resolve_artifact_names def test_filter_any_criterion_ul_nul(self): + UserKeyword, User, Keyword = (self.classes.UserKeyword, + self.classes.User, + self.classes.Keyword) + self._equivalent(self.session.query(User). filter(User.keywords.any(Keyword.keyword == 'jumped')), @@ -1157,8 +1175,11 @@ class ComparatorTest(_base.MappedTest): UserKeyword.keyword.has(Keyword.keyword == 'jumped')))) - @testing.resolve_artifact_names def test_filter_has_criterion_nul_nul(self): + UserKeyword, User, Keyword = (self.classes.UserKeyword, + self.classes.User, + self.classes.Keyword) + self._equivalent(self.session.query(Keyword). filter(Keyword.user.has(User.name == 'user2')), @@ -1167,8 +1188,11 @@ class ComparatorTest(_base.MappedTest): UserKeyword.user.has(User.name == 'user2')))) - @testing.resolve_artifact_names def test_filter_any_criterion_nul_ul(self): + User, Keyword, Singular = (self.classes.User, + self.classes.Keyword, + self.classes.Singular) + self._equivalent( self.session.query(User).\ filter(User.singular_keywords.any(Keyword.keyword=='jumped')), @@ -1180,15 +1204,17 @@ class ComparatorTest(_base.MappedTest): ) ) - @testing.resolve_artifact_names def test_filter_contains_ul_nul(self): + User = self.classes.User + self._equivalent(self.session.query(User). filter(User.keywords.contains(self.kw)), self.session.query(User). filter(User.user_keywords.any(keyword=self.kw))) - @testing.resolve_artifact_names def test_filter_contains_nul_ul(self): + User, Singular = self.classes.User, self.classes.Singular + self._equivalent( self.session.query(User).filter( User.singular_keywords.contains(self.kw) @@ -1200,49 +1226,57 @@ class ComparatorTest(_base.MappedTest): ), ) - @testing.resolve_artifact_names def test_filter_eq_nul_nul(self): + Keyword = self.classes.Keyword + self._equivalent(self.session.query(Keyword).filter(Keyword.user == self.u), self.session.query(Keyword). filter(Keyword.user_keyword.has(user=self.u))) - @testing.resolve_artifact_names def test_filter_ne_nul_nul(self): + Keyword = self.classes.Keyword + self._equivalent(self.session.query(Keyword).filter(Keyword.user != self.u), self.session.query(Keyword). filter(not_(Keyword.user_keyword.has(user=self.u)))) - @testing.resolve_artifact_names def test_filter_eq_null_nul_nul(self): + UserKeyword, Keyword = self.classes.UserKeyword, self.classes.Keyword + self._equivalent(self.session.query(Keyword).filter(Keyword.user == None), self.session.query(Keyword). filter(Keyword.user_keyword.has(UserKeyword.user == None))) - @testing.resolve_artifact_names def test_filter_scalar_contains_fails_nul_nul(self): + Keyword = self.classes.Keyword + assert_raises(exceptions.InvalidRequestError, lambda : \ Keyword.user.contains(self.u)) - @testing.resolve_artifact_names def test_filter_scalar_any_fails_nul_nul(self): + Keyword = self.classes.Keyword + assert_raises(exceptions.InvalidRequestError, lambda : \ Keyword.user.any(name='user2')) - @testing.resolve_artifact_names def test_filter_collection_has_fails_ul_nul(self): + User = self.classes.User + assert_raises(exceptions.InvalidRequestError, lambda : \ User.keywords.has(keyword='quick')) - @testing.resolve_artifact_names def test_filter_collection_eq_fails_ul_nul(self): + User = self.classes.User + assert_raises(exceptions.InvalidRequestError, lambda : \ User.keywords == self.kw) - @testing.resolve_artifact_names def test_filter_collection_ne_fails_ul_nul(self): + User = self.classes.User + assert_raises(exceptions.InvalidRequestError, lambda : \ User.keywords != self.kw) diff --git a/test/ext/test_mutable.py b/test/ext/test_mutable.py index 605920368d..c3d5aecd8c 100644 --- a/test/ext/test_mutable.py +++ b/test/ext/test_mutable.py @@ -49,8 +49,9 @@ class _MutableDictTestBase(object): self.changed() return MutationDict - @testing.resolve_artifact_names def setup_mappers(cls): + foo = cls.tables.foo + mapper(Foo, foo) def teardown(self): @@ -59,7 +60,6 @@ class _MutableDictTestBase(object): ClassManager.dispatch._clear() super(_MutableDictTestBase, self).teardown() - @testing.resolve_artifact_names def test_in_place_mutation(self): sess = Session() @@ -72,7 +72,6 @@ class _MutableDictTestBase(object): eq_(f1.data, {'a':'c'}) - @testing.resolve_artifact_names def test_pickle_parent(self): sess = Session() @@ -89,7 +88,6 @@ class _MutableDictTestBase(object): f2.data['a'] = 'c' assert f2 in sess.dirty - @testing.resolve_artifact_names def _test_non_mutable(self): sess = Session() @@ -243,15 +241,15 @@ class MutableCompositesTest(_CompositeTestBase, _base.MappedTest): return Point @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + foo = cls.tables.foo + Point = cls._type_fixture() mapper(Foo, foo, properties={ 'data':composite(Point, foo.c.x, foo.c.y) }) - @testing.resolve_artifact_names def test_in_place_mutation(self): sess = Session() d = Point(3, 4) @@ -264,7 +262,6 @@ class MutableCompositesTest(_CompositeTestBase, _base.MappedTest): eq_(f1.data, Point(3, 5)) - @testing.resolve_artifact_names def test_pickle_of_parent(self): sess = Session() d = Point(3, 4) diff --git a/test/lib/testing.py b/test/lib/testing.py index bf852de7cd..e4edb8a86d 100644 --- a/test/lib/testing.py +++ b/test/lib/testing.py @@ -450,8 +450,6 @@ def global_cleanup_assertions(): testutil.lazy_gc() assert not pool._refs - - def against(*queries): """Boolean predicate, compares to testing database configuration. @@ -563,32 +561,6 @@ def provide_metadata(fn, *args, **kw): finally: metadata.drop_all() -@decorator -def resolve_artifact_names(fn, *args, **kw): - """Decorator, augment function globals with tables and classes. - - Swaps out the function's globals at execution time. The 'global' statement - will not work as expected inside a decorated function. - - """ - # This could be automatically applied to framework and test_ methods in - # the MappedTest-derived test suites but... *some* explicitness for this - # magic is probably good. Especially as 'global' won't work- these - # rebound functions aren't regular Python.. - # - # Also: it's lame that CPython accepts a dict-subclass for globals, but - # only calls dict methods. That would allow 'global' to pass through to - # the func_globals. - self = args[0] - context = dict(fn.func_globals) - for source in self._artifact_registries: - context.update(getattr(self, source)) - # jython bug #1034 - rebound = types.FunctionType( - fn.func_code, context, fn.func_name, fn.func_defaults, - fn.func_closure) - return rebound(*args, **kw) - class adict(dict): """Dict keys available as attributes. Shadows.""" def __getattribute__(self, key): diff --git a/test/orm/_base.py b/test/orm/_base.py index cd75e464fb..d66cc57a00 100644 --- a/test/orm/_base.py +++ b/test/orm/_base.py @@ -4,14 +4,13 @@ import types import sqlalchemy as sa from sqlalchemy import exc as sa_exc from test.lib import config, testing -from test.lib.testing import resolve_artifact_names, adict -from test.lib.engines import drop_all_tables +from test.lib.testing import adict from test.lib.entities import BasicEntity, ComparableEntity +from test.engine._base import TablesTest Entity = BasicEntity - -class ORMTest(testing.TestBase, testing.AssertsExecutionResults): +class _ORMTest(object): __requires__ = ('subqueries',) @classmethod @@ -21,126 +20,86 @@ class ORMTest(testing.TestBase, testing.AssertsExecutionResults): # TODO: ensure mapper registry is empty # TODO: ensure instrumentation registry is empty -class MappedTest(ORMTest): - # 'once', 'each', None - run_define_tables = 'once' +class ORMTest(_ORMTest, testing.TestBase): + pass +class MappedTest(_ORMTest, TablesTest, testing.AssertsExecutionResults): # 'once', 'each', None run_setup_classes = 'once' # 'once', 'each', None run_setup_mappers = 'each' - # 'once', 'each', None - run_inserts = 'each' - - # 'each', None - run_deletes = 'each' - - metadata = None - - _artifact_registries = ('tables', 'classes', 'other_artifacts') - tables = None classes = None - other_artifacts = None @classmethod def setup_class(cls): - if cls.run_setup_classes == 'each': - assert cls.run_setup_mappers != 'once' - - assert cls.run_deletes in (None, 'each') - if cls.run_inserts == 'once': - assert cls.run_deletes is None - - assert not hasattr(cls, 'keep_mappers') - assert not hasattr(cls, 'keep_data') + cls._init_class() - if cls.tables is None: - cls.tables = adict() if cls.classes is None: cls.classes = adict() - if cls.other_artifacts is None: - cls.other_artifacts = adict() - if cls.metadata is None: - setattr(cls, 'metadata', sa.MetaData()) + cls._setup_once_tables() - if cls.metadata.bind is None: - cls.metadata.bind = getattr(cls, 'engine', config.db) + cls._setup_once_classes() - if cls.run_define_tables == 'once': - cls.define_tables(cls.metadata) - cls.metadata.create_all() - cls.tables.update(cls.metadata.tables) + cls._setup_once_mappers() + cls._setup_once_inserts() + + @classmethod + def _setup_once_classes(cls): if cls.run_setup_classes == 'once': baseline = subclasses(BasicEntity) cls.setup_classes() cls._register_new_class_artifacts(baseline) + @classmethod + def _setup_once_mappers(cls): if cls.run_setup_mappers == 'once': baseline = subclasses(BasicEntity) cls.setup_mappers() cls._register_new_class_artifacts(baseline) - if cls.run_inserts == 'once': - cls._load_fixtures() - cls.insert_data() - - def setup(self): - if self.run_define_tables == 'each': - self.tables.clear() - drop_all_tables(self.metadata) - self.metadata.clear() - self.define_tables(self.metadata) - self.metadata.create_all() - self.tables.update(self.metadata.tables) - + def _setup_each_classes(self): if self.run_setup_classes == 'each': self.classes.clear() baseline = subclasses(BasicEntity) self.setup_classes() self._register_new_class_artifacts(baseline) + def _setup_each_mappers(self): if self.run_setup_mappers == 'each': baseline = subclasses(BasicEntity) self.setup_mappers() self._register_new_class_artifacts(baseline) - if self.run_inserts == 'each': - self._load_fixtures() - self.insert_data() - - def teardown(self): - sa.orm.session.Session.close_all() - + def _teardown_each_mappers(self): # some tests create mappers in the test bodies # and will define setup_mappers as None - # clear mappers in any case if self.run_setup_mappers != 'once': sa.orm.clear_mappers() - # no need to run deletes if tables are recreated on setup - if self.run_define_tables != 'each' and self.run_deletes: - for table in reversed(self.metadata.sorted_tables): - try: - table.delete().execute().close() - except sa.exc.DBAPIError, ex: - print >> sys.stderr, "Error emptying table %s: %r" % ( - table, ex) + def setup(self): + self._setup_each_tables() + self._setup_each_classes() + + self._setup_each_mappers() + self._setup_each_inserts() + + def teardown(self): + sa.orm.session.Session.close_all() + self._teardown_each_mappers() + self._teardown_each_tables() + self._teardown_each_bind() @classmethod def teardown_class(cls): for cl in cls.classes.values(): cls.unregister_class(cl) - ORMTest.teardown_class() - drop_all_tables(cls.metadata) - cls.metadata.bind = None - - @classmethod - def define_tables(cls, metadata): - raise NotImplementedError() + _ORMTest.teardown_class() + cls._teardown_once_metadata_bind() @classmethod def setup_classes(cls): @@ -150,21 +109,6 @@ class MappedTest(ORMTest): def setup_mappers(cls): pass - @classmethod - def fixtures(cls): - return {} - - @classmethod - def insert_data(cls): - pass - - def sql_count_(self, count, fn): - self.assert_sql_count(self.metadata.bind, fn, count) - - def sql_eq_(self, callable_, statements, with_sequences=None): - self.assert_sql(self.metadata.bind, - callable_, statements, with_sequences) - @classmethod def _register_new_class_artifacts(cls, baseline): for class_ in subclasses(BasicEntity) - baseline: diff --git a/test/orm/inheritance/test_basic.py b/test/orm/inheritance/test_basic.py index 96c31d516f..ea7cf9a69a 100644 --- a/test/orm/inheritance/test_basic.py +++ b/test/orm/inheritance/test_basic.py @@ -85,8 +85,9 @@ class PolymorphicOnNotLocalTest(_base.MappedTest): Column('y', String(10)), Column('xid', ForeignKey('t1.id'))) - @testing.resolve_artifact_names def test_bad_polymorphic_on(self): + t2, t1 = self.tables.t2, self.tables.t1 + class InterfaceBase(object): pass @@ -224,8 +225,11 @@ class PolymorphicAttributeManagementTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): + table_b, table_c, table_a = (cls.tables.table_b, + cls.tables.table_c, + cls.tables.table_a) + class A(_base.ComparableEntity): pass class B(A): @@ -242,8 +246,11 @@ class PolymorphicAttributeManagementTest(_base.MappedTest): mapper(C, table_c, inherits=B, polymorphic_identity='c') - @testing.resolve_artifact_names def test_poly_configured_immediate(self): + A, C, B = (self.classes.A, + self.classes.C, + self.classes.B) + a = A() b = B() c = C() @@ -251,8 +258,11 @@ class PolymorphicAttributeManagementTest(_base.MappedTest): eq_(b.class_name, 'b') eq_(c.class_name, 'c') - @testing.resolve_artifact_names def test_base_class(self): + A, C, B = (self.classes.A, + self.classes.C, + self.classes.B) + sess = Session() c1 = C() sess.add(c1) @@ -264,8 +274,9 @@ class PolymorphicAttributeManagementTest(_base.MappedTest): assert isinstance(sess.query(A).first(), C) - @testing.resolve_artifact_names def test_assignment(self): + C, B = self.classes.C, self.classes.B + sess = Session() b1 = B() b1.class_name = 'c' @@ -362,8 +373,11 @@ class M2OUseGetTest(_base.MappedTest): Column('sub_id', Integer, ForeignKey('sub.id')), ) - @testing.resolve_artifact_names def test_use_get(self): + base, sub, related = (self.tables.base, + self.tables.sub, + self.tables.related) + # test [ticket:1186] class Base(_base.BasicEntity): pass @@ -435,8 +449,14 @@ class GetTest(_base.MappedTest): def test_get_nonpolymorphic(self): self._do_get_test(False) - @testing.resolve_artifact_names def _do_get_test(self, polymorphic): + foo, Bar, Blub, blub, bar, Foo = (self.tables.foo, + self.classes.Bar, + self.classes.Blub, + self.tables.blub, + self.tables.bar, + self.classes.Foo) + if polymorphic: mapper(Foo, foo, polymorphic_on=foo.c.type, polymorphic_identity='foo') mapper(Bar, bar, inherits=Foo, polymorphic_identity='bar') @@ -559,8 +579,9 @@ class EagerTargetingTest(_base.MappedTest): Column('b_data', String(50)), ) - @testing.resolve_artifact_names def test_adapt_stringency(self): + b_table, a_table = self.tables.b_table, self.tables.a_table + class A(_base.ComparableEntity): pass class B(A): @@ -623,8 +644,12 @@ class FlushTest(_base.MappedTest): Column('user_id', Integer, ForeignKey('users.id')) ) - @testing.resolve_artifact_names def test_one(self): + admins, users, roles, user_roles = (self.tables.admins, + self.tables.users, + self.tables.roles, + self.tables.user_roles) + class User(object):pass class Role(object):pass class Admin(User):pass @@ -651,8 +676,12 @@ class FlushTest(_base.MappedTest): assert user_roles.count().scalar() == 1 - @testing.resolve_artifact_names def test_two(self): + admins, users, roles, user_roles = (self.tables.admins, + self.tables.users, + self.tables.roles, + self.tables.user_roles) + class User(object): def __init__(self, email=None, password=None): self.email = email @@ -709,8 +738,11 @@ class VersioningTest(_base.MappedTest): @testing.emits_warning(r".*updated rowcount") @engines.close_open_connections - @testing.resolve_artifact_names def test_save_update(self): + subtable, base, stuff = (self.tables.subtable, + self.tables.base, + self.tables.stuff) + class Base(_fixtures.Base): pass class Sub(Base): @@ -759,8 +791,9 @@ class VersioningTest(_base.MappedTest): sess2.flush() @testing.emits_warning(r".*updated rowcount") - @testing.resolve_artifact_names def test_delete(self): + subtable, base = self.tables.subtable, self.tables.base + class Base(_fixtures.Base): pass class Sub(Base): @@ -1200,8 +1233,9 @@ class OptimizedLoadTest(_base.MappedTest): Column('b', String(10)) ) - @testing.resolve_artifact_names def test_optimized_passes(self): + base, sub = self.tables.base, self.tables.sub + """"test that the 'optimized load' routine doesn't crash when a column in the join condition is not available.""" @@ -1230,8 +1264,9 @@ class OptimizedLoadTest(_base.MappedTest): s1 = sess.query(Base).first() assert s1.sub == 's1sub' - @testing.resolve_artifact_names def test_column_expression(self): + base, sub = self.tables.base, self.tables.sub + class Base(_base.BasicEntity): pass class Sub(Base): @@ -1248,8 +1283,9 @@ class OptimizedLoadTest(_base.MappedTest): s1 = sess.query(Base).first() assert s1.concat == 's1sub|s1sub' - @testing.resolve_artifact_names def test_column_expression_joined(self): + base, sub = self.tables.base, self.tables.sub + class Base(_base.ComparableEntity): pass class Sub(Base): @@ -1278,8 +1314,9 @@ class OptimizedLoadTest(_base.MappedTest): ] ) - @testing.resolve_artifact_names def test_composite_column_joined(self): + base, with_comp = self.tables.base, self.tables.with_comp + class Base(_base.ComparableEntity): pass class WithComp(Base): @@ -1308,8 +1345,9 @@ class OptimizedLoadTest(_base.MappedTest): eq_(s1test.comp, Comp('ham', 'cheese')) eq_(s2test.comp, Comp('bacon', 'eggs')) - @testing.resolve_artifact_names def test_load_expired_on_pending(self): + base, sub = self.tables.base, self.tables.sub + class Base(_base.ComparableEntity): pass class Sub(Base): @@ -1344,8 +1382,9 @@ class OptimizedLoadTest(_base.MappedTest): ), ) - @testing.resolve_artifact_names def test_dont_generate_on_none(self): + base, sub = self.tables.base, self.tables.sub + class Base(_base.ComparableEntity): pass class Sub(Base): @@ -1370,8 +1409,11 @@ class OptimizedLoadTest(_base.MappedTest): assert m._optimized_get_statement(attributes.instance_state(s1), ['counter2']) is not None - @testing.resolve_artifact_names def test_load_expired_on_pending_twolevel(self): + base, sub, subsub = (self.tables.base, + self.tables.sub, + self.tables.subsub) + class Base(_base.ComparableEntity): pass class Sub(Base): @@ -1477,8 +1519,9 @@ class PKDiscriminatorTest(_base.MappedTest): Column('type', Integer,primary_key=True), Column('name', String(60))) - @testing.resolve_artifact_names def test_pk_as_discriminator(self): + parents, children = self.tables.parents, self.tables.children + class Parent(object): def __init__(self, name=None): self.name = name @@ -1539,37 +1582,53 @@ class NoPolyIdentInMiddleTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + A, C, B, E, D, base = (cls.classes.A, + cls.classes.C, + cls.classes.B, + cls.classes.E, + cls.classes.D, + cls.tables.base) + mapper(A, base, polymorphic_on=base.c.type) mapper(B, inherits=A, ) mapper(C, inherits=B, polymorphic_identity='c') mapper(D, inherits=B, polymorphic_identity='d') mapper(E, inherits=A, polymorphic_identity='e') - @testing.resolve_artifact_names def test_load_from_middle(self): + C, B = self.classes.C, self.classes.B + s = Session() s.add(C()) o = s.query(B).first() eq_(o.type, 'c') assert isinstance(o, C) - @testing.resolve_artifact_names def test_load_from_base(self): + A, C = self.classes.A, self.classes.C + s = Session() s.add(C()) o = s.query(A).first() eq_(o.type, 'c') assert isinstance(o, C) - @testing.resolve_artifact_names def test_discriminator(self): + C, B, base = (self.classes.C, + self.classes.B, + self.tables.base) + assert class_mapper(B).polymorphic_on is base.c.type assert class_mapper(C).polymorphic_on is base.c.type - @testing.resolve_artifact_names def test_load_multiple_from_middle(self): + C, B, E, D, base = (self.classes.C, + self.classes.B, + self.classes.E, + self.classes.D, + self.tables.base) + s = Session() s.add_all([C(), D(), E()]) eq_( diff --git a/test/orm/inheritance/test_concrete.py b/test/orm/inheritance/test_concrete.py index 4e20e7a787..02f266b3cc 100644 --- a/test/orm/inheritance/test_concrete.py +++ b/test/orm/inheritance/test_concrete.py @@ -409,8 +409,14 @@ class PropertyInheritanceTest(_base.MappedTest): class Dest(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_noninherited_warning(self): + A, B, b_table, a_table, Dest, dest_table = (self.classes.A, + self.classes.B, + self.tables.b_table, + self.tables.a_table, + self.classes.Dest, + self.tables.dest_table) + mapper(A, a_table, properties={'some_dest': relationship(Dest)}) mapper(B, b_table, inherits=A, concrete=True) mapper(Dest, dest_table) @@ -430,8 +436,14 @@ class PropertyInheritanceTest(_base.MappedTest): mapper(B, b_table, inherits=A, concrete=True) mapper(Dest, dest_table) - @testing.resolve_artifact_names def test_inheriting(self): + A, B, b_table, a_table, Dest, dest_table = (self.classes.A, + self.classes.B, + self.tables.b_table, + self.tables.a_table, + self.classes.Dest, + self.tables.dest_table) + mapper(A, a_table, properties={ 'some_dest': relationship(Dest,back_populates='many_a') }) @@ -464,8 +476,16 @@ class PropertyInheritanceTest(_base.MappedTest): assert dest1.many_b == [b1, b2] assert sess.query(B).filter(B.bname == 'b1').one() is b1 - @testing.resolve_artifact_names def test_polymorphic_backref(self): + A, C, B, c_table, b_table, a_table, Dest, dest_table = (self.classes.A, + self.classes.C, + self.classes.B, + self.tables.c_table, + self.tables.b_table, + self.tables.a_table, + self.classes.Dest, + self.tables.dest_table) + """test multiple backrefs to the same polymorphically-loading attribute.""" @@ -543,8 +563,16 @@ class PropertyInheritanceTest(_base.MappedTest): self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_merge_w_relationship(self): + A, C, B, c_table, b_table, a_table, Dest, dest_table = (self.classes.A, + self.classes.C, + self.classes.B, + self.tables.c_table, + self.tables.b_table, + self.tables.a_table, + self.classes.Dest, + self.tables.dest_table) + ajoin = polymorphic_union({'a': a_table, 'b': b_table, 'c':c_table}, 'type','ajoin') mapper( @@ -622,7 +650,6 @@ class ManyToManyTest(_base.MappedTest): primary_key=True, test_needs_autoincrement=True)) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): class Base(_base.ComparableEntity): pass @@ -634,8 +661,16 @@ class ManyToManyTest(_base.MappedTest): pass - @testing.resolve_artifact_names def test_selective_relationships(self): + sub, base_mtom, Related, Base, related, sub_mtom, base, Sub = (self.tables.sub, + self.tables.base_mtom, + self.classes.Related, + self.classes.Base, + self.tables.related, + self.tables.sub_mtom, + self.tables.base, + self.classes.Sub) + mapper(Base, base, properties={'related': relationship(Related, secondary=base_mtom, backref='bases', order_by=related.c.id)}) diff --git a/test/orm/inheritance/test_query.py b/test/orm/inheritance/test_query.py index 7cfd2000cd..08131d7020 100644 --- a/test/orm/inheritance/test_query.py +++ b/test/orm/inheritance/test_query.py @@ -924,8 +924,9 @@ class SelfReferentialTestJoinedToBase(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + engineers, people = cls.tables.engineers, cls.tables.people + mapper(Person, people, polymorphic_on=people.c.type, polymorphic_identity='person') mapper(Engineer, engineers, inherits=Person, inherit_condition=engineers.c.person_id==people.c.person_id, @@ -933,7 +934,6 @@ class SelfReferentialTestJoinedToBase(_base.MappedTest): 'reports_to':relationship(Person, primaryjoin=people.c.person_id==engineers.c.reports_to_id) }) - @testing.resolve_artifact_names def test_has(self): p1 = Person(name='dogbert') @@ -946,7 +946,6 @@ class SelfReferentialTestJoinedToBase(_base.MappedTest): eq_(sess.query(Engineer).filter(Engineer.reports_to.has(Person.name=='dogbert')).first(), Engineer(name='dilbert')) - @testing.resolve_artifact_names def test_oftype_aliases_in_exists(self): e1 = Engineer(name='dilbert', primary_language='java') e2 = Engineer(name='wally', primary_language='c++', reports_to=e1) @@ -956,7 +955,6 @@ class SelfReferentialTestJoinedToBase(_base.MappedTest): eq_(sess.query(Engineer).filter(Engineer.reports_to.of_type(Engineer).has(Engineer.name=='dilbert')).first(), e2) - @testing.resolve_artifact_names def test_join(self): p1 = Person(name='dogbert') e1 = Engineer(name='dilbert', primary_language='java', reports_to=p1) @@ -991,8 +989,11 @@ class SelfReferentialJ2JTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + engineers, managers, people = (cls.tables.engineers, + cls.tables.managers, + cls.tables.people) + mapper(Person, people, polymorphic_on=people.c.type, polymorphic_identity='person') mapper(Manager, managers, inherits=Person, polymorphic_identity='manager') @@ -1001,7 +1002,6 @@ class SelfReferentialJ2JTest(_base.MappedTest): 'reports_to':relationship(Manager, primaryjoin=managers.c.person_id==engineers.c.reports_to_id, backref='engineers') }) - @testing.resolve_artifact_names def test_has(self): m1 = Manager(name='dogbert') @@ -1014,7 +1014,6 @@ class SelfReferentialJ2JTest(_base.MappedTest): eq_(sess.query(Engineer).filter(Engineer.reports_to.has(Manager.name=='dogbert')).first(), Engineer(name='dilbert')) - @testing.resolve_artifact_names def test_join(self): m1 = Manager(name='dogbert') e1 = Engineer(name='dilbert', primary_language='java', reports_to=m1) @@ -1028,7 +1027,6 @@ class SelfReferentialJ2JTest(_base.MappedTest): sess.query(Engineer).join('reports_to', aliased=True).filter(Manager.name=='dogbert').first(), Engineer(name='dilbert')) - @testing.resolve_artifact_names def test_filter_aliasing(self): m1 = Manager(name='dogbert') m2 = Manager(name='foo') @@ -1059,7 +1057,6 @@ class SelfReferentialJ2JTest(_base.MappedTest): ] ) - @testing.resolve_artifact_names def test_relationship_compare(self): m1 = Manager(name='dogbert') m2 = Manager(name='foo') @@ -1114,8 +1111,12 @@ class M2MFilterTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + organizations, people, engineers, engineers_to_org = (cls.tables.organizations, + cls.tables.people, + cls.tables.engineers, + cls.tables.engineers_to_org) + class Organization(_fixtures.Base): pass @@ -1127,8 +1128,9 @@ class M2MFilterTest(_base.MappedTest): mapper(Engineer, engineers, inherits=Person, polymorphic_identity='engineer') @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Organization = cls.classes.Organization + e1 = Engineer(name='e1') e2 = Engineer(name='e2') e3 = Engineer(name='e3') @@ -1141,8 +1143,9 @@ class M2MFilterTest(_base.MappedTest): sess.add(org2) sess.flush() - @testing.resolve_artifact_names def test_not_contains(self): + Organization = self.classes.Organization + sess = create_session() e1 = sess.query(Person).filter(Engineer.name == 'e1').one() @@ -1159,8 +1162,9 @@ class M2MFilterTest(_base.MappedTest): eq_(sess.query(Organization).filter(~Organization.engineers.contains(e1)).all(), [Organization(name='org2')]) - @testing.resolve_artifact_names def test_any(self): + Organization = self.classes.Organization + sess = create_session() eq_(sess.query(Organization).filter(Organization.engineers.of_type(Engineer).any(Engineer.name == 'e1')).all(), [Organization(name='org1')]) @@ -1195,8 +1199,15 @@ class SelfReferentialM2MTest(_base.MappedTest, AssertsCompiledSQL): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + child1, child2, Parent, parent, Child1, Child2, secondary = (cls.tables.child1, + cls.tables.child2, + cls.classes.Parent, + cls.tables.parent, + cls.classes.Child1, + cls.classes.Child2, + cls.tables.secondary) + mapper(Parent, parent, polymorphic_on=parent.c.cls) mapper(Child1, child1, inherits=Parent, polymorphic_identity='child1', properties={ 'left_child2' : relationship(Child2, @@ -1209,8 +1220,9 @@ class SelfReferentialM2MTest(_base.MappedTest, AssertsCompiledSQL): }) mapper(Child2, child2, inherits=Parent, polymorphic_identity = 'child2') - @testing.resolve_artifact_names def test_query_crit(self): + Child1, Child2 = self.classes.Child1, self.classes.Child2 + session = create_session() c11, c12, c13 = Child1(), Child1(), Child1() c21, c22, c23 = Child2(), Child2(), Child2() @@ -1250,8 +1262,9 @@ class SelfReferentialM2MTest(_base.MappedTest, AssertsCompiledSQL): dialect=default.DefaultDialect() ) - @testing.resolve_artifact_names def test_eager_join(self): + Child1, Child2 = self.classes.Child1, self.classes.Child2 + session = create_session() c1 = Child1() @@ -1279,8 +1292,9 @@ class SelfReferentialM2MTest(_base.MappedTest, AssertsCompiledSQL): assert q.first() is c1 - @testing.resolve_artifact_names def test_subquery_load(self): + Child1, Child2 = self.classes.Child1, self.classes.Child2 + session = create_session() c1 = Child1() @@ -1329,7 +1343,6 @@ class EagerToSubclassTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): class Parent(_base.ComparableEntity): pass @@ -1344,8 +1357,16 @@ class EagerToSubclassTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Base, sub, parent, related, base, Related, Parent, Sub = (cls.classes.Base, + cls.tables.sub, + cls.tables.parent, + cls.tables.related, + cls.tables.base, + cls.classes.Related, + cls.classes.Parent, + cls.classes.Sub) + mapper(Parent, parent, properties={ 'children':relationship(Sub, order_by=sub.c.data) }) @@ -1360,8 +1381,11 @@ class EagerToSubclassTest(_base.MappedTest): mapper(Related, related) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Parent, Sub, Related = (cls.classes.Parent, + cls.classes.Sub, + cls.classes.Related) + sess = Session() r1, r2 = Related(data='r1'), Related(data='r2') s1, s2, s3 = Sub(data='s1', related=r1), \ @@ -1375,8 +1399,9 @@ class EagerToSubclassTest(_base.MappedTest): sess.add(p2) sess.commit() - @testing.resolve_artifact_names def test_joinedload(self): + Sub, Parent = self.classes.Sub, self.classes.Parent + sess = Session() def go(): eq_( @@ -1396,8 +1421,9 @@ class EagerToSubclassTest(_base.MappedTest): ) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_contains_eager(self): + Sub, Parent = self.classes.Sub, self.classes.Parent + sess = Session() def go(): eq_( @@ -1418,8 +1444,11 @@ class EagerToSubclassTest(_base.MappedTest): ) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_subq_through_related(self): + Related, Parent, Sub = (self.classes.Related, + self.classes.Parent, + self.classes.Sub) + sess = Session() def go(): eq_( @@ -1475,7 +1504,6 @@ class SubClassEagerToSubClassTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): class Parent(_base.ComparableEntity): pass @@ -1490,8 +1518,16 @@ class SubClassEagerToSubClassTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Sub, parent, subparent, Subparent, Base, base, Parent, sub = (cls.classes.Sub, + cls.tables.parent, + cls.tables.subparent, + cls.classes.Subparent, + cls.classes.Base, + cls.tables.base, + cls.classes.Parent, + cls.tables.sub) + mapper(Parent, parent, polymorphic_on=parent.c.type, polymorphic_identity='b') mapper(Subparent, subparent, inherits=Parent, polymorphic_identity='s', properties={ 'children':relationship(Sub, order_by=base.c.id) @@ -1500,8 +1536,9 @@ class SubClassEagerToSubClassTest(_base.MappedTest): mapper(Sub, sub, inherits=Base, polymorphic_identity='s') @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Sub, Subparent = cls.classes.Sub, cls.classes.Subparent + sess = create_session() p1 = Subparent(data='p1', children=[Sub(data='s1'), Sub(data='s2'), Sub(data='s3')]) p2 = Subparent(data='p2', children=[Sub(data='s4'), Sub(data='s5')]) @@ -1509,8 +1546,9 @@ class SubClassEagerToSubClassTest(_base.MappedTest): sess.add(p2) sess.flush() - @testing.resolve_artifact_names def test_joinedload(self): + Sub, Subparent = self.classes.Sub, self.classes.Subparent + sess = create_session() def go(): eq_( @@ -1533,8 +1571,9 @@ class SubClassEagerToSubClassTest(_base.MappedTest): ) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_contains_eager(self): + Sub, Subparent = self.classes.Sub, self.classes.Subparent + sess = create_session() def go(): eq_( @@ -1557,8 +1596,9 @@ class SubClassEagerToSubClassTest(_base.MappedTest): ) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_subqueryload(self): + Sub, Subparent = self.classes.Sub, self.classes.Subparent + sess = create_session() def go(): eq_( diff --git a/test/orm/inheritance/test_single.py b/test/orm/inheritance/test_single.py index b5b9dbf884..2815806c63 100644 --- a/test/orm/inheritance/test_single.py +++ b/test/orm/inheritance/test_single.py @@ -37,15 +37,24 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Employee, Manager, JuniorEngineer, employees, Engineer = (cls.classes.Employee, + cls.classes.Manager, + cls.classes.JuniorEngineer, + cls.tables.employees, + cls.classes.Engineer) + mapper(Employee, employees, polymorphic_on=employees.c.type) mapper(Manager, inherits=Employee, polymorphic_identity='manager') mapper(Engineer, inherits=Employee, polymorphic_identity='engineer') mapper(JuniorEngineer, inherits=Engineer, polymorphic_identity='juniorengineer') - @testing.resolve_artifact_names def test_single_inheritance(self): + Employee, JuniorEngineer, Manager, Engineer = (self.classes.Employee, + self.classes.JuniorEngineer, + self.classes.Manager, + self.classes.Engineer) + session = create_session() @@ -68,8 +77,11 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): assert row.name == 'Kurt' assert row.employee_id == e1.employee_id - @testing.resolve_artifact_names def test_multi_qualification(self): + JuniorEngineer, Manager, Engineer = (self.classes.JuniorEngineer, + self.classes.Manager, + self.classes.Engineer) + session = create_session() m1 = Manager(name='Tom', manager_data='knows how to manage things') @@ -116,8 +128,9 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): # [] # ) - @testing.resolve_artifact_names def test_from_self(self): + Engineer = self.classes.Engineer + sess = create_session() self.assert_compile(sess.query(Engineer).from_self(), 'SELECT anon_1.employees_employee_id AS ' @@ -141,8 +154,12 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): '(:type_1, :type_2)', use_default_dialect=True) - @testing.resolve_artifact_names def test_select_from(self): + Manager, JuniorEngineer, employees, Engineer = (self.classes.Manager, + self.classes.JuniorEngineer, + self.tables.employees, + self.classes.Engineer) + sess = create_session() m1 = Manager(name='Tom', manager_data='data1') m2 = Manager(name='Tom2', manager_data='data2') @@ -156,8 +173,12 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): [m1, m2] ) - @testing.resolve_artifact_names def test_count(self): + Employee, JuniorEngineer, Manager, Engineer = (self.classes.Employee, + self.classes.JuniorEngineer, + self.classes.Manager, + self.classes.Engineer) + sess = create_session() m1 = Manager(name='Tom', manager_data='data1') m2 = Manager(name='Tom2', manager_data='data2') @@ -173,8 +194,12 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): eq_(sess.query(Manager).filter(Manager.name.like('%m%')).count(), 2) eq_(sess.query(Employee).filter(Employee.name.like('%m%')).count(), 3) - @testing.resolve_artifact_names def test_type_filtering(self): + Employee, Manager, reports, Engineer = (self.classes.Employee, + self.classes.Manager, + self.tables.reports, + self.classes.Engineer) + class Report(ComparableEntity): pass mapper(Report, reports, properties={ @@ -190,8 +215,12 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest): assert len(rq.filter(Report.employee.of_type(Manager).has()).all()) == 1 assert len(rq.filter(Report.employee.of_type(Engineer).has()).all()) == 0 - @testing.resolve_artifact_names def test_type_joins(self): + Employee, Manager, reports, Engineer = (self.classes.Employee, + self.classes.Manager, + self.tables.reports, + self.classes.Engineer) + class Report(ComparableEntity): pass mapper(Report, reports, properties={ @@ -232,8 +261,13 @@ class RelationshipFromSingleTest(testing.AssertsCompiledSQL, MappedTest): class Stuff(ComparableEntity): pass - @testing.resolve_artifact_names def test_subquery_load(self): + employee, employee_stuff, Employee, Stuff, Manager = (self.tables.employee, + self.tables.employee_stuff, + self.classes.Employee, + self.classes.Stuff, + self.classes.Manager) + mapper(Employee, employee, polymorphic_on=employee.c.type, polymorphic_identity='employee') mapper(Manager, inherits=Employee, polymorphic_identity='manager', properties={ 'stuff':relationship(Stuff) @@ -290,8 +324,15 @@ class RelationshipToSingleTest(MappedTest): class JuniorEngineer(Engineer): pass - @testing.resolve_artifact_names def test_of_type(self): + JuniorEngineer, Company, companies, Manager, Employee, employees, Engineer = (self.classes.JuniorEngineer, + self.classes.Company, + self.tables.companies, + self.classes.Manager, + self.classes.Employee, + self.tables.employees, + self.classes.Engineer) + mapper(Company, companies, properties={ 'employees':relationship(Employee, backref='company') }) @@ -326,8 +367,15 @@ class RelationshipToSingleTest(MappedTest): ) - @testing.resolve_artifact_names def test_relationship_to_subclass(self): + JuniorEngineer, Company, companies, Manager, Employee, employees, Engineer = (self.classes.JuniorEngineer, + self.classes.Company, + self.tables.companies, + self.classes.Manager, + self.classes.Employee, + self.tables.employees, + self.classes.Engineer) + mapper(Company, companies, properties={ 'engineers':relationship(Engineer) }) diff --git a/test/orm/test_association.py b/test/orm/test_association.py index e681099c55..41dfe178b6 100644 --- a/test/orm/test_association.py +++ b/test/orm/test_association.py @@ -48,8 +48,11 @@ class AssociationTest(_base.MappedTest): self.item_id, self.keyword, self.data) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + KeywordAssociation, Item, Keyword = (cls.classes.KeywordAssociation, + cls.classes.Item, + cls.classes.Keyword) + items, item_keywords, keywords = cls.tables.get_all( 'items', 'item_keywords', 'keywords') @@ -64,8 +67,11 @@ class AssociationTest(_base.MappedTest): cascade="all, delete-orphan") }) - @testing.resolve_artifact_names def test_insert(self): + KeywordAssociation, Item, Keyword = (self.classes.KeywordAssociation, + self.classes.Item, + self.classes.Keyword) + sess = create_session() item1 = Item('item1') item2 = Item('item2') @@ -80,8 +86,11 @@ class AssociationTest(_base.MappedTest): loaded = repr(l) eq_(saved, loaded) - @testing.resolve_artifact_names def test_replace(self): + KeywordAssociation, Item, Keyword = (self.classes.KeywordAssociation, + self.classes.Item, + self.classes.Keyword) + sess = create_session() item1 = Item('item1') item1.keywords.append(KeywordAssociation(Keyword('blue'), 'blue_assoc')) @@ -99,8 +108,11 @@ class AssociationTest(_base.MappedTest): loaded = repr(l) eq_(saved, loaded) - @testing.resolve_artifact_names def test_modify(self): + KeywordAssociation, Item, Keyword = (self.classes.KeywordAssociation, + self.classes.Item, + self.classes.Keyword) + sess = create_session() item1 = Item('item1') item2 = Item('item2') @@ -126,8 +138,12 @@ class AssociationTest(_base.MappedTest): loaded = repr(l) eq_(saved, loaded) - @testing.resolve_artifact_names def test_delete(self): + KeywordAssociation, Item, item_keywords, Keyword = (self.classes.KeywordAssociation, + self.classes.Item, + self.tables.item_keywords, + self.classes.Keyword) + sess = create_session() item1 = Item('item1') item2 = Item('item2') diff --git a/test/orm/test_assorted_eager.py b/test/orm/test_assorted_eager.py index eb4104355d..ac935acda6 100644 --- a/test/orm/test_assorted_eager.py +++ b/test/orm/test_assorted_eager.py @@ -30,7 +30,7 @@ class EagerTest(_base.MappedTest): else: false = "0" - cls.other_artifacts['false'] = false + cls.other['false'] = false Table('owners', metadata , Column('id', Integer, primary_key=True, test_needs_autoincrement=True), @@ -67,8 +67,16 @@ class EagerTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Category, owners, Option, tests, Thing, Owner, options, categories = (cls.classes.Category, + cls.tables.owners, + cls.classes.Option, + cls.tables.tests, + cls.classes.Thing, + cls.classes.Owner, + cls.tables.options, + cls.tables.categories) + mapper(Owner, owners) mapper(Category, categories) @@ -87,8 +95,12 @@ class EagerTest(_base.MappedTest): uselist=False))) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Owner, Category, Option, Thing = (cls.classes.Owner, + cls.classes.Category, + cls.classes.Option, + cls.classes.Thing) + session = create_session() o = Owner() @@ -100,8 +112,11 @@ class EagerTest(_base.MappedTest): session.flush() - @testing.resolve_artifact_names def test_noorm(self): + tests, options, categories = (self.tables.tests, + self.tables.options, + self.tables.categories) + """test the control case""" # I want to display a list of tests owned by owner 1 # if someoption is false or he hasn't specified it yet (null) @@ -126,8 +141,11 @@ class EagerTest(_base.MappedTest): ).execute().fetchall() eq_(result, [(1, u'Some Category'), (3, u'Some Category')]) - @testing.resolve_artifact_names def test_withoutjoinedload(self): + Thing, tests, options = (self.classes.Thing, + self.tables.tests, + self.tables.options) + s = create_session() l = (s.query(Thing). select_from(tests.outerjoin(options, @@ -141,8 +159,11 @@ class EagerTest(_base.MappedTest): result = ["%d %s" % ( t.id,t.category.name ) for t in l] eq_(result, [u'1 Some Category', u'3 Some Category']) - @testing.resolve_artifact_names def test_withjoinedload(self): + Thing, tests, options = (self.classes.Thing, + self.tables.tests, + self.tables.options) + """ Test that an joinedload locates the correct "from" clause with which to attach to, when presented with a query that already has a complicated @@ -164,8 +185,11 @@ class EagerTest(_base.MappedTest): result = ["%d %s" % ( t.id,t.category.name ) for t in l] eq_(result, [u'1 Some Category', u'3 Some Category']) - @testing.resolve_artifact_names def test_dslish(self): + Thing, tests, options = (self.classes.Thing, + self.tables.tests, + self.tables.options) + """test the same as withjoinedload except using generative""" s = create_session() q = s.query(Thing).options(sa.orm.joinedload('category')) @@ -179,8 +203,11 @@ class EagerTest(_base.MappedTest): eq_(result, [u'1 Some Category', u'3 Some Category']) @testing.crashes('sybase', 'FIXME: unknown, verify not fails_on') - @testing.resolve_artifact_names def test_without_outerjoin_literal(self): + Thing, tests, false = (self.classes.Thing, + self.tables.tests, + self.other.false) + s = create_session() q = s.query(Thing).options(sa.orm.joinedload('category')) l = (q.filter( @@ -191,8 +218,11 @@ class EagerTest(_base.MappedTest): result = ["%d %s" % ( t.id,t.category.name ) for t in l] eq_(result, [u'3 Some Category']) - @testing.resolve_artifact_names def test_withoutouterjoin(self): + Thing, tests, options = (self.classes.Thing, + self.tables.tests, + self.tables.options) + s = create_session() q = s.query(Thing).options(sa.orm.joinedload('category')) l = q.filter( @@ -234,8 +264,14 @@ class EagerTest2(_base.MappedTest): self.data = data @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Right, Middle, middle, right, left, Left = (cls.classes.Right, + cls.classes.Middle, + cls.tables.middle, + cls.tables.right, + cls.tables.left, + cls.classes.Left) + # set up bi-directional eager loads mapper(Left, left) mapper(Right, right) @@ -248,8 +284,11 @@ class EagerTest2(_base.MappedTest): backref=backref('middle', lazy='joined')))), @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_eager_terminate(self): + Middle, Right, Left = (self.classes.Middle, + self.classes.Right, + self.classes.Left) + """Eager query generation does not include the same mapper's table twice. Or, that bi-directional eager loads dont include each other in eager @@ -297,8 +336,14 @@ class EagerTest3(_base.MappedTest): pass @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_nesting_with_functions(self): + Stat, Foo, stats, foo, Data, datas = (self.classes.Stat, + self.classes.Foo, + self.tables.stats, + self.tables.foo, + self.classes.Data, + self.tables.datas) + mapper(Data, datas) mapper(Foo, foo, properties={ 'data': relationship(Data,backref=backref('foo',uselist=False))}) @@ -375,8 +420,12 @@ class EagerTest4(_base.MappedTest): pass @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_basic(self): + Department, Employee, employees, departments = (self.classes.Department, + self.classes.Employee, + self.tables.employees, + self.tables.departments) + mapper(Employee, employees) mapper(Department, departments, properties=dict( employees=relationship(Employee, @@ -451,8 +500,16 @@ class EagerTest5(_base.MappedTest): self.uid = uid self.comment = comment - @testing.resolve_artifact_names def test_basic(self): + Comment, Derived, derived, comments, DerivedII, Base, base, derivedII = (self.classes.Comment, + self.classes.Derived, + self.tables.derived, + self.tables.comments, + self.classes.DerivedII, + self.classes.Base, + self.tables.base, + self.tables.derivedII) + commentMapper = mapper(Comment, comments) baseMapper = mapper(Base, base, properties=dict( @@ -528,8 +585,16 @@ class EagerTest6(_base.MappedTest): class InheritedPart(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_one(self): + Part, inherited_part, design_types, DesignType, parts, design, Design, InheritedPart = (self.classes.Part, + self.tables.inherited_part, + self.tables.design_types, + self.classes.DesignType, + self.tables.parts, + self.tables.design, + self.classes.Design, + self.classes.InheritedPart) + p_m = mapper(Part, parts) mapper(InheritedPart, inherited_part, properties=dict( @@ -597,8 +662,14 @@ class EagerTest7(_base.MappedTest): class Invoice(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_load_m2o_attached_to_o2(self): + addresses, invoices, Company, companies, Invoice, Address = (self.tables.addresses, + self.tables.invoices, + self.classes.Company, + self.tables.companies, + self.classes.Invoice, + self.classes.Address) + """ Tests eager load of a many-to-one attached to a one-to-many. this testcase illustrated the bug, which is that when the single Company is @@ -676,7 +747,6 @@ class EagerTest8(_base.MappedTest): Column('display_name', sa.Unicode(20))) @classmethod - @testing.resolve_artifact_names def fixtures(cls): return dict( prj=(('id',), @@ -700,8 +770,14 @@ class EagerTest8(_base.MappedTest): pass @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_nested_joins(self): + task, Task_Type, Joined, prj, task_type, msg = (self.tables.task, + self.classes.Task_Type, + self.classes.Joined, + self.tables.prj, + self.tables.task_type, + self.tables.msg) + # this is testing some subtle column resolution stuff, # concerning corresponding_column() being extremely accurate # as well as how mapper sets up its column properties @@ -764,8 +840,14 @@ class EagerTest9(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Account, Transaction, transactions, accounts, entries, Entry = (cls.classes.Account, + cls.classes.Transaction, + cls.tables.transactions, + cls.tables.accounts, + cls.tables.entries, + cls.classes.Entry) + mapper(Account, accounts) mapper(Transaction, transactions) @@ -781,8 +863,11 @@ class EagerTest9(_base.MappedTest): order_by=entries.c.entry_id)))) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_joinedload_on_path(self): + Entry, Account, Transaction = (self.classes.Entry, + self.classes.Account, + self.classes.Transaction) + session = create_session() tx1 = Transaction(name='tx1') diff --git a/test/orm/test_backref_mutations.py b/test/orm/test_backref_mutations.py index d0aae128c4..9abc0df28e 100644 --- a/test/orm/test_backref_mutations.py +++ b/test/orm/test_backref_mutations.py @@ -23,15 +23,20 @@ class O2MCollectionTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Address, addresses, users, User = (cls.classes.Address, + cls.tables.addresses, + cls.tables.users, + cls.classes.User) + mapper(Address, addresses) mapper(User, users, properties = dict( addresses = relationship(Address, backref="user"), )) - @testing.resolve_artifact_names def test_collection_move_hitslazy(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") a2 = Address(email_address="address2") @@ -49,8 +54,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): u2.addresses.append(a3) self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_collection_move_preloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', addresses=[a1]) @@ -73,8 +79,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): assert a1 in u1.addresses assert a1 in u2.addresses - @testing.resolve_artifact_names def test_collection_move_notloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', addresses=[a1]) @@ -93,8 +100,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): assert a1 not in u1.addresses assert a1 in u2.addresses - @testing.resolve_artifact_names def test_collection_move_commitfirst(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', addresses=[a1]) @@ -117,8 +125,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): assert a1 not in u1.addresses assert a1 in u2.addresses - @testing.resolve_artifact_names def test_scalar_move_preloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() u1 = User(name='jack') @@ -141,8 +150,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): assert a1 not in u1.addresses assert a1 in u2.addresses - @testing.resolve_artifact_names def test_plain_load_passive(self): + User, Address = self.classes.User, self.classes.Address + """test that many-to-one set doesn't load the old value.""" sess = sessionmaker()() @@ -163,8 +173,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): assert a1 not in u1.addresses assert a1 in u2.addresses - @testing.resolve_artifact_names def test_set_none(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() u1 = User(name='jack') a1 = Address(email_address='a1') @@ -181,8 +192,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_scalar_move_notloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() u1 = User(name='jack') @@ -200,8 +212,9 @@ class O2MCollectionTest(_fixtures.FixtureTest): assert a1 not in u1.addresses assert a1 in u2.addresses - @testing.resolve_artifact_names def test_scalar_move_commitfirst(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() u1 = User(name='jack') @@ -227,15 +240,20 @@ class O2OScalarBackrefMoveTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Address, addresses, users, User = (cls.classes.Address, + cls.tables.addresses, + cls.tables.users, + cls.classes.User) + mapper(Address, addresses) mapper(User, users, properties = { 'address':relationship(Address, backref=backref("user"), uselist=False) }) - @testing.resolve_artifact_names def test_collection_move_preloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', address=a1) @@ -259,8 +277,9 @@ class O2OScalarBackrefMoveTest(_fixtures.FixtureTest): assert u1.address is a1 assert u2.address is a1 - @testing.resolve_artifact_names def test_scalar_move_preloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") a2 = Address(email_address="address1") @@ -282,8 +301,9 @@ class O2OScalarBackrefMoveTest(_fixtures.FixtureTest): assert a1.user is u1 assert a2.user is u1 - @testing.resolve_artifact_names def test_collection_move_notloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', address=a1) @@ -303,8 +323,9 @@ class O2OScalarBackrefMoveTest(_fixtures.FixtureTest): assert u1.address is None assert u2.address is a1 - @testing.resolve_artifact_names def test_scalar_move_notloaded(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") a2 = Address(email_address="address1") @@ -323,8 +344,9 @@ class O2OScalarBackrefMoveTest(_fixtures.FixtureTest): assert a1.user is u1 assert a2.user is u1 - @testing.resolve_artifact_names def test_collection_move_commitfirst(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', address=a1) @@ -349,8 +371,9 @@ class O2OScalarBackrefMoveTest(_fixtures.FixtureTest): assert u1.address is None assert u2.address is a1 - @testing.resolve_artifact_names def test_scalar_move_commitfirst(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") a2 = Address(email_address="address2") @@ -381,15 +404,20 @@ class O2OScalarMoveTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Address, addresses, users, User = (cls.classes.Address, + cls.tables.addresses, + cls.tables.users, + cls.classes.User) + mapper(Address, addresses) mapper(User, users, properties = { 'address':relationship(Address, uselist=False) }) - @testing.resolve_artifact_names def test_collection_move_commitfirst(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', address=a1) @@ -415,8 +443,12 @@ class O2OScalarOrphanTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Address, addresses, users, User = (cls.classes.Address, + cls.tables.addresses, + cls.tables.users, + cls.classes.User) + mapper(Address, addresses) mapper(User, users, properties = { 'address':relationship(Address, uselist=False, @@ -424,8 +456,9 @@ class O2OScalarOrphanTest(_fixtures.FixtureTest): cascade="all, delete-orphan")) }) - @testing.resolve_artifact_names def test_m2o_event(self): + User, Address = self.classes.User, self.classes.Address + sess = sessionmaker()() a1 = Address(email_address="address1") u1 = User(name='jack', address=a1) @@ -446,15 +479,21 @@ class M2MScalarMoveTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + keywords, items, item_keywords, Keyword, Item = (cls.tables.keywords, + cls.tables.items, + cls.tables.item_keywords, + cls.classes.Keyword, + cls.classes.Item) + mapper(Item, items, properties={ 'keyword':relationship(Keyword, secondary=item_keywords, uselist=False, backref=backref("item", uselist=False)) }) mapper(Keyword, keywords) - @testing.resolve_artifact_names def test_collection_move_preloaded(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + sess = sessionmaker()() k1 = Keyword(name='k1') @@ -475,8 +514,9 @@ class M2MScalarMoveTest(_fixtures.FixtureTest): assert i1.keyword is k1 assert i2.keyword is k1 - @testing.resolve_artifact_names def test_collection_move_notloaded(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + sess = sessionmaker()() k1 = Keyword(name='k1') @@ -493,8 +533,9 @@ class M2MScalarMoveTest(_fixtures.FixtureTest): assert i1.keyword is None assert i2.keyword is k1 - @testing.resolve_artifact_names def test_collection_move_commit(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + sess = sessionmaker()() k1 = Keyword(name='k1') diff --git a/test/orm/test_bind.py b/test/orm/test_bind.py index bab9be428a..d680de0a77 100644 --- a/test/orm/test_bind.py +++ b/test/orm/test_bind.py @@ -22,16 +22,18 @@ class BindTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + test_table, Foo = cls.tables.test_table, cls.classes.Foo + meta = MetaData() test_table.tometadata(meta) assert meta.tables['test_table'].bind is None mapper(Foo, meta.tables['test_table']) - @testing.resolve_artifact_names def test_session_bind(self): + Foo = self.classes.Foo + engine = self.metadata.bind for bind in (engine, engine.connect()): @@ -46,8 +48,9 @@ class BindTest(_base.MappedTest): if hasattr(bind, 'close'): bind.close() - @testing.resolve_artifact_names def test_session_unbound(self): + Foo = self.classes.Foo + sess = create_session() sess.add(Foo()) assert_raises_message( diff --git a/test/orm/test_cascade.py b/test/orm/test_cascade.py index ccc5120f85..4ba18a8756 100644 --- a/test/orm/test_cascade.py +++ b/test/orm/test_cascade.py @@ -48,8 +48,16 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, Dingaling, Order, User, dingalings, Address, orders, addresses = (cls.tables.users, + cls.classes.Dingaling, + cls.classes.Order, + cls.classes.User, + cls.tables.dingalings, + cls.classes.Address, + cls.tables.orders, + cls.tables.addresses) + mapper(Address, addresses) mapper(Order, orders) mapper(User, users, properties={ @@ -64,8 +72,9 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): 'address' : relationship(Address) }) - @testing.resolve_artifact_names def test_list_assignment_new(self): + User, Order = self.classes.User, self.classes.Order + sess = Session() u = User(name='jack', orders=[ Order(description='order 1'), @@ -77,8 +86,9 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): orders=[Order(description='order 1'), Order(description='order 2')])) - @testing.resolve_artifact_names def test_list_assignment_replace(self): + User, Order = self.classes.User, self.classes.Order + sess = Session() u = User(name='jack', orders=[ Order(description='someorder'), @@ -96,15 +106,17 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): eq_(sess.query(Order).order_by(Order.id).all(), [Order(description="order 3"), Order(description="order 4")]) - @testing.resolve_artifact_names def test_standalone_orphan(self): + Order = self.classes.Order + sess = Session() o5 = Order(description="order 5") sess.add(o5) assert_raises(sa_exc.DBAPIError, sess.flush) - @testing.resolve_artifact_names def test_save_update_sends_pending(self): + Order, User = self.classes.Order, self.classes.User + """test that newly added and deleted collection items are cascaded on save-update""" @@ -123,8 +135,9 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): assert o3 in sess sess.commit() - @testing.resolve_artifact_names def test_remove_pending_from_collection(self): + User, Order = self.classes.User, self.classes.Order + sess = Session() u = User(name='jack') @@ -138,8 +151,12 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): assert o1 not in sess - @testing.resolve_artifact_names def test_delete(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + sess = create_session() u = User(name='jack', orders=[Order(description='someorder'), @@ -152,8 +169,12 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): assert users.count().scalar() == 0 assert orders.count().scalar() == 0 - @testing.resolve_artifact_names def test_delete_unloaded_collections(self): + User, addresses, users, Address = (self.classes.User, + self.tables.addresses, + self.tables.users, + self.classes.Address) + """Unloaded collections are still included in a delete-cascade by default.""" sess = create_session() @@ -174,8 +195,12 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): assert addresses.count().scalar() == 0 assert users.count().scalar() == 0 - @testing.resolve_artifact_names def test_cascades_onlycollection(self): + User, Order, users, orders = (self.classes.User, + self.classes.Order, + self.tables.users, + self.tables.orders) + """Cascade only reaches instances that are still part of the collection, not those that have been removed""" @@ -203,8 +228,11 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): [User(name='newuser', orders=[Order(description='someorder')])]) - @testing.resolve_artifact_names def test_cascade_nosideeffects(self): + Dingaling, User, Address = (self.classes.Dingaling, + self.classes.User, + self.classes.Address) + """test that cascade leaves the state of unloaded scalars/collections unchanged.""" @@ -230,8 +258,12 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): sess.flush() assert d.address is a - @testing.resolve_artifact_names def test_cascade_delete_plusorphans(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + sess = create_session() u = User(name='jack', orders=[Order(description='someorder'), @@ -247,8 +279,12 @@ class O2MCascadeDeleteOrphanTest(_base.MappedTest): assert users.count().scalar() == 0 assert orders.count().scalar() == 0 - @testing.resolve_artifact_names def test_collection_orphans(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + sess = create_session() u = User(name='jack', orders=[Order(description='someorder'), @@ -289,15 +325,23 @@ class O2MCascadeDeleteNoOrphanTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + User, Order, orders, users = (cls.classes.User, + cls.classes.Order, + cls.tables.orders, + cls.tables.users) + mapper(User, users, properties = dict( orders = relationship( mapper(Order, orders), cascade="all") )) - @testing.resolve_artifact_names def test_cascade_delete_noorphans(self): + User, Order, orders, users = (self.classes.User, + self.classes.Order, + self.tables.orders, + self.tables.users) + sess = create_session() u = User(name='jack', orders=[Order(description='someorder'), @@ -317,15 +361,20 @@ class O2OSingleParentTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Address, addresses, users, User = (cls.classes.Address, + cls.tables.addresses, + cls.tables.users, + cls.classes.User) + mapper(Address, addresses) mapper(User, users, properties={'address' : relationship(Address, backref=backref('user', single_parent=True), uselist=False)}) - @testing.resolve_artifact_names def test_single_parent_raise(self): + User, Address = self.classes.User, self.classes.Address + a1 = Address(email_address='some address') u1 = User(name='u1', address=a1) assert_raises(sa_exc.InvalidRequestError, Address, @@ -340,7 +389,6 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def _one_to_many_fixture(self, o2m_cascade=True, m2o_cascade=True, o2m=False, @@ -348,6 +396,11 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): o2m_cascade_backrefs=True, m2o_cascade_backrefs=True): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + if o2m: if m2o: addresses_rel = {'addresses':relationship( @@ -380,7 +433,6 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): mapper(User, users, properties=addresses_rel) mapper(Address, addresses, properties=user_rel) - @testing.resolve_artifact_names def _many_to_many_fixture(self, fwd_cascade=True, bkd_cascade=True, fwd=False, @@ -388,6 +440,12 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): fwd_cascade_backrefs=True, bkd_cascade_backrefs=True): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + if fwd: if bkd: keywords_rel = {'keywords':relationship( @@ -423,8 +481,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): mapper(Item, items, properties=keywords_rel) mapper(Keyword, keywords, properties=items_rel) - @testing.resolve_artifact_names def test_o2m_only_child_pending(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=False) sess = Session() u1 = User(name='u1') @@ -435,8 +494,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): assert a1 in sess sess.flush() - @testing.resolve_artifact_names def test_o2m_only_child_transient(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=False, o2m_cascade=False) sess = Session() u1 = User(name='u1') @@ -449,8 +509,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_o2m_only_child_persistent(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=False, o2m_cascade=False) sess = Session() u1 = User(name='u1') @@ -468,8 +529,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_o2m_backref_child_pending(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True) sess = Session() u1 = User(name='u1') @@ -480,8 +542,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): assert a1 in sess sess.flush() - @testing.resolve_artifact_names def test_o2m_backref_child_transient(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False) sess = Session() @@ -495,8 +558,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_o2m_backref_child_transient_nochange(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False) sess = Session() @@ -512,8 +576,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): go() eq_(u1.addresses, []) - @testing.resolve_artifact_names def test_o2m_backref_child_expunged(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False) sess = Session() @@ -531,8 +596,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_o2m_backref_child_expunged_nochange(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False) sess = Session() @@ -552,8 +618,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): go() eq_(u1.addresses, []) - @testing.resolve_artifact_names def test_m2o_only_child_pending(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=False, m2o=True) sess = Session() u1 = User(name='u1') @@ -564,8 +631,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): assert a1 in sess sess.flush() - @testing.resolve_artifact_names def test_m2o_only_child_transient(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=False, m2o=True, m2o_cascade=False) sess = Session() u1 = User(name='u1') @@ -578,8 +646,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2o_only_child_expunged(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=False, m2o=True, m2o_cascade=False) sess = Session() u1 = User(name='u1') @@ -596,8 +665,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2o_backref_child_pending(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True) sess = Session() u1 = User(name='u1') @@ -608,8 +678,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): assert a1 in sess sess.flush() - @testing.resolve_artifact_names def test_m2o_backref_child_transient(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False) sess = Session() u1 = User(name='u1') @@ -622,8 +693,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2o_backref_child_expunged(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False) sess = Session() u1 = User(name='u1') @@ -640,8 +712,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2o_backref_child_pending_nochange(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False) sess = Session() u1 = User(name='u1') @@ -658,8 +731,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): # didn't get flushed assert a1.user is None - @testing.resolve_artifact_names def test_m2o_backref_child_expunged_nochange(self): + User, Address = self.classes.User, self.classes.Address + self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False) sess = Session() u1 = User(name='u1') @@ -679,8 +753,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): # didn't get flushed assert a1.user is None - @testing.resolve_artifact_names def test_m2m_only_child_pending(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=False) sess = Session() i1 = Item(description='i1') @@ -691,8 +766,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): assert k1 in sess sess.flush() - @testing.resolve_artifact_names def test_m2m_only_child_transient(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=False, fwd_cascade=False) sess = Session() i1 = Item(description='i1') @@ -705,8 +781,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2m_only_child_persistent(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=False, fwd_cascade=False) sess = Session() i1 = Item(description='i1') @@ -724,8 +801,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2m_backref_child_pending(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=True) sess = Session() i1 = Item(description='i1') @@ -736,8 +814,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): assert k1 in sess sess.flush() - @testing.resolve_artifact_names def test_m2m_backref_child_transient(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False) sess = Session() @@ -751,8 +830,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2m_backref_child_transient_nochange(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False) sess = Session() @@ -768,8 +848,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): go() eq_(i1.keywords, []) - @testing.resolve_artifact_names def test_m2m_backref_child_expunged(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False) sess = Session() @@ -787,8 +868,9 @@ class NoSaveCascadeFlushTest(_fixtures.FixtureTest): sa_exc.SAWarning, "not in session", sess.flush ) - @testing.resolve_artifact_names def test_m2m_backref_child_expunged_nochange(self): + Item, Keyword = self.classes.Item, self.classes.Keyword + self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False) sess = Session() @@ -812,8 +894,12 @@ class NoSaveCascadeBackrefTest(_fixtures.FixtureTest): """test that backrefs don't force save-update cascades to occur when the cascade initiated from the forwards side.""" - @testing.resolve_artifact_names def test_unidirectional_cascade_o2m(self): + User, Order, users, orders = (self.classes.User, + self.classes.Order, + self.tables.users, + self.tables.orders) + mapper(Order, orders) mapper(User, users, properties = dict( orders = relationship( @@ -836,8 +922,12 @@ class NoSaveCascadeBackrefTest(_fixtures.FixtureTest): assert u1 not in sess assert o1 in sess - @testing.resolve_artifact_names def test_unidirectional_cascade_m2o(self): + User, Order, users, orders = (self.classes.User, + self.classes.Order, + self.tables.users, + self.tables.orders) + mapper(Order, orders, properties={ 'user':relationship(User, backref=backref("orders", cascade=None)) }) @@ -861,8 +951,13 @@ class NoSaveCascadeBackrefTest(_fixtures.FixtureTest): assert o1 not in sess assert u1 in sess - @testing.resolve_artifact_names def test_unidirectional_cascade_m2m(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Item, items, properties={'keywords' : relationship(Keyword, secondary=item_keywords, cascade='none', backref='items')}) @@ -922,8 +1017,16 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + extra, foo, users, Extra, Pref, User, prefs, Foo = (cls.tables.extra, + cls.tables.foo, + cls.tables.users, + cls.classes.Extra, + cls.classes.Pref, + cls.classes.User, + cls.tables.prefs, + cls.classes.Foo) + mapper(Extra, extra) mapper(Pref, prefs, properties=dict(extra=relationship(Extra, cascade='all, delete'))) @@ -933,8 +1036,11 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): mapper(Foo, foo) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Pref, User, Extra = (cls.classes.Pref, + cls.classes.User, + cls.classes.Extra) + u1 = User(name='ed', pref=Pref(data="pref 1", extra=[Extra()])) u2 = User(name='jack', pref=Pref(data="pref 2", extra=[Extra()])) u3 = User(name="foo", pref=Pref(data="pref 3", extra=[Extra()])) @@ -944,8 +1050,11 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): sess.close() @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_orphan(self): + prefs, User, extra = (self.tables.prefs, + self.classes.User, + self.tables.extra) + sess = create_session() assert prefs.count().scalar() == 3 assert extra.count().scalar() == 3 @@ -955,8 +1064,9 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): assert prefs.count().scalar() == 2 assert extra.count().scalar() == 2 - @testing.resolve_artifact_names def test_cascade_on_deleted(self): + Foo, User = self.classes.Foo, self.classes.User + """test a bug introduced by r6711""" sess = sessionmaker(expire_on_commit=True)() @@ -980,8 +1090,9 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): assert u1 in sess sess.commit() - @testing.resolve_artifact_names def test_save_update_sends_pending(self): + Pref, User = self.classes.Pref, self.classes.User + """test that newly added and deleted scalar items are cascaded on save-update""" @@ -1002,8 +1113,11 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): sess.commit() @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_orphan_on_update(self): + prefs, User, extra = (self.tables.prefs, + self.classes.User, + self.tables.extra) + sess = create_session() jack = sess.query(User).filter_by(name="jack").one() p = jack.pref @@ -1020,8 +1134,9 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): assert prefs.count().scalar() == 2 assert extra.count().scalar() == 2 - @testing.resolve_artifact_names def test_pending_expunge(self): + Pref, User = self.classes.Pref, self.classes.User + sess = create_session() someuser = User(name='someuser') sess.add(someuser) @@ -1034,8 +1149,9 @@ class M2OCascadeDeleteOrphanTestOne(_base.MappedTest): eq_(sess.query(Pref).with_parent(someuser).all(), [Pref(data="someotherpref")]) - @testing.resolve_artifact_names def test_double_assignment(self): + Pref, User = self.classes.Pref, self.classes.User + """Double assignment will not accidentally reset the 'parent' flag.""" sess = create_session() @@ -1079,8 +1195,14 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + t2, T2, T3, t1, t3, T1 = (cls.tables.t2, + cls.classes.T2, + cls.classes.T3, + cls.tables.t1, + cls.tables.t3, + cls.classes.T1) + mapper(T1, t1, properties=dict(t2=relationship(T2, cascade='all, delete-orphan', single_parent=True))) mapper(T2, t2, properties=dict(t3=relationship(T3, @@ -1088,8 +1210,11 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): backref=backref('t2', uselist=False)))) mapper(T3, t3) - @testing.resolve_artifact_names def test_cascade_delete(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x = T1(data='t1a', t2=T2(data='t2a', t3=T3(data='t3a'))) sess.add(x) @@ -1101,8 +1226,11 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): eq_(sess.query(T2).all(), []) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_deletes_orphans_onelevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x2 = T1(data='t1b', t2=T2(data='t2b', t3=T3(data='t3b'))) sess.add(x2) @@ -1115,8 +1243,11 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): eq_(sess.query(T2).all(), []) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_deletes_orphans_twolevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x = T1(data='t1a', t2=T2(data='t2a', t3=T3(data='t3a'))) sess.add(x) @@ -1129,8 +1260,11 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): eq_(sess.query(T2).all(), []) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_finds_orphans_twolevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x = T1(data='t1a', t2=T2(data='t2a', t3=T3(data='t3a'))) sess.add(x) @@ -1142,8 +1276,9 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): eq_(sess.query(T2).all(), [T2()]) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_single_parent_raise(self): + T2, T1 = self.classes.T2, self.classes.T1 + sess = create_session() @@ -1151,8 +1286,9 @@ class M2OCascadeDeleteOrphanTestTwo(_base.MappedTest): x = T1(data='T1a', t2=y) assert_raises(sa_exc.InvalidRequestError, T1, data='T1b', t2=y) - @testing.resolve_artifact_names def test_single_parent_backref(self): + T2, T3 = self.classes.T2, self.classes.T3 + sess = create_session() @@ -1200,14 +1336,23 @@ class M2OCascadeDeleteNoOrphanTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + t2, T2, T3, t1, t3, T1 = (cls.tables.t2, + cls.classes.T2, + cls.classes.T3, + cls.tables.t1, + cls.tables.t3, + cls.classes.T1) + mapper(T1, t1, properties={'t2': relationship(T2, cascade="all")}) mapper(T2, t2, properties={'t3': relationship(T3, cascade="all")}) mapper(T3, t3) - @testing.resolve_artifact_names def test_cascade_delete(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x = T1(data='t1a', t2=T2(data='t2a', t3=T3(data='t3a'))) sess.add(x) @@ -1219,8 +1364,11 @@ class M2OCascadeDeleteNoOrphanTest(_base.MappedTest): eq_(sess.query(T2).all(), []) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_cascade_delete_postappend_onelevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x1 = T1(data='t1', ) x2 = T2(data='t2') @@ -1236,8 +1384,11 @@ class M2OCascadeDeleteNoOrphanTest(_base.MappedTest): eq_(sess.query(T2).all(), []) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_cascade_delete_postappend_twolevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x1 = T1(data='t1', t2=T2(data='t2')) x3 = T3(data='t3') @@ -1251,8 +1402,11 @@ class M2OCascadeDeleteNoOrphanTest(_base.MappedTest): eq_(sess.query(T2).all(), []) eq_(sess.query(T3).all(), []) - @testing.resolve_artifact_names def test_preserves_orphans_onelevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x2 = T1(data='t1b', t2=T2(data='t2b', t3=T3(data='t3b'))) sess.add(x2) @@ -1266,8 +1420,11 @@ class M2OCascadeDeleteNoOrphanTest(_base.MappedTest): eq_(sess.query(T3).all(), [T3()]) @testing.future - @testing.resolve_artifact_names def test_preserves_orphans_onelevel_postremove(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x2 = T1(data='t1b', t2=T2(data='t2b', t3=T3(data='t3b'))) sess.add(x2) @@ -1280,8 +1437,11 @@ class M2OCascadeDeleteNoOrphanTest(_base.MappedTest): eq_(sess.query(T2).all(), [T2()]) eq_(sess.query(T3).all(), [T3()]) - @testing.resolve_artifact_names def test_preserves_orphans_twolevel(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + sess = create_session() x = T1(data='t1a', t2=T2(data='t2a', t3=T3(data='t3a'))) sess.add(x) @@ -1336,8 +1496,13 @@ class M2MCascadeTest(_base.MappedTest): class C(_fixtures.Base): pass - @testing.resolve_artifact_names def test_delete_orphan(self): + a, A, B, b, atob = (self.tables.a, + self.classes.A, + self.classes.B, + self.tables.b, + self.tables.atob) + # if no backref here, delete-orphan failed until [ticket:427] # was fixed @@ -1358,8 +1523,13 @@ class M2MCascadeTest(_base.MappedTest): assert b.count().scalar() == 0 assert a.count().scalar() == 1 - @testing.resolve_artifact_names def test_delete_orphan_dynamic(self): + a, A, B, b, atob = (self.tables.a, + self.classes.A, + self.classes.B, + self.tables.b, + self.tables.atob) + mapper(A, a, properties={'bs': relationship(B, secondary=atob, cascade='all, delete-orphan', single_parent=True, lazy='dynamic')}) # if no backref here, delete-orphan @@ -1378,8 +1548,15 @@ class M2MCascadeTest(_base.MappedTest): assert b.count().scalar() == 0 assert a.count().scalar() == 1 - @testing.resolve_artifact_names def test_delete_orphan_cascades(self): + a, A, c, b, C, B, atob = (self.tables.a, + self.classes.A, + self.tables.c, + self.tables.b, + self.classes.C, + self.classes.B, + self.tables.atob) + mapper(A, a, properties={ # if no backref here, delete-orphan failed until [ticket:427] was # fixed @@ -1403,8 +1580,13 @@ class M2MCascadeTest(_base.MappedTest): assert a.count().scalar() == 1 assert c.count().scalar() == 0 - @testing.resolve_artifact_names def test_cascade_delete(self): + a, A, B, b, atob = (self.tables.a, + self.classes.A, + self.classes.B, + self.tables.b, + self.tables.atob) + mapper(A, a, properties={ 'bs':relationship(B, secondary=atob, cascade="all, delete-orphan", single_parent=True) @@ -1422,8 +1604,13 @@ class M2MCascadeTest(_base.MappedTest): assert b.count().scalar() == 0 assert a.count().scalar() == 0 - @testing.resolve_artifact_names def test_single_parent_raise(self): + a, A, B, b, atob = (self.tables.a, + self.classes.A, + self.classes.B, + self.tables.b, + self.tables.atob) + mapper(A, a, properties={ 'bs':relationship(B, secondary=atob, cascade="all, delete-orphan", single_parent=True) @@ -1438,8 +1625,13 @@ class M2MCascadeTest(_base.MappedTest): A, data='a2', bs=[b1] ) - @testing.resolve_artifact_names def test_single_parent_backref(self): + a, A, B, b, atob = (self.tables.a, + self.classes.A, + self.classes.B, + self.tables.b, + self.tables.atob) + """test that setting m2m via a uselist=False backref bypasses the single_parent raise""" mapper(A, a, properties={ @@ -1468,8 +1660,14 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + addresses, Dingaling, User, dingalings, Address, users = (cls.tables.addresses, + cls.classes.Dingaling, + cls.classes.User, + cls.tables.dingalings, + cls.classes.Address, + cls.tables.users) + mapper(Address, addresses) mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', @@ -1481,8 +1679,9 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): cascade_backrefs=False) }) - @testing.resolve_artifact_names def test_o2m_basic(self): + User, Address = self.classes.User, self.classes.Address + sess = Session() u1 = User(name='u1') @@ -1493,8 +1692,9 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): assert a1 not in sess - @testing.resolve_artifact_names def test_o2m_commit_warns(self): + User, Address = self.classes.User, self.classes.Address + sess = Session() u1 = User(name='u1') @@ -1512,8 +1712,9 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): assert a1 not in sess - @testing.resolve_artifact_names def test_o2m_flag_on_backref(self): + Dingaling, Address = self.classes.Dingaling, self.classes.Address + sess = Session() a1 = Address(email_address='a1') @@ -1526,8 +1727,9 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): sess.commit() - @testing.resolve_artifact_names def test_m2o_basic(self): + Dingaling, Address = self.classes.Dingaling, self.classes.Address + sess = Session() a1 = Address(email_address='a1') @@ -1537,8 +1739,9 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): a1.dingalings.append(d1) assert a1 not in sess - @testing.resolve_artifact_names def test_m2o_flag_on_backref(self): + User, Address = self.classes.User, self.classes.Address + sess = Session() a1 = Address(email_address='a1') @@ -1548,8 +1751,9 @@ class NoBackrefCascadeTest(_fixtures.FixtureTest): u1.addresses.append(a1) assert u1 in sess - @testing.resolve_artifact_names def test_m2o_commit_warns(self): + Dingaling, Address = self.classes.Dingaling, self.classes.Address + sess = Session() a1 = Address(email_address='a1') @@ -1593,8 +1797,14 @@ class PendingOrphanTestSingleLevel(_base.MappedTest): class Order(_fixtures.Base): pass - @testing.resolve_artifact_names def test_pending_standalone_orphan(self): + users, orders, User, Address, Order, addresses = (self.tables.users, + self.tables.orders, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """Standalone 'orphan' objects can now be persisted, if the underlying constraints of the database allow it. @@ -1635,8 +1845,12 @@ class PendingOrphanTestSingleLevel(_base.MappedTest): assert o in s and o not in s.new - @testing.resolve_artifact_names def test_pending_collection_expunge(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """Removing a pending item from a collection expunges it from the session.""" @@ -1663,8 +1877,12 @@ class PendingOrphanTestSingleLevel(_base.MappedTest): assert a.address_id is None, "Error: address should not be persistent" - @testing.resolve_artifact_names def test_nonorphans_ok(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties=dict( addresses=relationship(Address, cascade="all,delete", @@ -1711,8 +1929,12 @@ class PendingOrphanTestTwoLevel(_base.MappedTest): class Attribute(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_singlelevel_remove(self): + item, Order, order, Item = (self.tables.item, + self.classes.Order, + self.tables.order, + self.classes.Item) + mapper(Order, order, properties={ 'items':relationship(Item, cascade="all, delete-orphan") }) @@ -1727,8 +1949,14 @@ class PendingOrphanTestTwoLevel(_base.MappedTest): s.commit() assert i1 not in o1.items - @testing.resolve_artifact_names def test_multilevel_remove(self): + Item, Attribute, order, item, attribute, Order = (self.classes.Item, + self.classes.Attribute, + self.tables.order, + self.tables.item, + self.tables.attribute, + self.classes.Order) + mapper(Order, order, properties={ 'items':relationship(Item, cascade="all, delete-orphan") }) @@ -1789,8 +2017,11 @@ class DoubleParentO2MOrphanTest(_base.MappedTest): Column('account_id', Integer, ForeignKey('accounts.account_id'))) - @testing.resolve_artifact_names def test_double_parent_expunge_o2m(self): + sales_reps, customers, accounts = (self.tables.sales_reps, + self.tables.customers, + self.tables.accounts) + """test the delete-orphan uow event for multiple delete-orphan parent relationships.""" @@ -1830,8 +2061,11 @@ class DoubleParentO2MOrphanTest(_base.MappedTest): assert c not in s, \ 'Should expunge customer when both parents are gone' - @testing.resolve_artifact_names def test_double_parent_expunge_o2o(self): + sales_reps, customers, accounts = (self.tables.sales_reps, + self.tables.customers, + self.tables.accounts) + """test the delete-orphan uow event for multiple delete-orphan parent relationships.""" @@ -1902,8 +2136,11 @@ class DoubleParentM2OOrphanTest(_base.MappedTest): nullable=False), ) - @testing.resolve_artifact_names def test_non_orphan(self): + homes, businesses, addresses = (self.tables.homes, + self.tables.businesses, + self.tables.addresses) + """test that an entity can have two parent delete-orphan cascades, and persists normally.""" @@ -1936,8 +2173,11 @@ class DoubleParentM2OOrphanTest(_base.MappedTest): Business(description='business1', address=Address(street='address2'))) - @testing.resolve_artifact_names def test_orphan(self): + homes, businesses, addresses = (self.tables.homes, + self.tables.businesses, + self.tables.addresses) + """test that an entity can have two parent delete-orphan cascades, and is detected as an orphan when saved without a parent.""" @@ -1976,8 +2216,9 @@ class CollectionAssignmentOrphanTest(_base.MappedTest): Column('name', String(30)), Column('a_id', Integer, ForeignKey('table_a.id'))) - @testing.resolve_artifact_names def test_basic(self): + table_b, table_a = self.tables.table_b, self.tables.table_a + class A(_fixtures.Base): pass class B(_fixtures.Base): @@ -2036,8 +2277,9 @@ class O2MConflictTest(_base.MappedTest): class Child(_base.ComparableEntity): pass - @testing.resolve_artifact_names def _do_move_test(self, delete_old): + Parent, Child = self.classes.Parent, self.classes.Child + sess = create_session() p1, p2, c1 = Parent(), Parent(), Child() @@ -2060,8 +2302,12 @@ class O2MConflictTest(_base.MappedTest): sess.flush() eq_(sess.query(Child).filter(Child.parent_id==p2.id).all(), [c1]) - @testing.resolve_artifact_names def test_o2o_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'child':relationship(Child, uselist=False) }) @@ -2069,8 +2315,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2m_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'child':relationship(Child, uselist=True) }) @@ -2078,8 +2328,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2o_backref_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'child':relationship(Child, uselist=False, backref='parent') }) @@ -2087,8 +2341,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2o_delcascade_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'child':relationship(Child, uselist=False, cascade="all, delete") }) @@ -2096,8 +2354,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2o_delorphan_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'child':relationship(Child, uselist=False, cascade="all, delete, delete-orphan") @@ -2106,8 +2368,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2o_delorphan_backref_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'child':relationship(Child, uselist=False, cascade="all, delete, delete-orphan", @@ -2117,8 +2383,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2o_backref_delorphan_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent) mapper(Child, child, properties = { 'parent' : relationship(Parent, uselist=False, single_parent=True, @@ -2128,8 +2398,12 @@ class O2MConflictTest(_base.MappedTest): self._do_move_test(True) self._do_move_test(False) - @testing.resolve_artifact_names def test_o2m_backref_delorphan_delete_old(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent) mapper(Child, child, properties = { 'parent' : relationship(Parent, uselist=False, single_parent=True, @@ -2165,8 +2439,9 @@ class PartialFlushTest(_base.MappedTest): ) @testing.uses_deprecated() - @testing.resolve_artifact_names def test_o2m_m2o(self): + base, noninh_child = self.tables.base, self.tables.noninh_child + class Base(_base.ComparableEntity): pass class Child(_base.ComparableEntity): @@ -2215,8 +2490,11 @@ class PartialFlushTest(_base.MappedTest): assert b1 in sess and b1 in sess.new @testing.uses_deprecated() - @testing.resolve_artifact_names def test_circular_sort(self): + base, inh_child, parent = (self.tables.base, + self.tables.inh_child, + self.tables.parent) + """test ticket 1306""" class Base(_base.ComparableEntity): diff --git a/test/orm/test_collection.py b/test/orm/test_collection.py index 8e17b2f2bf..0e0c225ae2 100644 --- a/test/orm/test_collection.py +++ b/test/orm/test_collection.py @@ -1435,8 +1435,12 @@ class DictHelpersTest(_base.MappedTest): self.b = b self.c = c - @testing.resolve_artifact_names def _test_scalar_mapped(self, collection_class): + parents, children, Parent, Child = (self.tables.parents, + self.tables.children, + self.classes.Parent, + self.classes.Child) + mapper(Child, children) mapper(Parent, parents, properties={ 'children': relationship(Child, collection_class=collection_class, @@ -1494,8 +1498,12 @@ class DictHelpersTest(_base.MappedTest): self.assert_(len(list(collections.collection_adapter(p.children))) == 0) - @testing.resolve_artifact_names def _test_composite_mapped(self, collection_class): + parents, children, Parent, Child = (self.tables.parents, + self.tables.children, + self.classes.Parent, + self.classes.Child) + mapper(Child, children) mapper(Parent, parents, properties={ 'children': relationship(Child, collection_class=collection_class, @@ -1563,7 +1571,6 @@ class DictHelpersTest(_base.MappedTest): eq_(Bar.foos.property.collection_class().keyfunc(Foo(id=3)), 3) eq_(Bar.foos2.property.collection_class().keyfunc(Foo(id=3, bar_id=12)), (3, 12)) - @testing.resolve_artifact_names def test_column_mapped_assertions(self): assert_raises_message(sa_exc.ArgumentError, "Column-based expression object expected " @@ -1576,14 +1583,16 @@ class DictHelpersTest(_base.MappedTest): text('a')) - @testing.resolve_artifact_names def test_column_mapped_collection(self): + children = self.tables.children + collection_class = collections.column_mapped_collection( children.c.a) self._test_scalar_mapped(collection_class) - @testing.resolve_artifact_names def test_column_mapped_collection2(self): + children = self.tables.children + collection_class = collections.column_mapped_collection( (children.c.a, children.c.b)) self._test_composite_mapped(collection_class) @@ -1618,8 +1627,9 @@ class CustomCollectionsTest(_base.MappedTest): ForeignKey('sometable.col1')), Column('data', String(20))) - @testing.resolve_artifact_names def test_basic(self): + someothertable, sometable = self.tables.someothertable, self.tables.sometable + class MyList(list): pass class Foo(object): @@ -1634,8 +1644,9 @@ class CustomCollectionsTest(_base.MappedTest): f = Foo() assert isinstance(f.bars, MyList) - @testing.resolve_artifact_names def test_lazyload(self): + someothertable, sometable = self.tables.someothertable, self.tables.sometable + """test that a 'set' can be used as a collection and can lazyload.""" class Foo(object): pass @@ -1656,8 +1667,9 @@ class CustomCollectionsTest(_base.MappedTest): assert len(list(f.bars)) == 2 f.bars.clear() - @testing.resolve_artifact_names def test_dict(self): + someothertable, sometable = self.tables.someothertable, self.tables.sometable + """test that a 'dict' can be used as a collection and can lazyload.""" class Foo(object): @@ -1688,8 +1700,9 @@ class CustomCollectionsTest(_base.MappedTest): assert len(list(f.bars)) == 2 f.bars.clear() - @testing.resolve_artifact_names def test_dict_wrapper(self): + someothertable, sometable = self.tables.someothertable, self.tables.sometable + """test that the supplied 'dict' wrapper can be used as a collection and can lazyload.""" class Foo(object): @@ -1763,8 +1776,9 @@ class CustomCollectionsTest(_base.MappedTest): self._test_list(ListLike) - @testing.resolve_artifact_names def _test_list(self, listcls): + someothertable, sometable = self.tables.someothertable, self.tables.sometable + class Parent(object): pass class Child(object): @@ -1885,8 +1899,9 @@ class CustomCollectionsTest(_base.MappedTest): assert control == p.children assert control == list(p.children) - @testing.resolve_artifact_names def test_custom(self): + someothertable, sometable = self.tables.someothertable, self.tables.sometable + class Parent(object): pass class Child(object): diff --git a/test/orm/test_composites.py b/test/orm/test_composites.py index ad52820f69..d3f7f030f5 100644 --- a/test/orm/test_composites.py +++ b/test/orm/test_composites.py @@ -35,8 +35,9 @@ class PointTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + graphs, edges = cls.tables.graphs, cls.tables.edges + class Point(_base.BasicEntity): def __init__(self, x, y): self.x = x @@ -67,8 +68,11 @@ class PointTest(_base.MappedTest): 'end': sa.orm.composite(Point, edges.c.x2, edges.c.y2) }) - @testing.resolve_artifact_names def _fixture(self): + Graph, Edge, Point = (self.classes.Graph, + self.classes.Edge, + self.classes.Point) + sess = Session() g = Graph(id=1, edges=[ Edge(Point(3, 4), Point(5, 6)), @@ -78,8 +82,9 @@ class PointTest(_base.MappedTest): sess.commit() return sess - @testing.resolve_artifact_names def test_round_trip(self): + Graph, Point = self.classes.Graph, self.classes.Point + sess = self._fixture() @@ -95,8 +100,11 @@ class PointTest(_base.MappedTest): ] ) - @testing.resolve_artifact_names def test_detect_change(self): + Graph, Edge, Point = (self.classes.Graph, + self.classes.Edge, + self.classes.Point) + sess = self._fixture() g = sess.query(Graph).first() @@ -106,8 +114,9 @@ class PointTest(_base.MappedTest): e = sess.query(Edge).get(g.edges[1].id) eq_(e.end, Point(18, 4)) - @testing.resolve_artifact_names def test_eager_load(self): + Graph, Point = self.classes.Graph, self.classes.Point + sess = self._fixture() g = sess.query(Graph).first() @@ -127,8 +136,11 @@ class PointTest(_base.MappedTest): ) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_comparator(self): + Graph, Edge, Point = (self.classes.Graph, + self.classes.Edge, + self.classes.Point) + sess = self._fixture() g = sess.query(Graph).first() @@ -146,8 +158,9 @@ class PointTest(_base.MappedTest): [] ) - @testing.resolve_artifact_names def test_query_cols(self): + Edge = self.classes.Edge + sess = self._fixture() eq_( @@ -155,8 +168,9 @@ class PointTest(_base.MappedTest): [(3, 4, 5, 6), (14, 5, 2, 7)] ) - @testing.resolve_artifact_names def test_delete(self): + Graph, Edge = self.classes.Graph, self.classes.Edge + sess = self._fixture() g = sess.query(Graph).first() @@ -168,8 +182,9 @@ class PointTest(_base.MappedTest): [(3, 4, 5, 6), (14, 5, None, None)] ) - @testing.resolve_artifact_names def test_save_null(self): + Graph, Edge = self.classes.Graph, self.classes.Edge + """test saving a null composite value See google groups thread for more context: @@ -188,8 +203,9 @@ class PointTest(_base.MappedTest): assert g2.edges[-1].start.x is None assert g2.edges[-1].start.y is None - @testing.resolve_artifact_names def test_expire(self): + Graph, Point = self.classes.Graph, self.classes.Point + sess = self._fixture() g = sess.query(Graph).first() e = g.edges[0] @@ -197,8 +213,9 @@ class PointTest(_base.MappedTest): assert 'start' not in e.__dict__ assert e.start == Point(3, 4) - @testing.resolve_artifact_names def test_default_value(self): + Edge = self.classes.Edge + e = Edge() eq_(e.start, None) @@ -213,8 +230,9 @@ class PrimaryKeyTest(_base.MappedTest): Column('name', String(30))) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + graphs = cls.tables.graphs + class Version(_base.BasicEntity): def __init__(self, id, version): self.id = id @@ -238,16 +256,18 @@ class PrimaryKeyTest(_base.MappedTest): graphs.c.version_id)}) - @testing.resolve_artifact_names def _fixture(self): + Graph, Version = self.classes.Graph, self.classes.Version + sess = Session() g = Graph(Version(1, 1)) sess.add(g) sess.commit() return sess - @testing.resolve_artifact_names def test_get_by_col(self): + Graph = self.classes.Graph + sess = self._fixture() g = sess.query(Graph).first() @@ -255,8 +275,9 @@ class PrimaryKeyTest(_base.MappedTest): g2 = sess.query(Graph).get([g.id, g.version_id]) eq_(g.version, g2.version) - @testing.resolve_artifact_names def test_get_by_composite(self): + Graph, Version = self.classes.Graph, self.classes.Version + sess = self._fixture() g = sess.query(Graph).first() @@ -264,8 +285,9 @@ class PrimaryKeyTest(_base.MappedTest): eq_(g.version, g2.version) @testing.fails_on('mssql', 'Cannot update identity columns.') - @testing.resolve_artifact_names def test_pk_mutation(self): + Graph, Version = self.classes.Graph, self.classes.Version + sess = self._fixture() g = sess.query(Graph).first() @@ -276,8 +298,9 @@ class PrimaryKeyTest(_base.MappedTest): eq_(g.version, g2.version) @testing.fails_on_everything_except("sqlite") - @testing.resolve_artifact_names def test_null_pk(self): + Graph, Version = self.classes.Graph, self.classes.Version + sess = Session() # test pk with one column NULL @@ -302,8 +325,9 @@ class DefaultsTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + foobars = cls.tables.foobars + class Foobar(_base.BasicEntity): pass @@ -332,8 +356,9 @@ class DefaultsTest(_base.MappedTest): foobars.c.x4) )) - @testing.resolve_artifact_names def test_attributes_with_defaults(self): + Foobar, FBComposite = self.classes.Foobar, self.classes.FBComposite + sess = Session() f1 = Foobar() @@ -348,8 +373,9 @@ class DefaultsTest(_base.MappedTest): sess.flush() assert f2.foob == FBComposite(2, None, 15, None) - @testing.resolve_artifact_names def test_set_composite_values(self): + Foobar, FBComposite = self.classes.Foobar, self.classes.FBComposite + sess = Session() f1 = Foobar() f1.foob = FBComposite(None, 5, None, None) @@ -379,8 +405,9 @@ class MappedSelectTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + values, descriptions = cls.tables.values, cls.tables.descriptions + class Descriptions(_base.BasicEntity): pass @@ -415,8 +442,13 @@ class MappedSelectTest(_base.MappedTest): }) - @testing.resolve_artifact_names def test_set_composite_attrs_via_selectable(self): + Values, CustomValues, values, Descriptions, descriptions = (self.classes.Values, + self.classes.CustomValues, + self.tables.values, + self.classes.Descriptions, + self.tables.descriptions) + session = Session() d = Descriptions( custom_descriptions = CustomValues('Color', 'Number'), @@ -455,8 +487,9 @@ class ManyToOneTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + a, b = cls.tables.a, cls.tables.b + class A(_base.ComparableEntity): pass class B(_base.ComparableEntity): @@ -481,8 +514,11 @@ class ManyToOneTest(_base.MappedTest): }) mapper(B, b) - @testing.resolve_artifact_names def test_persist(self): + A, C, B = (self.classes.A, + self.classes.C, + self.classes.B) + sess = Session() sess.add(A(c=C('b1', B(data='b2')))) sess.commit() @@ -490,8 +526,11 @@ class ManyToOneTest(_base.MappedTest): a1 = sess.query(A).one() eq_(a1.c, C('b1', B(data='b2'))) - @testing.resolve_artifact_names def test_query(self): + A, C, B = (self.classes.A, + self.classes.C, + self.classes.B) + sess = Session() b1, b2 = B(data='b1'), B(data='b2') a1 = A(c=C('a1b1', b1)) @@ -517,7 +556,6 @@ class ConfigurationTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): class Point(_base.BasicEntity): def __init__(self, x, y): @@ -536,8 +574,9 @@ class ConfigurationTest(_base.MappedTest): class Edge(_base.ComparableEntity): pass - @testing.resolve_artifact_names def _test_roundtrip(self): + Edge, Point = self.classes.Edge, self.classes.Point + e1 = Edge(start=Point(3, 4), end=Point(5, 6)) sess = Session() sess.add(e1) @@ -548,8 +587,11 @@ class ConfigurationTest(_base.MappedTest): Edge(start=Point(3, 4), end=Point(5, 6)) ) - @testing.resolve_artifact_names def test_columns(self): + edge, Edge, Point = (self.tables.edge, + self.classes.Edge, + self.classes.Point) + mapper(Edge, edge, properties={ 'start':sa.orm.composite(Point, edge.c.x1, edge.c.y1), 'end': sa.orm.composite(Point, edge.c.x2, edge.c.y2) @@ -557,16 +599,22 @@ class ConfigurationTest(_base.MappedTest): self._test_roundtrip() - @testing.resolve_artifact_names def test_attributes(self): + edge, Edge, Point = (self.tables.edge, + self.classes.Edge, + self.classes.Point) + m = mapper(Edge, edge) m.add_property('start', sa.orm.composite(Point, Edge.x1, Edge.y1)) m.add_property('end', sa.orm.composite(Point, Edge.x2, Edge.y2)) self._test_roundtrip() - @testing.resolve_artifact_names def test_strings(self): + edge, Edge, Point = (self.tables.edge, + self.classes.Edge, + self.classes.Point) + m = mapper(Edge, edge) m.add_property('start', sa.orm.composite(Point, 'x1', 'y1')) m.add_property('end', sa.orm.composite(Point, 'x2', 'y2')) diff --git a/test/orm/test_cycles.py b/test/orm/test_cycles.py index 6aa1eaa1a9..4c2a359500 100644 --- a/test/orm/test_cycles.py +++ b/test/orm/test_cycles.py @@ -41,8 +41,9 @@ class SelfReferentialTest(_base.MappedTest): def __init__(self, data=None): self.data = data - @testing.resolve_artifact_names def test_single(self): + C1, t1 = self.classes.C1, self.tables.t1 + mapper(C1, t1, properties = { 'c1s':relationship(C1, cascade="all"), 'parent':relationship(C1, @@ -59,8 +60,9 @@ class SelfReferentialTest(_base.MappedTest): sess.delete(a) sess.flush() - @testing.resolve_artifact_names def test_many_to_one_only(self): + C1, t1 = self.classes.C1, self.tables.t1 + """ test that the circular dependency sort can assemble a many-to-one @@ -86,8 +88,12 @@ class SelfReferentialTest(_base.MappedTest): sess.flush() assert c2.parent_c1==c1.c1 - @testing.resolve_artifact_names def test_cycle(self): + C2, C1, t2, t1 = (self.classes.C2, + self.classes.C1, + self.tables.t2, + self.tables.t1) + mapper(C1, t1, properties = { 'c1s' : relationship(C1, cascade="all"), 'c2s' : relationship(mapper(C2, t2), cascade="all, delete-orphan")}) @@ -106,8 +112,9 @@ class SelfReferentialTest(_base.MappedTest): sess.delete(a) sess.flush() - @testing.resolve_artifact_names def test_setnull_ondelete(self): + C1, t1 = self.classes.C1, self.tables.t1 + mapper(C1, t1, properties={ 'children':relationship(C1) }) @@ -145,16 +152,18 @@ class SelfReferentialNoPKTest(_base.MappedTest): self.uuid = hex(id(self)) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + item, TT = cls.tables.item, cls.classes.TT + mapper(TT, item, properties={ 'children': relationship( TT, remote_side=[item.c.parent_uuid], backref=backref('parent', remote_side=[item.c.uuid]))}) - @testing.resolve_artifact_names def test_basic(self): + TT = self.classes.TT + t1 = TT() t1.children.append(TT()) t1.children.append(TT()) @@ -166,8 +175,9 @@ class SelfReferentialNoPKTest(_base.MappedTest): t = s.query(TT).filter_by(id=t1.id).one() eq_(t.children[0].parent_uuid, t1.uuid) - @testing.resolve_artifact_names def test_lazy_clause(self): + TT = self.classes.TT + s = create_session() t1 = TT() t2 = TT() @@ -211,16 +221,23 @@ class InheritTestOne(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + child1, child2, parent, Parent, Child1, Child2 = (cls.tables.child1, + cls.tables.child2, + cls.tables.parent, + cls.classes.Parent, + cls.classes.Child1, + cls.classes.Child2) + mapper(Parent, parent) mapper(Child1, child1, inherits=Parent) mapper(Child2, child2, inherits=Parent, properties=dict( child1=relationship(Child1, primaryjoin=child2.c.child1_id == child1.c.id))) - @testing.resolve_artifact_names def test_many_to_one_only(self): + Child1, Child2 = self.classes.Child1, self.classes.Child2 + """test similar to SelfReferentialTest.testmanytooneonly""" session = create_session() @@ -280,8 +297,14 @@ class InheritTestTwo(_base.MappedTest): class C(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_flush(self): + a, A, c, b, C, B = (self.tables.a, + self.classes.A, + self.tables.c, + self.tables.b, + self.classes.C, + self.classes.B) + mapper(A, a, properties={ 'cs':relationship(C, primaryjoin=a.c.cid==c.c.id)}) @@ -328,8 +351,14 @@ class BiDirectionalManyToOneTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + t2, T2, T3, t1, t3, T1 = (cls.tables.t2, + cls.classes.T2, + cls.classes.T3, + cls.tables.t1, + cls.tables.t3, + cls.classes.T1) + mapper(T1, t1, properties={ 't2':relationship(T2, primaryjoin=t1.c.t2id == t2.c.id)}) mapper(T2, t2, properties={ @@ -338,8 +367,11 @@ class BiDirectionalManyToOneTest(_base.MappedTest): 't1':relationship(T1), 't2':relationship(T2)}) - @testing.resolve_artifact_names def test_reflush(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + o1 = T1() o1.t2 = T2() sess = create_session() @@ -357,8 +389,11 @@ class BiDirectionalManyToOneTest(_base.MappedTest): sess.add(o3) sess.flush() - @testing.resolve_artifact_names def test_reflush_2(self): + T2, T3, T1 = (self.classes.T2, + self.classes.T3, + self.classes.T1) + """A variant on test_reflush()""" o1 = T1() o1.t2 = T2() @@ -410,8 +445,12 @@ class BiDirectionalOneToManyTest(_base.MappedTest): class C2(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_cycle(self): + C2, C1, t2, t1 = (self.classes.C2, + self.classes.C1, + self.tables.t2, + self.tables.t1) + mapper(C2, t2, properties={ 'c1s': relationship(C1, primaryjoin=t2.c.c1 == t1.c.c2, @@ -472,8 +511,14 @@ class BiDirectionalOneToManyTest2(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + t2, t1, C1Data, t1_data, C2, C1 = (cls.tables.t2, + cls.tables.t1, + cls.classes.C1Data, + cls.tables.t1_data, + cls.classes.C2, + cls.classes.C1) + mapper(C2, t2, properties={ 'c1s': relationship(C1, primaryjoin=t2.c.c1 == t1.c.c2, @@ -484,8 +529,11 @@ class BiDirectionalOneToManyTest2(_base.MappedTest): uselist=True), 'data': relationship(mapper(C1Data, t1_data))}) - @testing.resolve_artifact_names def test_cycle(self): + C2, C1, C1Data = (self.classes.C2, + self.classes.C1, + self.classes.C1Data) + a = C1() b = C2() c = C1() @@ -539,8 +587,12 @@ class OneToManyManyToOneTest(_base.MappedTest): class Ball(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_cycle(self): + person, ball, Ball, Person = (self.tables.person, + self.tables.ball, + self.classes.Ball, + self.classes.Person) + """ This test has a peculiar aspect in that it doesnt create as many dependent relationships as the other tests, and revealed a small @@ -563,8 +615,12 @@ class OneToManyManyToOneTest(_base.MappedTest): sess.add(p) sess.flush() - @testing.resolve_artifact_names def test_post_update_m2o(self): + person, ball, Ball, Person = (self.tables.person, + self.tables.ball, + self.classes.Ball, + self.classes.Person) + """A cycle between two rows, with a post_update on the many-to-one""" mapper(Ball, ball) mapper(Person, person, properties=dict( @@ -615,8 +671,12 @@ class OneToManyManyToOneTest(_base.MappedTest): ExactSQL("DELETE FROM person WHERE person.id = :id", lambda ctx:[{'id': p.id}]) ) - @testing.resolve_artifact_names def test_post_update_backref(self): + person, ball, Ball, Person = (self.tables.person, + self.tables.ball, + self.classes.Ball, + self.classes.Person) + """test bidirectional post_update.""" mapper(Ball, ball) @@ -661,8 +721,12 @@ class OneToManyManyToOneTest(_base.MappedTest): - @testing.resolve_artifact_names def test_post_update_o2m(self): + person, ball, Ball, Person = (self.tables.person, + self.tables.ball, + self.classes.Ball, + self.classes.Person) + """A cycle between two rows, with a post_update on the one-to-many""" mapper(Ball, ball) @@ -773,8 +837,9 @@ class SelfReferentialPostUpdateTest(_base.MappedTest): def __init__(self, path=''): self.path = path - @testing.resolve_artifact_names def test_one(self): + node, Node = self.tables.node, self.classes.Node + """Post_update only fires off when needed. This test case used to produce many superfluous update statements, @@ -910,8 +975,9 @@ class SelfReferentialPostUpdateTest2(_base.MappedTest): class A(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_one(self): + A, a_table = self.classes.A, self.tables.a_table + """ Test that post_update remembers to be involved in update operations as well, since it replaces the normal dependency processing completely @@ -972,8 +1038,12 @@ class SelfReferentialPostUpdateTest3(_base.MappedTest): def __init__(self, name=''): self.name = name - @testing.resolve_artifact_names def test_one(self): + Child, Parent, parent, child = (self.classes.Child, + self.classes.Parent, + self.tables.parent, + self.tables.child) + mapper(Parent, parent, properties={ 'children':relationship(Child, primaryjoin=parent.c.id==child.c.parent_id), 'child':relationship(Child, primaryjoin=parent.c.child_id==child.c.id, post_update=True) @@ -1060,8 +1130,16 @@ class PostUpdateBatchingTest(_base.MappedTest): def __init__(self, name=''): self.name = name - @testing.resolve_artifact_names def test_one(self): + child1, child2, child3, Parent, parent, Child1, Child2, Child3 = (self.tables.child1, + self.tables.child2, + self.tables.child3, + self.classes.Parent, + self.tables.parent, + self.classes.Child1, + self.classes.Child2, + self.classes.Child3) + mapper(Parent, parent, properties={ 'c1s':relationship(Child1, primaryjoin=child1.c.parent_id==parent.c.id), 'c2s':relationship(Child2, primaryjoin=child2.c.parent_id==parent.c.id), diff --git a/test/orm/test_defaults.py b/test/orm/test_defaults.py index 004a401c75..ddb9cea1ac 100644 --- a/test/orm/test_defaults.py +++ b/test/orm/test_defaults.py @@ -82,12 +82,14 @@ class TriggerDefaultsTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Default, dt = cls.classes.Default, cls.tables.dt + mapper(Default, dt) - @testing.resolve_artifact_names def test_insert(self): + Default = self.classes.Default + d1 = Default(id=1) @@ -106,8 +108,9 @@ class TriggerDefaultsTest(_base.MappedTest): # don't care which trigger fired assert d1.col4 in ('ins', 'up') - @testing.resolve_artifact_names def test_update(self): + Default = self.classes.Default + d1 = Default(id=1) session = create_session() @@ -129,8 +132,9 @@ class ExcludedDefaultsTest(_base.MappedTest): Column('col1', String(20), default="hello"), ) - @testing.resolve_artifact_names def test_exclude(self): + dt = self.tables.dt + class Foo(_base.ComparableEntity): pass mapper(Foo, dt, exclude_properties=('col1',)) diff --git a/test/orm/test_deprecations.py b/test/orm/test_deprecations.py index 400532cb28..f454435b4d 100644 --- a/test/orm/test_deprecations.py +++ b/test/orm/test_deprecations.py @@ -67,8 +67,12 @@ class QueryAlternativesTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + addresses_table, User, users_table, Address = (cls.tables.addresses_table, + cls.classes.User, + cls.tables.users_table, + cls.classes.Address) + mapper(User, users_table, properties=dict( addresses=relationship(Address, backref='user'), )) @@ -94,8 +98,9 @@ class QueryAlternativesTest(_base.MappedTest): ###################################################################### - @testing.resolve_artifact_names def test_override_get(self): + Address = self.classes.Address + """MapperExtension.get() x = session.query.get(5) @@ -117,8 +122,9 @@ class QueryAlternativesTest(_base.MappedTest): ad1 = session.query(Address).get(1) assert ad1 in cache.values() - @testing.resolve_artifact_names def test_load(self): + Address = self.classes.Address + """x = session.query(Address).load(1) x = session.load(Address, 1) @@ -130,8 +136,9 @@ class QueryAlternativesTest(_base.MappedTest): assert bool(ad1) - @testing.resolve_artifact_names def test_apply_max(self): + Address = self.classes.Address + """Query.apply_max(col) max = session.query(Address).apply_max(Address.bounces) @@ -147,8 +154,9 @@ class QueryAlternativesTest(_base.MappedTest): max = session.query(func.max(Address.bounces)).one()[0] assert max == 10 - @testing.resolve_artifact_names def test_apply_min(self): + Address = self.classes.Address + """Query.apply_min(col) min = session.query(Address).apply_min(Address.bounces) @@ -164,8 +172,9 @@ class QueryAlternativesTest(_base.MappedTest): min = session.query(func.min(Address.bounces)).one()[0] assert min == 0 - @testing.resolve_artifact_names def test_apply_avg(self): + Address = self.classes.Address + """Query.apply_avg(col) avg = session.query(Address).apply_avg(Address.bounces) @@ -180,8 +189,9 @@ class QueryAlternativesTest(_base.MappedTest): avg = session.query(func.avg(Address.bounces)).one()[0] assert avg > 0 and avg < 10 - @testing.resolve_artifact_names def test_apply_sum(self): + Address = self.classes.Address + """Query.apply_sum(col) avg = session.query(Address).apply_avg(Address.bounces) @@ -196,8 +206,9 @@ class QueryAlternativesTest(_base.MappedTest): avg = session.query(func.sum(Address.bounces)).one()[0] assert avg == 11 - @testing.resolve_artifact_names def test_count_by(self): + User, Address = self.classes.User, self.classes.Address + """Query.count_by(*args, **params) num = session.query(Address).count_by(purpose='Personal') @@ -215,8 +226,9 @@ class QueryAlternativesTest(_base.MappedTest): filter(Address.purpose=='Personal')).count() assert num == 3, num - @testing.resolve_artifact_names def test_count_whereclause(self): + Address = self.classes.Address + """Query.count(whereclause=None, params=None, **kwargs) num = session.query(Address).count(address_table.c.bounces > 1) @@ -227,8 +239,9 @@ class QueryAlternativesTest(_base.MappedTest): num = session.query(Address).filter(Address.bounces > 1).count() assert num == 1, num - @testing.resolve_artifact_names def test_execute(self): + User, users_table = self.classes.User, self.tables.users_table + """Query.execute(clauseelement, params=None, *args, **kwargs) users = session.query(User).execute(users_table.select()) @@ -239,8 +252,9 @@ class QueryAlternativesTest(_base.MappedTest): users = session.query(User).from_statement(users_table.select()).all() assert len(users) == 4 - @testing.resolve_artifact_names def test_get_by(self): + User, Address = self.classes.User, self.classes.Address + """Query.get_by(*args, **params) user = session.query(User).get_by(name='ed') @@ -262,8 +276,12 @@ class QueryAlternativesTest(_base.MappedTest): User.addresses.any(Address.email_address=='fred@the.fred')).first() assert user.name == 'fred' - @testing.resolve_artifact_names def test_instances_entities(self): + addresses_table, User, users_table, Address = (self.tables.addresses_table, + self.classes.User, + self.tables.users_table, + self.classes.Address) + """Query.instances(cursor, *mappers_or_columns, **kwargs) sel = users_table.join(addresses_table).select(use_labels=True) @@ -279,7 +297,6 @@ class QueryAlternativesTest(_base.MappedTest): cola, colb = res[0] assert isinstance(cola, User) and isinstance(colb, Address) - @testing.resolve_artifact_names def test_join_by(self): """Query.join_by(*args, **params) @@ -288,7 +305,6 @@ class QueryAlternativesTest(_base.MappedTest): session = create_session() - @testing.resolve_artifact_names def test_join_to(self): """Query.join_to(key) @@ -297,7 +313,6 @@ class QueryAlternativesTest(_base.MappedTest): session = create_session() - @testing.resolve_artifact_names def test_join_via(self): """Query.join_via(keys) @@ -306,8 +321,9 @@ class QueryAlternativesTest(_base.MappedTest): session = create_session() - @testing.resolve_artifact_names def test_list(self): + User = self.classes.User + """Query.list() users = session.query(User).list() @@ -318,8 +334,9 @@ class QueryAlternativesTest(_base.MappedTest): users = session.query(User).all() assert len(users) == 4 - @testing.resolve_artifact_names def test_scalar(self): + User = self.classes.User + """Query.scalar() user = session.query(User).filter(User.id==1).scalar() @@ -330,8 +347,9 @@ class QueryAlternativesTest(_base.MappedTest): user = session.query(User).filter(User.id==1).first() assert user.id==1 - @testing.resolve_artifact_names def test_select(self): + User = self.classes.User + """Query.select(arg=None, **kwargs) users = session.query(User).select(users_table.c.name != None) @@ -342,8 +360,9 @@ class QueryAlternativesTest(_base.MappedTest): users = session.query(User).filter(User.name != None).all() assert len(users) == 4 - @testing.resolve_artifact_names def test_select_by(self): + User, Address = self.classes.User, self.classes.Address + """Query.select_by(*args, **params) users = session.query(User).select_by(name='fred') @@ -368,8 +387,9 @@ class QueryAlternativesTest(_base.MappedTest): Address.email_address == 'fred@the.fred')).all() assert len(users) == 1 - @testing.resolve_artifact_names def test_selectfirst(self): + Address = self.classes.Address + """Query.selectfirst(arg=None, **kwargs) bounced = session.query(Address).selectfirst( @@ -381,8 +401,9 @@ class QueryAlternativesTest(_base.MappedTest): bounced = session.query(Address).filter(Address.bounces > 0).first() assert bounced.bounces > 0 - @testing.resolve_artifact_names def test_selectfirst_by(self): + User, Address = self.classes.User, self.classes.Address + """Query.selectfirst_by(*args, **params) onebounce = session.query(Address).selectfirst_by(bounces=1) @@ -408,8 +429,9 @@ class QueryAlternativesTest(_base.MappedTest): Address.bounces == 1)).first() assert onebounce_user.name == 'jack' - @testing.resolve_artifact_names def test_selectone(self): + User = self.classes.User + """Query.selectone(arg=None, **kwargs) ed = session.query(User).selectone(users_table.c.name == 'ed') @@ -419,8 +441,9 @@ class QueryAlternativesTest(_base.MappedTest): ed = session.query(User).filter(User.name == 'jack').one() - @testing.resolve_artifact_names def test_selectone_by(self): + User, Address = self.classes.User, self.classes.Address + """Query.selectone_by ed = session.query(User).selectone_by(name='ed') @@ -441,8 +464,9 @@ class QueryAlternativesTest(_base.MappedTest): ed = session.query(User).filter(User.addresses.any( Address.email_address == 'ed@foo.bar')).one() - @testing.resolve_artifact_names def test_select_statement(self): + User, users_table = self.classes.User, self.tables.users_table + """Query.select_statement(statement, **params) users = session.query(User).select_statement(users_table.select()) @@ -453,8 +477,9 @@ class QueryAlternativesTest(_base.MappedTest): users = session.query(User).from_statement(users_table.select()).all() assert len(users) == 4 - @testing.resolve_artifact_names def test_select_text(self): + User = self.classes.User + """Query.select_text(text, **params) users = session.query(User).select_text('SELECT * FROM users_table') @@ -466,8 +491,9 @@ class QueryAlternativesTest(_base.MappedTest): from_statement('SELECT * FROM users_table')).all() assert len(users) == 4 - @testing.resolve_artifact_names def test_select_whereclause(self): + User = self.classes.User + """Query.select_whereclause(whereclause=None, params=None, **kwargs) diff --git a/test/orm/test_dynamic.py b/test/orm/test_dynamic.py index 5ce36ec8a4..a5e23db98a 100644 --- a/test/orm/test_dynamic.py +++ b/test/orm/test_dynamic.py @@ -11,8 +11,12 @@ from test.orm import _base, _fixtures class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): - @testing.resolve_artifact_names def test_basic(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -26,8 +30,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): q.filter(User.id==7).all()) eq_(self.static.user_address_result, q.all()) - @testing.resolve_artifact_names def test_statement(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test that the .statement accessor returns the actual statement that would render, without any _clones called.""" @@ -45,8 +53,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): use_default_dialect=True ) - @testing.resolve_artifact_names def test_order_by(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -58,8 +70,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): Address(email_address=u'ed@bettyboop.com')] ) - @testing.resolve_artifact_names def test_configured_order_by(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=desc(Address.email_address)) }) @@ -79,8 +95,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): set([Address(email_address=u'ed@bettyboop.com'), Address(email_address=u'ed@lala.com'), Address(email_address=u'ed@wood.com')]) ) - @testing.resolve_artifact_names def test_count(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -88,8 +108,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): u = sess.query(User).first() eq_(u.addresses.count(), 1) - @testing.resolve_artifact_names def test_backref(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(Address, addresses, properties={ 'user':relationship(User, backref=backref('addresses', lazy='dynamic')) }) @@ -104,8 +128,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): u = sess.query(User).get(7) assert ad not in u.addresses - @testing.resolve_artifact_names def test_no_count(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -122,8 +150,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): q.filter(User.id==7).all()) self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_no_populate(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -134,8 +166,13 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): attributes.set_committed_value, u1, 'addresses', [] ) - @testing.resolve_artifact_names def test_m2m(self): + items, Order, orders, order_items, Item = (self.tables.items, + self.classes.Order, + self.tables.orders, + self.tables.order_items, + self.classes.Item) + mapper(Order, orders, properties={ 'items':relationship(Item, secondary=order_items, lazy="dynamic", backref=backref('orders', lazy="dynamic")) @@ -152,8 +189,13 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): assert o1 in i1.orders.all() assert i1 in o1.items.all() - @testing.resolve_artifact_names def test_association_nonaliased(self): + items, Order, orders, order_items, Item = (self.tables.items, + self.classes.Order, + self.tables.orders, + self.tables.order_items, + self.classes.Item) + mapper(Order, orders, properties={ 'items':relationship(Item, secondary=order_items, lazy="dynamic", @@ -180,8 +222,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): ) - @testing.resolve_artifact_names def test_transient_detached(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -191,8 +237,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): eq_(u1.addresses.count(), 1) eq_(u1.addresses[0], Address()) - @testing.resolve_artifact_names def test_custom_query(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + class MyQuery(Query): pass @@ -216,8 +266,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): assert not hasattr(q, 'append') eq_(type(q).__name__, 'MyQuery') - @testing.resolve_artifact_names def test_custom_query_with_custom_mixin(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + class MyAppenderMixin(AppenderMixin): def add(self, items): if isinstance(items, list): @@ -258,8 +312,12 @@ class DynamicTest(_fixtures.FixtureTest, AssertsCompiledSQL): class SessionTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_events(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -294,8 +352,12 @@ class SessionTest(_fixtures.FixtureTest): [(a2.id, u1.id, 'bar')]) - @testing.resolve_artifact_names def test_merge(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=addresses.c.email_address) }) @@ -328,8 +390,12 @@ class SessionTest(_fixtures.FixtureTest): [a1, a3] ) - @testing.resolve_artifact_names def test_flush(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -358,8 +424,12 @@ class SessionTest(_fixtures.FixtureTest): ], sess.query(User).all()) - @testing.resolve_artifact_names def test_hasattr(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -369,8 +439,12 @@ class SessionTest(_fixtures.FixtureTest): u1.addresses = [Address(email_address='test')] assert 'addresses' in dir(u1) - @testing.resolve_artifact_names def test_collection_set(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=addresses.c.email_address) }) @@ -391,8 +465,12 @@ class SessionTest(_fixtures.FixtureTest): u1.addresses = [] eq_(list(u1.addresses), []) - @testing.resolve_artifact_names def test_rollback(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) @@ -409,8 +487,12 @@ class SessionTest(_fixtures.FixtureTest): eq_(u1.addresses.all(), [Address(email_address='lala@hoho.com')]) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_delete_nocascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, backref='user') @@ -445,8 +527,12 @@ class SessionTest(_fixtures.FixtureTest): eq_(testing.db.scalar(addresses.count(addresses.c.user_id != None)), 0) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_delete_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, backref='user', cascade="all, delete-orphan") @@ -481,8 +567,12 @@ class SessionTest(_fixtures.FixtureTest): eq_(testing.db.scalar(addresses.count()), 0) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_remove_orphans(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, cascade="all, delete-orphan", backref='user') @@ -522,8 +612,12 @@ class SessionTest(_fixtures.FixtureTest): sess.delete(u) sess.close() - @testing.resolve_artifact_names def _backref_test(self, autoflush, saveuser): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), backref='user') }) @@ -582,8 +676,9 @@ class DontDereferenceTest(_base.MappedTest): Column('user_id', Integer, ForeignKey('users.id'))) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, addresses = cls.tables.users, cls.tables.addresses + class User(_base.ComparableEntity): pass @@ -595,8 +690,9 @@ class DontDereferenceTest(_base.MappedTest): }) mapper(Address, addresses) - @testing.resolve_artifact_names def test_no_deref(self): + User, Address = self.classes.User, self.classes.Address + session = create_session() user = User() user.name = 'joe' diff --git a/test/orm/test_eager_relations.py b/test/orm/test_eager_relations.py index 3ff910dd3f..bd2145519c 100644 --- a/test/orm/test_eager_relations.py +++ b/test/orm/test_eager_relations.py @@ -21,8 +21,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def test_basic(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses), lazy='joined', order_by=Address.id) }) @@ -33,8 +37,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): q.filter(User.id==7).all()) eq_(self.static.user_address_result, q.order_by(User.id).all()) - @testing.resolve_artifact_names def test_late_compile(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + m = mapper(User, users) sess = create_session() sess.query(User).all() @@ -49,8 +57,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_no_orphan(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """An eagerly loaded child object is not marked as an orphan""" mapper(User, users, properties={ @@ -65,8 +77,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): assert not sa.orm.class_mapper(Address).\ _is_orphan(sa.orm.attributes.instance_state(user.addresses[0])) - @testing.resolve_artifact_names def test_orderby(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses':relationship(mapper(Address, addresses), lazy='joined', order_by=addresses.c.email_address), @@ -87,8 +103,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): User(id=10, addresses=[]) ], q.order_by(User.id).all()) - @testing.resolve_artifact_names def test_orderby_multi(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses':relationship(mapper(Address, addresses), lazy='joined', @@ -110,8 +130,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): User(id=10, addresses=[]) ], q.order_by(User.id).all()) - @testing.resolve_artifact_names def test_orderby_related(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A regular mapper select on a single table can order by a relationship to a second table""" @@ -137,8 +161,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ]), ], l) - @testing.resolve_artifact_names def test_orderby_desc(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties = dict( addresses = relationship(Address, lazy='joined', @@ -160,8 +188,14 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): User(id=10, addresses=[]) ], sess.query(User).order_by(User.id).all()) - @testing.resolve_artifact_names def test_deferred_fk_col(self): + users, Dingaling, User, dingalings, Address, addresses = (self.tables.users, + self.classes.Dingaling, + self.classes.User, + self.tables.dingalings, + self.classes.Address, + self.tables.addresses) + mapper(Address, addresses, properties={ 'user_id':deferred(addresses.c.user_id), 'user':relationship(User, lazy='joined') @@ -245,8 +279,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): u) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_options_pathing(self): + users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (self.tables.users, + self.classes.Keyword, + self.tables.orders, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.keywords, + self.tables.item_keywords) + mapper(User, users, properties={ 'orders':relationship(Order, order_by=orders.c.id), # o2m, m2o }) @@ -287,8 +331,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ) self.assert_sql_count(testing.db, go, count) - @testing.resolve_artifact_names def test_disable_dynamic(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test no joined option on a dynamic.""" mapper(User, users, properties={ @@ -302,8 +350,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): sess.query(User).options(joinedload(User.addresses)).first, ) - @testing.resolve_artifact_names def test_many_to_many(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( @@ -326,8 +379,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): filter(Keyword.name == 'red')).all()) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_eager_option(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( keywords = relationship(Keyword, secondary=item_keywords, lazy='select', @@ -342,8 +400,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_cyclical(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A circular eager relationship breaks the cycle with a lazy loader""" mapper(Address, addresses) @@ -358,8 +420,14 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): sess = create_session() eq_(self.static.user_address_result, sess.query(User).order_by(User.id).all()) - @testing.resolve_artifact_names def test_double(self): + users, orders, User, Address, Order, addresses = (self.tables.users, + self.tables.orders, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """Eager loading with two relationships simultaneously, from the same table, using aliases.""" @@ -412,8 +480,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ], q.all()) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_double_same_mappers(self): + addresses, items, order_items, orders, Item, User, Address, Order, users = (self.tables.addresses, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.users) + """Eager loading with two relationships simulatneously, from the same table, using aliases.""" @@ -479,8 +556,14 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ], q.all()) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_no_false_hits(self): + addresses, orders, User, Address, Order, users = (self.tables.addresses, + self.tables.orders, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.users) + """Eager loaders don't interpret main table columns as part of their eager load.""" @@ -503,8 +586,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): assert 'addresses' not in noeagers[0].__dict__ @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_limit(self): + users, items, order_items, orders, Item, User, Address, Order, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """Limit operations combined with lazy-load relationships.""" mapper(Item, items) @@ -523,8 +615,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): l = q.order_by(User.id).limit(2).offset(1).all() eq_(self.static.user_all_result[1:3], l) - @testing.resolve_artifact_names def test_distinct(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + # this is an involved 3x union of the users table to get a lot of rows. # then see if the "distinct" works its way out. you actually get the same # result with or without the distinct, just via less or more rows. @@ -544,8 +640,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 1) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_limit_2(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( keywords = relationship(Keyword, secondary=item_keywords, lazy='joined', order_by=[keywords.c.id]), @@ -561,8 +662,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): eq_(self.static.item_keyword_result[1:3], l) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_limit_3(self): + addresses, items, order_items, orders, Item, User, Address, Order, users = (self.tables.addresses, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.users) + """test that the ORDER BY is propagated from the inner select to the outer select, when using the 'wrapped' select statement resulting from the combination of @@ -603,8 +713,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ) ], l.all()) - @testing.resolve_artifact_names def test_limit_4(self): + User, Order, addresses, users, orders = (self.classes.User, + self.classes.Order, + self.tables.addresses, + self.tables.users, + self.tables.orders) + # tests the LIMIT/OFFSET aliasing on a mapper # against a select. original issue from ticket #904 sel = sa.select([users, addresses.c.email_address], @@ -624,8 +739,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): email_address=u'jack@bean.com',id=7) ) - @testing.resolve_artifact_names def test_useget_cancels_eager(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test that a one to many lazyload cancels the unnecessary eager many-to-one join on the other side.""" @@ -648,8 +767,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ) - @testing.resolve_artifact_names def test_manytoone_limit(self): + users, items, order_items, Order, Item, User, Address, orders, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.tables.orders, + self.tables.addresses) + """test that the subquery wrapping only occurs with limit/offset and m2m or o2m joins present.""" @@ -757,8 +885,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): use_default_dialect=True ) - @testing.resolve_artifact_names def test_one_to_many_scalar(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties = dict( address = relationship(mapper(Address, addresses), lazy='joined', uselist=False) @@ -771,8 +903,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 1) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_many_to_one(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(Address, addresses, properties = dict( user = relationship(mapper(User, users), lazy='joined') )) @@ -786,8 +922,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): is_(a.user, u1) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_many_to_one_null(self): + Order, Address, addresses, orders = (self.classes.Order, + self.classes.Address, + self.tables.addresses, + self.tables.orders) + """test that a many-to-one eager load which loads None does not later trigger a lazy load. @@ -817,8 +957,15 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): eq_(o1.address, None) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_one_and_many(self): + users, items, order_items, orders, Item, User, Order = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Order) + """tests eager load for a parent object with a child object that contains a many-to-many relationship to a third object.""" @@ -838,8 +985,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): eq_(self.static.user_order_result[0:3], l.all()) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_double_with_aggregate(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + max_orders_by_user = sa.select([sa.func.max(orders.c.id).label('order_id')], group_by=[orders.c.user_id] ).alias('max_orders_by_user') @@ -875,8 +1026,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ], q.order_by(User.id).all()) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_uselist_false_warning(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + """test that multiple rows received by a uselist=False raises a warning.""" @@ -888,8 +1043,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): assert_raises(sa.exc.SAWarning, s.query(User).options(joinedload(User.order)).all) - @testing.resolve_artifact_names def test_wide(self): + users, items, order_items, Order, Item, User, Address, orders, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.tables.orders, + self.tables.addresses) + mapper(Order, orders, properties={'items':relationship(Item, secondary=order_items, lazy='joined', order_by=items.c.id)}) mapper(Item, items) @@ -901,8 +1065,15 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): l = q.all() eq_(self.static.user_all_result, q.order_by(User.id).all()) - @testing.resolve_artifact_names def test_against_select(self): + users, items, order_items, orders, Item, User, Order = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Order) + """test eager loading of a mapper which is against a select""" s = sa.select([orders], orders.c.isopen==1).alias('openorders') @@ -924,8 +1095,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): Order(id=3, user=User(id=7)), ], q.all()) - @testing.resolve_artifact_names def test_aliasing(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """test that eager loading uses aliases to insulate the eager load from regular criterion against those tables.""" @@ -938,8 +1113,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): Address.user_id==User.id).order_by(User.id) eq_(self.static.user_address_result[1:2], l.all()) - @testing.resolve_artifact_names def test_inner_join(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties = dict( addresses = relationship(mapper(Address, addresses), lazy='joined', innerjoin=True, order_by=addresses.c.id) @@ -961,8 +1140,15 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): "addresses AS addresses_1 ON users.id = addresses_1.user_id ORDER BY addresses_1.id" , use_default_dialect=True) - @testing.resolve_artifact_names def test_inner_join_chaining_options(self): + users, items, order_items, Order, Item, User, orders = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.orders) + mapper(User, users, properties = dict( orders =relationship(Order, innerjoin=True, lazy=False) @@ -1013,8 +1199,15 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): use_default_dialect=True ) - @testing.resolve_artifact_names def test_inner_join_chaining_fixed(self): + users, items, order_items, Order, Item, User, orders = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.orders) + mapper(User, users, properties = dict( orders =relationship(Order, lazy=False) )) @@ -1055,8 +1248,15 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): - @testing.resolve_artifact_names def test_inner_join_options(self): + users, items, order_items, Order, Item, User, orders = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.orders) + mapper(User, users, properties = dict( orders =relationship(Order, backref=backref('user', innerjoin=True), order_by=orders.c.id) )) @@ -1116,8 +1316,12 @@ class AddEntityTest(_fixtures.FixtureTest): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def _assert_result(self): + Item, Address, Order, User = (self.classes.Item, + self.classes.Address, + self.classes.Order, + self.classes.User) + return [ ( User(id=7, @@ -1161,8 +1365,17 @@ class AddEntityTest(_fixtures.FixtureTest): ) ] - @testing.resolve_artifact_names def test_mapper_configured(self): + users, items, order_items, Order, Item, User, Address, orders, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.tables.orders, + self.tables.addresses) + mapper(User, users, properties={ 'addresses':relationship(Address, lazy='joined'), 'orders':relationship(Order) @@ -1182,8 +1395,17 @@ class AddEntityTest(_fixtures.FixtureTest): eq_(ret, self._assert_result()) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_options(self): + users, items, order_items, Order, Item, User, Address, orders, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.tables.orders, + self.tables.addresses) + mapper(User, users, properties={ 'addresses':relationship(Address), 'orders':relationship(Order) @@ -1250,8 +1472,11 @@ class OrderBySecondaryTest(_base.MappedTest): (3, 1, 2), (5, 2, 3))) - @testing.resolve_artifact_names def test_ordering(self): + a, m2m, b = (self.tables.a, + self.tables.m2m, + self.tables.b) + class A(_base.ComparableEntity):pass class B(_base.ComparableEntity):pass @@ -1276,8 +1501,9 @@ class SelfReferentialEagerTest(_base.MappedTest): Column('data', String(30))) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_basic(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -1326,8 +1552,9 @@ class SelfReferentialEagerTest(_base.MappedTest): self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_lazy_fallback_doesnt_affect_eager(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -1367,8 +1594,9 @@ class SelfReferentialEagerTest(_base.MappedTest): ], list(n12.children)) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_with_deferred(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -1409,8 +1637,9 @@ class SelfReferentialEagerTest(_base.MappedTest): self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_options(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -1457,8 +1686,9 @@ class SelfReferentialEagerTest(_base.MappedTest): ) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_no_depth(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -1505,8 +1735,9 @@ class MixedSelfReferentialEagerTest(_base.MappedTest): @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + b_table, a_table = cls.tables.b_table, cls.tables.a_table + class A(_base.ComparableEntity): pass class B(_base.ComparableEntity): @@ -1528,8 +1759,9 @@ class MixedSelfReferentialEagerTest(_base.MappedTest): }); @classmethod - @testing.resolve_artifact_names def insert_data(cls): + b_table, a_table = cls.tables.b_table, cls.tables.a_table + a_table.insert().execute(dict(id=1), dict(id=2), dict(id=3)) b_table.insert().execute( dict(id=1, parent_a_id=2, parent_b1_id=None, parent_b2_id=None), @@ -1548,8 +1780,9 @@ class MixedSelfReferentialEagerTest(_base.MappedTest): dict(id=14, parent_a_id=3, parent_b1_id=7, parent_b2_id=2), ) - @testing.resolve_artifact_names def test_eager_load(self): + A, B = self.classes.A, self.classes.B + session = create_session() def go(): eq_( @@ -1581,8 +1814,9 @@ class SelfReferentialM2MEagerTest(_base.MappedTest): sa.UniqueConstraint('parent_id', 'child_id'), ) - @testing.resolve_artifact_names def test_basic(self): + widget, widget_rel = self.tables.widget, self.tables.widget_rel + class Widget(_base.ComparableEntity): pass @@ -1611,8 +1845,20 @@ class MixedEntitiesTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): run_deletes = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, Keyword, items, order_items, orders, Item, User, Address, keywords, Order, item_keywords, addresses = (cls.tables.users, + cls.classes.Keyword, + cls.tables.items, + cls.tables.order_items, + cls.tables.orders, + cls.classes.Item, + cls.classes.User, + cls.classes.Address, + cls.tables.keywords, + cls.classes.Order, + cls.tables.item_keywords, + cls.tables.addresses) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user'), 'orders':relationship(Order, backref='user'), # o2m, m2o @@ -1626,8 +1872,12 @@ class MixedEntitiesTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): }) mapper(Keyword, keywords) - @testing.resolve_artifact_names def test_two_entities(self): + Item, Order, User, Address = (self.classes.Item, + self.classes.Order, + self.classes.User, + self.classes.Address) + sess = create_session() # two FROM clauses @@ -1656,8 +1906,12 @@ class MixedEntitiesTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 1) @testing.exclude('sqlite', '>', (0, ), "sqlite flat out blows it on the multiple JOINs") - @testing.resolve_artifact_names def test_two_entities_with_joins(self): + Item, Order, User, Address = (self.classes.Item, + self.classes.Order, + self.classes.User, + self.classes.Address) + sess = create_session() # two FROM clauses where there's a join on each one @@ -1697,8 +1951,12 @@ class MixedEntitiesTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): - @testing.resolve_artifact_names def test_aliased_entity(self): + Item, Order, User, Address = (self.classes.Item, + self.classes.Order, + self.classes.User, + self.classes.Address) + sess = create_session() oalias = sa.orm.aliased(Order) @@ -1762,8 +2020,9 @@ class CyclicalInheritingEagerTest(_base.MappedTest): Column('type', String(30)), Column('t1.id', Integer, ForeignKey('t1.c1'))) - @testing.resolve_artifact_names def test_basic(self): + t2, t1 = self.tables.t2, self.tables.t1 + class T(object): pass @@ -1801,8 +2060,9 @@ class SubqueryTest(_base.MappedTest): Column('score2', sa.Float), ) - @testing.resolve_artifact_names def test_label_anonymizing(self): + tags_table, users_table = self.tables.tags_table, self.tables.users_table + """Eager loading works with subqueries with labels, Even if an explicit labelname which conflicts with a label on the @@ -1896,8 +2156,9 @@ class CorrelatedSubqueryTest(_base.MappedTest): Column('user_id', Integer, ForeignKey('users.id'))) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + stuff, users = cls.tables.stuff, cls.tables.users + users.insert().execute( {'id':1, 'name':'user1'}, {'id':2, 'name':'user2'}, @@ -1950,8 +2211,9 @@ class CorrelatedSubqueryTest(_base.MappedTest): def test_plain_on_limitid_alias(self): self._do_test('none', False, True) - @testing.resolve_artifact_names def _do_test(self, labeled, ondate, aliasstuff): + stuff, users = self.tables.stuff, self.tables.users + class User(_base.ComparableEntity): pass diff --git a/test/orm/test_evaluator.py b/test/orm/test_evaluator.py index 017619cfe9..a27c81260e 100644 --- a/test/orm/test_evaluator.py +++ b/test/orm/test_evaluator.py @@ -34,12 +34,14 @@ class EvaluateTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, User = cls.tables.users, cls.classes.User + mapper(User, users) - @testing.resolve_artifact_names def test_compare_to_value(self): + User = self.classes.User + eval_eq(User.name == 'foo', testcases=[ (User(name='foo'), True), (User(name='bar'), False), @@ -52,15 +54,17 @@ class EvaluateTest(_base.MappedTest): (User(id=None), None), ]) - @testing.resolve_artifact_names def test_compare_to_none(self): + User = self.classes.User + eval_eq(User.name == None, testcases=[ (User(name='foo'), False), (User(name=None), True), ]) - @testing.resolve_artifact_names def test_boolean_ops(self): + User = self.classes.User + eval_eq(and_(User.name == 'foo', User.id == 1), testcases=[ (User(id=1, name='foo'), True), (User(id=2, name='foo'), False), @@ -84,8 +88,9 @@ class EvaluateTest(_base.MappedTest): (User(id=None), None), ]) - @testing.resolve_artifact_names def test_null_propagation(self): + User = self.classes.User + eval_eq((User.name == 'foo') == (User.id == 1), testcases=[ (User(id=1, name='foo'), True), (User(id=2, name='foo'), False), diff --git a/test/orm/test_events.py b/test/orm/test_events.py index d61c2fcaa2..831fb4a118 100644 --- a/test/orm/test_events.py +++ b/test/orm/test_events.py @@ -26,8 +26,9 @@ class _RemoveListeners(object): class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_instance_event_listen(self): + users, addresses = self.tables.users, self.tables.addresses + """test listen targets for instance events""" canary = [] @@ -97,8 +98,9 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): event.listen(mapper, meth, evt(meth), **kw) return canary - @testing.resolve_artifact_names def test_basic(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) canary = self.listen_all(User) @@ -123,8 +125,9 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): 'populate_instance', 'load', 'append_result', 'before_update', 'after_update', 'before_delete', 'after_delete']) - @testing.resolve_artifact_names def test_merge(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) canary =[] @@ -144,8 +147,11 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): s.query(User).first() eq_(canary,['load', 'load', 'load']) - @testing.resolve_artifact_names def test_inheritance(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + class AdminUser(User): pass @@ -181,8 +187,13 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): 'before_update', 'after_update', 'before_delete', 'after_delete']) - @testing.resolve_artifact_names def test_before_after_only_collection(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + """before_update is called on parent for collection modifications, after_update is called even if no columns were updated. @@ -217,8 +228,9 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): eq_(canary2, []) - @testing.resolve_artifact_names def test_retval(self): + User, users = self.classes.User, self.tables.users + def create_instance(mapper, context, row, class_): u = User.__new__(User) u.foo = True @@ -235,8 +247,12 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest): u = sess.query(User).first() assert u.foo - @testing.resolve_artifact_names def test_instrument_event(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + canary = [] def instrument_class(mapper, cls): canary.append(cls) @@ -253,12 +269,14 @@ class LoadTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + User, users = cls.classes.User, cls.tables.users + mapper(User, users) - @testing.resolve_artifact_names def _fixture(self): + User = self.classes.User + canary = [] def load(target, ctx): canary.append("load") @@ -269,8 +287,9 @@ class LoadTest(_fixtures.FixtureTest): event.listen(User, "refresh", refresh) return canary - @testing.resolve_artifact_names def test_just_loaded(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -283,8 +302,9 @@ class LoadTest(_fixtures.FixtureTest): sess.query(User).first() eq_(canary, ['load']) - @testing.resolve_artifact_names def test_repeated_rows(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -303,12 +323,14 @@ class RefreshTest(_fixtures.FixtureTest): run_inserts = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + User, users = cls.classes.User, cls.tables.users + mapper(User, users) - @testing.resolve_artifact_names def _fixture(self): + User = self.classes.User + canary = [] def load(target, ctx): canary.append("load") @@ -319,8 +341,9 @@ class RefreshTest(_fixtures.FixtureTest): event.listen(User, "refresh", refresh) return canary - @testing.resolve_artifact_names def test_already_present(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -332,8 +355,9 @@ class RefreshTest(_fixtures.FixtureTest): sess.query(User).first() eq_(canary, []) - @testing.resolve_artifact_names def test_repeated_rows(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -345,8 +369,9 @@ class RefreshTest(_fixtures.FixtureTest): sess.query(User).union_all(sess.query(User)).all() eq_(canary, [('refresh', set(['id','name']))]) - @testing.resolve_artifact_names def test_via_refresh_state(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -358,8 +383,9 @@ class RefreshTest(_fixtures.FixtureTest): u1.name eq_(canary, [('refresh', set(['id','name']))]) - @testing.resolve_artifact_names def test_was_expired(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -372,8 +398,9 @@ class RefreshTest(_fixtures.FixtureTest): sess.query(User).first() eq_(canary, [('refresh', set(['id','name']))]) - @testing.resolve_artifact_names def test_was_expired_via_commit(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -385,8 +412,9 @@ class RefreshTest(_fixtures.FixtureTest): sess.query(User).first() eq_(canary, [('refresh', set(['id','name']))]) - @testing.resolve_artifact_names def test_was_expired_attrs(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -399,8 +427,9 @@ class RefreshTest(_fixtures.FixtureTest): sess.query(User).first() eq_(canary, [('refresh', set(['name']))]) - @testing.resolve_artifact_names def test_populate_existing(self): + User = self.classes.User + canary = self._fixture() sess = Session() @@ -517,8 +546,9 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): return sess, canary - @testing.resolve_artifact_names def test_flush_autocommit_hook(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) @@ -534,8 +564,9 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): 'before_commit', 'after_commit',] ) - @testing.resolve_artifact_names def test_flush_noautocommit_hook(self): + User, users = self.classes.User, self.tables.users + sess, canary = self._listener_fixture() mapper(User, users) @@ -546,8 +577,9 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): eq_(canary, ['after_attach', 'before_flush', 'after_begin', 'after_flush', 'after_flush_postexec']) - @testing.resolve_artifact_names def test_flush_in_commit_hook(self): + User, users = self.classes.User, self.tables.users + sess, canary = self._listener_fixture() mapper(User, users) @@ -566,15 +598,17 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): sess.commit() eq_(canary, ['before_commit', 'after_commit']) - @testing.resolve_artifact_names def test_on_bulk_update_hook(self): + User, users = self.classes.User, self.tables.users + sess, canary = self._listener_fixture() mapper(User, users) sess.query(User).update({'name': 'foo'}) eq_(canary, ['after_begin', 'after_bulk_update']) - @testing.resolve_artifact_names def test_on_bulk_delete_hook(self): + User, users = self.classes.User, self.tables.users + sess, canary = self._listener_fixture() mapper(User, users) sess.query(User).delete() @@ -585,8 +619,9 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): conn = sess.connection() eq_(canary, ['after_begin']) - @testing.resolve_artifact_names def test_reentrant_flush(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) @@ -599,8 +634,9 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): assert_raises_message(sa.exc.InvalidRequestError, 'already flushing', sess.flush) - @testing.resolve_artifact_names def test_before_flush_affects_flush_plan(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) @@ -653,8 +689,9 @@ class SessionEventsTest(_RemoveListeners, _fixtures.FixtureTest): ] ) - @testing.resolve_artifact_names def test_before_flush_affects_dirty(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) def before_flush(session, flush_context, objects): @@ -751,8 +788,9 @@ class MapperExtensionTest(_fixtures.FixtureTest): return Ext, methods - @testing.resolve_artifact_names def test_basic(self): + User, users = self.classes.User, self.tables.users + """test that common user-defined methods get called.""" Ext, methods = self.extension() @@ -775,8 +813,11 @@ class MapperExtensionTest(_fixtures.FixtureTest): 'populate_instance', 'reconstruct_instance', 'append_result', 'before_update', 'after_update', 'before_delete', 'after_delete']) - @testing.resolve_artifact_names def test_inheritance(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + Ext, methods = self.extension() class AdminUser(User): @@ -804,8 +845,13 @@ class MapperExtensionTest(_fixtures.FixtureTest): 'append_result', 'before_update', 'after_update', 'before_delete', 'after_delete']) - @testing.resolve_artifact_names def test_before_after_only_collection(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + """before_update is called on parent for collection modifications, after_update is called even if no columns were updated. @@ -839,8 +885,11 @@ class MapperExtensionTest(_fixtures.FixtureTest): eq_(methods2, []) - @testing.resolve_artifact_names def test_inheritance_with_dupes(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + """Inheritance with the same extension instance on both mappers.""" Ext, methods = self.extension() @@ -870,8 +919,9 @@ class MapperExtensionTest(_fixtures.FixtureTest): 'append_result', 'before_update', 'after_update', 'before_delete', 'after_delete']) - @testing.resolve_artifact_names def test_create_instance(self): + User, users = self.classes.User, self.tables.users + class CreateUserExt(sa.orm.MapperExtension): def create_instance(self, mapper, selectcontext, row, class_): return User.__new__(User) @@ -885,8 +935,9 @@ class MapperExtensionTest(_fixtures.FixtureTest): sess.expunge_all() assert sess.query(User).first() - @testing.resolve_artifact_names def test_unnecessary_methods_not_evented(self): + users = self.tables.users + class MyExtension(sa.orm.MapperExtension): def before_insert(self, mapper, connection, instance): pass @@ -910,8 +961,9 @@ class AttributeExtensionTest(_base.MappedTest): ) - @testing.resolve_artifact_names def test_cascading_extensions(self): + t1 = self.tables.t1 + ext_msg = [] class Ex1(sa.orm.AttributeExtension): @@ -962,8 +1014,9 @@ class AttributeExtensionTest(_base.MappedTest): class SessionExtensionTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_extension(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) log = [] class MyExt(sa.orm.session.SessionExtension): @@ -1041,8 +1094,9 @@ class SessionExtensionTest(_fixtures.FixtureTest): conn = sess.connection() assert log == ['after_begin'] - @testing.resolve_artifact_names def test_multiple_extensions(self): + User, users = self.classes.User, self.tables.users + log = [] class MyExt1(sa.orm.session.SessionExtension): def before_commit(self, session): @@ -1063,7 +1117,6 @@ class SessionExtensionTest(_fixtures.FixtureTest): 'before_commit_two', ] - @testing.resolve_artifact_names def test_unnecessary_methods_not_evented(self): class MyExtension(sa.orm.session.SessionExtension): def before_commit(self, session): diff --git a/test/orm/test_expire.py b/test/orm/test_expire.py index cfa218630e..23ea834384 100644 --- a/test/orm/test_expire.py +++ b/test/orm/test_expire.py @@ -15,8 +15,12 @@ from test.orm import _base, _fixtures class ExpireTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_expire(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user'), }) @@ -54,8 +58,9 @@ class ExpireTest(_fixtures.FixtureTest): assert u.name == 'jack' self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_persistence_check(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) s = create_session() u = s.query(User).get(7) @@ -64,8 +69,9 @@ class ExpireTest(_fixtures.FixtureTest): assert_raises_message(sa_exc.InvalidRequestError, r"is not persistent within this Session", s.expire, u) - @testing.resolve_artifact_names def test_get_refreshes(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) s = create_session(autocommit=False) u = s.query(User).get(10) @@ -109,8 +115,9 @@ class ExpireTest(_fixtures.FixtureTest): # is reverted eq_(u.name, 'chuck') - @testing.resolve_artifact_names def test_deferred(self): + Order, orders = self.classes.Order, self.tables.orders + """test that unloaded, deferred attributes aren't included in the expiry list.""" mapper(Order, orders, properties={'description':deferred(orders.c.description)}) @@ -123,8 +130,12 @@ class ExpireTest(_fixtures.FixtureTest): assert 'description' not in o1.__dict__ assert o1.description - @testing.resolve_artifact_names def test_lazyload_autoflushes(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, order_by=addresses.c.email_address) }) @@ -146,8 +157,12 @@ class ExpireTest(_fixtures.FixtureTest): Address(email_address='ed@lala.com'), ]) - @testing.resolve_artifact_names def test_refresh_collection_exception(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test graceful failure for currently unsupported immediate refresh of a collection""" @@ -165,8 +180,9 @@ class ExpireTest(_fixtures.FixtureTest): assert_raises_message(sa_exc.InvalidRequestError, "no columns with which to SELECT", s.query().all) - @testing.resolve_artifact_names def test_refresh_cancels_expire(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) s = create_session() u = s.query(User).get(7) @@ -178,8 +194,9 @@ class ExpireTest(_fixtures.FixtureTest): eq_(u.name, 'jack') self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_expire_doesntload_on_set(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session() @@ -193,8 +210,9 @@ class ExpireTest(_fixtures.FixtureTest): sess.expunge_all() assert sess.query(User).get(7).name == 'somenewname' - @testing.resolve_artifact_names def test_no_session(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session() u = sess.query(User).get(7) @@ -203,8 +221,9 @@ class ExpireTest(_fixtures.FixtureTest): sess.expunge(u) assert_raises(orm_exc.DetachedInstanceError, getattr, u, 'name') - @testing.resolve_artifact_names def test_pending_raises(self): + users, User = self.tables.users, self.classes.User + # this was the opposite in 0.4, but the reasoning there seemed off. # expiring a pending instance makes no sense, so should raise mapper(User, users) @@ -213,8 +232,9 @@ class ExpireTest(_fixtures.FixtureTest): sess.add(u) assert_raises(sa_exc.InvalidRequestError, sess.expire, u, ['name']) - @testing.resolve_artifact_names def test_no_instance_key(self): + User, users = self.classes.User, self.tables.users + # this tests an artificial condition such that # an instance is pending, but has expired attributes. this # is actually part of a larger behavior when postfetch needs to @@ -230,8 +250,9 @@ class ExpireTest(_fixtures.FixtureTest): sess.add(u) assert u.name == 'jack' - @testing.resolve_artifact_names def test_no_instance_key_no_pk(self): + users, User = self.tables.users, self.classes.User + # same as test_no_instance_key, but the PK columns # are absent. ensure an error is raised. mapper(User, users) @@ -246,8 +267,9 @@ class ExpireTest(_fixtures.FixtureTest): assert_raises(sa_exc.InvalidRequestError, getattr, u, 'name') - @testing.resolve_artifact_names def test_expire_preserves_changes(self): + Order, orders = self.classes.Order, self.tables.orders + """test that the expire load operation doesn't revert post-expire changes""" mapper(Order, orders) @@ -291,8 +313,9 @@ class ExpireTest(_fixtures.FixtureTest): assert o.isopen == 1 assert o.description == 'another new description' - @testing.resolve_artifact_names def test_expire_committed(self): + orders, Order = self.tables.orders, self.classes.Order + """test that the committed state of the attribute receives the most recent DB data""" mapper(Order, orders) @@ -307,8 +330,12 @@ class ExpireTest(_fixtures.FixtureTest): sess.flush() self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_expire_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, cascade="all, refresh-expire") }) @@ -321,8 +348,12 @@ class ExpireTest(_fixtures.FixtureTest): s.expire(u) assert u.addresses[0].email_address == 'ed@wood.com' - @testing.resolve_artifact_names def test_refresh_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, cascade="all, refresh-expire") }) @@ -351,8 +382,12 @@ class ExpireTest(_fixtures.FixtureTest): cascade = 'save-update, refresh-expire' self._test_cascade_to_pending(cascade, False) - @testing.resolve_artifact_names def _test_cascade_to_pending(self, cascade, expire_or_refresh): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, cascade=cascade) }) @@ -375,8 +410,12 @@ class ExpireTest(_fixtures.FixtureTest): assert a not in u.addresses s.flush() - @testing.resolve_artifact_names def test_expired_lazy(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user'), }) @@ -397,8 +436,12 @@ class ExpireTest(_fixtures.FixtureTest): assert 'name' in u.__dict__ assert 'addresses' in u.__dict__ - @testing.resolve_artifact_names def test_expired_eager(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', lazy='joined'), }) @@ -432,8 +475,12 @@ class ExpireTest(_fixtures.FixtureTest): # together when eager load used with Query self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_relationship_changes_preserved(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', lazy='joined'), }) @@ -448,8 +495,12 @@ class ExpireTest(_fixtures.FixtureTest): assert 'name' in u.__dict__ assert len(u.addresses) == 2 - @testing.resolve_artifact_names def test_joinedload_props_dontload(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + # relationships currently have to load separately from scalar instances. # the use case is: expire "addresses". then access it. lazy load # fires off to load "addresses", but needs foreign key or primary key @@ -472,8 +523,9 @@ class ExpireTest(_fixtures.FixtureTest): u.addresses assert 'addresses' in u.__dict__ - @testing.resolve_artifact_names def test_expire_synonym(self): + User, users = self.classes.User, self.tables.users + mapper(User, users, properties={ 'uname': sa.orm.synonym('name') }) @@ -497,8 +549,9 @@ class ExpireTest(_fixtures.FixtureTest): # users.update(users.c.id==7).execute(name='jack3') # assert u.uname == 'jack3' - @testing.resolve_artifact_names def test_partial_expire(self): + orders, Order = self.tables.orders, self.classes.Order + mapper(Order, orders) sess = create_session() @@ -542,8 +595,12 @@ class ExpireTest(_fixtures.FixtureTest): assert o.isopen == 5 self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_partial_expire_lazy(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user'), }) @@ -587,8 +644,12 @@ class ExpireTest(_fixtures.FixtureTest): assert u.name == 'ed' self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_partial_expire_eager(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', lazy='joined'), }) @@ -628,8 +689,12 @@ class ExpireTest(_fixtures.FixtureTest): # doing it that way right now #self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_relationships_load_on_query(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user'), }) @@ -649,8 +714,9 @@ class ExpireTest(_fixtures.FixtureTest): assert 'name' in u.__dict__ assert 'addresses' in u.__dict__ - @testing.resolve_artifact_names def test_partial_expire_deferred(self): + orders, Order = self.tables.orders, self.classes.Order + mapper(Order, orders, properties={ 'description': sa.orm.deferred(orders.c.description) }) @@ -716,8 +782,12 @@ class ExpireTest(_fixtures.FixtureTest): assert o.isopen == 1 self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_joinedload_query_refreshes(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', lazy='joined'), }) @@ -733,8 +803,12 @@ class ExpireTest(_fixtures.FixtureTest): assert 'addresses' in u.__dict__ assert len(u.addresses) == 3 - @testing.resolve_artifact_names def test_expire_all(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', lazy='joined', order_by=addresses.c.id), @@ -754,8 +828,9 @@ class ExpireTest(_fixtures.FixtureTest): eq_(self.static.user_address_result, userlist) assert len(list(sess)) == 9 - @testing.resolve_artifact_names def test_state_change_col_to_deferred(self): + users, User = self.tables.users, self.classes.User + """Behavioral test to verify the current activity of loader callables.""" mapper(User, users) @@ -801,8 +876,9 @@ class ExpireTest(_fixtures.FixtureTest): sess.expire(u1) assert 'name' in attributes.instance_state(u1).callables - @testing.resolve_artifact_names def test_state_deferred_to_col(self): + users, User = self.tables.users, self.classes.User + """Behavioral test to verify the current activity of loader callables.""" mapper(User, users, properties={'name':deferred(users.c.name)}) @@ -841,8 +917,12 @@ class ExpireTest(_fixtures.FixtureTest): state.InstanceState ) - @testing.resolve_artifact_names def test_state_noload_to_lazy(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """Behavioral test to verify the current activity of loader callables.""" mapper(User, users, properties={'addresses':relationship(Address, lazy='noload')}) @@ -906,8 +986,9 @@ class PolymorphicExpireTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def insert_data(cls): + people, engineers = cls.tables.people, cls.tables.engineers + people.insert().execute( {'person_id':1, 'name':'person1', 'type':'person'}, {'person_id':2, 'name':'engineer1', 'type':'engineer'}, @@ -919,13 +1000,20 @@ class PolymorphicExpireTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Person, people, engineers, Engineer = (cls.classes.Person, + cls.tables.people, + cls.tables.engineers, + cls.classes.Engineer) + mapper(Person, people, polymorphic_on=people.c.type, polymorphic_identity='person') mapper(Engineer, engineers, inherits=Person, polymorphic_identity='engineer') - @testing.resolve_artifact_names def test_poly_deferred(self): + Person, people, Engineer = (self.classes.Person, + self.tables.people, + self.classes.Engineer) + sess = create_session() [p1, e1, e2] = sess.query(Person).order_by(people.c.person_id).all() @@ -961,8 +1049,9 @@ class PolymorphicExpireTest(_base.MappedTest): self.assert_sql_count(testing.db, go, 2) eq_(Engineer.name.get_history(e1), (['new engineer name'],(), ['engineer1'])) - @testing.resolve_artifact_names def test_no_instance_key(self): + Engineer = self.classes.Engineer + sess = create_session() e1 = sess.query(Engineer).get(2) @@ -974,8 +1063,9 @@ class PolymorphicExpireTest(_base.MappedTest): sess.add(e1) assert e1.name == 'engineer1' - @testing.resolve_artifact_names def test_no_instance_key(self): + Engineer = self.classes.Engineer + # same as test_no_instance_key, but the PK columns # are absent. ensure an error is raised. sess = create_session() @@ -995,8 +1085,12 @@ class ExpiredPendingTest(_fixtures.FixtureTest): run_setup_mappers = None run_inserts = None - @testing.resolve_artifact_names def test_expired_pending(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user'), }) @@ -1037,8 +1131,12 @@ class ExpiredPendingTest(_fixtures.FixtureTest): class RefreshTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_refresh(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses), backref='user') }) @@ -1073,16 +1171,18 @@ class RefreshTest(_fixtures.FixtureTest): assert u.name == 'jack' assert id(a) not in [id(x) for x in u.addresses] - @testing.resolve_artifact_names def test_persistence_check(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) s = create_session() u = s.query(User).get(7) s.expunge_all() assert_raises_message(sa_exc.InvalidRequestError, r"is not persistent within this Session", lambda: s.refresh(u)) - @testing.resolve_artifact_names def test_refresh_expired(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) s = create_session() u = s.query(User).get(7) @@ -1091,8 +1191,12 @@ class RefreshTest(_fixtures.FixtureTest): s.refresh(u) assert u.name == 'jack' - @testing.resolve_artifact_names def test_refresh_with_lazy(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + """test that when a lazy loader is set as a trigger on an object's attribute (at the attribute level, not the class level), a refresh() operation doesnt fire the lazy loader or create any problems""" @@ -1105,8 +1209,12 @@ class RefreshTest(_fixtures.FixtureTest): s.refresh(u) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_refresh_with_eager(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test that a refresh/expire operation loads rows properly and sends correct "isnew" state to eager loaders""" mapper(User, users, properties={ @@ -1126,8 +1234,12 @@ class RefreshTest(_fixtures.FixtureTest): assert len(u.addresses) == 3 @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_refresh2(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """test a hang condition that was occurring on expire/refresh""" s = create_session() diff --git a/test/orm/test_froms.py b/test/orm/test_froms.py index ffdc110e2a..fd0b2fd959 100644 --- a/test/orm/test_froms.py +++ b/test/orm/test_froms.py @@ -255,8 +255,12 @@ class AddEntityEquivalenceTest(_base.MappedTest, AssertsCompiledSQL): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): + a, c, b, d = (cls.tables.a, + cls.tables.c, + cls.tables.b, + cls.tables.d) + class A(_fixtures.Base): pass @@ -285,8 +289,11 @@ class AddEntityEquivalenceTest(_base.MappedTest, AssertsCompiledSQL): mapper(D, d, inherits=A, polymorphic_identity='d') @classmethod - @testing.resolve_artifact_names def insert_data(cls): + A, C, B = (cls.classes.A, + cls.classes.C, + cls.classes.B) + sess = create_session() sess.add_all([ B(name='b1'), @@ -296,8 +303,11 @@ class AddEntityEquivalenceTest(_base.MappedTest, AssertsCompiledSQL): ]) sess.flush() - @testing.resolve_artifact_names def test_add_entity_equivalence(self): + A, C, B = (self.classes.A, + self.classes.C, + self.classes.B) + sess = create_session() for q in [ @@ -1692,8 +1702,11 @@ class TestOverlyEagerEquivalentCols(_base.MappedTest): Column('data', String(50)) ) - @testing.resolve_artifact_names def test_equivs(self): + base, sub2, sub1 = (self.tables.base, + self.tables.sub2, + self.tables.sub1) + class Base(_base.ComparableEntity): pass class Sub1(_base.ComparableEntity): diff --git a/test/orm/test_generative.py b/test/orm/test_generative.py index 79da5fc7a0..9eb90d4e91 100644 --- a/test/orm/test_generative.py +++ b/test/orm/test_generative.py @@ -27,22 +27,25 @@ class GenerativeQueryTest(_base.MappedTest): return dict(foo=foo_data) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + foo = cls.tables.foo + class Foo(_base.BasicEntity): pass mapper(Foo, foo) - @testing.resolve_artifact_names def test_selectby(self): + Foo = self.classes.Foo + res = create_session().query(Foo).filter_by(range=5) assert res.order_by(Foo.bar)[0].bar == 5 assert res.order_by(sa.desc(Foo.bar))[0].bar == 95 @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_slice(self): + Foo = self.classes.Foo + sess = create_session() query = sess.query(Foo).order_by(Foo.id) orig = query.all() @@ -65,8 +68,9 @@ class GenerativeQueryTest(_base.MappedTest): assert query[10:20][5] == orig[10:20][5] @testing.uses_deprecated('Call to deprecated function apply_max') - @testing.resolve_artifact_names def test_aggregate(self): + foo, Foo = self.tables.foo, self.classes.Foo + sess = create_session() query = sess.query(Foo) assert query.count() == 100 @@ -84,23 +88,26 @@ class GenerativeQueryTest(_base.MappedTest): @testing.fails_if(lambda:testing.against('mysql+mysqldb') and testing.db.dialect.dbapi.version_info[:4] == (1, 2, 1, 'gamma'), "unknown incompatibility") - @testing.resolve_artifact_names def test_aggregate_1(self): + foo = self.tables.foo + query = create_session().query(func.sum(foo.c.bar)) assert query.filter(foo.c.bar<30).one() == (435,) @testing.fails_on('firebird', 'FIXME: unknown') @testing.fails_on('mssql', 'AVG produces an average as the original column type on mssql.') - @testing.resolve_artifact_names def test_aggregate_2(self): + foo = self.tables.foo + query = create_session().query(func.avg(foo.c.bar)) avg = query.filter(foo.c.bar < 30).one()[0] eq_(float(round(avg, 1)), 14.5) @testing.fails_on('mssql', 'AVG produces an average as the original column type on mssql.') - @testing.resolve_artifact_names def test_aggregate_3(self): + foo, Foo = self.tables.foo, self.classes.Foo + query = create_session().query(Foo) # Py3K @@ -117,27 +124,31 @@ class GenerativeQueryTest(_base.MappedTest): # end Py2K assert float(round(avg_o, 1)) == 14.5 - @testing.resolve_artifact_names def test_filter(self): + Foo = self.classes.Foo + query = create_session().query(Foo) assert query.count() == 100 assert query.filter(Foo.bar < 30).count() == 30 res2 = query.filter(Foo.bar < 30).filter(Foo.bar > 10) assert res2.count() == 19 - @testing.resolve_artifact_names def test_order_by(self): + Foo = self.classes.Foo + query = create_session().query(Foo) assert query.order_by(Foo.bar)[0].bar == 0 assert query.order_by(sa.desc(Foo.bar))[0].bar == 99 - @testing.resolve_artifact_names def test_offset(self): + Foo = self.classes.Foo + query = create_session().query(Foo) assert list(query.order_by(Foo.bar).offset(10))[0].bar == 10 - @testing.resolve_artifact_names def test_offset(self): + Foo = self.classes.Foo + query = create_session().query(Foo) assert len(list(query.limit(10))) == 10 @@ -146,33 +157,34 @@ class GenerativeTest2(_base.MappedTest): @classmethod def define_tables(cls, metadata): - Table('Table1', metadata, + Table('table1', metadata, Column('id', Integer, primary_key=True)) - Table('Table2', metadata, - Column('t1id', Integer, ForeignKey("Table1.id"), + Table('table2', metadata, + Column('t1id', Integer, ForeignKey("table1.id"), primary_key=True), Column('num', Integer, primary_key=True)) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + table2, table1 = cls.tables.table2, cls.tables.table1 + class Obj1(_base.BasicEntity): pass class Obj2(_base.BasicEntity): pass - mapper(Obj1, Table1) - mapper(Obj2, Table2) + mapper(Obj1, table1) + mapper(Obj2, table2) @classmethod def fixtures(cls): return dict( - Table1=(('id',), + table1=(('id',), (1,), (2,), (3,), (4,)), - Table2=(('num', 't1id'), + table2=(('num', 't1id'), (1, 1), (2, 1), (3, 1), @@ -180,16 +192,19 @@ class GenerativeTest2(_base.MappedTest): (5, 2), (6, 3))) - @testing.resolve_artifact_names def test_distinct_count(self): + table2, Obj1, table1 = (self.tables.table2, + self.classes.Obj1, + self.tables.table1) + query = create_session().query(Obj1) eq_(query.count(), 4) - res = query.filter(sa.and_(Table1.c.id == Table2.c.t1id, - Table2.c.t1id == 1)) + res = query.filter(sa.and_(table1.c.id == table2.c.t1id, + table2.c.t1id == 1)) eq_(res.count(), 3) - res = query.filter(sa.and_(Table1.c.id == Table2.c.t1id, - Table2.c.t1id == 1)).distinct() + res = query.filter(sa.and_(table1.c.id == table2.c.t1id, + table2.c.t1id == 1)).distinct() eq_(res.count(), 1) @@ -199,15 +214,22 @@ class RelationshipsTest(_fixtures.FixtureTest): run_deletes = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + addresses, Order, User, Address, orders, users = (cls.tables.addresses, + cls.classes.Order, + cls.classes.User, + cls.classes.Address, + cls.tables.orders, + cls.tables.users) + mapper(User, users, properties={ 'orders':relationship(mapper(Order, orders, properties={ 'addresses':relationship(mapper(Address, addresses))}))}) - @testing.resolve_artifact_names def test_join(self): + User, Address = self.classes.User, self.classes.Address + """Query.join""" session = create_session() @@ -215,8 +237,11 @@ class RelationshipsTest(_fixtures.FixtureTest): filter(Address.id == 1)) eq_([User(id=7)], q.all()) - @testing.resolve_artifact_names def test_outer_join(self): + Order, User, Address = (self.classes.Order, + self.classes.User, + self.classes.Address) + """Query.outerjoin""" session = create_session() @@ -225,8 +250,11 @@ class RelationshipsTest(_fixtures.FixtureTest): eq_(set([User(id=7), User(id=8), User(id=10)]), set(q.all())) - @testing.resolve_artifact_names def test_outer_join_count(self): + Order, User, Address = (self.classes.Order, + self.classes.User, + self.classes.Address) + """test the join and outerjoin functions on Query""" session = create_session() @@ -235,8 +263,14 @@ class RelationshipsTest(_fixtures.FixtureTest): filter(sa.or_(Order.id == None, Address.id == 1))) eq_(q.count(), 4) - @testing.resolve_artifact_names def test_from(self): + users, Order, User, Address, orders, addresses = (self.tables.users, + self.classes.Order, + self.classes.User, + self.classes.Address, + self.tables.orders, + self.tables.addresses) + session = create_session() sel = users.outerjoin(orders).outerjoin( @@ -259,8 +293,9 @@ class CaseSensitiveTest(_base.MappedTest): Column('NUM', Integer, primary_key=True)) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Table2, Table1 = cls.tables.Table2, cls.tables.Table1 + class Obj1(_base.BasicEntity): pass class Obj2(_base.BasicEntity): @@ -285,8 +320,11 @@ class CaseSensitiveTest(_base.MappedTest): (5, 2), (6, 3))) - @testing.resolve_artifact_names def test_distinct_count(self): + Table2, Obj1, Table1 = (self.tables.Table2, + self.classes.Obj1, + self.tables.Table1) + q = create_session(bind=testing.db).query(Obj1) assert q.count() == 4 res = q.filter(sa.and_(Table1.c.ID==Table2.c.T1ID,Table2.c.T1ID==1)) diff --git a/test/orm/test_immediate_load.py b/test/orm/test_immediate_load.py index eb62ef40e0..e809ebfe63 100644 --- a/test/orm/test_immediate_load.py +++ b/test/orm/test_immediate_load.py @@ -10,8 +10,12 @@ class ImmediateTest(_fixtures.FixtureTest): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def test_basic_option(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties={ 'addresses':relationship(Address) @@ -29,8 +33,12 @@ class ImmediateTest(_fixtures.FixtureTest): ) - @testing.resolve_artifact_names def test_basic(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties={ 'addresses':relationship(Address, lazy='immediate') diff --git a/test/orm/test_joins.py b/test/orm/test_joins.py index 47669d8d5c..acbf36a578 100644 --- a/test/orm/test_joins.py +++ b/test/orm/test_joins.py @@ -103,8 +103,15 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): Column('person_id', Integer, ForeignKey('people.person_id'))) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): + paperwork, people, companies, boss, managers, machines, engineers = (cls.tables.paperwork, + cls.tables.people, + cls.tables.companies, + cls.tables.boss, + cls.tables.managers, + cls.tables.machines, + cls.tables.engineers) + class Company(_fixtures.Base): pass class Person(_fixtures.Base): @@ -141,8 +148,9 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): mapper(Boss, boss, inherits=Manager, polymorphic_identity='boss') mapper(Paperwork, paperwork) - @testing.resolve_artifact_names def test_single_prop(self): + Company = self.classes.Company + sess = create_session() self.assert_compile( @@ -152,8 +160,9 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): , use_default_dialect = True ) - @testing.resolve_artifact_names def test_force_via_select_from(self): + Company, Engineer = self.classes.Company, self.classes.Engineer + sess = create_session() self.assert_compile( @@ -179,8 +188,9 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): ) - @testing.resolve_artifact_names def test_single_prop_of_type(self): + Company, Engineer = self.classes.Company, self.classes.Engineer + sess = create_session() self.assert_compile( @@ -197,8 +207,11 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): , use_default_dialect = True ) - @testing.resolve_artifact_names def test_prop_with_polymorphic(self): + Person, Manager, Paperwork = (self.classes.Person, + self.classes.Manager, + self.classes.Paperwork) + sess = create_session() self.assert_compile( @@ -231,8 +244,9 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): , use_default_dialect=True ) - @testing.resolve_artifact_names def test_explicit_polymorphic_join(self): + Company, Engineer = self.classes.Company, self.classes.Engineer + sess = create_session() self.assert_compile( @@ -271,8 +285,14 @@ class InheritedJoinTest(_base.MappedTest, AssertsCompiledSQL): , use_default_dialect=True ) - @testing.resolve_artifact_names def test_multiple_adaption(self): + people, Company, Machine, engineers, machines, Engineer = (self.tables.people, + self.classes.Company, + self.classes.Machine, + self.tables.engineers, + self.tables.machines, + self.classes.Engineer) + """test that multiple filter() adapters get chained together " and work correctly within a multiple-entry join().""" @@ -1198,8 +1218,12 @@ class MultiplePathTest(_base.MappedTest, AssertsCompiledSQL): Column('t2id', Integer, ForeignKey('t2.id')) ) - @testing.resolve_artifact_names def test_basic(self): + t2, t1t2_1, t1t2_2, t1 = (self.tables.t2, + self.tables.t1t2_1, + self.tables.t1t2_2, + self.tables.t1) + class T1(object):pass class T2(object):pass @@ -1241,8 +1265,11 @@ class SelfRefMixedTest(_base.MappedTest, AssertsCompiledSQL): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): + nodes, assoc_table, sub_table = (cls.tables.nodes, + cls.tables.assoc_table, + cls.tables.sub_table) + class Node(Base): pass @@ -1261,8 +1288,9 @@ class SelfRefMixedTest(_base.MappedTest, AssertsCompiledSQL): }) mapper(Sub, sub_table) - @testing.resolve_artifact_names def test_o2m_aliased_plus_o2m(self): + Node, Sub = self.classes.Node, self.classes.Sub + sess = create_session() n1 = aliased(Node) @@ -1280,8 +1308,9 @@ class SelfRefMixedTest(_base.MappedTest, AssertsCompiledSQL): "JOIN sub_table ON nodes.id = sub_table.node_id" ) - @testing.resolve_artifact_names def test_m2m_aliased_plus_o2m(self): + Node, Sub = self.classes.Node, self.classes.Sub + sess = create_session() n1 = aliased(Node) @@ -1321,8 +1350,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): self.children.append(node) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Node, nodes = cls.classes.Node, cls.tables.nodes + mapper(Node, nodes, properties={ 'children':relationship(Node, lazy='select', join_depth=3, backref=backref('parent', remote_side=[nodes.c.id]) @@ -1330,8 +1360,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): }) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Node = cls.classes.Node + sess = create_session() n1 = Node(data='n1') n1.append(Node(data='n11')) @@ -1344,8 +1375,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): sess.flush() sess.close() - @testing.resolve_artifact_names def test_join(self): + Node = self.classes.Node + sess = create_session() node = sess.query(Node).join('children', aliased=True).filter_by(data='n122').first() @@ -1362,8 +1394,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): join('parent', aliased=True, from_joinpoint=True).filter_by(data='n1').first() assert node.data == 'n122' - @testing.resolve_artifact_names def test_string_or_prop_aliased(self): + Node = self.classes.Node + """test that join('foo') behaves the same as join(Cls.foo) in a self referential scenario. @@ -1411,8 +1444,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): use_default_dialect=True ) - @testing.resolve_artifact_names def test_from_self_inside_excludes_outside(self): + Node = self.classes.Node + """test the propagation of aliased() from inside to outside on a from_self().. """ @@ -1467,8 +1501,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): use_default_dialect=True ) - @testing.resolve_artifact_names def test_explicit_join(self): + Node = self.classes.Node + sess = create_session() n1 = aliased(Node) @@ -1531,8 +1566,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): filter(and_(Node.data=='n122', n1.data=='n12', n2.data=='n1')).values(Node.data, n1.data, n2.data)), [('n122', 'n12', 'n1')]) - @testing.resolve_artifact_names def test_join_to_nonaliased(self): + Node = self.classes.Node + sess = create_session() n1 = aliased(Node) @@ -1550,8 +1586,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): ) - @testing.resolve_artifact_names def test_multiple_explicit_entities(self): + Node = self.classes.Node + sess = create_session() parent = aliased(Node) @@ -1605,16 +1642,18 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): ) - @testing.resolve_artifact_names def test_any(self): + Node = self.classes.Node + sess = create_session() eq_(sess.query(Node).filter(Node.children.any(Node.data=='n1')).all(), []) eq_(sess.query(Node).filter(Node.children.any(Node.data=='n12')).all(), [Node(data='n1')]) eq_(sess.query(Node).filter(~Node.children.any()).order_by(Node.id).all(), [Node(data='n11'), Node(data='n13'),Node(data='n121'),Node(data='n122'),Node(data='n123'),]) - @testing.resolve_artifact_names def test_has(self): + Node = self.classes.Node + sess = create_session() eq_(sess.query(Node).filter(Node.parent.has(Node.data=='n12')).order_by(Node.id).all(), @@ -1622,8 +1661,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): eq_(sess.query(Node).filter(Node.parent.has(Node.data=='n122')).all(), []) eq_(sess.query(Node).filter(~Node.parent.has()).all(), [Node(data='n1')]) - @testing.resolve_artifact_names def test_contains(self): + Node = self.classes.Node + sess = create_session() n122 = sess.query(Node).filter(Node.data=='n122').one() @@ -1632,8 +1672,9 @@ class SelfReferentialTest(_base.MappedTest, AssertsCompiledSQL): n13 = sess.query(Node).filter(Node.data=='n13').one() eq_(sess.query(Node).filter(Node.children.contains(n13)).all(), [Node(data='n1')]) - @testing.resolve_artifact_names def test_eq_ne(self): + Node = self.classes.Node + sess = create_session() n12 = sess.query(Node).filter(Node.data=='n12').one() @@ -1663,8 +1704,11 @@ class SelfReferentialM2MTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def insert_data(cls): + Node, nodes, node_to_nodes = (cls.classes.Node, + cls.tables.nodes, + cls.tables.node_to_nodes) + mapper(Node, nodes, properties={ 'children':relationship(Node, lazy='select', secondary=node_to_nodes, @@ -1692,14 +1736,16 @@ class SelfReferentialM2MTest(_base.MappedTest): sess.flush() sess.close() - @testing.resolve_artifact_names def test_any(self): + Node = self.classes.Node + sess = create_session() eq_(sess.query(Node).filter(Node.children.any(Node.data == 'n3' )).all(), [Node(data='n1'), Node(data='n2')]) - @testing.resolve_artifact_names def test_contains(self): + Node = self.classes.Node + sess = create_session() n4 = sess.query(Node).filter_by(data='n4').one() @@ -1709,8 +1755,9 @@ class SelfReferentialM2MTest(_base.MappedTest): [Node(data='n2'), Node(data='n4'), Node(data='n5'), Node(data='n6'), Node(data='n7')]) - @testing.resolve_artifact_names def test_explicit_join(self): + Node = self.classes.Node + sess = create_session() n1 = aliased(Node) diff --git a/test/orm/test_lazy_relations.py b/test/orm/test_lazy_relations.py index 3208d060e0..8766dd6173 100644 --- a/test/orm/test_lazy_relations.py +++ b/test/orm/test_lazy_relations.py @@ -19,8 +19,12 @@ class LazyTest(_fixtures.FixtureTest): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def test_basic(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses), lazy='select') }) @@ -28,8 +32,12 @@ class LazyTest(_fixtures.FixtureTest): q = sess.query(User) assert [User(id=7, addresses=[Address(id=1, email_address='jack@bean.com')])] == q.filter(users.c.id == 7).all() - @testing.resolve_artifact_names def test_needs_parent(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test the error raised when parent object is not bound.""" mapper(User, users, properties={ @@ -41,8 +49,12 @@ class LazyTest(_fixtures.FixtureTest): sess.expunge(u) assert_raises(orm_exc.DetachedInstanceError, getattr, u, 'addresses') - @testing.resolve_artifact_names def test_orderby(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses':relationship(mapper(Address, addresses), lazy='select', order_by=addresses.c.email_address), }) @@ -62,8 +74,12 @@ class LazyTest(_fixtures.FixtureTest): User(id=10, addresses=[]) ] == q.all() - @testing.resolve_artifact_names def test_orderby_secondary(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """tests that a regular mapper select on a single table can order by a relationship to a second table""" mapper(Address, addresses) @@ -87,8 +103,12 @@ class LazyTest(_fixtures.FixtureTest): ]), ] == l - @testing.resolve_artifact_names def test_orderby_desc(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties = dict( @@ -110,8 +130,12 @@ class LazyTest(_fixtures.FixtureTest): User(id=10, addresses=[]) ] == sess.query(User).all() - @testing.resolve_artifact_names def test_no_orphan(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test that a lazily loaded child object is not marked as an orphan""" mapper(User, users, properties={ @@ -124,8 +148,17 @@ class LazyTest(_fixtures.FixtureTest): assert getattr(User, 'addresses').hasparent(attributes.instance_state(user.addresses[0]), optimistic=True) assert not sa.orm.class_mapper(Address)._is_orphan(attributes.instance_state(user.addresses[0])) - @testing.resolve_artifact_names def test_limit(self): + users, items, order_items, orders, Item, User, Address, Order, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """test limit operations combined with lazy-load relationships.""" mapper(Item, items) @@ -147,8 +180,17 @@ class LazyTest(_fixtures.FixtureTest): l = q.limit(2).offset(1).all() assert self.static.user_all_result[1:3] == l - @testing.resolve_artifact_names def test_distinct(self): + users, items, order_items, orders, Item, User, Address, Order, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + mapper(Item, items) mapper(Order, orders, properties={ 'items':relationship(Item, secondary=order_items, lazy='select') @@ -167,8 +209,12 @@ class LazyTest(_fixtures.FixtureTest): l = q.filter(s.c.u2_id==User.id).order_by(User.id).distinct().all() eq_(self.static.user_all_result, l) - @testing.resolve_artifact_names def test_uselist_false_warning(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + """test that multiple rows received by a uselist=False raises a warning.""" mapper(User, users, properties={ @@ -179,8 +225,12 @@ class LazyTest(_fixtures.FixtureTest): u1 = s.query(User).filter(User.id==7).one() assert_raises(sa.exc.SAWarning, getattr, u1, 'order') - @testing.resolve_artifact_names def test_one_to_many_scalar(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties = dict( address = relationship(mapper(Address, addresses), lazy='select', uselist=False) )) @@ -188,8 +238,12 @@ class LazyTest(_fixtures.FixtureTest): l = q.filter(users.c.id == 7).all() assert [User(id=7, address=Address(id=1))] == l - @testing.resolve_artifact_names def test_many_to_one_binds(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses, primary_key=[addresses.c.user_id, addresses.c.email_address]) mapper(User, users, properties = dict( @@ -209,8 +263,14 @@ class LazyTest(_fixtures.FixtureTest): ) - @testing.resolve_artifact_names def test_double(self): + users, orders, User, Address, Order, addresses = (self.tables.users, + self.tables.orders, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """tests lazy loading with two relationships simulatneously, from the same table, using aliases. """ openorders = sa.alias(orders, 'openorders') @@ -257,8 +317,13 @@ class LazyTest(_fixtures.FixtureTest): assert [Order(id=1), Order(id=5)] == create_session().query(closed_mapper).with_parent(user, property='closed_orders').all() assert [Order(id=3)] == create_session().query(open_mapper).with_parent(user, property='open_orders').all() - @testing.resolve_artifact_names def test_many_to_many(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( @@ -270,8 +335,12 @@ class LazyTest(_fixtures.FixtureTest): assert self.static.item_keyword_result[0:2] == q.join('keywords').filter(keywords.c.name == 'red').all() - @testing.resolve_artifact_names def test_uses_get(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """test that a simple many-to-one lazyload optimizes to use query.get().""" for pj in ( @@ -297,8 +366,9 @@ class LazyTest(_fixtures.FixtureTest): self.assert_sql_count(testing.db, go, 0) sa.orm.clear_mappers() - @testing.resolve_artifact_names def test_uses_get_compatible_types(self): + User, Address = self.classes.User, self.classes.Address + """test the use_get optimization with compatible but non-identical types""" class IntDecorator(TypeDecorator): @@ -346,8 +416,12 @@ class LazyTest(_fixtures.FixtureTest): self.assert_sql_count(testing.db, go, 0) sa.orm.clear_mappers() - @testing.resolve_artifact_names def test_many_to_one(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(Address, addresses, properties = dict( user = relationship(mapper(User, users), lazy='select') )) @@ -361,8 +435,12 @@ class LazyTest(_fixtures.FixtureTest): assert a.user is u1 - @testing.resolve_artifact_names def test_backrefs_dont_lazyload(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user') }) @@ -401,8 +479,12 @@ class M2OGetTest(_fixtures.FixtureTest): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def test_m2o_noload(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test that a NULL foreign key doesn't trigger a lazy load""" mapper(User, users) @@ -439,8 +521,9 @@ class CorrelatedTest(_base.MappedTest): Column('user_id', Integer, ForeignKey('user_t.id'))) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + stuff, user_t = cls.tables.stuff, cls.tables.user_t + user_t.insert().execute( {'id':1, 'name':'user1'}, {'id':2, 'name':'user2'}, @@ -453,8 +536,9 @@ class CorrelatedTest(_base.MappedTest): {'id':4, 'user_id':2, 'date':datetime.date(2008, 1, 15)}, {'id':5, 'user_id':3, 'date':datetime.date(2007, 6, 15)}) - @testing.resolve_artifact_names def test_correlated_lazyload(self): + stuff, user_t = self.tables.stuff, self.tables.user_t + class User(_base.ComparableEntity): pass diff --git a/test/orm/test_legacy_mutable.py b/test/orm/test_legacy_mutable.py index dee3f193c4..002d288a26 100644 --- a/test/orm/test_legacy_mutable.py +++ b/test/orm/test_legacy_mutable.py @@ -33,12 +33,14 @@ class MutableTypesTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + mutable_t, Foo = cls.tables.mutable_t, cls.classes.Foo + mapper(Foo, mutable_t) - @testing.resolve_artifact_names def test_modified_status(self): + Foo = self.classes.Foo + f1 = Foo(data = pickleable.Bar(4,5)) session = Session() @@ -53,8 +55,9 @@ class MutableTypesTest(_base.MappedTest): assert f2 in session.dirty assert 'data' not in sa.orm.attributes.instance_state(f2).unmodified - @testing.resolve_artifact_names def test_mutations_persisted(self): + Foo = self.classes.Foo + f1 = Foo(data = pickleable.Bar(4,5)) session = Session() @@ -73,8 +76,9 @@ class MutableTypesTest(_base.MappedTest): ne_(f3.data,f1.data) eq_(f3.data, pickleable.Bar(4, 19)) - @testing.resolve_artifact_names def test_no_unnecessary_update(self): + Foo = self.classes.Foo + f1 = Foo(data = pickleable.Bar(4,5), val = u'hi') session = Session() @@ -96,8 +100,9 @@ class MutableTypesTest(_base.MappedTest): "WHERE mutable_t.id = :mutable_t_id", {'mutable_t_id': f1.id, 'val': u'hi', 'data':f1.data})]) - @testing.resolve_artifact_names def test_mutated_state_resurrected(self): + Foo = self.classes.Foo + f1 = Foo(data = pickleable.Bar(4,5), val = u'hi') session = Session() @@ -114,8 +119,9 @@ class MutableTypesTest(_base.MappedTest): assert session.query(Foo).one().data == pickleable.Bar(4, 19) - @testing.resolve_artifact_names def test_mutated_plus_scalar_state_change_resurrected(self): + Foo = self.classes.Foo + """test that a non-mutable attribute event subsequent to a mutable event prevents the object from falling into resurrected state. @@ -138,8 +144,9 @@ class MutableTypesTest(_base.MappedTest): [('some new val', )] ) - @testing.resolve_artifact_names def test_non_mutated_state_not_resurrected(self): + Foo = self.classes.Foo + f1 = Foo(data = pickleable.Bar(4,5)) session = Session() @@ -155,8 +162,9 @@ class MutableTypesTest(_base.MappedTest): f1 = session.query(Foo).first() assert not attributes.instance_state(f1).modified - @testing.resolve_artifact_names def test_scalar_no_net_change_no_update(self): + Foo = self.classes.Foo + """Test that a no-net-change on a scalar attribute event doesn't cause an UPDATE for a mutable state. @@ -173,8 +181,9 @@ class MutableTypesTest(_base.MappedTest): f1.val = u'hi' self.sql_count_(0, session.commit) - @testing.resolve_artifact_names def test_expire_attribute_set(self): + Foo = self.classes.Foo + """test no SELECT emitted when assigning to an expired mutable attribute. @@ -193,8 +202,9 @@ class MutableTypesTest(_base.MappedTest): eq_(f1.data.x, 10) - @testing.resolve_artifact_names def test_expire_mutate(self): + Foo = self.classes.Foo + """test mutations are detected on an expired mutable attribute.""" @@ -211,8 +221,9 @@ class MutableTypesTest(_base.MappedTest): eq_(f1.data.x, 10) - @testing.resolve_artifact_names def test_deferred_attribute_set(self): + mutable_t, Foo = self.tables.mutable_t, self.classes.Foo + """test no SELECT emitted when assigning to a deferred mutable attribute. @@ -237,8 +248,9 @@ class MutableTypesTest(_base.MappedTest): eq_(f1.data.x, 10) - @testing.resolve_artifact_names def test_deferred_mutate(self): + mutable_t, Foo = self.tables.mutable_t, self.classes.Foo + """test mutations are detected on a deferred mutable attribute.""" @@ -281,12 +293,14 @@ class PickledDictsTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + mutable_t, Foo = cls.tables.mutable_t, cls.classes.Foo + mapper(Foo, mutable_t) - @testing.resolve_artifact_names def test_dicts(self): + Foo = self.classes.Foo + """Dictionaries may not pickle the same way twice.""" f1 = Foo() diff --git a/test/orm/test_manytomany.py b/test/orm/test_manytomany.py index 9764ed684a..2bd1cd6f6e 100644 --- a/test/orm/test_manytomany.py +++ b/test/orm/test_manytomany.py @@ -81,8 +81,13 @@ class M2MTest(_base.MappedTest): repr(self.inputs), repr(self.outputs))) - @testing.resolve_artifact_names def test_error(self): + place, Transition, place_input, Place, transition = (self.tables.place, + self.classes.Transition, + self.tables.place_input, + self.classes.Place, + self.tables.transition) + mapper(Place, place, properties={ 'transitions':relationship(Transition, secondary=place_input, backref='places') }) @@ -92,8 +97,11 @@ class M2MTest(_base.MappedTest): assert_raises_message(sa.exc.ArgumentError, "Error creating backref", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_circular(self): + place, Place, place_place = (self.tables.place, + self.classes.Place, + self.tables.place_place) + """test a many-to-many relationship from a table to itself.""" mapper(Place, place, properties={ @@ -143,8 +151,11 @@ class M2MTest(_base.MappedTest): [sess.delete(p) for p in p1,p2,p3,p4,p5,p6,p7] sess.flush() - @testing.resolve_artifact_names def test_circular_mutation(self): + place, Place, place_place = (self.tables.place, + self.classes.Place, + self.tables.place_place) + """Test that a mutation in a self-ref m2m of both sides succeeds.""" mapper(Place, place, properties={ @@ -171,8 +182,16 @@ class M2MTest(_base.MappedTest): assert p2 in p1.parent_places - @testing.resolve_artifact_names def test_double(self): + place_input, transition, Transition, PlaceThingy, place, place_thingy, Place, place_output = (self.tables.place_input, + self.tables.transition, + self.classes.Transition, + self.classes.PlaceThingy, + self.tables.place, + self.tables.place_thingy, + self.classes.Place, + self.tables.place_output) + """test that a mapper can have two eager relationships to the same table, via two different association tables. aliases are required.""" @@ -202,8 +221,14 @@ class M2MTest(_base.MappedTest): 'outputs': (Place, [{'name':'place2'}, {'name':'place3'}]) }) - @testing.resolve_artifact_names def test_bidirectional(self): + place_input, transition, Transition, Place, place, place_output = (self.tables.place_input, + self.tables.transition, + self.classes.Transition, + self.classes.Place, + self.tables.place, + self.tables.place_output) + """tests a many-to-many backrefs""" Place.mapper = mapper(Place, place) Transition.mapper = mapper(Transition, transition, properties = dict( @@ -234,8 +259,13 @@ class M2MTest(_base.MappedTest): self.assert_result([p2], Place, {'inputs': (Transition, [{'name':'transition1'},{'name':'transition2'}])}) @testing.requires.sane_multi_rowcount - @testing.resolve_artifact_names def test_stale_conditions(self): + Place, Transition, place_input, place, transition = (self.classes.Place, + self.classes.Transition, + self.tables.place_input, + self.tables.place, + self.tables.transition) + mapper(Place, place, properties={ 'transitions':relationship(Transition, secondary=place_input, passive_updates=False) @@ -298,8 +328,13 @@ class M2MTest2(_base.MappedTest): def __init__(self, name=''): self.name = name - @testing.resolve_artifact_names def test_circular(self): + course, enroll, Student, student, Course = (self.tables.course, + self.tables.enroll, + self.classes.Student, + self.tables.student, + self.classes.Course) + mapper(Student, student) mapper(Course, course, properties={ @@ -324,8 +359,13 @@ class M2MTest2(_base.MappedTest): del s.courses[1] self.assert_(len(s.courses) == 2) - @testing.resolve_artifact_names def test_dupliates_raise(self): + course, enroll, Student, student, Course = (self.tables.course, + self.tables.enroll, + self.classes.Student, + self.tables.student, + self.classes.Course) + """test constraint error is raised for dupe entries in a list""" mapper(Student, student) @@ -340,8 +380,13 @@ class M2MTest2(_base.MappedTest): sess.add(s1) assert_raises(sa.exc.DBAPIError, sess.flush) - @testing.resolve_artifact_names def test_delete(self): + course, enroll, Student, student, Course = (self.tables.course, + self.tables.enroll, + self.classes.Student, + self.tables.student, + self.classes.Course) + """A many-to-many table gets cleared out with deletion from the backref side""" mapper(Student, student) @@ -388,8 +433,13 @@ class M2MTest3(_base.MappedTest): Column('a1', Integer, ForeignKey('a.a1')), Column('b2', sa.Boolean)) - @testing.resolve_artifact_names def test_basic(self): + a, c, b, c2a1, c2a2 = (self.tables.a, + self.tables.c, + self.tables.b, + self.tables.c2a1, + self.tables.c2a2) + class C(object):pass class A(object):pass class B(object):pass @@ -428,8 +478,11 @@ class M2MTest4(_base.MappedTest): Column('t2', Integer, ForeignKey('table2.col1')), ) - @testing.resolve_artifact_names def test_delete_parent(self): + table2, table3, table1 = (self.tables.table2, + self.tables.table3, + self.tables.table1) + class A(_base.ComparableEntity): pass class B(_base.ComparableEntity): diff --git a/test/orm/test_mapper.py b/test/orm/test_mapper.py index 552b631c24..3edd72a4ce 100644 --- a/test/orm/test_mapper.py +++ b/test/orm/test_mapper.py @@ -17,8 +17,12 @@ from test.lib.assertsql import CompiledSQL class MapperTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_prop_shadow(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A backref name may not shadow an existing property name.""" mapper(Address, addresses) @@ -28,8 +32,9 @@ class MapperTest(_fixtures.FixtureTest): }) assert_raises(sa.exc.ArgumentError, sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_update_attr_keys(self): + User, users = self.classes.User, self.tables.users + """test that update()/insert() use the correct key when given InstrumentedAttributes.""" mapper(User, users, properties={ @@ -42,8 +47,9 @@ class MapperTest(_fixtures.FixtureTest): users.update().values({User.foobar:User.foobar + 'foo'}).execute() eq_(sa.select([User.foobar]).where(User.foobar=='name1foo').execute().fetchall(), [('name1foo',)]) - @testing.resolve_artifact_names def test_utils(self): + users = self.tables.users + from sqlalchemy.orm.util import _is_mapped_class, _is_aliased_class class Foo(object): @@ -75,21 +81,24 @@ class MapperTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_prop_accessor(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) assert_raises(NotImplementedError, getattr, sa.orm.class_mapper(User), 'properties') - @testing.resolve_artifact_names def test_bad_cascade(self): + addresses, Address = self.tables.addresses, self.classes.Address + mapper(Address, addresses) assert_raises(sa.exc.ArgumentError, relationship, Address, cascade="fake, all, delete-orphan") - @testing.resolve_artifact_names def test_friendly_attribute_str_on_uncompiled_boom(self): + User, users = self.classes.User, self.tables.users + def boom(): raise Exception("it broke") mapper(User, users, properties={ @@ -100,8 +109,11 @@ class MapperTest(_fixtures.FixtureTest): # cause a compile. eq_(str(User.addresses), "User.addresses") - @testing.resolve_artifact_names def test_exceptions_sticky(self): + Address, addresses, User = (self.classes.Address, + self.tables.addresses, + self.classes.User) + """test preservation of mapper compile errors raised during hasattr(), as well as for redundant mapper compile calls. Test that repeated calls don't stack up error messages. @@ -126,8 +138,9 @@ class MapperTest(_fixtures.FixtureTest): "'test.orm._fixtures.User' is not mapped$" , configure_mappers) - @testing.resolve_artifact_names def test_column_prefix(self): + users, User = self.tables.users, self.classes.User + mapper(User, users, column_prefix='_', properties={ 'user_name': synonym('_name') }) @@ -139,18 +152,24 @@ class MapperTest(_fixtures.FixtureTest): u2 = s.query(User).filter_by(user_name='jack').one() assert u is u2 - @testing.resolve_artifact_names def test_no_pks_1(self): + User, users = self.classes.User, self.tables.users + s = sa.select([users.c.name]).alias('foo') assert_raises(sa.exc.ArgumentError, mapper, User, s) - @testing.resolve_artifact_names def test_no_pks_2(self): + User, users = self.classes.User, self.tables.users + s = sa.select([users.c.name]).alias() assert_raises(sa.exc.ArgumentError, mapper, User, s) - @testing.resolve_artifact_names def test_reconfigure_on_other_mapper(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """A configure trigger on an already-configured mapper still triggers a check against all mappers.""" mapper(User, users) @@ -166,14 +185,16 @@ class MapperTest(_fixtures.FixtureTest): assert User.addresses assert sa.orm.mapperlib._new_mappers is False - @testing.resolve_artifact_names def test_configure_on_session(self): + User, users = self.classes.User, self.tables.users + m = mapper(User, users) session = create_session() session.connection(m) - @testing.resolve_artifact_names def test_incomplete_columns(self): + addresses, Address = self.tables.addresses, self.classes.Address + """Loading from a select which does not contain all columns""" mapper(Address, addresses) s = create_session() @@ -185,15 +206,19 @@ class MapperTest(_fixtures.FixtureTest): assert 'email_addres' not in a.__dict__ eq_(a.email_address, 'jack@bean.com') - @testing.resolve_artifact_names def test_column_not_present(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + assert_raises_message(sa.exc.ArgumentError, "not represented in the mapper's table", mapper, User, users, properties={'foo' : addresses.c.user_id}) - @testing.resolve_artifact_names def test_constructor_exc(self): + users, addresses = self.tables.users, self.tables.addresses + """TypeError is raised for illegal constructor args, whether or not explicit __init__ is present [ticket:908].""" @@ -208,36 +233,54 @@ class MapperTest(_fixtures.FixtureTest): assert_raises(TypeError, Foo, x=5) assert_raises(TypeError, Bar, x=5) - @testing.resolve_artifact_names def test_props(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + m = mapper(User, users, properties = { 'addresses' : relationship(mapper(Address, addresses)) }) assert User.addresses.property is m.get_property('addresses') - @testing.resolve_artifact_names def test_configure_on_prop_1(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses' : relationship(mapper(Address, addresses)) }) User.addresses.any(Address.email_address=='foo@bar.com') - @testing.resolve_artifact_names def test_configure_on_prop_2(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses' : relationship(mapper(Address, addresses)) }) eq_(str(User.id == 3), str(users.c.id==3)) - @testing.resolve_artifact_names def test_configure_on_prop_3(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + class Foo(User):pass mapper(User, users) mapper(Foo, addresses, inherits=User) assert getattr(Foo().__class__, 'name').impl is not None - @testing.resolve_artifact_names def test_deferred_subclass_attribute_instrument(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + class Foo(User):pass mapper(User, users) configure_mappers() @@ -245,22 +288,28 @@ class MapperTest(_fixtures.FixtureTest): assert getattr(Foo().__class__, 'name').impl is not None - @testing.resolve_artifact_names def test_configure_on_get_props_1(self): + User, users = self.classes.User, self.tables.users + m =mapper(User, users) assert not m.configured assert list(m.iterate_properties) assert m.configured - @testing.resolve_artifact_names def test_configure_on_get_props_2(self): + User, users = self.classes.User, self.tables.users + m= mapper(User, users) assert not m.configured assert m.get_property('name') assert m.configured - @testing.resolve_artifact_names def test_configure_on_get_props_3(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + m= mapper(User, users) assert not m.configured configure_mappers() @@ -270,8 +319,11 @@ class MapperTest(_fixtures.FixtureTest): }) assert m.get_property('addresses') - @testing.resolve_artifact_names def test_add_property(self): + users, addresses, Address = (self.tables.users, + self.tables.addresses, + self.classes.Address) + assert_col = [] class User(_base.ComparableEntity): @@ -332,8 +384,9 @@ class MapperTest(_fixtures.FixtureTest): sess.flush() sess.rollback() - @testing.resolve_artifact_names def test_replace_property(self): + users, User = self.tables.users, self.classes.User + m = mapper(User, users) m.add_property('_name',users.c.name) m.add_property('name', synonym('_name')) @@ -357,8 +410,11 @@ class MapperTest(_fixtures.FixtureTest): u.name = 'jacko' assert m._columntoproperty[users.c.name] is m.get_property('_name') - @testing.resolve_artifact_names def test_synonym_replaces_backref(self): + addresses, users, User = (self.tables.addresses, + self.tables.users, + self.classes.User) + assert_calls = [] class Address(object): def _get_user(self): @@ -390,7 +446,6 @@ class MapperTest(_fixtures.FixtureTest): assert a1.user is u2 eq_(assert_calls, ["set", "get"]) - @testing.resolve_artifact_names def test_self_ref_synonym(self): t = Table('nodes', MetaData(), Column('id', Integer, primary_key=True, test_needs_autoincrement=True), @@ -412,8 +467,12 @@ class MapperTest(_fixtures.FixtureTest): assert n1.children[0] is n1._children[0] is n2 eq_(str(Node.parent == n2), ":param_1 = nodes.parent_id") - @testing.resolve_artifact_names def test_illegal_non_primary(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users) mapper(Address, addresses) mapper(User, users, non_primary=True, properties={ @@ -426,15 +485,17 @@ class MapperTest(_fixtures.FixtureTest): configure_mappers ) - @testing.resolve_artifact_names def test_illegal_non_primary_2(self): + User, users = self.classes.User, self.tables.users + assert_raises_message( sa.exc.InvalidRequestError, "Configure a primary mapper first", mapper, User, users, non_primary=True) - @testing.resolve_artifact_names def test_illegal_non_primary_3(self): + users, addresses = self.tables.users, self.tables.addresses + class Base(object): pass class Sub(Base): @@ -445,7 +506,6 @@ class MapperTest(_fixtures.FixtureTest): mapper, Sub, addresses, non_primary=True ) - @testing.resolve_artifact_names def test_prop_filters(self): t = Table('person', MetaData(), Column('id', Integer, primary_key=True, @@ -537,7 +597,6 @@ class MapperTest(_fixtures.FixtureTest): Foo, inherits=Person, polymorphic_identity='foo', exclude_properties=('type', ), ) - @testing.resolve_artifact_names @testing.provide_metadata def test_prop_filters_defaults(self): t = Table('t', metadata, @@ -553,8 +612,11 @@ class MapperTest(_fixtures.FixtureTest): s.commit() - @testing.resolve_artifact_names def test_mapping_to_join_raises(self): + addresses, users, User = (self.tables.addresses, + self.tables.users, + self.classes.User) + """Test implicit merging of two cols raises.""" usersaddresses = sa.join(users, addresses, @@ -565,8 +627,11 @@ class MapperTest(_fixtures.FixtureTest): mapper, User, usersaddresses, primary_key=[users.c.id] ) - @testing.resolve_artifact_names def test_mapping_to_join_explicit_prop(self): + User, addresses, users = (self.classes.User, + self.tables.addresses, + self.tables.users) + """Mapping to a join""" usersaddresses = sa.join(users, addresses, users.c.id @@ -577,8 +642,11 @@ class MapperTest(_fixtures.FixtureTest): l = create_session().query(User).order_by(users.c.id).all() eq_(l, self.static.user_result[:3]) - @testing.resolve_artifact_names def test_mapping_to_join_exclude_prop(self): + User, addresses, users = (self.classes.User, + self.tables.addresses, + self.tables.users) + """Mapping to a join""" usersaddresses = sa.join(users, addresses, users.c.id @@ -589,8 +657,11 @@ class MapperTest(_fixtures.FixtureTest): l = create_session().query(User).order_by(users.c.id).all() eq_(l, self.static.user_result[:3]) - @testing.resolve_artifact_names def test_mapping_to_join_no_pk(self): + email_bounces, addresses, Address = (self.tables.email_bounces, + self.tables.addresses, + self.classes.Address) + m = mapper(Address, addresses.join(email_bounces), properties={'id':[addresses.c.id, email_bounces.c.id]} @@ -607,8 +678,11 @@ class MapperTest(_fixtures.FixtureTest): eq_(addresses.count().scalar(), 6) eq_(email_bounces.count().scalar(), 5) - @testing.resolve_artifact_names def test_mapping_to_outerjoin(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + """Mapping to an outer join with a nullable composite primary key.""" @@ -628,8 +702,11 @@ class MapperTest(_fixtures.FixtureTest): User(id=9, address_id=5), User(id=10, address_id=None)]) - @testing.resolve_artifact_names def test_mapping_to_outerjoin_no_partial_pks(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + """test the allow_partial_pks=False flag.""" @@ -650,8 +727,14 @@ class MapperTest(_fixtures.FixtureTest): User(id=9, address_id=5), None]) - @testing.resolve_artifact_names def test_scalar_pk_arg(self): + users, Keyword, items, Item, User, keywords = (self.tables.users, + self.classes.Keyword, + self.tables.items, + self.classes.Item, + self.classes.User, + self.tables.keywords) + m1 = mapper(Item, items, primary_key=[items.c.id]) m2 = mapper(Keyword, keywords, primary_key=keywords.c.id) m3 = mapper(User, users, primary_key=(users.c.id,)) @@ -661,8 +744,15 @@ class MapperTest(_fixtures.FixtureTest): assert m3.primary_key[0] is users.c.id - @testing.resolve_artifact_names def test_custom_join(self): + users, items, order_items, orders, Item, User, Order = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Order) + """select_from totally replace the FROM parameters.""" mapper(Item, items) @@ -682,8 +772,9 @@ class MapperTest(_fixtures.FixtureTest): eq_(l, [self.static.user_result[0]]) - @testing.resolve_artifact_names def test_cancel_order_by(self): + users, User = self.tables.users, self.classes.User + mapper(User, users, order_by=users.c.name.desc()) assert "order by users.name desc" in str(create_session().query(User).statement).lower() @@ -702,8 +793,11 @@ class MapperTest(_fixtures.FixtureTest): # 'Raises a "expression evaluation not supported" error at prepare time @testing.fails_on('firebird', 'FIXME: unknown') - @testing.resolve_artifact_names def test_function(self): + addresses, users, User = (self.tables.addresses, + self.tables.users, + self.classes.User) + """Mapping to a SELECT statement that has functions in it.""" s = sa.select([users, @@ -720,8 +814,9 @@ class MapperTest(_fixtures.FixtureTest): eq_(l[idx].concat, l[idx].id * 2) eq_(l[idx].concat, total) - @testing.resolve_artifact_names def test_count(self): + User, users = self.classes.User, self.tables.users + """The count function on Query.""" mapper(User, users) @@ -736,8 +831,13 @@ class MapperTest(_fixtures.FixtureTest): eq_(session.query(User.id).count(), 4) eq_(session.query(User.id).filter(User.id.in_((8, 9))).count(), 2) - @testing.resolve_artifact_names def test_many_to_many_count(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties=dict( keywords = relationship(Keyword, item_keywords, lazy='select'))) @@ -749,8 +849,12 @@ class MapperTest(_fixtures.FixtureTest): filter(Keyword.name == "red")) eq_(q.count(), 2) - @testing.resolve_artifact_names def test_override_1(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """Overriding a column raises an error.""" def go(): mapper(User, users, @@ -759,8 +863,12 @@ class MapperTest(_fixtures.FixtureTest): assert_raises(sa.exc.ArgumentError, go) - @testing.resolve_artifact_names def test_override_2(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """exclude_properties cancels the error.""" mapper(User, users, @@ -770,16 +878,23 @@ class MapperTest(_fixtures.FixtureTest): assert bool(User.name) - @testing.resolve_artifact_names def test_override_3(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """The column being named elsewhere also cancels the error,""" mapper(User, users, properties=dict( name=relationship(mapper(Address, addresses)), foo=users.c.name)) - @testing.resolve_artifact_names def test_synonym(self): + users, addresses, Address = (self.tables.users, + self.tables.addresses, + self.classes.Address) + assert_col = [] class extendedproperty(property): @@ -847,8 +962,9 @@ class MapperTest(_fixtures.FixtureTest): eq_(User.uname.attribute, 123) eq_(User.uname['key'], 'value') - @testing.resolve_artifact_names def test_synonym_column_location(self): + users, User = self.tables.users, self.classes.User + def go(): mapper(User, users, properties={ 'not_name':synonym('_name', map_column=True)}) @@ -859,8 +975,11 @@ class MapperTest(_fixtures.FixtureTest): "'users' named 'not_name'"), go) - @testing.resolve_artifact_names def test_column_synonyms(self): + addresses, users, Address = (self.tables.addresses, + self.tables.users, + self.classes.Address) + """Synonyms which automatically instrument properties, set up aliased column, etc.""" @@ -893,8 +1012,9 @@ class MapperTest(_fixtures.FixtureTest): eq_(u.name, 'foo') eq_(assert_col, [('get', 'jack'), ('set', 'foo'), ('get', 'foo')]) - @testing.resolve_artifact_names def test_synonym_map_column_conflict(self): + users, User = self.tables.users, self.classes.User + assert_raises( sa.exc.ArgumentError, mapper, @@ -913,8 +1033,9 @@ class MapperTest(_fixtures.FixtureTest): ]) ) - @testing.resolve_artifact_names def test_comparable(self): + users = self.tables.users + class extendedproperty(property): attribute = 123 @@ -997,8 +1118,9 @@ class MapperTest(_fixtures.FixtureTest): eq_(User.uc_name['key'], 'value') sess.rollback() - @testing.resolve_artifact_names def test_comparable_column(self): + users, User = self.tables.users, self.classes.User + class MyComparator(sa.orm.properties.ColumnProperty.Comparator): __hash__ = None def __eq__(self, other): @@ -1022,8 +1144,12 @@ class MapperTest(_fixtures.FixtureTest): eq_(str((User.name.intersects('ed')).compile(dialect=sa.engine.default.DefaultDialect())), "users.name &= :name_1") - @testing.resolve_artifact_names def test_reentrant_compile(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + class MyFakeProperty(sa.orm.properties.ColumnProperty): def post_instrument_class(self, mapper): super(MyFakeProperty, self).post_instrument_class(mapper) @@ -1047,8 +1173,9 @@ class MapperTest(_fixtures.FixtureTest): m2 = mapper(Address, addresses) configure_mappers() - @testing.resolve_artifact_names def test_reconstructor(self): + users = self.tables.users + recon = [] class User(object): @@ -1063,8 +1190,9 @@ class MapperTest(_fixtures.FixtureTest): create_session().query(User).first() eq_(recon, ['go']) - @testing.resolve_artifact_names def test_reconstructor_inheritance(self): + users = self.tables.users + recon = [] class A(object): @reconstructor @@ -1100,8 +1228,9 @@ class MapperTest(_fixtures.FixtureTest): sess.query(C).first() eq_(recon, ['A', 'B', 'C']) - @testing.resolve_artifact_names def test_unmapped_reconstructor_inheritance(self): + users = self.tables.users + recon = [] class Base(object): @reconstructor @@ -1119,8 +1248,12 @@ class MapperTest(_fixtures.FixtureTest): create_session().query(User).first() eq_(recon, ['go']) - @testing.resolve_artifact_names def test_unmapped_error(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) sa.orm.clear_mappers() @@ -1130,8 +1263,9 @@ class MapperTest(_fixtures.FixtureTest): assert_raises(sa.orm.exc.UnmappedClassError, sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_unmapped_subclass_error_postmap(self): + users = self.tables.users + class Base(object): pass class Sub(Base): @@ -1153,8 +1287,9 @@ class MapperTest(_fixtures.FixtureTest): assert_raises(sa.orm.exc.UnmappedClassError, create_session().add, Sub()) - @testing.resolve_artifact_names def test_unmapped_subclass_error_premap(self): + users = self.tables.users + class Base(object): pass @@ -1178,8 +1313,9 @@ class MapperTest(_fixtures.FixtureTest): assert_raises(sa.orm.exc.UnmappedClassError, create_session().add, Sub()) - @testing.resolve_artifact_names def test_oldstyle_mixin(self): + users = self.tables.users + class OldStyle: pass class NewStyle(object): @@ -1244,8 +1380,12 @@ class OptionsTest(_fixtures.FixtureTest): @testing.fails_if(lambda: True, "0.7 regression, may not support " "synonyms for relationship") @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_synonym_options(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), lazy='select', order_by=addresses.c.id), @@ -1261,8 +1401,12 @@ class OptionsTest(_fixtures.FixtureTest): [self.static.user_address_result[0].addresses[0]]) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_eager_options(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A lazy relationship can be upgraded to an eager relationship.""" mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), @@ -1278,8 +1422,12 @@ class OptionsTest(_fixtures.FixtureTest): self.sql_count_(0, go) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_eager_options_with_limit(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties=dict( addresses=relationship(mapper(Address, addresses), lazy='select'))) @@ -1300,8 +1448,12 @@ class OptionsTest(_fixtures.FixtureTest): eq_(len(u.addresses), 3) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_lazy_options_with_limit(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), lazy='joined'))) @@ -1315,8 +1467,12 @@ class OptionsTest(_fixtures.FixtureTest): eq_(len(u.addresses), 3) self.sql_count_(1, go) - @testing.resolve_artifact_names def test_eager_degrade(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """An eager relationship automatically degrades to a lazy relationship if eager columns are not available""" mapper(User, users, properties=dict( @@ -1342,8 +1498,20 @@ class OptionsTest(_fixtures.FixtureTest): eq_(l, self.static.user_address_result) self.sql_count_(4, go) - @testing.resolve_artifact_names def test_eager_degrade_deep(self): + users, Keyword, items, order_items, orders, Item, User, Address, keywords, item_keywords, Order, addresses = (self.tables.users, + self.classes.Keyword, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.tables.keywords, + self.tables.item_keywords, + self.classes.Order, + self.tables.addresses) + # test with a deeper set of eager loads. when we first load the three # users, they will have no addresses or orders. the number of lazy # loads when traversing the whole thing will be three for the @@ -1385,8 +1553,12 @@ class OptionsTest(_fixtures.FixtureTest): eq_(l, self.static.user_all_result) self.assert_sql_count(testing.db, go, 6) - @testing.resolve_artifact_names def test_lazy_options(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """An eager relationship can be upgraded to a lazy relationship.""" mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), lazy='joined') @@ -1401,8 +1573,15 @@ class OptionsTest(_fixtures.FixtureTest): eq_(l, self.static.user_address_result) self.sql_count_(4, go) - @testing.resolve_artifact_names def test_option_propagate(self): + users, items, order_items, Order, Item, User, orders = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.orders) + mapper(User, users, properties=dict( orders = relationship(Order) )) @@ -1427,8 +1606,18 @@ class OptionsTest(_fixtures.FixtureTest): class DeepOptionsTest(_fixtures.FixtureTest): @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, Keyword, items, order_items, Order, Item, User, keywords, item_keywords, orders = (cls.tables.users, + cls.classes.Keyword, + cls.tables.items, + cls.tables.order_items, + cls.classes.Order, + cls.classes.Item, + cls.classes.User, + cls.tables.keywords, + cls.tables.item_keywords, + cls.tables.orders) + mapper(Keyword, keywords) mapper(Item, items, properties=dict( @@ -1442,8 +1631,9 @@ class DeepOptionsTest(_fixtures.FixtureTest): mapper(User, users, order_by=users.c.id, properties=dict( orders=relationship(Order, order_by=orders.c.id))) - @testing.resolve_artifact_names def test_deep_options_1(self): + User = self.classes.User + sess = create_session() # joinedload nothing. @@ -1452,8 +1642,9 @@ class DeepOptionsTest(_fixtures.FixtureTest): x = u[0].orders[1].items[0].keywords[1] self.assert_sql_count(testing.db, go, 3) - @testing.resolve_artifact_names def test_deep_options_2(self): + User = self.classes.User + """test (joined|subquery)load_all() options""" sess = create_session() @@ -1473,8 +1664,9 @@ class DeepOptionsTest(_fixtures.FixtureTest): self.sql_count_(0, go) - @testing.resolve_artifact_names def test_deep_options_3(self): + User = self.classes.User + sess = create_session() # same thing, with separate options calls @@ -1487,8 +1679,11 @@ class DeepOptionsTest(_fixtures.FixtureTest): x = u[0].orders[1].items[0].keywords[1] self.sql_count_(0, go) - @testing.resolve_artifact_names def test_deep_options_4(self): + Item, User, Order = (self.classes.Item, + self.classes.User, + self.classes.Order) + sess = create_session() assert_raises_message( @@ -1515,8 +1710,9 @@ class DeepOptionsTest(_fixtures.FixtureTest): self.sql_count_(2, go) class ValidatorTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_scalar(self): + users = self.tables.users + class User(_base.ComparableEntity): @validates('name') def validate_name(self, key, name): @@ -1535,8 +1731,11 @@ class ValidatorTest(_fixtures.FixtureTest): eq_(sess.query(User).filter_by(name='ed modified').one(), User(name='ed')) - @testing.resolve_artifact_names def test_collection(self): + users, addresses, Address = (self.tables.users, + self.tables.addresses, + self.classes.Address) + class User(_base.ComparableEntity): @validates('addresses') def validate_address(self, key, ad): @@ -1558,8 +1757,9 @@ class ValidatorTest(_fixtures.FixtureTest): ) class ComparatorFactoryTest(_fixtures.FixtureTest, AssertsCompiledSQL): - @testing.resolve_artifact_names def test_kwarg_accepted(self): + users, Address = self.tables.users, self.classes.Address + class DummyComposite(object): def __init__(self, x, y): pass @@ -1583,8 +1783,9 @@ class ComparatorFactoryTest(_fixtures.FixtureTest, AssertsCompiledSQL): args = args[1:] fn(comparator_factory=MyFactory, *args) - @testing.resolve_artifact_names def test_column(self): + User, users = self.classes.User, self.tables.users + from sqlalchemy.orm.properties import ColumnProperty class MyFactory(ColumnProperty.Comparator): @@ -1595,8 +1796,9 @@ class ComparatorFactoryTest(_fixtures.FixtureTest, AssertsCompiledSQL): self.assert_compile(User.name == 'ed', "foobar(users.name) = foobar(:foobar_1)", dialect=default.DefaultDialect()) self.assert_compile(aliased(User).name == 'ed', "foobar(users_1.name) = foobar(:foobar_1)", dialect=default.DefaultDialect()) - @testing.resolve_artifact_names def test_synonym(self): + users, User = self.tables.users, self.classes.User + from sqlalchemy.orm.properties import ColumnProperty class MyFactory(ColumnProperty.Comparator): __hash__ = None @@ -1618,8 +1820,12 @@ class ComparatorFactoryTest(_fixtures.FixtureTest, AssertsCompiledSQL): "foobar(users_1.name) = foobar(:foobar_1)", dialect=default.DefaultDialect()) - @testing.resolve_artifact_names def test_relationship(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + from sqlalchemy.orm.properties import PropertyLoader class MyFactory(PropertyLoader.Comparator): @@ -1648,8 +1854,9 @@ class ComparatorFactoryTest(_fixtures.FixtureTest, AssertsCompiledSQL): class DeferredTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_basic(self): + Order, orders = self.classes.Order, self.tables.orders + """A basic deferred load.""" mapper(Order, orders, order_by=orders.c.id, properties={ @@ -1674,8 +1881,9 @@ class DeferredTest(_fixtures.FixtureTest): "FROM orders WHERE orders.id = :param_1", {'param_1':3})]) - @testing.resolve_artifact_names def test_unsaved(self): + Order, orders = self.classes.Order, self.tables.orders + """Deferred loading does not kick in when just PK cols are set.""" mapper(Order, orders, properties={ @@ -1689,8 +1897,9 @@ class DeferredTest(_fixtures.FixtureTest): o.description = "some description" self.sql_count_(0, go) - @testing.resolve_artifact_names def test_synonym_group_bug(self): + orders, Order = self.tables.orders, self.classes.Order + mapper(Order, orders, properties={ 'isopen':synonym('_isopen', map_column=True), 'description':deferred(orders.c.description, group='foo') @@ -1700,8 +1909,9 @@ class DeferredTest(_fixtures.FixtureTest): o1 = sess.query(Order).get(1) eq_(o1.description, "order 1") - @testing.resolve_artifact_names def test_unsaved_2(self): + Order, orders = self.classes.Order, self.tables.orders + mapper(Order, orders, properties={ 'description': deferred(orders.c.description)}) @@ -1712,8 +1922,9 @@ class DeferredTest(_fixtures.FixtureTest): o.description = "some description" self.sql_count_(0, go) - @testing.resolve_artifact_names def test_unsaved_group(self): + orders, Order = self.tables.orders, self.classes.Order + """Deferred loading doesnt kick in when just PK cols are set""" mapper(Order, orders, order_by=orders.c.id, properties=dict( @@ -1728,8 +1939,9 @@ class DeferredTest(_fixtures.FixtureTest): o.description = "some description" self.sql_count_(0, go) - @testing.resolve_artifact_names def test_unsaved_group_2(self): + orders, Order = self.tables.orders, self.classes.Order + mapper(Order, orders, order_by=orders.c.id, properties=dict( description=deferred(orders.c.description, group='primary'), opened=deferred(orders.c.isopen, group='primary'))) @@ -1741,8 +1953,9 @@ class DeferredTest(_fixtures.FixtureTest): o.description = "some description" self.sql_count_(0, go) - @testing.resolve_artifact_names def test_save(self): + Order, orders = self.classes.Order, self.tables.orders + m = mapper(Order, orders, properties={ 'description': deferred(orders.c.description)}) @@ -1751,8 +1964,9 @@ class DeferredTest(_fixtures.FixtureTest): o2.isopen = 1 sess.flush() - @testing.resolve_artifact_names def test_group(self): + orders, Order = self.tables.orders, self.classes.Order + """Deferred load with a group""" mapper(Order, orders, properties=util.OrderedDict([ ('userident', deferred(orders.c.user_id, group='primary')), @@ -1788,8 +2002,9 @@ class DeferredTest(_fixtures.FixtureTest): sess.flush() self.sql_count_(0, go) - @testing.resolve_artifact_names def test_preserve_changes(self): + orders, Order = self.tables.orders, self.classes.Order + """A deferred load operation doesn't revert modifications on attributes""" mapper(Order, orders, properties = { 'userident': deferred(orders.c.user_id, group='primary'), @@ -1807,8 +2022,9 @@ class DeferredTest(_fixtures.FixtureTest): eq_(o.description, 'somenewdescription') assert o in sess.dirty - @testing.resolve_artifact_names def test_commits_state(self): + orders, Order = self.tables.orders, self.classes.Order + """ When deferred elements are loaded via a group, they get the proper CommittedState and don't result in changes being committed @@ -1830,8 +2046,9 @@ class DeferredTest(_fixtures.FixtureTest): # therefore the flush() shouldnt actually issue any SQL self.assert_sql_count(testing.db, sess.flush, 0) - @testing.resolve_artifact_names def test_options(self): + orders, Order = self.tables.orders, self.classes.Order + """Options on a mapper to create deferred and undeferred columns""" mapper(Order, orders) @@ -1863,8 +2080,9 @@ class DeferredTest(_fixtures.FixtureTest): "FROM orders ORDER BY orders.id", {})]) - @testing.resolve_artifact_names def test_undefer_group(self): + orders, Order = self.tables.orders, self.classes.Order + mapper(Order, orders, properties=util.OrderedDict([ ('userident',deferred(orders.c.user_id, group='primary')), ('description',deferred(orders.c.description, group='primary')), @@ -1890,8 +2108,9 @@ class DeferredTest(_fixtures.FixtureTest): "FROM orders ORDER BY orders.id", {})]) - @testing.resolve_artifact_names def test_locates_col(self): + orders, Order = self.tables.orders, self.classes.Order + """Manually adding a column to the result undefers the column.""" mapper(Order, orders, properties={ @@ -1911,8 +2130,9 @@ class DeferredTest(_fixtures.FixtureTest): eq_(o1.description, 'order 1') self.sql_count_(0, go) - @testing.resolve_artifact_names def test_map_selectable_wo_deferred(self): + Order, orders = self.classes.Order, self.tables.orders + """test mapping to a selectable with deferred cols, the selectable doesn't include the deferred col. @@ -1933,8 +2153,15 @@ class DeferredTest(_fixtures.FixtureTest): assert 'description' not in o1.__dict__ eq_(o1.description, 'order 1') - @testing.resolve_artifact_names def test_deep_options(self): + users, items, order_items, Order, Item, User, orders = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.orders) + mapper(Item, items, properties=dict( description=deferred(items.c.description))) mapper(Order, orders, properties=dict( @@ -1985,8 +2212,12 @@ class SecondaryOptionsTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + child1, child2, base, related = (cls.tables.child1, + cls.tables.child2, + cls.tables.base, + cls.tables.related) + class Base(_base.ComparableEntity): pass class Child1(Base): @@ -2009,8 +2240,12 @@ class SecondaryOptionsTest(_base.MappedTest): mapper(Related, related) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + child1, child2, base, related = (cls.tables.child1, + cls.tables.child2, + cls.tables.base, + cls.tables.related) + base.insert().execute([ {'id':1, 'type':'child1'}, {'id':2, 'type':'child1'}, @@ -2038,8 +2273,9 @@ class SecondaryOptionsTest(_base.MappedTest): {'id':6}, ]) - @testing.resolve_artifact_names def test_contains_eager(self): + Child1, Related = self.classes.Child1, self.classes.Related + sess = create_session() child1s = sess.query(Child1).\ @@ -2071,8 +2307,9 @@ class SecondaryOptionsTest(_base.MappedTest): ) ) - @testing.resolve_artifact_names def test_joinedload_on_other(self): + Child1, Related = self.classes.Child1, self.classes.Related + sess = create_session() child1s = sess.query(Child1).join(Child1.related).options(sa.orm.joinedload(Child1.related)).order_by(Child1.id) @@ -2101,8 +2338,11 @@ class SecondaryOptionsTest(_base.MappedTest): ) ) - @testing.resolve_artifact_names def test_joinedload_on_same(self): + Child1, Child2, Related = (self.classes.Child1, + self.classes.Child2, + self.classes.Related) + sess = create_session() child1s = sess.query(Child1).join(Child1.related).options(sa.orm.joinedload(Child1.child2, Child2.related)).order_by(Child1.id) @@ -2142,8 +2382,9 @@ class DeferredPopulationTest(_base.MappedTest): Column("name", String(20))) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + thing, human = cls.tables.thing, cls.tables.human + class Human(_base.BasicEntity): pass class Thing(_base.BasicEntity): pass @@ -2151,8 +2392,9 @@ class DeferredPopulationTest(_base.MappedTest): mapper(Thing, thing, properties={"name": deferred(thing.c.name)}) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + thing, human = cls.tables.thing, cls.tables.human + thing.insert().execute([ {"id": 1, "name": "Chair"}, ]) @@ -2164,52 +2406,59 @@ class DeferredPopulationTest(_base.MappedTest): def _test(self, thing): assert "name" in attributes.instance_state(thing).dict - @testing.resolve_artifact_names def test_no_previous_query(self): + Thing = self.classes.Thing + session = create_session() thing = session.query(Thing).options(sa.orm.undefer("name")).first() self._test(thing) - @testing.resolve_artifact_names def test_query_twice_with_clear(self): + Thing = self.classes.Thing + session = create_session() result = session.query(Thing).first() session.expunge_all() thing = session.query(Thing).options(sa.orm.undefer("name")).first() self._test(thing) - @testing.resolve_artifact_names def test_query_twice_no_clear(self): + Thing = self.classes.Thing + session = create_session() result = session.query(Thing).first() thing = session.query(Thing).options(sa.orm.undefer("name")).first() self._test(thing) - @testing.resolve_artifact_names def test_joinedload_with_clear(self): + Thing, Human = self.classes.Thing, self.classes.Human + session = create_session() human = session.query(Human).options(sa.orm.joinedload("thing")).first() session.expunge_all() thing = session.query(Thing).options(sa.orm.undefer("name")).first() self._test(thing) - @testing.resolve_artifact_names def test_joinedload_no_clear(self): + Thing, Human = self.classes.Thing, self.classes.Human + session = create_session() human = session.query(Human).options(sa.orm.joinedload("thing")).first() thing = session.query(Thing).options(sa.orm.undefer("name")).first() self._test(thing) - @testing.resolve_artifact_names def test_join_with_clear(self): + Thing, Human = self.classes.Thing, self.classes.Human + session = create_session() result = session.query(Human).add_entity(Thing).join("thing").first() session.expunge_all() thing = session.query(Thing).options(sa.orm.undefer("name")).first() self._test(thing) - @testing.resolve_artifact_names def test_join_no_clear(self): + Thing, Human = self.classes.Thing, self.classes.Human + session = create_session() result = session.query(Human).add_entity(Thing).join("thing").first() thing = session.query(Thing).options(sa.orm.undefer("name")).first() @@ -2222,8 +2471,12 @@ class NoLoadTest(_fixtures.FixtureTest): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def test_basic(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A basic one-to-many lazy load""" m = mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), lazy='noload') @@ -2240,8 +2493,12 @@ class NoLoadTest(_fixtures.FixtureTest): {'id' : 7, 'addresses' : (Address, [])}, ) - @testing.resolve_artifact_names def test_options(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + m = mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), lazy='noload') )) @@ -2287,8 +2544,9 @@ class RequirementsTest(_base.MappedTest): Column('value', String(10))) # Py2K - @testing.resolve_artifact_names def test_baseclass(self): + ht1 = self.tables.ht1 + class OldStyle: pass @@ -2303,8 +2561,14 @@ class RequirementsTest(_base.MappedTest): #self.assertRaises(sa.exc.ArgumentError, mapper, NoWeakrefSupport, t2) # end Py2K - @testing.resolve_artifact_names def test_comparison_overrides(self): + ht6, ht5, ht4, ht3, ht2, ht1 = (self.tables.ht6, + self.tables.ht5, + self.tables.ht4, + self.tables.ht3, + self.tables.ht2, + self.tables.ht1) + """Simple tests to ensure users can supply comparison __methods__. The suite-level test --options are better suited to detect @@ -2398,8 +2662,9 @@ class RequirementsTest(_base.MappedTest): sa.orm.joinedload_all('h3s.h1s')).all() eq_(len(h1s), 5) - @testing.resolve_artifact_names def test_nonzero_len_recursion(self): + ht1 = self.tables.ht1 + class H1(object): def __len__(self): return len(self.get_value()) @@ -2451,8 +2716,12 @@ class MagicNamesTest(_base.MappedTest): class Map(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_mappish(self): + maps, Cartographer, cartographers, Map = (self.tables.maps, + self.classes.Cartographer, + self.tables.cartographers, + self.classes.Map) + mapper(Cartographer, cartographers, properties=dict( query=cartographers.c.quip)) mapper(Map, maps, properties=dict( @@ -2474,7 +2743,6 @@ class MagicNamesTest(_base.MappedTest): filter(C.query=='Where be dragons?')).one() m1 = sess.query(M).filter(M.mapper==c1).one() - @testing.resolve_artifact_names def test_direct_stateish(self): for reserved in (sa.orm.instrumentation.ClassManager.STATE_ATTR, sa.orm.instrumentation.ClassManager.MANAGER_ATTR): @@ -2490,8 +2758,9 @@ class MagicNamesTest(_base.MappedTest): 'instrumentation attribute of the same name.' % reserved), mapper, T, t) - @testing.resolve_artifact_names def test_indirect_stateish(self): + maps = self.tables.maps + for reserved in (sa.orm.instrumentation.ClassManager.STATE_ATTR, sa.orm.instrumentation.ClassManager.MANAGER_ATTR): class M(object): diff --git a/test/orm/test_merge.py b/test/orm/test_merge.py index 34494b9789..23fc294e2a 100644 --- a/test/orm/test_merge.py +++ b/test/orm/test_merge.py @@ -28,8 +28,9 @@ class MergeTest(_fixtures.FixtureTest): return canary - @testing.resolve_artifact_names def test_transient_to_pending(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session() load = self.load_tracker(User) @@ -44,8 +45,9 @@ class MergeTest(_fixtures.FixtureTest): sess.expunge_all() eq_(sess.query(User).first(), User(id=7, name='fred')) - @testing.resolve_artifact_names def test_transient_to_pending_no_pk(self): + User, users = self.classes.User, self.tables.users + """test that a transient object with no PK attribute doesn't trigger a needless load.""" mapper(User, users) sess = create_session() @@ -54,8 +56,12 @@ class MergeTest(_fixtures.FixtureTest): sess.merge(u) self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_transient_to_pending_collection(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + mapper(User, users, properties={ 'addresses': relationship(Address, backref='user', collection_class=OrderedSet)}) @@ -87,8 +93,9 @@ class MergeTest(_fixtures.FixtureTest): ])) ) - @testing.resolve_artifact_names def test_transient_to_persistent(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) load = self.load_tracker(User) @@ -110,8 +117,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(sess.query(User).first(), User(id=7, name='fred jones')) eq_(load.called, 2) - @testing.resolve_artifact_names def test_transient_to_persistent_collection(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', @@ -163,8 +174,12 @@ class MergeTest(_fixtures.FixtureTest): ])) ) - @testing.resolve_artifact_names def test_detached_to_persistent_collection(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', @@ -199,8 +214,12 @@ class MergeTest(_fixtures.FixtureTest): Address(id=2, email_address='fred2'), Address(id=3, email_address='fred3')]))) - @testing.resolve_artifact_names def test_unsaved_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """Merge of a transient entity with two child transient entities, with a bidirectional relationship.""" mapper(User, users, properties={ @@ -238,8 +257,9 @@ class MergeTest(_fixtures.FixtureTest): Address(email_address='hoho@bar.com')])) eq_(load.called, 6) - @testing.resolve_artifact_names def test_merge_empty_attributes(self): + User, dingalings = self.classes.User, self.tables.dingalings + mapper(User, dingalings) sess = create_session() @@ -302,8 +322,12 @@ class MergeTest(_fixtures.FixtureTest): assert u6.__dict__['data'] is None - @testing.resolve_artifact_names def test_merge_irregular_collection(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses': relationship( mapper(Address, addresses), @@ -317,8 +341,12 @@ class MergeTest(_fixtures.FixtureTest): sess.flush() assert u1.addresses.keys() == ['foo@bar.com'] - @testing.resolve_artifact_names def test_attribute_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """Merge of a persistent entity with two child persistent entities.""" mapper(User, users, properties={ @@ -413,8 +441,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(u2.addresses[1].email_address, 'afafds') eq_(load.called, 21) - @testing.resolve_artifact_names def test_no_relationship_cascade(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """test that merge doesn't interfere with a relationship() target that specifically doesn't include 'merge' cascade. """ @@ -448,8 +480,12 @@ class MergeTest(_fixtures.FixtureTest): [User(name="fred")] ) - @testing.resolve_artifact_names def test_one_to_many_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses))}) @@ -486,8 +522,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(load.called, 6) eq_(u3.name, 'also fred') - @testing.resolve_artifact_names def test_many_to_one_cascade(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses, properties={ 'user':relationship(User) }) @@ -521,8 +561,13 @@ class MergeTest(_fixtures.FixtureTest): ) assert a2 not in sess2.dirty - @testing.resolve_artifact_names def test_many_to_many_cascade(self): + items, Order, orders, order_items, Item = (self.tables.items, + self.classes.Order, + self.tables.orders, + self.tables.order_items, + self.classes.Item) + mapper(Order, orders, properties={ 'items':relationship(mapper(Item, items), secondary=order_items)}) @@ -566,8 +611,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(load.called, 6) eq_(o3.description, 'desc modified') - @testing.resolve_artifact_names def test_one_to_one_cascade(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'address':relationship(mapper(Address, addresses),uselist = False) @@ -599,8 +648,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(load.called, 2) assert u3 is u - @testing.resolve_artifact_names def test_value_to_none(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'address':relationship(mapper(Address, addresses),uselist = False, backref='user') }) @@ -621,16 +674,18 @@ class MergeTest(_fixtures.FixtureTest): a2 = sess.merge(a1) assert a2.user is None - @testing.resolve_artifact_names def test_transient_no_load(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session() u = User() assert_raises_message(sa.exc.InvalidRequestError, "load=False option does not support", sess.merge, u, load=False) - @testing.resolve_artifact_names def test_dont_load_deprecated(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session() @@ -648,8 +703,12 @@ class MergeTest(_fixtures.FixtureTest): assert u1 not in sess.dirty go() - @testing.resolve_artifact_names def test_no_load_with_backrefs(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """load=False populates relationships in both directions without requiring a load""" mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses), backref='user') @@ -679,8 +738,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(u.addresses[1].user, User(id=7, name='fred')) - @testing.resolve_artifact_names def test_dontload_with_eager(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """ This test illustrates that with load=False, we can't just copy the @@ -716,8 +779,9 @@ class MergeTest(_fixtures.FixtureTest): sess3.flush() self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_no_load_disallows_dirty(self): + users, User = self.tables.users, self.classes.User + """load=False doesnt support 'dirty' objects right now (see test_no_load_with_eager()). Therefore lets assert it. @@ -751,8 +815,12 @@ class MergeTest(_fixtures.FixtureTest): self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_no_load_sets_backrefs(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses),backref='user')}) @@ -776,8 +844,12 @@ class MergeTest(_fixtures.FixtureTest): assert u2.addresses[0].user is u2 self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_no_load_preserves_parents(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """Merge with load=False does not trigger a 'delete-orphan' operation. merge with load=False sets attributes without using events. this means @@ -844,8 +916,9 @@ class MergeTest(_fixtures.FixtureTest): except sa.exc.InvalidRequestError, e: assert "load=False option does not support" in str(e) - @testing.resolve_artifact_names def test_synonym_comparable(self): + users = self.tables.users + class User(object): class Comparator(PropComparator): @@ -872,8 +945,12 @@ class MergeTest(_fixtures.FixtureTest): sess.expunge(u) sess.merge(u) - @testing.resolve_artifact_names def test_cascade_doesnt_blowaway_manytoone(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + """a merge test that was fixed by [ticket:1202]""" s = create_session(autoflush=True, autocommit=False) @@ -890,8 +967,12 @@ class MergeTest(_fixtures.FixtureTest): eq_(before_id, after_id) eq_(a1.user, a2.user) - @testing.resolve_artifact_names def test_cascades_dont_autoflush(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + sess = create_session(autoflush=True, autocommit=False) m = mapper(User, users, properties={ 'addresses':relationship(mapper(Address, addresses),backref='user')}) @@ -901,8 +982,12 @@ class MergeTest(_fixtures.FixtureTest): sess.flush() assert merged_user not in sess.new - @testing.resolve_artifact_names def test_cascades_dont_autoflush_2(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', @@ -927,8 +1012,9 @@ class MergeTest(_fixtures.FixtureTest): assert sess.autoflush sess.commit() - @testing.resolve_artifact_names def test_dont_expire_pending(self): + users, User = self.tables.users, self.classes.User + """test that pending instances aren't expired during a merge.""" mapper(User, users) @@ -940,8 +1026,9 @@ class MergeTest(_fixtures.FixtureTest): eq_(u.name, None) self.assert_sql_count(testing.db, go, 0) - @testing.resolve_artifact_names def test_option_state(self): + users, User = self.tables.users, self.classes.User + """test that the merged takes on the MapperOption characteristics of that which is merged. @@ -1011,8 +1098,9 @@ class MutableMergeTest(_base.MappedTest): class Data(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_list(self): + Data, data = self.classes.Data, self.tables.data + mapper(Data, data) sess = sessionmaker()() d = Data(data=["this", "is", "a", "list"]) @@ -1039,8 +1127,9 @@ class CompositeNullPksTest(_base.MappedTest): class Data(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_merge_allow_partial(self): + Data, data = self.classes.Data, self.tables.data + mapper(Data, data) sess = sessionmaker()() @@ -1050,8 +1139,9 @@ class CompositeNullPksTest(_base.MappedTest): return sess.merge(d1) self.assert_sql_count(testing.db, go, 1) - @testing.resolve_artifact_names def test_merge_disallow_partial(self): + Data, data = self.classes.Data, self.tables.data + mapper(Data, data, allow_partial_pks=False) sess = sessionmaker()() diff --git a/test/orm/test_naturalpks.py b/test/orm/test_naturalpks.py index 18ebb5bba5..def3ce7d52 100644 --- a/test/orm/test_naturalpks.py +++ b/test/orm/test_naturalpks.py @@ -56,8 +56,9 @@ class NaturalPKTest(_base.MappedTest): class Item(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_entity(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session() @@ -80,8 +81,9 @@ class NaturalPKTest(_base.MappedTest): u1 = sess.query(User).get('ed') eq_(User(username='ed', fullname='jack'), u1) - @testing.resolve_artifact_names def test_load_after_expire(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session() @@ -103,8 +105,9 @@ class NaturalPKTest(_base.MappedTest): assert sess.query(User).get('jack') is None assert sess.query(User).get('ed').fullname == 'jack' - @testing.resolve_artifact_names def test_flush_new_pk_after_expire(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session() u1 = User(username='jack', fullname='jack') @@ -128,8 +131,12 @@ class NaturalPKTest(_base.MappedTest): def test_onetomany_nonpassive(self): self._test_onetomany(False) - @testing.resolve_artifact_names def _test_onetomany(self, passive_updates): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, passive_updates=passive_updates) }) @@ -187,8 +194,12 @@ class NaturalPKTest(_base.MappedTest): def test_manytoone_nonpassive(self): self._test_manytoone(False) - @testing.resolve_artifact_names def _test_manytoone(self, passive_updates): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users) mapper(Address, addresses, properties={ 'user':relationship(User, passive_updates=passive_updates) @@ -231,8 +242,12 @@ class NaturalPKTest(_base.MappedTest): def test_onetoone_nonpassive(self): self._test_onetoone(False) - @testing.resolve_artifact_names def _test_onetoone(self, passive_updates): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ "address":relationship(Address, passive_updates=passive_updates, uselist=False) @@ -274,8 +289,12 @@ class NaturalPKTest(_base.MappedTest): def test_bidirectional_nonpassive(self): self._test_bidirectional(False) - @testing.resolve_artifact_names def _test_bidirectional(self, passive_updates): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users) mapper(Address, addresses, properties={ 'user':relationship(User, passive_updates=passive_updates, @@ -333,8 +352,13 @@ class NaturalPKTest(_base.MappedTest): def test_manytomany_nonpassive(self): self._test_manytomany(False) - @testing.resolve_artifact_names def _test_manytomany(self, passive_updates): + users, items, Item, User, users_to_items = (self.tables.users, + self.tables.items, + self.classes.Item, + self.classes.User, + self.tables.users_to_items) + mapper(User, users, properties={ 'items':relationship(Item, secondary=users_to_items, backref='users', @@ -387,8 +411,12 @@ class NaturalPKTest(_base.MappedTest): class TransientExceptionTesst(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_transient_exception(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """An object that goes from a pk value to transient/pending doesn't count as a "pk" switch. @@ -438,8 +466,9 @@ class ReversePKsTest(_base.MappedTest): self.status = status self.username = username - @testing.resolve_artifact_names def test_reverse(self): + user, User = self.tables.user, self.classes.User + PUBLISHED, EDITABLE, ARCHIVED = 1, 2, 3 mapper(User, user) @@ -498,8 +527,9 @@ class SelfReferentialTest(_base.MappedTest): class Node(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_one_to_many_on_m2o(self): + Node, nodes = self.classes.Node, self.tables.nodes + mapper(Node, nodes, properties={ 'children': relationship(Node, backref=sa.orm.backref('parentnode', @@ -523,8 +553,9 @@ class SelfReferentialTest(_base.MappedTest): for n in sess.query(Node).filter( Node.name.in_(['n11', 'n12', 'n13']))]) - @testing.resolve_artifact_names def test_one_to_many_on_o2m(self): + Node, nodes = self.classes.Node, self.tables.nodes + mapper(Node, nodes, properties={ 'children': relationship(Node, backref=sa.orm.backref('parentnode', @@ -556,8 +587,9 @@ class SelfReferentialTest(_base.MappedTest): def test_many_to_one_nonpassive(self): self._test_many_to_one(False) - @testing.resolve_artifact_names def _test_many_to_one(self, passive): + Node, nodes = self.classes.Node, self.tables.nodes + mapper(Node, nodes, properties={ 'parentnode':relationship(Node, remote_side=nodes.c.name, @@ -620,8 +652,12 @@ class NonPKCascadeTest(_base.MappedTest): def test_onetomany_nonpassive(self): self._test_onetomany(False) - @testing.resolve_artifact_names def _test_onetomany(self, passive_updates): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + mapper(User, users, properties={ 'addresses':relationship(Address, passive_updates=passive_updates)}) @@ -731,8 +767,12 @@ class CascadeToFKPKTest(_base.MappedTest, testing.AssertsCompiledSQL): def test_o2m_change_nonpassive(self): self._test_o2m_change(False) - @testing.resolve_artifact_names def _test_o2m_change(self, passive_updates): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + """Change the PK of a related entity to another. "on update cascade" is not involved here, so the mapper has @@ -761,8 +801,12 @@ class CascadeToFKPKTest(_base.MappedTest, testing.AssertsCompiledSQL): def test_o2m_move_nonpassive(self): self._test_o2m_move(False) - @testing.resolve_artifact_names def _test_o2m_move(self, passive_updates): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + """Move the related entity to a different collection, changing its PK. @@ -794,8 +838,12 @@ class CascadeToFKPKTest(_base.MappedTest, testing.AssertsCompiledSQL): def test_change_m2o_nonpassive(self): self._test_change_m2o(False) - @testing.resolve_artifact_names def _test_change_m2o(self, passive_updates): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + mapper(User, users) mapper(Address, addresses, properties={ 'user':relationship(User, passive_updates=passive_updates) @@ -820,8 +868,12 @@ class CascadeToFKPKTest(_base.MappedTest, testing.AssertsCompiledSQL): def test_move_m2o_nonpassive(self): self._test_move_m2o(False) - @testing.resolve_artifact_names def _test_move_m2o(self, passive_updates): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + # tests [ticket:1856] mapper(User, users) mapper(Address, addresses, properties={ @@ -839,8 +891,12 @@ class CascadeToFKPKTest(_base.MappedTest, testing.AssertsCompiledSQL): sess.flush() - @testing.resolve_artifact_names def test_rowswitch_doesntfire(self): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + mapper(User, users) mapper(Address, addresses, properties={ 'user':relationship(User, passive_updates=True) @@ -877,8 +933,12 @@ class CascadeToFKPKTest(_base.MappedTest, testing.AssertsCompiledSQL): ) - @testing.resolve_artifact_names def _test_onetomany(self, passive_updates): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + """Change the PK of a related entity via foreign key cascade. For databases that require "on update cascade", the mapper @@ -977,8 +1037,14 @@ class JoinedInheritanceTest(_base.MappedTest): def test_fk_nonpassive(self): self._test_fk(False) - @testing.resolve_artifact_names def _test_pk(self, passive_updates): + Person, Manager, person, manager, Engineer, engineer = (self.classes.Person, + self.classes.Manager, + self.tables.person, + self.tables.manager, + self.classes.Engineer, + self.tables.engineer) + mapper(Person, person, polymorphic_on=person.c.type, polymorphic_identity='person', passive_updates=passive_updates) @@ -1001,8 +1067,14 @@ class JoinedInheritanceTest(_base.MappedTest): e1.primary_language = 'c++' sess.commit() - @testing.resolve_artifact_names def _test_fk(self, passive_updates): + Person, Manager, person, manager, Engineer, engineer = (self.classes.Person, + self.classes.Manager, + self.tables.person, + self.tables.manager, + self.classes.Engineer, + self.tables.engineer) + mapper(Person, person, polymorphic_on=person.c.type, polymorphic_identity='person', passive_updates=passive_updates) diff --git a/test/orm/test_onetoone.py b/test/orm/test_onetoone.py index ff0ac508ab..0d09705bd2 100644 --- a/test/orm/test_onetoone.py +++ b/test/orm/test_onetoone.py @@ -22,7 +22,6 @@ class O2OTest(_base.MappedTest): Column('jack_id', Integer, ForeignKey("jack.id"))) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): class Jack(_base.BasicEntity): pass @@ -30,8 +29,12 @@ class O2OTest(_base.MappedTest): pass - @testing.resolve_artifact_names def test_basic(self): + Port, port, jack, Jack = (self.classes.Port, + self.tables.port, + self.tables.jack, + self.classes.Jack) + mapper(Port, port) mapper(Jack, jack, order_by=[jack.c.number], diff --git a/test/orm/test_pickled.py b/test/orm/test_pickled.py index fccc03b8dd..c979ed3345 100644 --- a/test/orm/test_pickled.py +++ b/test/orm/test_pickled.py @@ -20,8 +20,12 @@ User, EmailUser = None, None class PickleTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_transient(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) @@ -39,8 +43,9 @@ class PickleTest(_fixtures.FixtureTest): eq_(u1, sess.query(User).get(u2.id)) - @testing.resolve_artifact_names def test_no_mappers(self): + users, User = self.tables.users, self.classes.User + umapper = mapper(User, users) u1 = User(name='ed') @@ -53,8 +58,9 @@ class PickleTest(_fixtures.FixtureTest): "Cannot deserialize object of type - no mapper()", pickle.loads, u1_pickled) - @testing.resolve_artifact_names def test_no_instrumentation(self): + users, User = self.tables.users, self.classes.User + umapper = mapper(User, users) u1 = User(name='ed') @@ -69,8 +75,12 @@ class PickleTest(_fixtures.FixtureTest): # compiles the mapper eq_(str(u1), "User(name='ed')") - @testing.resolve_artifact_names def test_serialize_path(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + umapper = mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) @@ -98,8 +108,12 @@ class PickleTest(_fixtures.FixtureTest): p3 ) - @testing.resolve_artifact_names def test_class_deferred_cols(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties={ 'name':sa.orm.deferred(users.c.name), 'addresses':relationship(Address, backref="user") @@ -129,8 +143,12 @@ class PickleTest(_fixtures.FixtureTest): eq_(u2.name, 'ed') eq_(u2, User(name='ed', addresses=[Address(email_address='ed@bar.com')])) - @testing.resolve_artifact_names def test_instance_lazy_relation_loaders(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, lazy='noload') }) @@ -156,8 +174,12 @@ class PickleTest(_fixtures.FixtureTest): sess.add(u2) assert u2.addresses - @testing.resolve_artifact_names def test_instance_deferred_cols(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) @@ -201,8 +223,12 @@ class PickleTest(_fixtures.FixtureTest): eq_(ad.email_address, 'ed@bar.com') eq_(u2, User(name='ed', addresses=[Address(email_address='ed@bar.com')])) - @testing.resolve_artifact_names def test_pickle_protocols(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) @@ -221,8 +247,12 @@ class PickleTest(_fixtures.FixtureTest): u2 = loads(dumps(u1)) eq_(u1, u2) - @testing.resolve_artifact_names def test_options_with_descriptors(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) @@ -318,8 +348,12 @@ class PolymorphicDeferredTest(_base.MappedTest): User, EmailUser = None, None super(PolymorphicDeferredTest, cls).teardown_class() - @testing.resolve_artifact_names def test_polymorphic_deferred(self): + EmailUser, email_users, users, User = (self.classes.EmailUser, + self.tables.email_users, + self.tables.users, + self.classes.User) + mapper(User, users, polymorphic_identity='user', polymorphic_on=users.c.type) mapper(EmailUser, email_users, inherits=User, polymorphic_identity='emailuser') @@ -337,8 +371,9 @@ class PolymorphicDeferredTest(_base.MappedTest): eq_(eu2.email_address, 'foo@bar.com') class CustomSetupTeardownTest(_fixtures.FixtureTest): - @testing.resolve_artifact_names def test_rebuild_state(self): + User, users = self.classes.User, self.tables.users + """not much of a 'test', but illustrate how to remove instance-level state before pickling. @@ -357,8 +392,12 @@ class UnpickleSA05Test(_fixtures.FixtureTest): __requires__ = ('python2',) - @testing.resolve_artifact_names def test_one(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) @@ -370,8 +409,12 @@ class UnpickleSA05Test(_fixtures.FixtureTest): result = list(sess.query(User).merge_result(pickle.loads(data))) eq_(result, self.static.user_address_result) - @testing.resolve_artifact_names def test_two(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref="user") }) diff --git a/test/orm/test_query.py b/test/orm/test_query.py index 6c9895977f..1861fd7dd0 100644 --- a/test/orm/test_query.py +++ b/test/orm/test_query.py @@ -1463,15 +1463,20 @@ class ImmediateTest(_fixtures.FixtureTest): run_deletes = None @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + Address, addresses, users, User = (cls.classes.Address, + cls.tables.addresses, + cls.tables.users, + cls.classes.User) + mapper(Address, addresses) mapper(User, users, properties=dict( addresses=relationship(Address))) - @testing.resolve_artifact_names def test_one(self): + User, Address = self.classes.User, self.classes.Address + sess = create_session() assert_raises(sa.orm.exc.NoResultFound, @@ -1532,8 +1537,9 @@ class ImmediateTest(_fixtures.FixtureTest): def test_getslice(self): assert False - @testing.resolve_artifact_names def test_scalar(self): + User = self.classes.User + sess = create_session() eq_(sess.query(User.id).filter_by(id=7).scalar(), 7) @@ -1545,8 +1551,9 @@ class ImmediateTest(_fixtures.FixtureTest): assert_raises(sa.orm.exc.MultipleResultsFound, sess.query(User).scalar) assert_raises(sa.orm.exc.MultipleResultsFound, sess.query(User.id, User.name).scalar) - @testing.resolve_artifact_names def test_value(self): + User = self.classes.User + sess = create_session() eq_(sess.query(User).filter_by(id=7).value(User.id), 7) @@ -1578,8 +1585,9 @@ class UpdateDeleteTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def insert_data(cls): + users = cls.tables.users + users.insert().execute([ dict(id=1, name='john', age=25), dict(id=2, name='jack', age=47), @@ -1587,8 +1595,9 @@ class UpdateDeleteTest(_base.MappedTest): dict(id=4, name='jane', age=37), ]) - @testing.resolve_artifact_names def insert_documents(self): + documents = self.tables.documents + documents.insert().execute([ dict(id=1, user_id=1, title='foo'), dict(id=2, user_id=1, title='bar'), @@ -1596,16 +1605,21 @@ class UpdateDeleteTest(_base.MappedTest): ]) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + documents, Document, User, users = (cls.tables.documents, + cls.classes.Document, + cls.classes.User, + cls.tables.users) + mapper(User, users) mapper(Document, documents, properties={ 'user': relationship(User, lazy='joined', backref=backref('documents', lazy='select')) }) - @testing.resolve_artifact_names def test_illegal_operations(self): + User = self.classes.User + s = create_session() for q, mname in ( @@ -1620,8 +1634,9 @@ class UpdateDeleteTest(_base.MappedTest): assert_raises_message(sa_exc.InvalidRequestError, r"Can't call Query.delete\(\) when %s\(\) has been called" % mname, q.delete) - @testing.resolve_artifact_names def test_delete(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1631,8 +1646,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(User).order_by(User.id).all(), [jack,jane]) - @testing.resolve_artifact_names def test_delete_with_bindparams(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1641,8 +1657,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(User).order_by(User.id).all(), [jack,jill,jane]) - @testing.resolve_artifact_names def test_delete_rollback(self): + User = self.classes.User + sess = sessionmaker()() john,jack,jill,jane = sess.query(User).order_by(User.id).all() sess.query(User).filter(or_(User.name == 'john', User.name == 'jill')).delete(synchronize_session='evaluate') @@ -1650,8 +1667,9 @@ class UpdateDeleteTest(_base.MappedTest): sess.rollback() assert john in sess and jill in sess - @testing.resolve_artifact_names def test_delete_rollback_with_fetch(self): + User = self.classes.User + sess = sessionmaker()() john,jack,jill,jane = sess.query(User).order_by(User.id).all() sess.query(User).filter(or_(User.name == 'john', User.name == 'jill')).delete(synchronize_session='fetch') @@ -1659,8 +1677,9 @@ class UpdateDeleteTest(_base.MappedTest): sess.rollback() assert john in sess and jill in sess - @testing.resolve_artifact_names def test_delete_without_session_sync(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1670,8 +1689,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(User).order_by(User.id).all(), [jack,jane]) - @testing.resolve_artifact_names def test_delete_with_fetch_strategy(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1682,8 +1702,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(User).order_by(User.id).all(), [jack,jane]) @testing.fails_on('mysql', 'FIXME: unknown') - @testing.resolve_artifact_names def test_delete_invalid_evaluation(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1698,8 +1719,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(User).order_by(User.id).all(), [jack,jill,jane]) - @testing.resolve_artifact_names def test_update(self): + User, users = self.classes.User, self.tables.users + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1720,7 +1742,6 @@ class UpdateDeleteTest(_base.MappedTest): eq_([john.age, jack.age, jill.age, jane.age], [15,27,19,27]) eq_(sess.query(User.age).order_by(User.id).all(), zip([15,27,19,27])) - @testing.resolve_artifact_names @testing.provide_metadata def test_update_attr_names(self): data = Table('data', metadata, @@ -1749,8 +1770,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(d1.cnt, 2) sess.close() - @testing.resolve_artifact_names def test_update_with_bindparams(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1760,8 +1782,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_([john.age, jack.age, jill.age, jane.age], [25,37,29,27]) eq_(sess.query(User.age).order_by(User.id).all(), zip([25,37,29,27])) - @testing.resolve_artifact_names def test_update_changes_resets_dirty(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False, autoflush=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1785,8 +1808,9 @@ class UpdateDeleteTest(_base.MappedTest): assert not sess.is_modified(john) assert not sess.is_modified(jack) - @testing.resolve_artifact_names def test_update_changes_with_autoflush(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False, autoflush=True) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1810,8 +1834,9 @@ class UpdateDeleteTest(_base.MappedTest): - @testing.resolve_artifact_names def test_update_with_expire_strategy(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1821,8 +1846,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(User.age).order_by(User.id).all(), zip([25,37,29,27])) @testing.fails_if(lambda: not testing.db.dialect.supports_sane_rowcount) - @testing.resolve_artifact_names def test_update_returns_rowcount(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) rowcount = sess.query(User).filter(User.age > 29).update({'age': User.age + 0}) @@ -1832,15 +1858,17 @@ class UpdateDeleteTest(_base.MappedTest): eq_(rowcount, 2) @testing.fails_if(lambda: not testing.db.dialect.supports_sane_rowcount) - @testing.resolve_artifact_names def test_delete_returns_rowcount(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) rowcount = sess.query(User).filter(User.age > 26).delete(synchronize_session=False) eq_(rowcount, 3) - @testing.resolve_artifact_names def test_update_with_eager_relationships(self): + Document = self.classes.Document + self.insert_documents() sess = create_session(bind=testing.db, autocommit=False) @@ -1851,8 +1879,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_([foo.title, bar.title, baz.title], ['foofoo','barbar', 'baz']) eq_(sess.query(Document.title).order_by(Document.id).all(), zip(['foofoo','barbar', 'baz'])) - @testing.resolve_artifact_names def test_update_with_explicit_joinedload(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1861,8 +1890,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_([john.age, jack.age, jill.age, jane.age], [25,37,29,27]) eq_(sess.query(User.age).order_by(User.id).all(), zip([25,37,29,27])) - @testing.resolve_artifact_names def test_delete_with_eager_relationships(self): + Document = self.classes.Document + self.insert_documents() sess = create_session(bind=testing.db, autocommit=False) @@ -1871,8 +1901,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_(sess.query(Document.title).all(), zip(['baz'])) - @testing.resolve_artifact_names def test_update_all(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -1881,8 +1912,9 @@ class UpdateDeleteTest(_base.MappedTest): eq_([john.age, jack.age, jill.age, jane.age], [42,42,42,42]) eq_(sess.query(User.age).order_by(User.id).all(), zip([42,42,42,42])) - @testing.resolve_artifact_names def test_delete_all(self): + User = self.classes.User + sess = create_session(bind=testing.db, autocommit=False) john,jack,jill,jane = sess.query(User).order_by(User.id).all() @@ -2153,31 +2185,24 @@ class OptionsNoPropTest(_base.MappedTest): """ - @testing.resolve_artifact_names def test_option_with_mapper_using_basestring(self): self._assert_option([Item], 'keywords') - @testing.resolve_artifact_names def test_option_with_mapper_using_PropCompatator(self): self._assert_option([Item], Item.keywords) - @testing.resolve_artifact_names def test_option_with_mapper_then_column_using_basestring(self): self._assert_option([Item, Item.id], 'keywords') - @testing.resolve_artifact_names def test_option_with_mapper_then_column_using_PropComparator(self): self._assert_option([Item, Item.id], Item.keywords) - @testing.resolve_artifact_names def test_option_with_column_then_mapper_using_basestring(self): self._assert_option([Item.id, Item], 'keywords') - @testing.resolve_artifact_names def test_option_with_column_then_mapper_using_PropComparator(self): self._assert_option([Item.id, Item], Item.keywords) - @testing.resolve_artifact_names def test_option_with_column_using_basestring(self): message = \ "Can't find property named 'keywords' on the first mapped "\ @@ -2186,7 +2211,6 @@ class OptionsNoPropTest(_base.MappedTest): self._assert_eager_with_just_column_exception(Item.id, 'keywords', message) - @testing.resolve_artifact_names def test_option_with_column_using_PropComparator(self): message = \ "Can't find property 'keywords' on any entity specified "\ @@ -2199,14 +2223,12 @@ class OptionsNoPropTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): mapper(Keyword, keywords) mapper(Item, items, properties=dict(keywords=relationship(Keyword, secondary=item_keywords))) - @testing.resolve_artifact_names def _assert_option(self, entity_list, option): q = create_session().query(*entity_list).\ options(eagerload(option)) diff --git a/test/orm/test_relationships.py b/test/orm/test_relationships.py index feb5c85036..a12076bad5 100644 --- a/test/orm/test_relationships.py +++ b/test/orm/test_relationships.py @@ -55,8 +55,16 @@ class DependencyTwoParentTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + A, C, B, D, tbl_b, tbl_c, tbl_a, tbl_d = (cls.classes.A, + cls.classes.C, + cls.classes.B, + cls.classes.D, + cls.tables.tbl_b, + cls.tables.tbl_c, + cls.tables.tbl_a, + cls.tables.tbl_d) + mapper(A, tbl_a, properties=dict( c_rows=relationship(C, cascade="all, delete-orphan", backref="a_row"))) @@ -68,8 +76,12 @@ class DependencyTwoParentTest(_base.MappedTest): b_row=relationship(B))) @classmethod - @testing.resolve_artifact_names def insert_data(cls): + A, C, B, D = (cls.classes.A, + cls.classes.C, + cls.classes.B, + cls.classes.D) + session = create_session() a = A(name='a1') b = B(name='b1') @@ -82,16 +94,18 @@ class DependencyTwoParentTest(_base.MappedTest): session.add(b) session.flush() - @testing.resolve_artifact_names def testDeleteRootTable(self): + A = self.classes.A + session = create_session() a = session.query(A).filter_by(name='a1').one() session.delete(a) session.flush() - @testing.resolve_artifact_names def testDeleteMiddleTable(self): + C = self.classes.C + session = create_session() c = session.query(C).filter_by(name='c1').one() @@ -152,8 +166,12 @@ class CompositeSelfRefFKTest(_base.MappedTest): self.emp_id = emp_id self.reports_to = reports_to - @testing.resolve_artifact_names def test_explicit(self): + Employee, Company, employee_t, company_t = (self.classes.Employee, + self.classes.Company, + self.tables.employee_t, + self.tables.company_t) + mapper(Company, company_t) mapper(Employee, employee_t, properties= { 'company':relationship(Company, @@ -172,8 +190,12 @@ class CompositeSelfRefFKTest(_base.MappedTest): self._test() - @testing.resolve_artifact_names def test_implicit(self): + Employee, Company, employee_t, company_t = (self.classes.Employee, + self.classes.Company, + self.tables.employee_t, + self.tables.company_t) + mapper(Company, company_t) mapper(Employee, employee_t, properties= { 'company':relationship(Company, backref='employees'), @@ -186,8 +208,12 @@ class CompositeSelfRefFKTest(_base.MappedTest): self._test() - @testing.resolve_artifact_names def test_very_implicit(self): + Employee, Company, employee_t, company_t = (self.classes.Employee, + self.classes.Company, + self.tables.employee_t, + self.tables.company_t) + mapper(Company, company_t) mapper(Employee, employee_t, properties= { 'company':relationship(Company, backref='employees'), @@ -199,8 +225,12 @@ class CompositeSelfRefFKTest(_base.MappedTest): self._test() - @testing.resolve_artifact_names def test_very_explicit(self): + Employee, Company, employee_t, company_t = (self.classes.Employee, + self.classes.Company, + self.tables.employee_t, + self.tables.company_t) + mapper(Company, company_t) mapper(Employee, employee_t, properties= { 'company':relationship(Company, backref='employees'), @@ -216,8 +246,9 @@ class CompositeSelfRefFKTest(_base.MappedTest): self._test() - @testing.resolve_artifact_names def _test(self): + Employee, Company = self.classes.Employee, self.classes.Company + sess = create_session() c1 = Company() c2 = Company() @@ -287,8 +318,12 @@ class ComplexPostUpdateTest(_base.MappedTest): ["pages.jobno", "pages.pagename"])) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + pageversions, pagecomments, jobs, pages = (cls.tables.pageversions, + cls.tables.pagecomments, + cls.tables.jobs, + cls.tables.pages) + class Job(_base.Entity): def create_page(self, pagename): return Page(job=self, pagename=pagename) @@ -352,8 +387,9 @@ class ComplexPostUpdateTest(_base.MappedTest): cascade="all, delete-orphan", order_by=pagecomments.c.comment_id))}) - @testing.resolve_artifact_names def test_basic(self): + Job = self.classes.Job + """A combination of complicated join conditions with post_update.""" j1 = Job(jobno=u'somejob') @@ -411,8 +447,12 @@ class FKsAsPksTest(_base.MappedTest): class B(_base.Entity): pass - @testing.resolve_artifact_names def test_onetoone_switch(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + """test that active history is enabled on a one-to-many/one that has use_get==True""" @@ -433,8 +473,12 @@ class FKsAsPksTest(_base.MappedTest): a1.b = B() sess.flush() - @testing.resolve_artifact_names def test_no_delete_PK_AtoB(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + """A cant be deleted without B because B would have no PK value.""" mapper(A, tableA, properties={ 'bs':relationship(B, cascade="save-update")}) @@ -455,8 +499,12 @@ class FKsAsPksTest(_base.MappedTest): "Dependency rule tried to blank-out " "primary key column 'tableB.id' on instance ") - @testing.resolve_artifact_names def test_no_delete_PK_BtoA(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + mapper(B, tableB, properties={ 'a':relationship(A, cascade="save-update")}) mapper(A, tableA) @@ -477,8 +525,9 @@ class FKsAsPksTest(_base.MappedTest): "primary key column 'tableB.id' on instance ") @testing.fails_on_everything_except('sqlite', 'mysql') - @testing.resolve_artifact_names def test_nullPKsOK_BtoA(self): + A, tableA = self.classes.A, self.tables.tableA + # postgresql cant handle a nullable PK column...? tableC = Table('tablec', tableA.metadata, Column('id', Integer, primary_key=True), @@ -501,8 +550,12 @@ class FKsAsPksTest(_base.MappedTest): # test that no error is raised. sess.flush() - @testing.resolve_artifact_names def test_delete_cascade_BtoA(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + """No 'blank the PK' error when the child is to be deleted as part of a cascade""" @@ -527,8 +580,12 @@ class FKsAsPksTest(_base.MappedTest): sess.expunge_all() sa.orm.clear_mappers() - @testing.resolve_artifact_names def test_delete_cascade_AtoB(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + """No 'blank the PK' error when the child is to be deleted as part of a cascade""" @@ -554,8 +611,12 @@ class FKsAsPksTest(_base.MappedTest): sess.expunge_all() sa.orm.clear_mappers() - @testing.resolve_artifact_names def test_delete_manual_AtoB(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + mapper(A, tableA, properties={ 'bs':relationship(B, cascade="none")}) mapper(B, tableB) @@ -575,8 +636,12 @@ class FKsAsPksTest(_base.MappedTest): assert b1 not in sess sess.expunge_all() - @testing.resolve_artifact_names def test_delete_manual_BtoA(self): + tableB, A, B, tableA = (self.tables.tableB, + self.classes.A, + self.classes.B, + self.tables.tableA) + mapper(B, tableB, properties={ 'a':relationship(A, cascade="none")}) mapper(A, tableA) @@ -622,8 +687,12 @@ class UniqueColReferenceSwitchTest(_base.MappedTest): class B(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_switch_parent(self): + A, B, table_b, table_a = (self.classes.A, + self.classes.B, + self.tables.table_b, + self.tables.table_a) + mapper(A, table_a) mapper(B, table_b, properties={"a": relationship(A, backref="bs")}) @@ -657,8 +726,9 @@ class RelationshipToSelectableTest(_base.MappedTest): Column('item_id', Integer, primary_key=True, key='id', autoincrement=False)) - @testing.resolve_artifact_names def test_basic(self): + items = self.tables.items + class Container(_base.Entity): pass class LineItem(_base.Entity): @@ -729,8 +799,9 @@ class FKEquatedToConstantTest(_base.MappedTest): Column("data", String(50)), ) - @testing.resolve_artifact_names def test_basic(self): + tag_foo, tags = self.tables.tag_foo, self.tables.tags + class Tag(_base.ComparableEntity): pass class TagInstance(_base.ComparableEntity): @@ -789,8 +860,12 @@ class BackrefPropagatesForwardsArgs(_base.MappedTest): class Address(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_backref(self): + User, Address, users, addresses = (self.classes.User, + self.classes.Address, + self.tables.users, + self.tables.addresses) + mapper(User, users, properties={ 'addresses':relationship(Address, @@ -835,8 +910,9 @@ class AmbiguousJoinInterpretedAsSelfRef(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + subscriber, address = cls.tables.subscriber, cls.tables.address + subscriber_and_address = subscriber.join(address, and_(address.c.subscriber_id==subscriber.c.id, address.c.type.in_(['A', 'B', 'C']))) @@ -855,8 +931,9 @@ class AmbiguousJoinInterpretedAsSelfRef(_base.MappedTest): backref=backref("customer")) }) - @testing.resolve_artifact_names def test_mapping(self): + Subscriber, Address = self.classes.Subscriber, self.classes.Address + from sqlalchemy.orm.interfaces import ONETOMANY, MANYTOONE sess = create_session() assert Subscriber.addresses.property.direction is ONETOMANY @@ -893,8 +970,12 @@ class ManualBackrefTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_o2m(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, back_populates='user') }) @@ -917,8 +998,12 @@ class ManualBackrefTest(_fixtures.FixtureTest): assert a1.user is u1 assert a1 in u1.addresses - @testing.resolve_artifact_names def test_invalid_key(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, back_populates='userr') }) @@ -929,8 +1014,14 @@ class ManualBackrefTest(_fixtures.FixtureTest): assert_raises(sa.exc.InvalidRequestError, configure_mappers) - @testing.resolve_artifact_names def test_invalid_target(self): + addresses, Dingaling, User, dingalings, Address, users = (self.tables.addresses, + self.classes.Dingaling, + self.classes.User, + self.tables.dingalings, + self.classes.Address, + self.tables.users) + mapper(User, users, properties={ 'addresses':relationship(Address, back_populates='dingaling'), }) @@ -1106,8 +1197,11 @@ class TypeMatchTest(_base.MappedTest): Column("a_id", Integer, ForeignKey("a.aid")), Column('data', String(30))) - @testing.resolve_artifact_names def test_o2m_oncascade(self): + a, c, b = (self.tables.a, + self.tables.c, + self.tables.b) + class A(_base.Entity): pass class B(_base.Entity): pass class C(_base.Entity): pass @@ -1129,8 +1223,11 @@ class TypeMatchTest(_base.MappedTest): "Attribute 'bs' on class '%s' doesn't handle " "objects of type '%s'" % (A, C)) - @testing.resolve_artifact_names def test_o2m_onflush(self): + a, c, b = (self.tables.a, + self.tables.c, + self.tables.b) + class A(_base.Entity): pass class B(_base.Entity): pass class C(_base.Entity): pass @@ -1151,8 +1248,11 @@ class TypeMatchTest(_base.MappedTest): "Attempting to flush an item", sess.flush) - @testing.resolve_artifact_names def test_o2m_nopoly_onflush(self): + a, c, b = (self.tables.a, + self.tables.c, + self.tables.b) + class A(_base.Entity): pass class B(_base.Entity): pass class C(B): pass @@ -1173,8 +1273,11 @@ class TypeMatchTest(_base.MappedTest): "Attempting to flush an item", sess.flush) - @testing.resolve_artifact_names def test_m2o_nopoly_onflush(self): + a, b, d = (self.tables.a, + self.tables.b, + self.tables.d) + class A(_base.Entity): pass class B(A): pass class D(_base.Entity): pass @@ -1191,8 +1294,11 @@ class TypeMatchTest(_base.MappedTest): "Attempting to flush an item", sess.flush) - @testing.resolve_artifact_names def test_m2o_oncascade(self): + a, b, d = (self.tables.a, + self.tables.b, + self.tables.d) + class A(_base.Entity): pass class B(_base.Entity): pass class D(_base.Entity): pass @@ -1228,8 +1334,11 @@ class TypedAssociationTable(_base.MappedTest): Column('t1c1', MySpecialType(30), ForeignKey('t1.col1')), Column('t2c1', MySpecialType(30), ForeignKey('t2.col1'))) - @testing.resolve_artifact_names def testm2m(self): + t2, t3, t1 = (self.tables.t2, + self.tables.t3, + self.tables.t1) + """Many-to-many tables with special types for candidate keys.""" class T1(_base.Entity): pass @@ -1274,8 +1383,11 @@ class ViewOnlyM2MBackrefTest(_base.MappedTest): Column('t2id', Integer, ForeignKey('t2.id'), primary_key=True), ) - @testing.resolve_artifact_names def test_viewonly(self): + t1t2, t2, t1 = (self.tables.t1t2, + self.tables.t2, + self.tables.t1) + class A(_base.ComparableEntity):pass class B(_base.ComparableEntity):pass @@ -1318,8 +1430,11 @@ class ViewOnlyOverlappingNames(_base.MappedTest): Column('data', String(40)), Column('t2id', Integer, ForeignKey('t2.id'))) - @testing.resolve_artifact_names def test_three_table_view(self): + t2, t3, t1 = (self.tables.t2, + self.tables.t3, + self.tables.t1) + """A three table join with overlapping PK names. A third table is pulled into the primary join condition using @@ -1381,8 +1496,11 @@ class ViewOnlyUniqueNames(_base.MappedTest): Column('data', String(40)), Column('t2id_ref', Integer, ForeignKey('t2.t2id'))) - @testing.resolve_artifact_names def test_three_table_view(self): + t2, t3, t1 = (self.tables.t2, + self.tables.t3, + self.tables.t1) + """A three table join with overlapping PK names. A third table is pulled into the primary join condition using unique @@ -1466,8 +1584,9 @@ class ViewOnlyNonEquijoin(_base.MappedTest): Column('id', Integer, primary_key=True), Column('fid', Integer)) - @testing.resolve_artifact_names def test_viewonly_join(self): + bars, foos = self.tables.bars, self.tables.foos + class Foo(_base.ComparableEntity): pass class Bar(_base.ComparableEntity): @@ -1511,8 +1630,9 @@ class ViewOnlyRepeatedRemoteColumn(_base.MappedTest): Column('id', Integer, primary_key=True, test_needs_autoincrement=True), Column('data', String(50))) - @testing.resolve_artifact_names def test_relationship_on_or(self): + bars, foos = self.tables.bars, self.tables.foos + class Foo(_base.ComparableEntity): pass class Bar(_base.ComparableEntity): @@ -1561,8 +1681,9 @@ class ViewOnlyRepeatedLocalColumn(_base.MappedTest): Column('fid2', Integer, ForeignKey('foos.id')), Column('data', String(50))) - @testing.resolve_artifact_names def test_relationship_on_or(self): + bars, foos = self.tables.bars, self.tables.foos + class Foo(_base.ComparableEntity): pass class Bar(_base.ComparableEntity): @@ -1626,8 +1747,15 @@ class ViewOnlyComplexJoin(_base.MappedTest): class T3(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_basic(self): + T1, t2, T2, T3, t3, t2tot3, t1 = (self.classes.T1, + self.tables.t2, + self.classes.T2, + self.classes.T3, + self.tables.t3, + self.tables.t2tot3, + self.tables.t1) + mapper(T1, t1, properties={ 't3s':relationship(T3, primaryjoin=sa.and_( t1.c.id==t2.c.t1id, @@ -1651,8 +1779,15 @@ class ViewOnlyComplexJoin(_base.MappedTest): eq_(a.t3s, [T3(data='t3')]) - @testing.resolve_artifact_names def test_remote_side_escalation(self): + T1, t2, T2, T3, t3, t2tot3, t1 = (self.classes.T1, + self.tables.t2, + self.classes.T2, + self.classes.T3, + self.tables.t3, + self.tables.t2tot3, + self.tables.t1) + mapper(T1, t1, properties={ 't3s':relationship(T3, primaryjoin=sa.and_(t1.c.id==t2.c.t1id, @@ -1685,15 +1820,18 @@ class ExplicitLocalRemoteTest(_base.MappedTest): Column('t1id', String(50))) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): class T1(_base.ComparableEntity): pass class T2(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_onetomany_funcfk(self): + T2, T1, t2, t1 = (self.classes.T2, + self.classes.T1, + self.tables.t2, + self.tables.t1) + # use a function within join condition. but specifying # local_remote_pairs overrides all parsing of the join condition. mapper(T1, t1, properties={ @@ -1718,8 +1856,12 @@ class ExplicitLocalRemoteTest(_base.MappedTest): T2(data='b1', t1id='NuMbEr1'), T2(data='b2', t1id='Number1')])) - @testing.resolve_artifact_names def test_manytoone_funcfk(self): + T2, T1, t2, t1 = (self.classes.T2, + self.classes.T1, + self.tables.t2, + self.tables.t1) + mapper(T1, t1) mapper(T2, t2, properties={ 't1':relationship(T1, @@ -1742,8 +1884,12 @@ class ExplicitLocalRemoteTest(_base.MappedTest): [T2(data='b1', t1=[T1(id='number1', data='a1')]), T2(data='b2', t1=[T1(id='number1', data='a1')])]) - @testing.resolve_artifact_names def test_onetomany_func_referent(self): + T2, T1, t2, t1 = (self.classes.T2, + self.classes.T1, + self.tables.t2, + self.tables.t1) + mapper(T1, t1, properties={ 't2s':relationship(T2, primaryjoin=sa.func.lower(t1.c.id)==t2.c.t1id, @@ -1766,8 +1912,12 @@ class ExplicitLocalRemoteTest(_base.MappedTest): T2(data='b1', t1id='number1'), T2(data='b2', t1id='number1')])) - @testing.resolve_artifact_names def test_manytoone_func_referent(self): + T2, T1, t2, t1 = (self.classes.T2, + self.classes.T1, + self.tables.t2, + self.tables.t1) + mapper(T1, t1) mapper(T2, t2, properties={ 't1':relationship(T1, @@ -1789,8 +1939,12 @@ class ExplicitLocalRemoteTest(_base.MappedTest): [T2(data='b1', t1=[T1(id='NuMbeR1', data='a1')]), T2(data='b2', t1=[T1(id='NuMbeR1', data='a1')])]) - @testing.resolve_artifact_names def test_escalation_1(self): + T2, T1, t2, t1 = (self.classes.T2, + self.classes.T1, + self.tables.t2, + self.tables.t1) + mapper(T1, t1, properties={ 't2s':relationship(T2, primaryjoin=t1.c.id==sa.func.lower(t2.c.t1id), @@ -1800,8 +1954,12 @@ class ExplicitLocalRemoteTest(_base.MappedTest): mapper(T2, t2) assert_raises(sa.exc.ArgumentError, sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_escalation_2(self): + T2, T1, t2, t1 = (self.classes.T2, + self.classes.T1, + self.tables.t2, + self.tables.t1) + mapper(T1, t1, properties={ 't2s':relationship(T2, primaryjoin=t1.c.id==sa.func.lower(t2.c.t1id), @@ -1819,13 +1977,13 @@ class InvalidRemoteSideTest(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): class T1(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_o2m_backref(self): + T1, t1 = self.classes.T1, self.tables.t1 + mapper(T1, t1, properties={ 't1s':relationship(T1, backref='parent') }) @@ -1836,8 +1994,9 @@ class InvalidRemoteSideTest(_base.MappedTest): "mean to set remote_side on the many-to-one side ?", configure_mappers) - @testing.resolve_artifact_names def test_m2o_backref(self): + T1, t1 = self.classes.T1, self.tables.t1 + mapper(T1, t1, properties={ 't1s':relationship(T1, backref=backref('parent', remote_side=t1.c.id), @@ -1850,8 +2009,9 @@ class InvalidRemoteSideTest(_base.MappedTest): "mean to set remote_side on the many-to-one side ?", configure_mappers) - @testing.resolve_artifact_names def test_o2m_explicit(self): + T1, t1 = self.classes.T1, self.tables.t1 + mapper(T1, t1, properties={ 't1s':relationship(T1, back_populates='parent'), 'parent':relationship(T1, back_populates='t1s'), @@ -1863,8 +2023,9 @@ class InvalidRemoteSideTest(_base.MappedTest): "mean to set remote_side on the many-to-one side ?", configure_mappers) - @testing.resolve_artifact_names def test_m2o_explicit(self): + T1, t1 = self.classes.T1, self.tables.t1 + mapper(T1, t1, properties={ 't1s':relationship(T1, back_populates='parent', remote_side=t1.c.id), @@ -1904,8 +2065,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): class Bar(_base.Entity): pass - @testing.resolve_artifact_names def test_no_join(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar)}) mapper(Bar, bars) @@ -1915,8 +2080,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "Could not determine join condition between parent/child " "tables on relationship", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_join_self_ref(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'foos':relationship(Foo)}) mapper(Bar, bars) @@ -1926,8 +2095,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "Could not determine join condition between parent/child " "tables on relationship", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_equated(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id>bars.c.fid)}) @@ -1939,8 +2112,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "for primaryjoin condition", configure_mappers) - @testing.resolve_artifact_names def test_no_equated_fks(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id>bars.c.fid, @@ -1956,8 +2133,13 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "conditions, the relationship may be marked as viewonly=True.", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_equated_wo_fks_works_on_relaxed(self): + foos_with_fks, Foo, Bar, bars_with_fks, foos = (self.tables.foos_with_fks, + self.classes.Foo, + self.classes.Bar, + self.tables.bars_with_fks, + self.tables.foos) + # very unique - the join between parent/child # has no fks, but there is an fk join between two other # tables in the join condition, for those users that try creating @@ -1987,8 +2169,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "may be marked as viewonly=True.", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_ambiguous_fks(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id==bars.c.fid, @@ -2010,8 +2196,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): r"'foreign_keys' is usually unnecessary\)\?" , sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_ambiguous_remoteside_o2m(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id==bars.c.fid, @@ -2026,8 +2216,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "could not determine any local/remote column pairs", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_ambiguous_remoteside_m2o(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id==bars.c.fid, @@ -2043,8 +2237,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_equated_self_ref(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'foos':relationship(Foo, primaryjoin=foos.c.id>foos.c.fid)}) @@ -2056,8 +2254,12 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "condition", configure_mappers) - @testing.resolve_artifact_names def test_no_equated_self_ref(self): + bars, Foo, Bar, foos = (self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'foos':relationship(Foo, primaryjoin=foos.c.id>foos.c.fid, @@ -2073,8 +2275,14 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): "conditions, the relationship may be marked as viewonly=True.", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_equated_viewonly(self): + bars, Bar, bars_with_fks, foos_with_fks, Foo, foos = (self.tables.bars, + self.classes.Bar, + self.tables.bars_with_fks, + self.tables.foos_with_fks, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id>bars.c.fid, @@ -2094,8 +2302,14 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): mapper(Bar, bars_with_fks) sa.orm.configure_mappers() - @testing.resolve_artifact_names def test_no_equated_self_ref_viewonly(self): + bars, Bar, bars_with_fks, foos_with_fks, Foo, foos = (self.tables.bars, + self.classes.Bar, + self.tables.bars_with_fks, + self.tables.foos_with_fks, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'foos':relationship(Foo, primaryjoin=foos.c.id>foos.c.fid, @@ -2120,8 +2334,9 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): mapper(Bar, bars_with_fks) sa.orm.configure_mappers() - @testing.resolve_artifact_names def test_no_equated_self_ref_viewonly_fks(self): + Foo, foos = self.classes.Foo, self.tables.foos + mapper(Foo, foos, properties={ 'foos':relationship(Foo, primaryjoin=foos.c.id>foos.c.fid, @@ -2131,8 +2346,14 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): sa.orm.configure_mappers() eq_(Foo.foos.property.local_remote_pairs, [(foos.c.id, foos.c.fid)]) - @testing.resolve_artifact_names def test_equated(self): + bars, Bar, bars_with_fks, foos_with_fks, Foo, foos = (self.tables.bars, + self.classes.Bar, + self.tables.bars_with_fks, + self.tables.foos_with_fks, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, primaryjoin=foos.c.id==bars.c.fid)}) @@ -2151,8 +2372,9 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): mapper(Bar, bars_with_fks) sa.orm.configure_mappers() - @testing.resolve_artifact_names def test_equated_self_ref(self): + Foo, foos = self.classes.Foo, self.tables.foos + mapper(Foo, foos, properties={ 'foos':relationship(Foo, primaryjoin=foos.c.id==foos.c.fid)}) @@ -2164,8 +2386,11 @@ class InvalidRelationshipEscalationTest(_base.MappedTest): configure_mappers) - @testing.resolve_artifact_names def test_equated_self_ref_wrong_fks(self): + bars, Foo, foos = (self.tables.bars, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'foos':relationship(Foo, primaryjoin=foos.c.id==foos.c.fid, @@ -2204,15 +2429,19 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): ) @classmethod - @testing.resolve_artifact_names def setup_classes(cls): class Foo(_base.Entity): pass class Bar(_base.Entity): pass - @testing.resolve_artifact_names def test_no_join(self): + foobars, bars, Foo, Bar, foos = (self.tables.foobars, + self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars': relationship(Bar, secondary=foobars)}) mapper(Bar, bars) @@ -2222,8 +2451,13 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): "Could not determine join condition between parent/child tables " "on relationship", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_secondaryjoin(self): + foobars, bars, Foo, Bar, foos = (self.tables.foobars, + self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars': relationship(Bar, secondary=foobars, @@ -2236,8 +2470,14 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): "on relationship", sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_fks_warning_1(self): + foobars_with_many_columns, bars, Bar, foobars, Foo, foos = (self.tables.foobars_with_many_columns, + self.tables.bars, + self.classes.Bar, + self.tables.foobars, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars': relationship(Bar, secondary=foobars, primaryjoin=foos.c.id==foobars.c.fid, @@ -2279,8 +2519,14 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): sa.orm.configure_mappers) @testing.emits_warning(r'No ForeignKey objects.*') - @testing.resolve_artifact_names def test_no_fks_warning_2(self): + foobars_with_many_columns, bars, Bar, foobars, Foo, foos = (self.tables.foobars_with_many_columns, + self.tables.bars, + self.classes.Bar, + self.tables.foobars, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars': relationship(Bar, secondary=foobars, primaryjoin=foos.c.id==foobars.c.fid, @@ -2316,8 +2562,14 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): ) - @testing.resolve_artifact_names def test_bad_primaryjoin(self): + foobars_with_fks, bars, Bar, foobars, Foo, foos = (self.tables.foobars_with_fks, + self.tables.bars, + self.classes.Bar, + self.tables.foobars, + self.classes.Foo, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars': relationship(Bar, secondary=foobars, @@ -2361,8 +2613,13 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): mapper(Bar, bars) sa.orm.configure_mappers() - @testing.resolve_artifact_names def test_bad_secondaryjoin(self): + foobars, bars, Foo, Bar, foos = (self.tables.foobars, + self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, secondary=foobars, @@ -2386,8 +2643,13 @@ class InvalidRelationshipEscalationTestM2M(_base.MappedTest): r"'foreign_keys' is usually unnecessary\)?" , sa.orm.configure_mappers) - @testing.resolve_artifact_names def test_no_equated_secondaryjoin(self): + foobars, bars, Foo, Bar, foos = (self.tables.foobars, + self.tables.bars, + self.classes.Foo, + self.classes.Bar, + self.tables.foos) + mapper(Foo, foos, properties={ 'bars':relationship(Bar, secondary=foobars, @@ -2420,8 +2682,9 @@ class ActiveHistoryFlagTest(_fixtures.FixtureTest): ([newvalue,], (), [oldvalue,]) ) - @testing.resolve_artifact_names def test_column_property_flag(self): + User, users = self.classes.User, self.tables.users + mapper(User, users, properties={ 'name':column_property(users.c.name, active_history=True) @@ -2429,8 +2692,12 @@ class ActiveHistoryFlagTest(_fixtures.FixtureTest): u1 = User(name='jack') self._test_attribute(u1, 'name', 'ed') - @testing.resolve_artifact_names def test_relationship_property_flag(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses, properties={ 'user':relationship(User, active_history=True) }) @@ -2440,8 +2707,9 @@ class ActiveHistoryFlagTest(_fixtures.FixtureTest): a1 = Address(email_address='a1', user=u1) self._test_attribute(a1, 'user', u2) - @testing.resolve_artifact_names def test_composite_property_flag(self): + Order, orders = self.classes.Order, self.tables.orders + class MyComposite(object): def __init__(self, description, isopen): self.description = description @@ -2507,8 +2775,12 @@ class RelationDeprecationTest(_base.MappedTest): (3, 2, 'ed@foo.bar', 'Personal', 0), (4, 3, 'fred@the.fred', 'Personal', 10))) - @testing.resolve_artifact_names def test_relation(self): + addresses_table, User, users_table, Address = (self.tables.addresses_table, + self.classes.User, + self.tables.users_table, + self.classes.Address) + mapper(User, users_table, properties=dict( addresses=relation(Address, backref='user'), )) diff --git a/test/orm/test_scoping.py b/test/orm/test_scoping.py index 2ea1960f16..c7e1b566c2 100644 --- a/test/orm/test_scoping.py +++ b/test/orm/test_scoping.py @@ -40,8 +40,9 @@ class ScopedSessionTest(_base.MappedTest): Column('id', Integer, primary_key=True, test_needs_autoincrement=True), Column('someid', None, ForeignKey('table1.id'))) - @testing.resolve_artifact_names def test_basic(self): + table2, table1 = self.tables.table2, self.tables.table1 + Session = scoped_session(sa.orm.sessionmaker()) class CustomQuery(query.Query): diff --git a/test/orm/test_selectable.py b/test/orm/test_selectable.py index d1cf29751a..bbbf3b3317 100644 --- a/test/orm/test_selectable.py +++ b/test/orm/test_selectable.py @@ -25,8 +25,9 @@ class SelectableNoFromsTest(_base.MappedTest, AssertsCompiledSQL): class Subset(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_no_tables(self): + Subset = self.classes.Subset + selectable = select(["x", "y", "z"]).alias() mapper(Subset, selectable, primary_key=[selectable.c.x]) @@ -37,8 +38,9 @@ class SelectableNoFromsTest(_base.MappedTest, AssertsCompiledSQL): use_default_dialect=True ) - @testing.resolve_artifact_names def test_no_table_needs_pl(self): + Subset = self.classes.Subset + selectable = select(["x", "y", "z"]).alias() assert_raises_message( @@ -47,13 +49,15 @@ class SelectableNoFromsTest(_base.MappedTest, AssertsCompiledSQL): mapper, Subset, selectable ) - @testing.resolve_artifact_names def test_no_selects(self): + Subset, common = self.classes.Subset, self.tables.common + subset_select = select([common.c.id, common.c.data]) assert_raises(sa.exc.InvalidRequestError, mapper, Subset, subset_select) - @testing.resolve_artifact_names def test_basic(self): + Subset, common = self.classes.Subset, self.tables.common + subset_select = select([common.c.id, common.c.data]).alias() subset_mapper = mapper(Subset, subset_select) diff --git a/test/orm/test_session.py b/test/orm/test_session.py index d00854528f..15a9313318 100644 --- a/test/orm/test_session.py +++ b/test/orm/test_session.py @@ -18,8 +18,9 @@ from test.orm import _base, _fixtures class SessionTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_no_close_on_flush(self): + User, users = self.classes.User, self.tables.users + """Flush() doesn't close a connection the session didn't open""" c = testing.db.connect() c.execute("select * from users") @@ -30,8 +31,9 @@ class SessionTest(_fixtures.FixtureTest): s.flush() c.execute("select * from users") - @testing.resolve_artifact_names def test_close(self): + User, users = self.classes.User, self.tables.users + """close() doesn't close a connection the session didn't open""" c = testing.db.connect() c.execute("select * from users") @@ -44,8 +46,9 @@ class SessionTest(_fixtures.FixtureTest): s.close() c.execute("select * from users") - @testing.resolve_artifact_names def test_no_close_transaction_on_flulsh(self): + User, users = self.classes.User, self.tables.users + c = testing.db.connect() try: mapper(User, users) @@ -66,8 +69,9 @@ class SessionTest(_fixtures.FixtureTest): finally: c.close() - @testing.resolve_artifact_names def test_object_session_raises(self): + User = self.classes.User + assert_raises( orm_exc.UnmappedInstanceError, object_session, @@ -91,8 +95,12 @@ class SessionTest(_fixtures.FixtureTest): seq.drop(testing.db) - @testing.resolve_artifact_names def test_expunge_cascade(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties={ 'addresses':relationship(Address, @@ -118,8 +126,12 @@ class SessionTest(_fixtures.FixtureTest): assert sa.orm.attributes.instance_state(a).session_id is None @engines.close_open_connections - @testing.resolve_artifact_names def test_mapped_binds(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + # ensure tables are unbound m2 = sa.MetaData() @@ -157,8 +169,12 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @engines.close_open_connections - @testing.resolve_artifact_names def test_table_binds(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + # ensure tables are unbound m2 = sa.MetaData() @@ -194,8 +210,9 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @engines.close_open_connections - @testing.resolve_artifact_names def test_bind_from_metadata(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) session = create_session() @@ -210,8 +227,9 @@ class SessionTest(_fixtures.FixtureTest): @testing.requires.independent_connections @engines.close_open_connections - @testing.resolve_artifact_names def test_transaction(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) conn1 = testing.db.connect() conn2 = testing.db.connect() @@ -231,8 +249,9 @@ class SessionTest(_fixtures.FixtureTest): @testing.requires.independent_connections @engines.close_open_connections - @testing.resolve_artifact_names def test_autoflush(self): + User, users = self.classes.User, self.tables.users + bind = self.metadata.bind mapper(User, users) conn1 = bind.connect() @@ -251,8 +270,9 @@ class SessionTest(_fixtures.FixtureTest): eq_(bind.connect().execute("select count(1) from users").scalar(), 1) sess.close() - @testing.resolve_artifact_names def test_make_transient(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session() sess.add(User(name='test')) @@ -297,8 +317,9 @@ class SessionTest(_fixtures.FixtureTest): sess.flush() assert u1 in sess - @testing.resolve_artifact_names def test_deleted_flag(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = sessionmaker()() @@ -325,8 +346,12 @@ class SessionTest(_fixtures.FixtureTest): eq_(sess.query(User).count(), 1) - @testing.resolve_artifact_names def test_autoflush_expressions(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test that an expression which is dependent on object state is evaluated after the session autoflushes. This is the lambda inside of strategies.py lazy_clause. @@ -355,8 +380,9 @@ class SessionTest(_fixtures.FixtureTest): @testing.requires.independent_connections @engines.close_open_connections - @testing.resolve_artifact_names def test_autoflush_unbound(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) try: sess = create_session(autocommit=False, autoflush=True) @@ -380,8 +406,9 @@ class SessionTest(_fixtures.FixtureTest): raise @engines.close_open_connections - @testing.resolve_artifact_names def test_autoflush_2(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) conn1 = testing.db.connect() conn2 = testing.db.connect() @@ -396,8 +423,12 @@ class SessionTest(_fixtures.FixtureTest): ).scalar() == 1 sess.commit() - @testing.resolve_artifact_names def test_autoflush_rollback(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties={ 'addresses':relationship(Address)}) @@ -421,8 +452,9 @@ class SessionTest(_fixtures.FixtureTest): # pending objects dont get expired assert newad.email_address == 'a new address' - @testing.resolve_artifact_names def test_autocommit_doesnt_raise_on_pending(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) session = create_session(autocommit=True) @@ -440,8 +472,9 @@ class SessionTest(_fixtures.FixtureTest): sess.rollback() assert not sess.is_active - @testing.resolve_artifact_names def test_textual_execute(self): + users = self.tables.users + """test that Session.execute() converts to text()""" sess = create_session(bind=self.metadata.bind) @@ -459,8 +492,9 @@ class SessionTest(_fixtures.FixtureTest): 7) @engines.close_open_connections - @testing.resolve_artifact_names def test_subtransaction_on_external(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) conn = testing.db.connect() trans = conn.begin() @@ -476,8 +510,9 @@ class SessionTest(_fixtures.FixtureTest): @testing.requires.savepoints @engines.close_open_connections - @testing.resolve_artifact_names def test_external_nested_transaction(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) try: conn = testing.db.connect() @@ -500,8 +535,9 @@ class SessionTest(_fixtures.FixtureTest): raise @testing.requires.savepoints - @testing.resolve_artifact_names def test_heavy_nesting(self): + users = self.tables.users + session = create_session(bind=testing.db) session.begin() session.connection().execute(users.insert().values(name='user1' @@ -522,8 +558,9 @@ class SessionTest(_fixtures.FixtureTest): ).scalar() == 2 @testing.requires.independent_connections - @testing.resolve_artifact_names def test_transactions_isolated(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) users.delete().execute() @@ -536,8 +573,12 @@ class SessionTest(_fixtures.FixtureTest): assert s2.query(User).all() == [] @testing.requires.two_phase_transactions - @testing.resolve_artifact_names def test_twophase(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + # TODO: mock up a failure condition here # to ensure a rollback succeeds mapper(User, users) @@ -557,8 +598,9 @@ class SessionTest(_fixtures.FixtureTest): assert users.count().scalar() == 1 assert addresses.count().scalar() == 1 - @testing.resolve_artifact_names def test_subtransaction_on_noautocommit(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session(autocommit=False, autoflush=True) sess.begin(subtransactions=True) @@ -571,8 +613,9 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @testing.requires.savepoints - @testing.resolve_artifact_names def test_nested_transaction(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session() sess.begin() @@ -594,8 +637,9 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @testing.requires.savepoints - @testing.resolve_artifact_names def test_nested_autotrans(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) sess = create_session(autocommit=False) u = User(name='u1') @@ -615,8 +659,9 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @testing.requires.savepoints - @testing.resolve_artifact_names def test_nested_transaction_connection_add(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session(autocommit=True) @@ -650,8 +695,9 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @testing.requires.savepoints - @testing.resolve_artifact_names def test_mixed_transaction_control(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session(autocommit=True) @@ -681,8 +727,9 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @testing.requires.savepoints - @testing.resolve_artifact_names def test_mixed_transaction_close(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session(autocommit=False) @@ -701,8 +748,9 @@ class SessionTest(_fixtures.FixtureTest): eq_(len(sess.query(User).all()), 1) - @testing.resolve_artifact_names def test_error_on_using_inactive_session(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = create_session(autocommit=True) sess.begin() @@ -718,8 +766,9 @@ class SessionTest(_fixtures.FixtureTest): sess.begin, subtransactions=True) sess.close() - @testing.resolve_artifact_names def test_preserve_flush_error(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = Session() @@ -743,8 +792,9 @@ class SessionTest(_fixtures.FixtureTest): sess.commit() - @testing.resolve_artifact_names def test_no_autocommit_with_explicit_commit(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) session = create_session(autocommit=False) session.add(User(name='ed')) @@ -753,8 +803,9 @@ class SessionTest(_fixtures.FixtureTest): 'autocommit=False should start a new transaction' @engines.close_open_connections - @testing.resolve_artifact_names def test_bound_connection(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) c = testing.db.connect() sess = create_session(bind=c) @@ -775,8 +826,9 @@ class SessionTest(_fixtures.FixtureTest): assert len(sess.query(User).all()) == 0 sess.close() - @testing.resolve_artifact_names def test_bound_connection_transactional(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) c = testing.db.connect() @@ -810,8 +862,12 @@ class SessionTest(_fixtures.FixtureTest): assert not c.in_transaction() assert c.scalar("select count(1) from users") == 1 - @testing.resolve_artifact_names def test_bind_arguments(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users) mapper(Address, addresses) @@ -837,8 +893,12 @@ class SessionTest(_fixtures.FixtureTest): sess.close() @engines.close_open_connections - @testing.resolve_artifact_names def test_add_delete(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + s = create_session() mapper(User, users, properties={ @@ -892,8 +952,12 @@ class SessionTest(_fixtures.FixtureTest): assert user not in s assert s.query(User).count() == 0 - @testing.resolve_artifact_names def test_is_modified(self): + User, Address, addresses, users = (self.classes.User, + self.classes.Address, + self.tables.addresses, + self.tables.users) + s = create_session() mapper(User, users, properties={'addresses':relationship(Address)}) @@ -924,8 +988,9 @@ class SessionTest(_fixtures.FixtureTest): assert s.is_modified(user) assert not s.is_modified(user, include_collections=False) - @testing.resolve_artifact_names def test_is_modified_syn(self): + User, users = self.classes.User, self.tables.users + s = sessionmaker()() mapper(User, users, properties={'uname':sa.orm.synonym('name')}) @@ -935,8 +1000,9 @@ class SessionTest(_fixtures.FixtureTest): s.commit() assert not s.is_modified(u) - @testing.resolve_artifact_names def test_weak_ref(self): + users, User = self.tables.users, self.classes.User + """test the weak-referencing identity map, which strongly- references modified items.""" @@ -968,8 +1034,9 @@ class SessionTest(_fixtures.FixtureTest): assert user.name == 'fred' assert s.identity_map - @testing.resolve_artifact_names def test_weak_ref_pickled(self): + users, User = self.tables.users, self.classes.User + s = create_session() mapper(User, users) @@ -999,8 +1066,9 @@ class SessionTest(_fixtures.FixtureTest): assert not s.identity_map @testing.uses_deprecated() - @testing.resolve_artifact_names def test_identity_conflict(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) for s in ( create_session(), @@ -1019,8 +1087,12 @@ class SessionTest(_fixtures.FixtureTest): sa.orm.attributes.instance_state(u2)) - @testing.resolve_artifact_names def test_weakref_with_cycles_o2m(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + s = sessionmaker()() mapper(User, users, properties={ "addresses":relationship(Address, backref="user") @@ -1048,8 +1120,12 @@ class SessionTest(_fixtures.FixtureTest): user = s.query(User).options(joinedload(User.addresses)).one() eq_(user, User(name="ed", addresses=[Address(email_address="ed2")])) - @testing.resolve_artifact_names def test_weakref_with_cycles_o2o(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + s = sessionmaker()() mapper(User, users, properties={ "address":relationship(Address, backref="user", uselist=False) @@ -1079,8 +1155,9 @@ class SessionTest(_fixtures.FixtureTest): eq_(user, User(name="ed", address=Address(email_address="ed2"))) @testing.uses_deprecated() - @testing.resolve_artifact_names def test_strong_ref(self): + users, User = self.tables.users, self.classes.User + s = create_session(weak_identity_map=False) mapper(User, users) @@ -1103,8 +1180,9 @@ class SessionTest(_fixtures.FixtureTest): @testing.uses_deprecated() @testing.fails_if(lambda: pypy, "pypy has a real GC") @testing.fails_on('+zxjdbc', 'http://www.sqlalchemy.org/trac/ticket/1473') - @testing.resolve_artifact_names def test_prune(self): + users, User = self.tables.users, self.classes.User + s = create_session(weak_identity_map=False) mapper(User, users) @@ -1153,8 +1231,9 @@ class SessionTest(_fixtures.FixtureTest): self.assert_(len(s.identity_map) == 0) - @testing.resolve_artifact_names def test_pickled_update(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess1 = create_session() sess2 = create_session() @@ -1166,8 +1245,9 @@ class SessionTest(_fixtures.FixtureTest): u2 = pickle.loads(pickle.dumps(u1)) sess2.add(u2) - @testing.resolve_artifact_names def test_duplicate_update(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) Session = sessionmaker() sess = Session() @@ -1206,8 +1286,9 @@ class SessionTest(_fixtures.FixtureTest): u3 = sess.query(User).get(u1.id) assert u3 is not u1 and u3 is not u2 and u3.name == u1.name - @testing.resolve_artifact_names def test_no_double_save(self): + users = self.tables.users + sess = create_session() class Foo(object): def __init__(self): @@ -1223,8 +1304,9 @@ class SessionTest(_fixtures.FixtureTest): assert b in sess assert len(list(sess)) == 1 - @testing.resolve_artifact_names def test_identity_map_mutate(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) sess = Session() @@ -1456,9 +1538,11 @@ class SessionInterface(testing.TestBase): self._test_class_guards(early) -class TLTransactionTest(engine_base.AltEngineTest, _base.MappedTest): +class TLTransactionTest(_base.MappedTest): + run_dispose_bind = 'once' + @classmethod - def create_engine(cls): + def setup_bind(cls): return engines.testing_engine(options=dict(strategy='threadlocal')) @classmethod @@ -1473,18 +1557,19 @@ class TLTransactionTest(engine_base.AltEngineTest, _base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + users, User = cls.tables.users, cls.classes.User + mapper(User, users) @testing.exclude('mysql', '<', (5, 0, 3), 'FIXME: unknown') - @testing.resolve_artifact_names def test_session_nesting(self): - sess = create_session(bind=self.engine) - self.engine.begin() + User = self.classes.User + + sess = create_session(bind=self.bind) + self.bind.begin() u = User(name='ed') sess.add(u) sess.flush() - self.engine.commit() - + self.bind.commit() diff --git a/test/orm/test_subquery_relations.py b/test/orm/test_subquery_relations.py index b7ff8095e9..ff20496e44 100644 --- a/test/orm/test_subquery_relations.py +++ b/test/orm/test_subquery_relations.py @@ -15,8 +15,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): run_inserts = 'once' run_deletes = None - @testing.resolve_artifact_names def test_basic(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship( mapper(Address, addresses), @@ -42,8 +46,14 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ) self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_from_aliased(self): + users, Dingaling, User, dingalings, Address, addresses = (self.tables.users, + self.classes.Dingaling, + self.classes.User, + self.tables.dingalings, + self.classes.Address, + self.tables.addresses) + mapper(Dingaling, dingalings) mapper(Address, addresses, properties={ 'dingalings':relationship(Dingaling, order_by=Dingaling.id) @@ -95,8 +105,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 3) - @testing.resolve_artifact_names def test_from_get(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship( mapper(Address, addresses), @@ -114,8 +128,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_from_params(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship( mapper(Address, addresses), @@ -133,8 +151,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_disable_dynamic(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """test no subquery option on a dynamic.""" mapper(User, users, properties={ @@ -151,8 +173,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): sess.query(User).options(subqueryload(User.addresses)).first, ) - @testing.resolve_artifact_names def test_many_to_many_plain(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( keywords = relationship(Keyword, secondary=item_keywords, @@ -163,8 +190,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): eq_(self.static.item_keyword_result, q.all()) self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_many_to_many_with_join(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( keywords = relationship(Keyword, secondary=item_keywords, @@ -176,8 +208,13 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): q.join('keywords').filter(Keyword.name == 'red').all()) self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_many_to_many_with_join_alias(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) mapper(Item, items, properties = dict( keywords = relationship(Keyword, secondary=item_keywords, @@ -190,8 +227,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): filter(Keyword.name == 'red')).all()) self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_orderby(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses':relationship(mapper(Address, addresses), lazy='subquery', order_by=addresses.c.email_address), @@ -212,8 +253,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): User(id=10, addresses=[]) ], q.order_by(User.id).all()) - @testing.resolve_artifact_names def test_orderby_multi(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties = { 'addresses':relationship(mapper(Address, addresses), lazy='subquery', @@ -237,8 +282,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): User(id=10, addresses=[]) ], q.order_by(User.id).all()) - @testing.resolve_artifact_names def test_orderby_related(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A regular mapper select on a single table can order by a relationship to a second table""" @@ -267,8 +316,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ]), ], l) - @testing.resolve_artifact_names def test_orderby_desc(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(Address, addresses) mapper(User, users, properties = dict( addresses = relationship(Address, lazy='subquery', @@ -310,8 +363,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): def test_mapper_pathing(self): self._do_mapper_test(self._pathing_runs) - @testing.resolve_artifact_names def _do_options_test(self, configs): + users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (self.tables.users, + self.classes.Keyword, + self.tables.orders, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.keywords, + self.tables.item_keywords) + mapper(User, users, properties={ 'orders':relationship(Order, order_by=orders.c.id), # o2m, m2o }) @@ -342,8 +405,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self._do_query_tests(options, count) - @testing.resolve_artifact_names def _do_mapper_test(self, configs): + users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (self.tables.users, + self.classes.Keyword, + self.tables.orders, + self.tables.items, + self.tables.order_items, + self.classes.Order, + self.classes.Item, + self.classes.User, + self.tables.keywords, + self.tables.item_keywords) + opts = { 'lazyload':'select', 'joinedload':'joined', @@ -371,8 +444,9 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): finally: clear_mappers() - @testing.resolve_artifact_names def _do_query_tests(self, opts, count): + Order, User = self.classes.Order, self.classes.User + sess = create_session() def go(): eq_( @@ -396,8 +470,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ) - @testing.resolve_artifact_names def test_cyclical(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """A circular eager relationship breaks the cycle with a lazy loader""" mapper(Address, addresses) @@ -412,8 +490,14 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): sess = create_session() eq_(self.static.user_address_result, sess.query(User).order_by(User.id).all()) - @testing.resolve_artifact_names def test_double(self): + users, orders, User, Address, Order, addresses = (self.tables.users, + self.tables.orders, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """Eager loading with two relationships simultaneously, from the same table, using aliases.""" @@ -467,8 +551,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ], q.all()) self.assert_sql_count(testing.db, go, 4) - @testing.resolve_artifact_names def test_double_same_mappers(self): + addresses, items, order_items, orders, Item, User, Address, Order, users = (self.tables.addresses, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.users) + """Eager loading with two relationships simulatneously, from the same table, using aliases.""" @@ -535,8 +628,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 6) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_limit(self): + users, items, order_items, orders, Item, User, Address, Order, addresses = (self.tables.users, + self.tables.items, + self.tables.order_items, + self.tables.orders, + self.classes.Item, + self.classes.User, + self.classes.Address, + self.classes.Order, + self.tables.addresses) + """Limit operations combined with lazy-load relationships.""" mapper(Item, items) @@ -561,8 +663,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): l = q.order_by(sa.desc(User.id)).limit(2).offset(2).all() eq_(list(reversed(self.static.user_all_result[0:2])), l) - @testing.resolve_artifact_names def test_one_to_many_scalar(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + mapper(User, users, properties = dict( address = relationship(mapper(Address, addresses), lazy='subquery', uselist=False) @@ -575,8 +681,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): self.assert_sql_count(testing.db, go, 2) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_many_to_one(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(Address, addresses, properties = dict( user = relationship(mapper(User, users), lazy='subquery') )) @@ -590,8 +700,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): is_(a.user, u1) self.assert_sql_count(testing.db, go, 2) - @testing.resolve_artifact_names def test_double_with_aggregate(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + max_orders_by_user = sa.select([sa.func.max(orders.c.id).label('order_id')], group_by=[orders.c.user_id] ).alias('max_orders_by_user') @@ -627,8 +741,12 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL): ], q.order_by(User.id).all()) self.assert_sql_count(testing.db, go, 3) - @testing.resolve_artifact_names def test_uselist_false_warning(self): + User, users, orders, Order = (self.classes.User, + self.tables.users, + self.tables.orders, + self.classes.Order) + """test that multiple rows received by a uselist=False raises a warning.""" @@ -676,8 +794,11 @@ class OrderBySecondaryTest(_base.MappedTest): (3, 1, 2), (5, 2, 3))) - @testing.resolve_artifact_names def test_ordering(self): + a, m2m, b = (self.tables.a, + self.tables.m2m, + self.tables.b) + class A(_base.ComparableEntity):pass class B(_base.ComparableEntity):pass @@ -703,8 +824,9 @@ class SelfReferentialTest(_base.MappedTest): Column('data', String(30))) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_basic(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -754,8 +876,9 @@ class SelfReferentialTest(_base.MappedTest): - @testing.resolve_artifact_names def test_lazy_fallback_doesnt_affect_eager(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -787,8 +910,9 @@ class SelfReferentialTest(_base.MappedTest): ], list(n12.children)) self.assert_sql_count(testing.db, go, 4) - @testing.resolve_artifact_names def test_with_deferred(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -829,8 +953,9 @@ class SelfReferentialTest(_base.MappedTest): self.assert_sql_count(testing.db, go, 3) - @testing.resolve_artifact_names def test_options(self): + nodes = self.tables.nodes + class Node(_base.ComparableEntity): def append(self, node): self.children.append(node) @@ -864,8 +989,9 @@ class SelfReferentialTest(_base.MappedTest): self.assert_sql_count(testing.db, go, 3) @testing.fails_on('maxdb', 'FIXME: unknown') - @testing.resolve_artifact_names def test_no_depth(self): + nodes = self.tables.nodes + """no join depth is set, so no eager loading occurs.""" class Node(_base.ComparableEntity): def append(self, node): diff --git a/test/orm/test_transaction.py b/test/orm/test_transaction.py index 2b1167b53b..af52f1f2e9 100644 --- a/test/orm/test_transaction.py +++ b/test/orm/test_transaction.py @@ -581,8 +581,9 @@ class NaturalPKRollbackTest(_base.MappedTest): class User(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_rollback_recover(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) session = sessionmaker()() diff --git a/test/orm/test_unitofwork.py b/test/orm/test_unitofwork.py index 748db61ec0..93e1dc7a20 100644 --- a/test/orm/test_unitofwork.py +++ b/test/orm/test_unitofwork.py @@ -33,8 +33,12 @@ class HistoryTest(_fixtures.FixtureTest): class Address(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_backref(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + am = mapper(Address, addresses) m = mapper(User, users, properties=dict( addresses = relationship(am, backref='user', lazy='joined'))) @@ -81,8 +85,9 @@ class UnicodeTest(_base.MappedTest): class Test2(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_basic(self): + Test, uni_t1 = self.classes.Test, self.tables.uni_t1 + mapper(Test, uni_t1) txt = u"\u0160\u0110\u0106\u010c\u017d" @@ -95,8 +100,12 @@ class UnicodeTest(_base.MappedTest): self.assert_(t1.txt == txt) - @testing.resolve_artifact_names def test_relationship(self): + Test, uni_t2, uni_t1, Test2 = (self.classes.Test, + self.tables.uni_t2, + self.tables.uni_t1, + self.classes.Test2) + mapper(Test, uni_t1, properties={ 't2s': relationship(Test2)}) mapper(Test2, uni_t2) @@ -114,9 +123,11 @@ class UnicodeTest(_base.MappedTest): t1 = session.query(Test).filter_by(id=t1.id).one() assert len(t1.t2s) == 2 -class UnicodeSchemaTest(engine_base.AltEngineTest, _base.MappedTest): +class UnicodeSchemaTest(_base.MappedTest): __requires__ = ('unicode_connections', 'unicode_ddl',) + run_dispose_bind = 'once' + @classmethod def create_engine(cls): return engines.utf8_engine() @@ -150,8 +161,9 @@ class UnicodeSchemaTest(engine_base.AltEngineTest, _base.MappedTest): @testing.fails_on('mssql+pyodbc', 'pyodbc returns a non unicode encoding of the results description.') - @testing.resolve_artifact_names def test_mapping(self): + t2, t1 = self.tables.t2, self.tables.t1 + class A(_base.ComparableEntity): pass class B(_base.ComparableEntity): @@ -188,8 +200,9 @@ class UnicodeSchemaTest(engine_base.AltEngineTest, _base.MappedTest): @testing.fails_on('mssql+pyodbc', 'pyodbc returns a non unicode encoding of the results description.') - @testing.resolve_artifact_names def test_inheritance_mapping(self): + t2, t1 = self.tables.t2, self.tables.t1 + class A(_base.ComparableEntity): pass class B(A): @@ -224,8 +237,9 @@ class BinaryHistTest(_base.MappedTest, testing.AssertsExecutionResults): class Foo(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_binary_equality(self): + Foo, t1 = self.classes.Foo, self.tables.t1 + # Py3K #data = b"this is some data" @@ -285,8 +299,9 @@ class PKTest(_base.MappedTest): # not supported on sqlite since sqlite's auto-pk generation only works with # single column primary keys @testing.fails_on('sqlite', 'FIXME: unknown') - @testing.resolve_artifact_names def test_primary_key(self): + Entry, multipk1 = self.classes.Entry, self.tables.multipk1 + mapper(Entry, multipk1) e = Entry(name='entry1', value='this is entry 1', multi_rev=2) @@ -303,8 +318,9 @@ class PKTest(_base.MappedTest): eq_(state.key, state2.key) # this one works with sqlite since we are manually setting up pk values - @testing.resolve_artifact_names def test_manual_pk(self): + Entry, multipk2 = self.classes.Entry, self.tables.multipk2 + mapper(Entry, multipk2) e = Entry(pk_col_1='pk1', pk_col_2='pk1_related', data='im the data') @@ -313,8 +329,9 @@ class PKTest(_base.MappedTest): session.add(e) session.flush() - @testing.resolve_artifact_names def test_key_pks(self): + Entry, multipk3 = self.classes.Entry, self.tables.multipk3 + mapper(Entry, multipk3) e = Entry(primary= 'pk1', secondary='pk2', @@ -347,8 +364,12 @@ class ForeignPKTest(_base.MappedTest): class PersonSite(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_basic(self): + peoplesites, PersonSite, Person, people = (self.tables.peoplesites, + self.classes.PersonSite, + self.classes.Person, + self.tables.people) + m1 = mapper(PersonSite, peoplesites) m2 = mapper(Person, people, properties={ 'sites' : relationship(PersonSite)}) @@ -386,12 +407,14 @@ class ClauseAttributesTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + User, users_t = cls.classes.User, cls.tables.users_t + mapper(User, users_t) - @testing.resolve_artifact_names def test_update(self): + User = self.classes.User + u = User(name='test') session = create_session() @@ -406,8 +429,9 @@ class ClauseAttributesTest(_base.MappedTest): assert (u.counter == 2) is True # ensure its not a ClauseElement self.sql_count_(1, go) - @testing.resolve_artifact_names def test_multi_update(self): + User = self.classes.User + u = User(name='test') session = create_session() @@ -429,8 +453,9 @@ class ClauseAttributesTest(_base.MappedTest): eq_(u.name, 'test2') eq_(u.counter, 2) - @testing.resolve_artifact_names def test_insert(self): + User = self.classes.User + u = User(name='test', counter=sa.select([5])) session = create_session() @@ -466,8 +491,12 @@ class PassiveDeletesTest(_base.MappedTest): class MyOtherClass(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_basic(self): + myothertable, MyClass, MyOtherClass, mytable = (self.tables.myothertable, + self.classes.MyClass, + self.classes.MyOtherClass, + self.tables.mytable) + mapper(MyOtherClass, myothertable) mapper(MyClass, mytable, properties={ 'children':relationship(MyOtherClass, @@ -493,8 +522,12 @@ class PassiveDeletesTest(_base.MappedTest): assert myothertable.count().scalar() == 0 @testing.emits_warning(r".*'passive_deletes' is normally configured on one-to-many") - @testing.resolve_artifact_names def test_backwards_pd(self): + myothertable, MyClass, MyOtherClass, mytable = (self.tables.myothertable, + self.classes.MyClass, + self.classes.MyOtherClass, + self.tables.mytable) + """Test that passive_deletes=True disables a delete from an m2o. This is not the usual usage and it now raises a warning, but test @@ -524,8 +557,12 @@ class PassiveDeletesTest(_base.MappedTest): assert mytable.count().scalar() == 1 assert myothertable.count().scalar() == 0 - @testing.resolve_artifact_names def test_aaa_m2o_emits_warning(self): + myothertable, MyClass, MyOtherClass, mytable = (self.tables.myothertable, + self.classes.MyClass, + self.classes.MyOtherClass, + self.tables.mytable) + mapper(MyOtherClass, myothertable, properties={ 'myclass':relationship(MyClass, cascade="all, delete", passive_deletes=True) }) @@ -558,8 +595,9 @@ class ExtraPassiveDeletesTest(_base.MappedTest): class MyOtherClass(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_assertions(self): + myothertable, MyOtherClass = self.tables.myothertable, self.classes.MyOtherClass + mapper(MyOtherClass, myothertable) assert_raises_message( sa.exc.ArgumentError, @@ -570,8 +608,12 @@ class ExtraPassiveDeletesTest(_base.MappedTest): cascade="all" ) - @testing.resolve_artifact_names def test_extra_passive(self): + myothertable, MyClass, MyOtherClass, mytable = (self.tables.myothertable, + self.classes.MyClass, + self.classes.MyOtherClass, + self.tables.mytable) + mapper(MyOtherClass, myothertable) mapper(MyClass, mytable, properties={ 'children': relationship(MyOtherClass, @@ -593,8 +635,12 @@ class ExtraPassiveDeletesTest(_base.MappedTest): session.delete(mc) assert_raises(sa.exc.DBAPIError, session.flush) - @testing.resolve_artifact_names def test_extra_passive_2(self): + myothertable, MyClass, MyOtherClass, mytable = (self.tables.myothertable, + self.classes.MyClass, + self.classes.MyOtherClass, + self.tables.mytable) + mapper(MyOtherClass, myothertable) mapper(MyClass, mytable, properties={ 'children': relationship(MyOtherClass, @@ -615,8 +661,12 @@ class ExtraPassiveDeletesTest(_base.MappedTest): mc.children[0].data = 'some new data' assert_raises(sa.exc.DBAPIError, session.flush) - @testing.resolve_artifact_names def test_dont_emit(self): + myothertable, MyClass, MyOtherClass, mytable = (self.tables.myothertable, + self.classes.MyClass, + self.classes.MyOtherClass, + self.tables.mytable) + mapper(MyOtherClass, myothertable) mapper(MyClass, mytable, properties={ 'children': relationship(MyOtherClass, @@ -644,8 +694,9 @@ class ColumnCollisionTest(_base.MappedTest): Column('title', String(50)) ) - @testing.resolve_artifact_names def test_naming(self): + book = self.tables.book + class Book(_base.ComparableEntity): pass @@ -689,8 +740,8 @@ class DefaultTest(_base.MappedTest): hohoval = 9 althohoval = 15 - cls.other_artifacts['hohoval'] = hohoval - cls.other_artifacts['althohoval'] = althohoval + cls.other['hohoval'] = hohoval + cls.other['althohoval'] = althohoval dt = Table('default_t', metadata, Column('id', Integer, primary_key=True, @@ -726,8 +777,12 @@ class DefaultTest(_base.MappedTest): pass @testing.fails_on('firebird', 'Data type unknown on the parameter') - @testing.resolve_artifact_names def test_insert(self): + althohoval, hohoval, default_t, Hoho = (self.other.althohoval, + self.other.hohoval, + self.tables.default_t, + self.classes.Hoho) + mapper(Hoho, default_t) h1 = Hoho(hoho=althohoval) @@ -771,8 +826,11 @@ class DefaultTest(_base.MappedTest): eq_(h5.foober, 'im the new foober') @testing.fails_on('firebird', 'Data type unknown on the parameter') - @testing.resolve_artifact_names def test_eager_defaults(self): + hohoval, default_t, Hoho = (self.other.hohoval, + self.tables.default_t, + self.classes.Hoho) + mapper(Hoho, default_t, eager_defaults=True) h1 = Hoho() @@ -783,8 +841,9 @@ class DefaultTest(_base.MappedTest): self.sql_count_(0, lambda: eq_(h1.hoho, hohoval)) - @testing.resolve_artifact_names def test_insert_nopostfetch(self): + default_t, Hoho = self.tables.default_t, self.classes.Hoho + # populates from the FetchValues explicitly so there is no # "post-update" mapper(Hoho, default_t) @@ -801,8 +860,9 @@ class DefaultTest(_base.MappedTest): self.sql_count_(0, go) @testing.fails_on('firebird', 'Data type unknown on the parameter') - @testing.resolve_artifact_names def test_update(self): + default_t, Hoho = self.tables.default_t, self.classes.Hoho + mapper(Hoho, default_t) h1 = Hoho() @@ -816,8 +876,13 @@ class DefaultTest(_base.MappedTest): eq_(h1.foober, 'im the update') @testing.fails_on('firebird', 'Data type unknown on the parameter') - @testing.resolve_artifact_names def test_used_in_relationship(self): + Hoho, hohoval, default_t, secondary_table, Secondary = (self.classes.Hoho, + self.other.hohoval, + self.tables.default_t, + self.tables.secondary_table, + self.classes.Secondary) + """A server-side default can be used as the target of a foreign key""" mapper(Hoho, default_t, properties={ @@ -868,21 +933,26 @@ class ColumnPropertyTest(_base.MappedTest): class Data(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_refreshes(self): + Data, data = self.classes.Data, self.tables.data + mapper(Data, data, properties={ 'aplusb':column_property(data.c.a + literal_column("' '") + data.c.b) }) self._test() - @testing.resolve_artifact_names def test_refreshes_post_init(self): + Data, data = self.classes.Data, self.tables.data + m = mapper(Data, data) m.add_property('aplusb', column_property(data.c.a + literal_column("' '") + data.c.b)) self._test() - @testing.resolve_artifact_names def test_with_inheritance(self): + subdata, data, Data = (self.tables.subdata, + self.tables.data, + self.classes.Data) + class SubData(Data): pass mapper(Data, data, properties={ @@ -896,8 +966,9 @@ class ColumnPropertyTest(_base.MappedTest): sess.flush() eq_(sd1.aplusb, "hello there") - @testing.resolve_artifact_names def _test(self): + Data = self.classes.Data + sess = create_session() d1 = Data(a="hello", b="there") @@ -918,8 +989,12 @@ class ColumnPropertyTest(_base.MappedTest): class OneToManyTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_one_to_many_1(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """Basic save of one to many.""" m = mapper(User, users, properties=dict( @@ -958,8 +1033,12 @@ class OneToManyTest(_fixtures.FixtureTest): [addressid, userid, 'somethingnew@foo.com']) self.assert_(u.id == userid and a2.id == addressid) - @testing.resolve_artifact_names def test_one_to_many_2(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """Modifying the child items of an object.""" m = mapper(User, users, properties=dict( @@ -1001,8 +1080,12 @@ class OneToManyTest(_fixtures.FixtureTest): "WHERE addresses.id = :addresses_id", {'user_id': u1.id, 'addresses_id': a3.id})]) - @testing.resolve_artifact_names def test_child_move(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + """Moving a child from one parent to another, with a delete. Tests that deleting the first parent properly updates the child with @@ -1032,8 +1115,12 @@ class OneToManyTest(_fixtures.FixtureTest): u2 = session.query(User).get(u2.id) eq_(len(u2.addresses), 1) - @testing.resolve_artifact_names def test_child_move_2(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + m = mapper(User, users, properties=dict( addresses = relationship(mapper(Address, addresses), lazy='select'))) @@ -1055,8 +1142,12 @@ class OneToManyTest(_fixtures.FixtureTest): u2 = session.query(User).get(u2.id) eq_(len(u2.addresses), 1) - @testing.resolve_artifact_names def test_o2m_delete_parent(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + m = mapper(User, users, properties=dict( address = relationship(mapper(Address, addresses), lazy='select', @@ -1078,8 +1169,12 @@ class OneToManyTest(_fixtures.FixtureTest): assert sa.orm.attributes.instance_state(a).key in session.identity_map assert sa.orm.attributes.instance_state(u).key not in session.identity_map - @testing.resolve_artifact_names def test_one_to_one(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + m = mapper(User, users, properties=dict( address = relationship(mapper(Address, addresses), lazy='select', @@ -1098,8 +1193,12 @@ class OneToManyTest(_fixtures.FixtureTest): u.address.email_address = 'imnew@foo.com' session.flush() - @testing.resolve_artifact_names def test_bidirectional(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + m1 = mapper(User, users) m2 = mapper(Address, addresses, properties=dict( user = relationship(m1, lazy='joined', backref='addresses'))) @@ -1114,8 +1213,12 @@ class OneToManyTest(_fixtures.FixtureTest): session.delete(u) session.flush() - @testing.resolve_artifact_names def test_double_relationship(self): + Address, addresses, users, User = (self.classes.Address, + self.tables.addresses, + self.tables.users, + self.classes.User) + m2 = mapper(Address, addresses) m = mapper(User, users, properties={ 'boston_addresses' : relationship(m2, primaryjoin= @@ -1138,8 +1241,9 @@ class OneToManyTest(_fixtures.FixtureTest): class SaveTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_basic(self): + User, users = self.classes.User, self.tables.users + m = mapper(User, users) # save two users @@ -1177,8 +1281,9 @@ class SaveTest(_fixtures.FixtureTest): eq_(u2.id, userlist[1].id) eq_(userlist[1].name, 'savetester2') - @testing.resolve_artifact_names def test_synonym(self): + users = self.tables.users + class SUser(_base.BasicEntity): def _get_name(self): return "User:" + self.name @@ -1201,8 +1306,12 @@ class SaveTest(_fixtures.FixtureTest): u = session.query(SUser).first() eq_(u.syn_name, 'User:some name:User') - @testing.resolve_artifact_names def test_lazyattr_commit(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """Lazily loaded relationships. When a lazy-loaded list is unloaded, and a commit occurs, that the @@ -1228,8 +1337,11 @@ class SaveTest(_fixtures.FixtureTest): session.flush() eq_(len(u.addresses), 4) - @testing.resolve_artifact_names def test_inherits(self): + users, addresses, User = (self.tables.users, + self.tables.addresses, + self.classes.User) + m1 = mapper(User, users) class AddressUser(User): @@ -1251,8 +1363,9 @@ class SaveTest(_fixtures.FixtureTest): eq_(au.user_id, rt.user_id) eq_(rt.id, rt.id) - @testing.resolve_artifact_names def test_deferred(self): + orders, Order = self.tables.orders, self.classes.Order + """Deferred column operations""" mapper(Order, orders, properties={ @@ -1295,8 +1408,9 @@ class SaveTest(_fixtures.FixtureTest): # why no support on oracle ? because oracle doesn't save # "blank" strings; it saves a single space character. @testing.fails_on('oracle', 'FIXME: unknown') - @testing.resolve_artifact_names def test_dont_update_blanks(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) u = User(name='') @@ -1309,8 +1423,11 @@ class SaveTest(_fixtures.FixtureTest): u.name = '' self.sql_count_(0, session.flush) - @testing.resolve_artifact_names def test_multi_table_selectable(self): + addresses, users, User = (self.tables.addresses, + self.tables.users, + self.classes.User) + """Mapped selectables that span tables. Also tests redefinition of the keynames for the column properties. @@ -1353,8 +1470,12 @@ class SaveTest(_fixtures.FixtureTest): u = session.query(User).get(id) assert u.name == 'imnew' - @testing.resolve_artifact_names def test_history_get(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + """The history lazy-fetches data when it wasn't otherwise loaded.""" mapper(User, users, properties={ 'addresses':relationship(Address, cascade="all, delete-orphan")}) @@ -1374,8 +1495,9 @@ class SaveTest(_fixtures.FixtureTest): assert users.count().scalar() == 0 assert addresses.count().scalar() == 0 - @testing.resolve_artifact_names def test_batch_mode(self): + users, User = self.tables.users, self.classes.User + """The 'batch=False' flag on mapper()""" names = [] @@ -1426,8 +1548,12 @@ class SaveTest(_fixtures.FixtureTest): class ManyToOneTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_m2o_one_to_one(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + # TODO: put assertion in here !!! m = mapper(Address, addresses, properties=dict( user = relationship(mapper(User, users), lazy='select', uselist=False))) @@ -1478,8 +1604,12 @@ class ManyToOneTest(_fixtures.FixtureTest): eq_(l.first().values(), [a.user.id, 'asdf8d', a.id, a.user_id, 'theater@foo.com']) - @testing.resolve_artifact_names def test_many_to_one_1(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + m = mapper(Address, addresses, properties=dict( user = relationship(mapper(User, users), lazy='select'))) @@ -1503,8 +1633,12 @@ class ManyToOneTest(_fixtures.FixtureTest): u1 = session.query(User).get(u1.id) assert a1.user is None - @testing.resolve_artifact_names def test_many_to_one_2(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + m = mapper(Address, addresses, properties=dict( user = relationship(mapper(User, users), lazy='select'))) @@ -1534,8 +1668,12 @@ class ManyToOneTest(_fixtures.FixtureTest): assert a1.user is None assert a2.user is u1 - @testing.resolve_artifact_names def test_many_to_one_3(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + m = mapper(Address, addresses, properties=dict( user = relationship(mapper(User, users), lazy='select'))) @@ -1562,8 +1700,12 @@ class ManyToOneTest(_fixtures.FixtureTest): u2 = session.query(User).get(u2.id) assert a1.user is u2 - @testing.resolve_artifact_names def test_bidirectional_no_load(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users, properties={ 'addresses':relationship(Address, backref='user', lazy='noload')}) mapper(Address, addresses) @@ -1590,8 +1732,13 @@ class ManyToOneTest(_fixtures.FixtureTest): class ManyToManyTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_many_to_many(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + mapper(Keyword, keywords) m = mapper(Item, items, properties=dict( @@ -1693,8 +1840,13 @@ class ManyToManyTest(_fixtures.FixtureTest): session.delete(objects[3]) session.flush() - @testing.resolve_artifact_names def test_many_to_many_remove(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + """Setting a collection to empty deletes many-to-many rows. Tests that setting a list-based attribute to '[]' properly affects the @@ -1721,8 +1873,13 @@ class ManyToManyTest(_fixtures.FixtureTest): session.flush() assert item_keywords.count().scalar() == 0 - @testing.resolve_artifact_names def test_scalar(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + """sa.dependency won't delete an m2m relationship referencing None.""" mapper(Keyword, keywords) @@ -1737,8 +1894,13 @@ class ManyToManyTest(_fixtures.FixtureTest): session.delete(i) session.flush() - @testing.resolve_artifact_names def test_many_to_many_update(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + """Assorted history operations on a many to many""" mapper(Keyword, keywords) mapper(Item, items, properties=dict( @@ -1767,8 +1929,13 @@ class ManyToManyTest(_fixtures.FixtureTest): item = session.query(Item).get(item.id) assert item.keywords == [k1, k2] - @testing.resolve_artifact_names def test_association(self): + keywords, items, item_keywords, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.item_keywords, + self.classes.Keyword, + self.classes.Item) + """Basic test of an association object""" class IKAssociation(_base.ComparableEntity): @@ -1822,8 +1989,12 @@ class ManyToManyTest(_fixtures.FixtureTest): class SaveTest2(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_m2o_nonmatch(self): + users, Address, addresses, User = (self.tables.users, + self.classes.Address, + self.tables.addresses, + self.classes.User) + mapper(User, users) mapper(Address, addresses, properties=dict( user = relationship(User, lazy='select', uselist=False))) @@ -1877,8 +2048,13 @@ class SaveTest3(_base.MappedTest): class Item(_base.BasicEntity): pass - @testing.resolve_artifact_names def test_manytomany_xtracol_delete(self): + keywords, items, assoc, Keyword, Item = (self.tables.keywords, + self.tables.items, + self.tables.assoc, + self.classes.Keyword, + self.classes.Item) + """A many-to-many on a table that has an extra column can properly delete rows from the table without referencing the extra column""" mapper(Keyword, keywords) @@ -1909,8 +2085,9 @@ class BooleanColTest(_base.MappedTest): Column('name', String(30)), Column('value', sa.Boolean)) - @testing.resolve_artifact_names def test_boolean(self): + t1_t = self.tables.t1_t + # use the regular mapper class T(_base.ComparableEntity): pass @@ -1961,8 +2138,9 @@ class DontAllowFlushOnLoadingObjectTest(_base.MappedTest): Column('data', String(30)), ) - @testing.resolve_artifact_names def test_flush_raises(self): + t1 = self.tables.t1 + class T1(_base.ComparableEntity): @reconstructor def go(self): @@ -2040,8 +2218,12 @@ class RowSwitchTest(_base.MappedTest): class T7(_base.ComparableEntity): pass - @testing.resolve_artifact_names def test_onetomany(self): + t6, T6, t5, T5 = (self.tables.t6, + self.classes.T6, + self.tables.t5, + self.classes.T5) + mapper(T5, t5, properties={ 't6s':relationship(T6, cascade="all, delete-orphan") }) @@ -2082,8 +2264,13 @@ class RowSwitchTest(_base.MappedTest): [(3, 'third t6', 1), (4, 'fourth t6', 1)] ) - @testing.resolve_artifact_names def test_manytomany(self): + t7, t5, t5t7, T5, T7 = (self.tables.t7, + self.tables.t5, + self.tables.t5t7, + self.classes.T5, + self.classes.T7) + mapper(T5, t5, properties={ 't7s':relationship(T7, secondary=t5t7, cascade="all") }) @@ -2118,8 +2305,12 @@ class RowSwitchTest(_base.MappedTest): assert list(sess.execute(t5.select(), mapper=T5)) == [(1, 'some other t5')] assert list(sess.execute(t7.select(), mapper=T5)) == [(3, 'third t7'), (4, 'fourth t7')] - @testing.resolve_artifact_names def test_manytoone(self): + t6, T6, t5, T5 = (self.tables.t6, + self.classes.T6, + self.tables.t5, + self.classes.T5) + mapper(T6, t6, properties={ 't5':relationship(T5) @@ -2167,8 +2358,12 @@ class InheritingRowSwitchTest(_base.MappedTest): class C(P): pass - @testing.resolve_artifact_names def test_row_switch_no_child_table(self): + P, C, parent, child = (self.classes.P, + self.classes.C, + self.tables.parent, + self.tables.child) + mapper(P, parent) mapper(C, child, inherits=P) @@ -2226,13 +2421,18 @@ class TransactionTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + T2, T1, t2, t1 = (cls.classes.T2, + cls.classes.T1, + cls.tables.t2, + cls.tables.t1) + orm_mapper(T1, t1) orm_mapper(T2, t2) - @testing.resolve_artifact_names def test_close_transaction_on_commit_fail(self): + T2, t1 = self.classes.T2, self.tables.t1 + session = create_session(autocommit=True) # with a deferred constraint, this fails at COMMIT time instead diff --git a/test/orm/test_unitofworkv2.py b/test/orm/test_unitofworkv2.py index 4063ccfabc..aaecd2af4e 100644 --- a/test/orm/test_unitofworkv2.py +++ b/test/orm/test_unitofworkv2.py @@ -917,8 +917,9 @@ class SingleCyclePlusAttributeTest(_base.MappedTest, Column('parent_id', Integer, ForeignKey('nodes.id')), ) - @testing.resolve_artifact_names def test_flush_size(self): + foobars, nodes = self.tables.foobars, self.tables.nodes + class Node(Base): pass class FooBar(Base): @@ -966,8 +967,9 @@ class SingleCycleM2MTest(_base.MappedTest, ForeignKey('nodes.id'),primary_key=True), ) - @testing.resolve_artifact_names def test_many_to_many_one(self): + nodes, node_to_nodes = self.tables.nodes, self.tables.node_to_nodes + class Node(Base): pass @@ -1087,8 +1089,9 @@ class RowswitchAccountingTest(_base.MappedTest): Column('id', Integer, ForeignKey('parent.id'), primary_key=True) ) - @testing.resolve_artifact_names def test_accounting_for_rowswitch(self): + parent, child = self.tables.parent, self.tables.child + class Parent(object): def __init__(self, id): self.id = id @@ -1139,8 +1142,9 @@ class BatchInsertsTest(_base.MappedTest, testing.AssertsExecutionResults): Column('def_', String(50), server_default='def1') ) - @testing.resolve_artifact_names def test_batch_interaction(self): + t = self.tables.t + """test batching groups same-structured, primary key present statements together. diff --git a/test/orm/test_utils.py b/test/orm/test_utils.py index 362b54cf09..9664d0c232 100644 --- a/test/orm/test_utils.py +++ b/test/orm/test_utils.py @@ -189,8 +189,9 @@ class AliasedClassTest(TestBase): class IdentityKeyTest(_fixtures.FixtureTest): run_inserts = None - @testing.resolve_artifact_names def test_identity_key_1(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) key = util.identity_key(User, [1]) @@ -198,8 +199,9 @@ class IdentityKeyTest(_fixtures.FixtureTest): key = util.identity_key(User, ident=[1]) eq_(key, (User, (1,))) - @testing.resolve_artifact_names def test_identity_key_2(self): + users, User = self.tables.users, self.classes.User + mapper(User, users) s = create_session() u = User(name='u1') @@ -208,8 +210,9 @@ class IdentityKeyTest(_fixtures.FixtureTest): key = util.identity_key(instance=u) eq_(key, (User, (u.id,))) - @testing.resolve_artifact_names def test_identity_key_3(self): + User, users = self.classes.User, self.tables.users + mapper(User, users) row = {users.c.id: 1, users.c.name: "Frank"} diff --git a/test/orm/test_versioning.py b/test/orm/test_versioning.py index 128927d727..cdf2bdbcfc 100644 --- a/test/orm/test_versioning.py +++ b/test/orm/test_versioning.py @@ -47,16 +47,18 @@ class VersioningTest(_base.MappedTest): class Foo(_base.ComparableEntity): pass - @testing.resolve_artifact_names def _fixture(self): + Foo, version_table = self.classes.Foo, self.tables.version_table + mapper(Foo, version_table, version_id_col=version_table.c.version_id) s1 = Session() return s1 @engines.close_open_connections - @testing.resolve_artifact_names def test_notsane_warning(self): + Foo = self.classes.Foo + save = testing.db.dialect.supports_sane_rowcount testing.db.dialect.supports_sane_rowcount = False try: @@ -72,8 +74,9 @@ class VersioningTest(_base.MappedTest): testing.db.dialect.supports_sane_rowcount = save @testing.emits_warning(r'.*does not support updated rowcount') - @testing.resolve_artifact_names def test_basic(self): + Foo = self.classes.Foo + s1 = self._fixture() f1 = Foo(value='f1') f2 = Foo(value='f2') @@ -121,8 +124,9 @@ class VersioningTest(_base.MappedTest): s1.commit() @testing.emits_warning(r'.*does not support updated rowcount') - @testing.resolve_artifact_names def test_bump_version(self): + Foo = self.classes.Foo + """test that version number can be bumped. Ensures that the UPDATE or DELETE is against the @@ -153,8 +157,9 @@ class VersioningTest(_base.MappedTest): @testing.emits_warning(r'.*does not support updated rowcount') @engines.close_open_connections - @testing.resolve_artifact_names def test_versioncheck(self): + Foo = self.classes.Foo + """query.with_lockmode performs a 'version check' on an already loaded instance""" s1 = self._fixture() @@ -189,8 +194,9 @@ class VersioningTest(_base.MappedTest): @testing.emits_warning(r'.*does not support updated rowcount') @engines.close_open_connections @testing.requires.update_nowait - @testing.resolve_artifact_names def test_versioncheck_for_update(self): + Foo = self.classes.Foo + """query.with_lockmode performs a 'version check' on an already loaded instance""" s1 = self._fixture() @@ -215,8 +221,9 @@ class VersioningTest(_base.MappedTest): @testing.emits_warning(r'.*does not support updated rowcount') @engines.close_open_connections - @testing.resolve_artifact_names def test_noversioncheck(self): + Foo, version_table = self.classes.Foo, self.tables.version_table + """test query.with_lockmode works when the mapper has no version id col""" s1 = create_session(autocommit=False) mapper(Foo, version_table) @@ -229,8 +236,9 @@ class VersioningTest(_base.MappedTest): assert f1s2.id == f1s1.id assert f1s2.value == f1s1.value - @testing.resolve_artifact_names def test_merge_no_version(self): + Foo = self.classes.Foo + s1 = self._fixture() f1 = Foo(value='f1') s1.add(f1) @@ -245,8 +253,9 @@ class VersioningTest(_base.MappedTest): s1.commit() eq_(f3.version_id, 3) - @testing.resolve_artifact_names def test_merge_correct_version(self): + Foo = self.classes.Foo + s1 = self._fixture() f1 = Foo(value='f1') s1.add(f1) @@ -261,8 +270,9 @@ class VersioningTest(_base.MappedTest): s1.commit() eq_(f3.version_id, 3) - @testing.resolve_artifact_names def test_merge_incorrect_version(self): + Foo = self.classes.Foo + s1 = self._fixture() f1 = Foo(value='f1') s1.add(f1) @@ -281,8 +291,9 @@ class VersioningTest(_base.MappedTest): s1.merge, f2 ) - @testing.resolve_artifact_names def test_merge_incorrect_version_not_in_session(self): + Foo = self.classes.Foo + s1 = self._fixture() f1 = Foo(value='f1') s1.add(f1) @@ -325,16 +336,21 @@ class RowSwitchTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + p, c, C, P = (cls.tables.p, + cls.tables.c, + cls.classes.C, + cls.classes.P) + mapper(P, p, version_id_col=p.c.version_id, properties={ 'c':relationship(C, uselist=False, cascade='all, delete-orphan') }) mapper(C, c, version_id_col=c.c.version_id) - @testing.resolve_artifact_names def test_row_switch(self): + P = self.classes.P + session = sessionmaker()() session.add(P(id='P1', data='P version 1')) session.commit() @@ -345,8 +361,9 @@ class RowSwitchTest(_base.MappedTest): session.add(P(id='P1', data="really a row-switch")) session.commit() - @testing.resolve_artifact_names def test_child_row_switch(self): + P, C = self.classes.P, self.classes.C + assert P.c.property.strategy.use_get session = sessionmaker()() @@ -384,8 +401,12 @@ class AlternateGeneratorTest(_base.MappedTest): pass @classmethod - @testing.resolve_artifact_names def setup_mappers(cls): + p, c, C, P = (cls.tables.p, + cls.tables.c, + cls.classes.C, + cls.classes.P) + mapper(P, p, version_id_col=p.c.version_id, version_id_generator=lambda x:make_uuid(), properties={ @@ -395,8 +416,9 @@ class AlternateGeneratorTest(_base.MappedTest): version_id_generator=lambda x:make_uuid(), ) - @testing.resolve_artifact_names def test_row_switch(self): + P = self.classes.P + session = sessionmaker()() session.add(P(id='P1', data='P version 1')) session.commit() @@ -407,8 +429,9 @@ class AlternateGeneratorTest(_base.MappedTest): session.add(P(id='P1', data="really a row-switch")) session.commit() - @testing.resolve_artifact_names def test_child_row_switch_one(self): + P, C = self.classes.P, self.classes.C + assert P.c.property.strategy.use_get session = sessionmaker()() @@ -424,8 +447,9 @@ class AlternateGeneratorTest(_base.MappedTest): p.c = C(data='child row-switch') session.commit() - @testing.resolve_artifact_names def test_child_row_switch_two(self): + P = self.classes.P + Session = sessionmaker() # TODO: not sure this test is @@ -482,8 +506,12 @@ class InheritanceTwoVersionIdsTest(_base.MappedTest): class Sub(Base): pass - @testing.resolve_artifact_names def test_base_both(self): + Base, sub, base, Sub = (self.classes.Base, + self.tables.sub, + self.tables.base, + self.classes.Sub) + mapper(Base, base, version_id_col=base.c.version_id) mapper(Sub, sub, inherits=Base) @@ -496,8 +524,12 @@ class InheritanceTwoVersionIdsTest(_base.MappedTest): # base is populated eq_(select([base.c.version_id]).scalar(), 1) - @testing.resolve_artifact_names def test_sub_both(self): + Base, sub, base, Sub = (self.classes.Base, + self.tables.sub, + self.tables.base, + self.classes.Sub) + mapper(Base, base, version_id_col=base.c.version_id) mapper(Sub, sub, inherits=Base) @@ -513,8 +545,12 @@ class InheritanceTwoVersionIdsTest(_base.MappedTest): # base is populated eq_(select([base.c.version_id]).scalar(), 1) - @testing.resolve_artifact_names def test_sub_only(self): + Base, sub, base, Sub = (self.classes.Base, + self.tables.sub, + self.tables.base, + self.classes.Sub) + mapper(Base, base) mapper(Sub, sub, inherits=Base, version_id_col=sub.c.version_id) @@ -530,8 +566,12 @@ class InheritanceTwoVersionIdsTest(_base.MappedTest): # base is not eq_(select([base.c.version_id]).scalar(), None) - @testing.resolve_artifact_names def test_mismatch_version_col_warning(self): + Base, sub, base, Sub = (self.classes.Base, + self.tables.sub, + self.tables.base, + self.classes.Sub) + mapper(Base, base, version_id_col=base.c.version_id) diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py index 79243ad4f6..74998a77c5 100644 --- a/test/sql/test_defaults.py +++ b/test/sql/test_defaults.py @@ -413,8 +413,9 @@ class PKDefaultTest(_base.TablesTest): def test_regular(self): self._test(False) - @testing.resolve_artifact_names def _test(self, returning): + t2, t1 = self.tables.t2, self.tables.t1 + if not returning and not testing.db.dialect.implicit_returning: engine = testing.db else: @@ -440,8 +441,9 @@ class PKIncrementTest(_base.TablesTest): # TODO: add coverage for increment on a secondary column in a key @testing.fails_on('firebird', 'Data type unknown') - @testing.resolve_artifact_names def _test_autoincrement(self, bind): + aitable = self.tables.aitable + ids = set() rs = bind.execute(aitable.insert(), int1=1) last = rs.inserted_primary_key[0] @@ -472,11 +474,9 @@ class PKIncrementTest(_base.TablesTest): eq_(list(bind.execute(aitable.select().order_by(aitable.c.id))), [(1, 1, None), (2, None, 'row 2'), (3, 3, 'row 3'), (4, 4, None)]) - @testing.resolve_artifact_names def test_autoincrement_autocommit(self): self._test_autoincrement(testing.db) - @testing.resolve_artifact_names def test_autoincrement_transaction(self): con = testing.db.connect() tx = con.begin()