def test_doNotAddCommentsGreaterThan20000Characters(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
testing = Testing()
item = self.itemWithComments(testing)
item.addComment(Testing.stringOfAsOfSize(20002))
tracker.updateCommentsFor(item)
verify(trackerInstance, times=2).AddComment(any(), any())
def setupSync(self, syncDirection=ForwardSync):
toTracker = mock()
itemToSyncTo = mock()
itemToSyncFrom = mock()
syncCommentsFor = TrackerSyncBy.syncingItem(Direction=syncDirection)
when(toTracker).items(None).thenReturn(
Testing.MockIterator([itemToSyncTo]))
return toTracker, itemToSyncTo, itemToSyncFrom, syncCommentsFor
def test_updateAddsNewComments(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
testing = Testing()
item = self.itemWithComments(testing)
jira.update(item)
verify(jiraInstance.service, times=2).addComment(any(), any(), any())
pass
def test_doNotAddCommentsGreaterThan20000Characters(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
testing = Testing()
item = self.itemWithComments(testing)
item.addComment(Testing.stringOfAsOfSize(20002))
tracker.updateCommentsFor(item)
verify(trackerInstance, times=2).AddComment(any(), any())
def test_20000PlusCharacterCommentsAreNotSyned(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(Env().get("jira", "project"), "test_20000PlusCharacterCommentsAreNotSyned", "blah")
commentOnJira = TrackerItemComment(Testing.stringOfAsOfSize(20002))
newJiraItem.addComment(commentOnJira)
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
pivotalItem = next(pivotal.items())
self.assertEqual(len(pivotalItem.comments()), 0)
def test_rightItemReturnedWhenMoreThanOneItemReturnedForReverseSync(self):
toTracker = mock()
items = [mock(), mock(), mock()]
when(toTracker).items(any()).thenReturn(
Testing.MockIterator([items[1], items[2]]))
when(items[1]).canBeSyncedWith(items[0]).thenReturn(False)
when(items[2]).canBeSyncedWith(items[0]).thenReturn(True)
forwardSync = ReverseSync(mock().function, items[0], toTracker, None)
forwardSync.obtainItem()
verify(items[2]).canBeSyncedWith(items[0])
def test_canAddCommentsToTicket(self):
jira = JiraTracker()
jiraInstance = self.getMockFor(jira)
testing = Testing()
item = self.itemWithComments(testing)
jira.updateCommentsFor(item)
inorder.verify(jiraInstance.service).login(any(),any())
inorder.verify(jiraInstance.service).addComment(self.auth_, testing.issue.key, {"body":testing.comment1.text()})
inorder.verify(jiraInstance.service).addComment(self.auth_, testing.issue.key, {"body":testing.comment2.text()})
pass
def test_commentsNotAddedIfItemIsNotTheSame(self):
toTracker = mock()
item = mock()
otherItem = mock()
syncCommentsFor = TrackerSyncBy.syncingItem()
when(toTracker).items(None).thenReturn(Testing.MockIterator([item]))
when(item).canBeSyncedWith(otherItem).thenReturn(False)
syncCommentsFor(otherItem, toTracker)
verify(item, never).syncWith(any())
verify(toTracker, never).update(item)
def test_20000PlusCharacterCommentsAreNotSyned(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_20000PlusCharacterCommentsAreNotSyned", "blah")
commentOnJira = TrackerItemComment(Testing.stringOfAsOfSize(20002))
newJiraItem.addComment(commentOnJira)
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
pivotalItem = next(pivotal.items())
self.assertEqual(len(pivotalItem.comments()), 0)
def test_updateAddsNewComments(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
updatedStory = mock()
testing = Testing()
item = self.itemWithComments(testing)
when(trackerInstance).UpdateStory(any()).thenReturn(updatedStory)
when(updatedStory).GetName().thenReturn("")
tracker.update(item)
verify(trackerInstance, times=2).AddComment(any(), any())
pass
def test_canAddCommentsToStoryTicket(self):
tracker = self.makeValidTracker()
trackerInstance = self.trackerInstance_
testing = Testing()
item = self.itemWithComments(testing)
tracker.updateCommentsFor(item)
inorder.verify(trackerInstance).AddComment(testing.issue.GetStoryId(),
testing.comment1.text())
inorder.verify(trackerInstance).AddComment(testing.issue.GetStoryId(),
testing.comment2.text())
pass
def test_doNotAddItemWhenItemInTracker(self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(any()).thenReturn(
Testing.MockIterator([detectedItem]))
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(True)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(None)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker, never).update()
def test_reverseSyncGetsItemToSyncToFromCorrectTracker(self):
toTracker, itemToSyncTo, itemToSyncFrom, syncCommentsFor = self.setupSync(
ReverseSync)
fromTracker = mock()
when(fromTracker).items(None).thenReturn(
Testing.MockIterator([itemToSyncFrom]))
when(itemToSyncFrom).updatedAt().thenReturn(1)
when(itemToSyncTo).updatedAt().thenReturn(0)
when(itemToSyncTo).canBeSyncedWith(itemToSyncFrom).thenReturn(True)
syncCommentsFor(itemToSyncFrom, toTracker, fromTracker)
verify(itemToSyncFrom).syncWith(itemToSyncTo)
verify(fromTracker).update(itemToSyncFrom)
def test_whenMultipleItemsMatchFilterAndItemsCanNotBeSyncedWithThenAddNewItem(
self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(any()).thenReturn(
Testing.MockIterator([detectedItem, detectedItem]))
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(
False).thenReturn(True)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(None)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker, never).update()
def test_doNotAddUnnecessaryComments(self):
toTracker = mock()
item = mock()
testFilter = mock()
otherItem = mock()
syncCommentsFor = TrackerSyncBy.syncingItem(
FilteringOutCommentsFor=testFilter.calledWith)
when(toTracker).items(None).thenReturn(Testing.MockIterator([item]))
when(item).canBeSyncedWith(otherItem).thenReturn(True)
when(item).updatedAt().thenReturn(0)
when(otherItem).updatedAt().thenReturn(1)
syncCommentsFor(otherItem, toTracker)
verify(testFilter).calledWith(item)
def test_addCommentsAndUpdateIssue(self):
toTracker = mock()
itemToAddCommentsTo = mock()
itemToGetCommentsFrom = mock()
syncCommentsFor = TrackerSyncBy.syncingItem()
when(toTracker).items(None).thenReturn(
Testing.MockIterator([itemToAddCommentsTo]))
when(itemToAddCommentsTo).canBeSyncedWith(
itemToGetCommentsFrom).thenReturn(True)
when(itemToAddCommentsTo).updatedAt().thenReturn(0)
when(itemToGetCommentsFrom).updatedAt().thenReturn(1)
syncCommentsFor(itemToGetCommentsFrom, toTracker)
verify(itemToAddCommentsTo).syncWith(itemToGetCommentsFrom)
verify(toTracker).update(itemToAddCommentsTo)
def test_filterFunctionIsUsed(self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
filterValue = "filter"
filterFunction = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(filterValue).thenReturn(
Testing.MockIterator([detectedItem]))
when(filterFunction).calledWith(detectedItem).thenReturn(filterValue)
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(True)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(
None, filterFunction.calledWith)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker).items(filterValue)
def test_whenMultipleItemsMatchFilterAndItemCanBeSyncedWithThenDoNotAddNewItem(
self):
toTracker = mock()
fromTracker = mock()
detectedItem = mock()
TrackerItemType = mock()
itemToBeAdded = mock()
when(fromTracker).items(any()).thenReturn([detectedItem])
when(toTracker).items(any()).thenReturn(
Testing.MockIterator([detectedItem, detectedItem]))
when(detectedItem).canBeSyncedWith(detectedItem).thenReturn(False)
when(TrackerItemType).called().thenReturn(itemToBeAdded)
when(toTracker).update(itemToBeAdded).thenReturn(itemToBeAdded)
syncByAddingItems = TrackerSyncBy.addingItemsOfType(
TrackerItemType.called)
syncByAddingItems(fromTracker, toTracker)
verify(toTracker, times=2).update(itemToBeAdded)