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)
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)
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)
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()
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()
)
@classmethod
- @testing.resolve_artifact_names
def insert_data(cls):
+ data_table = cls.tables.data_table
+
data_table.insert().execute(
{'data':3},
{'data':5},
{'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),
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):
# '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())
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):
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
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
@classmethod
def define_tables(cls, metadata):
- raise NotImplementedError()
+ pass
@classmethod
def fixtures(cls):
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
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)
})
})
@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',
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'
)),
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'
)),
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')),
)
)
- @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')),
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')),
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')),
)
)
- @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)
),
)
- @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)
self.changed()
return MutationDict
- @testing.resolve_artifact_names
def setup_mappers(cls):
+ foo = cls.tables.foo
+
mapper(Foo, foo)
def teardown(self):
ClassManager.dispatch._clear()
super(_MutableDictTestBase, self).teardown()
- @testing.resolve_artifact_names
def test_in_place_mutation(self):
sess = Session()
eq_(f1.data, {'a':'c'})
- @testing.resolve_artifact_names
def test_pickle_parent(self):
sess = Session()
f2.data['a'] = 'c'
assert f2 in sess.dirty
- @testing.resolve_artifact_names
def _test_non_mutable(self):
sess = Session()
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)
eq_(f1.data, Point(3, 5))
- @testing.resolve_artifact_names
def test_pickle_of_parent(self):
sess = Session()
d = Point(3, 4)
testutil.lazy_gc()
assert not pool._refs
-
-
def against(*queries):
"""Boolean predicate, compares to testing database configuration.
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):
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
# 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):
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:
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
)
@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):
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()
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)
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'
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
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')
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):
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
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
@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):
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):
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."""
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):
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):
]
)
- @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):
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):
),
)
- @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):
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):
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
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_(
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)
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')
})
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."""
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(
primary_key=True, test_needs_autoincrement=True))
@classmethod
- @testing.resolve_artifact_names
def setup_classes(cls):
class Base(_base.ComparableEntity):
pass
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)})
)
@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,
'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')
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)
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)
)
@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')
'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')
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)
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')
]
)
- @testing.resolve_artifact_names
def test_relationship_compare(self):
m1 = Manager(name='dogbert')
m2 = Manager(name='foo')
)
@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
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')
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()
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')])
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,
})
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()
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()
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()
)
@classmethod
- @testing.resolve_artifact_names
def setup_classes(cls):
class Parent(_base.ComparableEntity):
pass
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)
})
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), \
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_(
)
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_(
)
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_(
)
@classmethod
- @testing.resolve_artifact_names
def setup_classes(cls):
class Parent(_base.ComparableEntity):
pass
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)
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')])
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_(
)
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_(
)
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_(
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()
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')
# []
# )
- @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 '
'(: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')
[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')
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={
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={
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)
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')
})
)
- @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)
})
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')
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')
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'))
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')
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')
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),
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)
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()
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)
).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,
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
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'))
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(
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(
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)
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
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))})
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,
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(
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(
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
Column('display_name', sa.Unicode(20)))
@classmethod
- @testing.resolve_artifact_names
def fixtures(cls):
return dict(
prj=(('id',),
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
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)
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')
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")
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])
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])
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])
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')
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()()
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')
- @testing.resolve_artifact_names
def test_scalar_move_notloaded(self):
+ User, Address = self.classes.User, self.classes.Address
+
sess = sessionmaker()()
u1 = User(name='jack')
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')
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)
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")
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)
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")
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)
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")
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)
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,
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)
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')
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')
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')
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()):
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(
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={
'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'),
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'),
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"""
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')
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'),
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()
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"""
[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."""
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'),
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'),
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'),
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,
run_inserts = None
- @testing.resolve_artifact_names
def _one_to_many_fixture(self, o2m_cascade=True,
m2o_cascade=True,
o2m=False,
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(
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,
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(
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')
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')
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')
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')
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()
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()
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()
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()
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')
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')
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')
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')
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')
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')
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')
# 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')
# 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')
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')
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')
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')
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()
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()
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()
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()
"""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(
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))
})
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')})
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')))
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()]))
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
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)()
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"""
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
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)
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()
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,
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)
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)
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)
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)
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()
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()
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)
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')
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')
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)
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)
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)
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
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
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
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)
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)
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={
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',
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')
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')
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')
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')
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')
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')
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.
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."""
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",
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")
})
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")
})
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."""
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."""
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."""
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."""
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):
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()
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)
})
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)
})
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')
})
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")
})
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")
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",
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,
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,
)
@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):
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):
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,
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,
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 "
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)
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):
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
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):
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):
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):
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):
)
@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
'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)),
sess.commit()
return sess
- @testing.resolve_artifact_names
def test_round_trip(self):
+ Graph, Point = self.classes.Graph, self.classes.Point
+
sess = self._fixture()
]
)
- @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()
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()
)
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()
[]
)
- @testing.resolve_artifact_names
def test_query_cols(self):
+ Edge = self.classes.Edge
+
sess = self._fixture()
eq_(
[(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()
[(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:
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]
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)
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
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()
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()
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()
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
)
@classmethod
- @testing.resolve_artifact_names
def setup_mappers(cls):
+ foobars = cls.tables.foobars
+
class Foobar(_base.BasicEntity):
pass
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()
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)
)
@classmethod
- @testing.resolve_artifact_names
def setup_mappers(cls):
+ values, descriptions = cls.tables.values, cls.tables.descriptions
+
class Descriptions(_base.BasicEntity):
pass
})
- @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'),
)
@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):
})
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()
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))
)
@classmethod
- @testing.resolve_artifact_names
def setup_mappers(cls):
class Point(_base.BasicEntity):
def __init__(self, x, y):
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)
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)
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'))
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,
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
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")})
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)
})
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())
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()
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()
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)})
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={
'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()
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()
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,
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,
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()
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
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(
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)
- @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)
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,
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
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)
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),
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)
# 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()
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',))
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'),
))
######################################################################
- @testing.resolve_artifact_names
def test_override_get(self):
+ Address = self.classes.Address
+
"""MapperExtension.get()
x = session.query.get(5)
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)
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)
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)
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)
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)
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')
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)
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())
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')
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)
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)
session = create_session()
- @testing.resolve_artifact_names
def test_join_to(self):
"""Query.join_to(key)
session = create_session()
- @testing.resolve_artifact_names
def test_join_via(self):
"""Query.join_via(keys)
session = create_session()
- @testing.resolve_artifact_names
def test_list(self):
+ User = self.classes.User
+
"""Query.list()
users = session.query(User).list()
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()
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)
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')
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(
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)
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')
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')
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())
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')
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)
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))
})
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."""
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))
})
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))
})
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))
})
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'))
})
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))
})
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))
})
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"))
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",
)
- @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))
})
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
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):
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))
})
[(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)
})
[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))
})
],
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))
})
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)
})
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))
})
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')
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")
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')
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')
})
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
})
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'
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)
})
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()
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={
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),
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',
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"""
]),
], 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',
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')
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
})
)
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={
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(
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',
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)
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."""
], 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."""
], 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."""
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)
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.
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]),
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
)
], 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],
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."""
)
- @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."""
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)
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')
))
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.
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."""
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')
], 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."""
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)
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')
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."""
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)
"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)
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)
))
- @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)
))
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,
)
]
- @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)
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)
(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
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)
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)
], 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)
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)
)
@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)
@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):
});
@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),
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_(
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
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
})
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
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
- @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)
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
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
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'},
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
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),
(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),
(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),
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 = []
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)
'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 =[]
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
'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.
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
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)
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")
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()
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()
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")
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()
sess.query(User).first()
eq_(canary, [])
- @testing.resolve_artifact_names
def test_repeated_rows(self):
+ User = self.classes.User
+
canary = self._fixture()
sess = Session()
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()
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()
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()
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()
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()
return sess, canary
- @testing.resolve_artifact_names
def test_flush_autocommit_hook(self):
+ User, users = self.classes.User, self.tables.users
+
mapper(User, users)
'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)
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)
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()
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)
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)
]
)
- @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):
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()
'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):
'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.
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()
'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)
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
)
- @testing.resolve_artifact_names
def test_cascading_extensions(self):
+ t1 = self.tables.t1
+
ext_msg = []
class Ex1(sa.orm.AttributeExtension):
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):
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):
'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):
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'),
})
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)
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)
# 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)})
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)
})
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"""
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)
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()
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)
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)
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
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)
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)
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)
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")
})
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")
})
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)
})
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'),
})
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'),
})
# 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'),
})
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
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')
})
# 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()
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'),
})
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'),
})
# 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'),
})
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)
})
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'),
})
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),
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)
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)})
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')})
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'},
)
@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()
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)
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()
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'),
})
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')
})
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)
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"""
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={
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()
)
@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
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'),
])
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 [
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):
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()
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
@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
# 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
@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),
(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)
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()
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()
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()
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(
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):
(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))
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)
)
- @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')
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):
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(
, 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(
)
- @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(
, 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(
, 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(
, 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()."""
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
)
@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
})
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)
"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)
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])
})
@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'))
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()
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.
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()..
"""
use_default_dialect=True
)
- @testing.resolve_artifact_names
def test_explicit_join(self):
+ Node = self.classes.Node
+
sess = create_session()
n1 = aliased(Node)
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)
)
- @testing.resolve_artifact_names
def test_multiple_explicit_entities(self):
+ Node = self.classes.Node
+
sess = create_session()
parent = aliased(Node)
)
- @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(),
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()
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()
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,
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()
[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)
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')
})
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={
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),
})
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)
]),
] == 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(
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={
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)
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')
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={
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)
))
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(
)
- @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')
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(
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 (
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):
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')
))
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')
})
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)
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'},
{'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
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()
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()
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()
"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()
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.
[('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()
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.
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.
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."""
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.
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."""
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()
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')
})
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={
[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={
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."""
'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(
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)
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={
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)
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)
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
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):
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)
})
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={
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):
- @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={
# 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.
"'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')
})
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)
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()
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]."""
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()
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()
})
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):
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'))
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):
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),
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={
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):
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,
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,
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,
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
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
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]}
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."""
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."""
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,))
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)
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()
# '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,
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)
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')))
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,
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,
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):
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)})
"'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."""
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,
])
)
- @testing.resolve_artifact_names
def test_comparable(self):
+ users = self.tables.users
+
class extendedproperty(property):
attribute = 123
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):
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)
m2 = mapper(Address, addresses)
configure_mappers()
- @testing.resolve_artifact_names
def test_reconstructor(self):
+ users = self.tables.users
+
recon = []
class User(object):
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
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
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()
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):
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
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):
@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),
[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),
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')))
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')))
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(
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
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')
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)
))
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(
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.
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()
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
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(
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):
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):
)
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
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):
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
"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):
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={
"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={
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')
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)})
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(
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')))
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)})
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')),
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'),
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
# 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)
"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')),
"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={
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.
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(
)
@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):
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'},
{'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).\
)
)
- @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)
)
)
- @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)
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
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"},
])
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()
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')
{'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')
))
Column('value', String(10)))
# Py2K
- @testing.resolve_artifact_names
def test_baseclass(self):
+ ht1 = self.tables.ht1
+
class OldStyle:
pass
#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
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())
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(
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):
'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):
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)
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()
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)})
]))
)
- @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)
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',
]))
)
- @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',
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={
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()
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),
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={
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.
"""
[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))})
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)
})
)
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)})
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)
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')
})
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()
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')
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
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.
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')})
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
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):
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)
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')})
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',
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)
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.
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"])
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()()
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()()
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()
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()
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')
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)
})
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)
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)
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,
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',
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.
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)
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',
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',
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,
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)})
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
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.
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)
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={
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)
)
- @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
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)
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)
Column('jack_id', Integer, ForeignKey("jack.id")))
@classmethod
- @testing.resolve_artifact_names
def setup_mappers(cls):
class Jack(_base.BasicEntity):
pass
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],
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")
})
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')
"Cannot deserialize object of type <class 'test.orm._fixtures.User'> - 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')
# 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")
})
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")
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')
})
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")
})
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")
})
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")
})
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')
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.
__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")
})
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")
})
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,
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)
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)
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),
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'),
])
@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 (
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()
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()
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')
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')
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()
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()
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()
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()
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,
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()
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()
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()
- @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()
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})
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)
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()
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)
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()
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()
"""
- @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 "\
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 "\
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))
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")))
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')
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()
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,
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'),
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'),
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'),
self._test()
- @testing.resolve_artifact_names
def _test(self):
+ Employee, Company = self.classes.Employee, self.classes.Company
+
sess = create_session()
c1 = Company()
c2 = Company()
["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)
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')
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"""
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")})
"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)
"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),
# 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"""
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"""
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)
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)
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")})
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):
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):
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,
)
@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'])))
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
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')
})
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')
})
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'),
})
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
"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
"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
"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
"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
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
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
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
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
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):
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):
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):
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,
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,
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={
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,
[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,
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,
[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),
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),
)
@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')
})
"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),
"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'),
"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),
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)
"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)
"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)})
"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,
"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
"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,
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,
"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,
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)})
"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,
"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,
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,
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,
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)})
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)})
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,
)
@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)
"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,
"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,
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,
)
- @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,
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,
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,
([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)
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)
})
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
(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'),
))
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):
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])
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(
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)
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")
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")
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)
finally:
c.close()
- @testing.resolve_artifact_names
def test_object_session_raises(self):
+ User = self.classes.User
+
assert_raises(
orm_exc.UnmappedInstanceError,
object_session,
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,
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()
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()
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()
@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()
@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()
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'))
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()()
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.
@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)
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()
).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)})
# 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)
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)
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()
@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()
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'
).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()
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)
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)
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()
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')
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)
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)
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)
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()
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()
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'))
'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)
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()
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)
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={
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)})
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')})
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."""
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)
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(),
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")
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)
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)
@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)
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()
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()
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):
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()
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
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()
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),
)
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)
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),
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),
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={
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,
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,
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,
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),
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',
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"""
]),
], 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',
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
})
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',
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_(
)
- @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)
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."""
], 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."""
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)
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)
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')
))
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')
], 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."""
(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
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)
- @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)
], 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)
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)
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):
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()()
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')))
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"
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)
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()
@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):
@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):
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"
# 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)
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')
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',
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)})
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()
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()
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()
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,
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
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)
})
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,
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,
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,
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,
Column('title', String(50))
)
- @testing.resolve_artifact_names
def test_naming(self):
+ book = self.tables.book
+
class Book(_base.ComparableEntity):
pass
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,
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)
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()
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)
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()
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={
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={
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")
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(
[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(
"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
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')))
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',
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',
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')))
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=
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
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
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
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):
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={
# 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='')
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.
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")})
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 = []
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)))
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')))
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')))
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')))
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)
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(
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
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)
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(
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):
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)))
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)
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
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):
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")
})
[(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")
})
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)
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)
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
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):
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
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
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.
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])
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')
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"}
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:
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')
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
@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()
@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()
@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)
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)
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)
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)
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)
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()
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()()
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={
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()
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()()
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
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)
# 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)
# 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)
# 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)
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:
# 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]
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()
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
