def setUp(self):
print('setup')
if hasattr(UserTable, 'test_column1'):
try:
delattr(UserTable, 'test_column1')
except:
pass
sa.inspect(UserTable).mapper._expire_memoizations()
del sa.inspect(UserTable).mapper.columns['test_column1']
del sa.inspect(UserTable).mapper._props['test_column1']
if hasattr(UserTable, 'test_column3'):
try:
delattr(UserTable, 'test_column3')
except:
pass
sa.inspect(UserTable).mapper._expire_memoizations()
del sa.inspect(UserTable).mapper.columns['test_column3']
del sa.inspect(UserTable).mapper._props['test_column3']
try:
delete_cmd = 'drop table {}'
self.engine.execute(delete_cmd.format(UserTable.__tablename__))
except Exception as e:
pass
Base.metadata.create_all(self.engine)
UserTable.register(ArchiveTable, self.engine)
MultiColumnUserTable.register(MultiColumnArchiveTable, self.engine)
self.p1 = dict(product_id=10, col1='foobar', col2=10, col3=1)
self.p2 = dict(product_id=11, col1='baz', col2=11, col3=1)
self.p3 = dict(product_id=2546, col1='test', col2=12, col3=0)
self.session = self.Session()
def setUp(self):
Base.metadata.create_all(self.engine)
UserTable.register(ArchiveTable, self.engine)
MultiColumnUserTable.register(MultiColumnArchiveTable, self.engine)
self.p1 = dict(product_id=10, col1='foobar', col2=10, col3=1)
self.p2 = dict(product_id=11, col1='baz', col2=11, col3=1)
self.p3 = dict(product_id=2546, col1='test', col2=12, col3=0)
self.session = self.Session()
def engine():
"""Session-wide test database engine."""
drop_test_db()
create_test_db()
savage.init()
_engine = create_engine(get_test_database_url(),
json_serializer=savage_json_serializer)
Base.metadata.create_all(_engine)
UserTable.register(ArchiveTable, _engine)
MultiColumnUserTable.register(MultiColumnArchiveTable, _engine)
yield _engine
_engine.dispose()
drop_test_db()
def __init__(self, methodName='runTest'):
self.engine1 = sa.create_engine(self.DATABASE_URL,
isolation_level='READ UNCOMMITTED',
echo='debug',
logging_name='engine1')
self.engine2 = sa.create_engine(self.DATABASE_URL,
isolation_level='READ UNCOMMITTED',
echo='debug',
logging_name='engine2')
self.Session1 = sessionmaker(bind=self.engine1)
self.Session2 = sessionmaker(bind=self.engine2)
Base.metadata.create_all(self.engine1)
UserTable.register(ArchiveTable, self.engine1)
UserTable.register(ArchiveTable, self.engine1)
self.p1 = dict(product_id=10, col1='foobar', col2=10, col3=True)
super(TestConcurrentUpdate, self).__init__(methodName)
def test_register_bad_archive_table_fails(engine):
"""
Assert that an archive table with the following conditions fails to get registered:
* no product_id column
* the product_id column has the wrong type
"""
Base_ = declarative_base(
) # use alternate base so these tables don't get created
try:
# no product_id column
class ArchiveNoFKey(SavageLogMixin, Base_):
__tablename__ = "no_fkey"
user_id = Column(String(50))
with pytest.raises(LogTableCreationError):
UserTable.register(ArchiveNoFKey, engine)
# product_id is not the same type as product_id
class ArchiveWrongFKey(SavageLogMixin, Base_):
__tablename__ = "wrong_fkey"
product_id = Column(String(10))
user_id = Column(String(50))
with pytest.raises(LogTableCreationError):
UserTable.register(ArchiveWrongFKey, engine)
# column is named something different
class ArchiveWrongName(SavageLogMixin, Base_):
__tablename__ = "wrong_name"
foo = Column(String(10))
user_id = Column(String(50))
with pytest.raises(LogTableCreationError):
UserTable.register(ArchiveWrongName, engine)
# user did not add user_id column
class ArchiveNoUserId(SavageLogMixin, Base_):
__tablename__ = "no_user_id"
product_id = Column(Integer, nullable=False)
with pytest.raises(LogTableCreationError):
UserTable.register(ArchiveNoUserId, engine)
# no unique constraint on version column
class ArchiveNoConstraint(SavageLogMixin, Base_):
__tablename__ = "no_constraint"
product_id = Column(Integer)
user_id = Column(String(50))
with pytest.raises(LogTableCreationError):
UserTable.register(ArchiveNoConstraint, engine)
finally:
UserTable.register(ArchiveTable, engine)
def test_register_user_table(engine):
Base_ = declarative_base()
try:
# --- Test failure cases ---
class WrongVersionColumns(SavageModelMixin, Base_):
__tablename__ = "wrong_version_cols"
version_columns = ["id"]
pid = Column(Integer, primary_key=True)
class WrongVersionColumnsArchive(SavageLogMixin, Base_):
__tablename__ = "wrong_version_cols_archive"
pid = Column(Integer)
with pytest.raises(LogTableCreationError):
WrongVersionColumns.register(WrongVersionColumnsArchive, engine)
class NoVersionCols(SavageModelMixin, Base_):
__tablename__ = "no_version_cols"
pid = Column(Integer, primary_key=True)
class NoVersionColsArchive(SavageLogMixin, Base_):
__tablename__ = "no_version_cols_archive"
pid = Column(Integer)
with pytest.raises(LogTableCreationError):
NoVersionCols.register(NoVersionColsArchive, engine)
class NoConstraint(SavageModelMixin, Base_):
__tablename__ = "no_constraint"
version_columns = ["pid1", "pid2"]
pid1 = Column(Integer, primary_key=True)
pid2 = Column(Integer)
class NoConstraintArchive(SavageLogMixin, Base_):
__tablename__ = "no_constraint_archive"
pid1 = Column(Integer)
pid2 = Column(Integer)
with pytest.raises(LogTableCreationError):
NoConstraint.register(NoConstraintArchive, engine)
# --- Test success cases ---
class PKConstraint(SavageModelMixin, Base_):
__tablename__ = "pk_constraint"
version_columns = ["pid1"]
pid1 = Column(Integer, primary_key=True)
pid2 = Column(Integer)
class PKConstraintArchive(SavageLogMixin, Base_):
__tablename__ = "pk_constraint_archive"
pid1 = Column(Integer)
user_id = Column(Integer)
__table_args__ = (UniqueConstraint("pid1",
"version_id",
name="pid"), )
Base_.metadata.create_all(engine)
PKConstraint.register(PKConstraintArchive, engine)
finally:
UserTable.register(ArchiveTable, engine)
Base_.metadata.drop_all(engine)
