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_doNotSyncIfItemIsLessUpToDate(self):
     toTracker, itemToSyncTo, itemToSyncFrom, syncCommentsFor = self.setupSync()
     when(itemToSyncTo).updatedAt().thenReturn(1)
     when(itemToSyncFrom).updatedAt().thenReturn(0)
     when(itemToSyncTo).canBeSyncedWith(itemToSyncFrom).thenReturn(True)
     syncCommentsFor(itemToSyncFrom, toTracker)
     verify(toTracker, never).update(itemToSyncTo)

    def test_get_children_watcher(self):
        watcher = mock()
        z = pookeeper.allocate(self.hosts)

        z.create('/pookie', CREATOR_ALL_ACL, Persistent(), data=_random_data())
        z.get_children('/pookie', watcher=watcher)

        z.create('/pookie/bear', CREATOR_ALL_ACL, Persistent(), data=_random_data())
        z.get_children('/pookie', watcher=watcher)

        z.set_data('/pookie', _random_data())
        z.set_data('/pookie/bear', _random_data())

        # One is for when we do and the other is for when we don't chroot
        z.get_children('/pookie', watcher=watcher)
        z.get_children('/pookie/bear', watcher=watcher)

        z.delete('/pookie/bear')
        z.delete('/pookie')

        z.close()

        mockito.verify(watcher, times=2).children_changed('/pookie')
        mockito.verify(watcher).node_deleted('/pookie/bear')
        verifyNoMoreInteractions(watcher)

 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 testFeedback(self):
     bmlToIpaaca = BMLRealizerToIpaacaAdapter()
     ipaacaToBML = IpaacaToBMLRealizerAdapter(self.mockRealizerPort)
     bmlToIpaaca.addListeners(self.mockFeedbackListener);
     ipaacaToBML.feedback("bmlfeedback");
     time.sleep(0.05)
     verify(self.mockFeedbackListener).feedback("bmlfeedback");    

 def testFeedbackOtherCharacter(self):
     bmlToIpaaca = BMLRealizerToIpaacaAdapter("Fred")
     ipaacaToBML = IpaacaToBMLRealizerAdapter(self.mockRealizerPort,"Wilma")
     bmlToIpaaca.addListeners(self.mockFeedbackListener);
     ipaacaToBML.feedback("bmlfeedback");
     time.sleep(0.05)
     verify(self.mockFeedbackListener,times=0).feedback("bmlfeedback"); 

 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 test_whenSeedingWithPivotalStatus(self):
     pivotalStatus = "Started"
     mapObject = mock()
     status = TrackerItemStatus(pivotalStatus, apiObject=mapObject)
     status.jira()
     verify(mapObject).translateStatusTo('jira', pivotalStatus)
     self.assertEqual(status.pivotal(), pivotalStatus) 

    def test_cleanup_quits_webdrivers(self):
        "Tests that clean up is performed on webdrivers created by WebdriverManger"
        config_reader = mock(ConfigReader)
        when(config_reader).get(
            WebDriverManager.SHUTDOWN_HOOK_CONFIG, True).thenReturn(True)
        when(config_reader).get(
            WebDriverManager.REUSE_BROWSER, True).thenReturn(False)
        when(config_reader).get(
            WebDriverManager.REUSE_BROWSER, True).thenReturn(False)
        when(config_reader).get(
            WebDriverManager.ENABLE_THREADING_SUPPORT, False).thenReturn(True)

        webdriver_mock1 = mock(WebDriver)
        webdriverfactory_mock = mock(WebDriverFactory)
        when(webdriverfactory_mock).create_webdriver(
            testname=None).thenReturn(webdriver_mock1)

        webdriver_provider = WebDriverManager(webdriver_factory=webdriverfactory_mock,
                                              config=config_reader)

        # Spawn thread to check if driver is unique per thread.
        driver = webdriver_provider.get_driver()
        del webdriver_provider

        # verify decontructor cleans up the webdriver.
        verify(driver).quit()

 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_CanRetrieveDevicesListFiltered():
    pertinoSdk, _, response = setupSdk()
    json = {"devices": [{"ipv4Address": "123.456.789.10", "hostName": "host", "id": 1234}]}
    when(response).json().thenReturn(json)
    closure = mock()
    pertinoSdk.listDevicesIn({"id":1}, closure.function)
    verify(closure).function(json["devices"][0])

 def test_user_can_login_with_password(self):
     cli = mock()
     user = User("username", "password", cli)
     when(cli).compareReceivedAgainst(any(),any(), indexOfSuccessfulResult=any()).thenReturn(0).thenReturn(1)
     user.login()
     verify(cli).send("su username")
     verify(cli).send("password")

 def test_retryWhenTryingToGetStoriesAndException(self):
     tracker = self.makeValidTracker()
     trackerInstance = self.trackerInstance_
     when(trackerInstance).GetStories(any()).thenRaise(Exception("")).thenReturn([Story(),Story()])
     when(trackerInstance).GetComments(any()).thenReturn([])
     next(tracker.items())
     verify(trackerInstance, times=2).GetStories(any())

 def test_filterIsSentWhenSpecified(self):
     jira = JiraTracker()
     jiraInstance = self.getMockFor(jira)
     forFilter = "blah"
     self.setMocksForGettingItems(jiraInstance)
     self.assertRaises(StopIteration, next, jira._getItems(forFilter)) 
     verify(jiraInstance.service).getIssuesFromJqlSearch(any(),forFilter,any())

 def test_mode_exited(self):
     cli = self.makeCli()
     when(cli).compareReceivedAgainst(any(),any()).thenReturn(0)
     testMode = Mode(cli)
     testMode.exit()
     verify(cli).exitMode(testMode)
     verify(cli).send("exit")

def test_CanRetrieveOrganizationListFiltered():
    pertinoSdk, _, response = setupSdk()
    json = {"orgs": [{"name": "organization", "id": 1234}]}
    when(response).json().thenReturn(json)
    closure = mock()
    pertinoSdk.listOrgs(closure=closure.function)
    verify(closure).function(json["orgs"][0])

 def test_noDeletionsWhenNoItems(self):
     tracker = self.makeValidTracker()
     trackerInstance = self.trackerInstance_
     when(trackerInstance).GetStories(any()).thenReturn([])
     tracker.deleteAllItems()
     verify(trackerInstance, never).DeleteStory(any())
     pass

 def test_authSentWhenGettingBugs(self):
     jira = JiraTracker()
     jiraInstance = self.getMockFor(jira)
     self.setMocksForGettingItems(jiraInstance)
     itemIterator = jira._getItems()
     self.assertRaises(StopIteration, next, itemIterator)
     verify(jiraInstance.service).getIssuesFromJqlSearch(self.auth_, any(), any())
     pass

 def test_canUpdateStatus(self):
     statusId = "Match"
     action = TestAction(5,statusId)
     jira, jiraInstance, itemId, trackerItem, status = self.setupStatus()
     when(status).jira().thenReturn(statusId)
     when(jiraInstance.service).getAvailableActions(any(), any()).thenReturn([action,])
     jira._ticketWithUpdatedStatusFrom(trackerItem)
     verify(jiraInstance.service).progressWorkflowAction(self.auth_, itemId, action.id, any())

 def test_filterIsSentWhenSpecified(self):
     tracker = self.makeValidTracker()
     trackerInstance = self.trackerInstance_
     forFilter = "blah"
     when(trackerInstance).GetStories(any()).thenReturn([])
     when(trackerInstance).GetComments(any()).thenReturn([])
     self.assertRaises(StopIteration, next, tracker.items(forFilter)) 
     verify(trackerInstance).GetStories(forFilter)