capybara-webkit 0.12.1 → 0.13.0

data/src/WebPage.h

@@ -1,24 +1,37 @@
+#ifndef _WEBPAGE_H
+#define _WEBPAGE_H
 #include <QtWebKit>
 
+class WebPageManager;
+
 class WebPage : public QWebPage {
   Q_OBJECT
 
   public:
-    WebPage(QObject *parent = 0);
-    QVariant invokeCapybaraFunction(const char *name, QStringList &arguments);
-    QVariant invokeCapybaraFunction(QString &name, QStringList &arguments);
+    WebPage(WebPageManager *, QObject *parent = 0);
+    QVariant invokeCapybaraFunction(const char *name, const QStringList &arguments);
+    QVariant invokeCapybaraFunction(QString &name, const QStringList &arguments);
     QString failureString();
     QString userAgentForUrl(const QUrl &url ) const;
     void setUserAgent(QString userAgent);
+    void setConfirmAction(QString action);
+    void setPromptAction(QString action);
+    void setPromptText(QString action);
     int getLastStatus();
-    void resetResponseHeaders();
     void setCustomNetworkAccessManager();
     bool render(const QString &fileName);
     virtual bool extension (Extension extension, const ExtensionOption *option=0, ExtensionReturn *output=0);
-    void ignoreSslErrors();
+    void setSkipImageLoading(bool skip);
     QString consoleMessages();
-    void resetConsoleMessages();
+    QString alertMessages();
+    QString confirmMessages();
+    QString promptMessages();
     void resetWindowSize();
+    QWebPage *createWindow(WebWindowType type);
+    QString uuid();
+    QString getWindowName();
+    bool matchesWindowSelector(QString);
+    void setFocus();
 
   public slots:
     bool shouldInterruptJavaScript();
@@ -26,14 +39,17 @@ class WebPage : public QWebPage {
     void loadStarted();
     void loadFinished(bool);
     bool isLoading() const;
-    QString pageHeaders();
+    const QList<QNetworkReply::RawHeaderPair> &pageHeaders();
     void frameCreated(QWebFrame *);
-    void replyFinished(QNetworkReply *reply);
     void handleSslErrorsForReply(QNetworkReply *reply, const QList<QSslError> &);
     void handleUnsupportedContent(QNetworkReply *reply);
+    void networkAccessManagerCreatedRequest(QByteArray &url, QNetworkReply *reply);
+    void networkAccessManagerFinishedReply(QNetworkReply *reply);
 
   signals:
     void pageFinished(bool);
+    void requestCreated(QByteArray &url, QNetworkReply *reply);
+    void replyFinished(QNetworkReply *reply);
 
   protected:
     virtual void javaScriptConsoleMessage(const QString &message, int lineNumber, const QString &sourceID);
@@ -41,17 +57,27 @@ class WebPage : public QWebPage {
     virtual bool javaScriptConfirm(QWebFrame *frame, const QString &message);
     virtual bool javaScriptPrompt(QWebFrame *frame, const QString &message, const QString &defaultValue, QString *result);
     virtual QString chooseFile(QWebFrame * parentFrame, const QString &suggestedFile);
+    virtual bool supportsExtension(Extension extension) const;
 
   private:
     QString m_capybaraJavascript;
     QString m_userAgent;
     bool m_loading;
+    bool m_failed;
     QString getLastAttachedFileName();
     void loadJavascript();
     void setUserStylesheet();
-    int m_lastStatus;
-    QString m_pageHeaders;
-    bool m_ignoreSslErrors;
+    bool m_confirm;
+    bool m_prompt;
     QStringList m_consoleMessages;
+    QStringList m_alertMessages;
+    QStringList m_confirmMessages;
+    QString m_prompt_text;
+    QStringList m_promptMessages;
+    QString m_uuid;
+    WebPageManager *m_manager;
+    QString m_errorPageMessage;
 };
 
+#endif //_WEBPAGE_H
+

data/src/WebPageManager.cpp

@@ -0,0 +1,127 @@
+#include "WebPageManager.h"
+#include "WebPage.h"
+#include "NetworkCookieJar.h"
+
+WebPageManager::WebPageManager(QObject *parent) : QObject(parent) {
+  m_ignoreSslErrors = false;
+  m_cookieJar = new NetworkCookieJar(this);
+  m_success = true;
+  m_loggingEnabled = false;
+  m_ignoredOutput = new QString();
+  m_timeout = -1;
+  createPage(this)->setFocus();
+}
+
+void WebPageManager::append(WebPage *value) {
+  m_pages.append(value);
+}
+
+QList<WebPage *> WebPageManager::pages() const {
+  return m_pages;
+}
+
+void WebPageManager::setCurrentPage(WebPage *page) {
+  m_currentPage = page;
+}
+
+WebPage *WebPageManager::currentPage() const {
+  return m_currentPage;
+}
+
+WebPage *WebPageManager::createPage(QObject *parent) {
+  WebPage *page = new WebPage(this, parent);
+  connect(page, SIGNAL(loadStarted()),
+          this, SLOT(emitLoadStarted()));
+  connect(page, SIGNAL(pageFinished(bool)),
+          this, SLOT(setPageStatus(bool)));
+  connect(page, SIGNAL(requestCreated(QByteArray &, QNetworkReply *)),
+          this, SLOT(requestCreated(QByteArray &, QNetworkReply *)));
+  connect(page, SIGNAL(replyFinished(QNetworkReply *)),
+          this, SLOT(replyFinished(QNetworkReply *)));
+  append(page);
+  return page;
+}
+
+void WebPageManager::emitLoadStarted() {
+  if (m_started.empty()) {
+    logger() << "Load started";
+    emit loadStarted();
+  }
+}
+
+void WebPageManager::requestCreated(QByteArray &url, QNetworkReply *reply) {
+  logger() << "Started request to" << url;
+  m_started += reply;
+}
+
+void WebPageManager::replyFinished(QNetworkReply *reply) {
+  int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  logger() << "Received" << status << "from" << reply->url().toString();
+  m_started.remove(reply);
+  logger() << m_started.size() << "requests remaining";
+  if (m_started.empty() && !m_success) {
+    emitPageFinished();
+  }
+}
+
+void WebPageManager::setPageStatus(bool success) {
+  logger() << "Page finished with" << success;
+  m_success = success && m_success;
+  if (m_started.empty()) {
+    emitPageFinished();
+  }
+}
+
+void WebPageManager::emitPageFinished() {
+  logger() << "Load finished";
+  emit pageFinished(m_success);
+  m_success = true;
+}
+
+void WebPageManager::setIgnoreSslErrors(bool value) {
+  m_ignoreSslErrors = value;
+}
+
+bool WebPageManager::ignoreSslErrors() {
+  return m_ignoreSslErrors;
+}
+
+int WebPageManager::getTimeout() {
+  return m_timeout;
+}
+
+void WebPageManager::setTimeout(int timeout) {
+  m_timeout = timeout;
+}
+
+void WebPageManager::reset() {
+  m_timeout = -1;
+  m_cookieJar->clearCookies();
+  m_pages.first()->deleteLater();
+  m_pages.clear();
+  createPage(this)->setFocus();
+}
+
+NetworkCookieJar *WebPageManager::cookieJar() {
+  return m_cookieJar;
+}
+
+bool WebPageManager::isLoading() const {
+  foreach(WebPage *page, pages()) {
+    if (page->isLoading()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+QDebug WebPageManager::logger() const {
+  if (m_loggingEnabled)
+    return qDebug();
+  else
+    return QDebug(m_ignoredOutput);
+}
+
+void WebPageManager::enableLogging() {
+  m_loggingEnabled = true;
+}

data/src/WebPageManager.h

@@ -0,0 +1,59 @@
+#ifndef _WEBPAGEMANAGER_H
+#define _WEBPAGEMANAGER_H
+#include <QList>
+#include <QSet>
+#include <QObject>
+#include <QNetworkReply>
+#include <QDebug>
+#include <QFile>
+
+class WebPage;
+class NetworkCookieJar;
+
+class WebPageManager : public QObject {
+  Q_OBJECT
+
+  public:
+    WebPageManager(QObject *parent = 0);
+    void append(WebPage *value);
+    QList<WebPage *> pages() const;
+    void setCurrentPage(WebPage *);
+    WebPage *currentPage() const;
+    WebPage *createPage(QObject *parent);
+    void setIgnoreSslErrors(bool);
+    bool ignoreSslErrors();
+    void setTimeout(int);
+    int getTimeout();
+    void reset();
+    NetworkCookieJar *cookieJar();
+    bool isLoading() const;
+    QDebug logger() const;
+    void enableLogging();
+
+  public slots:
+    void emitLoadStarted();
+    void setPageStatus(bool);
+    void requestCreated(QByteArray &url, QNetworkReply *reply);
+    void replyFinished(QNetworkReply *reply);
+
+  signals:
+    void pageFinished(bool);
+    void loadStarted();
+
+  private:
+    void emitPageFinished();
+    static void handleDebugMessage(QtMsgType type, const char *message);
+
+    QList<WebPage *> m_pages;
+    WebPage *m_currentPage;
+    bool m_ignoreSslErrors;
+    NetworkCookieJar *m_cookieJar;
+    QSet<QNetworkReply*> m_started;
+    bool m_success;
+    bool m_loggingEnabled;
+    QString *m_ignoredOutput;
+    int m_timeout;
+};
+
+#endif // _WEBPAGEMANAGER_H
+

data/src/WindowFocus.cpp

@@ -0,0 +1,32 @@
+#include "WindowFocus.h"
+#include "SocketCommand.h"
+#include "WebPage.h"
+#include "CommandFactory.h"
+#include "WebPageManager.h"
+
+WindowFocus::WindowFocus(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
+}
+
+void WindowFocus::start() {
+  focusWindow(arguments()[0]);
+}
+
+void WindowFocus::windowNotFound() {
+  emit finished(new Response(false, QString("Unable to locate window. ")));
+}
+
+void WindowFocus::success(WebPage *page) {
+  page->setFocus();
+  emit finished(new Response(true));
+}
+
+void WindowFocus::focusWindow(QString selector) {
+  foreach(WebPage *page, manager()->pages()) {
+    if (page->matchesWindowSelector(selector)) {
+      success(page);
+      return;
+    }
+  }
+
+  windowNotFound();
+}

data/src/WindowFocus.h

@@ -0,0 +1,15 @@
+#include "SocketCommand.h"
+
+class WindowFocus : public SocketCommand {
+  Q_OBJECT
+
+  public:
+    WindowFocus(WebPageManager *, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+
+  private:
+    void success(WebPage *);
+    void windowNotFound();
+    void focusWindow(QString);
+};
+

data/src/body.cpp

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

data/src/capybara.js

@@ -11,6 +11,10 @@ Capybara = {
     return this.findRelativeTo(document, xpath);
   },
 
+  currentUrl: function () {
+    return window.location.toString();
+  },
+
   findWithin: function (index, xpath) {
     return this.findRelativeTo(this.nodes[index], xpath);
   },
@@ -51,6 +55,10 @@ Capybara = {
       return this.nodes[index].disabled;
       break;
 
+    case 'multiple':
+      return this.nodes[index].multiple;
+      break;
+
     default:
       return this.nodes[index].getAttribute(name);
     }
@@ -110,6 +118,7 @@ Capybara = {
 
   click: function (index) {
     this.mousedown(index);
+    this.focus(index);
     this.mouseup(index);
     var clickEvent = document.createEvent('MouseEvents');
     clickEvent.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
@@ -148,8 +157,10 @@ Capybara = {
   visible: function (index) {
     var element = this.nodes[index];
     while (element) {
-      if (element.ownerDocument.defaultView.getComputedStyle(element, null).getPropertyValue("display") == 'none')
+      var style = element.ownerDocument.defaultView.getComputedStyle(element, null);
+      if (style.getPropertyValue("display") == 'none' || style.getPropertyValue("visibility") == 'hidden')
         return false;
+
       element = element.parentElement;
     }
     return true;
@@ -163,6 +174,15 @@ Capybara = {
     return this.nodes[index].value;
   },
 
+  getInnerHTML: function(index) {
+    return this.nodes[index].innerHTML;
+  },
+
+  setInnerHTML: function(index, value) {
+    this.nodes[index].innerHTML = value;
+    return true;
+  },
+
   characterToKeyCode: function(character) {
     var code = character.toUpperCase().charCodeAt(0);
     var specialKeys = {
@@ -214,7 +234,7 @@ Capybara = {
     textTypes = ["email", "number", "password", "search", "tel", "text", "textarea", "url"];
 
     if (textTypes.indexOf(type) != -1) {
-      this.trigger(index, "focus");
+      this.focus(index);
 
       maxLength = this.attribute(index, "maxlength");
       if (maxLength && value.length > maxLength) {
@@ -233,22 +253,25 @@ Capybara = {
         this.trigger(index, "input");
       }
       this.trigger(index, "change");
-      this.trigger(index, "blur");
 
     } else if (type === "checkbox" || type === "radio") {
       if (node.checked != (value === "true")) {
-        this.click(index)
+        this.click(index);
       }
 
     } else if (type === "file") {
       this.lastAttachedFile = value;
-      this.click(index)
+      this.click(index);
 
     } else {
       node.value = value;
     }
   },
 
+  focus: function(index) {
+    this.nodes[index].focus();
+  },
+
   selectOption: function(index) {
     this.nodes[index].selected = true;
     this.trigger(index, "change");
@@ -270,7 +293,8 @@ Capybara = {
         position.x += element.offsetLeft;
         position.y += element.offsetTop;
     } while ((element = element.offsetParent));
-    position.x = Math.floor(position.x), position.y = Math.floor(position.y);
+    position.x = Math.floor(position.x);
+    position.y = Math.floor(position.y);
 
     return position;
   },
@@ -282,7 +306,9 @@ Capybara = {
         oldStyle[prop] = element.style[prop];
         element.style[prop] = newStyle[prop];
       }
-      element.offsetWidth, element.offsetHeight; // force reflow
+      // force reflow
+      element.offsetWidth;
+      element.offsetHeight;
       for (prop in oldStyle)
         element.style[prop] = oldStyle[prop];
     }
@@ -299,12 +325,14 @@ Capybara = {
       var eventObject = document.createEvent("MouseEvents");
       eventObject.initMouseEvent(eventName, true, true, window, 0, 0, 0, options.clientX || 0, options.clientY || 0, false, false, false, false, 0, null);
       element.dispatchEvent(eventObject);
-    }
+    };
     mouseTrigger('mousedown', options);
-    options.clientX += 1, options.clientY += 1;
+    options.clientX += 1;
+    options.clientY += 1;
     mouseTrigger('mousemove', options);
 
-    position = this.centerPostion(target), options = {
+    position = this.centerPostion(target);
+    options = {
       clientX: position.x,
       clientY: position.y
     };