otherinbox-capybara-webkit 0.12.0 → 0.12.0.1

data/spec/integration/driver_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
-require 'capybara/driver/webkit'
+require 'capybara/webkit/driver'
 
-describe Capybara::Driver::Webkit do
+describe Capybara::Webkit::Driver do
   before do
-    @driver = Capybara::Driver::Webkit.new(TestApp, :browser => $webkit_browser)
+    @driver = Capybara::Webkit::Driver.new(TestApp, :browser => $webkit_browser)
   end
 
   it_should_behave_like "driver"
@@ -12,6 +12,7 @@ describe Capybara::Driver::Webkit do
   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"
+  it_should_behave_like "driver with support for window switching"
 
   it "returns the rack server port" do
     @driver.server_port.should  eq(@driver.instance_variable_get(:@rack_server).port)

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'rspec'
 require 'rspec/autorun'
 require 'rbconfig'
+require 'capybara'
 
 PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
 
@@ -20,15 +21,22 @@ RSpec.configure do |c|
   c.filter_run_excluding :skip_on_windows => !(RbConfig::CONFIG['host_os'] =~ /mingw32/).nil?
 end
 
-require File.join(spec_dir, "spec_helper")
+require 'capybara/webkit'
+connection = Capybara::Webkit::Connection.new(:socket_class => TCPSocket, :stdout => nil)
+$webkit_browser = Capybara::Webkit::Browser.new(connection)
+
+if ENV['DEBUG']
+  $webkit_browser.enable_logging
+end
 
-require 'capybara/driver/webkit/connection'
-require 'capybara/driver/webkit/browser'
-connection = Capybara::Driver::Webkit::Connection.new(:socket_class => TCPSocket, :stdout => nil)
-$webkit_browser = Capybara::Driver::Webkit::Browser.new(connection)
+RSpec.configure do |config|
+  config.before { $webkit_browser.reset! }
+end
+
+require File.join(spec_dir, "spec_helper")
 
 Capybara.register_driver :reusable_webkit do |app|
-  Capybara::Driver::Webkit.new(app, :browser => $webkit_browser)
+  Capybara::Webkit::Driver.new(app, :browser => $webkit_browser)
 end
 
 def with_env_vars(vars)

data/spec/support/app_runner.rb

@@ -0,0 +1,91 @@
+# Boots a single Capybara::Server for a Rack application that delegates to another, singleton Rack
+# application that can be configured for each spec. Also configures Capybara to use that server.
+
+require 'sinatra/base'
+
+module AppRunner
+  class << self
+    attr_accessor :app, :app_host
+  end
+
+  def self.boot
+    app_container = lambda { |env| AppRunner.app.call(env) }
+    server = Capybara::Server.new(app_container)
+    server.boot
+    self.app_host = "http://127.0.0.1:#{server.port}"
+  end
+
+  def self.reset
+    self.app = lambda do |env|
+      [200, { 'Content-Type' => 'html', 'Content-Length' => 0 }, []]
+    end
+  end
+
+  def run_application(app)
+    AppRunner.app = app
+  end
+
+  def driver_for_app(&body)
+    app = Class.new(ExampleApp, &body)
+    run_application app
+    build_driver
+  end
+
+  def driver_for_html(html)
+    app = lambda do |env|
+      [200, { 'Content-Type' => 'text/html', 'Content-Length' => html.size.to_s }, [html]]
+    end
+    run_application app
+    build_driver
+  end
+
+  private
+
+  def build_driver
+    Capybara::Webkit::Driver.new(AppRunner.app, :browser => $webkit_browser)
+  end
+
+  def self.included(example_group)
+    example_group.class_eval do
+      before { AppRunner.reset }
+
+      around do |example|
+        Capybara.run_server = false
+        Capybara.app_host = AppRunner.app_host
+        begin
+          example.run
+        ensure
+          Capybara.run_server = true
+          Capybara.app_host = nil
+        end
+      end
+    end
+  end
+end
+
+class ExampleApp < Sinatra::Base
+  # Sinatra fixes invalid responses that would break QWebPage, so this middleware breaks them again
+  # for testing purposes.
+  class ResponseInvalidator
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      response = @app.call(env)
+      if response.to_a[1]['X-Response-Invalid']
+        [404, {}, []]
+      else
+        response
+      end
+    end
+  end
+
+  use ResponseInvalidator
+
+  def invalid_response
+    [200, { 'X-Response-Invalid' => 'TRUE' }, []]
+  end
+end
+
+AppRunner.boot

data/src/Authenticate.cpp

@@ -0,0 +1,18 @@
+#include "Authenticate.h"
+#include "WebPage.h"
+#include "NetworkAccessManager.h"
+
+Authenticate::Authenticate(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
+}
+
+void Authenticate::start() {
+  QString username = arguments()[0];
+  QString password = arguments()[1];
+
+  NetworkAccessManager* networkAccessManager = qobject_cast<NetworkAccessManager*>(page()->networkAccessManager());
+  networkAccessManager->setUserName(username);
+  networkAccessManager->setPassword(password);
+
+  emit finished(new Response(true));
+}
+

data/src/Authenticate.h

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

data/src/Body.h

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

data/src/ClearCookies.cpp

@@ -1,15 +1,13 @@
 #include "ClearCookies.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 #include "NetworkCookieJar.h"
 #include <QNetworkCookie>
 
-ClearCookies::ClearCookies(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {}
+ClearCookies::ClearCookies(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {}
 
 void ClearCookies::start()
 {
-  NetworkCookieJar *jar = qobject_cast<NetworkCookieJar*>(page()
-                                                          ->networkAccessManager()
-                                                          ->cookieJar());
-  jar->clearCookies();
+  manager()->cookieJar()->clearCookies();
   emit finished(new Response(true));
 }

data/src/ClearCookies.h

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

data/src/Command.cpp

@@ -1,19 +1,8 @@
-#include "Command.h"
-#include "WebPage.h"
+#include "SocketCommand.h"
 
-Command::Command(WebPage *page, QStringList &arguments, QObject *parent) : QObject(parent) {
-  m_page = page;
-  m_arguments = arguments;
+Command::Command(QObject *parent) : QObject(parent) {
 }
 
-void Command::start() {
+QString Command::toString() const {
+  return metaObject()->className();
 }
-
-WebPage *Command::page() {
-  return m_page;
-}
-
-QStringList &Command::arguments() {
-  return m_arguments;
-}
-

data/src/Command.h

@@ -2,29 +2,18 @@
 #define COMMAND_H
 
 #include <QObject>
-#include <QStringList>
 #include "Response.h"
 
-class WebPage;
-
 class Command : public QObject {
   Q_OBJECT
 
   public:
-    Command(WebPage *page, QStringList &arguments, QObject *parent = 0);
-    virtual void start();
+    Command(QObject *parent = 0);
+    virtual void start() = 0;
+    virtual QString toString() const;
 
   signals:
     void finished(Response *response);
-
-  protected:
-    WebPage *page();
-    QStringList &arguments();
-
-  private:
-    WebPage *m_page;
-    QStringList m_arguments;
-
 };
 
 #endif

data/src/CommandFactory.cpp

@@ -1,8 +1,8 @@
 #include "CommandFactory.h"
 #include "NullCommand.h"
+#include "SocketCommand.h"
 #include "Visit.h"
 #include "Find.h"
-#include "Command.h"
 #include "Reset.h"
 #include "Node.h"
 #include "Url.h"
@@ -25,14 +25,18 @@
 #include "ResizeWindow.h"
 #include "IgnoreSslErrors.h"
 #include "SetSkipImageLoading.h"
+#include "WindowFocus.h"
+#include "GetWindowHandles.h"
+#include "GetWindowHandle.h"
+#include "WebPageManager.h"
+#include "Authenticate.h"
+#include "EnableLogging.h"
 
-CommandFactory::CommandFactory(WebPage *page, QObject *parent) : QObject(parent) {
-  m_page = page;
+CommandFactory::CommandFactory(WebPageManager *manager, QObject *parent) : QObject(parent) {
+  m_manager = manager;
 }
 
 Command *CommandFactory::createCommand(const char *name, QStringList &arguments) {
   #include "find_command.h"
-  arguments.clear();
-  arguments.append(QString(name));
-  return new NullCommand(m_page, arguments);
+  return new NullCommand(QString(name));
 }

data/src/CommandFactory.h

@@ -2,15 +2,16 @@
 
 class Command;
 class WebPage;
+class WebPageManager;
 
 class CommandFactory : public QObject {
   Q_OBJECT
 
   public:
-    CommandFactory(WebPage *page, QObject *parent = 0);
+    CommandFactory(WebPageManager *, QObject *parent = 0);
     Command *createCommand(const char *name, QStringList &arguments);
 
   private:
-    WebPage *m_page;
+    WebPageManager *m_manager;
 };
 

data/src/CommandParser.cpp

@@ -1,6 +1,6 @@
 #include "CommandParser.h"
 #include "CommandFactory.h"
-#include "Command.h"
+#include "SocketCommand.h"
 
 #include <QIODevice>
 

data/src/Connection.cpp

@@ -1,37 +1,41 @@
 #include "Connection.h"
 #include "WebPage.h"
+#include "WebPageManager.h"
 #include "CommandParser.h"
 #include "CommandFactory.h"
 #include "PageLoadingCommand.h"
-#include "Command.h"
+#include "SocketCommand.h"
 
 #include <QTcpSocket>
 
-Connection::Connection(QTcpSocket *socket, WebPage *page, QObject *parent) :
+Connection::Connection(QTcpSocket *socket, WebPageManager *manager, QObject *parent) :
     QObject(parent) {
   m_socket = socket;
-  m_page = page;
-  m_commandFactory = new CommandFactory(page, this);
+  m_manager = manager;
+  m_commandFactory = new CommandFactory(m_manager, 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)));
+  connect(m_manager, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
 }
 
 void Connection::commandReady(Command *command) {
   m_queuedCommand = command;
-  if (m_page->isLoading())
+  m_manager->logger() << "Received" << command->toString();
+  if (m_manager->isLoading()) {
+    m_manager->logger() << command->toString() << "waiting for load to finish";
     m_commandWaiting = true;
-  else
+  } else {
     startCommand();
+  }
 }
 
 void Connection::startCommand() {
   m_commandWaiting = false;
   if (m_pageSuccess) {
-    m_runningCommand = new PageLoadingCommand(m_queuedCommand, m_page, this);
+    m_runningCommand = new PageLoadingCommand(m_queuedCommand, m_manager, this);
     connect(m_runningCommand, SIGNAL(finished(Response *)), this, SLOT(finishCommand(Response *)));
     m_runningCommand->start();
   } else {
@@ -40,18 +44,20 @@ void Connection::startCommand() {
 }
 
 void Connection::pendingLoadFinished(bool success) {
-  m_pageSuccess = success;
-  if (m_commandWaiting)
+  m_pageSuccess = m_pageSuccess && success;
+  if (m_commandWaiting) {
     startCommand();
+  }
 }
 
 void Connection::writePageLoadFailure() {
   m_pageSuccess = true;
-  QString message = m_page->failureString();
+  QString message = currentPage()->failureString();
   writeResponse(new Response(false, message));
 }
 
 void Connection::finishCommand(Response *response) {
+  m_pageSuccess = true;
   m_runningCommand->deleteLater();
   writeResponse(response);
 }
@@ -62,6 +68,8 @@ void Connection::writeResponse(Response *response) {
   else
     m_socket->write("failure\n");
 
+  m_manager->logger() << "Wrote response" << response->isSuccess() << response->message();
+
   QByteArray messageUtf8 = response->message();
   QString messageLength = QString::number(messageUtf8.size()) + "\n";
   m_socket->write(messageLength.toAscii());
@@ -69,3 +77,6 @@ void Connection::writeResponse(Response *response) {
   delete response;
 }
 
+WebPage *Connection::currentPage() {
+  return m_manager->currentPage();
+}