capybara-webkit 0.14.2 → 1.0.0

data/src/Connection.cpp

@@ -6,6 +6,7 @@
 #include "PageLoadingCommand.h"
 #include "TimeoutCommand.h"
 #include "SocketCommand.h"
+#include "ErrorMessage.h"
 
 #include <QTcpSocket>
 
@@ -43,9 +44,8 @@ void Connection::pendingLoadFinished(bool success) {
 void Connection::writePageLoadFailure() {
   m_pageSuccess = true;
   QString message = currentPage()->failureString();
-  Response *response = new Response(false, message, this);
-  writeResponse(response);
-  delete response;
+  Response response(false, new ErrorMessage(message));
+  writeResponse(&response);
 }
 
 void Connection::finishCommand(Response *response) {
@@ -64,7 +64,7 @@ void Connection::writeResponse(Response *response) {
 
   QByteArray messageUtf8 = response->message();
   QString messageLength = QString::number(messageUtf8.size()) + "\n";
-  m_socket->write(messageLength.toAscii());
+  m_socket->write(messageLength.toLatin1());
   m_socket->write(messageUtf8);
 }
 

data/src/ConsoleMessages.cpp

@@ -9,6 +9,6 @@ ConsoleMessages::ConsoleMessages(WebPageManager *manager, QStringList &arguments
 void ConsoleMessages::start() {
   JsonSerializer serializer;
   QByteArray json = serializer.serialize(page()->consoleMessages());
-  emitFinished(true, json);
+  finish(true, json);
 }
 

data/src/CurrentUrl.cpp

@@ -7,8 +7,8 @@ CurrentUrl::CurrentUrl(WebPageManager *manager, QStringList &arguments, QObject
 
 void CurrentUrl::start() {
   QStringList arguments;
-  QVariant result = page()->invokeCapybaraFunction("currentUrl", arguments);
+  QVariant result = page()->currentFrame()->evaluateJavaScript("window.location.toString()");
   QString url = result.toString();
-  emitFinished(true, url);
+  finish(true, url);
 }
 

data/src/EnableLogging.cpp

@@ -6,5 +6,5 @@ EnableLogging::EnableLogging(WebPageManager *manager, QStringList &arguments, QO
 
 void EnableLogging::start() {
   manager()->enableLogging();
-  emitFinished(true);
+  finish(true);
 }

data/src/ErrorMessage.cpp

@@ -0,0 +1,26 @@
+#include "ErrorMessage.h"
+#include "JsonSerializer.h"
+
+ErrorMessage::ErrorMessage(QString message, QObject *parent) : QObject(parent) {
+  m_message = message;
+}
+
+ErrorMessage::ErrorMessage(QString type, QString message, QObject *parent) : QObject(parent) {
+  m_type = type;
+  m_message = message;
+}
+
+QByteArray ErrorMessage::toString() {
+  JsonSerializer serializer;
+
+  QVariantMap map;
+
+  if (m_type.isNull())
+    map["class"] = "InvalidResponseError";
+  else
+    map["class"] = m_type;
+
+  map["message"] = m_message;
+
+  return serializer.serialize(map);
+}

data/src/ErrorMessage.h

@@ -0,0 +1,21 @@
+#ifndef __ERROR_MESSAGE_H
+#define __ERROR_MESSAGE_H
+
+#include <QObject>
+#include <QString>
+#include <QByteArray>
+
+class ErrorMessage : public QObject {
+  Q_OBJECT
+
+  public:
+    ErrorMessage(QString message, QObject *parent = 0);
+    ErrorMessage(QString type, QString message, QObject *parent = 0);
+    QByteArray toString();
+
+  private:
+    QString m_type;
+    QString m_message;
+};
+
+#endif

data/src/Evaluate.cpp

@@ -10,5 +10,5 @@ Evaluate::Evaluate(WebPageManager *manager, QStringList &arguments, QObject *par
 void Evaluate::start() {
   QVariant result = page()->currentFrame()->evaluateJavaScript(arguments()[0]);
   JsonSerializer serializer;
-  emitFinished(true, serializer.serialize(result));
+  finish(true, serializer.serialize(result));
 }

data/src/Execute.cpp

@@ -1,6 +1,7 @@
 #include "Execute.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "ErrorMessage.h"
 
 Execute::Execute(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
@@ -9,9 +10,9 @@ void Execute::start() {
   QString script = arguments()[0] + QString("; 'success'");
   QVariant result = page()->currentFrame()->evaluateJavaScript(script);
   if (result.isValid()) {
-    emitFinished(true);
+    finish(true);
   } else {
-    emitFinished(false, QString("Javascript failed to execute"));
+    finish(false, new ErrorMessage("Javascript failed to execute"));
   }
 }
 

data/src/FindCss.cpp

@@ -0,0 +1,13 @@
+#include "FindCss.h"
+#include "WebPage.h"
+#include "WebPageManager.h"
+#include "InvocationResult.h"
+
+FindCss::FindCss(WebPageManager *manager, QStringList &arguments, QObject *parent) : JavascriptCommand(manager, arguments, parent) {
+}
+
+void FindCss::start() {
+  InvocationResult result = page()->invokeCapybaraFunction("findCss", arguments());
+  finish(&result);
+}
+

data/src/FindCss.h

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

data/src/FindXpath.cpp

@@ -0,0 +1,13 @@
+#include "FindXpath.h"
+#include "WebPage.h"
+#include "WebPageManager.h"
+#include "InvocationResult.h"
+
+FindXpath::FindXpath(WebPageManager *manager, QStringList &arguments, QObject *parent) : JavascriptCommand(manager, arguments, parent) {
+}
+
+void FindXpath::start() {
+  InvocationResult result = page()->invokeCapybaraFunction("findXpath", arguments());
+  finish(&result);
+}
+

data/src/FindXpath.h

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

data/src/FrameFocus.cpp

@@ -2,6 +2,7 @@
 #include "SocketCommand.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "ErrorMessage.h"
 
 FrameFocus::FrameFocus(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
@@ -51,7 +52,7 @@ void FrameFocus::focusId(QString name) {
 
 void FrameFocus::focusParent() {
   if (page()->currentFrame()->parentFrame() == 0) {
-    emitFinished(false, QString("Already at parent frame."));
+    finish(false, new ErrorMessage("Already at parent frame."));
   } else {
     page()->currentFrame()->parentFrame()->setFocus();
     success();
@@ -59,9 +60,9 @@ void FrameFocus::focusParent() {
 }
 
 void FrameFocus::frameNotFound() {
-  emitFinished(false, QString("Unable to locate frame. "));
+  finish(false, new ErrorMessage("Unable to locate frame."));
 }
 
 void FrameFocus::success() {
-  emitFinished(true);
+  finish(true);
 }

data/src/GetCookies.cpp

@@ -15,5 +15,5 @@ void GetCookies::start()
     m_buffer.append(cookie.toRawForm());
     m_buffer.append("\n");
   }
-  emitFinished(true, m_buffer);
+  finish(true, m_buffer);
 }

data/src/GetTimeout.cpp

@@ -5,5 +5,5 @@ GetTimeout::GetTimeout(WebPageManager *manager, QStringList &arguments, QObject
 }
 
 void GetTimeout::start() {
-  emitFinished(true, QString::number(manager()->getTimeout()));
+  finish(true, QString::number(manager()->getTimeout()));
 }

data/src/GetWindowHandle.cpp

@@ -7,5 +7,5 @@ GetWindowHandle::GetWindowHandle(WebPageManager *manager, QStringList &arguments
 }
 
 void GetWindowHandle::start() {
-  emitFinished(true, page()->uuid());
+  finish(true, page()->uuid());
 }

data/src/GetWindowHandles.cpp

@@ -17,5 +17,5 @@ void GetWindowHandles::start() {
   JsonSerializer serializer;
   QByteArray json = serializer.serialize(handles);
 
-  emitFinished(true, json);
+  finish(true, json);
 }

data/src/Header.cpp

@@ -9,11 +9,11 @@ Header::Header(WebPageManager *manager, QStringList &arguments, QObject *parent)
 void Header::start() {
   QString key = arguments()[0];
   QString value = arguments()[1];
-  NetworkAccessManager* networkAccessManager = page()->networkAccessManager();
+  NetworkAccessManager* networkAccessManager = manager()->networkAccessManager();
   if (key.toLower().replace("-", "_") == "user_agent") {
     page()->setUserAgent(value);
   } else {
     networkAccessManager->addHeader(key, value);
   }
-  emitFinished(true);
+  finish(true);
 }

data/src/Headers.cpp

@@ -6,11 +6,6 @@ Headers::Headers(WebPageManager *manager, QStringList &arguments, QObject *paren
 }
 
 void Headers::start() {
-  QStringList headers;
-
-  foreach(QNetworkReply::RawHeaderPair header, page()->pageHeaders())
-    headers << header.first+": "+header.second;
-
-  emitFinished(true, headers.join("\n"));
+  finish(true, page()->pageHeaders().join("\n"));
 }
 

data/src/IgnoreSslErrors.cpp

@@ -8,6 +8,6 @@ IgnoreSslErrors::IgnoreSslErrors(WebPageManager *manager, QStringList &arguments
 
 void IgnoreSslErrors::start() {
   manager()->setIgnoreSslErrors(true);
-  emitFinished(true);
+  finish(true);
 }
 

data/src/InvocationResult.cpp

@@ -0,0 +1,29 @@
+#include "InvocationResult.h"
+#include "ErrorMessage.h"
+
+InvocationResult::InvocationResult(QVariant result, bool error) {
+  m_result = result;
+  m_error = error;
+}
+
+const QVariant &InvocationResult::result() const {
+  return m_result;
+}
+
+bool InvocationResult::hasError() {
+  return m_error;
+}
+
+ErrorMessage *InvocationResult::errorMessage() {
+  if (!m_result.canConvert<QVariantMap>())
+    return new ErrorMessage(m_result.toString());
+
+  QVariantMap error = m_result.toMap();
+
+  QString message = error["message"].toString();
+
+  if (error["name"] == "Capybara.ClickFailed")
+    return new ErrorMessage("ClickFailed", message);
+  else
+    return new ErrorMessage(message);
+}

data/src/InvocationResult.h

@@ -0,0 +1,16 @@
+#include <QVariant>
+
+class ErrorMessage;
+
+class InvocationResult {
+  public:
+    InvocationResult(QVariant result, bool error = false);
+    const QVariant &result() const;
+    bool hasError();
+    ErrorMessage *errorMessage();
+
+  private:
+    QVariant m_result;
+    bool m_error;
+};
+

data/src/JavascriptAlertMessages.cpp

@@ -9,5 +9,5 @@ void JavascriptAlertMessages::start()
 {
   JsonSerializer serializer;
   QByteArray json = serializer.serialize(page()->alertMessages());
-  emitFinished(true, json);
+  finish(true, json);
 }

data/src/JavascriptCommand.cpp

@@ -0,0 +1,15 @@
+#include "JavascriptCommand.h"
+#include "WebPageManager.h"
+#include "InvocationResult.h"
+
+JavascriptCommand::JavascriptCommand(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
+}
+
+void JavascriptCommand::finish(InvocationResult *result) {
+  if (result->hasError())
+    SocketCommand::finish(false, result->errorMessage());
+  else {
+    QString message = result->result().toString();
+    SocketCommand::finish(true, message);
+  }
+}

data/src/JavascriptCommand.h

@@ -0,0 +1,20 @@
+#ifndef JAVASCRIPT_COMMAND_H
+#define JAVASCRIPT_COMMAND_H
+
+#include <QObject>
+#include <QStringList>
+#include "SocketCommand.h"
+
+class WebPage;
+class WebPageManager;
+class InvocationResult;
+
+class JavascriptCommand : public SocketCommand {
+  Q_OBJECT
+
+  public:
+    JavascriptCommand(WebPageManager *, QStringList &arguments, QObject *parent = 0);
+    void finish(InvocationResult *result);
+};
+
+#endif

data/src/JavascriptConfirmMessages.cpp

@@ -9,5 +9,5 @@ void JavascriptConfirmMessages::start()
 {
   JsonSerializer serializer;
   QByteArray json = serializer.serialize(page()->confirmMessages());
-  emitFinished(true, json);
+  finish(true, json);
 }

data/src/JavascriptInvocation.cpp

@@ -1,8 +1,14 @@
 #include "JavascriptInvocation.h"
+#include "WebPage.h"
+#include "InvocationResult.h"
+#include <QApplication>
+#include <QEvent>
+#include <QContextMenuEvent>
 
-JavascriptInvocation::JavascriptInvocation(const QString &functionName, const QStringList &arguments, QObject *parent) : QObject(parent) {
+JavascriptInvocation::JavascriptInvocation(const QString &functionName, const QStringList &arguments, WebPage *page, QObject *parent) : QObject(parent) {
   m_functionName = functionName;
   m_arguments = arguments;
+  m_page = page;
 }
 
 QString &JavascriptInvocation::functionName() {
@@ -12,3 +18,124 @@ QString &JavascriptInvocation::functionName() {
 QStringList &JavascriptInvocation::arguments() {
   return m_arguments;
 }
+
+QVariant JavascriptInvocation::getError() {
+  return m_error;
+}
+
+void JavascriptInvocation::setError(QVariant error) {
+  m_error = error;
+}
+
+InvocationResult JavascriptInvocation::invoke(QWebFrame *frame) {
+  frame->addToJavaScriptWindowObject("CapybaraInvocation", this);
+  QVariant result = frame->evaluateJavaScript("Capybara.invoke()");
+  if (getError().isValid())
+    return InvocationResult(getError(), true);
+  else
+    return InvocationResult(result);
+}
+
+void JavascriptInvocation::leftClick(int x, int y) {
+  QPoint mousePos(x, y);
+
+  hover(mousePos);
+  JavascriptInvocation::mouseEvent(QEvent::MouseButtonPress, mousePos, Qt::LeftButton);
+  JavascriptInvocation::mouseEvent(QEvent::MouseButtonRelease, mousePos, Qt::LeftButton);
+}
+
+void JavascriptInvocation::rightClick(int x, int y) {
+  QPoint mousePos(x, y);
+
+  hover(mousePos);
+  JavascriptInvocation::mouseEvent(QEvent::MouseButtonPress, mousePos, Qt::RightButton);
+
+  // swallowContextMenuEvent tries to fire contextmenu event in html page
+  QContextMenuEvent *event = new QContextMenuEvent(QContextMenuEvent::Mouse, mousePos);
+  m_page->swallowContextMenuEvent(event);
+
+  JavascriptInvocation::mouseEvent(QEvent::MouseButtonRelease, mousePos, Qt::RightButton);
+}
+
+void JavascriptInvocation::doubleClick(int x, int y) {
+  QPoint mousePos(x, y);
+
+  JavascriptInvocation::mouseEvent(QEvent::MouseButtonDblClick, mousePos, Qt::LeftButton);
+  JavascriptInvocation::mouseEvent(QEvent::MouseButtonRelease, mousePos, Qt::LeftButton);
+}
+
+void JavascriptInvocation::mouseEvent(QEvent::Type type, const QPoint &position, Qt::MouseButton button) {
+  QMouseEvent event(type, position, button, button, Qt::NoModifier);
+  QApplication::sendEvent(m_page, &event);
+}
+
+bool JavascriptInvocation::clickTest(QWebElement element, int absoluteX, int absoluteY) {
+  QPoint mousePos(absoluteX, absoluteY);
+  QWebHitTestResult res = m_page->mainFrame()->hitTestContent(mousePos);
+  return res.frame() == element.webFrame();
+}
+
+QVariantMap JavascriptInvocation::clickPosition(QWebElement element, int left, int top, int width, int height) {
+  QRect elementBox(left, top, width, height);
+  QRect viewport(QPoint(0, 0), m_page->viewportSize());
+  QRect boundedBox = elementBox.intersected(viewport);
+  QPoint mousePos = boundedBox.center();
+
+  QVariantMap m;
+  m["relativeX"] = mousePos.x();
+  m["relativeY"] = mousePos.y();
+
+  QWebFrame *parent = element.webFrame();
+  while (parent) {
+    elementBox.translate(parent->geometry().topLeft());
+    parent = parent->parentFrame();
+  }
+
+  boundedBox = elementBox.intersected(viewport);
+  mousePos = boundedBox.center();
+
+  m["absoluteX"] = mousePos.x();
+  m["absoluteY"] = mousePos.y();
+
+  return m;
+}
+
+void JavascriptInvocation::hover(int absoluteX, int absoluteY) {
+  QPoint mousePos(absoluteX, absoluteY);
+  hover(mousePos);
+}
+
+void JavascriptInvocation::hover(const QPoint &mousePos) {
+  mouseEvent(QEvent::MouseMove, mousePos, Qt::NoButton);
+}
+
+int JavascriptInvocation::keyCodeFor(const QChar &key) {
+  switch(key.unicode()) {
+    case 0x18:
+      return Qt::Key_Cancel;
+    case 0x08:
+      return Qt::Key_Backspace;
+    case 0x09:
+      return Qt::Key_Tab;
+    case 0x0A:
+      return Qt::Key_Return;
+    case 0x1B:
+      return Qt::Key_Escape;
+    case 0x7F:
+      return Qt::Key_Delete;
+    default:
+      int keyCode = key.toUpper().toLatin1();
+      if (keyCode >= Qt::Key_Space || keyCode <= Qt::Key_AsciiTilde)
+        return keyCode;
+      else
+        return Qt::Key_unknown;
+  }
+}
+
+void JavascriptInvocation::keypress(QChar key) {
+  int keyCode = keyCodeFor(key);
+  QKeyEvent event(QKeyEvent::KeyPress, keyCode, Qt::NoModifier, key);
+  QApplication::sendEvent(m_page, &event);
+  event = QKeyEvent(QKeyEvent::KeyRelease, keyCode, Qt::NoModifier, key);
+  QApplication::sendEvent(m_page, &event);
+}