Compare commits

..

119 Commits

Author SHA1 Message Date
John Bintz
f7384d684c It's been fun. Use Karma instead. 2014-05-14 15:34:21 -04:00
John Bintz
1055dc1016 Merge pull request #177 from jeremy-brenner/master
Qt 4.8 fix
2013-03-15 10:59:23 -07:00
Jeremy Brenner
c1e786f3c5 Added compiler directive to include getopt.h on qt versions >= 4.8 2013-03-15 11:23:50 -05:00
John Bintz
aa1d989a90 message about looking for new maintainer 2012-07-30 11:15:32 -04:00
John Bintz
30e1ff8e51 bump version 2012-04-23 11:08:17 -04:00
John Bintz
9b41a36841 fix a bad commit and fix multijson deprecation warnings 2012-04-23 09:30:56 -04:00
John Bintz
65137186c8 Merge pull request #142 from pungoyal/master
fixing multi_json 1.3.2 issue #140
2012-04-18 08:05:08 -07:00
Puneet Goyal
a89682f771 Update vendor/assets/javascripts/intense.coffee 2012-04-18 20:24:20 +05:30
Puneet Goyal
3815a47d07 fixing multi_json 1.3.2 issue 2012-04-18 20:22:14 +05:30
John Bintz
724541a2cb Merge pull request #135 from tddium/master
Sort order in directory globs
2012-04-03 06:50:51 -07:00
William Josephson
1c81ea7286 Most filesystems don't guarantee directory listing order, so sort glob results. 2012-04-02 22:12:45 -04:00
John Bintz
8c6a792960 Merge pull request #132 from doitian/master
Do not populate the global Sprockets environment
2012-03-23 11:48:33 -07:00
Ian Yang
1aac97ea1f do not populate the global Sprockets environment 2012-03-23 22:52:54 +08:00
John Bintz
21590a9a19 Merge pull request #111 from rossta/register_custom_template_hook
Ability to register custom template engines...
2012-03-22 04:17:13 -07:00
John Bintz
68683e4b6c Merge pull request #131 from pmcelhaney/patch-1
Great price and record fast shipping time!!! Would request again. :)
2012-03-20 11:12:14 -07:00
Patrick McElhaney
181f4e286a Removed log messages from spec runner. 2012-03-19 17:05:51 -03:00
John Bintz
d572b0d6fe Merge pull request #130 from pmcelhaney/patch-1
Fixed getLastModified callback firing three times
2012-03-19 12:11:28 -07:00
Patrick McElhaney
af20af8524 Fixed getLastModified callback firing three times (once for every readyState change). 2012-03-19 15:28:41 -03:00
John Bintz
0064595dea remove the specification of the qmakespec, maybe help fix #59 2012-02-21 09:19:33 -05:00
John Bintz
2e2651d11a may fix #119, file paths on windows 2012-02-21 09:04:00 -05:00
John Bintz
c96cbd4aac move sprockets gem finding to separate gem that enforces rubygems version, implements #116 in a different way 2012-02-08 09:07:54 -05:00
John Bintz
4f11cba073 some fixes for bad things. i'm sad 2012-02-03 15:12:28 -05:00
John Bintz
bad6839760 rc version bump 2012-01-27 09:19:44 -05:00
John Bintz
453f439271 forgot a change 2012-01-24 14:47:31 -05:00
John Bintz
142a0c974b make sure src_files can also be loaded from other asset paths, should fix problem found by @christiannelson 2012-01-24 14:38:10 -05:00
Ross Kaffenberger
75dce5b66b Ability to register custom template engines via Jasmine::Headless.register_engine hook 2012-01-22 18:40:13 -05:00
John Bintz
0d4550524f crazy crazy changes for server running and outside browser usage and other *magic* 2012-01-18 18:04:36 -05:00
John Bintz
47b8d10d56 server runner updated 2012-01-17 13:32:57 -05:00
John Bintz
d3c3e7bd7d don't reinvent the wheel 2012-01-13 07:45:27 -05:00
John Bintz
f51f041b85 webrick seems to need log write locations or things get weird 2012-01-12 18:40:25 -05:00
John Bintz
8de1bd8cf0 clean up some fixes 2012-01-12 18:07:08 -05:00
John Bintz
09842c0539 fix a few verbose reporter bugs 2012-01-12 16:47:36 -05:00
John Bintz
5d43eb2193 let's run with a server, like all the cool kids do nowadays\! 2012-01-12 15:02:32 -05:00
John Bintz
ed4590ee44 ensure assets with same logical_path but different pathnames are included, fixes #110 2012-01-12 14:16:16 -05:00
John Bintz
b7553062bd rearrange js 2012-01-11 15:41:27 -05:00
John Bintz
ed76916205 more cleanup 2012-01-11 14:24:09 -05:00
John Bintz
b9b4648a24 update reporter 2012-01-11 11:37:25 -05:00
John Bintz
282ed40264 merge 2012-01-11 09:58:47 -05:00
John Bintz
1f56031d8b -q to silence some noisy things, fixes #97 2012-01-11 08:44:28 -05:00
John Bintz
da59a48025 add verbose reporter 2012-01-10 17:14:37 -05:00
John Bintz
81f561282a make sure window.promot doesn't get called, fixes #106 2012-01-09 13:20:58 -05:00
John Bintz
dfe1bece2c make sure window.promot doesn't get called, fixes #106 2012-01-09 11:09:34 -05:00
John Bintz
7587381e1e qt 4.8 webkit doesn't use working dir to resolve local file urls anymore, fixes #101 2012-01-03 10:47:18 -05:00
John Bintz
df83a61cb5 add help options 2011-12-30 15:33:06 -05:00
John Bintz
d5b2239d0f more clean up work, break things apart for manageability/testing 2011-12-30 11:34:30 -05:00
John Bintz
d31f628d91 clean up how reporting is done somoe more 2011-12-30 10:47:08 -05:00
John Bintz
0adf3a41b6 a whole ton of reporters work 2011-12-29 18:37:23 -05:00
John Bintz
09f4df94de merge 2011-12-29 09:38:24 -05:00
John Bintz
9dafb83892 things in a weird state... 2011-12-29 09:32:27 -05:00
John Bintz
9ff0dca191 Merge branch 'master' of github.com:johnbintz/jasmine-headless-webkit 2011-12-24 10:12:44 -05:00
John Bintz
dd86eb404e remove debugging 2011-12-24 09:55:21 -05:00
John Bintz
ac9a9cf23b try loading bundler too 2011-12-24 09:54:04 -05:00
John Bintz
e38963ed42 try loading bundler too 2011-12-24 09:53:52 -05:00
John Bintz
8465590930 Merge pull request #98 from lautis/erb-in-config-file
Parse and run ERB tags inside YAML config
2011-12-16 06:31:00 -08:00
Ville Lautanala
4c7a1f860d Parse and run ERB tags inside YAML config 2011-12-16 14:21:06 +02:00
John Bintz
5743227de6 have runner define report files as a queue 2011-12-12 14:54:53 -05:00
John Bintz
e03389e938 start splitting the reporters out 2011-12-12 12:22:32 -05:00
John Bintz
4e64480c69 bump version 2011-12-12 09:44:45 -05:00
John Bintz
7dde9328df add lib/ and app/ to vendored assets search, fixes #93 2011-12-08 09:13:45 -05:00
John Bintz
84e369d30a bump version 2011-12-06 09:37:26 -05:00
John Bintz
352ee417c5 fix extension search issue and expand bad extension searches to jasmine-style includes 2011-12-06 09:31:23 -05:00
John Bintz
00468fc1b3 Merge pull request #90 from scottdavis/master
Patch for unsupported formats in sprockets
2011-12-05 15:52:15 -08:00
Scott Davis
297f822da1 register non supported formats to there own handler and return there contents as empty so sprokets requres do not have to be changed for work. This will report to STDOUT if the file has been skipped 2011-12-05 18:49:52 -05:00
John Bintz
1099773484 bump version 2011-12-05 17:30:23 -05:00
John Bintz
d038a748ed remove debugging 2011-12-02 18:47:17 -05:00
John Bintz
3b0a11edea fix spec filtering 2011-12-02 18:37:14 -05:00
John Bintz
f3dd4f2bf8 bump version 2011-12-01 18:24:15 -05:00
John Bintz
6ad4bdaec0 also provide asset_paths in jasmine.yml for adding paths 2011-12-01 16:52:01 -05:00
John Bintz
e25d89962c fix issues for when not running under bundler 2011-12-01 10:37:35 -05:00
John Bintz
b6d94a5d0d make sure a parent module is defined first 2011-12-01 10:26:23 -05:00
John Bintz
ab1994696d bump version and add basic developer instructions 2011-12-01 10:01:06 -05:00
John Bintz
5d504570fd small refactoring 2011-12-01 08:59:05 -05:00
John Bintz
a291fd5de3 clean up the printing of headless reporter results 2011-11-29 15:36:17 -05:00
John Bintz
af14f69a07 performance boost in finding matchign spec lines 2011-11-29 15:11:40 -05:00
John Bintz
3c993001de use kernel.rand/srand 2011-11-29 14:48:55 -05:00
John Bintz
602eb634d7 bump version for upcoming release 2011-11-29 11:25:20 -05:00
John Bintz
9affa65df4 fix writing of paths and stuff, fixes #77 2011-11-29 10:56:02 -05:00
John Bintz
0d4562119f small speed optimization 2011-11-29 09:45:23 -05:00
John Bintz
ee3b6e598c cacheable actions write out better filenames, and get rid of local jquery and use jquery-rails gem for testing 2011-11-28 16:53:42 -05:00
John Bintz
4ae9815471 better randomization 2011-11-28 11:52:33 -05:00
John Bintz
3fe66c66c5 specify the random order seed with --seed 2011-11-28 11:47:05 -05:00
John Bintz
f8db052281 randomize spec load order because why not 2011-11-25 18:11:21 -05:00
John Bintz
16f867af09 a little cleanup work 2011-11-25 16:18:06 -05:00
John Bintz
03a381d3cc prevent crazy onload loop, perhaps? 2011-11-25 11:20:14 -05:00
John Bintz
bd6a1afb92 bump version 2011-11-23 10:53:26 -05:00
John Bintz
3911041866 merge sprockets code into mainline, please report bugs 2011-11-23 09:50:14 -05:00
John Bintz
edf5a49f27 test coverage and cleanup in anticipation of merge 2011-11-23 09:35:44 -05:00
John Bintz
634f60ffe6 fix tests 2011-11-22 14:01:05 -05:00
John Bintz
38327e6a95 more cleanups for things i found that are broken 2011-11-22 12:14:00 -05:00
John Bintz
2316041580 ok i actually want a bundled asset 2011-11-22 10:51:46 -05:00
John Bintz
7d75b5466f whoa actually just plug in sprockets, need to backfill tests later since i have real work to do 2011-11-22 10:36:42 -05:00
John Bintz
130a65ecdd Merge branch 'sprockets-integration' of github.com:johnbintz/jasmine-headless-webkit into sprockets-integration 2011-11-21 20:19:05 -05:00
John Bintz
7206341768 require_self 2011-11-21 20:18:11 -05:00
John Bintz
a9cc872cc8 some cleanup 2011-11-21 17:03:44 -05:00
John Bintz
7ba77ea1f9 dont show the running message if there are compile errors 2011-11-21 16:10:15 -05:00
John Bintz
a18100bb71 move the jquery console test to the right spot 2011-11-21 14:13:15 -05:00
John Bintz
08798ff88d Merge pull request #82 from rocketpack/master
console.log to clone jQuery objects before appending them.
2011-11-21 10:56:49 -08:00
John Bintz
a9b879722b reset version for a release, other branch will be 0.8 2011-11-21 13:52:01 -05:00
John Bintz
4727ad5b7b show an indicator when wait tests are running, so it doesn't look like the program crashed 2011-11-21 11:33:51 -05:00
John Bintz
9b5729b808 yet more changes, getting really close 2011-11-21 10:55:37 -05:00
John Bintz
fde8bc3b7b a ton of changes 2011-11-21 10:32:49 -05:00
Leo Lännenmäki
115e2eff8b Clone elements before appending them to the temporary div that is used for logging. 2011-11-21 08:18:16 +02:00
John Bintz
d214674620 fixing things up and cleaning more things 2011-11-20 13:35:30 -05:00
John Bintz
ca8c655f00 more sprockets improvements 2011-11-20 11:56:25 -05:00
John Bintz
61c8ed8828 more sprockets improvements 2011-11-19 19:15:38 -05:00
John Bintz
e04d692d26 reowrk a bunch of the tilt stuff, only use extensions we know 2011-11-19 12:45:40 -05:00
John Bintz
8867d00ac8 support sprockets-style jst templates 2011-11-18 16:00:24 -05:00
John Bintz
537b2e437d more work on making sprockets support better, oh yeah 2011-11-18 11:50:48 -05:00
Leo Lännenmäki
f57a59d767 console.log to clone jQuery objects before appending them.
If the appended element was a child of another element it was removed from that element.
This caused console.logging a child element to remove it from the parent.
2011-11-18 15:09:36 +02:00
John Bintz
4f8e732fa4 run the spec file analyzer through the gauntlet 2011-11-18 06:29:36 -05:00
John Bintz
a2e3ea90c9 require works, whoa 2011-11-17 22:16:04 -05:00
John Bintz
1583807c14 still reworking things, broken 2011-11-17 16:18:25 -05:00
John Bintz
9b103807ee explicitly include coffeescript, might fix #79 2011-11-16 15:39:45 -05:00
John Bintz
4150dd1828 working on stuff, broken 2011-11-16 15:28:02 -05:00
John Bintz
91d9773933 do the ping better 2011-11-10 14:18:25 -05:00
John Bintz
26762f0586 have the built-in reporter ping the runner when tests complete, to keep it alive 2011-11-10 13:52:42 -05:00
John Bintz
c7ce823409 merge in the new file handle approach, try it and let me know where it breaks 2011-11-10 11:32:54 -05:00
John Bintz
2d73baabb3 bump version 2011-11-06 09:32:09 -05:00
John Bintz
ce7b0f1368 remove cpu detection, who cares when the runner's about to be totally slimmed down 2011-11-06 09:26:37 -05:00
164 changed files with 3038 additions and 1312 deletions

3
.gitignore vendored
View File

@ -14,3 +14,6 @@ jhw-test
.jhw-cache/
_site/
jhw.*.html
coverage/
tmp/
cache dir/

23
Gemfile
View File

@ -6,12 +6,25 @@ gemspec
gem 'rspec'
gem 'fakefs', :require => nil
gem 'guard'
gem 'guard-rspec'
gem 'guard-shell'
gem 'guard-coffeescript'
gem 'growl'
gem 'rake', '0.8.7'
gem 'mocha', '0.9.12'
gem 'guard-jasmine-headless-webkit', :git => 'git://github.com/johnbintz/guard-jasmine-headless-webkit.git'
gem 'facter'
gem 'guard-cucumber'
require 'rbconfig'
case RbConfig::CONFIG['host_os']
when /darwin/
when /linux/
gem 'libnotify'
end
gem 'mocha'
gem 'cucumber'
gem 'jquery-rails', '~> 1.0.0'
gem 'ejs'
gem 'guard-jasmine-headless-webkit', :git => 'git://github.com/johnbintz/guard-jasmine-headless-webkit.git'

View File

@ -22,13 +22,18 @@ guard 'rspec', :version => 2, :all_on_start => false do
watch('spec/spec_helper.rb') { "spec" }
end
guard 'cucumber', :cli => '-r features --format pretty' do
watch(%r{^features/.+\.feature$})
watch(%r{^features/support/.+$}) { 'features' }
watch(%r{^features/steps/(.+)_steps\.rb$}) { 'features' }
end
guard 'jasmine-headless-webkit', :all_on_start => false do
watch(%r{^spec/javascripts/.+_spec\.coffee})
watch(%r{^jasmine/(.+)\.coffee$}) { |m| "spec/javascripts/#{m[1]}_spec.coffee" }
end
def compile
#system %{cd ext/jasmine-webkit-specrunner && ruby test.rb && ruby extconf.rb}
system %{cd ext/jasmine-webkit-specrunner && ruby extconf.rb}
end

View File

@ -1,3 +1,5 @@
_This project is dead. You should use [Karma](http://karma-runner.github.io/) instead. I do._
# Jasmine Headless WebKit runner
Run your specs at sonic boom speed! No pesky reload button or page rendering slowdowns!
@ -5,6 +7,19 @@ Run your specs at sonic boom speed! No pesky reload button or page rendering slo
http://johnbintz.github.com/jasmine-headless-webkit/ has the most up-to-date information on using
this project. You can see the source of that site on the gh-pages branch.
## For those who want to hack on the project...
The best way to get everything running that you need for development and testing is
to use Guard:
``` bash
bundle install
bundle exec guard
... build Qt runner ...
... compile CoffeeScript to JS ...
... run RSpec and JHW ...
```
## License
* Copyright (c) 2011 John Bintz

View File

@ -14,7 +14,7 @@ require 'jasmine/headless/task'
Jasmine::Headless::Task.new
PLATFORMS = %w{1.8.7 1.9.2 ree 1.9.3-rc1}
PLATFORMS = %w{1.9.2 1.9.3}
def rvm_bundle(command = '')
Bundler.with_clean_env do
@ -30,6 +30,7 @@ namespace :spec do
task :platforms do
rvm_bundle
rvm_bundle "exec rspec spec"
rvm_bundle "exec cucumber"
raise SpecError.new if $?.exitstatus != 0
end
end
@ -43,3 +44,22 @@ task :build_runner do
end
end
desc "Generate vendored JS"
task :generate_js do
require 'sprockets'
source = 'vendor/assets/coffeescripts'
target = 'vendor/assets/javascripts'
env = Sprockets::Environment.new { |s| s.append_path 'vendor/assets/coffeescripts' }
Dir[File.join(File.expand_path(source), '*.coffee')].each do |file|
file_target = file.gsub(source, target).gsub('.coffee', '.js')
puts "#{file} => #{file_target}"
File.open(file_target, 'wb') do |fh|
fh.print env.find_asset(File.expand_path(file)).to_s
end
end
end

View File

@ -1,30 +1,11 @@
#!/usr/bin/env ruby
require 'rubygems'
require 'rainbow'
def gem_dir
File.expand_path('../..', __FILE__)
end
$: << File.expand_path('../../lib', __FILE__)
$:.unshift(File.join(gem_dir, 'lib'))
require 'jasmine-headless-webkit'
require 'coffee-script'
begin
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
exit runner.run
end
rescue CoffeeScript::CompilationError
exit 1
rescue StandardError => e
$stderr.puts "[%s] %s (%s)" % [ "jasmine-headless-webkit".color(:red), e.message.color(:white), e.class.name.color(:yellow) ]
$stderr.puts e.backtrace.collect { |line| " #{line}" }.join("\n")
exit 1
end
Jasmine::Headless::CommandLine.run!

2
config/cucumber.yml Normal file
View File

@ -0,0 +1,2 @@
default: -r features

View File

@ -11,6 +11,5 @@ void Page::javaScriptConsoleMessage(const QString & message, int lineNumber, con
}
void Page::javaScriptAlert(QWebFrame *, const QString &) {}
bool Page::javaScriptConfirm(QWebFrame *, const QString &) {
return false;
}
bool Page::javaScriptConfirm(QWebFrame *, const QString &) { return false; }
bool Page::javaScriptPrompt(QWebFrame *, const QString &, const QString &, QString *) { return false; }

View File

@ -12,6 +12,7 @@ class Page: public QWebPage {
void javaScriptConsoleMessage(const QString & message, int lineNumber, const QString & sourceID);
void javaScriptAlert(QWebFrame *, const QString &);
bool javaScriptConfirm(QWebFrame *, const QString &);
bool javaScriptPrompt(QWebFrame *, const QString &, const QString &, QString *);
signals:
void handleError(const QString & message, int lineNumber, const QString & sourceID);
};

View File

@ -18,6 +18,7 @@ Runner::Runner() : QObject()
, usedConsole(false)
, isFinished(false)
, useColors(false)
, quiet(false)
{
page.settings()->enablePersistentStorage();
ticker.setInterval(TIMER_TICK);
@ -62,17 +63,17 @@ void Runner::handleError(const QString &message, int lineNumber, const QString &
void Runner::loadSpec()
{
if (reportFileName.isEmpty()) {
outputFile = 0;
ts = 0;
} else {
outputFile = new QFile(reportFileName);
outputFile->open(QIODevice::WriteOnly);
QVectorIterator<QString> iterator(reportFiles);
ts = new QTextStream(outputFile);
while (iterator.hasNext()) {
QFile *outputFile = new QFile(iterator.next());
outputFile->open(QIODevice::WriteOnly);
outputFiles.enqueue(outputFile);
}
page.mainFrame()->load(runnerFiles.dequeue());
QString runnerFile = runnerFiles.dequeue();
page.mainFrame()->load(runnerFile);
ticker.start();
}
@ -104,8 +105,8 @@ void Runner::hasSpecFailure() {
_hasSpecFailure = true;
}
void Runner::reportFile(const QString &file) {
reportFileName = file;
void Runner::setReportFiles(QStack<QString> &files) {
reportFiles = files;
}
void Runner::timerPause() {
@ -116,6 +117,26 @@ void Runner::timerDone() {
ticker.start();
}
void Runner::ping() {
runs = 0;
}
void Runner::setSeed(QString s) {
seed = s;
}
void Runner::setQuiet(bool q) {
quiet = q;
}
QString Runner::getSeed() {
return seed;
}
bool Runner::isQuiet() {
return quiet;
}
void Runner::print(const QString &fh, const QString &content) {
if (fh == "stdout") {
std::cout << qPrintable(content);
@ -127,14 +148,18 @@ void Runner::print(const QString &fh, const QString &content) {
std::cerr.flush();
}
if (fh == "report" && outputFile) {
*ts << qPrintable(content);
ts->flush();
if (fh.contains("report")) {
int index = (int)fh.split(":").last().toUInt();
QTextStream ts(outputFiles.at(index));
ts << qPrintable(content);
ts.flush();
}
}
void Runner::finishSuite() {
isFinished = true;
runs = 0;
}
void Runner::timerEvent() {
@ -143,9 +168,9 @@ void Runner::timerEvent() {
if (hasErrors && runs > 2)
QApplication::instance()->exit(1);
if (isFinished) {
if (outputFile) {
outputFile->close();
if (isFinished && runs > 2) {
while (!outputFiles.isEmpty()) {
outputFiles.dequeue()->close();
}
int exitCode = 0;

View File

@ -7,7 +7,9 @@
#include <QTextStream>
#include <iostream>
#include <fstream>
#include <sstream>
#include <QQueue>
#include <QApplication>
#include "Page.h"
@ -20,7 +22,10 @@ class Runner: public QObject {
Runner();
void setColors(bool colors);
void reportFile(const QString &file);
void setReportFiles(QStack<QString> &files);
void setSeed(QString s);
void setQuiet(bool q);
void addFile(const QString &spec);
void go();
@ -30,8 +35,13 @@ class Runner: public QObject {
void hasUsedConsole();
void hasError();
void hasSpecFailure();
bool isQuiet();
QString getSeed();
void print(const QString &fh, const QString &content);
void finishSuite();
void ping();
private slots:
void watch(bool ok);
@ -48,15 +58,16 @@ class Runner: public QObject {
bool usedConsole;
bool isFinished;
bool useColors;
bool quiet;
QString seed;
QQueue<QString> runnerFiles;
QString reportFileName;
QStack<QString> reportFiles;
void loadSpec();
QFile *outputFile;
QTextStream *ts;
QQueue<QFile *> outputFiles;
};
#endif

View File

@ -1,7 +1,6 @@
TEMPLATE = app
CONFIG -= app_bundle
QMAKE_INFO_PLIST = Info.plist
QMAKESPEC = macx-g++
QT += network webkit
SOURCES = Page.cpp Runner.cpp

View File

@ -1,19 +0,0 @@
######################################################################
# Automatically generated by qmake (2.01a) Tue Aug 2 10:37:48 2011
######################################################################
TEMPLATE = app
TARGET =
DEPENDPATH += . HeadlessSpecRunner Test
INCLUDEPATH += . HeadlessSpecRunner Test
# Input
HEADERS += HeadlessSpecRunner/ConsoleOutput.h \
HeadlessSpecRunner/Page.h \
HeadlessSpecRunner/Runner.h \
Test/Page_test.h
SOURCES += specrunner.cpp \
HeadlessSpecRunner/ConsoleOutput.cpp \
HeadlessSpecRunner/Page.cpp \
HeadlessSpecRunner/Runner.cpp \
Test/Page_test.cpp

View File

@ -23,40 +23,54 @@
#include "Runner.h"
#if QT_VERSION >= QT_VERSION_CHECK(4, 8, 0)
#include <getopt.h>
#endif
#if QT_VERSION < QT_VERSION_CHECK(4, 7, 0)
#error Use Qt 4.7 or later version
#endif
int main(int argc, char** argv)
{
char *reporter = NULL;
char showColors = false;
bool showColors = false;
bool isQuiet = false;
QString seed;
QStack<QString> reporterFiles;
int c, index;
while ((c = getopt(argc, argv, "cr:")) != -1) {
while ((c = getopt(argc, argv, "cr:s:q")) != -1) {
switch(c) {
case 'c':
showColors = true;
break;
case 'q':
isQuiet = true;
break;
case 'r':
reporter = optarg;
reporterFiles.push(QString(optarg));
break;
case 's':
seed = QString(optarg);
break;
}
}
if (optind == argc) {
std::cerr << "Run Jasmine's SpecRunner headlessly" << std::endl << std::endl;
std::cerr << " specrunner [-c] [-r <report file>] specrunner.html ..." << std::endl;
std::cerr << " specrunner [-c] [-s seed] [-r report file ...] specrunner.html ..." << std::endl;
return 1;
}
QApplication app(argc, argv);
app.setApplicationName("jasmine-headless-webkit");
Runner runner;
runner.setColors(showColors);
runner.reportFile(reporter);
runner.setColors(showColors);
runner.setQuiet(isQuiet);
runner.setReportFiles(reporterFiles);
runner.setSeed(seed);
for (index = optind; index < argc; index++) {
runner.addFile(QString::fromLocal8Bit(argv[index]));

View File

@ -0,0 +1,7 @@
Feature: Bin - Failure
Scenario: Run a failing test
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/failure/failure.yml -f File:spec/report.txt`
Then the exit status should be 1
And the report file "spec/report.txt" should have 1 total, 1 failure, no console usage

View File

@ -0,0 +1,7 @@
Feature: Bin - Files
Scenario: List the files a test suite will use
Given I have a test suite
When I run `bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml -l`
Then the exit status should be 0
And the output should include "spec/jasmine/success/success.js"
And the output should include "spec/jasmine/success/success_spec.js"

View File

@ -0,0 +1,18 @@
Feature: Bin - Filtered Run - Both Runs
Background:
Given there is no existing "spec/report.txt" file
Scenario: Run one and fail
When I run `bin/jasmine-headless-webkit -j spec/jasmine/filtered_failure/filtered_failure.yml -f File:spec/report.txt ./spec/jasmine/filtered_failure/failure_spec.js`
Then the exit status should be 1
And the report file "spec/report.txt" should have 1 total, 1 failure, no console usage
Scenario: Run both and succeed
When I run `bin/jasmine-headless-webkit -j spec/jasmine/filtered_success/filtered_success.yml -f File:spec/report.txt ./spec/jasmine/filtered_success/success_one_spec.js`
Then the exit status should be 0
And the report file "spec/report.txt" should have 2 total, 0 failures, no console usage
Scenario: Run both with console.log
When I run `bin/jasmine-headless-webkit -j spec/jasmine/filtered_success_with_console/filtered_success.yml -f File:spec/report.txt ./spec/jasmine/filtered_success_with_console/success_one_spec.js`
Then the exit status should be 2
And the report file "spec/report.txt" should have 2 total, 0 failures, yes console usage

View File

@ -0,0 +1,14 @@
Feature: Bin - No Full Run
Background:
Given there is no existing "spec/report.txt" file
Scenario: Only run the filtered run
When I run `bin/jasmine-headless-webkit -j spec/jasmine/filtered_success/filtered_success.yml -f File:spec/report.txt --no-full-run ./spec/jasmine/filtered_success/success_one_spec.js`
Then the exit status should be 0
And the report file "spec/report.txt" should have 1 total, 0 failure, no console usage
Scenario: Use a file outside of the normal test run
When I run `bin/jasmine-headless-webkit -j spec/jasmine/filtered_success/filtered_success.yml -f File:spec/report.txt ./spec/jasmine/filtered_success/success_other_file.js`
Then the exit status should be 0
And the report file "spec/report.txt" should have 1 total, 0 failure, no console usage

View File

@ -0,0 +1,7 @@
Feature: Bin - Help
Scenario: Display the Help
Given I have a test suite
When I run `bin/jasmine-headless-webkit -h`
Then I should get help output
And the exit status should be 0

View File

@ -0,0 +1,8 @@
Feature: Bin - Quiet Messages
Scenario: Run a test that would cause a lot of messages to be displayed and silence them all
Given I have a test suite
When I run `bin/jasmine-headless-webkit -q -j spec/jasmine/noisy/noisy.yml`
Then the exit status should be 0
And the output should not include "[Skipping File]"
And the output should not include "You should mock"

View File

@ -0,0 +1,8 @@
Feature: Bin - Runner Out
Scenario: Write out the runner to a specified file
Given I have a test suite
When I run `bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml --runner-out spec/runner.html`
Then the exit status should be 0
And the file "spec/runner.html" should contain a JHW runner
When I delete the file "spec/runner.html"

View File

@ -0,0 +1,7 @@
Feature: Bin - Two spec files with same basename
Scenario: Run both files
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/two_spec_files_same_basename/jasmine.yml -f File:spec/report.txt`
Then the exit status should be 0
And the report file "spec/report.txt" should have 2 total, 0 failures, no console usage

View File

@ -0,0 +1,20 @@
Feature: Bin - Success
Scenario: Run a successful test with long format definition
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit --seed 1234 -j spec/jasmine/success/success.yml --format File --out spec/report.txt`
Then the exit status should be 0
And the report file "spec/report.txt" should have 1 total, 0 failures, no console usage
And the report file "spec/report.txt" should have seed 1234
Scenario: Run a successful test with legacy file reporting
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml --report spec/report.txt`
Then the exit status should be 0
And the report file "spec/report.txt" should have 1 total, 0 failures, no console usage
Scenario: Run a successful test with shortened format definition
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml -f File:spec/report.txt`
Then the exit status should be 0
And the report file "spec/report.txt" should have 1 total, 0 failures, no console usage

View File

@ -0,0 +1,5 @@
Feature: Bin - Success with JS Error
Scenario: Succeed
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/success_with_error/success_with_error.yml -f File:spec/report.txt`
Then the exit status should be 1

View File

@ -0,0 +1,7 @@
Feature: Bin - Try to Leave Page
Scenario: Fail on trying to leave the page
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/leave_page/leave_page.yml -f File:spec/report.txt`
Then the exit status should be 1
And the report file "spec/report.txt" should exist

View File

@ -0,0 +1,7 @@
Feature: Bin - Try to Click A Button
Scenario: Don't leave page when clicking a button
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/click_button/click_button.yml -f File:spec/report.txt`
Then the exit status should be 0
And the report file "spec/report.txt" should have 0 total, 0 failures, no console usage

View File

@ -0,0 +1,11 @@
Feature: Two files from source files
Scenario: Files are ordered directly
Given I have a test suite
When I run `bin/jasmine-headless-webkit -j spec/jasmine/two_files_from_src_files/jasmine.yml -l`
Then the exit status should be 0
And the following files should be loaded in order:
| vendor/vendor-file.js |
| vendor/vendor.js |
| app/app-file.js |
| app/app.js |

View File

@ -0,0 +1,7 @@
Feature: Bin - With CoffeeScript error
Scenario: Fail on CoffeeScript error
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/coffeescript_error/coffeescript_error.yml -f File:spec/report.txt`
Then the exit status should be 1
And the report file "spec/report.txt" should not exist

View File

@ -0,0 +1,7 @@
Feature: Use console.log
Scenario: Run a successful test that uses console.log
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit -j spec/jasmine/console_log/console_log.yml -f File:spec/report.txt`
Then the exit status should be 2
And the report file "spec/report.txt" should have 1 total, 0 failures, yes console usage

View File

@ -0,0 +1,7 @@
Feature: Bin - With Server
Scenario: Run using an HTTP server
Given there is no existing "spec/report.txt" file
When I run `bin/jasmine-headless-webkit --use-server -j spec/jasmine/success/success.yml -f File:spec/report.txt`
Then the exit status should be 0
And the report file "spec/report.txt" should have 1 total, 0 failures, no console usage

View File

@ -0,0 +1,7 @@
Feature: Bin - With window.prompt()
Scenario: Alert the user that window.prompt() needs to be stubbed
Given I have a test suite
When I run `bin/jasmine-headless-webkit -j spec/jasmine/window_prompt/window_prompt.yml`
Then the exit status should be 0
And the output should include "You should mock window.prompt"

View File

@ -0,0 +1,24 @@
Feature: Reporters
In order to allow for multiple types of output
I should be able to
Manage reporters and decide which ones to use
Scenario: Use default reporters
Given I have the default runner options
When I get a runner
And I get a template writer
Then the template should use the "Console" reporter to "stdout"
And the command to run the runner should not include a report file
Scenario: Use a file reporter
Given I have the default runner options
And I have the following reporters:
| Name | File |
| Console | |
| File | file |
When I get a runner
And I get a template writer
Then the template should use the "Console" reporter to "stdout"
And the template should use the "File" reporter to "report:0"
And the command to run the runner should include the report file "file"

34
features/runner.feature Normal file
View File

@ -0,0 +1,34 @@
Feature: Using the Runner directly
Scenario: Succeed
Given I have the following runner options:
"""
:jasmine_config: spec/jasmine/success/success.yml
:reporters:
- [ 'File', 'spec/report.txt' ]
"""
When I get a runner
And I run the runner
Then the runner should have an exit status of 0
And the report file "spec/report.txt" should have 1 total, 0 failures, no console usage
Scenario: JavaScript Error
Given I have the following runner options:
"""
:jasmine_config: spec/jasmine/success_with_error/success_with_error.yml
"""
When I get a runner
And I run the runner
Then the runner should have an exit status of 1
Scenario: Failure
Given I have the following runner options:
"""
:jasmine_config: spec/jasmine/failure/failure.yml
:reporters:
- [ 'File', 'spec/report.txt' ]
"""
When I get a runner
And I run the runner
Then the runner should have an exit status of 1
And the report file "spec/report.txt" should have 1 total, 1 failure, no console usage

View File

@ -0,0 +1,2 @@
Given /^I have a test suite$/ do
end

View File

@ -0,0 +1,4 @@
Given /^there is no existing "([^"]*)" file$/ do |file|
FileUtils.rm_rf file
end

View File

@ -0,0 +1,4 @@
Given /^I have the default runner options$/ do
@options = Jasmine::Headless::Options.new
end

View File

@ -0,0 +1,10 @@
Given /^I have the following reporters:$/ do |table|
@options[:reporters] = []
table.hashes.each do |hash|
reporter = [ hash['Name'] ]
reporter << hash['File'] if !hash['File'].empty?
@options[:reporters] << reporter
end
end

View File

@ -0,0 +1,3 @@
Given /^I have the following runner options:$/ do |string|
@options = YAML.load(string)
end

View File

@ -0,0 +1,3 @@
Then /^the exit status should be (\d+)$/ do |exitstatus|
$?.exitstatus.should == exitstatus.to_i
end

View File

@ -0,0 +1,4 @@
Then /^the file "([^"]*)" should contain a JHW runner$/ do |file|
File.read(file).should include('jasmine.HeadlessReporter')
end

View File

@ -0,0 +1,10 @@
Then /^the following files should be loaded in order:$/ do |table|
files = table.raw.flatten
@output.lines.collect(&:strip).each do |line|
files.shift if line[files.first]
end
files.should be_empty
end

View File

@ -0,0 +1,4 @@
Then /^I should get help output$/ do
@output.should include("Usage:")
end

View File

@ -0,0 +1,3 @@
Then /^the output should include "([^"]*)"$/ do |string|
@output.should include(string)
end

View File

@ -0,0 +1,4 @@
Then /^the output should not include "([^"]*)"$/ do |string|
@output.should_not include(string)
end

View File

@ -0,0 +1,4 @@
Then /^the report file "([^"]*)" should not exist$/ do |file|
File.file?(file).should be_false
end

View File

@ -0,0 +1,3 @@
Then /^the report file "([^"]*)" should exist$/ do |file|
File.file?(file).should be_true
end

View File

@ -0,0 +1,7 @@
Then /^the report file "(.*)" should have (\d+) total, (\d+) failures?, (no|yes) console usage$/ do |file, total, failures, console_usage|
report = Jasmine::Headless::Report.load(file)
report.total.should == total.to_i
report.failed.should == failures.to_i
report.has_used_console?.should == (console_usage == 'yes')
end

View File

@ -0,0 +1,4 @@
Then /^the report file "([^"]*)" should have seed (\d+)$/ do |file, seed|
report = Jasmine::Headless::Report.load(file)
report.seed.should == seed.to_i
end

View File

@ -0,0 +1,3 @@
Then /^the runner should have an exit status of (\d+)$/ do |exit_status|
@result.should == exit_status.to_i
end

View File

@ -0,0 +1,4 @@
Then /^the command to run the runner should include the report file "([^"]*)"$/ do |file|
@runner.jasmine_command.should include("-r #{file}")
end

View File

@ -0,0 +1,3 @@
Then /^the command to run the runner should not include a report file$/ do
@runner.jasmine_command.should_not include('-r')
end

View File

@ -0,0 +1,6 @@
Then /^the template should use the "([^"]*)" reporter to "([^"]*)"$/ do |reporter, target|
output = @template_writer.render
output.should include(%{jasmine.HeadlessReporter.#{reporter}("#{target}")})
end

View File

@ -0,0 +1,3 @@
When /^I delete the file "([^"]*)"$/ do |file|
FileUtils.rm_f(file)
end

View File

@ -0,0 +1,4 @@
When /^I get a runner$/ do
@runner = Jasmine::Headless::Runner.new(@options)
end

View File

@ -0,0 +1,4 @@
When /^I get a template writer$/ do
@template_writer = Jasmine::Headless::TemplateWriter.new(@runner)
end

View File

@ -0,0 +1,4 @@
When /^I run `(.*)`$/ do |command|
@output = `#{command}`
end

View File

@ -0,0 +1,4 @@
When /^I run the runner$/ do
@result = @runner.run
end

7
features/support/env.rb Normal file
View File

@ -0,0 +1,7 @@
require 'jasmine-headless-webkit'
After do
FileUtils.rm_f 'spec/report.txt'
FileUtils.rm_f 'spec/runner.html'
end

View File

@ -20,8 +20,11 @@ Gem::Specification.new do |s|
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ["lib"]
s.add_dependency 'jasmine-core', '~>1.1.beta'
s.add_dependency 'coffee-script', '>= 2.2'
s.add_dependency 'rainbow'
s.add_dependency 'multi_json'
s.add_runtime_dependency 'jasmine-core'
s.add_runtime_dependency 'coffee-script'
s.add_runtime_dependency 'rainbow'
s.add_runtime_dependency 'multi_json', '>= 1.2.0'
s.add_runtime_dependency 'sprockets'
s.add_runtime_dependency 'sprockets-vendor_gems'
end

View File

@ -1,7 +1,3 @@
module Jasmine
autoload :FilesList, 'jasmine/files_list'
end
require 'jasmine/headless'
require 'jasmine/headless/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3

View File

@ -1,176 +0,0 @@
require 'jasmine-core'
require 'time'
require 'multi_json'
module Jasmine
class FilesList
attr_reader :files, :spec_files, :filtered_files, :spec_outside_scope
class << self
def find_vendored_asset_paths(*names)
require 'rubygems'
raise StandardError.new("A newer version of Rubygems is required to use vendored assets. Please upgrade.") if !Gem::Specification.respond_to?(:map)
all_spec_files.find_all do |file|
names.any? { |name| file["/#{name}.js"] }
end
end
def all_spec_files
@all_spec_files ||= Gem::Specification.map { |spec| spec.files.find_all { |file|
file["vendor/assets/javascripts"]
}.compact.collect { |file| File.join(spec.gem_dir, file) } }.flatten
end
end
DEFAULT_FILES = [
File.join(Jasmine::Core.path, "jasmine.js"),
File.join(Jasmine::Core.path, "jasmine-html.js"),
File.join(Jasmine::Core.path, "jasmine.css")
] + %w{jasmine-extensions intense headless_reporter_result jasmine.HeadlessConsoleReporter jsDump beautify-html}.collect { |name|
Jasmine::Headless.root.join("vendor/assets/javascripts/#{name}.js").to_s
}
PLEASE_WAIT_IM_WORKING_TIME = 2
def initialize(options = {})
@options = options
@files = DEFAULT_FILES.dup
@filtered_files = @files.dup
@spec_outside_scope = false
@spec_files = []
use_config! if config?
end
def has_spec_outside_scope?
@spec_outside_scope
end
def filtered?
files != filtered_files
end
def files_to_html
to_html(files)
end
def filtered_files_to_html
to_html(filtered_files)
end
def spec_file_line_numbers
@spec_file_line_numbers ||= Hash[@spec_files.collect { |file|
if File.exist?(file)
if !(lines = Jasmine::Headless::SpecFileAnalyzer.for(file)).empty?
[ file, lines ]
end
else
nil
end
}.compact]
end
private
def to_html(files)
alert_time = Time.now + PLEASE_WAIT_IM_WORKING_TIME
files.collect { |file|
if alert_time && alert_time < Time.now
puts "Rebuilding cache, please wait..."
alert_time = nil
end
source = nil
result = case File.extname(file)
when '.coffee'
begin
cache = Jasmine::Headless::CoffeeScriptCache.new(file)
source = cache.handle
if cache.cached?
%{<script type="text/javascript" src="#{cache.cache_file}"></script>
<script type="text/javascript">
window.CSTF['#{File.split(cache.cache_file).last}'] = '#{file}';
</script>}
else
%{<script type="text/javascript">#{source}</script>}
end
rescue CoffeeScript::CompilationError => ne
puts "[%s] %s: %s" % [ 'coffeescript'.color(:red), file.color(:yellow), ne.message.to_s.color(:white) ]
raise ne
rescue StandardError => e
puts "[%s] Error in compiling one of the followng: %s" % [ 'coffeescript'.color(:red), files.join(' ').color(:yellow) ]
raise e
end
when '.js'
%{<script type="text/javascript" src="#{file}"></script>}
when '.css'
%{<link rel="stylesheet" href="#{file}" type="text/css" />}
end
result
}.flatten.compact.reject(&:empty?)
end
def spec_filter
return @spec_filter if @spec_filter
@spec_filter = begin
if @options[:only]
@options[:only].collect { |path| expanded_dir(path) }.flatten
else
[]
end
end
end
def use_config!
@filtered_files = @files.dup
data = @options[:config].dup
[ [ 'src_files', 'src_dir' ], [ 'stylesheets', 'src_dir' ], [ 'vendored_helpers' ], [ 'helpers', 'spec_dir' ], [ 'spec_files', 'spec_dir' ] ].each do |searches, root|
if data[searches]
case searches
when 'vendored_helpers'
data[searches].each do |name|
found_files = self.class.find_vendored_asset_path(name)
@files += found_files
@filtered_files += found_files
end
else
data[searches].flatten.collect do |search|
path = search
path = File.join(data[root], path) if data[root]
found_files = expanded_dir(path) - @files
@files += found_files
if searches == 'spec_files'
@spec_files += spec_filter.empty? ? found_files : (found_files & spec_filter)
end
@filtered_files += begin
if searches == 'spec_files'
@spec_outside_scope = ((spec_filter | found_files).sort != found_files.sort)
spec_filter.empty? ? found_files : (spec_filter || found_files)
else
found_files
end
end
end
end
end
end
end
def config?
@options[:config]
end
def expanded_dir(path)
Dir[path].collect { |file| File.expand_path(file) }
end
end
end

View File

@ -1,6 +1,12 @@
require 'pathname'
module Jasmine::Headless
module Jasmine
module Headless
EXCLUDED_FORMATS = %w{less sass scss erb str}
autoload :CommandLine, 'jasmine/headless/command_line'
autoload :CoffeeScriptCache, 'jasmine/headless/coffee_script_cache'
autoload :SpecFileAnalyzer, 'jasmine/headless/spec_file_analyzer'
autoload :CacheableAction, 'jasmine/headless/cacheable_action'
@ -9,8 +15,19 @@ module Jasmine::Headless
autoload :Options, 'jasmine/headless/options'
autoload :Task, 'jasmine/headless/task'
autoload :FilesList, 'jasmine/headless/files_list'
autoload :UniqueAssetList, 'jasmine/headless/unique_asset_list'
autoload :TemplateWriter, 'jasmine/headless/template_writer'
autoload :FileChecker, 'jasmine/headless/file_checker'
autoload :CoffeeTemplate, 'jasmine/headless/coffee_template'
autoload :JSTemplate, 'jasmine/headless/js_template'
autoload :JSTTemplate, 'jasmine/headless/jst_template'
autoload :CSSTemplate, 'jasmine/headless/css_template'
autoload :NilTemplate, 'jasmine/headless/nil_template'
autoload :Report, 'jasmine/headless/report'
autoload :ReportMessage, 'jasmine/headless/report_message'
@ -18,7 +35,27 @@ module Jasmine::Headless
def root
@root ||= Pathname(File.expand_path('../../..', __FILE__))
end
def warn(message)
output.puts message if show_warnings?
end
def show_warnings=(show)
@show_warnings = show
end
def show_warnings?
@show_warnings = true if @show_warnings.nil?
@show_warnings
end
def output
$stdout
end
end
end
end
require 'jasmine/headless/errors'

View File

@ -1,5 +1,3 @@
require 'digest/sha1'
module Jasmine::Headless
class CacheableAction
class << self
@ -56,7 +54,11 @@ module Jasmine::Headless
end
def cache_file
@cache_file ||= File.join(self.class.cache_dir, self.class.cache_type, Digest::SHA1.hexdigest(file)) + '.js'
@cache_file ||= File.expand_path(relative_cache_file) + '.js'
end
def relative_cache_file
File.join(self.class.cache_dir, self.class.cache_type, file.gsub(Dir.pwd + '/', ''))
end
def fresh?

View File

@ -0,0 +1,36 @@
require 'tilt/template'
require 'rainbow'
module Jasmine::Headless
class CoffeeTemplate < Tilt::Template
include Jasmine::Headless::FileChecker
self.default_mime_type = 'application/javascript'
def prepare ; end
def evaluate(scope, locals, &block)
if bad_format?(file)
alert_bad_format(file)
return ''
end
begin
cache = Jasmine::Headless::CoffeeScriptCache.new(file)
source = cache.handle
if cache.cached?
%{<script type="text/javascript" src="#{cache.cache_file}"></script>
<script type="text/javascript">window.CSTF['#{File.split(cache.cache_file).last}'] = '#{file}';</script>}
else
%{<script type="text/javascript">#{source}</script>}
end
rescue CoffeeScript::CompilationError => ne
puts "[%s] %s: %s" % [ 'coffeescript'.color(:red), file.color(:yellow), "#{ne.message}".color(:white) ]
raise ne
rescue StandardError => e
puts "[%s] Error in compiling file: %s" % [ 'coffeescript'.color(:red), file.color(:yellow) ]
raise e
end
end
end
end

View File

@ -0,0 +1,31 @@
module Jasmine::Headless
class CommandLine
class << self
def run!
require 'coffee-script'
require 'rainbow'
begin
options = Options.from_command_line
runner = Runner.new(options)
if options[:do_list]
FilesList.reset!
files_list = FilesList.new(:config => runner.jasmine_config)
files_list.files.each { |file| puts file }
else
exit runner.run
end
rescue CoffeeScript::CompilationError
exit 1
rescue StandardError => e
$stderr.puts "[%s] %s (%s)" % [ "jasmine-headless-webkit".color(:red), e.message.color(:white), e.class.name.color(:yellow) ]
$stderr.puts e.backtrace.collect { |line| " #{line}" }.join("\n")
exit 1
end
end
end
end
end

View File

@ -0,0 +1,19 @@
require 'tilt/template'
module Jasmine::Headless
class CSSTemplate < Tilt::Template
include Jasmine::Headless::FileChecker
self.default_mime_type = 'text/css'
def prepare ; end
def evaluate(scope, locals, &block)
if bad_format?(file)
alert_bad_format(file)
return ''
end
file ? %{<link rel="stylesheet" href="#{file}" type="text/css" />} : data
end
end
end

View File

@ -0,0 +1,25 @@
module Jasmine::Headless::FileChecker
def excluded_formats
::Jasmine::Headless::EXCLUDED_FORMATS
end
def bad_format?(file)
return if file.nil?
excluded_formats.any? do |format|
file[%r{\.#{format}(\.|$)}]
end
end
def alert_bad_format(file)
Jasmine::Headless.warn("[%s] %s: %s" % [ 'Skipping File'.color(:red), file.color(:yellow), "unsupported format".color(:white) ])
end
def alert_if_bad_format?(file)
if result = bad_format?(file)
alert_bad_format(file)
end
result
end
end

View File

@ -0,0 +1,332 @@
require 'jasmine-core'
require 'time'
require 'multi_json'
require 'set'
require 'sprockets'
require 'sprockets/engines'
require 'sprockets-vendor_gems'
module Jasmine::Headless
class FilesList
include FileChecker
class << self
def asset_paths
@asset_paths ||= Sprockets.find_gem_vendor_paths(:for => 'javascripts')
end
def reset!
@asset_paths = nil
@registered_engines = {}
# register haml-sprockets and handlebars_assets if it's available...
%w{haml-sprockets handlebars_assets}.each do |library|
begin
require library
rescue LoadError
end
end
if ENV['JHW_ENV']
begin
require 'bundler'
Bundler.require(ENV['JHW_ENV'].to_sym)
rescue LoadError
end
end
@sprockets_environment = nil
end
def registered_engines
@registered_engines ||= {}
end
def register_engine(file_extension, template_class)
registered_engines[file_extension] = template_class
end
def register_engines!
registered_engines.each do |file_extension, template_class|
Sprockets.register_engine file_extension, template_class
end
end
def default_files
%w{jasmine.js jasmine-html jasmine.css jasmine-extensions
intense headless_reporter_result jasmine.HeadlessReporter
jasmine.HeadlessReporter.ConsoleBase
jsDump beautify-html}
end
def extension_filter
extensions = (%w{.js .css} + Sprockets.engine_extensions)
%r{(#{extensions.join('|')})$}
end
end
PLEASE_WAIT_IM_WORKING_TIME = 2
attr_reader :options, :required_files, :potential_files_to_filter
def initialize(options = {})
@options = options
Kernel.srand(options[:seed]) if options[:seed]
@required_files = UniqueAssetList.new
@potential_files_to_filter = []
register_engines!
load_initial_assets
use_config if config?
end
def register_engines!
begin
require spec_helper
rescue LoadError
end
self.class.register_engines!
end
def load_initial_assets
self.class.default_files.each do |file|
begin
add_path(file)
rescue InvalidUniqueAsset => e
raise StandardError.new("Not an asset: #{file}")
end
end
(options[:reporters] || []).each do |reporter, identifier, file|
add_path("jasmine.HeadlessReporter.#{reporter}")
end
end
def files
required_files.flatten.collect { |asset| asset.pathname.to_s }.uniq
end
def spec_files
filter_for_requested_specs(
files.find_all { |file| spec_dir.any? { |dir| file[dir] } }
)
end
def filtered_files
filter_for_requested_specs(files)
end
def search_paths
return @search_paths if @search_paths
@search_paths = [ Jasmine::Core.path, Jasmine::Headless.root.join('vendor/assets/javascripts').to_s ]
@search_paths += self.class.asset_paths
@search_paths += src_dir.collect { |dir| File.expand_path(dir) }
@search_paths += asset_paths.collect { |dir| File.expand_path(dir) }
@search_paths += spec_dir.collect { |dir| File.expand_path(dir) }
@search_paths.uniq!
@search_paths
end
def sprockets_environment
return @sprockets_environment if @sprockets_environment
@sprockets_environment = Sprockets::Environment.new
search_paths.each { |path| @sprockets_environment.append_path(path) }
@sprockets_environment.unregister_postprocessor('application/javascript', Sprockets::SafetyColons)
# ...and unregister ones we don't want/need
@sprockets_environment.instance_eval do
EXCLUDED_FORMATS.each do |extension|
register_engine ".#{extension}", Jasmine::Headless::NilTemplate
end
register_engine '.coffee', Jasmine::Headless::CoffeeTemplate
register_engine '.js', Jasmine::Headless::JSTemplate
register_engine '.css', Jasmine::Headless::CSSTemplate
register_engine '.jst', Jasmine::Headless::JSTTemplate
end
@sprockets_environment
end
def has_spec_outside_scope?
if is_outside_scope = !spec_filter.empty?
is_outside_scope = spec_dir.any? do |dir|
spec_file_searches.any? do |search|
!spec_files.any? do |file|
target = File.join(dir, search)
File.fnmatch?(target, file) || File.fnmatch?(target.gsub(%{^**/}, ''), file)
end
end
end
end
is_outside_scope
end
def filtered?
files != filtered_files
end
def files_to_html
to_html(files)
end
def filtered_files_to_html
to_html(filtered_files)
end
def spec_file_line_numbers
@spec_file_line_numbers ||= Hash[spec_files.collect { |file|
if File.exist?(file)
if !(lines = Jasmine::Headless::SpecFileAnalyzer.for(file)).empty?
[ file, lines ]
end
else
nil
end
}.compact]
end
private
def to_html(files)
alert_time = Time.now + PLEASE_WAIT_IM_WORKING_TIME
files.collect do |file|
if alert_time && alert_time < Time.now
puts "Rebuilding cache, please wait..."
alert_time = nil
end
sprockets_environment.find_asset(file, :bundle => false).body
end.compact.reject(&:empty?)
end
def spec_filter
@spec_filter ||= (@options[:only] && @options[:only].collect { |path| expanded_dir(path) }.flatten) || []
end
SEARCH_ROOTS = {
'src_files' => 'src_dir',
'stylesheets' => 'src_dir',
'helpers' => 'spec_dir',
'spec_files' => 'spec_dir'
}
def use_config
@config = @options[:config].dup
@searches = {}
@potential_files_to_filter = []
%w{src_files stylesheets helpers spec_files}.each do |type|
if data = @config[type]
add_files(@searches[type] = data.flatten, type, send(SEARCH_ROOTS[type]))
end
end
end
def add_files(patterns, type, dirs)
patterns.each do |pattern|
dirs.collect { |dir| expanded_dir(File.join(dir, pattern)) }.each do |files|
files.sort! { |a, b| Kernel.rand(3) - 1 } if type == 'spec_files'
files.each do |path|
add_path(path, type)
end
end
end
if type == 'spec_files'
spec_filter.each { |path| add_path(path, type) }
end
end
def config?
@options[:config]
end
def expanded_dir(path)
file_list = Dir.glob(path).sort
file_list.find_all { |file|
file[extension_filter] && !alert_if_bad_format?(file)
}.collect {
|file| File.expand_path(file)
}.find_all {
|path| File.file?(path)
}
end
def extension_filter
self.class.extension_filter
end
def add_path(path, type = nil)
asset = sprockets_environment.find_asset(path)
@required_files << asset
if type == 'spec_files'
@potential_files_to_filter << path
end
end
def src_dir
@src_dir ||= config_dir_or_pwd('src_dir') + asset_paths
end
def spec_dir
@spec_dir ||= config_dir_or_pwd('spec_dir')
end
def asset_paths
@asset_paths ||= config_dir('asset_paths')
end
def spec_file_searches
@searches['spec_files']
end
def config_dir_or_pwd(dir)
if (found = config_dir(dir)).empty?
found = [ Dir.pwd ]
end
found
end
def config_dir(dir)
[ @options[:config] && @options[:config][dir] ].flatten.compact.collect { |dir| File.expand_path(dir) }
end
def filter_for_requested_specs(files)
files.find_all do |file|
if potential_files_to_filter.include?(file)
spec_filter.empty? || spec_filter.any? { |pattern| File.fnmatch?(pattern, file) }
else
true
end
end
end
def spec_helper
File.join(spec_dir, "helpers", "spec_helper")
end
end
end
module Jasmine::Headless
extend self
def register_engine(file_extension, template_class)
Jasmine::Headless::FilesList.register_engine(file_extension, template_class)
end
end

View File

@ -0,0 +1,23 @@
require 'tilt/template'
module Jasmine::Headless
class JSTemplate < Tilt::Template
include Jasmine::Headless::FileChecker
self.default_mime_type = 'application/javascript'
def prepare ; end
def evaluate(scope, locals, &block)
if bad_format?(file)
alert_bad_format(file)
return ''
end
if data[%r{^<script type="text/javascript"}]
data
else
file ? %{<script type="text/javascript" src="#{file}"></script>} : data
end
end
end
end

View File

@ -0,0 +1,15 @@
require 'sprockets/jst_processor'
module Jasmine::Headless
class JSTTemplate < Sprockets::JstProcessor
include Jasmine::Headless::FileChecker
def evaluate(*args)
if bad_format?(file)
alert_bad_format(file)
return ''
end
%{<script type="text/javascript">#{super}</script>}
end
end
end

View File

@ -0,0 +1,14 @@
require 'tilt/template'
require 'rainbow'
module Jasmine::Headless
class NilTemplate < Tilt::Template
def prepare ; end
def evaluate(scope, locals, &block)
return ''
end
end
end

View File

@ -13,16 +13,21 @@ module Jasmine
:remove_html_file => true,
:runner_output_filename => false,
:jasmine_config => 'spec/javascripts/support/jasmine.yml',
:report => false,
:do_list => false,
:full_run => true,
:enable_cache => true,
:files => []
:files => [],
:reporters => [ [ 'Console' ] ],
:quiet => false,
:use_server => false,
:server_port => nil
}
DEFAULTS_FILE = File.join(Dir.pwd, '.jasmine-headless-webkit')
GLOBAL_DEFAULTS_FILE = File.expand_path('~/.jasmine-headless-webkit')
REPORT_DEPRECATED_MESSAGE = "--report is deprecated. Use --format HeadlessFileReporter --out <filename>"
def self.from_command_line
options = new
options.process_command_line_args
@ -32,7 +37,10 @@ module Jasmine
def initialize(opts = {})
@options = DEFAULT_OPTIONS.dup
srand
@options[:seed] = rand(10000)
read_defaults_files
opts.each { |k, v| @options[k] = v if v }
end
@ -51,7 +59,10 @@ module Jasmine
when '--keep'
@options[:remove_html_file] = false
when '--report'
@options[:report] = arg
warn REPORT_DEPRECATED_MESSAGE
add_reporter('File', arg)
add_reporter('Console')
when '--runner-out'
@options[:runner_output_filename] = arg
when '--jasmine-config', '-j'
@ -60,6 +71,22 @@ module Jasmine
@options[:full_run] = false
when '--list', '-l'
@options[:do_list] = true
when '--quiet', '-q'
@options[:quiet] = true
when '--seed'
@options[:seed] = arg.to_i
when '--format', '-f'
add_reporter(arg)
when '--use-server'
@options[:use_server] = true
when '--server-port'
@options[:server_port] = arg.to_i
when '--out'
add_reporter_file(arg)
when '-h', '--help'
print_help
exit
end
end
@ -76,17 +103,103 @@ module Jasmine
[ '--colors', '-c', GetoptLong::NO_ARGUMENT ],
[ '--no-colors', GetoptLong::NO_ARGUMENT ],
[ '--cache', GetoptLong::NO_ARGUMENT ],
[ '--no-t stcache', GetoptLong::NO_ARGUMENT ],
[ '--no-cache', GetoptLong::NO_ARGUMENT ],
[ '--keep', GetoptLong::NO_ARGUMENT ],
[ '--runner-out', GetoptLong::REQUIRED_ARGUMENT ],
[ '--report', GetoptLong::REQUIRED_ARGUMENT ],
[ '--jasmine-config', '-j', GetoptLong::REQUIRED_ARGUMENT ],
[ '--no-full-run', GetoptLong::NO_ARGUMENT ],
[ '--list', '-l', GetoptLong::NO_ARGUMENT ]
[ '--list', '-l', GetoptLong::NO_ARGUMENT ],
[ '--seed', GetoptLong::REQUIRED_ARGUMENT ],
[ '--format', '-f', GetoptLong::REQUIRED_ARGUMENT ],
[ '--out', GetoptLong::REQUIRED_ARGUMENT ],
[ '--use-server', GetoptLong::NO_ARGUMENT ],
[ '--server-port', GetoptLong::REQUIRED_ARGUMENT ],
[ '-h', '--help', GetoptLong::NO_ARGUMENT ],
[ '-q', '--quiet', GetoptLong::NO_ARGUMENT ]
)
command_line_args.each { |*args| process_option(*args) }
end
def reporters
file_index = 0
@options[:reporters].collect do |reporter, file|
output = [ reporter ]
if file
output << "report:#{file_index}"
output << file
file_index += 1
else
output << "stdout"
end
output
end
end
def file_reporters
reporters.find_all { |reporter| reporter[1]["report:"] }
end
private
def add_reporter(name, file = nil)
if !@added_reporter
@options[:reporters] = []
@added_reporter = true
end
if (parts = name.split(':')).length == 2
name, file = parts
end
@options[:reporters] << [ name ]
add_reporter_file(file) if file
end
def add_reporter_file(file)
@options[:reporters].last << file
end
def print_help
options = [
[ '-c, --colors', 'Enable colors (default: disabled)' ],
[ '-nc, --no-colors', 'Disable colors' ],
[ '--cache', 'Enable cache (default: enabled)' ],
[ '--no-cache', 'Disable cache' ],
[ '--keep', 'Keep runner files on failure' ],
[ '--runner-out <filename>', 'Write runner to specified filename' ],
[ '-j, --jasmine-config <config file>', 'Jasmine Yaml config to use' ],
[ '--no-full-run', 'Do not perform a full spec run after a successful targeted spec run' ],
[ '--use-server', 'Load tests from an HTTP server instead of from filesystem' ],
[ '-l, --list', 'List files in the order they will be required' ],
[ '--seed <seed>', 'Random order seed for spec file ordering' ],
[ '-f, --format <reporter<:filename>>', 'Specify an output reporter and possibly output filename' ],
[ '--out <filename>', 'Specify output filename for last defined reporter' ],
[ '-q, --quiet', "Silence most non-test related warnings" ],
[ '-h, --help', "You're looking at it" ]
]
longest_length = options.collect(&:first).collect(&:length).max
puts <<-HELP
Usage: #{$0} [ options ] [ spec files ]
Options:
#{options.collect { |option, description| " #{option.ljust(longest_length)} #{description}" }.join("\n")}
Available reporters:
Console Write out spec results to the console in a progress format (default)
Verbose Write out spec results to the console in a verbose format
File Write spec results in jasmine-headless-webkit ReportFile format
Tap Write spec results in TAP format
Add reporters to the jasmine.HeadlessReporter object to access them
(ex: jasmine.HeadlessReporter.Teamcity for the Teamcity reporter)
HELP
end
end
end
end

View File

@ -60,8 +60,13 @@ module Jasmine::Headless
}.collect(&:filename).uniq.compact
end
private
def seed
if seed = report.find { |entry| entry.respond_to?(:seed) }
seed.seed
end
end
private
def last_total
@report.reverse.find { |entry| entry.respond_to?(:total) }
end

View File

@ -6,6 +6,7 @@ module Jasmine::Headless
autoload :Console, 'jasmine/headless/report_message/console'
autoload :Error, 'jasmine/headless/report_message/error'
autoload :Total, 'jasmine/headless/report_message/total'
autoload :Seed, 'jasmine/headless/report_message/seed'
end
end

View File

@ -1,10 +1,8 @@
module Jasmine::Headless::ReportMessage
class Console
class << self
def new_from_parts(parts)
def self.new_from_parts(parts)
new(parts.first)
end
end
attr_reader :message

View File

@ -0,0 +1,14 @@
module Jasmine::Headless::ReportMessage
class Seed
def self.new_from_parts(parts)
new(parts.first)
end
attr_reader :seed
def initialize(seed)
@seed = seed.to_i
end
end
end

View File

@ -1,12 +1,10 @@
module Jasmine::Headless::ReportMessage
class Spec
class << self
def new_from_parts(parts)
def self.new_from_parts(parts)
file_info = parts.pop
new(parts.join(' '), file_info)
end
end
attr_reader :statement, :file_info

View File

@ -4,9 +4,29 @@ require 'coffee-script'
require 'rainbow'
require 'yaml'
require 'erb'
require 'sprockets'
module Jasmine
module Headless
class IndexHandler
class << self
attr_accessor :index
end
def initialize(app)
@app = app
end
def call(env)
if env['PATH_INFO'] == '/'
return [ 302, { 'Location' => self.class.index }, [ 'Redirecting...' ] ]
end
@app.call(env)
end
end
class Runner
JASMINE_DEFAULTS = {
'spec_files' => [ '**/*[sS]pec.js' ],
@ -24,18 +44,107 @@ module Jasmine
attr_reader :options
def self.run(options = {})
options = Options.new(options) if !options.kind_of?(Options)
new(options).run
end
def self.server_port
return @server_port if @server_port
require 'socket'
count = 100
begin
port = select_server_port
socket = TCPSocket.new(server_interface, port)
socket.close
count -= 1
raise "Could not create server port after 100 attempts!" if count == 0
rescue Errno::ECONNREFUSED
@server_port = port
break
ensure
begin
socket.close if socket
rescue IOError
end
end while true
@server_port
end
def self.server_port=(port)
@server_port = port
end
def self.select_server_port
21000 + rand(10000)
end
def self.server_interface
'127.0.0.1'
end
def self.server_uri
"http://#{server_interface}:#{server_port}"
end
def self.server_spec_path
self.server_uri + '/__JHW__/'
end
def self.ensure_server(options)
return if @server
require 'webrick'
require 'thread'
require 'rack'
require 'net/http'
port = server_port
@server = Thread.new do
Jasmine::Headless.warn "Powering up!"
app = Rack::Builder.new do
use IndexHandler
map '/__JHW__' do
run Rack::File.new(Dir.pwd)
end
map '/' do
run Rack::File.new('/')
end
end
Rack::Handler::WEBrick.run(
app,
:Port => port,
:Logger => Logger.new(StringIO.new),
:AccessLog => [
[ StringIO.new, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
[ StringIO.new, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
]
)
end
while true do
begin
Net::HTTP.get(URI(server_uri))
break
rescue Errno::ECONNREFUSED => e
end
sleep 0.1
end
end
def initialize(options)
if !File.file?(RUNNER)
$stderr.puts "No runner found, attempting to compile..."
Dir.chdir RUNNER_DIR do
system %{ruby extconf.rb}
end
raise NoRunnerError if !File.file?(RUNNER)
end
options = Options.new(options) if !options.kind_of?(Options)
@options = options
end
@ -55,27 +164,45 @@ module Jasmine
end
def jasmine_command(*targets)
[
RUNNER,
@options[:colors] ? '-c' : nil,
@options[:report] ? "-r #{@options[:report]}" : nil,
*targets
].compact.join(" ")
command = [ RUNNER ]
command << "-s #{options[:seed]}"
command << '-c' if options[:colors]
command << '-q' if options[:quiet]
options.file_reporters.each do |reporter, identifier, file|
command << "-r #{file}"
end
command += targets
command.compact.join(' ')
end
def run
Jasmine::Headless::CacheableAction.enabled = @options[:enable_cache]
Jasmine::Headless.show_warnings = !@options[:quiet]
FilesList.reset!
files_list = Jasmine::FilesList.new(
:config => jasmine_config,
:only => @options[:files]
)
self.class.server_port = options[:server_port]
@_targets = template_writer.write!(files_list)
run_targets = @_targets.dup
run_targets.pop if (!@options[:full_run] && files_list.filtered?) || files_list.has_spec_outside_scope?
@_targets = template_writer.write
run_targets = absolute_run_targets(@_targets.dup)
if run_targets.length == 2
if (!@options[:full_run] && files_list.filtered?) || files_list.has_spec_outside_scope?
run_targets.pop
end
end
runner = lambda { system jasmine_command(run_targets) }
if options[:use_server]
wrap_in_server(run_targets, &runner)
else
runner.call
end
system jasmine_command(run_targets)
@_status = $?.exitstatus
ensure
if @_targets && !runner_filename && (@options[:remove_html_file] || (@_status == 0))
@ -83,6 +210,17 @@ module Jasmine
end
end
def absolute_run_targets(targets)
targets.flatten.collect do |target|
if options[:use_server]
target = self.class.server_spec_path + target
else
target = "file://" + File.expand_path(target)
end
target
end
end
def runner_filename
options[:runner_output_filename] || begin
if (runner_output = jasmine_config['runner_output']) && !runner_output.empty?
@ -93,11 +231,29 @@ module Jasmine
end
end
def files_list
@files_list ||= Jasmine::Headless::FilesList.new(
:config => jasmine_config,
:only => options[:files],
:seed => options[:seed],
:reporters => options.reporters
)
end
def wrap_in_server(run_targets)
self.class.ensure_server(options)
IndexHandler.index = run_targets.last
Jasmine::Headless.warn "HTTP powered specs! Located at #{run_targets.join(' ')}"
yield
end
private
def jasmine_config_data
raise JasmineConfigNotFound.new("Jasmine config not found. I tried #{@options[:jasmine_config]}.") if !File.file?(@options[:jasmine_config])
YAML.load_file(@options[:jasmine_config])
YAML.load(ERB.new(File.read(@options[:jasmine_config])).result(binding))
end
end
end

View File

@ -14,7 +14,7 @@ module Jasmine::Headless
data = File.read(file)
if data.respond_to?(:encode)
data.encode!('US-ASCII', 'UTF-8', :invalid => :replace)
data.encode!('US-ASCII', 'UTF-8', :invalid => :replace, :undef => :replace)
else
require 'iconv'
ic = Iconv.new('UTF-8//IGNORE', 'US-ASCII')
@ -33,11 +33,11 @@ module Jasmine::Headless
end
def serialize(data)
MultiJson.encode(data)
MultiJson.dump(data)
end
def unserialize(data)
MultiJson.decode(data)
MultiJson.load(data)
end
end
end

View File

@ -1,23 +1,3 @@
module Digest
class JasmineTest
def self.file(file)
new
end
def file(file)
self
end
def hexdigest
'test'
end
def update(prefix)
self
end
end
end
module Jasmine
module Headless
class Task
@ -34,22 +14,9 @@ module Jasmine
desc 'Run Jasmine specs headlessly'
task(name) { run_rake_task }
create_rails_compliant_task if defined?(Rails)
end
private
def create_rails_compliant_task
if Rails.respond_to?(:version) && Rails.version >= "3.1.0"
desc 'Force generate static assets without an MD5 hash, all assets end with -test.<ext>'
task 'assets:precompile:for_testing' => :environment do
Rails.application.assets.digest_class = Digest::JasmineTest
Rake::Task['assets:precompile'].invoke
end
end
end
def run_rake_task
case Jasmine::Headless::Runner.run(
:colors => colors,

View File

@ -1,24 +1,32 @@
require 'multi_json'
require 'erb'
require 'tempfile'
require 'forwardable'
module Jasmine::Headless
class TemplateWriter
attr_reader :runner
extend Forwardable
def_delegators :runner, :files_list, :options
def_delegators :options, :reporters
def initialize(runner)
@runner = runner
end
def write!(files_list)
def write
output = [
[ all_tests_filename, files_list.files_to_html ]
]
output.unshift([filtered_tests_filename , files_list.filtered_files_to_html ]) if files_list.filtered?
output.unshift([filtered_tests_filename, files_list.filtered_files_to_html ]) if files_list.filtered?
output.each do |name, files|
File.open(name, 'w') { |fh| fh.print template_for(files, files_list.spec_file_line_numbers) }
template = template_for(files)
File.open(name, 'wb') { |fh| fh.print template }
end
output.collect(&:first)
@ -32,8 +40,24 @@ module Jasmine::Headless
all_tests_filename.gsub(%r{\.html$}, '.filter.html')
end
def render
template_for(all_files)
end
def all_files
files_list.files_to_html
end
def jhw_reporters
reporters.collect do |reporter, output|
%{jasmine.getEnv().addReporter(new jasmine.HeadlessReporter.#{reporter}("#{output}"));}
end.join("\n")
end
private
def template_for(files, spec_lines)
def template_for(files)
spec_lines = files_list.spec_file_line_numbers
ERB.new(Jasmine::Headless.root.join('skel/template.html.erb').read).result(binding)
end
end

View File

@ -0,0 +1,16 @@
module Jasmine::Headless
class UniqueAssetList < ::Array
def <<(asset)
raise InvalidUniqueAsset.new("Not an asset: #{asset.inspect}") if !asset.respond_to?(:logical_path)
super if !self.any? { |other| asset.pathname == other.pathname }
end
def flatten
self.collect(&:to_a).flatten
end
end
class InvalidUniqueAsset < StandardError ; end
end

View File

@ -1,5 +1,5 @@
module Jasmine
module Headless
VERSION = "0.8.0"
VERSION = "0.9.0.rc.2"
end
end

4
script/hooks/post-commit Executable file
View File

@ -0,0 +1,4 @@
#!/bin/bash
penchant gemfile remote --switch-back

View File

@ -2,9 +2,9 @@
OLD_GIT_DIR=$GIT_DIR
if [ "$(penchant gemfile-env)" != "remote" ]; then
if [ "$(penchant gemfile-env)" != "remote deployment" ]; then
unset GIT_DIR
penchant gemfile remote
penchant gemfile remote --deployment
GIT_DIR=$OLD_GIT_DIR
git add Gemfile*
fi

View File

@ -5,7 +5,7 @@ if File.file?('Gemfile.erb')
Dir.chdir '..' do
File.readlines(File.join(pwd, 'Gemfile.erb')).find_all { |line| line[':git'] }.each do |line|
repo = line[%r{:git => (['"])(.*)\1}, 2]
repo = line[%r{:git => (['"])([^'"]+)\1}, 2]
puts "Installing #{repo}"
system %{git clone #{repo}}

View File

@ -6,24 +6,67 @@
<script type="text/javascript" src="<%= Jasmine::Headless.root.join('vendor/assets/javascripts/prolog.js') %>"></script>
<%= files.join("\n") %>
<script type="text/javascript">
if (window.JHW) { HeadlessReporterResult.specLineNumbers = <%= MultiJson.encode(spec_lines) %>; }
if (window.JHW) { HeadlessReporterResult.specLineNumbers = <%= MultiJson.dump(spec_lines) %>; }
</script>
</head>
<body>
<script type="text/javascript">
jasmine.getEnv().console = {
log: function(msg) { JHW.stdout.puts(msg) }
log: function(msg) { JHW.print('stdout', msg + "\n"); }
}
window._onload = window.onload
window._onload = window.onload;
window.onload = function() {
if (window._onload) { window._onload() }
if (window._onload && (window._onload != window.onload)) {
window._onload();
}
if (window.JHW) {
jasmine.getEnv().addReporter(new jasmine.HeadlessConsoleReporter());
<%= jhw_reporters %>
} else {
jasmine.getEnv().addReporter(new jasmine.HtmlReporter());
types = [ 'HtmlReporter', 'TrivialReporter' ];
for (var i = 0, j = types.length; i < j; ++i) {
var type = jasmine[types[i]]
if (type) {
jasmine.getEnv().addReporter(new type());
break;
}
}
var location = window.location.href;
var getLastModified = function(callback) {
var http = new XMLHttpRequest();
var header;
http.open('HEAD', location, true);
http.onreadystatechange = function() {
if(http.readyState === http.DONE) {
callback(http.getResponseHeader('Last-Modified'));
}
};
http.send();
}
getLastModified(function(currentLastModified) {
var checker;
checker = function() {
setTimeout(function() {
getLastModified(function(newLastModified) {
if (currentLastModified != newLastModified) {
setTimeout(function() { window.location.reload(); }, 1000);
} else {
checker();
}
});
}, 3000);
};
checker();
});
}
jasmine.getEnv().execute();

View File

@ -1,142 +0,0 @@
require 'spec_helper'
require 'tempfile'
describe "jasmine-headless-webkit" do
let(:report) { 'spec/report.txt' }
before do
FileUtils.rm_f report
end
after do
FileUtils.rm_f report
end
describe 'success' do
it "should succeed with error code 0" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml --report #{report}}
$?.exitstatus.should == 0
report.should be_a_report_containing(1, 0, false)
end
end
describe 'success but with js error' do
it "should succeed with error code 0" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/success_with_error/success_with_error.yml --report #{report}}
$?.exitstatus.should == 1
# returns are unpredictable due to changes in jasmine! >.<
# all we can do is ensure that we've actually failed
#
# report.should be_a_report_containing(0, 0, false)
end
end
describe 'failure' do
it "should fail with an error code of 1" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/failure/failure.yml --report #{report}}
$?.exitstatus.should == 1
report.should be_a_report_containing(1, 1, false)
end
end
describe 'with console.log' do
it "should succeed, but has a console.log so an error code of 2" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/console_log/console_log.yml --report #{report}}
$?.exitstatus.should == 2
report.should be_a_report_containing(1, 0, true)
end
end
describe 'with coffeescript error' do
it "should fail" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/coffeescript_error/coffeescript_error.yml --report #{report}}
$?.exitstatus.should == 1
File.exist?(report).should be_false
end
end
describe 'tries to leave page' do
it "should not leave the page nor loop" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/leave_page/leave_page.yml --report #{report}}
$?.exitstatus.should == 1
end
end
describe 'tries to click a button' do
it "should not leave the page nor loop" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/click_button/click_button.yml --report #{report}}
$?.exitstatus.should == 0
report.should be_a_report_containing(0, 0, false)
end
end
describe 'with filtered run' do
context "don't run a full run, just the filtered run" do
it "should succeed and run both" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/filtered_success/filtered_success.yml --no-full-run --report #{report} ./spec/jasmine/filtered_success/success_one_spec.js}
$?.exitstatus.should == 0
report.should be_a_report_containing(1, 0, false)
end
it "should use a file outside the normal test run and only run one" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/filtered_success/filtered_success.yml --report #{report} ./spec/jasmine/filtered_success/success_other_file.js}
$?.exitstatus.should == 0
report.should be_a_report_containing(1, 0, false)
end
end
context "do both runs" do
it "should fail and not run the second" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/filtered_failure/filtered_failure.yml --report #{report} ./spec/jasmine/filtered_failure/failure_spec.js}
$?.exitstatus.should == 1
report.should be_a_report_containing(1, 1, false)
end
it "should succeed and run both" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/filtered_success/filtered_success.yml --report #{report} ./spec/jasmine/filtered_success/success_one_spec.js}
$?.exitstatus.should == 0
report.should be_a_report_containing(2, 0, false)
end
it "should succeed and run both, with the first having a console.log call" do
system %{bin/jasmine-headless-webkit -j spec/jasmine/filtered_success_with_console/filtered_success.yml --report #{report} ./spec/jasmine/filtered_success_with_console/success_one_spec.js}
$?.exitstatus.should == 2
report.should be_a_report_containing(2, 0, true)
end
end
end
describe 'files' do
it 'should list all the files that will be found' do
files = %x{bin/jasmine-headless-webkit -l -j spec/jasmine/success/success.yml}
$?.exitstatus.should == 0
files.lines.to_a.should include(File.expand_path("./spec/jasmine/success/success.js\n"))
files.lines.to_a.should include(File.expand_path("./spec/jasmine/success/success_spec.js\n"))
end
end
describe 'runner-out' do
it 'should write out the runner HTML to the specified path and not run the test' do
runner_path = Tempfile.new('jhw')
runner_path.close
system %{bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml --runner-out #{runner_path.path}}
File.size(runner_path.path).should_not == 0
end
end
end

BIN
spec/files/UTF-8-test.txt Normal file

Binary file not shown.

View File

@ -0,0 +1,13 @@
require 'spec_helper'
describe 'randomize run order' do
let(:seed) { 100 }
it 'should randomize the run order' do
output = %x{bin/jasmine-headless-webkit -j spec/jasmine/success/success.yml --seed #{seed}}
$?.exitstatus.should == 0
output.should include("--seed #{seed}")
end
end

View File

@ -0,0 +1,22 @@
require 'spec_helper'
describe 'specify runner in jasmine.yml' do
before do
File.unlink "spec/temp_out.html" if File.file?('spec/temp_out.html')
end
it 'should randomize the run order' do
output = %x{bin/jasmine-headless-webkit -j spec/jasmine/runner_out_in_jasmine_yml/jasmine.yml}
$?.exitstatus.should == 2
output.should include("made it")
output.should include("1 test")
"spec/temp_out.html".should be_a_file
end
after do
File.unlink "spec/temp_out.html" if File.file?('spec/temp_out.html')
end
end

View File

@ -0,0 +1,23 @@
require 'spec_helper'
describe 'sprockets' do
it 'should pull in the code via sprockets' do
files = %x{bin/jasmine-headless-webkit -l -j spec/jasmine/with_sprockets_includes/with_sprockets_includes.yml}
$?.exitstatus.should == 0
files.lines.to_a.should contain_in_order_in_file_list(
'assets/application.js.erb: unsupported format',
'vendor/assets/javascripts/jquery.js',
'templates/that.jst.ejs',
'templates/this.jst',
'things/jquery.string.js',
'assets/things/required.js',
'assets/things/code.js',
'assets/things/subcode/more_code.js',
'spec_helper.js',
'spec/things/code_spec.js'
)
files.lines.to_a.any? { |line| line['assets/jquery.string.js: unsupported format'] }.should be_false
end
end

View File

@ -1,5 +1,5 @@
src_files:
- spec/javascripts/support/jquery-1.6.2.min.js
- spec/jasmine/console_log/console_log.js
spec_files:

View File

View File

@ -0,0 +1,8 @@
src_dir: spec/jasmine/noisy
src_files:
- '**/*'
spec_dir: spec/jasmine/noisy
spec_files:
- '**/*'

View File

@ -0,0 +1,2 @@
window.prompt("hello");

View File

@ -0,0 +1,11 @@
src_dir: spec/jasmine/runner_out_in_jasmine_yml
spec_dir: spec/jasmine/runner_out_in_jasmine_yml
src_files:
- "*.js"
spec_files:
- "*_spec.coffee"
runner_output: 'spec/temp_out.html'

View File

@ -0,0 +1,2 @@
console.log("made it")

View File

@ -0,0 +1,4 @@
describe 'this', ->
it 'should be true', ->
expect(true).toEqual(true)

Some files were not shown because too many files have changed in this diff Show More