def test_notcallable(self):
class Point(object):
pass
table = self.point_map(Point)
alias = aliased(Point)
assert_raises(TypeError, alias)
def test_bogus(self):
assert_raises(exc.ArgumentError, Column, 'foo', name='bar')
assert_raises(exc.ArgumentError,
Column,
'foo',
Integer,
type_=Integer())
def test_nonreflected_fk_raises(self):
"""test that a NoReferencedColumnError is raised when reflecting
a table with an FK to another table which has not included the target
column in its reflection.
"""
meta = MetaData(testing.db)
a1 = Table('a', meta,
Column('x', sa.Integer, primary_key=True),
Column('z', sa.Integer),
test_needs_fk=True
)
b1 = Table('b', meta,
Column('y', sa.Integer, sa.ForeignKey('a.x')),
test_needs_fk=True
)
meta.create_all()
try:
m2 = MetaData(testing.db)
a2 = Table('a', m2, include_columns=['z'], autoload=True)
b2 = Table('b', m2, autoload=True)
assert_raises(tsa.exc.NoReferencedColumnError, a2.join, b2)
finally:
meta.drop_all()
def test_explode_in_initializer(self):
engine = engines.testing_engine()
def broken_initialize(connection):
connection.execute("select fake_stuff from _fake_table")
engine.dialect.initialize = broken_initialize
# raises a DBAPIError, not an AttributeError
assert_raises(exc.DBAPIError, engine.connect)
# dispose connections so we get a new one on
# next go
engine.dispose()
p1 = engine.pool
def is_disconnect(e):
return True
engine.dialect.is_disconnect = is_disconnect
# invalidate() also doesn't screw up
assert_raises(exc.DBAPIError, engine.connect)
# pool was recreated
assert engine.pool is not p1
def test_basic(self):
carrier = util.ExtensionCarrier()
assert 'translate_row' not in carrier
assert carrier.translate_row() is interfaces.EXT_CONTINUE
assert 'translate_row' not in carrier
assert_raises(AttributeError, lambda: carrier.snickysnack)
class Partial(object):
def __init__(self, marker):
self.marker = marker
def translate_row(self, row):
return self.marker
carrier.append(Partial('end'))
assert 'translate_row' in carrier
assert carrier.translate_row(None) == 'end'
carrier.push(Partial('front'))
assert carrier.translate_row(None) == 'front'
assert 'populate_instance' not in carrier
carrier.append(interfaces.MapperExtension)
# Py3K
#assert 'populate_instance' not in carrier
# Py2K
assert 'populate_instance' in carrier
# end Py2K
assert carrier.interface
for m in carrier.interface:
assert getattr(interfaces.MapperExtension, m)
def test_notcallable(self):
class Point(object):
pass
table = self.point_map(Point)
alias = aliased(Point)
assert_raises(TypeError, alias)
def test_inheriting(self):
mapper(A, a_table, properties={
'some_dest': relationship(Dest,back_populates='many_a')
})
mapper(B, b_table, inherits=A, concrete=True,
properties={
'some_dest': relationship(Dest, back_populates='many_b')
})
mapper(Dest, dest_table, properties={
'many_a': relationship(A,back_populates='some_dest'),
'many_b': relationship(B,back_populates='some_dest')
})
sess = sessionmaker()()
dest1 = Dest(name='c1')
dest2 = Dest(name='c2')
a1 = A(some_dest=dest1, aname='a1')
a2 = A(some_dest=dest2, aname='a2')
b1 = B(some_dest=dest1, bname='b1')
b2 = B(some_dest=dest1, bname='b2')
assert_raises(AttributeError, setattr, b1, 'aname', 'foo')
assert_raises(AttributeError, getattr, A, 'bname')
assert dest2.many_a == [a2]
assert dest1.many_a == [a1]
assert dest1.many_b == [b1, b2]
sess.add_all([dest1, dest2])
sess.commit()
assert sess.query(Dest).filter(Dest.many_a.contains(a2)).one() is dest2
assert dest2.many_a == [a2]
assert dest1.many_a == [a1]
assert dest1.many_b == [b1, b2]
assert sess.query(B).filter(B.bname == 'b1').one() is b1
def test_basic(self):
carrier = util.ExtensionCarrier()
assert "translate_row" not in carrier
assert carrier.translate_row() is interfaces.EXT_CONTINUE
assert "translate_row" not in carrier
assert_raises(AttributeError, lambda: carrier.snickysnack)
class Partial(object):
def __init__(self, marker):
self.marker = marker
def translate_row(self, row):
return self.marker
carrier.append(Partial("end"))
assert "translate_row" in carrier
assert carrier.translate_row(None) == "end"
carrier.push(Partial("front"))
assert carrier.translate_row(None) == "front"
assert "populate_instance" not in carrier
carrier.append(interfaces.MapperExtension)
assert "populate_instance" in carrier
assert carrier.interface
for m in carrier.interface:
assert getattr(interfaces.MapperExtension, m)
def test_length_deprecation(self):
assert_raises(exc.SADeprecationWarning, Numeric, length=8)
@testing.uses_deprecated(".*is deprecated for Numeric")
def go():
n = Numeric(length=12)
assert n.scale == 12
go()
n = Numeric(scale=12)
for dialect in engines.all_dialects():
n2 = dialect.type_descriptor(n)
eq_(n2.scale, 12, dialect.name)
# test colspec generates successfully using 'scale'
assert n2.get_col_spec()
# test constructor of the dialect-specific type
n3 = n2.__class__(scale=5)
eq_(n3.scale, 5, dialect.name)
@testing.uses_deprecated(".*is deprecated for Numeric")
def go():
n3 = n2.__class__(length=6)
eq_(n3.scale, 6, dialect.name)
go()
def test_deleted_flag(self):
mapper(User, users)
sess = sessionmaker()()
u1 = User(name='u1')
sess.add(u1)
sess.commit()
sess.delete(u1)
sess.flush()
assert u1 not in sess
assert_raises(sa.exc.InvalidRequestError, sess.add, u1)
sess.rollback()
assert u1 in sess
sess.delete(u1)
sess.commit()
assert u1 not in sess
assert_raises(sa.exc.InvalidRequestError, sess.add, u1)
make_transient(u1)
sess.add(u1)
sess.commit()
eq_(sess.query(User).count(), 1)
def test_string_dates_raise(self):
assert_raises(
TypeError,
testing.db.execute,
select([1]).where(bindparam("date", type_=Date)),
date=str(datetime.date(2007, 10, 30)),
)
def test_length_deprecation(self):
assert_raises(exc.SADeprecationWarning, Numeric, length=8)
@testing.uses_deprecated(".*is deprecated for Numeric")
def go():
n = Numeric(length=12)
assert n.scale == 12
go()
n = Numeric(scale=12)
for dialect in engines.all_dialects():
n2 = dialect.type_descriptor(n)
eq_(n2.scale, 12, dialect.name)
# test colspec generates successfully using 'scale'
assert n2.get_col_spec()
# test constructor of the dialect-specific type
n3 = n2.__class__(scale=5)
eq_(n3.scale, 5, dialect.name)
@testing.uses_deprecated(".*is deprecated for Numeric")
def go():
n3 = n2.__class__(length=6)
eq_(n3.scale, 6, dialect.name)
go()
def test_versioncheck(self):
"""query.with_lockmode performs a 'version check' on an already loaded instance"""
s1 = create_session(autocommit=False)
mapper(Foo, version_table, version_id_col=version_table.c.version_id)
f1s1 = Foo(value='f1 value')
s1.add(f1s1)
s1.commit()
s2 = create_session(autocommit=False)
f1s2 = s2.query(Foo).get(f1s1.id)
f1s2.value = 'f1 new value'
s2.commit()
# load, version is wrong
assert_raises(sa.orm.exc.ConcurrentModificationError,
s1.query(Foo).with_lockmode('read').get, f1s1.id)
# reload it - this expires the old version first
s1.refresh(f1s1, lockmode='read')
# now assert version OK
s1.query(Foo).with_lockmode('read').get(f1s1.id)
# assert brand new load is OK too
s1.close()
s1.query(Foo).with_lockmode('read').get(f1s1.id)
def test_explode_in_initializer(self):
engine = engines.testing_engine()
def broken_initialize(connection):
connection.execute("select fake_stuff from _fake_table")
engine.dialect.initialize = broken_initialize
# raises a DBAPIError, not an AttributeError
assert_raises(exc.DBAPIError, engine.connect)
# dispose connections so we get a new one on
# next go
engine.dispose()
p1 = engine.pool
def is_disconnect(e):
return True
engine.dialect.is_disconnect = is_disconnect
# invalidate() also doesn't screw up
assert_raises(exc.DBAPIError, engine.connect)
# pool was recreated
assert engine.pool is not p1
def test_nonreflected_fk_raises(self):
"""test that a NoReferencedColumnError is raised when reflecting
a table with an FK to another table which has not included the target
column in its reflection.
"""
meta = MetaData(testing.db)
a1 = Table('a',
meta,
Column('x', sa.Integer, primary_key=True),
Column('z', sa.Integer),
test_needs_fk=True)
b1 = Table('b',
meta,
Column('y', sa.Integer, sa.ForeignKey('a.x')),
test_needs_fk=True)
meta.create_all()
try:
m2 = MetaData(testing.db)
a2 = Table('a', m2, include_columns=['z'], autoload=True)
b2 = Table('b', m2, autoload=True)
assert_raises(tsa.exc.NoReferencedColumnError, a2.join, b2)
finally:
meta.drop_all()
def test_rollback_recover(self):
mapper(User, users)
session = sessionmaker()()
u1, u2, u3= \
User(name='u1'),\
User(name='u2'),\
User(name='u3')
session.add_all([u1, u2, u3])
session.commit()
session.delete(u2)
u4 = User(name='u2')
session.add(u4)
session.flush()
u5 = User(name='u3')
session.add(u5)
assert_raises(orm_exc.FlushError, session.flush)
assert u5 not in session
assert u2 not in session.deleted
session.rollback()
def test_mapped_managerattr(self):
t = Table('t', MetaData(),
Column('id', Integer, primary_key=True),
Column(attributes.ClassManager.MANAGER_ATTR, Integer))
class T(object): pass
assert_raises(KeyError, mapper, T, t)
def test_pk_violation_with_savepoint(self):
s = self.session()
a1 = Address(email_address='foo')
u1 = User(id=1, name='ed', addresses=[a1])
s.add(u1)
s.commit()
a2 = Address(email_address='bar')
u2 = User(id=1, name='jack', addresses=[a2])
u1.name = 'edward'
a1.email_address = 'foober'
s.begin_nested()
s.add(u2)
assert_raises(sa_exc.FlushError, s.commit)
assert_raises(sa_exc.InvalidRequestError, s.commit)
s.rollback()
assert u2 not in s
assert a2 not in s
assert u1 in s
assert a1 in s
s.commit()
assert s.query(User).all() == [
User(id=1,
name='edward',
addresses=[Address(email_address='foober')])
]
def test_single_parent_raise(self):
sess = create_session()
y = T2(data='T2a')
x = T1(data='T1a', t2=y)
assert_raises(sa_exc.InvalidRequestError, T1, data='T1b', t2=y)
def test_inheriting(self):
mapper(A, a_table, properties={
'some_dest': relationship(Dest,back_populates='many_a')
})
mapper(B, b_table, inherits=A, concrete=True,
properties={
'some_dest': relationship(Dest, back_populates='many_b')
})
mapper(Dest, dest_table, properties={
'many_a': relationship(A,back_populates='some_dest'),
'many_b': relationship(B,back_populates='some_dest')
})
sess = sessionmaker()()
dest1 = Dest(name='c1')
dest2 = Dest(name='c2')
a1 = A(some_dest=dest1, aname='a1')
a2 = A(some_dest=dest2, aname='a2')
b1 = B(some_dest=dest1, bname='b1')
b2 = B(some_dest=dest1, bname='b2')
assert_raises(AttributeError, setattr, b1, 'aname', 'foo')
assert_raises(AttributeError, getattr, A, 'bname')
assert dest2.many_a == [a2]
assert dest1.many_a == [a1]
assert dest1.many_b == [b1, b2]
sess.add_all([dest1, dest2])
sess.commit()
assert sess.query(Dest).filter(Dest.many_a.contains(a2)).one() is dest2
assert dest2.many_a == [a2]
assert dest1.many_a == [a1]
assert dest1.many_b == [b1, b2]
assert sess.query(B).filter(B.bname == 'b1').one() is b1
def test_empty_insert_pk2(self):
assert_raises(
exc.DBAPIError,
self._test_empty_insert,
Table('b', MetaData(testing.db),
Column('x', Integer, primary_key=True),
Column('y', Integer, primary_key=True)))
def test_notsane_warning(self):
# clear the warning module's ignores to force the SAWarning this
# test relies on to be emitted (it may have already been ignored
# forever by other VersioningTests)
try:
del __warningregistry__
except NameError:
pass
save = testing.db.dialect.supports_sane_rowcount
testing.db.dialect.supports_sane_rowcount = False
try:
mapper(Foo, version_table,
version_id_col=version_table.c.version_id)
s1 = create_session(autocommit=False)
f1 = Foo(value='f1')
f2 = Foo(value='f2')
s1.add_all((f1, f2))
s1.commit()
f1.value='f1rev2'
assert_raises(sa.exc.SAWarning, s1.commit)
finally:
testing.db.dialect.supports_sane_rowcount = save
def test_noninherited_warning(self):
mapper(A, a_table, properties={
'some_c':relation(C)
})
mapper(B, b_table,inherits=A, concrete=True)
mapper(C, c_table)
b = B()
c = C()
assert_raises(AttributeError, setattr, b, 'some_c', c)
clear_mappers()
mapper(A, a_table, properties={
'a_id':a_table.c.id
})
mapper(B, b_table,inherits=A, concrete=True)
mapper(C, c_table)
b = B()
assert_raises(AttributeError, setattr, b, 'a_id', 3)
clear_mappers()
mapper(A, a_table, properties={
'a_id':a_table.c.id
})
mapper(B, b_table,inherits=A, concrete=True)
mapper(C, c_table)
def test_double_fk_usage_raises(self):
f = ForeignKey('b.id')
assert_raises(exc.InvalidRequestError, Table, "a", metadata,
Column('x', Integer, f),
Column('y', Integer, f)
)
def test_versioncheck(self):
"""query.with_lockmode performs a 'version check' on an already loaded instance"""
s1 = create_session(autocommit=False)
mapper(Foo, version_table, version_id_col=version_table.c.version_id)
f1s1 = Foo(value='f1 value')
s1.add(f1s1)
s1.commit()
s2 = create_session(autocommit=False)
f1s2 = s2.query(Foo).get(f1s1.id)
f1s2.value='f1 new value'
s2.commit()
# load, version is wrong
assert_raises(
sa.orm.exc.ConcurrentModificationError,
s1.query(Foo).with_lockmode('read').get, f1s1.id
)
# reload it - this expires the old version first
s1.refresh(f1s1, lockmode='read')
# now assert version OK
s1.query(Foo).with_lockmode('read').get(f1s1.id)
# assert brand new load is OK too
s1.close()
s1.query(Foo).with_lockmode('read').get(f1s1.id)
def test_unknown_types(self):
meta = MetaData(testing.db)
t = Table("test", meta,
Column('foo', sa.DateTime))
import sys
dialect_module = sys.modules[testing.db.dialect.__module__]
# we're relying on the presence of "ischema_names" in the
# dialect module, else we can't test this. we need to be able
# to get the dialect to not be aware of some type so we temporarily
# monkeypatch. not sure what a better way for this could be,
# except for an established dialect hook or dialect-specific tests
if not hasattr(dialect_module, 'ischema_names'):
return
ischema_names = dialect_module.ischema_names
t.create()
dialect_module.ischema_names = {}
try:
m2 = MetaData(testing.db)
assert_raises(tsa.exc.SAWarning, Table, "test", m2, autoload=True)
@testing.emits_warning('Did not recognize type')
def warns():
m3 = MetaData(testing.db)
t3 = Table("test", m3, autoload=True)
assert t3.c.foo.type.__class__ == sa.types.NullType
finally:
dialect_module.ischema_names = ischema_names
t.drop()
def test_noeq_deprecation(self):
p1 = PickleType()
assert_raises(DeprecationWarning, p1.compare_values,
pickleable.BarWithoutCompare(1, 2),
pickleable.BarWithoutCompare(1, 2))
assert_raises(DeprecationWarning, p1.compare_values,
pickleable.OldSchoolWithoutCompare(1, 2),
pickleable.OldSchoolWithoutCompare(1, 2))
@testing.uses_deprecated()
def go():
# test actual dumps comparison
assert p1.compare_values(pickleable.BarWithoutCompare(1, 2),
pickleable.BarWithoutCompare(1, 2))
assert p1.compare_values(pickleable.OldSchoolWithoutCompare(1, 2),
pickleable.OldSchoolWithoutCompare(1, 2))
go()
assert p1.compare_values({1: 2, 3: 4}, {3: 4, 1: 2})
p2 = PickleType(mutable=False)
assert not p2.compare_values(pickleable.BarWithoutCompare(1, 2),
pickleable.BarWithoutCompare(1, 2))
assert not p2.compare_values(pickleable.OldSchoolWithoutCompare(1, 2),
pickleable.OldSchoolWithoutCompare(1, 2))
def test_rollback_recover(self):
mapper(User, users)
session = sessionmaker()()
u1, u2, u3= \
User(name='u1'),\
User(name='u2'),\
User(name='u3')
session.add_all([u1, u2, u3])
session.commit()
session.delete(u2)
u4 = User(name='u2')
session.add(u4)
session.flush()
u5 = User(name='u3')
session.add(u5)
assert_raises(orm_exc.FlushError, session.flush)
assert u5 not in session
assert u2 not in session.deleted
session.rollback()
def test_pk_violation(self):
s = self.session()
a1 = Address(email_address='foo')
u1 = User(id=1, name='ed', addresses=[a1])
s.add(u1)
s.commit()
a2 = Address(email_address='bar')
u2 = User(id=1, name='jack', addresses=[a2])
u1.name = 'edward'
a1.email_address = 'foober'
s.add(u2)
assert_raises(sa_exc.FlushError, s.commit)
assert_raises(sa_exc.InvalidRequestError, s.commit)
s.rollback()
assert u2 not in s
assert a2 not in s
assert u1 in s
assert a1 in s
assert u1.name == 'ed'
assert a1.email_address == 'foo'
u1.name = 'edward'
a1.email_address = 'foober'
s.commit()
eq_(
s.query(User).all(),
[User(id=1, name='edward', addresses=[Address(email_address='foober')])]
)
def test_too_long_idx_name(self):
dialect = testing.db.dialect.__class__()
for max_ident, max_index in [(22, None), (256, 22)]:
dialect.max_identifier_length = max_ident
dialect.max_index_name_length = max_index
for tname, cname, exp in [
('sometable', 'this_name_is_too_long', 'ix_sometable_t_09aa'),
('sometable', 'this_name_alsois_long', 'ix_sometable_t_3cf1'),
]:
t1 = Table(
tname,
MetaData(),
Column(cname, Integer, index=True),
)
ix1 = list(t1.indexes)[0]
self.assert_compile(schema.CreateIndex(ix1),
"CREATE INDEX %s "
"ON %s (%s)" % (exp, tname, cname),
dialect=dialect)
dialect.max_identifier_length = 22
dialect.max_index_name_length = None
t1 = Table('t', MetaData(), Column('c', Integer))
assert_raises(
exc.IdentifierError,
schema.CreateIndex(
Index("this_other_name_is_too_long_for_what_were_doing",
t1.c.c)).compile,
dialect=dialect)
def test_unknown_types(self):
meta = MetaData(testing.db)
t = Table("test", meta, Column('foo', sa.DateTime))
import sys
dialect_module = sys.modules[testing.db.dialect.__module__]
# we're relying on the presence of "ischema_names" in the
# dialect module, else we can't test this. we need to be able
# to get the dialect to not be aware of some type so we temporarily
# monkeypatch. not sure what a better way for this could be,
# except for an established dialect hook or dialect-specific tests
if not hasattr(dialect_module, 'ischema_names'):
return
ischema_names = dialect_module.ischema_names
t.create()
dialect_module.ischema_names = {}
try:
m2 = MetaData(testing.db)
assert_raises(tsa.exc.SAWarning, Table, "test", m2, autoload=True)
@testing.emits_warning('Did not recognize type')
def warns():
m3 = MetaData(testing.db)
t3 = Table("test", m3, autoload=True)
assert t3.c.foo.type.__class__ == sa.types.NullType
finally:
dialect_module.ischema_names = ischema_names
t.drop()
def test_literal_interpretation(self):
t = table('test', column('col1'))
assert_raises(exc.ArgumentError, case, [("x", "y")])
self.assert_compile(case([("x", "y")], value=t.c.col1), "CASE test.col1 WHEN :param_1 THEN :param_2 END")
self.assert_compile(case([(t.c.col1==7, "y")], else_="z"), "CASE WHEN (test.col1 = :col1_1) THEN :param_1 ELSE :param_2 END")
def test_noninherited_warning(self):
mapper(A, a_table, properties={
'some_c':relation(C)
})
mapper(B, b_table,inherits=A, concrete=True)
mapper(C, c_table)
b = B()
c = C()
assert_raises(AttributeError, setattr, b, 'some_c', c)
clear_mappers()
mapper(A, a_table, properties={
'a_id':a_table.c.id
})
mapper(B, b_table,inherits=A, concrete=True)
mapper(C, c_table)
b = B()
assert_raises(AttributeError, setattr, b, 'a_id', 3)
clear_mappers()
mapper(A, a_table, properties={
'a_id':a_table.c.id
})
mapper(B, b_table,inherits=A, concrete=True)
mapper(C, c_table)
def test_notsane_warning(self):
# clear the warning module's ignores to force the SAWarning this
# test relies on to be emitted (it may have already been ignored
# forever by other VersioningTests)
try:
del __warningregistry__
except NameError:
pass
save = testing.db.dialect.supports_sane_rowcount
testing.db.dialect.supports_sane_rowcount = False
try:
mapper(Foo,
version_table,
version_id_col=version_table.c.version_id)
s1 = create_session(autocommit=False)
f1 = Foo(value='f1')
f2 = Foo(value='f2')
s1.add_all((f1, f2))
s1.commit()
f1.value = 'f1rev2'
assert_raises(sa.exc.SAWarning, s1.commit)
finally:
testing.db.dialect.supports_sane_rowcount = save
def test_empty_insert_pk3(self):
assert_raises(
exc.DBAPIError, self._test_empty_insert,
Table('c', MetaData(testing.db),
Column('x', Integer, primary_key=True),
Column('y', Integer, DefaultClause('123'),
primary_key=True)))
def test_default_constructor_state_not_shared(self):
scope = scoped_session(sa.orm.sessionmaker())
class A(object):
pass
class B(object):
def __init__(self):
pass
scope.mapper(A, table1)
scope.mapper(B, table2)
A(foo='bar')
assert_raises(TypeError, B, foo='bar')
scope = scoped_session(sa.orm.sessionmaker())
class C(object):
def __init__(self):
pass
class D(object):
pass
scope.mapper(C, table1)
scope.mapper(D, table2)
assert_raises(TypeError, C, foo='bar')
D(foo='bar')
def test_basic(self):
carrier = util.ExtensionCarrier()
assert 'translate_row' not in carrier
assert carrier.translate_row() is interfaces.EXT_CONTINUE
assert 'translate_row' not in carrier
assert_raises(AttributeError, lambda: carrier.snickysnack)
class Partial(object):
def __init__(self, marker):
self.marker = marker
def translate_row(self, row):
return self.marker
carrier.append(Partial('end'))
assert 'translate_row' in carrier
assert carrier.translate_row(None) == 'end'
carrier.push(Partial('front'))
assert carrier.translate_row(None) == 'front'
assert 'populate_instance' not in carrier
carrier.append(interfaces.MapperExtension)
# Py3K
#assert 'populate_instance' not in carrier
# Py2K
assert 'populate_instance' in carrier
# end Py2K
assert carrier.interface
for m in carrier.interface:
assert getattr(interfaces.MapperExtension, m)
def test_no_rowcount_on_selects_inserts(self):
"""assert that rowcount is only called on deletes and updates.
This because cursor.rowcount can be expensive on some dialects
such as Firebird.
"""
engine = engines.testing_engine()
metadata.bind = engine
t = Table('t1', metadata, Column('data', String(10)))
metadata.create_all()
class BreakRowcountMixin(object):
@property
def rowcount(self):
assert False
execution_ctx_cls = engine.dialect.execution_ctx_cls
engine.dialect.execution_ctx_cls = type(
"FakeCtx", (BreakRowcountMixin, execution_ctx_cls), {})
try:
r = t.insert().execute({'data': 'd1'}, {'data': 'd2'},
{'data': 'd3'})
eq_(t.select().execute().fetchall(), [('d1', ), ('d2', ),
('d3', )])
assert_raises(AssertionError, t.update().execute, {'data': 'd4'})
assert_raises(AssertionError, t.delete().execute)
finally:
engine.dialect.execution_ctx_cls = execution_ctx_cls
def test_child_row_switch_two(self):
Session = sessionmaker()
sess1 = Session()
sess1.add(P(id=1, data='P version 1'))
sess1.commit()
sess1.close()
p1 = sess1.query(P).first()
sess2 = Session()
p2 = sess2.query(P).first()
sess1.delete(p1)
sess1.commit()
sess1.add(P(id='P1', data='P version 2'))
sess1.commit()
p2.data = 'P overwritten by concurrent tx'
assert_raises(
orm.exc.ConcurrentModificationError,
sess2.commit
)
def test_too_long_idx_name(self):
dialect = testing.db.dialect.__class__()
for max_ident, max_index in [(22, None), (256, 22)]:
dialect.max_identifier_length = max_ident
dialect.max_index_name_length = max_index
for tname, cname, exp in [
('sometable', 'this_name_is_too_long', 'ix_sometable_t_09aa'),
('sometable', 'this_name_alsois_long', 'ix_sometable_t_3cf1'),
]:
t1 = Table(tname, MetaData(),
Column(cname, Integer, index=True),
)
ix1 = list(t1.indexes)[0]
self.assert_compile(
schema.CreateIndex(ix1),
"CREATE INDEX %s "
"ON %s (%s)" % (exp, tname, cname),
dialect=dialect
)
dialect.max_identifier_length = 22
dialect.max_index_name_length = None
t1 = Table('t', MetaData(), Column('c', Integer))
assert_raises(
exc.IdentifierError,
schema.CreateIndex(Index(
"this_other_name_is_too_long_for_what_were_doing",
t1.c.c)).compile,
dialect=dialect
)
def test_default_constructor_state_not_shared(self):
scope = scoped_session(sa.orm.sessionmaker())
class A(object):
pass
class B(object):
def __init__(self):
pass
scope.mapper(A, table1)
scope.mapper(B, table2)
A(foo='bar')
assert_raises(TypeError, B, foo='bar')
scope = scoped_session(sa.orm.sessionmaker())
class C(object):
def __init__(self):
pass
class D(object):
pass
scope.mapper(C, table1)
scope.mapper(D, table2)
assert_raises(TypeError, C, foo='bar')
D(foo='bar')
def test_single_parent_backref(self):
"""test that setting m2m via a uselist=False backref bypasses the single_parent raise"""
mapper(A,
a,
properties={
'bs':
relation(B,
secondary=atob,
cascade="all, delete-orphan",
single_parent=True,
backref=backref('a', uselist=False))
})
mapper(B, b)
sess = create_session()
b1 = B(data='b1')
a1 = A(data='a1', bs=[b1])
assert_raises(sa_exc.InvalidRequestError, A, data='a2', bs=[b1])
a2 = A(data='a2')
b1.a = a2
assert b1 not in a1.bs
assert b1 in a2.bs
def test_single_parent_raise(self):
sess = create_session()
y = T2(data='T2a')
x = T1(data='T1a', t2=y)
assert_raises(sa_exc.InvalidRequestError, T1, data='T1b', t2=y)
def test_pending_raises(self):
# 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 = create_session()
u = User(id=15)
sess.add(u)
assert_raises(sa_exc.InvalidRequestError, sess.expire, u, ['name'])
def test_no_session(self):
mapper(User, users)
sess = create_session()
u = sess.query(User).get(7)
sess.expire(u, attribute_names=['name'])
sess.expunge(u)
assert_raises(orm_exc.DetachedInstanceError, getattr, u, 'name')
def test_pending_raises(self):
# 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 = create_session()
u = User(id=15)
sess.add(u)
assert_raises(sa.exc.InvalidRequestError, sess.expire, u, ['name'])
def test_mapped_managerattr(self):
t = Table('t', MetaData(), Column('id', Integer, primary_key=True),
Column(attributes.ClassManager.MANAGER_ATTR, Integer))
class T(object):
pass
assert_raises(KeyError, mapper, T, t)
def test_uselist_false_warning(self):
"""test that multiple rows received by a uselist=False raises a warning."""
mapper(User, users, properties={"order": relation(Order, uselist=False)})
mapper(Order, orders)
s = create_session()
u1 = s.query(User).filter(User.id == 7).one()
assert_raises(sa.exc.SAWarning, getattr, u1, "order")
def test_no_session(self):
mapper(User, users)
sess = create_session()
u = sess.query(User).get(7)
sess.expire(u, attribute_names=['name'])
sess.expunge(u)
assert_raises(sa.exc.UnboundExecutionError, getattr, u, 'name')
def test_empty_insert_pk3(self):
assert_raises(
exc.DBAPIError,
self._test_empty_insert,
Table('c', MetaData(testing.db),
Column('x', Integer, primary_key=True),
Column('y', Integer, DefaultClause('123'),
primary_key=True)))
def test_no_session(self):
mapper(User, users)
sess = create_session()
u = sess.query(User).get(7)
sess.expire(u, attribute_names=['name'])
sess.expunge(u)
assert_raises(orm_exc.DetachedInstanceError, getattr, u, 'name')
def test_no_session(self):
mapper(User, users)
sess = create_session()
u = sess.query(User).get(7)
sess.expire(u, attribute_names=['name'])
sess.expunge(u)
assert_raises(sa.exc.UnboundExecutionError, getattr, u, 'name')
def test_needs_parent(self):
"""test the error raised when parent object is not bound."""
mapper(User, users, properties={"addresses": relation(mapper(Address, addresses), lazy=True)})
sess = create_session()
q = sess.query(User)
u = q.filter(users.c.id == 7).first()
sess.expunge(u)
assert_raises(orm_exc.DetachedInstanceError, getattr, u, "addresses")
def test_single_parent_raise(self):
a1 = Address(email_address='some address')
u1 = User(name='u1', address=a1)
assert_raises(sa_exc.InvalidRequestError, Address,
email_address='asd', user=u1)
a2 = Address(email_address='asd')
u1.address = a2
assert u1.address is not a1
assert a1.user is None
def test_uselist_false_warning(self):
"""test that multiple rows received by a uselist=False raises a warning."""
mapper(User,
users,
properties={'order': relationship(Order, uselist=False)})
mapper(Order, orders)
s = create_session()
u1 = s.query(User).filter(User.id == 7).one()
assert_raises(sa.exc.SAWarning, getattr, u1, 'order')
def test_dont_persist_alias(self):
db = sqlsoup.SqlSoup(engine)
MappedBooks = db.books
b = db.books._table
s = select([b.c.published_year, func.count('*').label('n')],
from_obj=[b], group_by=[b.c.published_year])
s = s.alias('years_with_count')
years_with_count = db.map(s, primary_key=[s.c.published_year])
assert_raises(exc.InvalidRequestError, years_with_count.insert,
published_year='2007', n=1)
def test_oracle_has_no_on_update_cascade(self):
bar = Table('bar', metadata, Column('id', Integer,
primary_key=True), Column('foo_id', Integer,
ForeignKey('foo.id', onupdate='CASCADE')))
assert_raises(exc.SAWarning, bar.create)
bat = Table('bat', metadata, Column('id', Integer,
primary_key=True), Column('foo_id', Integer),
ForeignKeyConstraint(['foo_id'], ['foo.id'],
onupdate='CASCADE'))
assert_raises(exc.SAWarning, bat.create)
def test_append_listener(self):
metadata, table, bind = self.metadata, self.table, self.bind
fn = lambda *a: None
table.append_ddl_listener('before-create', fn)
assert_raises(LookupError, table.append_ddl_listener, 'blah', fn)
metadata.append_ddl_listener('before-create', fn)
assert_raises(LookupError, metadata.append_ddl_listener, 'blah', fn)
def test_uselist_false_warning(self):
"""test that multiple rows received by a
uselist=False raises a warning."""
mapper(User,
users,
properties={'order': relationship(Order, uselist=False)})
mapper(Order, orders)
s = create_session()
assert_raises(sa.exc.SAWarning,
s.query(User).options(subqueryload(User.order)).all)
