jasmine-headless-webkit 0.7.3.1 → 0.7.3.2

data/Guardfile

@@ -3,6 +3,8 @@
 #   watch('file/path') { `command(s)` }
 #
 
+guard 'coffeescript', :input => 'vendor/assets/coffeescripts', :output => 'vendor/assets/javascripts'
+
 guard 'shell' do
   watch(%r{ext/jasmine-webkit-specrunner/.*\.(cpp|h|pro|pri)}) { |m|
     if !m[0]['moc_']
@@ -27,9 +29,8 @@ end
 
 def compile
   #system %{cd ext/jasmine-webkit-specrunner && ruby test.rb && ruby extconf.rb}
-  system %{cd ext/jasmine-webkit-specrunner && ruby test.rb && ruby extconf.rb}
+  system %{cd ext/jasmine-webkit-specrunner && ruby extconf.rb}
 end
 
 compile
 
-guard 'coffeescript', :input => 'jasmine'

data/bin/jasmine-headless-webkit

@@ -9,6 +9,7 @@ end
 
 $:.unshift(File.join(gem_dir, 'lib'))
 require 'jasmine-headless-webkit'
+require 'coffee-script'
 
 begin
   options = Jasmine::Headless::Options.from_command_line
@@ -18,7 +19,6 @@ begin
     files_list = Jasmine::FilesList.new(:config => runner.jasmine_config)
     files_list.files.each { |file| puts file }
   else
-    puts "Running Jasmine specs...".color(:white)
     exit runner.run
   end
 rescue CoffeeScript::CompilationError

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

@@ -4,26 +4,13 @@
 
 #include "Page.h"
 
-  Page::Page() : QWebPage(), confirmResult(true) {}
+Page::Page() : QWebPage() {}
 
-  void Page::javaScriptConsoleMessage(const QString &message, int lineNumber, const QString &sourceID) {
-    emit consoleLog(message, lineNumber, sourceID);
-  }
+void Page::javaScriptConsoleMessage(const QString & message, int lineNumber, const QString & sourceID) {
+  emit handleError(message, lineNumber, sourceID);
+}
 
-  bool Page::javaScriptConfirm(QWebFrame*, const QString&) {
-    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*, const QString &msg) {
-    emit internalLog("alert", msg);
-  }
-
-  void Page::oneFalseConfirm() {
-    confirmResult = false;
-  }
+void Page::javaScriptAlert(QWebFrame *, const QString &) {}
+bool Page::javaScriptConfirm(QWebFrame *, const QString &) {
+  return false;
+}

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

@@ -4,20 +4,16 @@
 #include <QtGui>
 #include <QtWebKit>
 
-  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;
-  };
+class Page: public QWebPage {
+  Q_OBJECT
+  public:
+    Page();
+  protected:
+    void javaScriptConsoleMessage(const QString & message, int lineNumber, const QString & sourceID);
+    void javaScriptAlert(QWebFrame *, const QString &);
+    bool javaScriptConfirm(QWebFrame *, const QString &);
+  signals:
+    void handleError(const QString & message, int lineNumber, const QString & sourceID);
+};
 
 #endif

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

@@ -3,181 +3,157 @@
 #include <QFile>
 #include <QTextStream>
 #include <iostream>
+#include <sstream>
 #include <QQueue>
 
 #include "Runner.h"
+#include "Page.h"
 
 using namespace std;
 
 Runner::Runner() : QObject()
-  , m_runs(0)
+  , runs(0)
   , hasErrors(false)
+  , _hasSpecFailure(false)
   , usedConsole(false)
   , isFinished(false)
-  , didFail(false)
+  , useColors(false)
   {
-  m_page.settings()->enablePersistentStorage();
-  m_ticker.setInterval(TIMER_TICK);
+  page.settings()->enablePersistentStorage();
+  ticker.setInterval(TIMER_TICK);
 
-  connect(&m_ticker, SIGNAL(timeout()), this, SLOT(timerEvent()));
-  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()));
+  connect(&ticker, SIGNAL(timeout()), this, SLOT(timerEvent()));
+  connect(&page, SIGNAL(loadFinished(bool)), this, SLOT(watch(bool)));
+  connect(&page, SIGNAL(handleError(const QString &, int, const QString &)), this, SLOT(handleError(const QString &, int, const QString &)));
+  connect(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));
+void Runner::go() {
+  ticker.stop();
+  page.setPreferredContentsSize(QSize(1024, 600));
   addJHW();
-  loadSpec();
 
-  m_ticker.start();
+  loadSpec();
 }
-void Runner::addJHW()
-{
-  m_page.mainFrame()->addToJavaScriptWindowObject("JHW", this);
+void Runner::addJHW() {
+  page.mainFrame()->addToJavaScriptWindowObject("JHW", this);
+}
+
+void Runner::handleError(const QString &message, int lineNumber, const QString &sourceID) {
+  QString messageEscaped = QString(message);
+  QString sourceIDEscaped = QString(sourceID);
+
+  messageEscaped.replace(QString("\""), QString("\\\""));
+  sourceIDEscaped.replace(QString("\""), QString("\\\""));
+
+  std::stringstream ss;
+  ss << lineNumber;
+
+  QString command("JHW._handleError(\"" + messageEscaped + "\", " + QString(ss.str().c_str()) + ", \"" + sourceIDEscaped + "\"); false;");
+
+  page.mainFrame()->evaluateJavaScript(command);
+
+  hasErrors = true;
 }
 
 void Runner::loadSpec()
 {
-  m_page.mainFrame()->load(runnerFiles.dequeue());
-  m_ticker.start();
+  if (reportFileName.isEmpty()) {
+    outputFile = 0;
+    ts = 0;
+  } else {
+    outputFile = new QFile(reportFileName);
+    outputFile->open(QIODevice::WriteOnly);
+
+    ts = new QTextStream(outputFile);
+  }
+
+  page.mainFrame()->load(runnerFiles.dequeue());
+  ticker.start();
 }
 
-void Runner::watch(bool ok)
-{
+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 << "Can't load " << qPrintable(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;
   }
 
-}
-
-bool Runner::hasElement(const char *select)
-{
-  return !m_page.mainFrame()->findFirstElement(select).isNull();
+  page.mainFrame()->evaluateJavaScript(QString("JHW._setColors(") + (useColors ? QString("true") : QString("false")) + QString("); false;"));
 }
 
 void Runner::setColors(bool colors) {
-  consoleOutput.showColors = colors;
+  useColors = colors;
 }
 
-void Runner::reportFile(const QString &file) {
-  reportFileName = file;
-}
-
-bool Runner::hasError() {
-  return hasErrors;
-}
-
-void Runner::timerPause() {
-  m_ticker.stop();
-}
-
-void Runner::timerDone() {
-  m_ticker.start();
-}
-
-void Runner::specPassed(const QString &specDetail) {
-  consoleOutput.passed(specDetail);
-  reportFileOutput.passed(specDetail);
-}
-
-void Runner::specFailed(const QString &specDetail) {
-  consoleOutput.failed(specDetail);
-  reportFileOutput.failed(specDetail);
-
-  didFail = true;
-  failedSpecs.push(specDetail);
+void Runner::hasUsedConsole() {
+  usedConsole = true;
 }
 
-void Runner::errorLog(const QString &msg, int lineNumber, const QString &sourceID)
-{
-  consoleOutput.errorLog(msg, lineNumber, sourceID);
-  reportFileOutput.errorLog(msg, lineNumber, sourceID);
-
+void Runner::hasError() {
   hasErrors = true;
-  m_runs = 0;
-  m_ticker.start();
 }
 
-void Runner::internalLog(const QString &note, const QString &msg) {
-  consoleOutput.internalLog(note, msg);
-  reportFileOutput.internalLog(note, msg);
+void Runner::hasSpecFailure() {
+  _hasSpecFailure = true;
 }
 
-void Runner::log(const QString &msg)
-{
-  usedConsole = true;
-  consoleOutput.consoleLog(msg);
-  reportFileOutput.consoleLog(msg);
+void Runner::reportFile(const QString &file) {
+  reportFileName = file;
 }
 
-void Runner::leavePageAttempt(const QString &msg)
-{
-  consoleOutput.internalLog("error", msg);
-  m_page.oneFalseConfirm();
-  hasErrors = true;
+void Runner::timerPause() {
+  ticker.stop();
 }
 
-void Runner::printName(const QString &name)
-{
-  consoleOutput.logSpecFilename(name);
+void Runner::timerDone() {
+  ticker.start();
 }
 
-void Runner::printResult(const QString &result)
-{
-  consoleOutput.logSpecResult(result);
+void Runner::ping() {
+  runs = 0;
 }
 
-void Runner::finishSuite(const QString &duration, const QString &total, const QString& failed)
-{
-  if (didFail) {
-    consoleOutput.reportFailure(total, failed, duration);
-    reportFileOutput.reportFailure(total, failed, duration);
-  } else {
-    if (hasErrors) {
-      consoleOutput.reportSuccessWithJSErrors(total, failed, duration);
-      reportFileOutput.reportSuccessWithJSErrors(total, failed, duration);
-    } else {
-      consoleOutput.reportSuccess(total, failed, duration);
-      reportFileOutput.reportSuccess(total, failed, duration);
-    }
+void Runner::print(const QString &fh, const QString &content) {
+  if (fh == "stdout") {
+    std::cout << qPrintable(content);
+    std::cout.flush();
   }
 
-  if (!reportFileName.isEmpty()) {
-    QFile outputFile(reportFileName);
-    outputFile.open(QIODevice::WriteOnly);
-
-    QTextStream ts(&outputFile);
-
-    ts << reportFileOutput.outputIO->str().c_str();
+  if (fh == "stderr") {
+    std::cerr << qPrintable(content);
+    std::cerr.flush();
+  }
 
-    outputFile.close();
+  if (fh == "report" && outputFile) {
+    *ts << qPrintable(content);
+    ts->flush();
   }
+}
 
+void Runner::finishSuite() {
   isFinished = true;
 }
 
-void Runner::timerEvent()
-{
-  ++m_runs;
+void Runner::timerEvent() {
+  ++runs;
 
-  if (hasErrors && m_runs > 2)
+  if (hasErrors && runs > 2)
     QApplication::instance()->exit(1);
 
   if (isFinished) {
+    if (outputFile) {
+      outputFile->close();
+    }
+
     int exitCode = 0;
-    if (didFail || hasErrors) {
+    if (_hasSpecFailure || hasErrors) {
       exitCode = 1;
     } else {
       if (usedConsole) {
@@ -203,8 +179,8 @@ void Runner::timerEvent()
     }
   }
 
-  if (m_runs > MAX_LOOPS) {
-    std::cout << "WARNING: too many runs and the test is still not finished!" << std::endl;
+  if (runs > MAX_LOOPS) {
+    std::cerr << "WARNING: too many runs and the test is still not finished!" << std::endl;
     QApplication::instance()->exit(1);
   }
 }

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

@@ -10,57 +10,54 @@
 #include <QQueue>
 
 #include "Page.h"
-#include "ConsoleOutput.h"
-#include "ReportFileOutput.h"
 
 using namespace std;
 
 class Runner: public QObject {
   Q_OBJECT
   public:
-    enum { TIMER_TICK = 200, MAX_LOOPS = 25 };
+    enum { TIMER_TICK = 200, MAX_LOOPS = 50 };
 
     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);
+
+  public slots:
     void timerPause();
     void timerDone();
-    void specPassed(const QString &specDetail);
-    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 hasUsedConsole();
+    void hasError();
+    void hasSpecFailure();
+    void print(const QString &fh, const QString &content);
+    void finishSuite();
+    void ping();
+
+  private slots:
+    void watch(bool ok);
     void addJHW();
     void timerEvent();
-  protected:
-    bool hasElement(const char *select);
+    void handleError(const QString & message, int lineNumber, const QString & sourceID);
+
   private:
-    Page m_page;
-    QTimer m_ticker;
-    int m_runs;
+    Page page;
+    QTimer ticker;
+    int runs;
     bool hasErrors;
+    bool _hasSpecFailure;
     bool usedConsole;
     bool isFinished;
-    bool didFail;
-    QQueue<QString> runnerFiles;
-    QStack<QString> failedSpecs;
+    bool useColors;
 
-    ConsoleOutput consoleOutput;
-    ReportFileOutput reportFileOutput;
+    QQueue<QString> runnerFiles;
 
     QString reportFileName;
 
     void loadSpec();
+
+    QFile *outputFile;
+    QTextStream *ts;
 };
 
 #endif