capybara-webkit 0.12.1 → 0.13.0

data/src/Status.h

@@ -1,12 +1,10 @@
-#include "Command.h"
+#include "SocketCommand.h"
 
-class WebPage;
-
-class Status : public Command {
+class Status : public SocketCommand {
   Q_OBJECT
 
   public:
-    Status(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    Status(WebPageManager *, QStringList &arguments, QObject *parent = 0);
     virtual void start();
 };
 

data/src/TimeoutCommand.cpp

@@ -0,0 +1,69 @@
+#include "TimeoutCommand.h"
+#include "Command.h"
+#include "WebPageManager.h"
+#include "WebPage.h"
+#include <QTimer>
+
+TimeoutCommand::TimeoutCommand(Command *command, WebPageManager *manager, QObject *parent) : Command(parent) {
+  m_command = command;
+  m_manager = manager;
+  m_timer = new QTimer(this);
+  m_timer->setSingleShot(true);
+  connect(m_timer, SIGNAL(timeout()), this, SLOT(commandTimeout()));
+  connect(m_manager, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+}
+
+void TimeoutCommand::start() {
+  if (m_manager->isLoading()) {
+    m_manager->logger() << this->toString() << "waiting for load to finish";
+    connect(m_manager, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+    startTimeout();
+  } else {
+    startCommand();
+  }
+}
+
+void TimeoutCommand::startCommand() {
+  connect(m_command, SIGNAL(finished(Response *)), this, SLOT(commandFinished(Response *)));
+  m_command->start();
+}
+
+void TimeoutCommand::startTimeout() {
+  int timeout = m_manager->getTimeout();
+  if (timeout > 0) {
+    m_timer->start(timeout * 1000);
+  }
+}
+
+void TimeoutCommand::pendingLoadFinished(bool success) {
+  if (success) {
+    startCommand();
+  } else {
+    disconnect(m_timer, SIGNAL(timeout()), this, SLOT(commandTimeout()));
+    disconnect(m_manager, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+    disconnect(m_manager, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+    emit finished(new Response(false, m_manager->currentPage()->failureString()));
+  }
+}
+
+void TimeoutCommand::pageLoadingFromCommand() {
+  startTimeout();
+}
+
+void TimeoutCommand::commandTimeout() {
+  disconnect(m_manager, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  disconnect(m_manager, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+  disconnect(m_command, SIGNAL(finished(Response *)), this, SLOT(commandFinished(Response *)));
+  m_manager->currentPage()->triggerAction(QWebPage::Stop);
+  m_command->deleteLater();
+  emit finished(new Response(false, QString("timeout")));
+}
+
+void TimeoutCommand::commandFinished(Response *response) {
+  disconnect(m_timer, SIGNAL(timeout()), this, SLOT(commandTimeout()));
+  disconnect(m_manager, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  disconnect(m_manager, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+  m_command->deleteLater();
+  emit finished(response);
+}
+

data/src/TimeoutCommand.h

@@ -0,0 +1,41 @@
+#include "Command.h"
+#include <QObject>
+#include <QStringList>
+
+class Response;
+class WebPageManager;
+class QTimer;
+
+/* Decorates a command with a timeout.
+ *
+ * If the timeout, using a QTimer is reached before
+ * the command is finished, the load page load will
+ * be stopped and failure response will be issued.
+ *
+ */
+class TimeoutCommand : public Command {
+  Q_OBJECT
+ 
+  public:
+   TimeoutCommand(Command *command, WebPageManager *page, QObject *parent = 0);
+  virtual void start();
+
+  public slots:
+    void commandTimeout();
+    void commandFinished(Response *response);
+    void pageLoadingFromCommand();
+    void pendingLoadFinished(bool);
+
+  signals:
+    void finished(Response *response);
+
+  protected:
+    void startCommand();
+    void startTimeout();
+
+  private:
+    WebPageManager *m_manager;
+    QTimer *m_timer;
+    Command *m_command;
+};
+ 

data/src/UnsupportedContentHandler.cpp

@@ -5,28 +5,22 @@
 UnsupportedContentHandler::UnsupportedContentHandler(WebPage *page, QNetworkReply *reply, QObject *parent) : QObject(parent) {
   m_page = page;
   m_reply = reply;
-  connect(m_reply, SIGNAL(finished()), this, SLOT(handleUnsupportedContent()));
-  disconnect(m_page, SIGNAL(loadFinished(bool)), m_page, SLOT(loadFinished(bool)));
 }
 
-void UnsupportedContentHandler::handleUnsupportedContent() {
-  QVariant contentMimeType = m_reply->header(QNetworkRequest::ContentTypeHeader);
-  if(contentMimeType.isNull()) {
-    this->finish(false);
-  } else {
-    this->loadUnsupportedContent();
-    this->finish(true);
-  }
+void UnsupportedContentHandler::renderNonHtmlContent() {
+  QByteArray text = m_reply->readAll();
+  m_page->mainFrame()->setContent(text, QString("text/plain"), m_reply->url());
+  m_page->networkAccessManagerFinishedReply(m_reply);
+  m_page->loadFinished(true);
   this->deleteLater();
 }
 
-void UnsupportedContentHandler::loadUnsupportedContent() {
-    QByteArray text = m_reply->readAll();
-    m_page->mainFrame()->setContent(text, QString("text/plain"), m_reply->url());
+void UnsupportedContentHandler::waitForReplyToFinish() {
+  connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+  disconnect(m_page, SIGNAL(loadFinished(bool)), m_page, SLOT(loadFinished(bool)));
 }
 
-void UnsupportedContentHandler::finish(bool success) {
-    connect(m_page, SIGNAL(loadFinished(bool)), m_page, SLOT(loadFinished(bool)));
-    m_page->replyFinished(m_reply);
-    m_page->loadFinished(success);
+void UnsupportedContentHandler::replyFinished() {
+  renderNonHtmlContent();
+  connect(m_page, SIGNAL(loadFinished(bool)), m_page, SLOT(loadFinished(bool)));
 }

data/src/UnsupportedContentHandler.h

@@ -1,18 +1,20 @@
 #include <QObject>
+
 class WebPage;
 class QNetworkReply;
+
 class UnsupportedContentHandler : public QObject {
   Q_OBJECT
 
   public:
     UnsupportedContentHandler(WebPage *page, QNetworkReply *reply, QObject *parent = 0);
+    void waitForReplyToFinish();
+    void renderNonHtmlContent();
 
   public slots:
-    void handleUnsupportedContent();
+    void replyFinished();
 
   private:
     WebPage *m_page;
     QNetworkReply *m_reply;
-    void loadUnsupportedContent();
-    void finish(bool success);
 };

data/src/Url.cpp

@@ -1,7 +1,8 @@
 #include "Url.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 
-Url::Url(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+Url::Url(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
 
 void Url::start() {

data/src/Url.h

@@ -1,12 +1,10 @@
-#include "Command.h"
+#include "SocketCommand.h"
 
-class WebPage;
-
-class Url : public Command {
+class Url : public SocketCommand {
   Q_OBJECT
 
   public:
-    Url(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    Url(WebPageManager *, QStringList &arguments, QObject *parent = 0);
     virtual void start();
 };
 

data/src/Visit.cpp

@@ -1,8 +1,9 @@
 #include "Visit.h"
-#include "Command.h"
+#include "SocketCommand.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 
-Visit::Visit(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+Visit::Visit(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
 
 void Visit::start() {

data/src/Visit.h

@@ -1,12 +1,10 @@
-#include "Command.h"
+#include "SocketCommand.h"
 
-class WebPage;
-
-class Visit : public Command {
+class Visit : public SocketCommand {
   Q_OBJECT
 
   public:
-    Visit(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    Visit(WebPageManager *manager, QStringList &arguments, QObject *parent = 0);
     virtual void start();
 };
 

data/src/WebPage.cpp

@@ -1,18 +1,27 @@
 #include "WebPage.h"
+#include "WebPageManager.h"
 #include "JavascriptInvocation.h"
 #include "NetworkAccessManager.h"
 #include "NetworkCookieJar.h"
 #include "UnsupportedContentHandler.h"
 #include <QResource>
 #include <iostream>
+#include <QWebSettings>
+#include <QUuid>
+
+WebPage::WebPage(WebPageManager *manager, QObject *parent) : QWebPage(parent) {
+  m_loading = false;
+  m_failed = false;
+  m_manager = manager;
+  m_uuid = QUuid::createUuid().toString();
 
-WebPage::WebPage(QObject *parent) : QWebPage(parent) {
   setForwardUnsupportedContent(true);
   loadJavascript();
   setUserStylesheet();
 
-  m_loading = false;
-  m_ignoreSslErrors = false;
+  m_confirm = true;
+  m_prompt = false;
+  m_prompt_text = QString();
   this->setCustomNetworkAccessManager();
 
   connect(this, SIGNAL(loadStarted()), this, SLOT(loadStarted()));
@@ -22,6 +31,9 @@ WebPage::WebPage(QObject *parent) : QWebPage(parent) {
   connect(this, SIGNAL(unsupportedContent(QNetworkReply*)),
       this, SLOT(handleUnsupportedContent(QNetworkReply*)));
   resetWindowSize();
+
+  settings()->setAttribute(QWebSettings::JavascriptCanOpenWindows, true);
+  currentFrame()->setUrl(QUrl("about:blank"));
 }
 
 void WebPage::resetWindowSize() {
@@ -30,12 +42,21 @@ void WebPage::resetWindowSize() {
 }
 
 void WebPage::setCustomNetworkAccessManager() {
-  NetworkAccessManager *manager = new NetworkAccessManager();
-  manager->setCookieJar(new NetworkCookieJar());
+  NetworkAccessManager *manager = new NetworkAccessManager(this);
+  manager->setCookieJar(m_manager->cookieJar());
   this->setNetworkAccessManager(manager);
-  connect(manager, SIGNAL(finished(QNetworkReply *)), this, SLOT(replyFinished(QNetworkReply *)));
+  connect(manager, SIGNAL(finished(QNetworkReply *)), this, SLOT(networkAccessManagerFinishedReply(QNetworkReply *)));
   connect(manager, SIGNAL(sslErrors(QNetworkReply *, QList<QSslError>)),
           this, SLOT(handleSslErrorsForReply(QNetworkReply *, QList<QSslError>)));
+  connect(manager, SIGNAL(requestCreated(QByteArray &, QNetworkReply *)), this, SLOT(networkAccessManagerCreatedRequest(QByteArray &, QNetworkReply *)));
+}
+
+void WebPage::networkAccessManagerCreatedRequest(QByteArray &url, QNetworkReply *reply) {
+  emit requestCreated(url, reply);
+}
+
+void WebPage::networkAccessManagerFinishedReply(QNetworkReply *reply) {
+  emit replyFinished(reply);
 }
 
 void WebPage::loadJavascript() {
@@ -69,6 +90,18 @@ QString WebPage::consoleMessages() {
   return m_consoleMessages.join("\n");
 }
 
+QString WebPage::alertMessages() {
+  return m_alertMessages.join("\n");
+}
+
+QString WebPage::confirmMessages() {
+  return m_confirmMessages.join("\n");
+}
+
+QString WebPage::promptMessages() {
+  return m_promptMessages.join("\n");
+}
+
 void WebPage::setUserAgent(QString userAgent) {
   m_userAgent = userAgent;
 }
@@ -87,7 +120,7 @@ bool WebPage::shouldInterruptJavaScript() {
   return false;
 }
 
-QVariant WebPage::invokeCapybaraFunction(const char *name, QStringList &arguments) {
+QVariant WebPage::invokeCapybaraFunction(const char *name, const QStringList &arguments) {
   QString qname(name);
   QString objectName("CapybaraInvocation");
   JavascriptInvocation invocation(qname, arguments);
@@ -96,7 +129,7 @@ QVariant WebPage::invokeCapybaraFunction(const char *name, QStringList &argument
   return currentFrame()->evaluateJavaScript(javascript);
 }
 
-QVariant WebPage::invokeCapybaraFunction(QString &name, QStringList &arguments) {
+QVariant WebPage::invokeCapybaraFunction(QString &name, const QStringList &arguments) {
   return invokeCapybaraFunction(name.toAscii().data(), arguments);
 }
 
@@ -110,30 +143,39 @@ void WebPage::javaScriptConsoleMessage(const QString &message, int lineNumber, c
 
 void WebPage::javaScriptAlert(QWebFrame *frame, const QString &message) {
   Q_UNUSED(frame);
+  m_alertMessages.append(message);
   std::cout << "ALERT: " << qPrintable(message) << std::endl;
 }
 
 bool WebPage::javaScriptConfirm(QWebFrame *frame, const QString &message) {
   Q_UNUSED(frame);
-  Q_UNUSED(message);
-  return true;
+  m_confirmMessages.append(message);
+  return m_confirm;
 }
 
 bool WebPage::javaScriptPrompt(QWebFrame *frame, const QString &message, const QString &defaultValue, QString *result) {
   Q_UNUSED(frame)
-  Q_UNUSED(message)
-  Q_UNUSED(defaultValue)
-  Q_UNUSED(result)
-  return false;
+  m_promptMessages.append(message);
+  if (m_prompt) {
+    if (m_prompt_text.isNull()) {
+      *result = defaultValue;
+    } else {
+      *result = m_prompt_text;
+    }
+  }
+  return m_prompt;
 }
 
 void WebPage::loadStarted() {
   m_loading = true;
+  m_errorPageMessage = QString();
 }
 
 void WebPage::loadFinished(bool success) {
+  Q_UNUSED(success);
   m_loading = false;
-  emit pageFinished(success);
+  emit pageFinished(!m_failed);
+  m_failed = false;
 }
 
 bool WebPage::isLoading() const {
@@ -141,7 +183,11 @@ bool WebPage::isLoading() const {
 }
 
 QString WebPage::failureString() {
-  return QString("Unable to load URL: ") + currentFrame()->requestedUrl().toString();
+  QString message = QString("Unable to load URL: ") + currentFrame()->requestedUrl().toString();
+  if (m_errorPageMessage.isEmpty())
+    return message;
+  else
+    return message + m_errorPageMessage;
 }
 
 bool WebPage::render(const QString &fileName) {
@@ -179,12 +225,17 @@ QString WebPage::chooseFile(QWebFrame *parentFrame, const QString &suggestedFile
 }
 
 bool WebPage::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output) {
-  Q_UNUSED(option);
   if (extension == ChooseMultipleFilesExtension) {
     QStringList names = QStringList() << getLastAttachedFileName();
     static_cast<ChooseMultipleFilesExtensionReturn*>(output)->fileNames = names;
     return true;
   }
+  else if (extension == QWebPage::ErrorPageExtension) {
+    ErrorPageExtensionOption *errorOption = (ErrorPageExtensionOption*) option;
+    m_errorPageMessage = " because of error loading " + errorOption->url.toString() + ": " + errorOption->errorString;
+    m_failed = true;
+    return false;
+  }
   return false;
 }
 
@@ -192,48 +243,82 @@ QString WebPage::getLastAttachedFileName() {
   return currentFrame()->evaluateJavaScript(QString("Capybara.lastAttachedFile")).toString();
 }
 
-void WebPage::replyFinished(QNetworkReply *reply) {
-  if (reply->url() == this->currentFrame()->url()) {
-    QStringList headers;
-    m_lastStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    QList<QByteArray> list = reply->rawHeaderList();
+void WebPage::handleSslErrorsForReply(QNetworkReply *reply, const QList<QSslError> &errors) {
+  if (m_manager->ignoreSslErrors())
+    reply->ignoreSslErrors(errors);
+}
 
-    int length = list.size();
-    for(int i = 0; i < length; i++) {
-      headers << list.at(i)+": "+reply->rawHeader(list.at(i));
-    }
+void WebPage::setSkipImageLoading(bool skip) {
+  settings()->setAttribute(QWebSettings::AutoLoadImages, !skip);
+}
+
+int WebPage::getLastStatus() {
+  return qobject_cast<NetworkAccessManager *>(networkAccessManager())->statusFor(currentFrame()->url());
+}
 
-    m_pageHeaders = headers.join("\n");
+const QList<QNetworkReply::RawHeaderPair> &WebPage::pageHeaders() {
+  return qobject_cast<NetworkAccessManager *>(networkAccessManager())->headersFor(currentFrame()->url());
+}
+
+void WebPage::handleUnsupportedContent(QNetworkReply *reply) {
+  QVariant contentMimeType = reply->header(QNetworkRequest::ContentTypeHeader);
+  if(!contentMimeType.isNull()) {
+    triggerAction(QWebPage::Stop);
+    UnsupportedContentHandler *handler = new UnsupportedContentHandler(this, reply);
+    if (reply->isFinished())
+      handler->renderNonHtmlContent();
+    else
+      handler->waitForReplyToFinish();
   }
 }
 
-void WebPage::handleSslErrorsForReply(QNetworkReply *reply, const QList<QSslError> &errors) {
-  if (m_ignoreSslErrors)
-    reply->ignoreSslErrors(errors);
+bool WebPage::supportsExtension(Extension extension) const {
+  if (extension == ErrorPageExtension)
+    return true;
+  else if (extension == ChooseMultipleFilesExtension)
+    return true;
+  else
+    return false;
 }
 
-void WebPage::ignoreSslErrors() {
-  m_ignoreSslErrors = true;
+QWebPage *WebPage::createWindow(WebWindowType type) {
+  Q_UNUSED(type);
+  return m_manager->createPage(this);
 }
 
-int WebPage::getLastStatus() {
-  return m_lastStatus;
+QString WebPage::uuid() {
+  return m_uuid;
 }
 
-void WebPage::resetResponseHeaders() {
-  m_lastStatus = 0;
-  m_pageHeaders = QString();
+QString WebPage::getWindowName() {
+  QVariant windowName = mainFrame()->evaluateJavaScript("window.name");
+
+  if (windowName.isValid())
+    return windowName.toString();
+  else
+    return "";
 }
 
-void WebPage::resetConsoleMessages() {
-  m_consoleMessages.clear();
+bool WebPage::matchesWindowSelector(QString selector) {
+  return (selector == getWindowName()           ||
+      selector == mainFrame()->title()          ||
+      selector == mainFrame()->url().toString() ||
+      selector == uuid());
 }
 
-QString WebPage::pageHeaders() {
-  return m_pageHeaders;
+void WebPage::setFocus() {
+  m_manager->setCurrentPage(this);
 }
 
-void WebPage::handleUnsupportedContent(QNetworkReply *reply) {
-  UnsupportedContentHandler *handler = new UnsupportedContentHandler(this, reply);
-  Q_UNUSED(handler);
+void WebPage::setConfirmAction(QString action) {
+  m_confirm = (action == "Yes");
 }
+
+void WebPage::setPromptAction(QString action) {
+  m_prompt = (action == "Yes");
+}
+
+void WebPage::setPromptText(QString text) {
+  m_prompt_text = text;
+}
+