| /* | |
| * Copyright 2009 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 | |
| * | |
| * 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. | |
| */ | |
| package com.google.gwt.junit; | |
| import static com.gargoylesoftware.htmlunit.BrowserVersionFeatures.JS_WINDOW_ONERROR_COLUMN_ERROR_ARGUMENT; | |
| import com.google.gwt.core.ext.TreeLogger; | |
| import com.google.gwt.dev.shell.HostedModePluginObject; | |
| import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet; | |
| import com.google.gwt.thirdparty.guava.common.collect.Maps; | |
| import com.gargoylesoftware.htmlunit.AlertHandler; | |
| import com.gargoylesoftware.htmlunit.BrowserVersion; | |
| import com.gargoylesoftware.htmlunit.FailingHttpStatusCodeException; | |
| import com.gargoylesoftware.htmlunit.IncorrectnessListener; | |
| import com.gargoylesoftware.htmlunit.InteractivePage; | |
| import com.gargoylesoftware.htmlunit.OnbeforeunloadHandler; | |
| import com.gargoylesoftware.htmlunit.Page; | |
| import com.gargoylesoftware.htmlunit.ScriptException; | |
| import com.gargoylesoftware.htmlunit.WebClient; | |
| import com.gargoylesoftware.htmlunit.WebWindow; | |
| import com.gargoylesoftware.htmlunit.html.HtmlPage; | |
| import com.gargoylesoftware.htmlunit.javascript.JavaScriptEngine; | |
| import com.gargoylesoftware.htmlunit.javascript.JavaScriptErrorListener; | |
| import com.gargoylesoftware.htmlunit.javascript.host.Window; | |
| import com.gargoylesoftware.htmlunit.util.WebClientUtils; | |
| import net.sourceforge.htmlunit.corejs.javascript.Context; | |
| import net.sourceforge.htmlunit.corejs.javascript.Function; | |
| import net.sourceforge.htmlunit.corejs.javascript.JavaScriptException; | |
| import net.sourceforge.htmlunit.corejs.javascript.ScriptableObject; | |
| import org.apache.commons.logging.Log; | |
| import org.apache.commons.logging.LogFactory; | |
| import java.io.IOException; | |
| import java.net.MalformedURLException; | |
| import java.net.URL; | |
| import java.util.ArrayList; | |
| import java.util.Collections; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| /** | |
| * Launches a web-mode test via HTMLUnit. | |
| */ | |
| public class RunStyleHtmlUnit extends RunStyle { | |
| /** | |
| * Runs HTMLUnit in a separate thread. | |
| */ | |
| protected static class HtmlUnitThread extends Thread implements AlertHandler, | |
| IncorrectnessListener, OnbeforeunloadHandler { | |
| private final BrowserVersion browser; | |
| private final boolean developmentMode; | |
| private final TreeLogger treeLogger; | |
| private final String url; | |
| private Object waitForUnload = new Object(); | |
| public HtmlUnitThread(BrowserVersion browser, String url, | |
| TreeLogger treeLogger, boolean developmentMode) { | |
| this.browser = browser; | |
| this.url = url; | |
| this.treeLogger = treeLogger; | |
| this.setName("htmlUnit client thread"); | |
| this.developmentMode = developmentMode; | |
| } | |
| public void handleAlert(Page page, String message) { | |
| treeLogger.log(TreeLogger.ERROR, "Alert: " + message); | |
| } | |
| public boolean handleEvent(Page page, String returnValue) { | |
| synchronized (waitForUnload) { | |
| waitForUnload.notifyAll(); | |
| } | |
| return true; | |
| } | |
| public void notify(String message, Object origin) { | |
| if ("Obsolete content type encountered: 'text/javascript'.".equals(message) || | |
| "Obsolete content type encountered: 'application/x-javascript'.".equals(message)) { | |
| // silently eat warning about text/javascript MIME type and application/x-javascript | |
| return; | |
| } | |
| treeLogger.log(TreeLogger.WARN, message); | |
| } | |
| @Override | |
| public void run() { | |
| WebClient webClient = new WebClient(browser); | |
| webClient.setAlertHandler(this); | |
| webClient.setIncorrectnessListener(this); | |
| webClient.getOptions().setThrowExceptionOnFailingStatusCode(false); | |
| // To receive exceptions from js side in the development mode, we need set this to 'true'. | |
| // However, as htmlunit dies after throwing the exception, we still want it to be 'false' | |
| // for web mode. | |
| webClient.getOptions().setThrowExceptionOnScriptError(developmentMode); | |
| webClient.setOnbeforeunloadHandler(this); | |
| webClient.setJavaScriptErrorListener(new JavaScriptErrorListener() { | |
| @Override | |
| public void loadScriptError(InteractivePage htmlPage, URL scriptUrl, | |
| Exception exception) { | |
| treeLogger.log(TreeLogger.ERROR, | |
| "Load Script Error: " + exception, exception); | |
| } | |
| @Override | |
| public void malformedScriptURL(InteractivePage htmlPage, String url, | |
| MalformedURLException malformedURLException) { | |
| treeLogger.log(TreeLogger.ERROR, | |
| "Malformed Script URL: " + malformedURLException.getLocalizedMessage()); | |
| } | |
| @Override | |
| public void scriptException(InteractivePage htmlPage, | |
| ScriptException scriptException) { | |
| treeLogger.log(TreeLogger.DEBUG, | |
| "Script Exception: " + scriptException.getLocalizedMessage() + | |
| ", line " + scriptException.getFailingLine()); | |
| } | |
| @Override | |
| public void timeoutError(InteractivePage htmlPage, long allowedTime, | |
| long executionTime) { | |
| treeLogger.log(TreeLogger.ERROR, | |
| "Script Timeout Error " + executionTime + " > " + allowedTime); | |
| } | |
| }); | |
| setupWebClient(webClient); | |
| try { | |
| Page page = webClient.getPage(url); | |
| webClient.waitForBackgroundJavaScriptStartingBefore(2000); | |
| if (treeLogger.isLoggable(TreeLogger.SPAM)) { | |
| treeLogger.log(TreeLogger.SPAM, "getPage returned " | |
| + ((HtmlPage) page).asXml()); | |
| } | |
| // TODO(amitmanjhi): call webClient.closeAllWindows() | |
| } catch (FailingHttpStatusCodeException e) { | |
| treeLogger.log(TreeLogger.ERROR, "HTTP request failed", e); | |
| return; | |
| } catch (MalformedURLException e) { | |
| treeLogger.log(TreeLogger.ERROR, "Bad URL", e); | |
| return; | |
| } catch (IOException e) { | |
| treeLogger.log(TreeLogger.ERROR, "I/O error on HTTP request", e); | |
| return; | |
| } | |
| } | |
| protected void setupWebClient(WebClient webClient) { | |
| if (developmentMode) { | |
| JavaScriptEngine hostedEngine = new HostedJavaScriptEngine(webClient, | |
| treeLogger); | |
| webClient.setJavaScriptEngine(hostedEngine); | |
| } else { | |
| JavaScriptEngine webEngine = new WebJavaScriptEngine(webClient); | |
| webClient.setJavaScriptEngine(webEngine); | |
| } | |
| if (System.getProperty("gwt.htmlunit.debug") != null) { | |
| WebClientUtils.attachVisualDebugger(webClient); | |
| } | |
| } | |
| } | |
| /** | |
| * JavaScriptEngine subclass that provides a hook of initializing the | |
| * __gwt_HostedModePlugin property on any new window, so it acts just like | |
| * Firefox with the XPCOM plugin installed. | |
| */ | |
| private static class HostedJavaScriptEngine extends JavaScriptEngine { | |
| private static final long serialVersionUID = 3594816610842448691L; | |
| private final TreeLogger logger; | |
| public HostedJavaScriptEngine(WebClient webClient, TreeLogger logger) { | |
| super(webClient); | |
| this.logger = logger; | |
| } | |
| @Override | |
| public void initialize(WebWindow webWindow) { | |
| // Hook in the hosted-mode plugin after initializing the JS engine. | |
| super.initialize(webWindow); | |
| Window window = (Window) webWindow.getScriptableObject(); | |
| window.defineProperty("__gwt_HostedModePlugin", | |
| new HostedModePluginObject(this, logger), ScriptableObject.READONLY); | |
| } | |
| } | |
| /** | |
| * JavaScriptEngine subclass that fixes a bug when calling {@code window.onerror}. | |
| * Make sure to remove when updating HtmlUnit. | |
| * | |
| * @see <a href="https://sourceforge.net/p/htmlunit/bugs/1924/">HtmlUnit bug #1924</a> | |
| */ | |
| private static class WebJavaScriptEngine extends JavaScriptEngine { | |
| private static final Log LOG = LogFactory.getLog(JavaScriptEngine.class); | |
| public WebJavaScriptEngine(WebClient webClient) { | |
| super(webClient); | |
| } | |
| @Override | |
| protected void handleJavaScriptException(ScriptException scriptException, | |
| boolean triggerOnError) { | |
| // XXX(tbroyer): copied from JavaScriptEngine to call below triggerOnError | |
| // instead of Window's triggerOnError. | |
| // Trigger window.onerror, if it has been set. | |
| final InteractivePage page = scriptException.getPage(); | |
| if (triggerOnError && page != null) { | |
| final WebWindow window = page.getEnclosingWindow(); | |
| if (window != null) { | |
| final Window w = (Window) window.getScriptableObject(); | |
| if (w != null) { | |
| try { | |
| triggerOnError(w, scriptException); | |
| } catch (final Exception e) { | |
| handleJavaScriptException(new ScriptException(page, e, null), false); | |
| } | |
| } | |
| } | |
| } | |
| final JavaScriptErrorListener javaScriptErrorListener = | |
| getWebClient().getJavaScriptErrorListener(); | |
| if (javaScriptErrorListener != null) { | |
| javaScriptErrorListener.scriptException(page, scriptException); | |
| } | |
| // Throw a Java exception if the user wants us to. | |
| if (getWebClient().getOptions().isThrowExceptionOnScriptError()) { | |
| throw scriptException; | |
| } | |
| // Log the error; ScriptException instances provide good debug info. | |
| LOG.info("Caught script exception", scriptException); | |
| } | |
| private void triggerOnError(Window w, ScriptException e) { | |
| // XXX(tbroyer): copied from HtmlUnit's javascript.host.Window | |
| // with fix unwrapping the JS exception before passing it back to JS. | |
| final Object o = w.getOnerror(); | |
| if (o instanceof Function) { | |
| final Function f = (Function) o; | |
| final String msg = e.getMessage(); | |
| final String url = e.getPage().getUrl().toExternalForm(); | |
| final int line = e.getFailingLineNumber(); | |
| Object[] args; | |
| if (w.getBrowserVersion().hasFeature(JS_WINDOW_ONERROR_COLUMN_ERROR_ARGUMENT)) { | |
| final int column = e.getFailingColumnNumber(); | |
| Object jsError = null; | |
| if (e.getCause() instanceof JavaScriptException) { | |
| jsError = ((JavaScriptException) e.getCause()).getValue(); | |
| } | |
| args = new Object[] {msg, url, Integer.valueOf(line), Integer.valueOf(column), jsError}; | |
| } else { | |
| args = new Object[] {msg, url, Integer.valueOf(line)}; | |
| } | |
| f.call(Context.getCurrentContext(), w, w, args); | |
| } | |
| } | |
| } | |
| private static final Map<String, BrowserVersion> BROWSER_MAP = Maps.newHashMap(); | |
| private static final Map<BrowserVersion, String> USER_AGENT_MAP = Maps.newHashMap(); | |
| static { | |
| // “Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0″ | |
| addBrowser(BrowserVersion.EDGE, "safari"); | |
| addBrowser(BrowserVersion.FIREFOX_38, "gecko1_8"); | |
| addBrowser(BrowserVersion.CHROME, "safari"); | |
| addBrowser(BrowserVersion.INTERNET_EXPLORER_8, "ie8"); | |
| addBrowser(BrowserVersion.INTERNET_EXPLORER_11, "gecko1_8"); | |
| } | |
| private static void addBrowser(BrowserVersion browser, String userAgent) { | |
| BROWSER_MAP.put(browser.getNickname(), browser); | |
| USER_AGENT_MAP.put(browser, userAgent); | |
| } | |
| /* | |
| * as long as this number is greater than 1, GWTTestCaseTest::testRetry will | |
| * pass | |
| */ | |
| private static final int DEFAULT_TRIES = 1; | |
| private static final Set<Platform> PLATFORMS = ImmutableSet.of(Platform.HtmlUnitBug, | |
| Platform.HtmlUnitLayout, Platform.HtmlUnitUnknown); | |
| private Set<BrowserVersion> browsers = new HashSet<BrowserVersion>(); | |
| private boolean developmentMode; | |
| private final List<Thread> threads = new ArrayList<Thread>(); | |
| /** | |
| * Create a RunStyle instance with the passed-in browser targets. | |
| */ | |
| public RunStyleHtmlUnit(JUnitShell shell) { | |
| super(shell); | |
| } | |
| @Override | |
| public Set<Platform> getPlatforms() { | |
| return PLATFORMS; | |
| } | |
| @Override | |
| public int initialize(String args) { | |
| if (args == null || args.length() == 0) { | |
| // If no browsers specified, default to Firefox 38. | |
| args = "FF38"; | |
| } | |
| Set<BrowserVersion> browserSet = new HashSet<BrowserVersion>(); | |
| Set<String> userAgentSet = new HashSet<String>(); | |
| for (String browserName : args.split(",")) { | |
| BrowserVersion browser = BROWSER_MAP.get(browserName); | |
| if (browser == null) { | |
| getLogger().log( | |
| TreeLogger.ERROR, | |
| "RunStyleHtmlUnit: Unknown browser " + "name " + browserName | |
| + ", expected browser name: one of " + BROWSER_MAP.keySet()); | |
| return -1; | |
| } | |
| browserSet.add(browser); | |
| userAgentSet.add(USER_AGENT_MAP.get(browser)); | |
| } | |
| browsers = Collections.unmodifiableSet(browserSet); | |
| setUserAgents(Collections.unmodifiableSet(userAgentSet)); | |
| setTries(DEFAULT_TRIES); // set to the default value for this RunStyle | |
| return browsers.size(); | |
| } | |
| @Override | |
| public void launchModule(String moduleName) { | |
| for (BrowserVersion browser : browsers) { | |
| String url = shell.getModuleUrl(moduleName); | |
| HtmlUnitThread hut = createHtmlUnitThread(browser, url); | |
| TreeLogger logger = shell.getTopLogger(); | |
| if (logger.isLoggable(TreeLogger.INFO)) { | |
| logger.log(TreeLogger.INFO, | |
| "Starting " + url + " on browser " + browser.getNickname()); | |
| } | |
| /* | |
| * TODO (amitmanjhi): Is it worth pausing here and waiting for the main | |
| * test thread to get to an "okay" state. | |
| */ | |
| hut.start(); | |
| threads.add(hut); | |
| } | |
| } | |
| public int numBrowsers() { | |
| return browsers.size(); | |
| } | |
| @Override | |
| public boolean setupMode(TreeLogger logger, boolean developmentMode) { | |
| this.developmentMode = developmentMode; | |
| return true; | |
| } | |
| protected HtmlUnitThread createHtmlUnitThread(BrowserVersion browser, | |
| String url) { | |
| return new HtmlUnitThread(browser, url, shell.getTopLogger().branch( | |
| TreeLogger.SPAM, "logging for HtmlUnit thread"), developmentMode); | |
| } | |
| } |