def test_onlyTakeCommentsFromIssueForByFilter(self):
     toTracker = mock()
     aTestItemFilter = mock()
     syncCommentsFor = TrackerSyncBy.syncingItem(aTestItemFilter.calledWith)
     when(toTracker).items(None).thenRaise(StopIteration)
     syncCommentsFor(None, toTracker)
     verify(aTestItemFilter).calledWith(None)

 def test_doNotAddCommentsWhenItemNotFound(self):
     toTracker = mock()
     item = mock()
     syncCommentsFor = TrackerSyncBy.syncingItem()
     when(toTracker).items(None).thenRaise(StopIteration)
     syncCommentsFor(item, toTracker)
     verify(toTracker, never).update(item) 

 def test_whenJiraIdIsZeroNameIsNone(self):
     jiraStatus = mock()
     mapObject = mock()
     when(jiraStatus).status().thenReturn("")
     status = TrackerItemStatus(jiraStatus, mapObject)
     verify(mapObject, never).translateStatusTo(any(), any())
     self.assertEqual(status.jira(), None)

 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_doNotAddItemWhenNoItemToAdd(self):
     toTracker = mock()
     fromTracker = mock()
     when(fromTracker).items(any()).thenReturn([])
     syncByAddingItems = TrackerSyncBy.addingItemsOfType(None)
     syncByAddingItems(fromTracker, toTracker)
     verify(toTracker, never).update()

 def test_whenStatusCanBeMatchedToActionThenReturnActionId(self):
     status = mock()
     potentialAction = mock()
     actions = [potentialAction, ]
     when(status).jira().thenReturn([str(potentialAction.name)])
     action = JiraStatusToAction(status, actions)
     self.assertEqual(str(potentialAction.id), str(action.Id()))
     pass

 def test_canConvertItemToType(self):
     tracker = Tracker()
     contents = mock()
     timezone = mock()
     item = tracker._convertToItem(testType, contents, timezone )
     storedItem, storedTimezone = item.contains()
     self.assertEqual(storedItem, contents)
     self.assertEqual(storedTimezone, timezone)

    def test_should_not_throw_exception_when_node_is_up_and_running(self):
        mock_command_helper = mock()
        mock_string_attr = mock()
        mock_string_attr.succeeded=True
        lxc_node = LXCNode("123", mock_command_helper, "test_host_name")

        when(mock_command_helper).run_command_silently("ping -c1 123").thenReturn(mock_string_attr)

        lxc_node.wait_for_ready(lambda : None, 15)

 def setupStatus(self): 
     jira = JiraTracker()
     jiraInstance = self.getMockFor(jira)
     itemId = 1234
     trackerItem = mock()
     status = mock()
     when(trackerItem).Id().thenReturn(itemId)
     when(trackerItem).status().thenReturn(status)
     return jira, jiraInstance, itemId, trackerItem, status

    def test_should_throw_exception_when_node_is_not_up_and_running(self):
        mock_command_helper = mock()
        mock_string_attr = mock()
        mock_string_attr.succeeded=False
        lxc_node = LXCNode("123", mock_command_helper, "test_host_name")

        when(mock_command_helper).run_command_silently("ping -c1 123").thenReturn(mock_string_attr)
        with self.assertRaisesRegexp(Exception, "Node 123 is not running"):
            lxc_node.wait_for_ready(lambda : None, 5)

 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 getMockFor(self, jira):
     jiraApiObject = mock()
     jiraInstance = Holder()
     jiraInstance.service = mock()
     jira.apiObject(jiraApiObject)
     when(jiraApiObject).Client(any(), timeout=any()).thenReturn(jiraInstance)
     self.auth_ = mock()
     when(jiraInstance.service).login(any(),any()).thenReturn(self.auth_)
     jira.withCredential("None")
     return jiraInstance

def setupCliProcessingJson(json, password=None):
    cliProcessingJson = CliProcessingJson("garbage", initialJsonString=json)
    UserObject = mock()
    user = mock()
    user.password = password
    CliObject = mock()
    cli = mock()
    when(UserObject).called(any(), any()).thenReturn(user)
    when(CliObject).called(any(), any(), debug=any(), trace=any()).thenReturn(cli)
    return cliProcessingJson, UserObject, CliObject, cli, user

 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_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_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_dontDeleteNotAddedItem(self):
     jira = JiraTracker()
     jiraInstance = self.getMockFor(jira)
     jira.selectProject([])
     jiraTrackerItem = mock()
     story = mock()
     when(jiraTrackerItem).underlying().thenReturn(story)
     when(story).GetStoryId().thenReturn(None)
     jira.delete(jiraTrackerItem)
     verify(jiraInstance.service, never).DeleteStory(any())
     pass 

 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_trackerCanAddItem(self):
     tracker = self.makeValidTracker()
     trackerInstance = self.trackerInstance_
     pivotalTrackerItem = mock()
     story = mock()
     when(pivotalTrackerItem).decoratedStory().thenReturn(story)
     when(pivotalTrackerItem).Id().thenReturn(None)
     when(trackerInstance).AddNewStory(any()).thenReturn(mock())
     when(pivotalTrackerItem).comments('new').thenReturn([])
     tracker.update(pivotalTrackerItem)
     verify(trackerInstance).AddNewStory(story)
     pass

 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)