capybara-webkit 0.1.0

data/spec/integration/driver_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'capybara/driver/webkit'
+
+describe Capybara::Driver::Webkit do
+  before do
+    @driver = Capybara::Driver::Webkit.new(TestApp, :browser => $webkit_browser)
+  end
+
+  # TODO: select options
+  # it_should_behave_like "driver"
+
+  # TODO: bug with drag and drop
+  # it_should_behave_like "driver with javascript support"
+
+  it_should_behave_like "driver with cookies support"
+
+  # Can't support:
+  # it_should_behave_like "driver with header support"
+  # it_should_behave_like "driver with status code support"
+  # it_should_behave_like "driver with frame support"
+end

data/spec/integration/session_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'capybara-webkit'
+
+describe Capybara::Session do
+  before do
+    @session = Capybara::Session.new(:webkit, TestApp)
+  end
+
+  # TODO: needs to only use one Browser throughout tests
+  # it_should_behave_like "session"
+  # it_should_behave_like "session with javascript support"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rspec'
+require 'rspec/autorun'
+
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
+
+$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
+
+Dir[File.join(PROJECT_ROOT, 'spec', 'support', '**', '*.rb')].each { |file| require(file) }
+
+spec_dir = nil
+$:.detect do |dir|
+  if File.exists? File.join(dir, "capybara.rb")
+    spec_dir = File.expand_path(File.join(dir,"..","spec"))
+    $:.unshift( spec_dir )
+  end
+end
+
+require File.join(spec_dir,"spec_helper")
+
+require 'capybara/driver/webkit/browser'
+$webkit_browser = Capybara::Driver::Webkit::Browser.new(:socket_class => TCPSocket)
+

data/spec/support/socket_debugger.rb

@@ -0,0 +1,42 @@
+# Wraps the TCP socket and prints data sent and received. Used for debugging
+# the wire protocol. You can use this by passing a :socket_class to Browser.
+class SocketDebugger
+  def self.open(host, port)
+    real_socket = TCPSocket.open(host, port)
+    new(real_socket)
+  end
+
+  def initialize(socket)
+    @socket = socket
+  end
+
+  def read(length)
+    received @socket.read(length)
+  end
+
+  def puts(line)
+    sent line
+    @socket.puts(line)
+  end
+
+  def print(content)
+    sent content
+    @socket.print(content)
+  end
+
+  def gets
+    received @socket.gets
+  end
+
+  private
+
+  def sent(content)
+    Kernel.puts " >> " + content.to_s
+  end
+
+  def received(content)
+    Kernel.puts " << " + content.to_s
+    content
+  end
+end
+

data/src/Command.cpp

@@ -0,0 +1,15 @@
+#include "Command.h"
+#include "WebPage.h"
+
+Command::Command(WebPage *page, QObject *parent) : QObject(parent) {
+  m_page = page;
+}
+
+void Command::start(QStringList &arguments) {
+  Q_UNUSED(arguments);
+}
+
+WebPage *Command::page() {
+  return m_page;
+}
+

data/src/Command.h

@@ -0,0 +1,28 @@
+#ifndef COMMAND_H
+#define COMMAND_H
+
+#include <QObject>
+#include <QStringList>
+
+class WebPage;
+
+class Command : public QObject {
+  Q_OBJECT
+
+  public:
+    Command(WebPage *page, QObject *parent = 0);
+    virtual void start(QStringList &arguments);
+
+  signals:
+    void finished(bool success, QString &response);
+
+  protected:
+    WebPage *page();
+
+  private:
+    WebPage *m_page;
+
+};
+
+#endif
+

data/src/Connection.cpp

@@ -0,0 +1,130 @@
+#include "Connection.h"
+#include "WebPage.h"
+#include "Visit.h"
+#include "Find.h"
+#include "Command.h"
+#include "Reset.h"
+#include "Node.h"
+#include "Url.h"
+#include "Source.h"
+#include "Evaluate.h"
+#include "Execute.h"
+
+#include <QTcpSocket>
+#include <iostream>
+
+Connection::Connection(QTcpSocket *socket, WebPage *page, QObject *parent) :
+    QObject(parent) {
+  m_socket = socket;
+  m_page = page;
+  m_command = NULL;
+  m_expectingDataSize = -1;
+  connect(m_socket, SIGNAL(readyRead()), this, SLOT(checkNext()));
+}
+
+void Connection::checkNext() {
+  if (m_expectingDataSize == -1) {
+    if (m_socket->canReadLine()) {
+      readLine();
+      checkNext();
+    }
+  } else {
+    if (m_socket->bytesAvailable() >= m_expectingDataSize) {
+      readDataBlock();
+      checkNext();
+    }
+  }
+}
+
+void Connection::readLine() {
+  char buffer[128];
+  qint64 lineLength = m_socket->readLine(buffer, 128);
+  if (lineLength != -1) {
+    buffer[lineLength - 1] = 0;
+    processNext(buffer);
+  }
+}
+
+void Connection::readDataBlock() {
+  char *buffer = new char[m_expectingDataSize + 1];
+  m_socket->read(buffer, m_expectingDataSize);
+  buffer[m_expectingDataSize] = 0;
+  processNext(buffer);
+  m_expectingDataSize = -1;
+  delete buffer;
+}
+
+void Connection::processNext(const char *data) {
+  if (m_commandName.isNull()) {
+    m_commandName = data;
+    m_argumentsExpected = -1;
+  } else {
+    processArgument(data);
+  }
+}
+
+void Connection::processArgument(const char *data) {
+  if (m_argumentsExpected == -1) {
+    m_argumentsExpected = QString(data).toInt();
+  } else if (m_expectingDataSize == -1) {
+    m_expectingDataSize = QString(data).toInt();
+  } else {
+    m_arguments.append(data);
+  }
+
+  if (m_arguments.length() == m_argumentsExpected) {
+    if (m_page->isLoading())
+      connect(m_page, SIGNAL(loadFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+    else
+      startCommand();
+  }
+}
+
+void Connection::startCommand() {
+  m_command = createCommand(m_commandName.toAscii().constData());
+  if (m_command) {
+    connect(m_command,
+            SIGNAL(finished(bool, QString &)),
+            this,
+            SLOT(finishCommand(bool, QString &)));
+    m_command->start(m_arguments);
+  } else {
+    QString failure = QString("Unknown command: ") +  m_commandName + "\n";
+    writeResponse(false, failure);
+  }
+  m_commandName = QString();
+}
+
+Command *Connection::createCommand(const char *name) {
+  #include "find_command.h"
+  return NULL;
+}
+
+void Connection::pendingLoadFinished(bool success) {
+  m_page->disconnect(this, SLOT(pendingLoadFinished(bool)));
+  if (success) {
+    startCommand();
+  } else {
+    QString response = m_page->failureString();
+    finishCommand(false, response);
+  }
+}
+
+void Connection::finishCommand(bool success, QString &response) {
+  m_command->deleteLater();
+  m_command = NULL;
+  m_arguments.clear();
+  writeResponse(success, response);
+}
+
+void Connection::writeResponse(bool success, QString &response) {
+  if (success)
+    m_socket->write("ok\n");
+  else
+    m_socket->write("failure\n");
+
+  QString responseLength = QString::number(response.size()) + "\n";
+  m_socket->write(responseLength.toAscii());
+  m_socket->write(response.toAscii());
+}
+

data/src/Connection.h

@@ -0,0 +1,36 @@
+#include <QObject>
+#include <QStringList>
+
+class QTcpSocket;
+class WebPage;
+class Command;
+
+class Connection : public QObject {
+  Q_OBJECT
+
+  public:
+    Connection(QTcpSocket *socket, WebPage *page, QObject *parent = 0);
+
+  public slots:
+    void checkNext();
+    void finishCommand(bool success, QString &response);
+    void pendingLoadFinished(bool success);
+
+  private:
+    void readLine();
+    void readDataBlock();
+    void processNext(const char *line);
+    Command *createCommand(const char *name);
+    void processArgument(const char *line);
+    void startCommand();
+    void writeResponse(bool success, QString &response);
+
+    QTcpSocket *m_socket;
+    QString m_commandName;
+    Command *m_command;
+    QStringList m_arguments;
+    int m_argumentsExpected;
+    WebPage *m_page;
+    int m_expectingDataSize;
+};
+

data/src/Evaluate.cpp

@@ -0,0 +1,84 @@
+#include "Evaluate.h"
+#include "WebPage.h"
+#include <iostream>
+
+Evaluate::Evaluate(WebPage *page, QObject *parent) : Command(page, parent) {
+  m_buffer = "";
+}
+
+void Evaluate::start(QStringList &arguments) {
+  QVariant result = page()->mainFrame()->evaluateJavaScript(arguments[0]);
+  addVariant(result);
+  emit finished(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, QObject *parent = 0);
+    virtual void start(QStringList &arguments);
+
+  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,17 @@
+#include "Execute.h"
+#include "WebPage.h"
+
+Execute::Execute(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Execute::start(QStringList &arguments) {
+  QVariant result = page()->mainFrame()->evaluateJavaScript(arguments[0]);
+  QString response;
+  if (result.isValid()) {
+    emit finished(true, response);
+  } else {
+    response = "Javascript failed to execute";
+    emit finished(false, response);
+  }
+}
+