jasmine-headless-webkit 0.6.3 → 0.7.0

data/.gitignore

@@ -10,3 +10,6 @@ ext/jasmine-webkit-specrunner/jasmine-webkit-specrunner
 moc_*.*
 .DS_Store
 hydra-runner.log
+jhw-test
+.jhw-cache/
+_site/

data/Gemfile

@@ -12,4 +12,6 @@ gem 'guard-coffeescript'
 gem 'growl'
 gem 'rake', '0.8.7'
 gem 'mocha', '0.9.12'
-gem 'guard-jasmine-headless-webkit'
+gem 'guard-jasmine-headless-webkit', :git => 'git://github.com/johnbintz/guard-jasmine-headless-webkit.git'
+gem 'facter'
+

data/Guardfile

@@ -4,7 +4,11 @@
 #
 
 guard 'shell' do
-  watch(%r{ext/jasmine-webkit-specrunner/.*\.(cpp|h)}) { compile }
+  watch(%r{ext/jasmine-webkit-specrunner/.*\.(cpp|h|pro|pri)}) { |m|
+    if !m[0]['moc_']
+      compile 
+    end
+  }
 end
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
@@ -22,7 +26,8 @@ guard 'jasmine-headless-webkit', :all_on_start => false do
 end
 
 def compile
-  system %{cd ext/jasmine-webkit-specrunner && ruby extconf.rb}
+  #system %{cd ext/jasmine-webkit-specrunner && ruby test.rb && ruby extconf.rb}
+  system %{cd ext/jasmine-webkit-specrunner && ruby test.rb && ruby extconf.rb}
 end
 
 compile

data/Rakefile

@@ -9,6 +9,7 @@ RSpec::Core::RakeTask.new(:spec)
 
 $: << File.expand_path('../lib', __FILE__)
 
+require 'jasmine-headless-webkit'
 require 'jasmine/headless/task'
 
 Jasmine::Headless::Task.new

data/bin/jasmine-headless-webkit

@@ -8,13 +8,26 @@ def gem_dir
 end
 
 $:.unshift(File.join(gem_dir, 'lib'))
+require 'jasmine-headless-webkit'
+
 require 'jasmine/headless/errors'
 require 'jasmine/headless/runner'
 require 'jasmine/headless/options'
 
 begin
-  puts "Running Jasmine specs...".color(:white)
-  exit Jasmine::Headless::Runner.run(Jasmine::Headless::Options.from_command_line)
+  options = Jasmine::Headless::Options.from_command_line
+  runner = Jasmine::Headless::Runner.new(options)
+
+  if options[:do_list]
+    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
   exit 1
 rescue StandardError => e

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

@@ -0,0 +1,140 @@
+#include "ConsoleOutput.h"
+
+ConsoleOutput::ConsoleOutput() : QObject(),
+  showColors(false),
+  consoleLogUsed(false) {
+    outputIO = &std::cout;
+  }
+
+void ConsoleOutput::passed(const QString &specDetail) {
+  green();
+  *outputIO << '.';
+  clear();
+  outputIO->flush();
+
+  consoleLogUsed = false;
+  successes.push(specDetail);
+}
+
+void ConsoleOutput::failed(const QString &specDetail) {
+  red();
+  *outputIO << 'F';
+  clear();
+  outputIO->flush();
+
+  consoleLogUsed = false;
+  failures.push(specDetail);
+}
+
+void ConsoleOutput::green() {
+  if (showColors) std::cout << "\033[0;32m";
+}
+
+void ConsoleOutput::clear() {
+  if (showColors) std::cout << "\033[m";
+}
+
+void ConsoleOutput::red() {
+  if (showColors) std::cout << "\033[0;31m";
+}
+
+void ConsoleOutput::yellow()
+{
+  if (showColors) std::cout << "\033[0;33m";
+}
+
+void ConsoleOutput::errorLog(const QString &msg, int lineNumber, const QString &sourceID) {
+  red();
+  *outputIO << "[error] ";
+  clear();
+  *outputIO << qPrintable(sourceID) << ":" << lineNumber << " : " << qPrintable(msg);
+  *outputIO << std::endl;
+}
+
+void ConsoleOutput::internalLog(const QString &note, const QString &msg) {
+  red();
+  *outputIO << "[" << qPrintable(note) << "] ";
+  clear();
+  *outputIO << qPrintable(msg);
+  *outputIO << std::endl;
+}
+
+void ConsoleOutput::consoleLog(const QString &msg) {
+  if (!consoleLogUsed) {
+    *outputIO << std::endl;
+    consoleLogUsed = true;
+  }
+
+  green();
+  *outputIO << "[console] ";
+  if (msg.contains("\n"))
+    *outputIO << std::endl;
+  clear();
+  *outputIO << qPrintable(msg);
+  *outputIO << std::endl;
+}
+
+void ConsoleOutput::logSpecFilename(const QString &name) {
+  *outputIO << std::endl << std::endl;
+  red();
+  *outputIO << qPrintable(name) << std::endl;
+  clear();
+}
+
+void ConsoleOutput::logSpecResult(const QString &result) {
+  red();
+  *outputIO << "  " << qPrintable(result) << std::endl;
+  clear();
+}
+
+void ConsoleOutput::reportFailure(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  red();
+  *outputIO << std::endl << "FAIL: ";
+  formatTestResults(totalTests, failedTests, duration);
+  *outputIO << std::endl;
+  clear();
+}
+
+void ConsoleOutput::reportSuccess(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  green();
+  *outputIO << std::endl << "PASS: ";
+  formatTestResults(totalTests, failedTests, duration);
+  *outputIO << std::endl;
+  clear();
+}
+
+void ConsoleOutput::reportSuccessWithJSErrors(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  yellow();
+  *outputIO << std::endl << "PASS with JS errors: ";
+  formatTestResults(totalTests, failedTests, duration);
+  *outputIO << std::endl;
+  clear();
+}
+
+void ConsoleOutput::formatTestResults(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  *outputIO << qPrintable(totalTests) << " ";
+  if (totalTests == "1") {
+    *outputIO << "test";
+  } else {
+    *outputIO << "tests";
+  }
+
+  *outputIO << ", ";
+
+  *outputIO << qPrintable(failedTests) << " ";
+  if (failedTests == "1") {
+    *outputIO << "failure";
+  } else {
+    *outputIO << "failures";
+  }
+
+  *outputIO << ", ";
+
+  *outputIO << qPrintable(duration) << " ";
+  if (duration == "1") {
+    *outputIO << "sec.";
+  } else {
+    *outputIO << "secs.";
+  }
+}
+

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

@@ -0,0 +1,38 @@
+#ifndef JHW_CONSOLE_OUTPUT
+#define JHW_CONSOLE_OUTPUT
+
+#include <QObject>
+#include <iostream>
+#include <QStack>
+
+class ConsoleOutput : public QObject {
+  public:
+    ConsoleOutput();
+
+    void passed(const QString &specDetail);
+    void failed(const QString &specDetail);
+    void errorLog(const QString &msg, int lineNumber, const QString &sourceID);
+    void internalLog(const QString &note, const QString &msg);
+    void consoleLog(const QString &msg);
+    void logSpecFilename(const QString &name);
+    void logSpecResult(const QString &result);
+
+    void reportFailure(const QString &totalTests, const QString &failedTests, const QString &duration);
+    void reportSuccess(const QString &totalTests, const QString &failedTests, const QString &duration);
+    void reportSuccessWithJSErrors(const QString &totalTests, const QString &failedTests, const QString &duration);
+
+    std::ostream *outputIO;
+    QStack<QString> successes;
+    QStack<QString> failures;
+
+    bool showColors;
+    bool consoleLogUsed;
+  private:
+    void green();
+    void clear();
+    void red();
+    void yellow();
+    void formatTestResults(const QString &totalTests, const QString &failedTests, const QString &duration);
+};
+
+#endif

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

@@ -0,0 +1,129 @@
+#include <QtTest/QtTest>
+
+#include "ConsoleOutput.h"
+#include "ConsoleOutput_test.h"
+
+using namespace std;
+
+  ConsoleOutputTest::ConsoleOutputTest() : QObject() {}
+
+  void ConsoleOutputTest::testPassed() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.consoleLogUsed = true;
+    output.outputIO = &buffer;
+    output.passed("test");
+    QVERIFY(buffer.str() == ".");
+    QVERIFY(output.successes.size() == 1);
+    QVERIFY(output.failures.size() == 0);
+    QVERIFY(output.consoleLogUsed == false);
+  }
+
+  void ConsoleOutputTest::testFailed() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.consoleLogUsed = true;
+    output.outputIO = &buffer;
+    output.failed("test");
+    QVERIFY(buffer.str() == "F");
+    QVERIFY(output.successes.size() == 0);
+    QVERIFY(output.failures.size() == 1);
+    QVERIFY(output.consoleLogUsed == false);
+  }
+
+  void ConsoleOutputTest::testErrorLog() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.errorLog("message", 1, "source");
+    QVERIFY(buffer.str() == "[error] source:1 : message\n");
+  }
+
+  void ConsoleOutputTest::testInternalLog() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.internalLog("note", "message");
+    QVERIFY(buffer.str() == "[note] message\n");
+  }
+
+  void ConsoleOutputTest::testConsoleLog() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.consoleLogUsed = false;
+    output.outputIO = &buffer;
+    output.consoleLog("log");
+    QVERIFY(buffer.str() == "\n[console] log\n");
+  }
+
+  void ConsoleOutputTest::testConsoleLogUsed() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.consoleLogUsed = true;
+    output.outputIO = &buffer;
+    output.consoleLog("log");
+    QVERIFY(buffer.str() == "[console] log\n");
+  }
+
+  void ConsoleOutputTest::testLogSpecFilename() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.logSpecFilename("whatever");
+    QVERIFY(buffer.str() == "\n\nwhatever\n");
+  }
+
+  void ConsoleOutputTest::testLogSpecResult() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.logSpecResult("whatever");
+    QVERIFY(buffer.str() == "  whatever\n");
+  }
+
+  void ConsoleOutputTest::testReportResultsFailedSingular() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.reportFailure("1", "1", "1");
+    QVERIFY(buffer.str() == "\nFAIL: 1 test, 1 failure, 1 sec.\n");
+  }
+
+  void ConsoleOutputTest::testReportResultsFailedPlural() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.reportFailure("2", "2", "2");
+    QVERIFY(buffer.str() == "\nFAIL: 2 tests, 2 failures, 2 secs.\n");
+  }
+
+  void ConsoleOutputTest::testReportResultsSucceeded() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.reportSuccess("2", "2", "2");
+    QVERIFY(buffer.str() == "\nPASS: 2 tests, 2 failures, 2 secs.\n");
+  }
+
+  void ConsoleOutputTest::testReportResultsSucceededWithJSErrors() {
+    stringstream buffer;
+    ConsoleOutput output;
+
+    output.outputIO = &buffer;
+    output.reportSuccessWithJSErrors("2", "2", "2");
+    QVERIFY(buffer.str() == "\nPASS with JS errors: 2 tests, 2 failures, 2 secs.\n");
+  }
+
+QTEST_MAIN(ConsoleOutputTest);
+

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

@@ -0,0 +1,32 @@
+#ifndef JHW_TEST_CONSOLE_OUTPUT
+#define JHW_TEST_CONSOLE_OUTPUT
+
+#include <QtTest/QtTest>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "ConsoleOutput.h"
+
+class ConsoleOutputTest : public QObject {
+  Q_OBJECT
+  public:
+    ConsoleOutputTest();
+
+    private slots:
+      void testPassed();
+    void testFailed();
+    void testErrorLog();
+    void testInternalLog();
+    void testConsoleLog();
+    void testConsoleLogUsed();
+    void testLogSpecFilename();
+    void testLogSpecResult();
+
+    void testReportResultsFailedSingular();
+    void testReportResultsFailedPlural();
+    void testReportResultsSucceeded();
+    void testReportResultsSucceededWithJSErrors();
+};
+
+#endif

data/ext/jasmine-webkit-specrunner/ConsoleOutput_test.pro

@@ -0,0 +1,7 @@
+include(common.pri)
+include(test.pri)
+
+SOURCES += ConsoleOutput_test.cpp
+HEADERS += ConsoleOutput_test.h
+
+

data/ext/jasmine-webkit-specrunner/Makefile.dummy

@@ -0,0 +1,5 @@
+build:
+	true
+install:
+	true
+

data/ext/jasmine-webkit-specrunner/{HeadlessSpecRunner/Page.cpp → Page.cpp}

@@ -1,16 +1,16 @@
 #include <QtGui>
 #include <QtWebKit>
+#include <iostream>
 
 #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) {
+  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;
@@ -20,11 +20,10 @@ namespace HeadlessSpecRunner {
     }
   }
 
-  void Page::javaScriptAlert(QWebFrame *frame, const QString &msg) {
+  void Page::javaScriptAlert(QWebFrame*, const QString &msg) {
     emit internalLog("alert", msg);
   }
 
   void Page::oneFalseConfirm() {
     confirmResult = false;
   }
-}

data/ext/jasmine-webkit-specrunner/{HeadlessSpecRunner/Page.h → Page.h}

@@ -4,7 +4,6 @@
 #include <QtGui>
 #include <QtWebKit>
 
-namespace HeadlessSpecRunner {
   class Page: public QWebPage {
     Q_OBJECT
     public:
@@ -20,6 +19,5 @@ namespace HeadlessSpecRunner {
     private:
       bool confirmResult;
   };
-}
 
 #endif

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

@@ -0,0 +1,43 @@
+#include <QtTest/QtTest>
+
+#include "Page.h"
+#include "Page_test.h"
+
+  PageTest::PageTest() : QObject(), internalLogCalled(false) {
+  }
+
+  void PageTest::internalLog(const QString &, const QString &) {
+    internalLogCalled = true;
+  }
+
+  void PageTest::consoleLog(const QString &, int, const QString &) {
+    consoleLogCalled = true;
+  }
+
+  void PageTest::testJavaScriptConfirmWithLog() {
+    connect(&page, SIGNAL(internalLog(QString, QString)), this, SLOT(internalLog(QString, QString)));
+    internalLogCalled = false;
+
+    page.mainFrame()->setHtml("<script>confirm('test')</script>");
+    QVERIFY(internalLogCalled);
+  }
+
+  void PageTest::testJavaScriptConfirmWithoutLog() {
+    connect(&page, SIGNAL(internalLog(QString, QString)), this, SLOT(internalLog(QString, QString)));
+    internalLogCalled = false;
+
+    page.oneFalseConfirm();
+    page.mainFrame()->setHtml("<script>confirm('test')</script>");
+    QVERIFY(!internalLogCalled);
+  }
+
+  void PageTest::testJavaScriptConsoleMessage() {
+    connect(&page, SIGNAL(consoleLog(QString, int, QString)), this, SLOT(consoleLog(QString, int, QString)));
+    consoleLogCalled = false;
+
+    page.mainFrame()->setHtml("<script>cats();</script>");
+    QVERIFY(consoleLogCalled);
+  }
+
+QTEST_MAIN(PageTest);
+

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

@@ -0,0 +1,27 @@
+#ifndef JHW_TEST_PAGE
+#define JHW_TEST_PAGE
+
+#include <QtTest/QtTest>
+
+#include "Page.h"
+
+  class PageTest : public QObject {
+    Q_OBJECT
+    public:
+      PageTest();
+
+    private:
+      bool internalLogCalled;
+      bool consoleLogCalled;
+      Page page;
+
+    private slots:
+      void internalLog(const QString &note, const QString &msg);
+      void consoleLog(const QString &message, int lineNumber, const QString &source);
+      void testJavaScriptConfirmWithLog();
+      void testJavaScriptConfirmWithoutLog();
+      void testJavaScriptConsoleMessage();
+  };
+
+#endif
+

data/ext/jasmine-webkit-specrunner/Page_test.pro

@@ -0,0 +1,6 @@
+include(common.pri)
+include(test.pri)
+
+SOURCES += Page_test.cpp
+HEADERS += Page_test.h
+

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

@@ -0,0 +1,54 @@
+#include "ReportFileOutput.h"
+
+using namespace std;
+
+ReportFileOutput::ReportFileOutput() : QObject() {
+  reset();
+}
+
+void ReportFileOutput::reset() {
+  buffer = new stringstream();
+
+  outputIO = buffer;
+}
+
+void ReportFileOutput::passed(const QString &specDetail) {
+  *outputIO << "PASS||" << qPrintable(specDetail) << std::endl;
+  successes.push(specDetail);
+}
+
+void ReportFileOutput::failed(const QString &specDetail) {
+  *outputIO << "FAIL||" << qPrintable(specDetail) << std::endl;
+  failures.push(specDetail);
+}
+
+void ReportFileOutput::errorLog(const QString &msg, int lineNumber, const QString &sourceID) {
+  *outputIO << "ERROR||" << qPrintable(msg) << "||" << qPrintable(sourceID) << ":" << lineNumber << std::endl;
+}
+
+void ReportFileOutput::consoleLog(const QString &msg) {
+  *outputIO << "CONSOLE||" << qPrintable(msg) << std::endl;
+}
+
+void ReportFileOutput::internalLog(const QString &, const QString &) {}
+void ReportFileOutput::logSpecFilename(const QString &) {}
+void ReportFileOutput::logSpecResult(const QString &) {}
+
+void ReportFileOutput::reportFailure(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  reportTotals(totalTests, failedTests, duration, false);
+}
+
+void ReportFileOutput::reportSuccess(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  reportTotals(totalTests, failedTests, duration, false);
+}
+
+void ReportFileOutput::reportSuccessWithJSErrors(const QString &totalTests, const QString &failedTests, const QString &duration) {
+  reportTotals(totalTests, failedTests, duration, true);
+}
+
+void ReportFileOutput::reportTotals(const QString &totalTests, const QString &failedTests, const QString &duration, bool hasJavaScriptError) {
+  *outputIO << "TOTAL||" << qPrintable(totalTests) << "||" << qPrintable(failedTests) << "||" << qPrintable(duration) << "||";
+  *outputIO << (hasJavaScriptError ? "T" : "F");
+  *outputIO << std::endl;
+}
+

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

@@ -0,0 +1,37 @@
+#ifndef JHW_REPORT_FILE_OUTPUT
+#define JHW_REPORT_FILE_OUTPUT
+
+#include <QObject>
+#include <iostream>
+#include <QStack>
+#include <sstream>
+
+using namespace std;
+
+class ReportFileOutput : public QObject {
+  public:
+    ReportFileOutput();
+
+    void passed(const QString &specDetail);
+    void failed(const QString &specDetail);
+    void errorLog(const QString &msg, int lineNumber, const QString &sourceID);
+    void internalLog(const QString &note, const QString &msg);
+    void consoleLog(const QString &msg);
+    void logSpecFilename(const QString &name);
+    void logSpecResult(const QString &result);
+
+    void reportFailure(const QString &totalTests, const QString &failedTests, const QString &duration);
+    void reportSuccess(const QString &totalTests, const QString &failedTests, const QString &duration);
+    void reportSuccessWithJSErrors(const QString &totalTests, const QString &failedTests, const QString &duration);
+
+    void reset();
+
+    stringstream *buffer;
+    stringstream *outputIO;
+    QStack<QString> successes;
+    QStack<QString> failures;
+  private:
+    void reportTotals(const QString &totalTests, const QString &failedTests, const QString &duration, bool hasJavaScriptError);
+};
+
+#endif