moving to scripts
This commit is contained in:
eneller
@@ -0,0 +1,16 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,84 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import logging
|
||||
import time
|
||||
|
||||
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
|
||||
from selenium.webdriver.common import utils
|
||||
from selenium.webdriver.remote.command import Command
|
||||
from selenium.webdriver.remote.remote_connection import RemoteConnection
|
||||
from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
|
||||
|
||||
LOGGER = logging.getLogger(__name__)
|
||||
PORT = 0
|
||||
HOST = None
|
||||
_URL = ""
|
||||
|
||||
|
||||
class ExtensionConnection(RemoteConnection):
|
||||
def __init__(self, host, firefox_profile, firefox_binary=None, timeout=30):
|
||||
self.profile = firefox_profile
|
||||
self.binary = firefox_binary
|
||||
HOST = host
|
||||
timeout = int(timeout)
|
||||
|
||||
if not self.binary:
|
||||
self.binary = FirefoxBinary()
|
||||
|
||||
if not HOST:
|
||||
HOST = "127.0.0.1"
|
||||
|
||||
PORT = utils.free_port()
|
||||
self.profile.port = PORT
|
||||
self.profile.update_preferences()
|
||||
|
||||
self.profile.add_extension()
|
||||
|
||||
self.binary.launch_browser(self.profile, timeout=timeout)
|
||||
_URL = "http://%s:%d/hub" % (HOST, PORT)
|
||||
RemoteConnection.__init__(
|
||||
self, _URL, keep_alive=True)
|
||||
|
||||
def quit(self, sessionId=None):
|
||||
self.execute(Command.QUIT, {'sessionId': sessionId})
|
||||
while self.is_connectable():
|
||||
LOGGER.info("waiting to quit")
|
||||
time.sleep(1)
|
||||
|
||||
def connect(self):
|
||||
"""Connects to the extension and retrieves the session id."""
|
||||
return self.execute(Command.NEW_SESSION,
|
||||
{'desiredCapabilities': DesiredCapabilities.FIREFOX})
|
||||
|
||||
@classmethod
|
||||
def connect_and_quit(self):
|
||||
"""Connects to an running browser and quit immediately."""
|
||||
self._request('%s/extensions/firefox/quit' % _URL)
|
||||
|
||||
@classmethod
|
||||
def is_connectable(self):
|
||||
"""Tries to connect to the extension but do not retrieve context."""
|
||||
utils.is_connectable(self.profile.port)
|
||||
|
||||
|
||||
class ExtensionConnectionError(Exception):
|
||||
"""An internal error occurred int the extension.
|
||||
|
||||
Might be caused by bad input or bugs in webdriver
|
||||
"""
|
||||
pass
|
||||
@@ -0,0 +1,218 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
|
||||
import os
|
||||
from platform import system
|
||||
from subprocess import Popen, STDOUT
|
||||
from selenium.common.exceptions import WebDriverException
|
||||
from selenium.webdriver.common import utils
|
||||
import time
|
||||
|
||||
|
||||
class FirefoxBinary(object):
|
||||
|
||||
NO_FOCUS_LIBRARY_NAME = "x_ignore_nofocus.so"
|
||||
|
||||
def __init__(self, firefox_path=None, log_file=None):
|
||||
"""
|
||||
Creates a new instance of Firefox binary.
|
||||
|
||||
:Args:
|
||||
- firefox_path - Path to the Firefox executable. By default, it will be detected from the standard locations.
|
||||
- log_file - A file object to redirect the firefox process output to. It can be sys.stdout.
|
||||
Please note that with parallel run the output won't be synchronous.
|
||||
By default, it will be redirected to /dev/null.
|
||||
"""
|
||||
self._start_cmd = firefox_path
|
||||
# We used to default to subprocess.PIPE instead of /dev/null, but after
|
||||
# a while the pipe would fill up and Firefox would freeze.
|
||||
self._log_file = log_file or open(os.devnull, "wb")
|
||||
self.command_line = None
|
||||
self.platform = system().lower()
|
||||
if not self._start_cmd:
|
||||
self._start_cmd = self._get_firefox_start_cmd()
|
||||
if not self._start_cmd.strip():
|
||||
raise WebDriverException(
|
||||
"Failed to find firefox binary. You can set it by specifying "
|
||||
"the path to 'firefox_binary':\n\nfrom "
|
||||
"selenium.webdriver.firefox.firefox_binary import "
|
||||
"FirefoxBinary\n\nbinary = "
|
||||
"FirefoxBinary('/path/to/binary')\ndriver = "
|
||||
"webdriver.Firefox(firefox_binary=binary)")
|
||||
# Rather than modifying the environment of the calling Python process
|
||||
# copy it and modify as needed.
|
||||
self._firefox_env = os.environ.copy()
|
||||
self._firefox_env["MOZ_CRASHREPORTER_DISABLE"] = "1"
|
||||
self._firefox_env["MOZ_NO_REMOTE"] = "1"
|
||||
self._firefox_env["NO_EM_RESTART"] = "1"
|
||||
|
||||
def add_command_line_options(self, *args):
|
||||
self.command_line = args
|
||||
|
||||
def launch_browser(self, profile, timeout=30):
|
||||
"""Launches the browser for the given profile name.
|
||||
It is assumed the profile already exists.
|
||||
"""
|
||||
self.profile = profile
|
||||
|
||||
self._start_from_profile_path(self.profile.path)
|
||||
self._wait_until_connectable(timeout=timeout)
|
||||
|
||||
def kill(self):
|
||||
"""Kill the browser.
|
||||
|
||||
This is useful when the browser is stuck.
|
||||
"""
|
||||
if self.process:
|
||||
self.process.kill()
|
||||
self.process.wait()
|
||||
|
||||
def _start_from_profile_path(self, path):
|
||||
self._firefox_env["XRE_PROFILE_PATH"] = path
|
||||
|
||||
if self.platform == 'linux':
|
||||
self._modify_link_library_path()
|
||||
command = [self._start_cmd, "-foreground"]
|
||||
if self.command_line:
|
||||
for cli in self.command_line:
|
||||
command.append(cli)
|
||||
self.process = Popen(
|
||||
command, stdout=self._log_file, stderr=STDOUT,
|
||||
env=self._firefox_env)
|
||||
|
||||
def _wait_until_connectable(self, timeout=30):
|
||||
"""Blocks until the extension is connectable in the firefox."""
|
||||
count = 0
|
||||
while not utils.is_connectable(self.profile.port):
|
||||
if self.process.poll():
|
||||
# Browser has exited
|
||||
raise WebDriverException(
|
||||
"The browser appears to have exited "
|
||||
"before we could connect. If you specified a log_file in "
|
||||
"the FirefoxBinary constructor, check it for details.")
|
||||
if count >= timeout:
|
||||
self.kill()
|
||||
raise WebDriverException(
|
||||
"Can't load the profile. Possible firefox version mismatch. "
|
||||
"You must use GeckoDriver instead for Firefox 48+. Profile "
|
||||
"Dir: %s If you specified a log_file in the "
|
||||
"FirefoxBinary constructor, check it for details."
|
||||
% (self.profile.path))
|
||||
count += 1
|
||||
time.sleep(1)
|
||||
return True
|
||||
|
||||
def _find_exe_in_registry(self):
|
||||
try:
|
||||
from _winreg import OpenKey, QueryValue, HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER
|
||||
except ImportError:
|
||||
from winreg import OpenKey, QueryValue, HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER
|
||||
import shlex
|
||||
keys = (r"SOFTWARE\Classes\FirefoxHTML\shell\open\command",
|
||||
r"SOFTWARE\Classes\Applications\firefox.exe\shell\open\command")
|
||||
command = ""
|
||||
for path in keys:
|
||||
try:
|
||||
key = OpenKey(HKEY_LOCAL_MACHINE, path)
|
||||
command = QueryValue(key, "")
|
||||
break
|
||||
except OSError:
|
||||
try:
|
||||
key = OpenKey(HKEY_CURRENT_USER, path)
|
||||
command = QueryValue(key, "")
|
||||
break
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
return ""
|
||||
|
||||
if not command:
|
||||
return ""
|
||||
|
||||
return shlex.split(command)[0]
|
||||
|
||||
def _get_firefox_start_cmd(self):
|
||||
"""Return the command to start firefox."""
|
||||
start_cmd = ""
|
||||
if self.platform == "darwin": # small darwin due to lower() in self.platform
|
||||
start_cmd = "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
|
||||
# fallback to homebrew installation for mac users
|
||||
if not os.path.exists(start_cmd):
|
||||
start_cmd = os.path.expanduser("~") + start_cmd
|
||||
elif self.platform == "windows": # same
|
||||
start_cmd = (self._find_exe_in_registry() or self._default_windows_location())
|
||||
elif self.platform == 'java' and os._name == 'nt':
|
||||
start_cmd = self._default_windows_location()
|
||||
else:
|
||||
for ffname in ["firefox", "iceweasel"]:
|
||||
start_cmd = self.which(ffname)
|
||||
if start_cmd:
|
||||
break
|
||||
else:
|
||||
# couldn't find firefox on the system path
|
||||
raise RuntimeError(
|
||||
"Could not find firefox in your system PATH."
|
||||
" Please specify the firefox binary location or install firefox")
|
||||
return start_cmd
|
||||
|
||||
def _default_windows_location(self):
|
||||
program_files = [os.getenv("PROGRAMFILES", r"C:\Program Files"),
|
||||
os.getenv("PROGRAMFILES(X86)", r"C:\Program Files (x86)")]
|
||||
for path in program_files:
|
||||
binary_path = os.path.join(path, r"Mozilla Firefox\firefox.exe")
|
||||
if os.access(binary_path, os.X_OK):
|
||||
return binary_path
|
||||
return ""
|
||||
|
||||
def _modify_link_library_path(self):
|
||||
existing_ld_lib_path = os.environ.get('LD_LIBRARY_PATH', '')
|
||||
|
||||
new_ld_lib_path = self._extract_and_check(
|
||||
self.profile, self.NO_FOCUS_LIBRARY_NAME, "x86", "amd64")
|
||||
|
||||
new_ld_lib_path += existing_ld_lib_path
|
||||
|
||||
self._firefox_env["LD_LIBRARY_PATH"] = new_ld_lib_path
|
||||
self._firefox_env['LD_PRELOAD'] = self.NO_FOCUS_LIBRARY_NAME
|
||||
|
||||
def _extract_and_check(self, profile, no_focus_so_name, x86, amd64):
|
||||
|
||||
paths = [x86, amd64]
|
||||
built_path = ""
|
||||
for path in paths:
|
||||
library_path = os.path.join(profile.path, path)
|
||||
if not os.path.exists(library_path):
|
||||
os.makedirs(library_path)
|
||||
import shutil
|
||||
shutil.copy(os.path.join(
|
||||
os.path.dirname(__file__),
|
||||
path,
|
||||
self.NO_FOCUS_LIBRARY_NAME),
|
||||
library_path)
|
||||
built_path += library_path + ":"
|
||||
|
||||
return built_path
|
||||
|
||||
def which(self, fname):
|
||||
"""Returns the fully qualified path by searching Path of the given
|
||||
name"""
|
||||
for pe in os.environ['PATH'].split(os.pathsep):
|
||||
checkname = os.path.join(pe, fname)
|
||||
if os.access(checkname, os.X_OK) and not os.path.isdir(checkname):
|
||||
return checkname
|
||||
return None
|
||||
@@ -0,0 +1,366 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import base64
|
||||
import copy
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
import warnings
|
||||
import zipfile
|
||||
from io import BytesIO
|
||||
from xml.dom import minidom
|
||||
|
||||
from selenium.common.exceptions import WebDriverException
|
||||
|
||||
|
||||
WEBDRIVER_EXT = "webdriver.xpi"
|
||||
WEBDRIVER_PREFERENCES = "webdriver_prefs.json"
|
||||
EXTENSION_NAME = "fxdriver@googlecode.com"
|
||||
|
||||
|
||||
class AddonFormatError(Exception):
|
||||
"""Exception for not well-formed add-on manifest files"""
|
||||
|
||||
|
||||
class FirefoxProfile(object):
|
||||
ANONYMOUS_PROFILE_NAME = "WEBDRIVER_ANONYMOUS_PROFILE"
|
||||
DEFAULT_PREFERENCES = None
|
||||
|
||||
def __init__(self, profile_directory=None):
|
||||
"""
|
||||
Initialises a new instance of a Firefox Profile
|
||||
|
||||
:args:
|
||||
- profile_directory: Directory of profile that you want to use. If a
|
||||
directory is passed in it will be cloned and the cloned directory
|
||||
will be used by the driver when instantiated.
|
||||
This defaults to None and will create a new
|
||||
directory when object is created.
|
||||
"""
|
||||
warnings.warn('firefox_profile has been deprecated, please use an Options object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
if not FirefoxProfile.DEFAULT_PREFERENCES:
|
||||
with open(os.path.join(os.path.dirname(__file__),
|
||||
WEBDRIVER_PREFERENCES)) as default_prefs:
|
||||
FirefoxProfile.DEFAULT_PREFERENCES = json.load(default_prefs)
|
||||
|
||||
self.default_preferences = copy.deepcopy(
|
||||
FirefoxProfile.DEFAULT_PREFERENCES['mutable'])
|
||||
self.profile_dir = profile_directory
|
||||
self.tempfolder = None
|
||||
if not self.profile_dir:
|
||||
self.profile_dir = self._create_tempfolder()
|
||||
else:
|
||||
self.tempfolder = tempfile.mkdtemp()
|
||||
newprof = os.path.join(self.tempfolder, "webdriver-py-profilecopy")
|
||||
shutil.copytree(self.profile_dir, newprof,
|
||||
ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock"))
|
||||
self.profile_dir = newprof
|
||||
os.chmod(self.profile_dir, 0o755)
|
||||
self._read_existing_userjs(os.path.join(self.profile_dir, "user.js"))
|
||||
self.extensionsDir = os.path.join(self.profile_dir, "extensions")
|
||||
self.userPrefs = os.path.join(self.profile_dir, "user.js")
|
||||
if os.path.isfile(self.userPrefs):
|
||||
os.chmod(self.userPrefs, 0o644)
|
||||
|
||||
# Public Methods
|
||||
def set_preference(self, key, value):
|
||||
"""
|
||||
sets the preference that we want in the profile.
|
||||
"""
|
||||
self.default_preferences[key] = value
|
||||
|
||||
def add_extension(self, extension=WEBDRIVER_EXT):
|
||||
self._install_extension(extension)
|
||||
|
||||
def update_preferences(self):
|
||||
for key, value in FirefoxProfile.DEFAULT_PREFERENCES['frozen'].items():
|
||||
# Do not update key that is being set by the user using
|
||||
# set_preference as users are unaware of the freeze properties
|
||||
# and it leads to an inconsistent behavior
|
||||
if key not in self.default_preferences:
|
||||
self.default_preferences[key] = value
|
||||
self._write_user_prefs(self.default_preferences)
|
||||
|
||||
# Properties
|
||||
|
||||
@property
|
||||
def path(self):
|
||||
"""
|
||||
Gets the profile directory that is currently being used
|
||||
"""
|
||||
return self.profile_dir
|
||||
|
||||
@property
|
||||
def port(self):
|
||||
"""
|
||||
Gets the port that WebDriver is working on
|
||||
"""
|
||||
return self._port
|
||||
|
||||
@port.setter
|
||||
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")
|
||||
try:
|
||||
port = int(port)
|
||||
if port < 1 or port > 65535:
|
||||
raise WebDriverException("Port number must be in the range 1..65535")
|
||||
except (ValueError, TypeError):
|
||||
raise WebDriverException("Port needs to be an integer")
|
||||
self._port = port
|
||||
self.set_preference("webdriver_firefox_port", self._port)
|
||||
|
||||
@property
|
||||
def accept_untrusted_certs(self):
|
||||
return self.default_preferences["webdriver_accept_untrusted_certs"]
|
||||
|
||||
@accept_untrusted_certs.setter
|
||||
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)
|
||||
|
||||
@property
|
||||
def assume_untrusted_cert_issuer(self):
|
||||
return self.default_preferences["webdriver_assume_untrusted_issuer"]
|
||||
|
||||
@assume_untrusted_cert_issuer.setter
|
||||
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)
|
||||
|
||||
@property
|
||||
def encoded(self):
|
||||
"""
|
||||
A zipped, base64 encoded string of profile directory
|
||||
for use with remote WebDriver JSON wire protocol
|
||||
"""
|
||||
self.update_preferences()
|
||||
fp = BytesIO()
|
||||
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:])
|
||||
zipped.close()
|
||||
return base64.b64encode(fp.getvalue()).decode('UTF-8')
|
||||
|
||||
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, json.dumps(value)))
|
||||
|
||||
def _read_existing_userjs(self, userjs):
|
||||
import warnings
|
||||
|
||||
PREF_RE = re.compile(r'user_pref\("(.*)",\s(.*)\)')
|
||||
try:
|
||||
with open(userjs) as f:
|
||||
for usr in f:
|
||||
matches = re.search(PREF_RE, usr)
|
||||
try:
|
||||
self.default_preferences[matches.group(1)] = json.loads(matches.group(2))
|
||||
except Exception:
|
||||
warnings.warn("(skipping) failed to json.loads existing preference: %s" %
|
||||
matches.group(1) + matches.group(2))
|
||||
except Exception:
|
||||
# The profile given hasn't had any changes made, i.e no users.js
|
||||
pass
|
||||
|
||||
def _install_extension(self, addon, unpack=True):
|
||||
"""
|
||||
Installs addon from a filepath, url
|
||||
or directory of addons in the profile.
|
||||
- path: url, absolute 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('/'):
|
||||
if not os.path.isdir(os.path.join(tmpdir, name)):
|
||||
os.makedirs(os.path.join(tmpdir, name))
|
||||
else:
|
||||
if not os.path.isdir(os.path.dirname(os.path.join(tmpdir, name))):
|
||||
os.makedirs(os.path.dirname(os.path.join(tmpdir, name)))
|
||||
data = compressed_file.read(name)
|
||||
with open(os.path.join(tmpdir, name), 'wb') as f:
|
||||
f.write(data)
|
||||
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
|
||||
addon_path = os.path.join(self.extensionsDir, addon_id)
|
||||
if not unpack and not addon_details['unpack'] and xpifile:
|
||||
if not os.path.exists(self.extensionsDir):
|
||||
os.makedirs(self.extensionsDir)
|
||||
os.chmod(self.extensionsDir, 0o755)
|
||||
shutil.copy(xpifile, addon_path + '.xpi')
|
||||
else:
|
||||
if not os.path.exists(addon_path):
|
||||
shutil.copytree(addon, addon_path, symlinks=True)
|
||||
|
||||
# remove the temporary directory, if any
|
||||
if tmpdir:
|
||||
shutil.rmtree(tmpdir)
|
||||
|
||||
def _addon_details(self, addon_path):
|
||||
"""
|
||||
Returns a dictionary of details about the addon.
|
||||
|
||||
:param addon_path: path to the add-on directory or XPI
|
||||
|
||||
Returns::
|
||||
|
||||
{'id': u'rainbow@colors.org', # 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
|
||||
"""
|
||||
|
||||
details = {
|
||||
'id': None,
|
||||
'unpack': False,
|
||||
'name': None,
|
||||
'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] + ":"
|
||||
break
|
||||
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:
|
||||
rc.append(node.data)
|
||||
return ''.join(rc).strip()
|
||||
|
||||
def parse_manifest_json(content):
|
||||
"""Extracts the details from the contents of a WebExtensions `manifest.json` file."""
|
||||
manifest = json.loads(content)
|
||||
try:
|
||||
id = manifest['applications']['gecko']['id']
|
||||
except KeyError:
|
||||
id = manifest['name'].replace(" ", "") + "@" + manifest['version']
|
||||
return {
|
||||
'id': id,
|
||||
'version': manifest['version'],
|
||||
'name': manifest['version'],
|
||||
'unpack': False,
|
||||
}
|
||||
|
||||
if not os.path.exists(addon_path):
|
||||
raise IOError('Add-on path does not exist: %s' % addon_path)
|
||||
|
||||
try:
|
||||
if zipfile.is_zipfile(addon_path):
|
||||
# Bug 944361 - We cannot use 'with' together with zipFile because
|
||||
# it will cause an exception thrown in Python 2.6.
|
||||
# TODO: use with statement when Python 2.x is no longer supported
|
||||
try:
|
||||
compressed_file = zipfile.ZipFile(addon_path, 'r')
|
||||
if 'manifest.json' in compressed_file.namelist():
|
||||
return parse_manifest_json(compressed_file.read('manifest.json'))
|
||||
|
||||
manifest = compressed_file.read('install.rdf')
|
||||
finally:
|
||||
compressed_file.close()
|
||||
elif os.path.isdir(addon_path):
|
||||
manifest_json_filename = os.path.join(addon_path, 'manifest.json')
|
||||
if os.path.exists(manifest_json_filename):
|
||||
with open(manifest_json_filename, 'r') as f:
|
||||
return parse_manifest_json(f.read())
|
||||
|
||||
with open(os.path.join(addon_path, 'install.rdf'), 'r') as f:
|
||||
manifest = f.read()
|
||||
else:
|
||||
raise IOError('Add-on path is neither an XPI nor a directory: %s' % addon_path)
|
||||
except (IOError, KeyError) as e:
|
||||
raise AddonFormatError(str(e), sys.exc_info()[2])
|
||||
|
||||
try:
|
||||
doc = minidom.parseString(manifest)
|
||||
|
||||
# Get the namespaces abbreviations
|
||||
em = get_namespace_id(doc, 'http://www.mozilla.org/2004/em-rdf#')
|
||||
rdf = get_namespace_id(doc, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
|
||||
|
||||
description = doc.getElementsByTagName(rdf + 'Description').item(0)
|
||||
if not description:
|
||||
description = doc.getElementsByTagName('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)})
|
||||
if not details.get('id'):
|
||||
for i in range(description.attributes.length):
|
||||
attribute = description.attributes.item(i)
|
||||
if attribute.name == em + 'id':
|
||||
details.update({'id': attribute.value})
|
||||
except Exception as e:
|
||||
raise AddonFormatError(str(e), sys.exc_info()[2])
|
||||
|
||||
# turn unpack into a true/false value
|
||||
if isinstance(details['unpack'], str):
|
||||
details['unpack'] = details['unpack'].lower() == 'true'
|
||||
|
||||
# If no ID is set, the add-on is invalid
|
||||
if not details.get('id'):
|
||||
raise AddonFormatError('Add-on id could not be found.')
|
||||
|
||||
return details
|
||||
@@ -0,0 +1,166 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
from typing import Union
|
||||
import warnings
|
||||
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
|
||||
from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
|
||||
from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
|
||||
from selenium.webdriver.common.options import ArgOptions
|
||||
|
||||
|
||||
class Log(object):
|
||||
def __init__(self):
|
||||
self.level = None
|
||||
|
||||
def to_capabilities(self) -> dict:
|
||||
if self.level:
|
||||
return {"log": {"level": self.level}}
|
||||
return {}
|
||||
|
||||
|
||||
class Options(ArgOptions):
|
||||
KEY = "moz:firefoxOptions"
|
||||
|
||||
def __init__(self):
|
||||
super(Options, self).__init__()
|
||||
self._binary: FirefoxBinary = None
|
||||
self._preferences: dict = {}
|
||||
self._profile = None
|
||||
self._proxy = None
|
||||
self.log = Log()
|
||||
|
||||
@property
|
||||
def binary(self) -> FirefoxBinary:
|
||||
"""Returns the FirefoxBinary instance"""
|
||||
return self._binary
|
||||
|
||||
@binary.setter
|
||||
def binary(self, new_binary: Union[str, FirefoxBinary]):
|
||||
"""Sets location of the browser binary, either by string or
|
||||
``FirefoxBinary`` instance.
|
||||
|
||||
"""
|
||||
if not isinstance(new_binary, FirefoxBinary):
|
||||
new_binary = FirefoxBinary(new_binary)
|
||||
self._binary = new_binary
|
||||
|
||||
@property
|
||||
def binary_location(self) -> str:
|
||||
"""
|
||||
:Returns: The location of the binary.
|
||||
"""
|
||||
return self.binary._start_cmd
|
||||
|
||||
@binary_location.setter # noqa
|
||||
def binary_location(self, value: str):
|
||||
""" Sets the location of the browser binary by string """
|
||||
self.binary = value
|
||||
|
||||
@property
|
||||
def preferences(self) -> dict:
|
||||
""":Returns: A dict of preferences."""
|
||||
return self._preferences
|
||||
|
||||
def set_preference(self, name: str, value: Union[str, int, bool]):
|
||||
"""Sets a preference."""
|
||||
self._preferences[name] = value
|
||||
|
||||
@property
|
||||
def profile(self) -> FirefoxProfile:
|
||||
"""
|
||||
:Returns: The Firefox profile to use.
|
||||
"""
|
||||
if self._profile:
|
||||
warnings.warn(
|
||||
"Getting a profile has been deprecated.",
|
||||
DeprecationWarning,
|
||||
stacklevel=2
|
||||
)
|
||||
return self._profile
|
||||
|
||||
@profile.setter
|
||||
def profile(self, new_profile: Union[str, FirefoxProfile]):
|
||||
"""Sets location of the browser profile to use, either by string
|
||||
or ``FirefoxProfile``.
|
||||
|
||||
"""
|
||||
warnings.warn(
|
||||
"Setting a profile has been deprecated. Please use the set_preference and install_addons methods",
|
||||
DeprecationWarning,
|
||||
stacklevel=2
|
||||
)
|
||||
if not isinstance(new_profile, FirefoxProfile):
|
||||
new_profile = FirefoxProfile(new_profile)
|
||||
self._profile = new_profile
|
||||
|
||||
@property
|
||||
def headless(self) -> bool:
|
||||
"""
|
||||
:Returns: True if the headless argument is set, else False
|
||||
"""
|
||||
return '-headless' in self._arguments
|
||||
|
||||
@headless.setter
|
||||
def headless(self, value: bool):
|
||||
"""
|
||||
Sets the headless argument
|
||||
|
||||
Args:
|
||||
value: boolean value indicating to set the headless option
|
||||
"""
|
||||
if value:
|
||||
self._arguments.append('-headless')
|
||||
elif '-headless' in self._arguments:
|
||||
self._arguments.remove('-headless')
|
||||
|
||||
def enable_mobile(self, android_package: str = "org.mozilla.firefox", android_activity=None, device_serial=None):
|
||||
super().enable_mobile(android_package, android_activity, device_serial)
|
||||
|
||||
def to_capabilities(self) -> dict:
|
||||
"""Marshals the Firefox options to a `moz:firefoxOptions`
|
||||
object.
|
||||
"""
|
||||
# This intentionally looks at the internal properties
|
||||
# so if a binary or profile has _not_ been set,
|
||||
# it will defer to geckodriver to find the system Firefox
|
||||
# and generate a fresh profile.
|
||||
caps = self._caps
|
||||
opts = {}
|
||||
|
||||
if self._binary:
|
||||
opts["binary"] = self._binary._start_cmd
|
||||
if self._preferences:
|
||||
opts["prefs"] = self._preferences
|
||||
if self._proxy:
|
||||
self._proxy.add_to_capabilities(caps)
|
||||
if self._profile:
|
||||
opts["profile"] = self._profile.encoded
|
||||
if self._arguments:
|
||||
opts["args"] = self._arguments
|
||||
if self.mobile_options:
|
||||
opts.update(self.mobile_options)
|
||||
|
||||
opts.update(self.log.to_capabilities())
|
||||
|
||||
if opts:
|
||||
caps[Options.KEY] = opts
|
||||
|
||||
return caps
|
||||
|
||||
@property
|
||||
def default_capabilities(self) -> dict:
|
||||
return DesiredCapabilities.FIREFOX.copy()
|
||||
@@ -0,0 +1,36 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
from selenium.webdriver.remote.remote_connection import RemoteConnection
|
||||
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
|
||||
|
||||
|
||||
class FirefoxRemoteConnection(RemoteConnection):
|
||||
|
||||
browser_name = DesiredCapabilities.FIREFOX['browserName']
|
||||
|
||||
def __init__(self, remote_server_addr, keep_alive=True, ignore_proxy=False):
|
||||
RemoteConnection.__init__(self, remote_server_addr, keep_alive, ignore_proxy=ignore_proxy)
|
||||
|
||||
self._commands["GET_CONTEXT"] = ('GET', '/session/$sessionId/moz/context')
|
||||
self._commands["SET_CONTEXT"] = ("POST", "/session/$sessionId/moz/context")
|
||||
self._commands["INSTALL_ADDON"] = \
|
||||
("POST", "/session/$sessionId/moz/addon/install")
|
||||
self._commands["UNINSTALL_ADDON"] = \
|
||||
("POST", "/session/$sessionId/moz/addon/uninstall")
|
||||
self._commands["FULL_PAGE_SCREENSHOT"] = \
|
||||
("GET", "/session/$sessionId/moz/screenshot/full")
|
||||
@@ -0,0 +1,62 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
from typing import List
|
||||
|
||||
from selenium.webdriver.common import (service, utils)
|
||||
|
||||
|
||||
class Service(service.Service):
|
||||
"""Object that manages the starting and stopping of the
|
||||
GeckoDriver."""
|
||||
|
||||
def __init__(self, executable_path: str, port: int = 0, service_args: List[str] = None,
|
||||
log_path: str = "geckodriver.log", env: dict = None):
|
||||
"""Creates a new instance of the GeckoDriver remote service proxy.
|
||||
|
||||
GeckoDriver provides a HTTP interface speaking the W3C WebDriver
|
||||
protocol to Marionette.
|
||||
|
||||
:param executable_path: Path to the GeckoDriver binary.
|
||||
:param port: Run the remote service on a specified port.
|
||||
Defaults to 0, which binds to a random open port of the
|
||||
system's choosing.
|
||||
:param service_args: Optional list of arguments to pass to the
|
||||
GeckoDriver binary.
|
||||
:param log_path: Optional path for the GeckoDriver to log to.
|
||||
Defaults to _geckodriver.log_ in the current working directory.
|
||||
:param env: Optional dictionary of output variables to expose
|
||||
in the services' environment.
|
||||
|
||||
"""
|
||||
log_file = open(log_path, "a+") if log_path else None
|
||||
|
||||
service.Service.__init__(
|
||||
self, executable_path, port=port, log_file=log_file, env=env)
|
||||
self.service_args = service_args or []
|
||||
# Set a port for CDP
|
||||
self.service_args.append("--websocket-port")
|
||||
self.service_args.append("%d" % utils.free_port())
|
||||
# Set the webdriver port
|
||||
self.service_args.append("--port")
|
||||
self.service_args.append("%d" % self.port)
|
||||
|
||||
def command_line_args(self) -> List[str]:
|
||||
return self.service_args
|
||||
|
||||
def send_remote_shutdown_command(self):
|
||||
pass
|
||||
@@ -0,0 +1,333 @@
|
||||
# Licensed to the Software Freedom Conservancy (SFC) under one
|
||||
# or more contributor license agreements. See the NOTICE file
|
||||
# distributed with this work for additional information
|
||||
# regarding copyright ownership. The SFC licenses this file
|
||||
# to you 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
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing,
|
||||
# software distributed under the License is distributed on an
|
||||
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
# KIND, either express or implied. See the License for the
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
from base64 import b64decode
|
||||
from shutil import rmtree
|
||||
import warnings
|
||||
from contextlib import contextmanager
|
||||
from typing import NoReturn
|
||||
|
||||
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
|
||||
from selenium.webdriver.remote.webdriver import WebDriver as RemoteWebDriver
|
||||
|
||||
from .firefox_binary import FirefoxBinary
|
||||
from .firefox_profile import FirefoxProfile
|
||||
from .options import Options
|
||||
from .remote_connection import FirefoxRemoteConnection
|
||||
from .service import Service
|
||||
|
||||
|
||||
# Default for log_path variable. To be deleted when deprecations for arguments are removed.
|
||||
DEFAULT_LOG_PATH = None
|
||||
DEFAULT_EXECUTABLE_PATH = "geckodriver"
|
||||
DEFAULT_SERVICE_LOG_PATH = "geckodriver.log"
|
||||
|
||||
|
||||
class WebDriver(RemoteWebDriver):
|
||||
|
||||
CONTEXT_CHROME = "chrome"
|
||||
CONTEXT_CONTENT = "content"
|
||||
|
||||
def __init__(self, firefox_profile=None, firefox_binary=None,
|
||||
capabilities=None, proxy=None,
|
||||
executable_path=DEFAULT_EXECUTABLE_PATH, options=None,
|
||||
service_log_path=DEFAULT_SERVICE_LOG_PATH,
|
||||
service_args=None, service=None, desired_capabilities=None,
|
||||
log_path=DEFAULT_LOG_PATH, keep_alive=True):
|
||||
"""Starts a new local session of Firefox.
|
||||
|
||||
Based on the combination and specificity of the various keyword
|
||||
arguments, a capabilities dictionary will be constructed that
|
||||
is passed to the remote end.
|
||||
|
||||
The keyword arguments given to this constructor are helpers to
|
||||
more easily allow Firefox WebDriver sessions to be customised
|
||||
with different options. They are mapped on to a capabilities
|
||||
dictionary that is passed on to the remote end.
|
||||
|
||||
As some of the options, such as `firefox_profile` and
|
||||
`options.profile` are mutually exclusive, precedence is
|
||||
given from how specific the setting is. `capabilities` is the
|
||||
least specific keyword argument, followed by `options`,
|
||||
followed by `firefox_binary` and `firefox_profile`.
|
||||
|
||||
In practice this means that if `firefox_profile` and
|
||||
`options.profile` are both set, the selected profile
|
||||
instance will always come from the most specific variable.
|
||||
In this case that would be `firefox_profile`. This will result in
|
||||
`options.profile` to be ignored because it is considered
|
||||
a less specific setting than the top-level `firefox_profile`
|
||||
keyword argument. Similarly, if you had specified a
|
||||
`capabilities["moz:firefoxOptions"]["profile"]` Base64 string,
|
||||
this would rank below `options.profile`.
|
||||
|
||||
:param firefox_profile: Deprecated: Instance of ``FirefoxProfile`` object
|
||||
or a string. If undefined, a fresh profile will be created
|
||||
in a temporary location on the system.
|
||||
:param firefox_binary: Deprecated: Instance of ``FirefoxBinary`` or full
|
||||
path to the Firefox binary. If undefined, the system default
|
||||
Firefox installation will be used.
|
||||
:param capabilities: Deprecated: Dictionary of desired capabilities.
|
||||
:param proxy: Deprecated: The proxy settings to use when communicating with
|
||||
Firefox via the extension connection.
|
||||
:param executable_path: Deprecated: Full path to override which geckodriver
|
||||
binary to use for Firefox 47.0.1 and greater, which
|
||||
defaults to picking up the binary from the system path.
|
||||
:param options: Instance of ``options.Options``.
|
||||
:param service_log_path: Deprecated: Where to log information from the driver.
|
||||
:param service_args: Deprecated: List of args to pass to the driver service
|
||||
:param desired_capabilities: Deprecated: alias of capabilities. In future
|
||||
versions of this library, this will replace 'capabilities'.
|
||||
This will make the signature consistent with RemoteWebDriver.
|
||||
:param keep_alive: Whether to configure remote_connection.RemoteConnection to use
|
||||
HTTP keep-alive.
|
||||
"""
|
||||
|
||||
if executable_path != DEFAULT_EXECUTABLE_PATH:
|
||||
warnings.warn('executable_path has been deprecated, please pass in a Service object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
if capabilities or desired_capabilities:
|
||||
warnings.warn('capabilities and desired_capabilities have been deprecated, please pass in a Service object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
if firefox_binary:
|
||||
warnings.warn('firefox_binary has been deprecated, please pass in a Service object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
self.binary = None
|
||||
if firefox_profile:
|
||||
warnings.warn('firefox_profile has been deprecated, please pass in an Options object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
self.profile = None
|
||||
|
||||
if log_path != DEFAULT_LOG_PATH:
|
||||
warnings.warn('log_path has been deprecated, please pass in a Service object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
|
||||
# Service Arguments being deprecated.
|
||||
if service_log_path != DEFAULT_SERVICE_LOG_PATH:
|
||||
warnings.warn('service_log_path has been deprecated, please pass in a Service object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
if service_args:
|
||||
warnings.warn('service_args has been deprecated, please pass in a Service object',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
|
||||
self.service = service
|
||||
|
||||
# If desired capabilities is set, alias it to capabilities.
|
||||
# If both are set ignore desired capabilities.
|
||||
if not capabilities and desired_capabilities:
|
||||
capabilities = desired_capabilities
|
||||
|
||||
if not capabilities:
|
||||
capabilities = DesiredCapabilities.FIREFOX.copy()
|
||||
if not options:
|
||||
options = Options()
|
||||
|
||||
capabilities = dict(capabilities)
|
||||
|
||||
if capabilities.get("binary"):
|
||||
options.binary = capabilities["binary"]
|
||||
|
||||
# options overrides capabilities
|
||||
if options:
|
||||
if options.binary:
|
||||
self.binary = options.binary
|
||||
if options.profile:
|
||||
self.profile = options.profile
|
||||
|
||||
# firefox_binary and firefox_profile
|
||||
# override options
|
||||
if firefox_binary:
|
||||
if isinstance(firefox_binary, str):
|
||||
firefox_binary = FirefoxBinary(firefox_binary)
|
||||
self.binary = firefox_binary
|
||||
options.binary = firefox_binary
|
||||
if firefox_profile:
|
||||
if isinstance(firefox_profile, str):
|
||||
firefox_profile = FirefoxProfile(firefox_profile)
|
||||
self.profile = firefox_profile
|
||||
options.profile = firefox_profile
|
||||
|
||||
# TODO: Remove when we remove capabilities code. Firefox
|
||||
# is being strict here, like it should. When we can remove capabilities
|
||||
# for options this will be good to be deleted.
|
||||
if capabilities.get("acceptInsecureCerts"):
|
||||
options.accept_insecure_certs = capabilities.get("acceptInsecureCerts")
|
||||
|
||||
if not self.service:
|
||||
self.service = Service(
|
||||
executable_path,
|
||||
service_args=service_args,
|
||||
log_path=service_log_path)
|
||||
self.service.start()
|
||||
|
||||
executor = FirefoxRemoteConnection(
|
||||
remote_server_addr=self.service.service_url,
|
||||
ignore_proxy=options._ignore_local_proxy)
|
||||
RemoteWebDriver.__init__(
|
||||
self,
|
||||
command_executor=executor,
|
||||
options=options,
|
||||
keep_alive=True)
|
||||
|
||||
self._is_remote = False
|
||||
|
||||
def quit(self) -> NoReturn:
|
||||
"""Quits the driver and close every associated window."""
|
||||
try:
|
||||
RemoteWebDriver.quit(self)
|
||||
except Exception:
|
||||
# We don't care about the message because something probably has gone wrong
|
||||
pass
|
||||
|
||||
self.service.stop()
|
||||
|
||||
if self.profile:
|
||||
try:
|
||||
rmtree(self.profile.path)
|
||||
if self.profile.tempfolder:
|
||||
rmtree(self.profile.tempfolder)
|
||||
except Exception as e:
|
||||
print(str(e))
|
||||
|
||||
@property
|
||||
def firefox_profile(self):
|
||||
return self.profile
|
||||
|
||||
# Extension commands:
|
||||
|
||||
def set_context(self, context) -> NoReturn:
|
||||
self.execute("SET_CONTEXT", {"context": context})
|
||||
|
||||
@contextmanager
|
||||
def context(self, context):
|
||||
"""Sets the context that Selenium commands are running in using
|
||||
a `with` statement. The state of the context on the server is
|
||||
saved before entering the block, and restored upon exiting it.
|
||||
|
||||
:param context: Context, may be one of the class properties
|
||||
`CONTEXT_CHROME` or `CONTEXT_CONTENT`.
|
||||
|
||||
Usage example::
|
||||
|
||||
with selenium.context(selenium.CONTEXT_CHROME):
|
||||
# chrome scope
|
||||
... do stuff ...
|
||||
"""
|
||||
initial_context = self.execute('GET_CONTEXT').pop('value')
|
||||
self.set_context(context)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
self.set_context(initial_context)
|
||||
|
||||
def install_addon(self, path, temporary=None) -> str:
|
||||
"""
|
||||
Installs Firefox addon.
|
||||
|
||||
Returns identifier of installed addon. This identifier can later
|
||||
be used to uninstall addon.
|
||||
|
||||
:param path: Absolute path to the addon that will be installed.
|
||||
|
||||
:Usage:
|
||||
::
|
||||
|
||||
driver.install_addon('/path/to/firebug.xpi')
|
||||
"""
|
||||
payload = {"path": path}
|
||||
if temporary:
|
||||
payload["temporary"] = temporary
|
||||
return self.execute("INSTALL_ADDON", payload)["value"]
|
||||
|
||||
def uninstall_addon(self, identifier) -> NoReturn:
|
||||
"""
|
||||
Uninstalls Firefox addon using its identifier.
|
||||
|
||||
:Usage:
|
||||
::
|
||||
|
||||
driver.uninstall_addon('addon@foo.com')
|
||||
"""
|
||||
self.execute("UNINSTALL_ADDON", {"id": identifier})
|
||||
|
||||
def get_full_page_screenshot_as_file(self, filename) -> bool:
|
||||
"""
|
||||
Saves a full document screenshot of the current window to a PNG image file. Returns
|
||||
False if there is any IOError, else returns True. Use full paths in
|
||||
your filename.
|
||||
|
||||
:Args:
|
||||
- filename: The full path you wish to save your screenshot to. This
|
||||
should end with a `.png` extension.
|
||||
|
||||
:Usage:
|
||||
::
|
||||
|
||||
driver.get_full_page_screenshot_as_file('/Screenshots/foo.png')
|
||||
"""
|
||||
if not filename.lower().endswith('.png'):
|
||||
warnings.warn("name used for saved screenshot does not match file "
|
||||
"type. It should end with a `.png` extension", UserWarning)
|
||||
png = self.get_full_page_screenshot_as_png()
|
||||
try:
|
||||
with open(filename, 'wb') as f:
|
||||
f.write(png)
|
||||
except IOError:
|
||||
return False
|
||||
finally:
|
||||
del png
|
||||
return True
|
||||
|
||||
def save_full_page_screenshot(self, filename) -> bool:
|
||||
"""
|
||||
Saves a full document screenshot of the current window to a PNG image file. Returns
|
||||
False if there is any IOError, else returns True. Use full paths in
|
||||
your filename.
|
||||
|
||||
:Args:
|
||||
- filename: The full path you wish to save your screenshot to. This
|
||||
should end with a `.png` extension.
|
||||
|
||||
:Usage:
|
||||
::
|
||||
|
||||
driver.save_full_page_screenshot('/Screenshots/foo.png')
|
||||
"""
|
||||
return self.get_full_page_screenshot_as_file(filename)
|
||||
|
||||
def get_full_page_screenshot_as_png(self) -> str:
|
||||
"""
|
||||
Gets the full document screenshot of the current window as a binary data.
|
||||
|
||||
:Usage:
|
||||
::
|
||||
|
||||
driver.get_full_page_screenshot_as_png()
|
||||
"""
|
||||
return b64decode(self.get_full_page_screenshot_as_base64().encode('ascii'))
|
||||
|
||||
def get_full_page_screenshot_as_base64(self) -> str:
|
||||
"""
|
||||
Gets the full document screenshot of the current window as a base64 encoded string
|
||||
which is useful in embedded images in HTML.
|
||||
|
||||
:Usage:
|
||||
::
|
||||
|
||||
driver.get_full_page_screenshot_as_base64()
|
||||
"""
|
||||
return self.execute("FULL_PAGE_SCREENSHOT")['value']
|
||||
@@ -0,0 +1,69 @@
|
||||
{
|
||||
"frozen": {
|
||||
"app.update.auto": false,
|
||||
"app.update.enabled": false,
|
||||
"browser.displayedE10SNotice": 4,
|
||||
"browser.download.manager.showWhenStarting": false,
|
||||
"browser.EULA.override": true,
|
||||
"browser.EULA.3.accepted": true,
|
||||
"browser.link.open_external": 2,
|
||||
"browser.link.open_newwindow": 2,
|
||||
"browser.offline": false,
|
||||
"browser.reader.detectedFirstArticle": true,
|
||||
"browser.safebrowsing.enabled": false,
|
||||
"browser.safebrowsing.malware.enabled": false,
|
||||
"browser.search.update": false,
|
||||
"browser.selfsupport.url" : "",
|
||||
"browser.sessionstore.resume_from_crash": false,
|
||||
"browser.shell.checkDefaultBrowser": false,
|
||||
"browser.tabs.warnOnClose": false,
|
||||
"browser.tabs.warnOnOpen": false,
|
||||
"datareporting.healthreport.service.enabled": false,
|
||||
"datareporting.healthreport.uploadEnabled": false,
|
||||
"datareporting.healthreport.service.firstRun": false,
|
||||
"datareporting.healthreport.logging.consoleEnabled": false,
|
||||
"datareporting.policy.dataSubmissionEnabled": false,
|
||||
"datareporting.policy.dataSubmissionPolicyAccepted": false,
|
||||
"devtools.errorconsole.enabled": true,
|
||||
"dom.disable_open_during_load": false,
|
||||
"extensions.autoDisableScopes": 10,
|
||||
"extensions.blocklist.enabled": false,
|
||||
"extensions.checkCompatibility.nightly": false,
|
||||
"extensions.update.enabled": false,
|
||||
"extensions.update.notifyUser": false,
|
||||
"javascript.enabled": true,
|
||||
"network.manage-offline-status": false,
|
||||
"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,
|
||||
"signon.rememberSignons": false,
|
||||
"toolkit.networkmanager.disable": true,
|
||||
"toolkit.telemetry.prompted": 2,
|
||||
"toolkit.telemetry.enabled": false,
|
||||
"toolkit.telemetry.rejected": true,
|
||||
"xpinstall.signatures.required": false,
|
||||
"xpinstall.whitelist.required": false
|
||||
},
|
||||
"mutable": {
|
||||
"browser.dom.window.dump.enabled": true,
|
||||
"browser.laterrun.enabled": false,
|
||||
"browser.newtab.url": "about:blank",
|
||||
"browser.newtabpage.enabled": false,
|
||||
"browser.startup.page": 0,
|
||||
"browser.startup.homepage": "about:blank",
|
||||
"browser.startup.homepage_override.mstone": "ignore",
|
||||
"browser.usedOnWindows10.introURL": "about:blank",
|
||||
"dom.max_chrome_script_run_time": 30,
|
||||
"dom.max_script_run_time": 30,
|
||||
"dom.report_all_js_exceptions": true,
|
||||
"javascript.options.showInConsole": true,
|
||||
"network.captive-portal-service.enabled": false,
|
||||
"security.csp.enable": false,
|
||||
"startup.homepage_welcome_url": "about:blank",
|
||||
"startup.homepage_welcome_url.additional": "about:blank",
|
||||
"webdriver_accept_untrusted_certs": true,
|
||||
"webdriver_assume_untrusted_issuer": true
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user