blob: eb9bb53a0e50d419bfe3fffc36ba27d72e9fb5a0 [file] [log] [blame]
# Copyright 2008-2011 WebDriver committers
# Copyright 2008-2011 Google Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import with_statement
import base64
import copy
import os
import re
import shutil
import tempfile
import zipfile
from cStringIO import StringIO
from xml.dom import minidom
from distutils import dir_util
from selenium.webdriver.common.proxy import ProxyType
from selenium.common.exceptions import WebDriverException
WEBDRIVER_EXT = "webdriver.xpi"
class FirefoxProfile(object):
"": "false",
"app.update.enabled": "false",
"": "false",
"browser.EULA.override": "true",
"browser.EULA.3.accepted": "true",
"": "2",
"": "2",
"browser.offline": "false",
"browser.safebrowsing.enabled": "false",
"": "false",
"extensions.blocklist.enabled": "false",
"browser.sessionstore.resume_from_crash": "false",
"": "false",
"browser.tabs.warnOnClose": "false",
"browser.tabs.warnOnOpen": "false",
"": "0",
"browser.safebrowsing.malware.enabled": "false",
"startup.homepage_welcome_url": "\"about:blank\"",
"devtools.errorconsole.enabled": "true",
"dom.disable_open_during_load": "false",
"extensions.autoDisableScopes" : 10,
"extensions.logging.enabled": "true",
"extensions.update.enabled": "false",
"extensions.update.notifyUser": "false",
"network.manage-offline-status": "false",
"network.http.max-connections-per-server": "10",
"network.http.phishy-userpass-length": "255",
"offline-apps.allow_by_default": "true",
"prompts.tab_modal.enabled": "false",
"security.fileuri.origin_policy": "3",
"security.fileuri.strict_origin_policy": "false",
"security.warn_entering_secure": "false",
"security.warn_entering_secure.show_once": "false",
"security.warn_entering_weak": "false",
"security.warn_entering_weak.show_once": "false",
"security.warn_leaving_secure": "false",
"security.warn_leaving_secure.show_once": "false",
"security.warn_submit_insecure": "false",
"security.warn_viewing_mixed": "false",
"security.warn_viewing_mixed.show_once": "false",
"signon.rememberSignons": "false",
"toolkit.networkmanager.disable": "true",
"toolkit.telemetry.enabled": "false",
"toolkit.telemetry.prompted": "2",
"toolkit.telemetry.rejected": "true",
"javascript.options.showInConsole": "true",
"browser.dom.window.dump.enabled": "true",
"webdriver_accept_untrusted_certs": "true",
"webdriver_enable_native_events": "true",
"webdriver_assume_untrusted_issuer": "true",
"dom.max_script_run_time": "30",
def __init__(self,profile_directory=None):
Initialises a new instance of a Firefox Profile
- profile_directory: Directory of profile that you want to use.
This defaults to None and will create a new
directory when object is created.
self.default_preferences = copy.deepcopy(
self.profile_dir = profile_directory
if self.profile_dir is None:
self.profile_dir = self._create_tempfolder()
newprof = os.path.join(tempfile.mkdtemp(),
shutil.copytree(self.profile_dir, newprof,
ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock"))
self.profile_dir = newprof
self.extensionsDir = os.path.join(self.profile_dir, "extensions")
self.userPrefs = os.path.join(self.profile_dir, "user.js")
#Public Methods
def set_preference(self, key, value):
sets the preference that we want in the profile.
clean_value = ''
if value is True:
clean_value = 'true'
elif value is False:
clean_value = 'false'
elif isinstance(value, str):
clean_value = '"%s"' % value
elif isinstance(value, unicode):
clean_value = '"%s"' % value
clean_value = str(int(value))
self.default_preferences[key] = clean_value
def add_extension(self, extension=WEBDRIVER_EXT):
def update_preferences(self):
def path(self):
Gets the profile directory that is currently being used
return self.profile_dir
def port(self):
Gets the port that WebDriver is working on
return self._port
def port(self, port):
Sets the port that WebDriver will be running on
if not isinstance(port, int):
raise WebDriverException("Port needs to be an integer")
self._port = port
self.set_preference("webdriver_firefox_port", self._port)
def accept_untrusted_certs(self):
return self._santise_pref(
def accept_untrusted_certs(self, value):
if value not in [True, False]:
raise WebDriverException("Please pass in a Boolean to this call")
self.set_preference("webdriver_accept_untrusted_certs", value)
def assume_untrusted_cert_issuer(self):
return self._santise_pref(self.default_preferences["webdriver_assume_untrusted_issuer"])
def assume_untrusted_cert_issuer(self, value):
if value not in [True, False]:
raise WebDriverException("Please pass in a Boolean to this call")
self.set_preference("webdriver_assume_untrusted_issuer", value)
def native_events_enabled(self):
return self._santise_pref(self.default_preferences['webdriver_enable_native_events'])
def native_events_enabled(self, value):
if value not in [True, False]:
raise WebDriverException("Please pass in a Boolean to this call")
self.set_preference("webdriver_enable_native_events", value)
def encoded(self):
A zipped, base64 encoded string of profile directory
for use with remote WebDriver JSON wire protocol
fp = StringIO()
zipped = zipfile.ZipFile(fp, 'w', zipfile.ZIP_DEFLATED)
path_root = len(self.path) + 1 # account for trailing slash
for base, dirs, files in os.walk(self.path):
for fyle in files:
filename = os.path.join(base, fyle)
zipped.write(filename, filename[path_root:])
return base64.encodestring(fp.getvalue())
def set_proxy(self, proxy):
import warnings
warnings.warn("This method has been deprecated. Please pass in the proxy object to the Driver Object",
if proxy is None:
raise ValueError("proxy can not be None")
if proxy.proxy_type is ProxyType.UNSPECIFIED:
self.set_preference("network.proxy.type", proxy.proxy_type['ff_value'])
if proxy.proxy_type is ProxyType.MANUAL:
self.set_preference("network.proxy.no_proxies_on", proxy.no_proxy)
self._set_manual_proxy_preference("ftp", proxy.ftp_proxy)
self._set_manual_proxy_preference("http", proxy.http_proxy)
self._set_manual_proxy_preference("ssl", proxy.ssl_proxy)
elif proxy.proxy_type is ProxyType.AUTODETECT:
self.set_preference("network.proxy.autoconfig_url", proxy.proxy_autoconfig_url)
#Private Methods
def _santise_pref(self, item):
if item == 'true':
return True
elif item == 'false':
return False
return item
def _set_manual_proxy_preference(self, key, setting):
if setting is None or setting is '':
host_details = setting.split(":")
self.set_preference("network.proxy.%s" % key, host_details[1][2:])
if len(host_details) > 1:
self.set_preference("network.proxy.%s_port" % key, int(host_details[2]))
def _create_tempfolder(self):
Creates a temp folder to store User.js and the extension
return tempfile.mkdtemp()
def _write_user_prefs(self, user_prefs):
writes the current user prefs dictionary to disk
with open(self.userPrefs, "w") as f:
for key, value in user_prefs.items():
f.write('user_pref("%s", %s);\n' % (key, value))
def _read_existing_userjs(self):
userjs_path = os.path.join(self.profile_dir, 'user.js')
PREF_RE = re.compile(r'user_pref\("(.*)",\s(.*)\)')
with open(userjs_path) as f:
for usr in f:
matches =, usr)
self.default_preferences[] =
# The profile given hasn't had any changes made, i.e no users.js
def _install_extension(self, addon, unpack=True):
Installs addon from a filepath, url
or directory of addons in the profile.
- path: url, path to .xpi, or directory of addons
- unpack: whether to unpack unless specified otherwise in the install.rdf
if addon == WEBDRIVER_EXT:
addon = os.path.join(os.path.dirname(__file__), WEBDRIVER_EXT)
tmpdir = None
xpifile = None
if addon.endswith('.xpi'):
tmpdir = tempfile.mkdtemp(suffix = '.' + os.path.split(addon)[-1])
compressed_file = zipfile.ZipFile(addon, 'r')
for name in compressed_file.namelist():
if name.endswith('/'):
os.makedirs(os.path.join(tmpdir, name))
if not os.path.isdir(os.path.dirname(os.path.join(tmpdir, name))):
os.makedirs(os.path.dirname(os.path.join(tmpdir, name)))
data =
with open(os.path.join(tmpdir, name), 'wb') as f:
xpifile = addon
addon = tmpdir
# determine the addon id
addon_details = self._addon_details(addon)
addon_id = addon_details.get('id')
assert addon_id, 'The addon id could not be found: %s' % addon
# copy the addon to the profile
extensions_path = os.path.join(self.profile_dir, 'extensions')
addon_path = os.path.join(extensions_path, addon_id)
if not unpack and not addon_details['unpack'] and xpifile:
if not os.path.exists(extensions_path):
shutil.copy(xpifile, addon_path + '.xpi')
dir_util.copy_tree(addon, addon_path, preserve_symlinks=1)
# remove the temporary directory, if any
if tmpdir:
def _addon_details(self, addon_path):
returns a dictionary of details about the addon
- addon_path : path to the addon directory
{'id': u'', # id of the addon
'version': u'1.4', # version of the addon
'name': u'Rainbow', # name of the addon
'unpack': False } # whether to unpack the addon
# TODO: We don't use the unpack variable yet, but we should: bug 662683
details = {
'id': None,
'name': None,
'unpack': True,
'version': None
def get_namespace_id(doc, url):
attributes = doc.documentElement.attributes
namespace = ""
for i in range(attributes.length):
if attributes.item(i).value == url:
if ":" in attributes.item(i).name:
# If the namespace is not the default one remove 'xlmns:'
namespace = attributes.item(i).name.split(':')[1] + ":"
return namespace
def get_text(element):
"""Retrieve the text value of a given node"""
rc = []
for node in element.childNodes:
if node.nodeType == node.TEXT_NODE:
return ''.join(rc).strip()
doc = minidom.parse(os.path.join(addon_path, 'install.rdf'))
# Get the namespaces abbreviations
em = get_namespace_id(doc, "")
rdf = get_namespace_id(doc, "")
description = doc.getElementsByTagName(rdf + "Description").item(0)
for node in description.childNodes:
# Remove the namespace prefix from the tag for comparison
entry = node.nodeName.replace(em, "")
if entry in details.keys():
details.update({ entry: get_text(node) })
return details