def testConflictingMerge_MD(self):
self.setUpConflictingMerge()
try:
self.assertNotEqual(git.shortSHA(), git.shortSHA("master"))
ret = grapeMenu.menu().applyMenuChoice("md", ["--am"])
self.assertFalse(
ret, "grape m did not return false as expected for a conflict")
# resolve the conflict
self.assertFalse(
git.isWorkingDirectoryClean(),
"working directory clean before attempted continution of "
"merge\n %s" % self.output.getvalue())
git.checkout("--ours f2")
git.add("f2")
ret = grapeMenu.menu().applyMenuChoice("md", ["--continue"])
self.assertTrue(
ret, "grape md --continue did not return True\n%s" %
self.output.getvalue())
self.assertTrue(
git.isWorkingDirectoryClean(),
"grape m --continue did not finish merge\n%s" %
self.output.getvalue())
except SystemExit:
self.fail("Unexpected SystemExit: %s" % self.output.getvalue())
def setUpConfig(self):
grapeMenu._resetMenu()
grapeMenu.menu()
config = grapeConfig.grapeConfig()
config.set("flow", "publicBranches", "master")
config.set("flow", "topicPrefixMappings", "?:master")
config.set("workspace", "submoduleTopicPrefixMappings", "?:master")
def setUpConfig(self):
grapeMenu._resetMenu()
grapeMenu.menu()
config = grapeConfig.grapeConfig()
config.set("flow", "publicBranches", "master")
config.set("flow", "topicPrefixMappings", "?:master")
config.set("workspace", "submoduleTopicPrefixMappings", "?:master")
def testProjectWideGrapeCommitWithNestedProjects(self):
try:
self.assertCanAddNewSubproject(self)
f1Path = os.path.join(self.subproject, "f1")
testGrape.writeFile1(f1Path)
cwd = os.getcwd()
os.chdir(self.subproject)
git.add(f1Path)
# check that git sees the file
firstStatus = git.status("--porcelain")
self.assertTrue("f1" in firstStatus)
os.chdir(cwd)
grapeMenu.menu().applyMenuChoice("commit", ["-m", "\"adding f1\""])
# check that running grape commit from the workspace base directory removes f1 from the status
os.chdir(self.subproject)
secondStatus = git.status("--porcelain")
self.assertTrue("f1" not in secondStatus,
"commit didn't remove f1 from status")
os.chdir(cwd)
except git.GrapeGitError as e:
self.assertTrue(False,
('\n'.join(self.output) + '\n'.join(self.error) +
e.gitCommand).split()[-10:])
pass
def assertCanAddNewSubproject(testGrapeObject):
git.clone("--mirror %s %s" % (testGrapeObject.repo, testGrapeObject.repos[1]))
os.chdir(testGrapeObject.repo)
grapeMenu.menu().applyMenuChoice("addSubproject", ["--name=subproject1", "--prefix=subs/subproject1",
"--branch=master", "--url=%s" % testGrapeObject.repos[1],
"--nested", "--noverify"])
subproject1path = os.path.join(testGrapeObject.repo, "subs/subproject1")
testGrapeObject.assertTrue(os.path.exists(subproject1path), "subproject1 does not exist")
os.chdir(subproject1path)
# check to see that subproject1 is a git repo
basedir = os.path.split(git.baseDir())[-1]
subdir = os.path.split(subproject1path)[-1]
testGrapeObject.assertTrue(basedir == subdir, "subproject1's git repo is %s, not %s" % (basedir, subdir))
# check to see that edits that occur in the new subproject are ignored by outer repo
testGrape.writeFile3(os.path.join(subproject1path, "f3"))
# make sure there is an edit
testGrapeObject.assertFalse(git.isWorkingDirectoryClean(), "subproject1 clean after adding f3")
os.chdir(testGrapeObject.repo)
# check that grape left the repository in a clean state
testGrapeObject.assertTrue(git.isWorkingDirectoryClean(), "repo not clean after added subproject1")
# check in the edit
os.chdir(subproject1path)
git.add("f3")
git.commit("-m \"added f3\"")
testGrapeObject.assertTrue(git.isWorkingDirectoryClean(), "subproject1 not clean")
os.chdir(testGrapeObject.repo)
testGrapeObject.subproject = subproject1path
def testVersionTickArgumentPassing(self):
self.setUpBranchToFFMerge()
grapeMenu.menu().applyMenuChoice(
"version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
self.assertGrapePublishWorked([
"--tickVersion=True", "-T", "--slot=3", "-T", "--file=VERSION.txt"
])
self.assertIn("v1.0.1", git.describe())
def testPublishFromWithinNestedSubproject(self):
import testNestedSubproject
self.setUpBranchToFFMerge()
grapeMenu.menu().applyMenuChoice("version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
testNestedSubproject.TestNestedSubproject.assertCanAddNewSubproject(self)
os.chdir(self.subproject)
self.assertGrapePublishWorked()
self.assertSuccessfulFastForwardMerge()
def testConflictingSubmoduleMerge(self):
try:
self.setUpConflictingSubmoduleMerge()
subPath = os.path.join(self.repo, "submodule1")
ret = grapeMenu.menu().applyMenuChoice("m", ["master", "--am"])
self.assertFalse(
ret, "grape m did not return False for conflicting merge.")
# should only have modifications in submodule1, not conflicts
status = git.status("--porcelain")
self.assertTrue("UU" not in status and "AA" in status,
"unexpected status %s at toplevel" % status)
os.chdir(subPath)
status = git.status("--porcelain")
self.assertTrue("AA" in status,
"unexpected status %s in submodule1" % status)
# resolve the conflict and continue from the submodule's directory
git.checkout("--ours f1")
git.add("f1")
git.commit("-m \"resolved conflict with our f1\"")
self.setUpConfig()
ret = grapeMenu.menu().applyMenuChoice("m", ["--continue"])
# test that we returned successfully
self.assertTrue(
ret,
"grape m --continue did not complete successfully after resolving submodule conflict"
"\n %s" % self.output.getvalue())
# test that the submodule master was merged in
self.assertTrue(
git.branchUpToDateWith("testSubmoduleMerge2", "master"),
"grape m --continue did not merge in submodule1`s master branch"
)
# test that the outer level master was merged in
os.chdir(self.repo)
self.assertTrue(
git.branchUpToDateWith("testSubmoduleMerge2", "master"),
"grape m --continue did not merge in the outer level master branch"
)
# ensure the gitlink is at the right commit
git.submodule("update")
os.chdir(subPath)
diff = git.diff("testSubmoduleMerge2")
self.assertFalse(
diff,
"checked in gitlink is not at tip of testSubmoduleMerge2")
except git.GrapeGitError as e:
self.fail("Uncaught git error executing %s: \n%s" %
(e.gitCommand, e.gitOutput))
except SystemExit:
self.fail("Uncaught exit\n%s" % self.output.getvalue())
def testPublishFromWithinNestedSubproject(self):
import testNestedSubproject
self.setUpBranchToFFMerge()
grapeMenu.menu().applyMenuChoice(
"version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
testNestedSubproject.TestNestedSubproject.assertCanAddNewSubproject(
self)
os.chdir(self.subproject)
self.assertGrapePublishWorked()
self.assertSuccessfulFastForwardMerge()
def testProjectWideGrapeStatusWithNestedProjects(self):
try:
self.assertCanAddNewSubproject(self)
f1Path = os.path.join(self.subproject, "f1")
testGrape.writeFile1(f1Path)
self.assertTrue(git.isWorkingDirectoryClean(), "subproject1/f1 shows up in git status when it shouldn't")
grapeMenu.menu().applyMenuChoice("status", ['-u'],globalArgs=["-v"])
self.assertTrue(" ?? subs/subproject1/f1" in '\n'.join(self.output.buflist), "subproject1/f1 does not show up in grape "
"status")
except git.GrapeGitError as e:
self.assertTrue(False, ('\n'.join(self.output)+'\n'.join(self.error) + e.gitCommand).split()[-10:])
pass
def testConfig(self):
os.chdir(self.repo)
self.queueUserInput(["\n", "\n", "\n", "\n"])
ret = grapeMenu.menu().applyMenuChoice("config")
contents = self.output.getvalue()
self.assertTrue(contents)
def testNonConflictingSubmoduleMerge(self):
try:
self.setUpNonConflictingSubmoduleMerge()
ret = grapeMenu.menu().applyMenuChoice("m", ["master", "--am"])
self.assertTrue(
ret, "grape m did not return true for submodule merge.")
# the submodule should not be modified
self.assertTrue(git.isWorkingDirectoryClean())
# master should be merged into current branch
self.assertTrue(
git.branchUpToDateWith("testSubmoduleMerge", "master"))
# the gitlink should be at the tip of testSubmoduleMerge
git.submodule("update")
os.chdir(os.path.join(self.repo, "submodule1"))
self.assertFalse(
git.diff("testSubmoduleMerge"),
"gitlink is not at testSubmoduleMerge tip after merge")
except git.GrapeGitError as e:
self.fail("Uncaught git error executing %s: \n%s" %
(e.gitCommand, e.gitOutput))
except SystemExit:
self.fail("Uncaught System Exit\n%s" % self.output.getvalue())
def testBranches(self):
os.chdir(self.repo)
ret = grapeMenu.menu().applyMenuChoice("b", [])
self.assertTrue(ret, "vine.branches returned failure.")
contents = self.output.getvalue()
self.assertNotEquals(-1, contents.find("master"), "vine.branches could not find the master branch")
def testStartStepStopStep(self):
self.setUpBranchToFFMerge()
config = grapeConfig.grapeConfig()
config.set("publish", "buildCmds", "echo hello , echo world")
config.set("publish", "testCmds", "echo helloTest , echo worldTest")
grapeMenu.menu().applyMenuChoice("version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
self.assertGrapePublishWorked(["--startAt=tickVersion", "--stopAt=updateLog", "--tickVersion=True",
"-T", "--slot=3", "-T", "--file=VERSION.txt"])
self.assertGrapePublishWorked(["--startAt=test", "--stopAt=deleteTopic", "--tickVersion=True",
"-T", "--slot=3", "-T", "--file=VERSION.txt"])
# check test occurred
self.assertIn("PERFORMING CUSTOM TEST STEP", self.output.getvalue())
# check that build never occurred
self.assertNotIn("PERFORMING CUSTOM BUILD STEP", self.output.getvalue())
# check that we tagged a new version
self.assertIn("v1.0.1", git.describe())
def testBranches(self):
os.chdir(self.repo)
ret = grapeMenu.menu().applyMenuChoice("b", [])
self.assertTrue(ret, "vine.branches returned failure.")
contents = self.output.getvalue()
self.assertNotEquals(-1, contents.find("master"),
"vine.branches could not find the master branch")
def testPublishNestedSubprojects(self):
import testNestedSubproject
self.setUpBranchToFFMerge()
config = grapeConfig.grapeConfig()
config.set("publish", "buildCmds", "echo hello , echo world")
config.set("publish", "testCmds", "echo helloTest , echo worldTest")
grapeMenu.menu().applyMenuChoice("version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
testNestedSubproject.TestNestedSubproject.assertCanAddNewSubproject(self)
os.chdir(self.subproject)
self.assertTrue(git.currentBranch() == self.branch)
os.chdir(self.repo)
self.assertGrapePublishWorked(["--merge"])
self.assertSuccessfulFastForwardMerge()
os.chdir(self.subproject)
self.assertTrue(git.currentBranch() == "master", "on %s, expected to be on master" % git.currentBranch())
def testConflictingNestedSubprojectMerge_MD(self):
self.setUpConflictingNestedSubprojectMerge()
os.chdir(self.repo)
git.checkout(" -b testNestedMerge")
#make sure we're not up to date with master
os.chdir(self.subproject)
self.assertFalse(git.branchUpToDateWith("testNestedMerge", "master"),
msg=None)
os.chdir(self.repo)
# run grape md --am
try:
ret = grapeMenu.menu().applyMenuChoice("md",
["--am", "--public=master"],
globalArgs=["-v"])
except SystemExit as e:
self.assertTrue(False, "grape md raised exception %s" % e)
self.assertFalse(
ret, "grape md did not return False for conflicting merge.")
# git status in outer repo should be clean
status = git.status("--porcelain")
self.assertFalse(
status,
"status is not empty in outer repo after conflict in subproject")
# git status in subproject should not be clean
os.chdir(self.subproject)
status = git.status("--porcelain")
self.assertIn("AA", status, "no conflicts in subproject status")
# resolve the conflict
git.checkout("--ours f1")
git.add("f1")
status = git.status("--porcelain")
self.assertNotIn("AA", status,
"conflict not resolved after staging f1")
# continue the merge
ret = grapeMenu.menu().applyMenuChoice("md", ["--continue"])
self.assertTrue(
ret, "md didn't return successfully after conflict resolution")
os.chdir(self.subproject)
self.assertTrue(git.branchUpToDateWith("testNestedMerge", "master"))
os.chdir(self.repo)
self.assertTrue(git.branchUpToDateWith("testNestedMerge", "master"))
def testReview(self):
os.chdir(self.repo)
args = ["review", "--test", "--user=user", "--proj=proj1", "--repo=repo1"]
try:
ret = grapeMenu.menu().applyMenuChoice("review", args, globalArgs=["-v"])
except SystemExit:
self.fail("grape-review failed with output %s" % self.output.getvalue())
contents = self.output.getvalue()
self.assertTrue(ret)
def testSwitchingBranchesWithNestedProjects(self):
try:
self.assertCanAddNewSubproject(self)
# create the branches using git
os.chdir(self.repo)
git.branch("newBranch")
os.chdir(self.subproject)
git.branch("newBranch")
# try switching to the branches using grape
os.chdir(self.repo)
grapeMenu.menu().applyMenuChoice("checkout", ["newBranch"])
self.assertTrue(git.currentBranch() == "newBranch", "outer level repo not on newBranch after checkout")
os.chdir(self.subproject)
self.assertTrue(git.currentBranch() == "newBranch", "subproject not on newBranch after checkout")
except git.GrapeGitError as e:
self.assertTrue(False, ('\n'.join(self.output)+'\n'.join(self.error) + e.gitCommand).split()[-10:])
pass
def testConflictingSubmoduleMerge(self):
try:
self.setUpConflictingSubmoduleMerge()
subPath = os.path.join(self.repo, "submodule1")
ret = grapeMenu.menu().applyMenuChoice("m", ["master", "--am"])
self.assertFalse(ret, "grape m did not return False for conflicting merge.")
# should only have modifications in submodule1, not conflicts
status = git.status("--porcelain")
self.assertTrue("UU" not in status and "AA" in status, "unexpected status %s at toplevel" % status)
os.chdir(subPath)
status = git.status("--porcelain")
self.assertTrue("AA" in status, "unexpected status %s in submodule1" % status)
# resolve the conflict and continue from the submodule's directory
git.checkout("--ours f1")
git.add("f1")
git.commit("-m \"resolved conflict with our f1\"")
self.setUpConfig()
ret = grapeMenu.menu().applyMenuChoice("m", ["--continue"])
# test that we returned successfully
self.assertTrue(ret, "grape m --continue did not complete successfully after resolving submodule conflict"
"\n %s" % self.output.getvalue())
# test that the submodule master was merged in
self.assertTrue(git.branchUpToDateWith("testSubmoduleMerge2", "master"),
"grape m --continue did not merge in submodule1`s master branch")
# test that the outer level master was merged in
os.chdir(self.repo)
self.assertTrue(git.branchUpToDateWith("testSubmoduleMerge2", "master"),
"grape m --continue did not merge in the outer level master branch")
# ensure the gitlink is at the right commit
git.submodule("update")
os.chdir(subPath)
diff = git.diff("testSubmoduleMerge2")
self.assertFalse(diff, "checked in gitlink is not at tip of testSubmoduleMerge2")
except git.GrapeGitError as e:
self.fail("Uncaught git error executing %s: \n%s" % (e.gitCommand, e.gitOutput))
except SystemExit:
self.fail("Uncaught exit\n%s" % self.output.getvalue())
def testConflictingMerge_MD(self):
self.setUpConflictingMerge()
try:
self.assertNotEqual(git.shortSHA(), git.shortSHA("master"))
ret = grapeMenu.menu().applyMenuChoice("md", ["--am"])
self.assertFalse(ret, "grape m did not return false as expected for a conflict")
# resolve the conflict
self.assertFalse(git.isWorkingDirectoryClean(), "working directory clean before attempted continution of "
"merge\n %s" % self.output.getvalue())
git.checkout("--ours f2")
git.add("f2")
ret = grapeMenu.menu().applyMenuChoice("md", ["--continue"])
self.assertTrue(ret, "grape md --continue did not return True\n%s" % self.output.getvalue())
self.assertTrue(git.isWorkingDirectoryClean(), "grape m --continue did not finish merge\n%s" %
self.output.getvalue())
except SystemExit:
self.fail("Unexpected SystemExit: %s" % self.output.getvalue())
def gridtestGrapeUp(self, testProjectScenario):
debugging = False
#if testProjectScenario.debugging() or debugging:
# self.switchToStdout()
#oldstdout = sys.stdout
os.chdir(testProjectScenario.getProjectDir())
# make sure the output is captured so we can check the number of fetches that occur
ret = grapeMenu.menu().applyMenuChoice("up", args=None, option_args=None, globalArgs=['-v'])
self.assertTrue(ret, "up failed to run")
def testProjectWideGrapeStatusWithNestedProjects(self):
try:
self.assertCanAddNewSubproject(self)
f1Path = os.path.join(self.subproject, "f1")
testGrape.writeFile1(f1Path)
self.assertTrue(
git.isWorkingDirectoryClean(),
"subproject1/f1 shows up in git status when it shouldn't")
grapeMenu.menu().applyMenuChoice("status", ['-u'],
globalArgs=["-v"])
self.assertTrue(
" ?? subs/subproject1/f1" in '\n'.join(self.output.buflist),
"subproject1/f1 does not show up in grape "
"status")
except git.GrapeGitError as e:
self.assertTrue(False,
('\n'.join(self.output) + '\n'.join(self.error) +
e.gitCommand).split()[-10:])
pass
def testPublishNestedSubprojects(self):
import testNestedSubproject
self.setUpBranchToFFMerge()
config = grapeConfig.grapeConfig()
config.set("publish", "buildCmds", "echo hello , echo world")
config.set("publish", "testCmds", "echo helloTest , echo worldTest")
grapeMenu.menu().applyMenuChoice(
"version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
testNestedSubproject.TestNestedSubproject.assertCanAddNewSubproject(
self)
os.chdir(self.subproject)
self.assertTrue(git.currentBranch() == self.branch)
os.chdir(self.repo)
self.assertGrapePublishWorked(["--merge"])
self.assertSuccessfulFastForwardMerge()
os.chdir(self.subproject)
self.assertTrue(
git.currentBranch() == "master",
"on %s, expected to be on master" % git.currentBranch())
def testRecursiveCloneNestedSubproject(self):
# make a repo to turn into a submodule
git.clone("--mirror %s %s " % (self.repo, self.repos[1]))
os.chdir(self.repo)
grapeMenu.menu().applyMenuChoice("addSubproject", ["--name=subproject1", "--prefix=subs/subproject1",
"--branch=master", "--url=%s" % self.repos[1],
"--nested", "--noverify"])
grapeMenu.menu().applyMenuChoice("commit",["-m", "\"added subproject1\""])
print git.log("--decorate")
#Now clone the repo into a temp dir and make sure the subproject is in the clone
try:
tempDir = tempfile.mkdtemp()
self.queueUserInput(["\n", "\n", "\n", "\n"])
args = [self.repo, tempDir, "--recursive", "--allNested"]
ret = grapeMenu.menu().applyMenuChoice("clone", args)
self.assertTrue(ret, "vine.clone returned failure")
# ensure we are on master with all nested subprojects
os.chdir(tempDir)
self.queueUserInput(["all\n"])
args = ["master", "--updateView"]
ret = grapeMenu.menu().applyMenuChoice("checkout", args)
self.assertTrue(ret, "vine.checkout master returned failure")
print git.log("--decorate")
subprojectpath = os.path.join(tempDir, "subs/subproject1")
self.assertTrue(os.path.exists(subprojectpath), "subproject1 does not exist in clone")
finally:
shutil.rmtree(tempDir)
def testNonConflictingMerge(self):
self.setUpMerge()
# now run grape md, should be a fast forward merge
try:
self.assertNotEqual(git.shortSHA(), git.shortSHA("master"))
ret = grapeMenu.menu().applyMenuChoice("md", ["--am"])
self.assertTrue(ret, "grape md did not return True")
self.assertEqual(git.shortSHA(), git.shortSHA("master"), "merging master into test branch did not fast"
"forward")
except SystemExit:
self.fail("Unexpected SystemExit: %s" % self.output.getvalue())
except git.GrapeGitError as e:
self.fail("Unhandled GrapeGitError: %s\n%s" % (e.gitCommand, e.gitOutput))
def testClone02(self):
tempDir = tempfile.mkdtemp()
args = [self.repo, tempDir]
try:
self.queueUserInput(["\n", "\n", "\n", "\n"])
ret = grapeMenu.menu().applyMenuChoice("clone", args)
self.assertTrue(ret, "vine.clone returned failure")
#ToDo: Finish checking contents
#contents = self.output.getvalue()
#self.stdout(contents)
finally:
shutil.rmtree(tempDir)
def testProjectWideGrapeCommitWithNestedProjects(self):
try:
self.assertCanAddNewSubproject(self)
f1Path = os.path.join(self.subproject, "f1")
testGrape.writeFile1(f1Path)
cwd = os.getcwd()
os.chdir(self.subproject)
git.add(f1Path)
# check that git sees the file
firstStatus = git.status("--porcelain")
self.assertTrue("f1" in firstStatus)
os.chdir(cwd)
grapeMenu.menu().applyMenuChoice("commit",["-m", "\"adding f1\""])
# check that running grape commit from the workspace base directory removes f1 from the status
os.chdir(self.subproject)
secondStatus = git.status("--porcelain")
self.assertTrue("f1" not in secondStatus,"commit didn't remove f1 from status")
os.chdir(cwd)
except git.GrapeGitError as e:
self.assertTrue(False, ('\n'.join(self.output)+'\n'.join(self.error) + e.gitCommand).split()[-10:])
pass
def testStartStepStopStep(self):
self.setUpBranchToFFMerge()
config = grapeConfig.grapeConfig()
config.set("publish", "buildCmds", "echo hello , echo world")
config.set("publish", "testCmds", "echo helloTest , echo worldTest")
grapeMenu.menu().applyMenuChoice(
"version", ["init", "v1.0.0", "--file=VERSION.txt", "--tag"])
self.assertGrapePublishWorked([
"--startAt=tickVersion", "--stopAt=updateLog",
"--tickVersion=True", "-T", "--slot=3", "-T", "--file=VERSION.txt"
])
self.assertGrapePublishWorked([
"--startAt=test", "--stopAt=deleteTopic", "--tickVersion=True",
"-T", "--slot=3", "-T", "--file=VERSION.txt"
])
# check test occurred
self.assertIn("PERFORMING CUSTOM TEST STEP", self.output.getvalue())
# check that build never occurred
self.assertNotIn("PERFORMING CUSTOM BUILD STEP",
self.output.getvalue())
# check that we tagged a new version
self.assertIn("v1.0.1", git.describe())
def gridtestGrapeUp(self, testProjectScenario):
debugging = False
#if testProjectScenario.debugging() or debugging:
# self.switchToStdout()
#oldstdout = sys.stdout
os.chdir(testProjectScenario.getProjectDir())
# make sure the output is captured so we can check the number of fetches that occur
ret = grapeMenu.menu().applyMenuChoice("up",
args=None,
option_args=None,
globalArgs=['-v'])
self.assertTrue(ret, "up failed to run")
def testSwitchingBranchesWithNestedProjects(self):
try:
self.assertCanAddNewSubproject(self)
# create the branches using git
os.chdir(self.repo)
git.branch("newBranch")
os.chdir(self.subproject)
git.branch("newBranch")
# try switching to the branches using grape
os.chdir(self.repo)
grapeMenu.menu().applyMenuChoice("checkout", ["newBranch"])
self.assertTrue(
git.currentBranch() == "newBranch",
"outer level repo not on newBranch after checkout")
os.chdir(self.subproject)
self.assertTrue(git.currentBranch() == "newBranch",
"subproject not on newBranch after checkout")
except git.GrapeGitError as e:
self.assertTrue(False,
('\n'.join(self.output) + '\n'.join(self.error) +
e.gitCommand).split()[-10:])
pass
def testConflictingNestedSubprojectMerge_MD(self):
self.setUpConflictingNestedSubprojectMerge()
os.chdir(self.repo)
git.checkout(" -b testNestedMerge")
#make sure we're not up to date with master
os.chdir(self.subproject)
self.assertFalse(git.branchUpToDateWith("testNestedMerge", "master"), msg=None)
os.chdir(self.repo)
# run grape md --am
try:
ret = grapeMenu.menu().applyMenuChoice("md", ["--am", "--public=master"], globalArgs=["-v"])
except SystemExit as e:
self.assertTrue(False, "grape md raised exception %s" % e)
self.assertFalse(ret, "grape md did not return False for conflicting merge.")
# git status in outer repo should be clean
status = git.status("--porcelain")
self.assertFalse(status, "status is not empty in outer repo after conflict in subproject")
# git status in subproject should not be clean
os.chdir(self.subproject)
status = git.status("--porcelain")
self.assertIn("AA", status, "no conflicts in subproject status")
# resolve the conflict
git.checkout("--ours f1")
git.add("f1")
status = git.status("--porcelain")
self.assertNotIn("AA", status, "conflict not resolved after staging f1")
# continue the merge
ret = grapeMenu.menu().applyMenuChoice("md", ["--continue"])
self.assertTrue(ret, "md didn't return successfully after conflict resolution")
os.chdir(self.subproject)
self.assertTrue(git.branchUpToDateWith("testNestedMerge", "master"))
os.chdir(self.repo)
self.assertTrue(git.branchUpToDateWith("testNestedMerge", "master"))
def assertCanAddNewSubproject(testGrapeObject):
git.clone("--mirror %s %s" %
(testGrapeObject.repo, testGrapeObject.repos[1]))
os.chdir(testGrapeObject.repo)
grapeMenu.menu().applyMenuChoice("addSubproject", [
"--name=subproject1", "--prefix=subs/subproject1",
"--branch=master",
"--url=%s" % testGrapeObject.repos[1], "--nested", "--noverify"
])
subproject1path = os.path.join(testGrapeObject.repo,
"subs/subproject1")
testGrapeObject.assertTrue(os.path.exists(subproject1path),
"subproject1 does not exist")
os.chdir(subproject1path)
# check to see that subproject1 is a git repo
basedir = os.path.split(git.baseDir())[-1]
subdir = os.path.split(subproject1path)[-1]
testGrapeObject.assertTrue(
basedir == subdir,
"subproject1's git repo is %s, not %s" % (basedir, subdir))
# check to see that edits that occur in the new subproject are ignored by outer repo
testGrape.writeFile3(os.path.join(subproject1path, "f3"))
# make sure there is an edit
testGrapeObject.assertFalse(git.isWorkingDirectoryClean(),
"subproject1 clean after adding f3")
os.chdir(testGrapeObject.repo)
# check that grape left the repository in a clean state
testGrapeObject.assertTrue(git.isWorkingDirectoryClean(),
"repo not clean after added subproject1")
# check in the edit
os.chdir(subproject1path)
git.add("f3")
git.commit("-m \"added f3\"")
testGrapeObject.assertTrue(git.isWorkingDirectoryClean(),
"subproject1 not clean")
os.chdir(testGrapeObject.repo)
testGrapeObject.subproject = subproject1path
def testNonConflictingMerge(self):
self.setUpMerge()
# now run grape md, should be a fast forward merge
try:
self.assertNotEqual(git.shortSHA(), git.shortSHA("master"))
ret = grapeMenu.menu().applyMenuChoice("md", ["--am"])
self.assertTrue(ret, "grape md did not return True")
self.assertEqual(
git.shortSHA(), git.shortSHA("master"),
"merging master into test branch did not fast"
"forward")
except SystemExit:
self.fail("Unexpected SystemExit: %s" % self.output.getvalue())
except git.GrapeGitError as e:
self.fail("Unhandled GrapeGitError: %s\n%s" %
(e.gitCommand, e.gitOutput))
def testMajorTick(self):
os.chdir(self.repo)
menu = grapeMenu.menu()
try:
ret = menu.applyMenuChoice(
"version", ["init", "v0.1.0", "--file=.grapeversion"])
self.assertTrue(
ret, "grape version init v0.1.0 returned False\n%s" %
self.output.getvalue())
self.assertEqual(git.describe("--abbrev=0"), "v0.1.0")
# test to make sure ticking the version works
ret = menu.applyMenuChoice("version", ["tick", "--major"])
self.assertTrue(ret, "grape version tick returned False")
self.assertEqual(git.describe(), "v1.0.0")
# test a minor tick with no tag update
ret = menu.applyMenuChoice("version",
["tick", "--minor", "--notag"])
self.assertEqual(git.describe("--abbrev=0"), "v1.0.0")
ret = menu.applyMenuChoice("version", ["tick", "--minor"])
self.assertEqual(git.describe(), "v1.2.0")
ret = menu.applyMenuChoice("version", ["tick", "--major"])
self.assertEqual(git.describe(), "v2.0.0")
#test overiding default tag behavior
config = grapeConfig.grapeConfig()
config.set("versioning", "updateTag", "False")
ret = menu.applyMenuChoice("version", ["tick", "--slot=3"])
self.assertEqual(git.describe("--abbrev=0"), "v2.0.0")
ret = menu.applyMenuChoice("version",
["tick", "--slot=3", "--tag"])
self.assertEqual(git.describe(), "v2.0.2")
# test auto extension of version number
menu.applyMenuChoice("version", ["tick", "--slot=4", "--tag"])
self.assertEqual(git.describe(), "v2.0.2.1")
except SystemExit:
self.fail("Unexpected SystemExit\n%s" % self.output.getvalue())
except git.GrapeGitError as e:
self.fail("Uncaught GrapeGitError: %s" % e.gitOutput)
def assertGrapePublishWorked(self, args=None, assertFail=False):
self.queueUserInput(["1.1.1"])
config = grapeConfig.grapeConfig()
config.ensureSection("project")
config.set("project", "name", "proj1")
defaultArgs = ["-m", "publishing testPublish to master", "--noverify", '-R', '--test', '-R', '--repo=repo1',
'-R', '--user=user', "--noReview", "--noUpdateLog", "--noPushSubtrees"]
try:
if args:
args += defaultArgs
else:
args = defaultArgs
ret = grapeMenu.menu().applyMenuChoice("publish", args=args)
self.assertEquals(ret, not assertFail, msg="publish returned " +str(ret))
except SystemExit as e:
self.fail("%s\n%s" % (self.output.getvalue(), e.message))
def startup():
versionOutput = git.version().split()
versionString = versionOutput.pop()
while '.' not in versionString:
versionString = versionOutput.pop()
versions = versionString.split('.')
if int(versions[0]) == 1 and int(versions[1]) < 8:
print('Grape requires at least git version 1.8, currently using %s' %
versionString)
return False
#TODO - allow addition grape config file to be specified at command line
#additionalConfigFiles = []
#grapeConfig.read(additionalConfigFiles)
with open(os.path.join(vinePath, "VERSION"), 'r') as f:
grapeVersion = f.read().split()[2]
args = docopt(CLI, version=grapeVersion, options_first=True)
myMenu = grapeMenu.menu()
utility.applyGlobalArgs(args)
retval = True
try:
if (args["<command>"] is None):
done = 0
while not done:
myMenu.presentTextMenu()
choice = utility.userInput(
"Please select an option from the above menu",
None).split()
done = myMenu.applyMenuChoice(choice[0], choice)
# If they specified a command line argument, then assume that it's
# a menu option, and bypass the menu
elif (len(sys.argv) > 1):
retval = myMenu.applyMenuChoice(args["<command>"], args["<args>"])
except KeyboardInterrupt:
print("GRAPE ERROR: Operation interrupted by user, exiting...")
retval = False
# Exit the script
print("Thank you - good bye")
return retval
def testMinorTick(self):
os.chdir(self.repo)
# test initialization of grape managed versioning
menu = grapeMenu.menu()
try:
# self.assertEqual(grapeConfig.grapeConfig().get("versioning", "updateTag").lower(), "true")
ret = menu.applyMenuChoice("version", ["init","v0.1.0", "--file=.grapeversion"])
self.assertTrue(ret, "grape version init v0.1.0 returned False\n%s" %
self.output.getvalue())
self.assertEqual(git.describe("--abbrev=0"), "v0.1.0")
# test to make sure ticking the version works
ret = menu.applyMenuChoice("version", ["tick", "--minor"])
self.assertTrue(ret, "grape version tick returned False")
self.assertEqual(git.describe(), "v0.2.0")
except SystemExit:
self.fail("Unexpected SystemExit\n%s" % self.output.getvalue())
except git.GrapeGitError as e:
self.fail("Uncaught GrapeGit error: %s" % e.gitOutput)
def testClone(self):
self.setUpConfig()
self.queueUserInput(['\n', '\n', '\n', '\n'])
args = [self.repo, self.repos[1], "--recursive"]
ret =grapeMenu.menu().applyMenuChoice("clone", args)
self.assertTrue(ret)
# check to make sure we didn't get a usage string dump
contents = self.output.getvalue()
self.assertNotIn(contents, "Usage: grape-clone")
# check to make sure we didn't see a GRAPE WARNING
self.assertNotIn("WARNING", contents, "GRAPE ISSUED A WARNING DURING A CLONE\n%s" % contents)
# check to make sure the new repo has the old repo as a remote
os.chdir(self.repos[1])
remote = git.showRemote()
self.assertIn(self.repo, remote)
self.assertTrue(ret)
def setUp(self):
# setUp stdout and stderr wrapping to capture
# messages from the modules that we test
self.output = StringIO.StringIO()
self.error = StringIO.StringIO()
self.stdout = sys.stdout
self.stderr = sys.stderr
self.stdin = sys.stdin
self.cwd = os.getcwd()
sys.stdout = self.output
sys.stderr = self.error
# create a test repository to operate in.
try:
try:
os.mkdir(self.repo + "-origin")
except OSError:
pass
os.chdir(self.repo + "-origin")
cwd = os.getcwd()
git.gitcmd("init --bare", "Setup Failed")
os.chdir(os.path.join(self.repo + "-origin", ".."))
git.gitcmd("clone %s %s" % (self.repo + "-origin", self.repo),
"could not clone test bare repo")
os.chdir(self.repo)
fname = os.path.join(self.repo, "testRepoFile")
writeFile1(fname)
self.file1 = fname
git.gitcmd("add %s" % fname, "Add Failed")
git.gitcmd("commit -m \"initial commit\"", "Commit Failed")
git.gitcmd("push origin master", "push to master failed")
# create a develop branch in addition to master by default
git.branch("develop")
git.push("origin develop")
os.chdir(os.path.join(self.repo, ".."))
except git.GrapeGitError:
pass
self.menu = grapeMenu.menu()
if self._debug:
self.switchToStdout()
def testMajorTick(self):
os.chdir(self.repo)
menu = grapeMenu.menu()
try:
ret = menu.applyMenuChoice("version", ["init","v0.1.0", "--file=.grapeversion"])
self.assertTrue(ret, "grape version init v0.1.0 returned False\n%s" %
self.output.getvalue())
self.assertEqual(git.describe("--abbrev=0"), "v0.1.0")
# test to make sure ticking the version works
ret = menu.applyMenuChoice("version", ["tick", "--major"])
self.assertTrue(ret, "grape version tick returned False")
self.assertEqual(git.describe(), "v1.0.0")
# test a minor tick with no tag update
ret = menu.applyMenuChoice("version", ["tick", "--minor", "--notag"])
self.assertEqual(git.describe("--abbrev=0"), "v1.0.0")
ret = menu.applyMenuChoice("version", ["tick", "--minor"])
self.assertEqual(git.describe(), "v1.2.0")
ret = menu.applyMenuChoice("version", ["tick", "--major"])
self.assertEqual(git.describe(), "v2.0.0")
#test overiding default tag behavior
config = grapeConfig.grapeConfig()
config.set("versioning", "updateTag", "False")
ret = menu.applyMenuChoice("version", ["tick", "--slot=3"])
self.assertEqual(git.describe("--abbrev=0"), "v2.0.0")
ret = menu.applyMenuChoice("version", ["tick", "--slot=3", "--tag"])
self.assertEqual(git.describe(), "v2.0.2")
# test auto extension of version number
menu.applyMenuChoice("version", ["tick", "--slot=4", "--tag"])
self.assertEqual(git.describe(), "v2.0.2.1")
except SystemExit:
self.fail("Unexpected SystemExit\n%s" % self.output.getvalue())
except git.GrapeGitError as e:
self.fail("Uncaught GrapeGitError: %s" % e.gitOutput)
def setUp(self):
# setUp stdout and stderr wrapping to capture
# messages from the modules that we test
self.output = StringIO.StringIO()
self.error = StringIO.StringIO()
self.stdout = sys.stdout
self.stderr = sys.stderr
self.stdin = sys.stdin
self.cwd = os.getcwd()
sys.stdout = self.output
sys.stderr = self.error
# create a test repository to operate in.
try:
try:
os.mkdir(self.repo + "-origin")
except OSError:
pass
os.chdir(self.repo + "-origin")
cwd = os.getcwd()
git.gitcmd("init --bare", "Setup Failed")
os.chdir(os.path.join(self.repo+"-origin",".."))
git.gitcmd("clone %s %s" % (self.repo +"-origin",self.repo), "could not clone test bare repo")
os.chdir(self.repo)
fname = os.path.join(self.repo, "testRepoFile")
writeFile1(fname)
self.file1 = fname
git.gitcmd("add %s" % fname, "Add Failed")
git.gitcmd("commit -m \"initial commit\"", "Commit Failed")
git.gitcmd("push origin master", "push to master failed")
# create a develop branch in addition to master by default
git.branch("develop")
git.push("origin develop")
os.chdir(os.path.join(self.repo, ".."))
except git.GrapeGitError:
pass
self.menu = grapeMenu.menu()
if self._debug:
self.switchToStdout()
def startup():
versionOutput = git.version().split()
versionString = versionOutput.pop()
while '.' not in versionString:
versionString = versionOutput.pop()
versions = versionString.split('.')
if int(versions[0]) == 1 and int(versions[1]) < 8:
print('Grape requires at least git version 1.8, currently using %s' % versionString)
return False
#TODO - allow addition grape config file to be specified at command line
#additionalConfigFiles = []
#grapeConfig.read(additionalConfigFiles)
with open(os.path.join(vinePath,"VERSION"),'r') as f:
grapeVersion = f.read().split()[2]
args = docopt(CLI, version=grapeVersion, options_first=True )
myMenu = grapeMenu.menu()
utility.applyGlobalArgs(args)
retval = True
try:
if (args["<command>"] is None):
done = 0
while not done:
myMenu.presentTextMenu()
choice = utility.userInput("Please select an option from the above menu", None).split()
done = myMenu.applyMenuChoice(choice[0],choice)
# If they specified a command line argument, then assume that it's
# a menu option, and bypass the menu
elif (len(sys.argv) > 1):
retval = myMenu.applyMenuChoice(args["<command>"],args["<args>"])
except KeyboardInterrupt:
print("GRAPE ERROR: Operation interrupted by user, exiting...")
retval = False
# Exit the script
print("Thank you - good bye")
return retval
def testRecursiveCloneWithSubmodule(self):
# make a repo to turn into a submodule
git.clone("--mirror %s %s " % (self.repo, self.repos[1]))
# add repo2 as a submodule to repo1
os.chdir(self.repo)
git.submodule("add %s %s" % (os.path.join(self.repos[1]), "submodule1"))
git.commit("-m \"added submodule1\"")
#Now clone the repo into a temp dir and make sure the submodule is in the clone
try:
tempDir = tempfile.mkdtemp()
args = [self.repo, tempDir, "--recursive"]
self.queueUserInput(["\n", "\n", "\n", "\n","\n","\n"])
ret = grapeMenu.menu().applyMenuChoice("clone", args)
self.assertTrue(ret, "vine.clone returned failure")
submodulepath = os.path.join(tempDir, "submodule1")
self.assertTrue(os.path.exists(submodulepath), "submodule1 does not exist in clone")
finally:
shutil.rmtree(tempDir)
def testNonConflictingSubmoduleMerge(self):
try:
self.setUpNonConflictingSubmoduleMerge()
ret = grapeMenu.menu().applyMenuChoice("m", ["master", "--am"])
self.assertTrue(ret, "grape m did not return true for submodule merge.")
# the submodule should not be modified
self.assertTrue(git.isWorkingDirectoryClean())
# master should be merged into current branch
self.assertTrue(git.branchUpToDateWith("testSubmoduleMerge", "master"))
# the gitlink should be at the tip of testSubmoduleMerge
git.submodule("update")
os.chdir(os.path.join(self.repo, "submodule1"))
self.assertFalse(git.diff("testSubmoduleMerge"), "gitlink is not at testSubmoduleMerge tip after merge")
except git.GrapeGitError as e:
self.fail("Uncaught git error executing %s: \n%s" % (e.gitCommand, e.gitOutput))
except SystemExit:
self.fail("Uncaught System Exit\n%s" % self.output.getvalue())
def testMinorTick(self):
os.chdir(self.repo)
# test initialization of grape managed versioning
menu = grapeMenu.menu()
try:
# self.assertEqual(grapeConfig.grapeConfig().get("versioning", "updateTag").lower(), "true")
ret = menu.applyMenuChoice(
"version", ["init", "v0.1.0", "--file=.grapeversion"])
self.assertTrue(
ret, "grape version init v0.1.0 returned False\n%s" %
self.output.getvalue())
self.assertEqual(git.describe("--abbrev=0"), "v0.1.0")
# test to make sure ticking the version works
ret = menu.applyMenuChoice("version", ["tick", "--minor"])
self.assertTrue(ret, "grape version tick returned False")
self.assertEqual(git.describe(), "v0.2.0")
except SystemExit:
self.fail("Unexpected SystemExit\n%s" % self.output.getvalue())
except git.GrapeGitError as e:
self.fail("Uncaught GrapeGit error: %s" % e.gitOutput)
def assertGrapePublishWorked(self, args=None, assertFail=False):
self.queueUserInput(["1.1.1"])
config = grapeConfig.grapeConfig()
config.ensureSection("project")
config.set("project", "name", "proj1")
defaultArgs = [
"-m", "publishing testPublish to master", "--noverify", '-R',
'--test', '-R', '--repo=repo1', '-R', '--user=user', "--noReview",
"--noUpdateLog", "--noPushSubtrees"
]
try:
if args:
args += defaultArgs
else:
args = defaultArgs
ret = grapeMenu.menu().applyMenuChoice("publish", args=args)
self.assertEquals(ret,
not assertFail,
msg="publish returned " + str(ret))
except SystemExit as e:
self.fail("%s\n%s" % (self.output.getvalue(), e.message))
def testDeactivatingAndReactiviatingNestProjects(self):
try:
self.assertCanAddNewSubproject(self)
self.assertTrue(os.path.isdir(self.subproject))
# answer none to whether we want all subprojects, y to deleting it
self.queueUserInput(["n\n", "y\n"])
grapeMenu.menu().applyMenuChoice("uv")
self.assertFalse(os.path.isdir(self.subproject))
# answer a to whether we want all subprojects
self.queueUserInput(["a\n"])
print self.input.buf
grapeMenu.menu().applyMenuChoice("uv")
self.assertTrue(os.path.isdir(self.subproject), '\n'.join(self.output)+'\n'.join(self.error))
# run grape uv again to make sure it just keeps things the same
self.queueUserInput(["a\n"])
grapeMenu.menu().applyMenuChoice("uv")
self.assertTrue(os.path.isdir(self.subproject))
except git.GrapeGitError as e:
self.assertTrue(False, ('\n'.join(self.output)+'\n'.join(self.error) + e.gitCommand).split()[-10:])
pass
def testDeactivatingAndReactiviatingNestProjects(self):
try:
self.assertCanAddNewSubproject(self)
self.assertTrue(os.path.isdir(self.subproject))
# answer none to whether we want all subprojects, y to deleting it
self.queueUserInput(["n\n", "y\n"])
grapeMenu.menu().applyMenuChoice("uv")
self.assertFalse(os.path.isdir(self.subproject))
# answer a to whether we want all subprojects
self.queueUserInput(["a\n"])
print self.input.buf
grapeMenu.menu().applyMenuChoice("uv")
self.assertTrue(os.path.isdir(self.subproject),
'\n'.join(self.output) + '\n'.join(self.error))
# run grape uv again to make sure it just keeps things the same
self.queueUserInput(["a\n"])
grapeMenu.menu().applyMenuChoice("uv")
self.assertTrue(os.path.isdir(self.subproject))
except git.GrapeGitError as e:
self.assertTrue(False,
('\n'.join(self.output) + '\n'.join(self.error) +
e.gitCommand).split()[-10:])
pass
def testHelpMessage(self):
args = ["--help"]
with self.assertRaises(SystemExit):
ret = grapeMenu.menu().applyMenuChoice("clone", args)
self.assertIn(clone.Clone.__doc__, self.output.getvalue())
def switchToAddSubmodule(self):
grapeMenu.menu().applyMenuChoice("checkout", ["addSubmodule"])
def switchToMaster(self):
grapeMenu.menu().applyMenuChoice("checkout", ["master"])
def switchToMaster(self):
grapeMenu.menu().applyMenuChoice("checkout", ["master"])
