def test_autodetect_proxy_is_set_in_profile():
    profile = FirefoxProfile()
    proxy = Proxy()
    proxy.auto_detect = True

    profile.set_proxy(proxy)
    assert profile.default_preferences["network.proxy.type"] == ProxyType.AUTODETECT['ff_value']

    def start(cls, url, driver=""):
        if cls.mode == "FireFox":
            default_profile = {
                'browser.usedOnWindows10': False,
                'browser.usedOnWindows10.introURL': 'https://www.google.com/',
                'startup.homepage_welcome_url.additional': 'about:blank',
                'browser.startup.homepage_override.mstone': 'ignore',
            }
            profile = FirefoxProfile()
            for name, value in default_profile.items():
                profile.set_preference(name, value)
            cls.driver = webdriver.Firefox(profile)

        elif cls.mode == "Chrome":
            try:
                if driver != "":
                    chromedriver = driver
                    L.info(chromedriver)
                    os.environ["webdriver.chrome.driver"] = chromedriver
                    cls.driver = webdriver.Chrome(chromedriver)
                else:
                    cls.driver = webdriver.Chrome()
            except Exception as e:
                L.warning(str(e))
                raise SeleniumError(
                    "Can't find Selenium Driver Mode. %s" % cls.mode)
        else:
            raise SeleniumError(
                "Can't find Selenium Driver Mode. %s" % cls.mode)

        cls.driver.implicitly_wait(DEFAULT_WAIT)
        cls.driver.set_window_size(WINDOW_SIZE_WIDTH, WINDOW_SIZE_HEIGHT)
        cls.driver.get(url)
        time.sleep(5)

 def _create_profile(self):
     """Create profile object.
     """
     profile = FirefoxProfile()
     for name, value in self.default_profile.items():
         profile.set_preference(name, value)
     return profile

def test_pac_proxy_is_set_in_profile():
    profile = FirefoxProfile()
    proxy = Proxy()
    proxy.proxy_autoconfig_url = 'http://some.url:12345/path'

    profile.set_proxy(proxy)
    assert profile.default_preferences["network.proxy.type"] == ProxyType.PAC['ff_value']
    assert profile.default_preferences["network.proxy.autoconfig_url"] == 'http://some.url:12345/path'

class SeleniumBaseTest(unittest.TestCase):

    def start_test_weblab_deployment(self):
        # Load the configuration of the weblab instance that we have set up for just this test.
        self.global_config = load_dir('test/deployments/webclient_dummy')

        # Start the weblab instance. Because we have activated the dont-start flag it won't actually
        # start listening on the port, but let us use the Flask test methods instead.
        self.handler = self.global_config.load_process('myhost', 'myprocess')

        self.core_server = GLOBAL_REGISTRY['mycore:[email protected]']

    @classmethod
    def setUpClass(self):

        # Starts a test deployment.
        self.start_test_weblab_deployment()

        if os.environ.get("SELENIUM_HEADLESS") and False:
            self.driver = webdriver.PhantomJS()
        else:
            self.profile = FirefoxProfile()
            self.profile.set_preference("intl.accept_languages", "en")
            self.driver = webdriver.Firefox(self.profile)

        self.driver.set_window_size(1400, 1000)

        # self.driver.implicitly_wait(30)

        self.base_url = "http://localhost:5000/"
        self.verificationErrors = []
        self.accept_next_alert = True

    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException, e: return False
        return True

    def is_alert_present(self):
        try: self.driver.switch_to_alert()
        except NoAlertPresentException, e: return False
        return True

    def close_alert_and_get_its_text(self):
        try:
            alert = self.driver.switch_to_alert()
            alert_text = alert.text
            if self.accept_next_alert:
                alert.accept()
            else:
                alert.dismiss()
            return alert_text
        finally: self.accept_next_alert = True

    @classmethod
    def tearDownClass(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)

 def __init__(self, cer_data, key_data):
   
   self.temp_cer = self.temp_file(cer_data)
   self.temp_key = self.temp_file(key_data)
   profile = FirefoxProfile(settings.PROFILE_PATH)
   
   for preference in settings.PROFILE_PREFERENCES:
     profile.set_preference(*preference)
   
   self._driver = Firefox(firefox_profile = profile)
   self._driver.get(settings.GET_CFDI_URL)

 def __call__(self, config, args):
     profile = FirefoxProfile()
     if config.user_agent:
         profile.set_preference("general.useragent.override",
                                config.user_agent)
     if config.ignore_ssl:
         profile.accept_untrusted_certs = True
     args["firefox_profile"] = profile
     args["capabilities"] = args["desired_capabilities"]
     args.pop("desired_capabilities")
     return args

def test_add_extension_web_extension_without_id(capabilities, webserver):
    current_directory = os.path.dirname(os.path.realpath(__file__))
    root_directory = os.path.join(current_directory, '..', '..', '..', '..', '..')
    extension_path = os.path.join(root_directory, 'third_party', 'firebug', 'mooltipass-1.1.87.xpi')

    profile = FirefoxProfile()
    profile.add_extension(extension_path)

    driver = Firefox(capabilities=capabilities, firefox_profile=profile)
    profile_path = driver.firefox_profile.path
    extension_path_in_profile = os.path.join(profile_path, 'extensions', '[email protected]')
    assert os.path.exists(extension_path_in_profile)
    driver.quit()

def test_add_extension_legacy_extension(capabilities, webserver):
    current_directory = os.path.dirname(os.path.realpath(__file__))
    root_directory = os.path.join(current_directory, '..', '..', '..', '..', '..')
    extension_path = os.path.join(root_directory, 'third_party', 'firebug', 'firebug-1.5.0-fx.xpi')

    profile = FirefoxProfile()
    profile.add_extension(extension_path)

    driver = Firefox(capabilities=capabilities, firefox_profile=profile)
    profile_path = driver.firefox_profile.path
    extension_path_in_profile = os.path.join(profile_path, 'extensions', '[email protected]')
    assert os.path.exists(extension_path_in_profile)
    driver.quit()

    def setUp(self):
        if _platform != "darwin":
            self.display = Display(visible=0, size=(1280, 800))
            self.display.start()

        p = FirefoxProfile()
        p.set_preference("webdriver.log.file", "/tmp/firefox_console")

        self.driver = webdriver.Firefox(p)
        self.base_url = os.getenv('SELENIUM_BASE_URL')
        self.verificationErrors = []
        self.accept_next_alert = True
        self.driver.set_window_size(1280, 800)
        self.project_name = "DBaaS"

def generate_profile(useragent="(default)"):
    profile = FirefoxProfile()
    if useragent.strip().lower()=="(default)":
        status("Using the default useragent")
        return profile
    elif useragent.strip().lower()=="(random)":
        random_useragent = generate_user_agent(os=('mac', 'linux'))
        profile.set_preference("general.useragent.override", random_useragent) # To make our useragent random
        status("Using random useragent "+random_useragent)
        return profile
    else:
        profile.set_preference("general.useragent.override", useragent)
        status("Using useragent "+useragent)
        return profile

def test_manual_proxy_is_set_in_profile():
    profile = FirefoxProfile()
    proxy = Proxy()
    proxy.no_proxy = 'localhost, foo.localhost'
    proxy.http_proxy = 'some.url:1234'
    proxy.ftp_proxy = None
    proxy.sslProxy = 'some2.url'

    profile.set_proxy(proxy)
    assert profile.default_preferences["network.proxy.type"] == ProxyType.MANUAL['ff_value']
    assert profile.default_preferences["network.proxy.no_proxies_on"] == 'localhost, foo.localhost'
    assert profile.default_preferences["network.proxy.http"] == 'some.url'
    assert profile.default_preferences["network.proxy.http_port"] == 1234
    assert profile.default_preferences["network.proxy.ssl"] == 'some2.url'
    assert "network.proxy.ssl_port" not in profile.default_preferences
    assert "network.proxy.ftp" not in profile.default_preferences

def test_add_extension_web_extension_with_id(capabilities, webserver):
    current_directory = os.path.dirname(os.path.realpath(__file__))
    root_directory = os.path.join(current_directory, '..', '..', '..', '..', '..')
    # TODO: This file should probably live in a common directory.
    extension_path = os.path.join(root_directory, 'javascript', 'node', 'selenium-webdriver',
                                  'lib', 'test', 'data', 'firefox', 'webextension.xpi')

    profile = FirefoxProfile()
    profile.add_extension(extension_path)

    driver = Firefox(capabilities=capabilities, firefox_profile=profile)
    profile_path = driver.firefox_profile.path
    extension_path_in_profile = os.path.join(profile_path, 'extensions', 'webextension[email protected]')
    assert os.path.exists(extension_path_in_profile)
    driver.get(webserver.where_is('simpleTest.html'))
    driver.find_element_by_id('webextensions-selenium-example')
    driver.quit()

    def setup_firefox_profile(self):
        """Return a custom firefox profile with given preferences
        and extensions.

        """
        fp = FirefoxProfile()

        if self.extensions:
            # Load extensions.
            for ext in self.extensions:
                fp.add_extension(ext)

        if self.preferences:
            # Load preferences
            for key, value in self.preferences:
                fp.set_preference(key, value)

        return fp

def test_that_unicode_prefs_are_written_in_the_correct_format():
    profile = FirefoxProfile()
    profile.set_preference('sample.preference.2', unicode('hi there'))
    profile.update_preferences()

    assert 'hi there' == profile.default_preferences["sample.preference.2"]

    encoded = profile.encoded
    decoded = base64.b64decode(encoded)
    with BytesIO(decoded) as fp:
        zip = zipfile.ZipFile(fp, "r")
        for entry in zip.namelist():
            if entry.endswith('user.js'):
                user_js = zip.read(entry)
                for line in user_js.splitlines():
                    if line.startswith(b'user_pref("sample.preference.2",'):
                        assert line.endswith(b'hi there");')
            # there should be only one user.js
            break

def browser(request):
    """
    initialize the selenium test case
    """
    profile = FirefoxProfile()
    profile.set_preference("browser.download.folderList", 2)
    profile.set_preference("browser.download.manager.showWhenStarting", False)
    profile.set_preference("browser.download.dir", DOWNLOAD_DIR)
    profile.set_preference("browser.helperApps.neverAsk.saveToDisk", "text/csv")

    b = Firefox(firefox_profile=profile)
    b.implicitly_wait(10)
    b.maximize_window()
    request.addfinalizer(lambda *args: b.quit())
    yield b
    time.sleep(10)

    def __init__(self, should_hide_window, installation_path):
        # ASSUMPTION: installation_path refers to a valid firefox executable.
        firefox_binary = None if installation_path is None else FirefoxBinary(installation_path)

        profile = FirefoxProfile()
        profile.set_preference("intl.accept_languages", "en-us,en")
        # do not load images:
        profile.set_preference('browser.migration.version', 9001)
        profile.set_preference('permissions.default.image', 2)
        profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so', 'false')

        driver = selenium.webdriver.Firefox(firefox_profile=profile, firefox_binary=firefox_binary)
        web_driver = EnhancedWebDriver(driver, should_hide_window)

        super(FacebookScrapingWebDriver, self).__init__(web_driver, should_hide_window)
        self.implicitly_wait(5)

 def __init__(self,test,browser_name,url,test_data=None):
     super(FrameworkTests,self).__init__(test)
     self.test=test
     self.browser_name=browser_name
     self.url=url
     self.driver=None
     if self.browser_name=='firefox':
         ffp = FirefoxProfile()
         ffp.update_preferences()
         self.driver = Firefox(firefox_profile=ffp)
     elif self.browser_name=='chrome':
         chromedriver = load_browser_driver("chromedriver")
         os.environ["webdriver.chrome.driver"] = chromedriver
         self.driver=Chrome(chromedriver)
     elif self.browser_name=='ie':
         iedriver = load_browser_driver("IEDriverServer")
         os.environ["webdriver.ie.driver"] = iedriver
         self.driver=Ie(iedriver)
     self.verification = []
     self.verification.append("Test %s on browser %s" %(self.test,self.browser_name))
     self.test_data=test_data
     self.errors=[]

 def load_cookie(self, session_id):
     sessions = json.load(open( self.sessions_file ))
     cookie_path = sessions[str(session_id)]["session_path"]
     url = sessions[str(session_id)]["web_url"]
     # Setting useragent to the same one the session saved with
     useragent = sessions[str(session_id)]["useragent"]
     profile = FirefoxProfile()
     profile.set_preference("general.useragent.override", useragent )
     cookies = pickle.load(open(cookie_path, "rb"))
     try:
         browser = Firefox(profile)
     except:
         error("Couldn't open browser to view session!")
         return
     browser.get(url)
     browser.delete_all_cookies()
     browser.execute_script("window.localStorage.clear()") # clear the current localStorage
     for cookie in cookies:
         browser.add_cookie(cookie)
     status(f"Session {session_id} loaded")
     browser.refresh()
     self.browsers.append(browser)

    def setUp(self):
        if os.environ.get("SELENIUM_HEADLESS"):
            self.driver = webdriver.PhantomJS()
        else:
            self.profile = FirefoxProfile();
            self.profile.set_preference("intl.accept_languages", "en")
            self.driver = webdriver.Firefox(self.profile)

        self.driver.set_window_size(1600, 1200)
        self.driver.implicitly_wait(30)
        self.base_url = "http://localhost:5000/"
        self.verificationErrors = []
        self.accept_next_alert = True