imseng-capybara-webkit 0.12.1

data/src/CurrentUrl.cpp

@@ -0,0 +1,68 @@
+#include "CurrentUrl.h"
+#include "WebPage.h"
+
+CurrentUrl::CurrentUrl(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+/*
+ * This CurrentUrl command attempts to produce a current_url value consistent
+ * with that returned by the Selenium WebDriver Capybara driver.
+ *
+ * It does not currently return the correct value in the case of an iframe whose
+ * source URL results in a redirect because the loading of the iframe does not
+ * generate a history item. This is most likely a rare case and is consistent
+ * with the current behavior of the capybara-webkit driver.
+ *
+ * The following two values are *not* affected by Javascript pushState.
+ *
+ * QWebFrame->url()
+ * QWebHistoryItem.originalUrl()
+ *
+ * The following two values *are* affected by Javascript pushState.
+ *
+ * QWebFrame->requestedUrl()
+ * QWebHistoryItem.url()
+ *
+ * In the cases that we have access to both the QWebFrame values and the
+ * correct history item for that frame, we can compare the values and determine
+ * if a redirect occurred and if pushState was used. The table below describes
+ * the various combinations of URL values that are possible.
+ *
+ *   O -> originally requested URL
+ *   R -> URL after redirection
+ *   P -> URL set by pushState
+ *   * -> denotes the desired URL value from the frame
+ *
+ *               frame               history
+ * case          url   requestedUrl  url     originalUrl
+ * -----------------------------------------------------------------
+ * regular load    O     O*            O       O
+ *
+ * redirect w/o    R*    O             R       O
+ * pushState
+ *
+ * pushState       O     P*            P       O
+ * only
+ *
+ * redirect w/     R     P*            P       O
+ * pushState
+ *
+ * Based on the above information, we only need to check for the case of a
+ * redirect w/o pushState, in which case QWebFrame->url() will have the correct
+ * current_url value. In all other cases QWebFrame->requestedUrl() is correct.
+ */
+void CurrentUrl::start() {
+  QUrl humanUrl = wasRedirectedAndNotModifiedByJavascript() ?
+    page()->currentFrame()->url() : page()->currentFrame()->requestedUrl();
+  QByteArray encodedBytes = humanUrl.toEncoded();
+  emit finished(new Response(true, encodedBytes));
+}
+
+bool CurrentUrl::wasRegularLoad() {
+  return page()->currentFrame()->url() == page()->currentFrame()->requestedUrl();
+}
+
+bool CurrentUrl::wasRedirectedAndNotModifiedByJavascript() {
+  return !wasRegularLoad() && page()->currentFrame()->url() == page()->history()->currentItem().url();
+}
+

data/src/CurrentUrl.h

@@ -0,0 +1,16 @@
+#include "Command.h"
+
+class WebPage;
+
+class CurrentUrl : public Command {
+  Q_OBJECT
+
+  public:
+    CurrentUrl(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+
+  private:
+    bool wasRegularLoad();
+    bool wasRedirectedAndNotModifiedByJavascript();
+};
+

data/src/Evaluate.cpp

@@ -0,0 +1,84 @@
+#include "Evaluate.h"
+#include "WebPage.h"
+#include <iostream>
+
+Evaluate::Evaluate(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+  m_buffer = "";
+}
+
+void Evaluate::start() {
+  QVariant result = page()->currentFrame()->evaluateJavaScript(arguments()[0]);
+  addVariant(result);
+  emit finished(new Response(true, m_buffer));
+}
+
+void Evaluate::addVariant(QVariant &object) {
+  if (object.isValid()) {
+    switch(object.type()) {
+      case QMetaType::QString:
+        {
+          QString string = object.toString();
+          addString(string);
+        }
+        break;
+      case QMetaType::QVariantList:
+        {
+          QVariantList list = object.toList();
+          addArray(list);
+        }
+        break;
+      case QMetaType::Double:
+        m_buffer.append(object.toString());
+        break;
+      case QMetaType::QVariantMap:
+        {
+          QVariantMap map = object.toMap();
+          addMap(map);
+          break;
+        }
+      case QMetaType::Bool:
+        {
+          m_buffer.append(object.toString());
+          break;
+        }
+      default:
+        m_buffer.append("null");
+    }
+  } else {
+    m_buffer.append("null");
+  }
+}
+
+void Evaluate::addString(QString &string) {
+  QString escapedString(string);
+  escapedString.replace("\"", "\\\"");
+  m_buffer.append("\"");
+  m_buffer.append(escapedString);
+  m_buffer.append("\"");
+}
+
+void Evaluate::addArray(QVariantList &list) {
+  m_buffer.append("[");
+  for (int i = 0; i < list.length(); i++) {
+    if (i > 0)
+      m_buffer.append(",");
+    addVariant(list[i]);
+  }
+  m_buffer.append("]");
+}
+
+void Evaluate::addMap(QVariantMap &map) {
+  m_buffer.append("{");
+  QMapIterator<QString, QVariant> iterator(map);
+  while (iterator.hasNext()) {
+    iterator.next();
+    QString key = iterator.key();
+    QVariant value = iterator.value();
+    addString(key);
+    m_buffer.append(":");
+    addVariant(value);
+    if (iterator.hasNext())
+      m_buffer.append(",");
+  }
+  m_buffer.append("}");
+}

data/src/Evaluate.h

@@ -0,0 +1,22 @@
+#include "Command.h"
+
+#include <QVariantList>
+
+class WebPage;
+
+class Evaluate : public Command {
+  Q_OBJECT
+
+  public:
+    Evaluate(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+
+  private:
+    void addVariant(QVariant &object);
+    void addString(QString &string);
+    void addArray(QVariantList &list);
+    void addMap(QVariantMap &map);
+
+    QString m_buffer;
+};
+

data/src/Execute.cpp

@@ -0,0 +1,16 @@
+#include "Execute.h"
+#include "WebPage.h"
+
+Execute::Execute(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Execute::start() {
+  QString script = arguments()[0] + QString("; 'success'");
+  QVariant result = page()->currentFrame()->evaluateJavaScript(script);
+  if (result.isValid()) {
+    emit finished(new Response(true));
+  } else {
+    emit finished(new Response(false, QString("Javascript failed to execute")));
+  }
+}
+

data/src/Execute.h

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

data/src/Find.cpp

@@ -0,0 +1,19 @@
+#include "Find.h"
+#include "Command.h"
+#include "WebPage.h"
+
+Find::Find(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Find::start() {
+  QString message;
+  QVariant result = page()->invokeCapybaraFunction("find", arguments());
+
+  if (result.isValid()) {
+    message = result.toString();
+    emit finished(new Response(true, message));
+  } else {
+    emit finished(new Response(false, QString("Invalid XPath expression")));
+  }
+}
+

data/src/Find.h

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

data/src/FrameFocus.cpp

@@ -0,0 +1,66 @@
+#include "FrameFocus.h"
+#include "Command.h"
+#include "WebPage.h"
+
+FrameFocus::FrameFocus(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void FrameFocus::start() {
+  findFrames();
+  switch(arguments().length()) {
+    case 1:
+      focusId(arguments()[0]);
+      break;
+    case 2:
+      focusIndex(arguments()[1].toInt());
+      break;
+    default:
+      focusParent();
+  }
+}
+
+void FrameFocus::findFrames() {
+  frames = page()->currentFrame()->childFrames();
+}
+
+void FrameFocus::focusIndex(int index) {
+  if (isFrameAtIndex(index)) {
+    frames[index]->setFocus();
+    success();
+  } else {
+    frameNotFound();
+  }
+}
+
+bool FrameFocus::isFrameAtIndex(int index) {
+  return 0 <= index && index < frames.length();
+}
+
+void FrameFocus::focusId(QString name) {
+  for (int i = 0; i < frames.length(); i++) {
+    if (frames[i]->frameName().compare(name) == 0) {
+      frames[i]->setFocus();
+      success();
+      return;
+    }
+  }
+
+  frameNotFound();
+}
+
+void FrameFocus::focusParent() {
+  if (page()->currentFrame()->parentFrame() == 0) {
+    emit finished(new Response(false, QString("Already at parent frame.")));
+  } else {
+    page()->currentFrame()->parentFrame()->setFocus();
+    success();
+  }
+}
+
+void FrameFocus::frameNotFound() {
+  emit finished(new Response(false, QString("Unable to locate frame. ")));
+}
+
+void FrameFocus::success() {
+  emit finished(new Response(true));
+}

data/src/FrameFocus.h

@@ -0,0 +1,28 @@
+#include "Command.h"
+
+class WebPage;
+class QWebFrame;
+
+class FrameFocus : public Command {
+  Q_OBJECT
+
+  public:
+    FrameFocus(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+
+  private:
+    void findFrames();
+
+    void focusParent();
+
+    void focusIndex(int index);
+    bool isFrameAtIndex(int index);
+
+    void focusId(QString id);
+
+    void success();
+    void frameNotFound();
+
+    QList<QWebFrame *> frames;
+};
+

data/src/GetCookies.cpp

@@ -0,0 +1,20 @@
+#include "GetCookies.h"
+#include "WebPage.h"
+#include "NetworkCookieJar.h"
+
+GetCookies::GetCookies(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent)
+{
+  m_buffer = "";
+}
+
+void GetCookies::start()
+{
+  NetworkCookieJar *jar = qobject_cast<NetworkCookieJar*>(page()
+                                                          ->networkAccessManager()
+                                                          ->cookieJar());
+  foreach (QNetworkCookie cookie, jar->getAllCookies()) {
+    m_buffer.append(cookie.toRawForm());
+    m_buffer.append("\n");
+  }
+  emit finished(new Response(true, m_buffer));
+}

data/src/GetCookies.h

@@ -0,0 +1,14 @@
+#include "Command.h"
+
+class WebPage;
+
+class GetCookies : public Command {
+  Q_OBJECT;
+
+ public:
+  GetCookies(WebPage *page, QStringList &arguments, QObject *parent = 0);
+  virtual void start();
+
+ private:
+  QString m_buffer;
+};

data/src/Header.cpp

@@ -0,0 +1,18 @@
+#include "Header.h"
+#include "WebPage.h"
+#include "NetworkAccessManager.h"
+
+Header::Header(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Header::start() {
+  QString key = arguments()[0];
+  QString value = arguments()[1];
+  NetworkAccessManager* networkAccessManager = qobject_cast<NetworkAccessManager*>(page()->networkAccessManager());
+  if (key.toLower().replace("-", "_") == "user_agent") {
+    page()->setUserAgent(value);
+  } else {
+    networkAccessManager->addHeader(key, value);
+  }
+  emit finished(new Response(true));
+}

data/src/Header.h

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

data/src/Headers.cpp

@@ -0,0 +1,10 @@
+#include "Headers.h"
+#include "WebPage.h"
+
+Headers::Headers(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Headers::start() {
+  emit finished(new Response(true, page()->pageHeaders()));
+}
+

data/src/Headers.h

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

data/src/IgnoreSslErrors.cpp

@@ -0,0 +1,12 @@
+#include "IgnoreSslErrors.h"
+#include "WebPage.h"
+
+IgnoreSslErrors::IgnoreSslErrors(WebPage *page, QStringList &arguments, QObject *parent) :
+  Command(page, arguments, parent) {
+}
+
+void IgnoreSslErrors::start() {
+  page()->ignoreSslErrors();
+  emit finished(new Response(true));
+}
+

data/src/IgnoreSslErrors.h

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

data/src/JavascriptInvocation.cpp

@@ -0,0 +1,14 @@
+#include "JavascriptInvocation.h"
+
+JavascriptInvocation::JavascriptInvocation(QString &functionName, QStringList &arguments, QObject *parent) : QObject(parent) {
+  m_functionName = functionName;
+  m_arguments = arguments;
+}
+
+QString &JavascriptInvocation::functionName() {
+  return m_functionName;
+}
+
+QStringList &JavascriptInvocation::arguments() {
+  return m_arguments;
+}

data/src/JavascriptInvocation.h

@@ -0,0 +1,19 @@
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+class JavascriptInvocation : public QObject {
+  Q_OBJECT
+  Q_PROPERTY(QString functionName READ functionName)
+  Q_PROPERTY(QStringList arguments READ arguments)
+
+  public:
+    JavascriptInvocation(QString &functionName, QStringList &arguments, QObject *parent = 0);
+    QString &functionName();
+    QStringList &arguments();
+
+  private:
+    QString m_functionName;
+    QStringList m_arguments;
+};
+

data/src/NetworkAccessManager.cpp

@@ -0,0 +1,29 @@
+#include "NetworkAccessManager.h"
+#include "WebPage.h"
+#include <iostream>
+
+
+NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManager(parent) {
+}
+
+QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
+  QNetworkRequest new_request(request);
+  if (operation != QNetworkAccessManager::PostOperation && operation != QNetworkAccessManager::PutOperation) {
+    new_request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
+  }
+  QHashIterator<QString, QString> item(m_headers);
+  while (item.hasNext()) {
+      item.next();
+      new_request.setRawHeader(item.key().toAscii(), item.value().toAscii());
+  }
+  return QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
+};
+
+void NetworkAccessManager::addHeader(QString key, QString value) {
+  m_headers.insert(key, value);
+};
+
+void NetworkAccessManager::resetHeaders() {
+  m_headers.clear();
+};
+

data/src/NetworkAccessManager.h

@@ -0,0 +1,19 @@
+#include <QtNetwork/QNetworkAccessManager>
+#include <QtNetwork/QNetworkRequest>
+#include <QtNetwork/QNetworkReply>
+
+class NetworkAccessManager : public QNetworkAccessManager {
+
+  Q_OBJECT
+
+  public:
+    NetworkAccessManager(QObject *parent = 0);
+    void addHeader(QString key, QString value);
+    void resetHeaders();
+
+  protected:
+    QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &req, QIODevice * outgoingData);
+
+  private:
+    QHash<QString, QString> m_headers;
+};

data/src/NetworkCookieJar.cpp

@@ -0,0 +1,101 @@
+#include "NetworkCookieJar.h"
+#include "QtCore/qdatetime.h"
+
+NetworkCookieJar::NetworkCookieJar(QObject *parent)
+  : QNetworkCookieJar(parent)
+{ }
+
+QList<QNetworkCookie> NetworkCookieJar::getAllCookies() const
+{
+  return allCookies();
+}
+
+void NetworkCookieJar::clearCookies()
+{
+  setAllCookies(QList<QNetworkCookie>());
+}
+
+static inline bool isParentDomain(QString domain, QString reference)
+{
+  if (!reference.startsWith(QLatin1Char('.')))
+    return domain == reference;
+
+  return domain.endsWith(reference) || domain == reference.mid(1);
+}
+
+void NetworkCookieJar::overwriteCookies(const QList<QNetworkCookie>& cookieList)
+{
+  /* this function is basically a copy-and-paste of the original
+     QNetworkCookieJar::setCookiesFromUrl with the domain and
+     path validations removed */
+
+  QString defaultPath(QLatin1Char('/'));
+  QDateTime now = QDateTime::currentDateTime();
+  QList<QNetworkCookie> newCookies = allCookies();
+
+  foreach (QNetworkCookie cookie, cookieList) {
+    bool isDeletion = (!cookie.isSessionCookie() &&
+                       cookie.expirationDate() < now);
+
+    // validate the cookie & set the defaults if unset
+    if (cookie.path().isEmpty())
+      cookie.setPath(defaultPath);
+
+    // don't do path checking. See http://bugreports.qt.nokia.com/browse/QTBUG-5815
+    //        else if (!isParentPath(pathAndFileName, cookie.path())) {
+    //            continue;           // not accepted
+    //        }
+
+    if (cookie.domain().isEmpty()) {
+      continue;
+    } else {
+      // Ensure the domain starts with a dot if its field was not empty
+      // in the HTTP header. There are some servers that forget the
+      // leading dot and this is actually forbidden according to RFC 2109,
+      // but all browsers accept it anyway so we do that as well.
+      if (!cookie.domain().startsWith(QLatin1Char('.')))
+        cookie.setDomain(QLatin1Char('.') + cookie.domain());
+
+      QString domain = cookie.domain();
+
+      // the check for effective TLDs makes the "embedded dot" rule from RFC 2109 section 4.3.2
+      // redundant; the "leading dot" rule has been relaxed anyway, see above
+      // we remove the leading dot for this check
+      /*
+      if (QNetworkCookieJarPrivate::isEffectiveTLD(domain.remove(0, 1)))
+        continue; // not accepted
+      */
+    }
+
+    for (int i = 0; i < newCookies.size(); ++i) {
+      // does this cookie already exist?
+      const QNetworkCookie &current = newCookies.at(i);
+      if (cookie.name() == current.name() &&
+          cookie.domain() == current.domain() &&
+          cookie.path() == current.path()) {
+        // found a match
+        newCookies.removeAt(i);
+        break;
+      }
+    }
+
+    // did not find a match
+    if (!isDeletion) {
+      int countForDomain = 0;
+      for (int i = newCookies.size() - 1; i >= 0; --i) {
+        // Start from the end and delete the oldest cookies to keep a maximum count of 50.
+        const QNetworkCookie &current = newCookies.at(i);
+        if (isParentDomain(cookie.domain(), current.domain())
+            || isParentDomain(current.domain(), cookie.domain())) {
+          if (countForDomain >= 49)
+            newCookies.removeAt(i);
+          else
+            ++countForDomain;
+        }
+      }
+
+      newCookies += cookie;
+    }
+  }
+  setAllCookies(newCookies);
+}

data/src/NetworkCookieJar.h

@@ -0,0 +1,15 @@
+#include <QtNetwork/QNetworkCookieJar>
+#include <QtNetwork/QNetworkCookie>
+
+class NetworkCookieJar : public QNetworkCookieJar {
+
+  Q_OBJECT;
+
+ public:
+
+  NetworkCookieJar(QObject *parent = 0);
+
+  QList<QNetworkCookie> getAllCookies() const;
+  void clearCookies();
+  void overwriteCookies(const QList<QNetworkCookie>& cookieList);
+};