capybara-webkit 0.12.1 → 0.13.0

data/src/Headers.cpp

@@ -1,10 +1,16 @@
 #include "Headers.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 
-Headers::Headers(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+Headers::Headers(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
 
 void Headers::start() {
-  emit finished(new Response(true, page()->pageHeaders()));
+  QStringList headers;
+
+  foreach(QNetworkReply::RawHeaderPair header, page()->pageHeaders())
+    headers << header.first+": "+header.second;
+
+  emit finished(new Response(true, headers.join("\n")));
 }
 

data/src/Headers.h

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

data/src/IgnoreSslErrors.cpp

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

data/src/IgnoreSslErrors.h

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

data/src/JavascriptAlertMessages.cpp

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

data/src/JavascriptAlertMessages.h

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

data/src/JavascriptConfirmMessages.cpp

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

data/src/JavascriptConfirmMessages.h

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

data/src/JavascriptInvocation.cpp

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

data/src/JavascriptInvocation.h

@@ -8,7 +8,7 @@ class JavascriptInvocation : public QObject {
   Q_PROPERTY(QStringList arguments READ arguments)
 
   public:
-    JavascriptInvocation(QString &functionName, QStringList &arguments, QObject *parent = 0);
+    JavascriptInvocation(const QString &functionName, const QStringList &arguments, QObject *parent = 0);
     QString &functionName();
     QStringList &arguments();
 

data/src/JavascriptPromptMessages.cpp

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

data/src/JavascriptPromptMessages.h

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

data/src/NetworkAccessManager.cpp

@@ -1,13 +1,16 @@
 #include "NetworkAccessManager.h"
 #include "WebPage.h"
 #include <iostream>
-
+#include <fstream>
 
 NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManager(parent) {
+  connect(this, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), SLOT(provideAuthentication(QNetworkReply*,QAuthenticator*)));
+  connect(this, SIGNAL(finished(QNetworkReply *)), this, SLOT(finished(QNetworkReply *)));
 }
 
 QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
   QNetworkRequest new_request(request);
+  QByteArray url = new_request.url().toEncoded();
   if (operation != QNetworkAccessManager::PostOperation && operation != QNetworkAccessManager::PutOperation) {
     new_request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
   }
@@ -16,14 +19,44 @@ QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operat
       item.next();
       new_request.setRawHeader(item.key().toAscii(), item.value().toAscii());
   }
-  return QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
-};
+  QNetworkReply *reply = QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
+  emit requestCreated(url, reply);
+  return reply;
+}
+
+void NetworkAccessManager::finished(QNetworkReply *reply) {
+  NetworkResponse response;
+  response.statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  response.headers = reply->rawHeaderPairs();
+  m_responses[reply->url()] = response;
+}
 
 void NetworkAccessManager::addHeader(QString key, QString value) {
   m_headers.insert(key, value);
-};
+}
 
 void NetworkAccessManager::resetHeaders() {
   m_headers.clear();
-};
+}
+
+void NetworkAccessManager::setUserName(const QString &userName) {
+  m_userName = userName;
+}
 
+void NetworkAccessManager::setPassword(const QString &password) {
+  m_password = password;
+}
+
+void NetworkAccessManager::provideAuthentication(QNetworkReply *reply, QAuthenticator *authenticator) {
+  Q_UNUSED(reply);
+  authenticator->setUser(m_userName);
+  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;
+}

data/src/NetworkAccessManager.h

@@ -6,14 +6,34 @@ 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 setUserName(const QString &userName);
+    void setPassword(const QString &password);
+    int statusFor(QUrl url);
+    const QList<QNetworkReply::RawHeaderPair> &headersFor(QUrl url);
 
   protected:
     QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &req, QIODevice * outgoingData);
+    QString m_userName;
+    QString m_password;
 
   private:
     QHash<QString, QString> m_headers;
+    QHash<QUrl, NetworkResponse> m_responses;
+
+  private slots:
+    void provideAuthentication(QNetworkReply *reply, QAuthenticator *authenticator);
+    void finished(QNetworkReply *);
+
+  signals:
+    void requestCreated(QByteArray &url, QNetworkReply *reply);
 };

data/src/Node.cpp

@@ -1,7 +1,8 @@
 #include "Node.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 
-Node::Node(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+Node::Node(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
 
 void Node::start() {
@@ -12,3 +13,7 @@ void Node::start() {
   emit finished(new Response(true, attributeValue));
 }
 
+QString Node::toString() const {
+  QStringList functionArguments(arguments());
+  return QString("Node.") + functionArguments.takeFirst();
+}

data/src/Node.h

@@ -1,13 +1,12 @@
-#include "Command.h"
+#include "SocketCommand.h"
 #include <QStringList>
 
-class WebPage;
-
-class Node : public Command {
+class Node : public SocketCommand {
   Q_OBJECT
 
   public:
-    Node(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    Node(WebPageManager *manager, QStringList &arguments, QObject *parent = 0);
     virtual void start();
+    virtual QString toString() const;
 };
 

data/src/NullCommand.cpp

@@ -1,10 +1,13 @@
 #include "NullCommand.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 
-NullCommand::NullCommand(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {}
+NullCommand::NullCommand(QString name, QObject *parent) : Command(parent) {
+  m_name = name;
+}
 
 void NullCommand::start() {
-  QString failure = QString("[Capybara WebKit] Unknown command: ") + arguments()[0] + "\n";
+  QString failure = QString("[Capybara WebKit] Unknown command: ") + m_name + "\n";
   emit finished(new Response(false, failure));
 }
 

data/src/NullCommand.h

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

data/src/PageLoadingCommand.cpp

@@ -1,18 +1,20 @@
 #include "PageLoadingCommand.h"
-#include "Command.h"
+#include "SocketCommand.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 
-PageLoadingCommand::PageLoadingCommand(Command *command, WebPage *page, QObject *parent) : QObject(parent) {
-  m_page = page;
+PageLoadingCommand::PageLoadingCommand(Command *command, WebPageManager *manager, QObject *parent) : Command(parent) {
+  m_manager = manager;
   m_command = command;
   m_pageLoadingFromCommand = false;
   m_pageSuccess = true;
   m_pendingResponse = NULL;
-  connect(m_page, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
-  connect(m_page, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+  connect(m_manager, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  connect(m_manager, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
 }
 
 void PageLoadingCommand::start() {
+  m_manager->logger() << "Started" << m_command->toString();
   connect(m_command, SIGNAL(finished(Response *)), this, SLOT(commandFinished(Response *)));
   m_command->start();
 };
@@ -22,10 +24,11 @@ void PageLoadingCommand::pendingLoadFinished(bool success) {
   if (m_pageLoadingFromCommand) {
     m_pageLoadingFromCommand = false;
     if (m_pendingResponse) {
+      m_manager->logger() << "Page load from command finished";
       if (m_pageSuccess) {
         emit finished(m_pendingResponse);
       } else {
-        QString message = m_page->failureString();
+        QString message = m_manager->currentPage()->failureString();
         emit finished(new Response(false, message));
       }
     }
@@ -33,11 +36,13 @@ void PageLoadingCommand::pendingLoadFinished(bool success) {
 }
 
 void PageLoadingCommand::pageLoadingFromCommand() {
+  m_manager->logger() << m_command->toString() << "started page load";
   m_pageLoadingFromCommand = true;
 }
 
 void PageLoadingCommand::commandFinished(Response *response) {
-  disconnect(m_page, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  disconnect(m_manager, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  m_manager->logger() << "Finished" << m_command->toString() << "with response" << response->toString();
   m_command->deleteLater();
   if (m_pageLoadingFromCommand)
     m_pendingResponse = response;

data/src/PageLoadingCommand.h

@@ -1,9 +1,9 @@
 #include <QObject>
 #include <QStringList>
+#include "Command.h"
 
-class Command;
 class Response;
-class WebPage;
+class WebPageManager;
 
 /*
  * Decorates a Command by deferring the finished() signal until any pending
@@ -15,23 +15,20 @@ class WebPage;
  * If a pending page load fails, the command's response will be discarded and a
  * failure response will be emitted instead.
  */
-class PageLoadingCommand : public QObject {
+class PageLoadingCommand : public Command {
   Q_OBJECT
 
   public:
-    PageLoadingCommand(Command *command, WebPage *page, QObject *parent = 0);
-    void start();
+    PageLoadingCommand(Command *command, WebPageManager *page, QObject *parent = 0);
+    virtual void start();
 
   public slots:
     void pageLoadingFromCommand();
     void pendingLoadFinished(bool success);
     void commandFinished(Response *response);
 
-  signals:
-    void finished(Response *response);
-
   private:
-    WebPage *m_page;
+    WebPageManager *m_manager;
     Command *m_command;
     Response *m_pendingResponse;
     bool m_pageSuccess;

data/src/Render.cpp

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

data/src/Render.h

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