jasmine-headless-webkit 0.6.1 → 0.6.2

data/.gitignore

@@ -6,3 +6,7 @@ Makefile
 specrunner.moc
 specrunner.o
 ext/jasmine-webkit-specrunner/jasmine-webkit-specrunner
+*.o
+moc_*.*
+.DS_Store
+hydra-runner.log

data/Gemfile

@@ -12,3 +12,4 @@ gem 'guard-coffeescript'
 gem 'growl'
 gem 'rake', '0.8.7'
 gem 'mocha', '0.9.12'
+gem 'guard-jasmine-headless-webkit'

data/Guardfile

@@ -4,7 +4,7 @@
 #
 
 guard 'shell' do
-  watch(%r{ext/jasmine-webkit-specrunner/specrunner.cpp}) { compile }
+  watch(%r{ext/jasmine-webkit-specrunner/.*\.(cpp|h)}) { compile }
 end
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme

data/Rakefile

@@ -16,31 +16,17 @@ Jasmine::Headless::Task.new
 namespace :spec do
   desc "Run on three Rubies"
   task :platforms do
-    current = %x{rvm-prompt v}
-    
-    fail = false
-    %w{1.8.7 1.9.2 ree}.each do |version|
-      puts "Switching to #{version}"
-      Bundler.with_clean_env do
-        system %{bash -c 'source ~/.rvm/scripts/rvm ; rvm #{version} ; bundle install ; bundle exec rake spec'}
-      end
-      if $?.exitstatus != 0
-        fail = true
-        break
-      end
-    end
-
-    system %{rvm #{current}}
-
-    exit (fail ? 1 : 0)
+    system %{rvm 1.8.7,1.9.2,ree ruby bundle}
+    system %{rvm 1.8.7,1.9.2,ree ruby bundle exec rake spec}
+    raise StandardError.new if $?.exitstatus != 0
   end
 end
 
 task :default => [ 'spec:platforms', 'jasmine:headless' ]
 
 desc "Build the runner"
-task :build do
-  Dir.chdir 'ext/jasmine-headless-specrunner' do
+task :build_runner do
+  Dir.chdir 'ext/jasmine-webkit-specrunner' do
     system %{ruby extconf.rb}
   end
 end

data/ext/jasmine-webkit-specrunner/HeadlessSpecRunner/Page.cpp

@@ -0,0 +1,30 @@
+#include <QtGui>
+#include <QtWebKit>
+
+#include "Page.h"
+
+namespace HeadlessSpecRunner {
+  Page::Page() : QWebPage(), confirmResult(true) {}
+
+  void Page::javaScriptConsoleMessage(const QString &message, int lineNumber, const QString &sourceID) {
+    emit consoleLog(message, lineNumber, sourceID);
+  }
+
+  bool Page::javaScriptConfirm(QWebFrame *frame, const QString &msg) {
+    if (confirmResult) {
+      emit internalLog("TODO", "jasmine-headless-webkit can't handle confirm() yet! You should mock window.confirm for now. Returning true.");
+      return true;
+    } else {
+      confirmResult = true;
+      return false;
+    }
+  }
+
+  void Page::javaScriptAlert(QWebFrame *frame, const QString &msg) {
+    emit internalLog("alert", msg);
+  }
+
+  void Page::oneFalseConfirm() {
+    confirmResult = false;
+  }
+}

data/ext/jasmine-webkit-specrunner/HeadlessSpecRunner/Page.h

@@ -0,0 +1,25 @@
+#ifndef JHW_PAGE
+#define JHW_PAGE
+
+#include <QtGui>
+#include <QtWebKit>
+
+namespace HeadlessSpecRunner {
+  class Page: public QWebPage {
+    Q_OBJECT
+    public:
+      Page();
+      void oneFalseConfirm();
+    signals:
+      void consoleLog(const QString &msg, int lineNumber, const QString &sourceID);
+      void internalLog(const QString &note, const QString &msg);
+    protected:
+      void javaScriptConsoleMessage(const QString & message, int lineNumber, const QString & sourceID);
+      bool javaScriptConfirm(QWebFrame *frame, const QString &msg);
+      void javaScriptAlert(QWebFrame *frame, const QString &msg);
+    private:
+      bool confirmResult;
+  };
+}
+
+#endif

data/ext/jasmine-webkit-specrunner/HeadlessSpecRunner/Runner.cpp

@@ -0,0 +1,270 @@
+#include <QtGui>
+#include <QtWebKit>
+#include <QFile>
+#include <QTextStream>
+#include <iostream>
+#include <QQueue>
+
+#include "Runner.h"
+
+namespace HeadlessSpecRunner {
+  Runner::Runner() : QObject()
+    , m_runs(0)
+    , hasErrors(false)
+    , usedConsole(false)
+    , showColors(false)
+    , isFinished(false)
+    , didFail(false)
+    , consoleNotUsedThisRun(false) {
+    m_page.settings()->enablePersistentStorage();
+    connect(&m_page, SIGNAL(loadFinished(bool)), this, SLOT(watch(bool)));
+    connect(&m_page, SIGNAL(consoleLog(QString, int, QString)), this, SLOT(errorLog(QString, int, QString)));
+    connect(&m_page, SIGNAL(internalLog(QString, QString)), this, SLOT(internalLog(QString, QString)));
+    connect(m_page.mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(addJHW()));
+  }
+
+  void Runner::addFile(const QString &spec) {
+    runnerFiles.enqueue(spec);
+  }
+
+  void Runner::go()
+  {
+    m_ticker.stop();
+    m_page.setPreferredContentsSize(QSize(1024, 600));
+    addJHW();
+    loadSpec();
+  }
+  void Runner::addJHW()
+  {
+    m_page.mainFrame()->addToJavaScriptWindowObject("JHW", this);
+  }
+
+  void Runner::loadSpec()
+  {
+    m_page.mainFrame()->load(runnerFiles.dequeue());
+    m_ticker.start(200, this);
+  }
+
+  void Runner::watch(bool ok)
+  {
+    if (!ok) {
+      std::cerr << "Can't load " << qPrintable(m_page.mainFrame()->url().toString()) << ", the file may be broken." << std::endl;
+      std::cerr << "Out of curiosity, did your tests try to submit a form and you haven't prevented that?" << std::endl;
+      std::cerr << "Try running your tests in your browser with the Jasmine server and see what happens." << std::endl;
+      QApplication::instance()->exit(1);
+      return;
+    }
+
+    m_ticker.start(200, this);
+  }
+
+  bool Runner::hasElement(const char *select)
+  {
+    return !m_page.mainFrame()->findFirstElement(select).isNull();
+  }
+
+  void Runner::setColors(bool colors)
+  {
+    showColors = colors;
+  }
+
+  void Runner::reportFile(const QString &file)
+  {
+    reportFilename = file;
+  }
+
+  void Runner::red()
+  {
+    if (showColors) std::cout << "\033[0;31m";
+  }
+
+  void Runner::green()
+  {
+    if (showColors) std::cout << "\033[0;32m";
+  }
+
+  bool Runner::hasError() {
+    return hasErrors;
+  }
+
+  void Runner::yellow()
+  {
+    if (showColors) std::cout << "\033[0;33m";
+  }
+
+  void Runner::clear()
+  {
+    if (showColors) std::cout << "\033[m";
+  }
+
+  void Runner::specPassed()
+  {
+    consoleNotUsedThisRun = true;
+    green();
+    std::cout << '.';
+    clear();
+    fflush(stdout);
+  }
+
+  void Runner::specFailed(const QString &specDetail)
+  {
+    consoleNotUsedThisRun = true;
+    didFail = true;
+    red();
+    std::cout << 'F';
+    failedSpecs.push(specDetail);
+    clear();
+    fflush(stdout);
+  }
+
+  void Runner::errorLog(const QString &msg, int lineNumber, const QString &sourceID)
+  {
+    red();
+    std::cout << "[error] ";
+    clear();
+    std::cout << qPrintable(sourceID) << ":" << lineNumber << " : " << qPrintable(msg);
+    std::cout << std::endl;
+
+    hasErrors = true;
+    m_runs = 0;
+    m_ticker.start(200, this);
+  }
+
+  void Runner::internalLog(const QString &note, const QString &msg) {
+    red();
+    std::cout << "[" << qPrintable(note) << "] ";
+    clear();
+    std::cout << qPrintable(msg);
+    std::cout << std::endl;
+  }
+
+  void Runner::log(const QString &msg)
+  {
+    usedConsole = true;
+    green();
+    if (consoleNotUsedThisRun) {
+      std::cout << std::endl;
+      consoleNotUsedThisRun = false;
+    }
+    std::cout << "[console] ";
+    clear();
+    if (msg.contains("\n"))
+      std::cout << std::endl;
+    std::cout << qPrintable(msg);
+    std::cout << std::endl;
+  }
+
+  void Runner::leavePageAttempt(const QString &msg)
+  {
+    red();
+    std::cout << "[error] ";
+    clear();
+    std::cout << qPrintable(msg) << std::endl;
+    m_page.oneFalseConfirm();
+    hasErrors = true;
+  }
+
+  void Runner::printName(const QString &name)
+  {
+    std::cout << std::endl << std::endl;
+    red();
+    std::cout << qPrintable(name) << std::endl;
+    clear();
+  }
+
+  void Runner::printResult(const QString &result)
+  {
+    red();
+    std::cout << "  " << qPrintable(result) << std::endl;
+    clear();
+  }
+
+  void Runner::finishSuite(const QString &duration, const QString &total, const QString& failed)
+  {
+    std::cout << std::endl;
+    if (didFail) {
+      red();
+      std::cout << "FAIL: ";
+    } else {
+      green();
+      std::cout << "PASS";
+
+      if (hasErrors) {
+        std::cout << " with JS errors";
+      }
+
+      std::cout << ": ";
+    }
+
+    std::cout << qPrintable(total) << " tests, " << qPrintable(failed) << " failures, " << qPrintable(duration) << " secs.";
+    clear();
+    std::cout << std::endl;
+
+    if (!reportFilename.isEmpty()) {
+      QFile reportFH(reportFilename);
+
+      if (reportFH.open(QFile::WriteOnly)) {
+        QTextStream report(&reportFH);
+        report << qPrintable(total) << "/" << qPrintable(failed) << "/";
+        report << (usedConsole ? "T" : "F");
+        report << "/" << qPrintable(duration) << "\n";
+
+        QString failedSpec;
+
+        while (!failedSpecs.isEmpty()) {
+          failedSpec = failedSpecs.pop();
+          report << qPrintable(failedSpec) << "\n";
+        }
+
+        reportFH.close();
+      }
+    }
+
+    isFinished = true;
+  }
+
+  void Runner::timerEvent(QTimerEvent *event)
+  {
+    ++m_runs;
+
+    if (event->timerId() != m_ticker.timerId())
+      return;
+
+    if (hasErrors && m_runs > 2)
+      QApplication::instance()->exit(1);
+
+    if (isFinished) {
+      int exitCode = 0;
+      if (didFail || hasErrors) {
+        exitCode = 1;
+      } else {
+        if (usedConsole) {
+          exitCode = 2;
+        }
+      }
+
+      bool runAgain = true;
+
+      if (runnerFiles.count() == 0) {
+        runAgain = false;
+      } else {
+        if (exitCode == 1) {
+          runAgain = false;
+        }
+      }
+
+      if (runAgain) {
+        isFinished = false;
+        loadSpec();
+      } else {
+        QApplication::instance()->exit(exitCode);
+      }
+    }
+
+    if (m_runs > 30) {
+      std::cout << "WARNING: too many runs and the test is still not finished!" << std::endl;
+      QApplication::instance()->exit(1);
+    }
+  }
+}
+

data/ext/jasmine-webkit-specrunner/HeadlessSpecRunner/Runner.h

@@ -0,0 +1,61 @@
+#ifndef JHW_RUNNER
+#define JHW_RUNNER
+
+#include <QtGui>
+#include <QtWebKit>
+#include <QFile>
+#include <QTextStream>
+#include <iostream>
+#include <QQueue>
+
+#include "Page.h"
+
+namespace HeadlessSpecRunner {
+  class Runner: public QObject {
+    Q_OBJECT
+    public:
+      Runner();
+      void setColors(bool colors);
+      void reportFile(const QString &file);
+      void addFile(const QString &spec);
+      void go();
+    public slots:
+      void log(const QString &msg);
+      bool hasError();
+      void leavePageAttempt(const QString &msg);
+      void specPassed();
+      void specFailed(const QString &specDetail);
+      void printName(const QString &name);
+      void printResult(const QString &result);
+      void finishSuite(const QString &duration, const QString &total, const QString& failed);
+    private slots:
+      void watch(bool ok);
+      void errorLog(const QString &msg, int lineNumber, const QString &sourceID);
+      void internalLog(const QString &note, const QString &msg);
+      void addJHW();
+    protected:
+      bool hasElement(const char *select);
+      void timerEvent(QTimerEvent *event);
+    private:
+      HeadlessSpecRunner::Page m_page;
+      QBasicTimer m_ticker;
+      int m_runs;
+      bool hasErrors;
+      bool usedConsole;
+      bool showColors;
+      bool isFinished;
+      bool didFail;
+      bool consoleNotUsedThisRun;
+      QQueue<QString> runnerFiles;
+      QString reportFilename;
+      QStack<QString> failedSpecs;
+
+      void red();
+      void green();
+      void yellow();
+      void clear();
+      void loadSpec();
+  };
+}
+
+#endif

data/ext/jasmine-webkit-specrunner/extconf.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+
 $: << File.expand_path("../../../lib", __FILE__)
 
 require 'qt/qmake'