merge 'improveretryacceptmultiplechanges' (fixes #27 closes #18)

Author: WtfJoke

migration.py

@@ -38,17 +38,19 @@ def migrate():
     initialize(config)
     streamuuid = config.streamuuid
     streamname = config.streamname
+    branchname = streamname + "_branchpoint"
 
     componentbaselineentries = rtc.getcomponentbaselineentriesfromstream(streamuuid)
     rtcworkspace.setnewflowtargets(streamuuid)
-    git.branch(streamname)
+    git.branch(branchname)
 
     history = rtc.readhistory(componentbaselineentries, streamname)
     changeentries = rtc.getchangeentriesofstreamcomponents(componentbaselineentries)
 
     rtc.acceptchangesintoworkspace(rtc.getchangeentriestoaccept(changeentries, history))
     shouter.shout("All changes until creation of stream '%s' accepted" % streamname)
-    git.pushbranch(streamname)
+    git.pushbranch(branchname)
+    git.branch(streamname)
 
     rtcworkspace.setcomponentstobaseline(componentbaselineentries, streamuuid)
     rtcworkspace.load()

rtcFunctions.py

@@ -90,7 +90,8 @@ def accept(config, logpath, *changeentries):
         for changeEntry in changeentries:
             shouter.shout("Accepting: " + changeEntry.tostring())
         revisions = Changes._collectids(changeentries)
-        Changes.latest_accept_command = config.scmcommand + " accept -v -o -r " + config.repo + " -t " + config.workspace + " --changes" + revisions
+        Changes.latest_accept_command = config.scmcommand + " accept -v -o -r " + config.repo + " -t " + \
+                                        config.workspace + " --changes" + revisions
         return shell.execute(Changes.latest_accept_command, logpath, "a")
 
     @staticmethod
@@ -100,6 +101,21 @@ def _collectids(changeentries):
             ids += " " + changeentry.revision
         return ids
 
+    @staticmethod
+    def arereleatedmergechangesets(changeentry1, changeentry2):
+        if changeentry1 and changeentry2:
+            if changeentry1.author == changeentry2.author or "merge" in changeentry2.comment.lower():
+                return True
+        return False
+
+    @staticmethod
+    def tostring(*changes):
+        logmessage = "Changes: \n"
+        for change in changes:
+            logmessage += change.tostring() + "\n"
+        shouter.shout(logmessage)
+
+
 
 class ImportHandler:
     def __init__(self, config):
@@ -168,51 +184,80 @@ def determineinitialbaseline(self, stream):
         return componentbaselinesentries
 
     def acceptchangesintoworkspace(self, changeentries):
-        git = Commiter
         amountofchanges = len(changeentries)
         shouter.shoutwithdate("Start accepting %s changesets" % amountofchanges)
         amountofacceptedchanges = 0
-        skipnextchangeset = False
+        changestoskip = 0
         reloaded = False
         for changeEntry in changeentries:
             amountofacceptedchanges += 1
-            if skipnextchangeset:
-                skipnextchangeset = False
+            if changestoskip > 0:
+                shouter.shout("Skipping " + changeEntry.tostring())
+                changestoskip -= 1
                 continue
             acceptedsuccesfully = Changes.accept(self.config, self.acceptlogpath,
                                                  changeEntry) is 0
             if not acceptedsuccesfully:
                 shouter.shout("Change wasnt succesfully accepted into workspace")
-                skipnextchangeset = self.retryacceptincludingnextchangeset(changeEntry, changeentries)
+                changestoskip = self.retryacceptincludingnextchangesets(changeEntry, changeentries)
             elif not reloaded:
                 if self.is_reloading_necessary():
                     WorkspaceHandler(self.config).load()
                 reloaded = True
             shouter.shout("Accepted change %s/%s into working directory" % (amountofacceptedchanges, amountofchanges))
-            git.addandcommit(changeEntry)
+            Commiter.addandcommit(changeEntry)
 
     @staticmethod
     def is_reloading_necessary():
         return shell.execute("git diff --exit-code") is 0
 
-    def retryacceptincludingnextchangeset(self, change, changes):
-        successfull = False
-        nextchangeentry = self.getnextchangeset(change, changes)
-        if nextchangeentry and (change.author == nextchangeentry.author or "merge" in nextchangeentry.comment.lower()):
-            shouter.shout("Next changeset: " + nextchangeentry.tostring())
-            if (not self.config.useautomaticconflictresolution) and input("Press Enter to try to accept it with next changeset together, press any other key to skip this changeset and continue"):
-                return False
-            Changes.discard(self.config, change)
-            successfull = Changes.accept(self.config, self.acceptlogpath, change, nextchangeentry) is 0
-            if not successfull:
-                Changes.discard(self.config, change, nextchangeentry)
-
-        if not successfull:
-            shouter.shout("Last executed command: \n" + Changes.latest_accept_command)
-            shouter.shout("Apropriate git commit command \n" + Commiter.getcommitcommand(change))
-            if not input("Press Enter to continue or any other key to exit the program and rerun it with resume"):
-                sys.exit("Please check the output and rerun programm with resume")
-        return successfull
+    @staticmethod
+    def collect_changes_to_accept_to_avoid_conflicts(changewhichcantacceptedallone, changes):
+        changestoaccept = [changewhichcantacceptedallone]
+        nextchange = ImportHandler.getnextchangeset(changewhichcantacceptedallone, changes)
+
+        while True:
+            if Changes.arereleatedmergechangesets(changewhichcantacceptedallone, nextchange):
+                changestoaccept.append(nextchange)
+                nextchange = ImportHandler.getnextchangeset(nextchange, changes)
+            else:
+                break
+        return changestoaccept
+
+    def retryacceptincludingnextchangesets(self, change, changes):
+        changestoskip = 0
+        changestoaccept = ImportHandler.collect_changes_to_accept_to_avoid_conflicts(change, changes)
+        amountofchangestoaccept = len(changestoaccept)
+
+        if amountofchangestoaccept > 1:
+            Changes.tostring(*changestoaccept)
+            if self.config.useautomaticconflictresolution or self.is_user_agreeing_to_accept_next_change(change):
+                for index in range(1, amountofchangestoaccept):
+                    toaccept = changestoaccept[0:index + 1]  # accept least possible amount of changes
+                    if Changes.accept(self.config, self.acceptlogpath, *toaccept) is 0:
+                        changestoskip = len(toaccept) - 1  # initialchange shouldnt be skipped
+                        break
+                    else:
+                        Changes.discard(self.config, *toaccept)  # revert initial state
+        return changestoskip
+
+    @staticmethod
+    def is_user_agreeing_to_accept_next_change(change):
+        messagetoask = "Press Y for accepting following changes, press N to skip"
+        while True:
+            answer = input(messagetoask).lower()
+            if answer == "y":
+                return True
+            elif answer == "n":
+                shouter.shout("Last executed command: \n" + Changes.latest_accept_command)
+                shouter.shout("Apropriate git commit command \n" + Commiter.getcommitcommand(change))
+                reallycontinue = "Do you want to continue? Y for continue, any key for abort"
+                if input(reallycontinue).lower() == "y":
+                    return False
+                else:
+                    sys.exit("Please check the output/log and rerun program with resume")
+            else:
+                shouter.shout("Please answer with Y/N, input was " + answer)
 
     @staticmethod
     def getnextchangeset(currentchangeentry, changeentries):
@@ -228,6 +273,8 @@ def getchangeentriesofstreamcomponents(self, componentbaselineentries):
         shouter.shout("Start collecting changeentries")
         changeentriesbycomponentbaselineentry = {}
         for componentBaseLineEntry in componentbaselineentries:
+            shouter.shout("Collect changes until baseline %s of component %s" %
+                          (componentBaseLineEntry.baselinename, componentBaseLineEntry.componentname))
             changeentries = self.getchangeentriesofbaseline(componentBaseLineEntry.baseline)
             for changeentry in changeentries:
                 missingchangeentries[changeentry.revision] = changeentry

tests/test_rtcFunctions.py

@@ -13,13 +13,14 @@ class RtcFunctionsTestCase(unittest.TestCase):
     def setUp(self):
         self.workspace = "anyWorkspace"
         self.apath = "aLogPath"
+        self.configBuilder = Builder()
 
     @patch('rtcFunctions.shell')
     def test_Accept_AssertThatCorrectParamaterGetPassedToShell(self, shell_mock):
         revision1 = "anyRevision"
         revision2 = "anyOtherRevision"
         anyurl = "anyUrl"
-        config = Builder().setrepourl(anyurl).setscmcommand("lscm").setworkspace(self.workspace).build()
+        config = self.configBuilder.setrepourl(anyurl).setworkspace(self.workspace).build()
         Changes.accept(config, self.apath, self.createChangeEntry(revision1),
                        self.createChangeEntry(revision2))
         expected_accept_command = "lscm accept -v -o -r %s -t %s --changes %s %s" % (anyurl, self.workspace, revision1,
@@ -33,13 +34,13 @@ def test_Discard_AssertThatCorrectParamaterGetPassedToShell(self, shell_mock):
         revision1 = "anyRevision"
         revision2 = "anyOtherRevision"
         anyurl = "anyUrl"
-        config = Builder().setrepourl(anyurl).setscmcommand("lscm").setworkspace(self.workspace).build()
+        config = self.configBuilder.setrepourl(anyurl).setworkspace(self.workspace).build()
         Changes.discard(config, self.createChangeEntry(revision1), self.createChangeEntry(revision2))
         expected_discard_command = "lscm discard -w %s -r %s -o %s %s" % (self.workspace, anyurl, revision1, revision2)
         shell_mock.execute.assert_called_once_with(expected_discard_command)
 
-    def createChangeEntry(self, revision):
-        return ChangeEntry(revision, "anyAuthor", "anyEmail", "anyDate", "anyComment")
+    def createChangeEntry(self, revision = "anyRevisionId", author = "anyAuthor", email = "anyEmail", comment = "anyComment", date = "anyDate"):
+        return ChangeEntry(revision, author, email, date, comment)
 
     def test_ReadChangesetInformationFromFile_WithoutLineBreakInComment_ShouldBeSuccessful(self):
         sample_file_path = self.get_Sample_File_Path("SampleCompareOutputWithoutLineBreaks.txt")
@@ -69,20 +70,53 @@ def test_ReadChangesetInformationFromFile_InUtf8_ShouldBeSuccesful(self):
         author = "John ÆØÅ"
         mail = "Jon.Doe@rtc2git.rocks"
         self.assert_Change_Entry(changeentries[0], author, mail, "Comment", "2015-05-26 10:40:00")
-        
-    @patch('rtcFunctions.Changes')
+
+    @patch('rtcFunctions.shell')
     @patch('builtins.input', return_value='')
-    def test_RetryAccept_AssertThatTwoChangesGetAcceptedTogether(self, inputmock, changesmock):
+    def test_RetryAccept_AssertThatTwoChangesGetAcceptedTogether(self, inputmock, shellmock):
         changeentry1 = self.createChangeEntry("anyRevId")
         changeentry2 = self.createChangeEntry("anyOtherRevId")
         changeentries = [changeentry1, changeentry2]
-        changesmock.accept.return_value = 0
 
-        config = Builder().setscmcommand("lscm").build()
+        shellmock.execute.return_value = 0
+        self.configBuilder.setrepourl("anyurl").setuseautomaticconflictresolution("True").setworkspace("anyWs")
+        config = self.configBuilder.build()
+
         handler = ImportHandler(config)
-        handler.retryacceptincludingnextchangeset(changeentry1, changeentries)
+        handler.retryacceptincludingnextchangesets(changeentry1, changeentries)
+
+        expectedshellcommand = 'lscm accept -v -o -r anyurl -t anyWs --changes anyRevId anyOtherRevId'
+        shellmock.execute.assert_called_once_with(expectedshellcommand, handler.config.getlogpath("accept.txt"), "a")
+
+    def test_collectChangeSetsToAcceptToAvoidMergeConflict_ShouldCollectThreeChangesets(self):
+        mychange1 = self.createChangeEntry("doSomethingOnOldRev")
+        mychange2 = self.createChangeEntry("doSomethingElseOnOldRev")
+        mymergechange = self.createChangeEntry("anyRev", comment="merge change")
+        changefromsomeoneelse = self.createChangeEntry(author="anyOtherAuthor", revision="2", comment="anotherCommit")
+
+        changeentries = [mychange1, mychange2, mymergechange, changefromsomeoneelse]
+
+        handler = ImportHandler(self.configBuilder.build())
+        collectedchanges = handler.collect_changes_to_accept_to_avoid_conflicts(mychange1, changeentries)
+        self.assertTrue(mychange1 in collectedchanges)
+        self.assertTrue(mychange2 in collectedchanges)
+        self.assertTrue(mymergechange in collectedchanges)
+        self.assertFalse(changefromsomeoneelse in collectedchanges)
+        self.assertEqual(3, len(collectedchanges))
+
+    @patch('builtins.input', return_value='Y')
+    def test_useragreeing_answeris_y_expecttrue(self, inputmock):
+        handler = ImportHandler(self.configBuilder.build())
+        self.assertTrue(handler.is_user_agreeing_to_accept_next_change(self.createChangeEntry()))
 
-        changesmock.accept.assert_called_with(config, handler.acceptlogpath, changeentry1, changeentry2)
+    @patch('builtins.input', return_value='n')
+    def test_useragreeing_answeris_n_expectfalseandexception(self, inputmock):
+        handler = ImportHandler(self.configBuilder.build())
+        try:
+            handler.is_user_agreeing_to_accept_next_change(self.createChangeEntry())
+            self.fail("Should have exit the program")
+        except SystemExit as e:
+            self.assertEqual("Please check the output/log and rerun program with resume", e.code)
 
     def get_Sample_File_Path(self, filename):
         testpath = os.path.realpath(__file__)