mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
329 lines
10 KiB
Python
329 lines
10 KiB
Python
#
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
#
|
|
# The contents of this file are subject to the Mozilla Public License Version
|
|
# 1.1 (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.mozilla.org/MPL/
|
|
#
|
|
# Software distributed under the License is distributed on an "AS IS" basis,
|
|
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
# for the specific language governing rights and limitations under the
|
|
# License.
|
|
#
|
|
# The Original Code is mozilla.org code.
|
|
#
|
|
# The Initial Developer of the Original Code is
|
|
# Mozilla Foundation.
|
|
# Portions created by the Initial Developer are Copyright (C) 2008
|
|
# the Initial Developer. All Rights Reserved.
|
|
#
|
|
# Contributor(s):
|
|
# Robert Sayre <sayrer@gmail.com>
|
|
# Jeff Walden <jwalden+bmo@mit.edu>
|
|
#
|
|
# Alternatively, the contents of this file may be used under the terms of
|
|
# either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
# in which case the provisions of the GPL or the LGPL are applicable instead
|
|
# of those above. If you wish to allow use of your version of this file only
|
|
# under the terms of either the GPL or the LGPL, and not to allow others to
|
|
# use your version of this file under the terms of the MPL, indicate your
|
|
# decision by deleting the provisions above and replace them with the notice
|
|
# and other provisions required by the GPL or the LGPL. If you do not delete
|
|
# the provisions above, a recipient may use your version of this file under
|
|
# the terms of any one of the MPL, the GPL or the LGPL.
|
|
#
|
|
# ***** END LICENSE BLOCK *****
|
|
|
|
from datetime import datetime
|
|
import itertools
|
|
import logging
|
|
import shutil
|
|
import os
|
|
import signal
|
|
import sys
|
|
import threading
|
|
|
|
"""
|
|
Runs the browser from a script, and provides useful utilities
|
|
for setting up the browser environment.
|
|
"""
|
|
|
|
__all__ = [
|
|
"UNIXISH",
|
|
"IS_WIN32",
|
|
"runApp",
|
|
"Process",
|
|
"initializeProfile",
|
|
"DIST_BIN",
|
|
"DEFAULT_APP",
|
|
]
|
|
|
|
# Since some tests require cross-domain support in Mochitest, across ports,
|
|
# domains, subdomains, etc. we use a proxy autoconfig hack to map a bunch of
|
|
# servers onto localhost:8888. We have to grant them the same privileges as
|
|
# localhost:8888 here, since the browser only knows them as the URLs they're
|
|
# pretending to be. We also have two servers which are set up but don't have
|
|
# privileges, for testing privilege functionality.
|
|
#
|
|
# These lists must be kept in sync with the following list:
|
|
#
|
|
# http://developer.mozilla.org/en/docs/Mochitest#How_do_I_test_issues_which_only_show_up_when_tests_are_run_across_domains.3F
|
|
#
|
|
servers = [
|
|
"localhost:8888", # MUST be first -- see PAC pref-setting code
|
|
"example.org:80",
|
|
"test1.example.org:80",
|
|
"test2.example.org:80",
|
|
"sub1.test1.example.org:80",
|
|
"sub1.test2.example.org:80",
|
|
"sub2.test1.example.org:80",
|
|
"sub2.test2.example.org:80",
|
|
"example.org:8000",
|
|
"test1.example.org:8000",
|
|
"test2.example.org:8000",
|
|
"sub1.test1.example.org:8000",
|
|
"sub1.test2.example.org:8000",
|
|
"sub2.test1.example.org:8000",
|
|
"sub2.test2.example.org:8000",
|
|
"example.com:80",
|
|
"test1.example.com:80",
|
|
"test2.example.com:80",
|
|
"sub1.test1.example.com:80",
|
|
"sub1.test2.example.com:80",
|
|
"sub2.test1.example.com:80",
|
|
"sub2.test2.example.com:80",
|
|
"sectest1.example.org:80",
|
|
"sub.sectest2.example.org:80",
|
|
"sub1.xn--lt-uia.example.org:8000", # U+00E4 U+006C U+0074
|
|
"sub2.xn--lt-uia.example.org:80", # U+00E4 U+006C U+0074
|
|
"xn--exmple-cua.test:80",
|
|
"sub1.xn--exmple-cua.test:80",
|
|
"xn--hxajbheg2az3al.xn--jxalpdlp:80", # Greek IDN for example.test
|
|
"sub1.xn--hxajbheg2az3al.xn--jxalpdlp:80",
|
|
]
|
|
|
|
unprivilegedServers = [
|
|
"sectest2.example.org:80",
|
|
"sub.sectest1.example.org:80",
|
|
]
|
|
|
|
|
|
# These are generated in mozilla/build/Makefile.in
|
|
#expand DIST_BIN = "./" + __XPC_BIN_PATH__
|
|
#expand IS_WIN32 = len("__WIN32__") != 0
|
|
#expand IS_MAC = __IS_MAC__ != 0
|
|
#ifdef IS_CYGWIN
|
|
#expand IS_CYGWIN = __IS_CYGWIN__ == 1
|
|
#else
|
|
IS_CYGWIN = False
|
|
#endif
|
|
|
|
UNIXISH = not IS_WIN32 and not IS_MAC
|
|
|
|
#expand DEFAULT_APP = "./" + __BROWSER_PATH__
|
|
|
|
###########
|
|
# LOGGING #
|
|
###########
|
|
|
|
# We use the logging system here primarily because it'll handle multiple
|
|
# threads, which is needed to process the output of the server and application
|
|
# processes simultaneously.
|
|
log = logging.getLogger()
|
|
handler = logging.StreamHandler(sys.stdout)
|
|
log.setLevel(logging.INFO)
|
|
log.addHandler(handler)
|
|
|
|
|
|
#################
|
|
# SUBPROCESSING #
|
|
#################
|
|
|
|
class Process:
|
|
"""
|
|
Represents a subprocess of this process. We don't just directly use the
|
|
subprocess module here because we want compatibility with Python 2.3 on
|
|
non-Windows platforms. :-(
|
|
"""
|
|
|
|
def __init__(self, command, args, env):
|
|
"""
|
|
Creates a process representing the execution of the given command, which
|
|
must be an absolute path, with the given arguments in the given environment.
|
|
The process is then started.
|
|
"""
|
|
command = os.path.abspath(command)
|
|
if IS_WIN32:
|
|
import subprocess
|
|
cmd = [command]
|
|
cmd.extend(args)
|
|
p = subprocess.Popen(cmd, env = env,
|
|
stdout = subprocess.PIPE,
|
|
stderr = subprocess.STDOUT)
|
|
self._out = p.stdout
|
|
else:
|
|
import popen2
|
|
cmd = []
|
|
for (k, v) in env.iteritems():
|
|
cmd.append(k + "='" + v + "' ")
|
|
cmd.append("'" + command + "'")
|
|
cmd.extend(map(lambda x: "'" + x + "'", args))
|
|
cmd = " ".join(cmd)
|
|
p = popen2.Popen4(cmd)
|
|
self._out = p.fromchild
|
|
|
|
self._process = p
|
|
self.pid = p.pid
|
|
|
|
self._thread = threading.Thread(target = lambda: self._run())
|
|
self._thread.start()
|
|
|
|
def _run(self):
|
|
"Continues execution of this process on a separate thread."
|
|
p = self._process
|
|
out = self._out
|
|
|
|
if IS_WIN32:
|
|
running = lambda: p.poll() is None
|
|
else:
|
|
running = lambda: p.poll() == -1
|
|
|
|
# read in lines until the process finishes, then read in any last remaining
|
|
# buffered lines
|
|
while running():
|
|
line = out.readline().rstrip()
|
|
if len(line) > 0:
|
|
log.info(line)
|
|
for line in out:
|
|
line = line.rstrip()
|
|
if len(line) > 0:
|
|
log.info(line)
|
|
self._status = p.poll()
|
|
|
|
def wait(self):
|
|
"Waits for this process to finish, then returns the process's status."
|
|
self._thread.join()
|
|
return self._status
|
|
|
|
def kill(self):
|
|
"Kills this process."
|
|
try:
|
|
if not IS_WIN32: # XXX
|
|
os.kill(self._process.pid, signal.SIGKILL)
|
|
except:
|
|
pass
|
|
|
|
|
|
#################
|
|
# PROFILE SETUP #
|
|
#################
|
|
|
|
def initializeProfile(profileDir):
|
|
"Sets up the standard testing profile."
|
|
|
|
# Start with a clean slate.
|
|
shutil.rmtree(profileDir, True)
|
|
os.mkdir(profileDir)
|
|
|
|
prefs = []
|
|
|
|
part = """\
|
|
user_pref("browser.dom.window.dump.enabled", true);
|
|
user_pref("dom.disable_open_during_load", false);
|
|
user_pref("dom.max_script_run_time", 0); // no slow script dialogs
|
|
user_pref("signed.applets.codebase_principal_support", true);
|
|
user_pref("security.warn_submit_insecure", false);
|
|
user_pref("browser.shell.checkDefaultBrowser", false);
|
|
user_pref("browser.warnOnQuit", false);
|
|
user_pref("accessibility.typeaheadfind.autostart", false);
|
|
user_pref("javascript.options.showInConsole", true);
|
|
"""
|
|
prefs.append(part)
|
|
|
|
# Grant God-power to all the servers on which tests can run.
|
|
for (i, server) in itertools.izip(itertools.count(1), servers):
|
|
part = """
|
|
user_pref("capability.principal.codebase.p%(i)d.granted",
|
|
"UniversalXPConnect UniversalBrowserRead UniversalBrowserWrite \
|
|
UniversalPreferencesRead UniversalPreferencesWrite \
|
|
UniversalFileRead");
|
|
user_pref("capability.principal.codebase.p%(i)d.id", "http://%(server)s");
|
|
user_pref("capability.principal.codebase.p%(i)d.subjectName", "");
|
|
""" % {"i": i, "server": server}
|
|
prefs.append(part)
|
|
|
|
# Now add the two servers that do NOT have God-power so we can properly test
|
|
# the granting and receiving of God-power. Strip off the first server because
|
|
# we proxy all the others to it.
|
|
allServers = servers[1:] + unprivilegedServers
|
|
|
|
|
|
# Now actually create the preference to make the proxying happen.
|
|
quotedServers = ", ".join(map(lambda x: "'" + x + "'", allServers))
|
|
|
|
pacURL = """data:text/plain,
|
|
function FindProxyForURL(url, host)
|
|
{
|
|
var servers = [%(quotedServers)s];
|
|
var regex = new RegExp('http://(?:[^/@]*@)?(.*?(:\\\\\\\\d+)?)/');
|
|
var matches = regex.exec(url);
|
|
if (!matches)
|
|
return 'DIRECT';
|
|
var hostport = matches[1], port = matches[2];
|
|
if (!port)
|
|
hostport += ':80';
|
|
if (servers.indexOf(hostport) >= 0)
|
|
return 'PROXY localhost:8888';
|
|
return 'DIRECT';
|
|
}""" % {"quotedServers": quotedServers}
|
|
pacURL = "".join(pacURL.splitlines())
|
|
|
|
part = """
|
|
user_pref("network.proxy.type", 2);
|
|
user_pref("network.proxy.autoconfig_url", "%(pacURL)s");
|
|
""" % {"pacURL": pacURL}
|
|
prefs.append(part)
|
|
|
|
# write the preferences
|
|
prefsFile = open(profileDir + "/" + "user.js", "a")
|
|
prefsFile.write("".join(prefs))
|
|
prefsFile.close()
|
|
|
|
|
|
###############
|
|
# RUN THE APP #
|
|
###############
|
|
|
|
def runApp(testURL, env, app, profileDir, extraArgs):
|
|
"Run the app, returning the time at which it was started."
|
|
# mark the start
|
|
start = datetime.now()
|
|
|
|
# now run with the profile we created
|
|
cmd = app
|
|
if IS_MAC and not cmd.endswith("-bin"):
|
|
cmd += "-bin"
|
|
cmd = os.path.abspath(cmd)
|
|
|
|
args = []
|
|
if IS_MAC:
|
|
args.append("-foreground")
|
|
|
|
if IS_CYGWIN:
|
|
profileDirectory = commands.getoutput("cygpath -w \"" + profileDir + "/\"")
|
|
else:
|
|
profileDirectory = profileDir + "/"
|
|
|
|
args.extend(("-no-remote", "-profile", profileDirectory, testURL))
|
|
args.extend(extraArgs)
|
|
proc = Process(cmd, args, env = env)
|
|
log.info("Application pid: %d", proc.pid)
|
|
status = proc.wait()
|
|
if status != 0:
|
|
log.info("ERROR FAIL Exited with code %d during test run", status)
|
|
|
|
return start
|