Beispiel #1
0
    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_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.")
Beispiel #3
0
    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")
        element = driver1.find_element_by_name(
            'q')  # Q is the name google use for the query field.
        element.send_keys("Hello World")
Beispiel #4
0
    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."
        )
Beispiel #5
0
    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_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")
    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_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())
Beispiel #9
0
    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())
    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())
Beispiel #11
0
    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())
 def test_read_good(self):
     '''
         make sure read returns true/results when the user retrieved is the same as
         the logged in user
     '''
     the_bundle = mock()
     the_bundle.obj = mock()
     the_bundle.obj.pk = 2
     the_bundle.request = mock()
     the_bundle.request.user = mock()
     the_bundle.request.user.pk = 2
     self.assertTrue(self.the_auth.read_detail(None, the_bundle))
     self.assertTrue(self.the_auth.read_list(User.objects.filter(pk=2), the_bundle).count(),
                     1)
 def test_read_unauthorized(self):
     '''
         make sure read methods returns false/nothing when the user retrieved is different from
         the logged in user
     '''
     the_bundle = mock()
     the_bundle.obj = mock()
     the_bundle.obj.pk = 1
     the_bundle.request = mock()
     the_bundle.request.user = mock()
     the_bundle.request.user.pk = 2
     self.assertFalse(self.the_auth.read_detail(None, the_bundle))
     self.assertEquals(len(list(self.the_auth.read_list(User.objects.filter(pk=1), the_bundle))),
                       0)
 def test_add_arguments(self):
     ''' verify that expected arguements are added to the parser '''
     the_parser = mock()
     when(the_parser).add_argument('input_file_path', nargs=1).thenReturn(None)
     when(the_parser).add_argument('error_file_path', nargs=1).thenReturn(None)
     when(the_parser).add_argument('error_detail_file_path', nargs=1).thenReturn(None)
     self.run_list.add_arguments(the_parser)
     verify(the_parser).add_argument('input_file_path', nargs=1)
     verify(the_parser).add_argument('error_file_path', nargs=1)
     verify(the_parser).add_argument('error_detail_file_path', nargs=1)
    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.")
 def setUp(self):
     ''' set up the test '''
     self.the_auth = OwnerObjectsOnlyAuthorization()
     self.the_bundle = mock()
     self.the_bundle.request = mock()