capybara-webkit 0.14.2 → 1.0.0

data/src/JavascriptInvocation.h

@@ -1,19 +1,40 @@
 #include <QObject>
 #include <QString>
 #include <QStringList>
+#include <QEvent>
+#include <QWebElement>
+
+class WebPage;
+class InvocationResult;
 
 class JavascriptInvocation : public QObject {
   Q_OBJECT
   Q_PROPERTY(QString functionName READ functionName)
   Q_PROPERTY(QStringList arguments READ arguments)
+  Q_PROPERTY(QVariant error READ getError WRITE setError)
 
   public:
-    JavascriptInvocation(const QString &functionName, const QStringList &arguments, QObject *parent = 0);
+    JavascriptInvocation(const QString &functionName, const QStringList &arguments, WebPage *page, QObject *parent = 0);
     QString &functionName();
     QStringList &arguments();
+    Q_INVOKABLE void leftClick(int x, int y);
+    Q_INVOKABLE void rightClick(int x, int y);
+    Q_INVOKABLE void doubleClick(int x, int y);
+    Q_INVOKABLE bool clickTest(QWebElement element, int absoluteX, int absoluteY);
+    Q_INVOKABLE QVariantMap clickPosition(QWebElement element, int left, int top, int width, int height);
+    Q_INVOKABLE void hover(int absoluteX, int absoluteY);
+    Q_INVOKABLE void keypress(QChar);
+    QVariant getError();
+    void setError(QVariant error);
+    InvocationResult invoke(QWebFrame *);
 
   private:
     QString m_functionName;
     QStringList m_arguments;
+    WebPage *m_page;
+    QVariant m_error;
+    void mouseEvent(QEvent::Type type, const QPoint & position, Qt::MouseButton button);
+    void hover(const QPoint &);
+    int keyCodeFor(const QChar &);
 };
 

data/src/JavascriptPromptMessages.cpp

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

data/src/NetworkAccessManager.cpp

@@ -3,6 +3,7 @@
 #include <iostream>
 #include <fstream>
 #include "NoOpReply.h"
+#include "NetworkReplyProxy.h"
 
 NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManager(parent) {
   connect(this, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), SLOT(provideAuthentication(QNetworkReply*,QAuthenticator*)));
@@ -13,7 +14,7 @@ QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operat
   QNetworkRequest new_request(request);
   QByteArray url = new_request.url().toEncoded();
   if (this->isBlacklisted(new_request.url())) {
-    return new NoOpReply(new_request, this);
+    return new NetworkReplyProxy(new NoOpReply(new_request), this);
   } else {
     if (operation != QNetworkAccessManager::PostOperation && operation != QNetworkAccessManager::PutOperation) {
       new_request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
@@ -21,9 +22,9 @@ QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operat
     QHashIterator<QString, QString> item(m_headers);
     while (item.hasNext()) {
         item.next();
-        new_request.setRawHeader(item.key().toAscii(), item.value().toAscii());
+        new_request.setRawHeader(item.key().toLatin1(), item.value().toLatin1());
     }
-    QNetworkReply *reply = QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
+    QNetworkReply *reply = new NetworkReplyProxy(QNetworkAccessManager::createRequest(operation, new_request, outgoingData), this);
     emit requestCreated(url, reply);
     return reply;
   }
@@ -37,10 +38,7 @@ void NetworkAccessManager::finished(QNetworkReply *reply) {
     QUrl requestedUrl = reply->url();
     while (m_redirectMappings.contains(requestedUrl))
       requestedUrl = m_redirectMappings.take(requestedUrl);
-    NetworkResponse response;
-    response.statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    response.headers = reply->rawHeaderPairs();
-    m_responses[requestedUrl] = response;
+    emit finished(requestedUrl, reply);
   }
 }
 
@@ -48,8 +46,10 @@ void NetworkAccessManager::addHeader(QString key, QString value) {
   m_headers.insert(key, value);
 }
 
-void NetworkAccessManager::resetHeaders() {
+void NetworkAccessManager::reset() {
   m_headers.clear();
+  m_userName = QString();
+  m_password = QString();
 }
 
 void NetworkAccessManager::setUserName(const QString &userName) {
@@ -68,14 +68,6 @@ void NetworkAccessManager::provideAuthentication(QNetworkReply *reply, QAuthenti
     authenticator->setPassword(m_password);
 }
 
-int NetworkAccessManager::statusFor(QUrl url) {
-  return m_responses[url].statusCode;
-}
-
-const QList<QNetworkReply::RawHeaderPair> &NetworkAccessManager::headersFor(QUrl url) {
-  return m_responses[url].headers;
-}
-
 void NetworkAccessManager::setUrlBlacklist(QStringList urlBlacklist) {
   m_urlBlacklist.clear();
 

data/src/NetworkAccessManager.h

@@ -1,3 +1,5 @@
+#ifndef __NETWORKACCESSMANAGER_H
+#define __NETWORKACCESSMANAGER_H
 #include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QNetworkRequest>
 #include <QtNetwork/QNetworkReply>
@@ -7,20 +9,12 @@ class NetworkAccessManager : public QNetworkAccessManager {
 
   Q_OBJECT
 
-  struct NetworkResponse {
-    int statusCode;
-    QList<QNetworkReply::RawHeaderPair> headers;
-    NetworkResponse() : statusCode(0) { }
-  };
-
   public:
     NetworkAccessManager(QObject *parent = 0);
     void addHeader(QString key, QString value);
-    void resetHeaders();
+    void reset();
     void setUserName(const QString &userName);
     void setPassword(const QString &password);
-    int statusFor(QUrl url);
-    const QList<QNetworkReply::RawHeaderPair> &headersFor(QUrl url);
     void setUrlBlacklist(QStringList urlBlacklist);
 
   protected:
@@ -29,10 +23,8 @@ class NetworkAccessManager : public QNetworkAccessManager {
     QString m_password;
     QList<QUrl> m_urlBlacklist;
 
-
   private:
     QHash<QString, QString> m_headers;
-    QHash<QUrl, NetworkResponse> m_responses;
     bool isBlacklisted(QUrl url);
     QHash<QUrl, QUrl> m_redirectMappings;
 
@@ -42,4 +34,6 @@ class NetworkAccessManager : public QNetworkAccessManager {
 
   signals:
     void requestCreated(QByteArray &url, QNetworkReply *reply);
+    void finished(QUrl &, QNetworkReply *);
 };
+#endif

data/src/NetworkReplyProxy.cpp

@@ -0,0 +1,91 @@
+#include "NetworkReplyProxy.h"
+
+NetworkReplyProxy::NetworkReplyProxy(QNetworkReply* reply, QObject* parent)
+  : QNetworkReply(parent)
+  , m_reply(reply)
+{
+  m_reply->setParent(this);
+
+  setOperation(m_reply->operation());
+  setRequest(m_reply->request());
+  setUrl(m_reply->url());
+
+  if (m_reply->isFinished()) {
+    readInternal();
+    setFinished(true);
+  }
+
+  applyMetaData();
+
+  connect(m_reply, SIGNAL(metaDataChanged()), SLOT(applyMetaData()));
+  connect(m_reply, SIGNAL(readyRead()), SLOT(handleReadyRead()));
+  connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(errorInternal(QNetworkReply::NetworkError)));
+  connect(m_reply, SIGNAL(finished()), SLOT(handleFinished()));
+
+  connect(m_reply, SIGNAL(uploadProgress(qint64,qint64)), SIGNAL(uploadProgress(qint64,qint64)));
+  connect(m_reply, SIGNAL(downloadProgress(qint64,qint64)), SIGNAL(downloadProgress(qint64,qint64)));
+  connect(m_reply, SIGNAL(sslErrors(const QList<QSslError> &)), SIGNAL(sslErrors(const QList<QSslError> &)));
+
+  setOpenMode(ReadOnly);
+}
+
+void NetworkReplyProxy::abort() { m_reply->abort(); }
+void NetworkReplyProxy::close() { m_reply->close(); }
+bool NetworkReplyProxy::isSequential() const { return m_reply->isSequential(); }
+
+void NetworkReplyProxy::handleFinished() {
+  setFinished(true);
+  emit finished();
+}
+
+qint64 NetworkReplyProxy::bytesAvailable() const
+{
+  return m_buffer.size() + QIODevice::bytesAvailable();
+}
+
+qint64 NetworkReplyProxy::readData(char* data, qint64 maxlen)
+{
+  qint64 size = qMin(maxlen, qint64(m_buffer.size()));
+  memcpy(data, m_buffer.constData(), size);
+  m_buffer.remove(0, size);
+  return size;
+}
+
+void NetworkReplyProxy::ignoreSslErrors() { m_reply->ignoreSslErrors(); }
+void NetworkReplyProxy::applyMetaData() {
+  foreach(QNetworkReply::RawHeaderPair header, m_reply->rawHeaderPairs())
+    setRawHeader(header.first, header.second);
+
+  setAttribute(QNetworkRequest::HttpStatusCodeAttribute, m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute));
+  setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, m_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute));
+  setAttribute(QNetworkRequest::RedirectionTargetAttribute, m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute));
+  setAttribute(QNetworkRequest::ConnectionEncryptedAttribute, m_reply->attribute(QNetworkRequest::ConnectionEncryptedAttribute));
+  setAttribute(QNetworkRequest::CacheLoadControlAttribute, m_reply->attribute(QNetworkRequest::CacheLoadControlAttribute));
+  setAttribute(QNetworkRequest::CacheSaveControlAttribute, m_reply->attribute(QNetworkRequest::CacheSaveControlAttribute));
+  setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, m_reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute));
+  setAttribute(QNetworkRequest::DoNotBufferUploadDataAttribute, m_reply->attribute(QNetworkRequest::DoNotBufferUploadDataAttribute));
+  emit metaDataChanged();
+}
+
+void NetworkReplyProxy::errorInternal(QNetworkReply::NetworkError _error)
+{
+  setError(_error, errorString());
+  emit error(_error);
+}
+
+void NetworkReplyProxy::readInternal() {
+  QByteArray data = m_reply->readAll();
+  m_data += data;
+  m_buffer += data;
+}
+
+void NetworkReplyProxy::handleReadyRead()
+{
+  readInternal();
+  emit readyRead();
+}
+
+QByteArray NetworkReplyProxy::data() {
+  return m_data;
+}
+

data/src/NetworkReplyProxy.h

@@ -0,0 +1,65 @@
+#ifndef _NETWORKREPLYPROXY_H
+#define _NETWORKREPLYPROXY_H
+/*
+ * Copyright (C) 2009, 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2009, 2010 Holger Hans Peter Freyther
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <QObject>
+#include <QtNetwork/QNetworkReply>
+
+class NetworkReplyProxy : public QNetworkReply {
+  Q_OBJECT
+
+  public:
+    NetworkReplyProxy(QNetworkReply* reply, QObject* parent);
+
+    virtual void abort();
+    virtual void close();
+    virtual bool isSequential() const;
+
+    virtual qint64 bytesAvailable() const;
+
+    virtual qint64 readData(char* data, qint64 maxlen);
+
+    QByteArray data();
+
+  public slots:
+    void ignoreSslErrors();
+    void applyMetaData();
+    void errorInternal(QNetworkReply::NetworkError _error);
+    void handleReadyRead();
+    void handleFinished();
+
+  private:
+    void readInternal();
+
+    QNetworkReply* m_reply;
+    QByteArray m_data;
+    QByteArray m_buffer;
+};
+
+#endif

data/src/Node.cpp

@@ -1,16 +1,16 @@
 #include "Node.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "InvocationResult.h"
 
-Node::Node(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
+Node::Node(WebPageManager *manager, QStringList &arguments, QObject *parent) : JavascriptCommand(manager, arguments, parent) {
 }
 
 void Node::start() {
   QStringList functionArguments(arguments());
   QString functionName = functionArguments.takeFirst();
-  QVariant result = page()->invokeCapybaraFunction(functionName, functionArguments);
-  QString attributeValue = result.toString();
-  emitFinished(true, attributeValue);
+  InvocationResult result = page()->invokeCapybaraFunction(functionName, functionArguments);
+  finish(&result);
 }
 
 QString Node::toString() const {

data/src/Node.h

@@ -1,7 +1,7 @@
-#include "SocketCommand.h"
+#include "JavascriptCommand.h"
 #include <QStringList>
 
-class Node : public SocketCommand {
+class Node : public JavascriptCommand {
   Q_OBJECT
 
   public:

data/src/NullCommand.cpp

@@ -1,6 +1,7 @@
 #include "NullCommand.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "ErrorMessage.h"
 
 NullCommand::NullCommand(QString name, QObject *parent) : Command(parent) {
   m_name = name;
@@ -8,6 +9,6 @@ NullCommand::NullCommand(QString name, QObject *parent) : Command(parent) {
 
 void NullCommand::start() {
   QString failure = QString("[Capybara WebKit] Unknown command: ") + m_name + "\n";
-  emitFinished(false, failure);
+  finish(false, new ErrorMessage(failure));
 }
 

data/src/PageLoadingCommand.cpp

@@ -2,6 +2,7 @@
 #include "SocketCommand.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "ErrorMessage.h"
 
 PageLoadingCommand::PageLoadingCommand(Command *command, WebPageManager *manager, QObject *parent) : Command(parent) {
   m_manager = manager;
@@ -30,7 +31,7 @@ void PageLoadingCommand::pendingLoadFinished(bool success) {
         emit finished(m_pendingResponse);
       } else {
         QString message = m_manager->currentPage()->failureString();
-        emitFinished(false, message);
+        finish(false, new ErrorMessage(message));
       }
     }
   }

data/src/Render.cpp

@@ -14,5 +14,5 @@ void Render::start() {
 
   bool result = page()->render( imagePath, size );
 
-  emitFinished(result);
+  finish(result);
 }

data/src/Reset.cpp

@@ -10,6 +10,6 @@ void Reset::start() {
 
   manager()->reset();
 
-  emitFinished(true);
+  finish(true);
 }
 

data/src/ResizeWindow.cpp

@@ -12,6 +12,6 @@ void ResizeWindow::start() {
   QSize size(width, height);
   page()->setViewportSize(size);
 
-  emitFinished(true);
+  finish(true);
 }
 

data/src/Response.cpp

@@ -1,4 +1,5 @@
 #include "Response.h"
+#include "ErrorMessage.h"
 #include <iostream>
 
 Response::Response(bool success, QString message, QObject *parent) : QObject(parent) {
@@ -11,6 +12,12 @@ Response::Response(bool success, QByteArray message, QObject *parent) : QObject(
   m_message = message;
 }
 
+Response::Response(bool success, ErrorMessage *message, QObject *parent) : QObject(parent) {
+  m_success = success;
+  m_message = message->toString();
+  message->deleteLater();
+}
+
 Response::Response(bool success, QObject *parent) : QObject(parent) {
   m_success = success;
 }

data/src/Response.h

@@ -5,20 +5,25 @@
 #include <QString>
 #include <QByteArray>
 
+class ErrorMessage;
+
 class Response : public QObject {
   Q_OBJECT
 
   public:
-    Response(bool success, QString message, QObject *parent);
-    Response(bool success, QByteArray message, QObject *parent);
+    Response(bool success, QString message, QObject *parent = 0);
+    Response(bool success, QByteArray message, QObject *parent = 0);
+    Response(bool success, ErrorMessage *message, QObject *parent = 0);
     Response(bool success, QObject *parent);
     bool isSuccess() const;
     QByteArray message() const;
     QString toString() const;
 
+  protected:
+    QByteArray m_message;
+
   private:
     bool m_success;
-    QByteArray m_message;
 };
 
 #endif