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_multithreadMode(self):
        """
        Tests that when we call get_driver() it returns a unique driver for each thread,
        but for the same thread returns the same driver.
        """
        config_reader = mock(ConfigReader)
        when(config_reader).get(WebDriverManager.SHUTDOWN_HOOK_CONFIG, any()).thenReturn(True)
        when(config_reader).get(WebDriverManager.REUSE_BROWSER, any()).thenReturn(False)
        when(config_reader).get(WebDriverManager.REUSE_BROWSER, any()).thenReturn(False)
        when(config_reader).get(WebDriverManager.ENABLE_THREADING_SUPPORT, any()).thenReturn(True)

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

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

        # Spawn thread to check if driver is unique per thread.
        driver1 = webdriver_provider.get_driver()
        t = threading.Thread(target=lambda: self.__multithreaded_7est_thread2(driver1, webdriver_provider))
        t.start()
        t.join()
        self.assertFalse(self._driver_from_thread_is_same)
        
        # Check that driver is same for the same thread.
        driver3 = webdriver_provider.get_driver()
        self.assertEqual(driver1, driver3, "Same thread should return same driver.")

 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_roger_push_env_from_ROGER_ENV_VAR(self):
        settings = mock(Settings)
        appConfig = mock(AppConfig)
        roger_push = RogerPush()
        marathon = mock(Marathon)
        mockedHooks = mock(Hooks)
        roger_env = self.roger_env
        config = self.config
        frameworkUtils = mock(FrameworkUtils)
        when(settings).getConfigDir().thenReturn(self.configs_dir)
        when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0)
        when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env)
        when(appConfig).getConfig(any(), any()).thenReturn(config)

        args = self.args
        args.env = None
        args.secrets_file = ""
        args.skip_push = True
        args.app_name = 'grafana_test_app'
        args.config_file = 'test.json'

        roger_env = appConfig.getRogerEnv(self.configs_dir)
        roger_env["default_environment"] = None
        # Setting ROGER_ENV to specific value
        os.environ["ROGER_ENV"] = "test_env"

        with self.assertRaises(ValueError):
            roger_push.main(settings, appConfig,
                            frameworkUtils, mockedHooks, args)

 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_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_get_children_default_watcher(self):
        watcher = mock()
        z = pookeeper.allocate(self.hosts, watcher=watcher)

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

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

        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', watch=True)
        z.get_children('/pookie/bear', watch=True)

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

        z.close()

        mockito.verify(watcher).session_connected(matchers.any(long), matchers.any(str), False)
        mockito.verify(watcher, times=2).children_changed('/pookie')
        mockito.verify(watcher).node_deleted('/pookie/bear')
        mockito.verify(watcher).connection_closed()
        verifyNoMoreInteractions(watcher)

 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_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_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_noDeletionsWhenNoItems(self):
     jira = JiraTracker()
     jiraInstance = self.getMockFor(jira)
     jira.selectProject(["",""])
     self.setMocksForGettingItems(jiraInstance)
     jira.deleteAllItems()
     verify(jiraInstance.service, never).deleteIssue(any(), 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_run_hook_returns_zero_when_hook_succeeds(self):

        when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
        sc = mock(StatsClient)
        when(sc).timing(any(), any()).thenReturn(any())
        when(self.hooks.utils).getStatsClient().thenReturn(sc)
        when(self.hooks.utils).get_identifier(any(), any(), any()).thenReturn(any())
        assert self.hooks.run_hook("pre-build", self.appdata, os.getcwd(), "roger-tools.pre-build-test") == 0

 def test_whenDoingPivotalOperationAuthenticationIsIncluded(self):
     tracker = self.makeTestTracker()
     pivotalApiObject = self.apiObject_
     password = "pass"
     authentication = mock()
     when(pivotalApiObject).HostedTrackerAuth(any(),any()).thenReturn(authentication)
     tracker.withCredential(password)
     verify(pivotalApiObject).Tracker(any(), authentication)

 def test_canntGetBugsForProject(self):
     jira = JiraTracker()
     jiraInstance = self.getMockFor(jira)
     jira.selectProject(["",""])
     fault = Holder()
     fault.faultstring = ""
     when(jiraInstance.service).getIssuesFromJqlSearch(any(), any(), any()).thenRaise(WebFault(fault, None))
     self.assertRaises(StopIteration, next, jira._getItems())

 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_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)

    def test_run_hook_returns_non_zero_when_hook_fails(self):

        when(self.hooks.whobj).invoke_webhook(any(), any(), any()).thenReturn()
        sc = mock(StatsClient)
        when(sc).timing(any(), any()).thenReturn(any())
        when(self.hooks.utils).getStatsClient().thenReturn(sc)
        when(self.hooks.utils).get_identifier(any(), any(), any()).thenReturn(any())
        assert self.hooks.run_hook(
            "bad-hook-cmd", self.appdata, os.getcwd(), "roger-tools.bad-hook-cmd-test") != 0

 def makeValidTracker(self):
     tracker = self.makeTestTracker()
     pivotalApiObject = self.apiObject_
     trackerInstance = mock()
     when(pivotalApiObject).Tracker(any(),any()).thenReturn(trackerInstance)
     pivotalProjectNumber = 0
     tracker.selectProject(pivotalProjectNumber)
     self.trackerInstance_ = trackerInstance
     return tracker