def test_missingUserSitePackages(self): """ L{BranchManager.getPaths} should return an iterable which does not have as an element the user-specific site-packages directory, if that directory does not exist. """ home = self.mktemp() self.changeEnvironment('HOME', home) b = BranchManager() self.assertNotIn(self._perUserSitePackages(home), list(b.getPaths()))
def test_userSitePackages(self): """ L{BranchManager.getPaths} should return an iterable which has as an element the user-specific site-packages directory, if that directory exists. """ home = self.mktemp() sitePackages = self._perUserSitePackages(home) os.makedirs(sitePackages) self.changeEnvironment('HOME', home) b = BranchManager() self.assertIn(sitePackages, list(b.getPaths()))
def setUp(self): """ Create a branch manager with temporary directories for all its working filesystem paths. """ self.paths = self.mktemp() self.projects = self.mktemp() os.makedirs(self.paths) os.makedirs(self.projects) self.manager = BranchManager(self.paths, self.projects) self.cwd = os.getcwd() self.repositories = FilePath(self.mktemp())
def test_projectsEnvironment(self): """ Verify that BranchManager draws from the environment for the projects path. """ self.changeEnvironment("COMBINATOR_PROJECTS", "somedir") b = BranchManager() self.assertEqual(b.svnProjectsDir, os.path.abspath("somedir"))
def test_creation(self): """ Verify that a newly-created branch manager can locate the paths it needs to do things. """ b = BranchManager() self.assertNotEqual(b.svnProjectsDir, None) self.assertNotEqual(b.sitePathsPath, None) self.assertNotEqual(b.binCachePath, None)
def test_pathsEnvironment(self): """ Verify that BranchManager draws from the environment for the paths path. """ self.changeEnvironment("COMBINATOR_PATHS", "pathdir") b = BranchManager() self.assertEqual(b.sitePathsPath, os.path.abspath("pathdir")) self.assertEqual(b.binCachePath, "pathdir/bincache")
class BranchManagerChangeBranchTests(TestCase, ChangeBranchTestsMixin): """ Tests for L{BranchManager.changeProjectBranch}. """ projectName = 'Quux' def setUp(self): """ Create a branch manager with temporary directories for all its working filesystem paths. """ self.paths = self.mktemp() self.projects = self.mktemp() os.makedirs(self.paths) os.makedirs(self.projects) self.manager = BranchManager(self.paths, self.projects) self.cwd = os.getcwd() self.repositories = FilePath(self.mktemp()) def tearDown(self): """ Assert that the working directory has been restored to its original value if it was changed. """ try: self.assertEqual(self.cwd, os.getcwd()) finally: os.chdir(self.cwd) def createRepository(self, projectName, contents): """ Create a new SVN repository with the given contents and associate it with given project. """ path = self.repositories.child(projectName) path.makedirs() createSubversionRepository(path, contents) def uri(self, projectName, *branch): """ Return a I{file} URI for the given branch of the given project. """ return _uri(self.repositories.child(projectName), *branch) def checkTrunkCheckout(self, project): """ Assert that a trunk checkout of the given project exists. """ trunkWorkingCopy = FilePath(self.paths).child(project).child('trunk') self.assertTrue( trunkWorkingCopy.exists(), "%r did not exist." % (trunkWorkingCopy.path,)) def makeRepositoryInaccessible(self, projectName): """ Make the repository inaccessible so checks for the existence of branches can't possibly succeed. """ self.repositories.child(projectName).remove() def modifyTrunk(self, projectName, fname, newData): """ Make a change to a file in trunk. """ trunkpath = FilePath(self.paths).child(projectName).child('trunk') f = trunkpath.child(fname).open('w') f.write(newData) f.close() def commitTrunk(self, projectName): """ Commit the trunk working copy for the given project. """ commit( FilePath(self.paths).child(projectName).child('trunk'), 'Commit some changes') def modifyBranch(self, projectName, branchName, fname, newData): """ Make a change to a file in a branch. """ fObj = FilePath(self.paths).child(projectName).child( 'branches').child(branchName).child(fname).open('w') fObj.write(newData) fObj.close() def commitBranch(self, projectName, branchName): """ Commit a branch working for the given project. """ commit( FilePath(self.paths).child(projectName).child( 'branches').child(branchName), 'Commit some changes') def test_mergeConflict(self): """ L{BranchManager.mergeProjectBranch} performs merges non-interactively so that they complete even if there is a merge conflict. """ projectName = "Quux" branchName = 'baz' fname = 'foo.txt' contents = {fname: 'some data'} self.createRepository(projectName, {"trunk": contents, "branches": {}}) self.manager.changeProjectBranch( projectName, 'trunk', self.uri(projectName, 'trunk')) self.manager.newProjectBranch(projectName, branchName) self.modifyTrunk(projectName, fname, 'changed data') self.commitTrunk(projectName) self.modifyBranch( projectName, branchName, fname, 'differently changed data') self.commitBranch(projectName, branchName) self.manager.mergeProjectBranch(projectName) def test_changeCurrentBranchDeletesUnknown(self): """ If L{BranchManager.changeProjectBranch} creates a new working copy, it doesn't contain extra unversioned files from the I{trunk} working copy. """ projectName = 'Quux' branchName = 'foo' self.createRepository( projectName, {'trunk': {}, 'branches': {branchName: {}}}) # Get a trunk checkout self.manager.changeProjectBranch( projectName, 'trunk', self.uri(projectName, 'trunk')) # Here is some unversioned junk in the trunk working copy self.modifyTrunk(projectName, "junk", "garbage") self.manager.changeProjectBranch(projectName, branchName) junk = FilePath(self.paths).descendant([ projectName, "branches", branchName, "junk"]) self.assertFalse(junk.exists())
class BranchManagerChangeBranchTests(TestCase, ChangeBranchTestsMixin): """ Tests for L{BranchManager.changeProjectBranch}. """ projectName = 'Quux' def setUp(self): """ Create a branch manager with temporary directories for all its working filesystem paths. """ self.paths = self.mktemp() self.projects = self.mktemp() os.makedirs(self.paths) os.makedirs(self.projects) self.manager = BranchManager(self.paths, self.projects) self.cwd = os.getcwd() self.repositories = FilePath(self.mktemp()) def tearDown(self): """ Assert that the working directory has been restored to its original value if it was changed. """ try: self.assertEqual(self.cwd, os.getcwd()) finally: os.chdir(self.cwd) def createRepository(self, projectName, contents): """ Create a new SVN repository with the given contents and associate it with given project. """ path = self.repositories.child(projectName) path.makedirs() createSubversionRepository(path, contents) def uri(self, projectName, *branch): """ Return a I{file} URI for the given branch of the given project. """ return _uri(self.repositories.child(projectName), *branch) def checkTrunkCheckout(self, project): """ Assert that a trunk checkout of the given project exists. """ trunkWorkingCopy = FilePath(self.paths).child(project).child('trunk') self.assertTrue(trunkWorkingCopy.exists(), "%r did not exist." % (trunkWorkingCopy.path, )) def makeRepositoryInaccessible(self, projectName): """ Make the repository inaccessible so checks for the existence of branches can't possibly succeed. """ self.repositories.child(projectName).remove() def modifyTrunk(self, projectName, fname, newData): """ Make a change to a file in trunk. """ trunkpath = FilePath(self.paths).child(projectName).child('trunk') f = trunkpath.child(fname).open('w') f.write(newData) f.close() def commitTrunk(self, projectName): """ Commit the trunk working copy for the given project. """ commit( FilePath(self.paths).child(projectName).child('trunk'), 'Commit some changes') def modifyBranch(self, projectName, branchName, fname, newData): """ Make a change to a file in a branch. """ fObj = FilePath(self.paths).child(projectName).child('branches').child( branchName).child(fname).open('w') fObj.write(newData) fObj.close() def commitBranch(self, projectName, branchName): """ Commit a branch working for the given project. """ commit( FilePath(self.paths).child(projectName).child('branches').child( branchName), 'Commit some changes') def test_mergeConflict(self): """ L{BranchManager.mergeProjectBranch} performs merges non-interactively so that they complete even if there is a merge conflict. """ projectName = "Quux" branchName = 'baz' fname = 'foo.txt' contents = {fname: 'some data'} self.createRepository(projectName, {"trunk": contents, "branches": {}}) self.manager.changeProjectBranch(projectName, 'trunk', self.uri(projectName, 'trunk')) self.manager.newProjectBranch(projectName, branchName) self.modifyTrunk(projectName, fname, 'changed data') self.commitTrunk(projectName) self.modifyBranch(projectName, branchName, fname, 'differently changed data') self.commitBranch(projectName, branchName) self.manager.mergeProjectBranch(projectName)