mockito.mockito.when

Here are the examples of the python api mockito.mockito.when taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

11 Examples 7

Example 1

Project: wtframework Source File: test_webdriver_manager.py
    def test_is_driver_available_withEmptyChannel_returnsFalse(self):
        "Test that false is returned if webdriver was not created."
        config_reader = mock(ConfigReader)
        webdriverfactory_mock = mock(WebDriverFactory)
        when(webdriverfactory_mock).create_webdriver(
            testname=None).thenReturn(None)

        webdriver_provider = WebDriverManager(webdriver_factory=webdriverfactory_mock,
                                              config=config_reader)
        self.assertFalse(webdriver_provider.is_driver_available())

Example 2

Project: wtframework Source File: test_webdriver_manager.py
    def test_is_driver_available_withWebdriverCreated_returnsTrue(self):
        "Test that true is returned if webdriver was created."
        config_reader = mock(ConfigReader)
        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)
        _ = webdriver_provider.new_driver()
        self.assertTrue(webdriver_provider.is_driver_available())

Example 3

Project: wtframework Source File: test_webdriver_manager.py
    def test_is_driver_available_withWebdriverClosed_returnsFalse(self):
        "Test that true is returned if webdriver was created."
        config_reader = mock(ConfigReader)
        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)
        _ = webdriver_provider.new_driver()
        webdriver_provider.close_driver()

        self.assertFalse(webdriver_provider.is_driver_available())

Example 4

Project: mythbox Source File: test_db.py
    def test_getJobs_All(self):
        when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
        jobs = self.db.getJobs()
        self.assertTrue(jobs is not None)
        for index, job in enumerate(jobs):
            log.debug('job %d = %s' % (index, job))

Example 5

Project: mythbox Source File: test_db.py
    def test_getJobs_ByJobType(self):
        # Setup
        when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
        jobs = self.db.getJobs()
        if len(jobs) == 0:
            log.warn('No jobs in database to test with. Test skipped...')
            return
        job = jobs[0]
    
        # Test
        jobs = self.db.getJobs(jobType=job.jobType)
    
        # Verify
        self.assertTrue(len(jobs) > 0)
        for index, j2 in enumerate(jobs):
            log.debug('job %d = %s' % (index, j2))
            self.assertEquals(job.jobType, j2.jobType)

Example 6

Project: wtframework Source File: test_webdriver_manager.py
    def test_getDriver_ReturnsSingletonSeleniumWebdriver(self):
        '''
        Test we return a single instance of selenium webdriver.
        '''
        mock_element = mock(WebElement)
        when(mock_element).send_keys(any(str)).thenReturn(None)
        webdriver_mock = mock(WebDriver)
        when(webdriver_mock).get("http://www.google.com").thenReturn(None)
        when(webdriver_mock).find_element_by_name('q').thenReturn(mock_element)
        webdriverfactory_mock = mock(WebDriverFactory)
        when(webdriverfactory_mock).create_webdriver(
            testname=None).thenReturn(webdriver_mock)

        webdriver_provider = WebDriverManager(webdriverfactory_mock)

        # Perform singleton tests
        driver1 = webdriver_provider.get_driver()
        driver2 = webdriver_provider.get_driver()
        self.assertIsNotNone(driver1, 'object is not webdriver.')
        self.assertEqual(
            id(driver1), id(driver2), 'Webdriver instance should be singleton.')

        # Do a small test by grabbing google's screen to exercise the webdriver
        # interface.
        driver1.get("http://www.google.com")
        # Q is the name google use for the query field.
        element = driver1.find_element_by_name('q')
        element.send_keys("Hello World")

Example 7

Project: wtframework Source File: test_webdriver_manager.py
    def test_newDriver_ReturnsNewInstance(self):
        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)

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

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

        driver1 = webdriver_provider.new_driver()
        driver2 = webdriver_provider.new_driver()

        self.assertFalse(driver1 is driver2,
                         "new_driver() should create fresh instance if reusebrowser if false.")

Example 8

Project: wtframework Source File: test_webdriver_manager.py
    @timeout(5)
    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.")

Example 9

Project: wtframework Source File: test_webdriver_manager.py
    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()

Example 10

Project: mythbox Source File: test_db.py
    def test_getJobs_ForProgram(self):
        # Setup
        when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
        jobs = self.db.getJobs()
        if len(jobs) == 0:
            log.warn('No jobs in database to test with. Test skipped...')
            return 
        job = jobs[-1]  # last job
        data = [''] * self.protocol.recordSize()
        data[4]  = job.channelId
        data[11] = time.mktime(job.startTime.timetuple()) 
        program = RecordedProgram(data=data, settings=Mock(), translator=Mock(), platform=Mock(), protocol=self.protocol, conn=Mock())
    
        # Test
        jobs = self.db.getJobs(program=program)
    
        # Verify
        self.assertTrue(len(jobs) > 0)
        for index, actual in enumerate(jobs):
            log.debug('job %d = %s' % (index, actual))
            self.assertEquals(job.channelId, actual.channelId)
            self.assertEquals(job.startTime, actual.startTime)

Example 11

Project: mythbox Source File: test_db.py
    def test_getJobs_ForProgram_ByJobType(self):
        # Setup
        when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
        jobs = self.db.getJobs()
        if len(jobs) == 0:
            log.warn('No jobs in database to test with. Test skipped...')
            return 
        job = jobs[-1] # last job
        data = [''] * self.protocol.recordSize()
        data[4]  = job.channelId
        data[11] = time.mktime(job.startTime.timetuple()) 
        program = RecordedProgram(data=data, settings=Mock(), translator=Mock(), platform=Mock(), protocol=self.protocol, conn=Mock())
    
        # Test
        jobs = self.db.getJobs(program=program, jobType=job.jobType)
    
        # Verify
        self.assertTrue(len(jobs) > 0)
        for index, actual in enumerate(jobs):
            log.debug('job %d = %s' % (index, actual))
            self.assertEquals(job.channelId, actual.channelId)
            self.assertEquals(job.startTime, actual.startTime)
            self.assertEquals(job.jobType, actual.jobType)