def setUp(self):
super(PatchSetTest, self).setUp()
self.sys_dir = self.makeDir()
self.package_dir = os.path.join(self.sys_dir, "mypackage")
os.makedirs(self.package_dir)
self.makeFile(content="",
dirname=self.package_dir,
basename="__init__.py")
sys.path.append(self.sys_dir)
import mypackage
self.patch_package = PatchSet(mypackage, sub_level="foo")
def __init__(self, creates, drops, deletes, patch_set, committer=None):
self._creates = creates
self._drops = drops
self._deletes = deletes
if isinstance(patch_set, types.ModuleType):
# Up to version 0.20.0 the fourth positional parameter used to
# be a raw module containing the patches. We wrap it with PatchSet
# for keeping backward-compatibility.
patch_set = PatchSet(patch_set)
self._patch_set = patch_set
self._committer = committer
def setUp(self):
super(PatchApplierTest, self).setUp()
self.patchdir = self.makeDir()
self.pkgdir = os.path.join(self.patchdir, "mypackage")
os.makedirs(self.pkgdir)
f = open(os.path.join(self.pkgdir, "__init__.py"), "w")
f.write("shared_data = []")
f.close()
# Order of creation here is important to try to screw up the
# patch ordering, as os.listdir returns in order of mtime (or
# something).
for pname, data in [("patch_380.py", patch_test_1),
("patch_42.py", patch_test_0)]:
self.add_module(pname, data)
sys.path.append(self.patchdir)
self.filename = self.makeFile()
self.uri = "sqlite:///%s" % self.filename
self.store = Store(create_database(self.uri))
self.store.execute("CREATE TABLE patch "
"(version INTEGER NOT NULL PRIMARY KEY)")
self.assertFalse(self.store.get(Patch, (42)))
self.assertFalse(self.store.get(Patch, (380)))
import mypackage
self.mypackage = mypackage
self.patch_set = PatchSet(mypackage)
# Create another connection just to keep track of the state of the
# whole transaction manager. See the assertion functions below.
self.another_store = Store(create_database("sqlite:"))
self.another_store.execute("CREATE TABLE test (id INT)")
self.another_store.commit()
self.prepare_for_transaction_check()
class Committer(object):
def commit(committer):
self.store.commit()
self.another_store.commit()
def rollback(committer):
self.store.rollback()
self.another_store.rollback()
self.committer = Committer()
self.patch_applier = PatchApplier(self.store, self.patch_set,
self.committer)
def setUp(self):
super(ZStormResourceManagerTest, self).setUp()
package_dir = self.makeDir()
sys.path.append(package_dir)
self.patch_dir = os.path.join(package_dir, "patch_package")
os.mkdir(self.patch_dir)
self.makeFile(path=os.path.join(self.patch_dir, "__init__.py"),
content="")
self.makeFile(path=os.path.join(self.patch_dir, "patch_1.py"),
content=PATCH)
import patch_package
create = ["CREATE TABLE test (foo TEXT UNIQUE, bar INT)"]
drop = ["DROP TABLE test"]
delete = ["DELETE FROM test"]
uri = "sqlite:///%s" % self.makeFile()
schema = ZSchema(create, drop, delete, PatchSet(patch_package))
self.databases = [{"name": "test", "uri": uri, "schema": schema}]
self.resource = ZStormResourceManager(self.databases)
self.resource.vertical_patching = False
self.store = Store(create_database(uri))
class PatchSetTest(MockerTestCase):
def setUp(self):
super(PatchSetTest, self).setUp()
self.sys_dir = self.makeDir()
self.package_dir = os.path.join(self.sys_dir, "mypackage")
os.makedirs(self.package_dir)
self.makeFile(content="",
dirname=self.package_dir,
basename="__init__.py")
sys.path.append(self.sys_dir)
import mypackage
self.patch_package = PatchSet(mypackage, sub_level="foo")
def tearDown(self):
super(PatchSetTest, self).tearDown()
for name in list(sys.modules):
if name == "mypackage" or name.startswith("mypackage."):
del sys.modules[name]
def test_get_patch_versions(self):
"""
The C{get_patch_versions} method returns the available patch versions,
by looking at directories named like "patch_N".
"""
patch_1_dir = os.path.join(self.package_dir, "patch_1")
os.makedirs(patch_1_dir)
self.assertEqual([1], self.patch_package.get_patch_versions())
def test_get_patch_versions_ignores_non_patch_directories(self):
"""
The C{get_patch_versions} method ignores files or directories not
matching the required name pattern.
"""
random_dir = os.path.join(self.package_dir, "random")
os.makedirs(random_dir)
self.assertEqual([], self.patch_package.get_patch_versions())
def test_get_patch_module(self):
"""
The C{get_patch_module} method returns the Python module for the patch
with the given version.
"""
patch_1_dir = os.path.join(self.package_dir, "patch_1")
os.makedirs(patch_1_dir)
self.makeFile(content="", dirname=patch_1_dir, basename="__init__.py")
self.makeFile(content="", dirname=patch_1_dir, basename="foo.py")
patch_module = self.patch_package.get_patch_module(1)
self.assertEqual("mypackage.patch_1.foo", patch_module.__name__)
def test_get_patch_module_no_sub_level(self):
"""
The C{get_patch_module} method returns a dummy patch module if no
sub-level file exists in the patch directory for the given version.
"""
patch_1_dir = os.path.join(self.package_dir, "patch_1")
os.makedirs(patch_1_dir)
patch_module = self.patch_package.get_patch_module(1)
store = object()
self.assertIsNone(patch_module.apply(store))