otherinbox-capybara-webkit 0.12.0

data/src/CommandParser.h

@@ -0,0 +1,33 @@
+#include <QObject>
+#include <QStringList>
+
+class QIODevice;
+class CommandFactory;
+class Command;
+
+class CommandParser : public QObject {
+  Q_OBJECT
+
+  public:
+    CommandParser(QIODevice *device, CommandFactory *commandFactory, QObject *parent = 0);
+
+  public slots:
+    void checkNext();
+
+  signals:
+    void commandReady(Command *command);
+
+  private:
+    void readLine();
+    void readDataBlock();
+    void processNext(const char *line);
+    void processArgument(const char *data);
+    void reset();
+    QIODevice *m_device;
+    QString m_commandName;
+    QStringList m_arguments;
+    int m_argumentsExpected;
+    int m_expectingDataSize;
+    CommandFactory *m_commandFactory;
+};
+

data/src/Connection.cpp

@@ -0,0 +1,71 @@
+#include "Connection.h"
+#include "WebPage.h"
+#include "CommandParser.h"
+#include "CommandFactory.h"
+#include "PageLoadingCommand.h"
+#include "Command.h"
+
+#include <QTcpSocket>
+
+Connection::Connection(QTcpSocket *socket, WebPage *page, QObject *parent) :
+    QObject(parent) {
+  m_socket = socket;
+  m_page = page;
+  m_commandFactory = new CommandFactory(page, this);
+  m_commandParser = new CommandParser(socket, m_commandFactory, this);
+  m_pageSuccess = true;
+  m_commandWaiting = false;
+  connect(m_socket, SIGNAL(readyRead()), m_commandParser, SLOT(checkNext()));
+  connect(m_commandParser, SIGNAL(commandReady(Command *)), this, SLOT(commandReady(Command *)));
+  connect(m_page, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+}
+
+void Connection::commandReady(Command *command) {
+  m_queuedCommand = command;
+  if (m_page->isLoading())
+    m_commandWaiting = true;
+  else
+    startCommand();
+}
+
+void Connection::startCommand() {
+  m_commandWaiting = false;
+  if (m_pageSuccess) {
+    m_runningCommand = new PageLoadingCommand(m_queuedCommand, m_page, this);
+    connect(m_runningCommand, SIGNAL(finished(Response *)), this, SLOT(finishCommand(Response *)));
+    m_runningCommand->start();
+  } else {
+    writePageLoadFailure();
+  }
+}
+
+void Connection::pendingLoadFinished(bool success) {
+  m_pageSuccess = success;
+  if (m_commandWaiting)
+    startCommand();
+}
+
+void Connection::writePageLoadFailure() {
+  m_pageSuccess = true;
+  QString message = m_page->failureString();
+  writeResponse(new Response(false, message));
+}
+
+void Connection::finishCommand(Response *response) {
+  m_runningCommand->deleteLater();
+  writeResponse(response);
+}
+
+void Connection::writeResponse(Response *response) {
+  if (response->isSuccess())
+    m_socket->write("ok\n");
+  else
+    m_socket->write("failure\n");
+
+  QByteArray messageUtf8 = response->message();
+  QString messageLength = QString::number(messageUtf8.size()) + "\n";
+  m_socket->write(messageLength.toAscii());
+  m_socket->write(messageUtf8);
+  delete response;
+}
+

data/src/Connection.h

@@ -0,0 +1,37 @@
+#include <QObject>
+#include <QStringList>
+
+class QTcpSocket;
+class WebPage;
+class Command;
+class Response;
+class CommandParser;
+class CommandFactory;
+class PageLoadingCommand;
+
+class Connection : public QObject {
+  Q_OBJECT
+
+  public:
+    Connection(QTcpSocket *socket, WebPage *page, QObject *parent = 0);
+
+  public slots:
+    void commandReady(Command *command);
+    void finishCommand(Response *response);
+    void pendingLoadFinished(bool success);
+
+  private:
+    void startCommand();
+    void writeResponse(Response *response);
+    void writePageLoadFailure();
+
+    QTcpSocket *m_socket;
+    Command *m_queuedCommand;
+    WebPage *m_page;
+    CommandParser *m_commandParser;
+    CommandFactory *m_commandFactory;
+    PageLoadingCommand *m_runningCommand;
+    bool m_pageSuccess;
+    bool m_commandWaiting;
+};
+

data/src/ConsoleMessages.cpp

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

data/src/ConsoleMessages.h

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

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));
+}