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))