def __init__( self, database, host, settings, desktop, nuke = False ):
self.database = database
self.settings = settings
self.desktop = desktop
self.main_notebook = None
self.anonymous = None
if nuke is True:
self.database.execute( file( "model/drop.sql" ).read(), commit = False )
if host:
self.database.execute( file( "model/schema.sql" ).read(), commit = False )
else:
self.database.execute_script( file( "model/schema.sqlite" ).read(), commit = False )
self.create_main_notebook()
self.create_anonymous_user()
if desktop is True:
self.create_desktop_user()
self.database.commit()
version = Schema_upgrader.version_string_to_tuple( VERSION )
Schema_upgrader.schema_version( database, default_version = version )
self.database.commit()
def __init__(self, database, host, settings, desktop, nuke=False):
self.database = database
self.settings = settings
self.desktop = desktop
self.main_notebook = None
self.anonymous = None
if nuke is True:
self.database.execute(file("model/drop.sql").read(), commit=False)
if host:
self.database.execute(file("model/schema.sql").read(),
commit=False)
else:
self.database.execute_script(file("model/schema.sqlite").read(),
commit=False)
self.create_main_notebook()
self.create_anonymous_user()
if desktop is True:
self.create_desktop_user()
self.database.commit()
version = Schema_upgrader.version_string_to_tuple(VERSION)
Schema_upgrader.schema_version(database, default_version=version)
self.database.commit()
class Test_schema_upgrader(object):
def setUp(self):
# make an in-memory sqlite database to use during testing
self.connection = Connection_wrapper(
sqlite.connect(":memory:",
detect_types=sqlite.PARSE_DECLTYPES,
check_same_thread=False))
self.cache = Stub_cache()
cursor = self.connection.cursor()
cursor.execute(Stub_object.sql_create_table())
self.fake_files = {
} # map of fake filename (full path) to fake file contents
self.database = Database(self.connection, self.cache)
self.upgrader = Schema_upgrader(self.database,
glob=self.glob,
read_file=self.read_file)
def tearDown(self):
self.database.close()
def glob(self, glob_pattern):
"""
A fake glob function that doesn't use the filesystem.
"""
re_pattern = re.compile(glob_pattern.replace("*", "[^/]*"))
return [
filename for filename in self.fake_files.keys()
if re_pattern.search(filename)
]
def read_file(self, filename):
"""
A fake read file function that doesn't use the filesystem.
"""
contents = self.fake_files.get(filename)
if not contents:
raise IOError()
return contents
def test_upgrade_schema(self, to_version=None):
if not to_version:
to_version = u"5.7.11"
self.fake_files = {
u"model/delta/5.6.7.sqlite":
u"create table new_table ( foo text ); insert into new_table values ( 'hi' );",
u"model/delta/5.6.8.sqlite":
u"insert into new_table values ( 'bye' );",
u"model/delta/5.6.10.sqlite":
u"alter table new_table add column bar text;",
u"model/delta/5.7.11.sqlite":
u"insert into new_table values ( 'whee', 'stuff' );",
u"model/delta/5.7.18.sqlite":
u"insert into new_table values ( 'more', 'things' );",
}
self.upgrader.upgrade_schema(to_version)
result = self.database.select_many(tuple, u"select * from new_table;")
if to_version == u"5.7.11":
assert result == [(u"hi", None), (u"bye", None), ("whee", "stuff")]
else:
assert result == [(u"hi", None), (u"bye", None), ("whee", "stuff"),
("more", "things")]
result = self.database.select_many(tuple,
u"select * from schema_version;")
if to_version == u"5.7.11":
assert result == [(5, 7, 11)]
else:
assert result == [(5, 7, 18)]
def test_upgrade_schema_with_schema_version_table(self):
self.database.execute(
u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );"
)
self.database.execute(
u"insert into schema_version values ( 0, 0, 0 );")
self.test_upgrade_schema()
def test_upgrade_schema_with_schema_version_table_and_starting_version(
self):
self.database.execute(
u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );"
)
self.database.execute(
u"insert into schema_version values ( 5, 6, 6 );")
self.fake_files[
u"model/delta/5.6.1.sqlite"] = u"this is not valid sql and should not be executed anyway;"
self.fake_files[u"model/delta/5.6.6.sqlite"] = u"also invalid;"
self.test_upgrade_schema()
def test_upgrade_schema_with_schema_version_table_and_target_version_without_schema(
self):
self.database.execute(
u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );"
)
self.database.execute(
u"insert into schema_version values ( 0, 0, 0 );")
self.test_upgrade_schema(to_version=u"5.7.20")
def test_upgrade_schema_with_schema_version_table_and_starting_version_and_target_version_without_schema(
self):
self.database.execute(
u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );"
)
self.database.execute(
u"insert into schema_version values ( 5, 6, 6 );")
self.test_upgrade_schema(to_version=u"5.7.20")
def test_upgrade_schema_with_future_ending_version(self):
self.fake_files = {
u"model/delta/5.6.7.sqlite":
u"create table new_table ( foo text ); insert into new_table values ( 'hi' );",
u"model/delta/5.6.8.sqlite":
u"insert into new_table values ( 'bye' );",
u"model/delta/5.6.10.sqlite":
u"alter table new_table add column bar text;",
u"model/delta/5.7.11.sqlite":
u"insert into new_table values ( 'whee', 'stuff' );",
u"model/delta/5.7.18.sqlite":
u"insert into new_table values ( 'more', 'and more' );",
}
self.upgrader.upgrade_schema(u"5.8.55")
result = self.database.select_many(tuple, u"select * from new_table;")
assert result == [(u"hi", None), (u"bye", None), ("whee", "stuff"),
("more", "and more")]
result = self.database.select_many(tuple,
u"select * from schema_version;")
assert result == [(5, 7, 18)]
def test_upgrade_schema_twice(self):
self.test_upgrade_schema()
# the second upgrade should have no effect, because at this point it's already upgraded
self.test_upgrade_schema()
def test_upgrade_schema_with_filename_with_invalid_version(self):
# the filename, not composed of all-integer parts, should be skipped
self.fake_files[
u"model/delta/5.6.9b.sqlite"] = u"this is not valid sql and should not be executed anyway;"
self.test_upgrade_schema()
def test_upgrade_schema_default_to_start_version_of_1_5_4(self):
# test that if no schema_version table exists, then the starting version is assumed to be 1.5.4
self.fake_files = {
u"model/delta/1.5.3.sqlite":
u"invalid sql;",
u"model/delta/1.5.4.sqlite":
u"should not be invoked;",
u"model/delta/1.5.5.sqlite":
u"create table new_table ( foo text ); insert into new_table values ( 'hi' );",
u"model/delta/1.5.6.sqlite":
u"insert into new_table values ( 'bye' );",
}
self.upgrader.upgrade_schema(u"1.5.6")
result = self.database.select_many(tuple, u"select * from new_table;")
assert result == [
(u"hi", ),
(u"bye", ),
]
result = self.database.select_many(tuple,
u"select * from schema_version;")
assert result == [(1, 5, 6)]
def test_apply_schema_delta(self):
self.database.execute(
u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );"
)
self.database.execute(
u"insert into schema_version values ( 0, 0, 0 );")
self.fake_files = {
u"model/delta/5.6.5.sqlite":
u"insert into new_table values ( 'should not show up' );",
u"model/delta/5.6.7.sqlite":
u"create table new_table ( foo text ); insert into new_table values ( 'hi' );",
u"model/delta/5.7.18.sqlite":
u"insert into new_table values ( 'should not be present' );",
}
self.upgrader.apply_schema_delta((5, 6, 7),
u"model/delta/5.6.7.sqlite")
result = self.database.select_many(unicode,
u"select * from new_table;")
assert result == [u"hi"]
result = self.database.select_many(tuple,
u"select * from schema_version;")
assert result == [(5, 6, 7)]
@raises(IOError)
def test_apply_schema_delta_with_unknown_file(self):
self.upgrader.apply_schema_delta((5, 6, 7),
u"model/delta/5.6.7.sqlite")
def test_version_string_to_tuple(self):
version = self.upgrader.version_string_to_tuple("2.5.13")
assert len(version) == 3
assert version[0] == 2
assert version[1] == 5
assert version[2] == 13
def test_version_string_to_tuple_with_extension(self):
version = self.upgrader.version_string_to_tuple("2.5.13.sqlite")
assert len(version) == 3
assert version[0] == 2
assert version[1] == 5
assert version[2] == 13
@raises(ValueError)
def test_version_string_to_tuple_with_too_many_parts(self):
version = self.upgrader.version_string_to_tuple("3.14.159.26.5")
@raises(ValueError)
def test_version_string_to_tuple_with_too_few_parts(self):
version = self.upgrader.version_string_to_tuple("3.14")
@raises(ValueError)
def test_version_string_to_tuple_with_non_integer_part(self):
version = self.upgrader.version_string_to_tuple("2.5b.13")
@raises(ValueError)
def test_version_string_to_tuple_with_empty_part(self):
version = self.upgrader.version_string_to_tuple("2..13")
