jasmine-headless-webkit 0.8.4 → 0.9.0.rc1

data/spec/lib/jasmine/headless/runner_spec.rb

@@ -36,14 +36,17 @@ describe Jasmine::Headless::Runner do
 
     context 'file exists' do
       before do
-        File.open(Jasmine::Headless::Runner::RUNNER, 'w')
-        File.open(config_filename, 'w') { |fh| fh.print YAML.dump('test' => 'hello') }
+        File.open(config_filename, 'w') { |fh| fh.print YAML.dump('test' => 'hello', 'erb' => '<%= "erb" %>') }
       end
 
       it 'should load the jasmine config' do
         runner.jasmine_config['test'].should == 'hello'
         runner.jasmine_config['spec_dir'].should == 'spec/javascripts'
       end
+
+      it 'should execute ERB in the config file' do
+        runner.jasmine_config['erb'].should == 'erb'
+      end
     end
 
     context 'file does not exist' do
@@ -54,51 +57,48 @@ describe Jasmine::Headless::Runner do
   end
 
   describe '#jasmine_command' do
-    let(:opts) { {
-      :colors => true,
-      :report => 'test'
-    } }
+    subject { runner.jasmine_command(target) }
 
-    it 'should have the right options' do
-      runner.jasmine_command.should match(/jasmine-webkit-specrunner/)
-      runner.jasmine_command.should match(/-c/)
-      runner.jasmine_command.should match(/-r test/)
-      runner.jasmine_command('file.js').should match(/file.js/)
-    end
-  end
+    let(:target) { 'target' }
 
-  context 'real tests' do
-    let(:report) { 'spec/report.txt' }
+    let(:options) { {} }
+    let(:reporters) { [] }
 
     before do
-      FileUtils.rm_f report
+      runner.stubs(:options).returns(options)
+      options.stubs(:file_reporters).returns(reporters)
     end
 
-    after do
-      FileUtils.rm_f report
+    def self.it_should_have_basics
+      it { should include(target) }
     end
 
-    it 'should succeed with error code 0' do
-      Jasmine::Headless::Runner.run(
-        :jasmine_config => 'spec/jasmine/success/success.yml',
-        :report => report
-      ).should == 0
+    context 'colors' do
+      before do
+        options[:colors] = true
+      end
 
-      report.should be_a_report_containing(1, 0, false)
+      it_should_have_basics
+      it { should include('-c') }
     end
 
-    it 'should succeed but with javascript error' do
-      Jasmine::Headless::Runner.run(:jasmine_config => 'spec/jasmine/success_with_error/success_with_error.yml').should == 1
+    context 'reporters' do
+      let(:reporter) { [ 'Reporter', 'identifier', file ] }
+      let(:reporters) { [ reporter ] }
+
+      let(:file) { 'file' }
+
+      it_should_have_basics
+      it { should include("-r #{file}") }
     end
 
-    it 'should fail on one test' do
-      Jasmine::Headless::Runner.run(
-        :jasmine_config => 'spec/jasmine/failure/failure.yml',
-        :report => report
-      ).should == 1
+    context 'quiet' do
+      before do
+        options[:quiet] = true
+      end
 
-      report.should be_a_report_containing(1, 1, false)
-      report.should contain_a_failing_spec(['failure', 'should fail with error code of 1'])
+      it_should_have_basics
+      it { should include("-q") }
     end
   end
 
@@ -167,4 +167,81 @@ describe Jasmine::Headless::Runner do
       runner.jasmine_config['spec_files'].should == described_class::JASMINE_DEFAULTS['spec_files']
     end
   end
+
+  describe '#files_list' do
+    subject { runner.files_list }
+
+    let(:options) { { :files => only, :seed => seed } }
+
+    let(:only) { 'only' }
+    let(:seed) { 12345 }
+    let(:jasmine_config) { 'jasmine config' }
+    let(:reporters) { [] }
+
+    before do
+      runner.stubs(:options).returns(options)
+      runner.stubs(:jasmine_config).returns(jasmine_config)
+
+      options.stubs(:reporters).returns(reporters)
+    end
+
+    it { should be_a_kind_of(Jasmine::Headless::FilesList) }
+
+    it 'should have settings' do
+      subject.options[:config].should == jasmine_config
+      subject.options[:only].should == only
+      subject.options[:seed].should == seed
+      subject.options[:reporters].should == reporters
+    end
+  end
+
+  describe '.server_port' do
+    before do
+      described_class.instance_variable_set(:@server_port, nil)
+    end
+
+    context 'port in use' do
+      require 'socket'
+
+      before do
+        described_class.stubs(:select_server_port).returns(5000, 5001)
+      end
+
+      it 'should try another port' do
+        server = TCPServer.new(described_class.server_interface, 5000)
+
+        described_class.server_port.should == 5001
+      end
+    end
+  end
+
+  describe '#absolute_run_targets' do
+    let(:opts) { {} }
+
+    subject { runner.absolute_run_targets(targets) }
+
+    let(:targets) { [ target ] }
+    let(:target) { 'target' }
+
+    before do
+      runner.stubs(:options).returns(:use_server => use_server)
+    end
+
+    context 'server' do
+      let(:use_server) { true }
+      let(:server_spec_path) { 'server spec path' }
+
+      before do
+        described_class.stubs(:server_spec_path).returns(server_spec_path)
+      end
+
+      it { should == [ server_spec_path + target ] }
+    end
+
+    context 'no server' do
+      let(:use_server) { false }
+
+      it { should == [ 'file://' + File.expand_path(target) ] }
+    end
+  end
 end

data/spec/lib/jasmine/headless/template_writer_spec.rb

@@ -43,46 +43,50 @@ describe Jasmine::Headless::TemplateWriter do
     end
   end
 
-  describe '#write!' do
-    include FakeFS::SpecHelpers
+  describe '#render' do
+    subject { template_writer.render }
+
+    let(:all_files) { 'all files' }
+    let(:template) { 'template' }
 
     before do
-      Jasmine::Headless::FilesList.stubs(:default_files).returns([])
+      template_writer.stubs(:all_files).returns(all_files)
 
-      File.stubs(:read).returns(nil)
+      template_writer.expects(:template_for).with(all_files).returns(template)
+    end
 
-      runner.stubs(:keep_runner).returns(true)
-      runner.stubs(:runner_filename).returns(false)
+    it { should == template }
+  end
 
-      Sprockets::Environment.any_instance.stubs(:find_asset).returns(stub(:body => ''))
-    end
+  describe '#all_files' do
+    subject { template_writer.all_files }
 
-    let(:files_list) { Jasmine::Headless::FilesList.new }
+    let(:files_list) { stub }
+    let(:files) { 'files' }
 
     before do
-      files_list.stubs(:files).returns([ 'file.js' ])
-      files_list.stubs(:filtered_files).returns([ 'file.js' ])
-    end
+      template_writer.stubs(:files_list).returns(files_list)
 
-    context 'no filter' do
-      it 'should write one file' do
-        template_writer.write!(files_list).should == [
-          "jhw.#{$$}.html"
-        ]
-      end
+      files_list.stubs(:files_to_html).returns(files)
     end
 
-    context 'filtered files' do
-      before do
-        files_list.stubs(:files).returns([ 'file.js', 'file2.js' ])
-      end
+    it { should == files }
+  end
 
-      it 'should write two files' do
-        template_writer.write!(files_list).should == [
-          "jhw.#{$$}.filter.html", "jhw.#{$$}.html"
-        ]
-      end
+  describe '#jhw_reporters' do
+    subject { template_writer.jhw_reporters }
+
+    let(:reporter) { 'reporter' }
+    let(:output) { 'output' }
+
+    before do
+      template_writer.stubs(:reporters).returns([
+        [ reporter, output ]
+      ])
     end
+
+    it { should include(reporter) }
+    it { should include(output) }
   end
 end
 

data/spec/lib/jasmine/headless/unique_asset_list_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Jasmine::Headless::UniqueAssetList do
   let(:list) { described_class.new }
 
-  let(:first) { stub(:logical_path => 'one') }
-  let(:second) { stub(:logical_path => 'two') }
-  let(:third) { stub(:logical_path => 'two') }
+  let(:first) { stub(:logical_path => 'one', :pathname => 'one') }
+  let(:second) { stub(:logical_path => 'two', :pathname => 'two') }
+  let(:third) { stub(:logical_path => 'two', :pathname => 'two') }
 
   it 'should raise an exception on a non-asset' do
     expect { list << "whatever" }.to raise_error(StandardError)

data/spec/lib/jasmine/headless_spec.rb

@@ -1,2 +1,38 @@
 require 'spec_helper'
 
+describe Jasmine::Headless do
+  describe '.warn' do
+    let(:output) { StringIO.new }
+
+    before do
+      described_class.stubs(:output).returns(output)
+    end
+
+    context 'warnings enabled' do
+      before do
+        described_class.stubs(:show_warnings?).returns(true)
+      end
+
+      it 'should work' do
+        described_class.warn("warning")
+
+        output.rewind
+        output.read.should == "warning\n"
+      end
+    end
+
+    context 'warnings disabled' do
+      before do
+        described_class.stubs(:show_warnings?).returns(false)
+      end
+
+      it 'should work' do
+        described_class.warn("warning")
+
+        output.rewind
+        output.read.should == ""
+      end
+    end
+  end
+end
+

data/spec/skel/template.html.erb_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe 'skel/template.html.erb' do
+  describe 'reporters' do
+
+  end
+end
+

data/vendor/assets/coffeescripts/prolog.coffee

@@ -26,47 +26,74 @@ if window.JHW
       console.log(data)
       data
 
+  puts = (message) ->
+    JHW.print('stdout', message + "\n")
+
+  warn = (message) ->
+    puts(message) if !JHW.isQuiet()
+
+  # handle unloading
   window.onbeforeunload = (e) ->
     e = e || window.event
 
     JHW.hasError()
-    JHW.stdout.puts('The code tried to leave the test page. Check for unhandled form submits and link clicks.')
+    warn "The code tried to leave the test page. Check for unhandled form submits and link clicks."
 
-    if e
-      e.returnValue = 'string'
+    e.returnValue = 'string' if e
 
     return 'string'
 
-  window.confirm = (message) ->
-    JHW.stderr.puts("#{"[confirm]".foreground('red')} jasmine-headless-webkit can't handle confirm() yet! You should mock window.confirm. Returning true.")
-    true
-
-  window.alert = (message) ->
-    JHW.stderr.puts("[alert] ".foreground('red') + message)
-
+  # script errors
   JHW._hasErrors = false
   JHW._handleError = (message, lineNumber, sourceURL) ->
-    JHW.stderr.puts(message)
+    JHW.print('stderr', message + "\n")
     JHW._hasErrors = true
     false
 
-  JHW._setColors = (useColors) ->
-    Intense.useColors = useColors
+  # dialogs
+  window.confirm = ->
+    warn "#{"[confirm]".foreground('red')} You should mock window.confirm. Returning true."
 
-  createHandle = (handle) ->
-    JHW[handle] =
-      print: (content) -> JHW.print(handle, content)
-      puts: (content) -> JHW.print(handle, content + "\n")
+    true
 
-  createHandle(handle) for handle in [ 'stdout', 'stderr', 'report' ]
+  window.prompt =  ->
+    warn "#{"[prompt]".foreground('red')} You should mock window.prompt. Returning true."
 
-  JHW._usedConsole = false
+    true
+
+  window.alert = (message) ->
+    warn "[alert] ".foreground('red') + message
+
+  # color support
+  JHW._setColors = (useColors) -> Intense.useColors = useColors
 
+  # console.log support
+  JHW._usedConsole = false
   JHW.log = (msg) ->
     JHW.hasUsedConsole()
-    JHW.report.puts("CONSOLE||#{msg}")
+
+    for reporter in jasmine.getEnv().reporter.subReporters_
+      reporter.consoleLogUsed(msg) if reporter.consoleLogUsed?
+
     JHW._usedConsole = true
-    JHW.stdout.puts(msg)
+
+    puts msg
+
+  JHW.createCoffeeScriptFileException = (e) ->
+    if e and e.sourceURL
+      filename = e.sourceURL.split('/').pop()
+
+      e =
+        name: e.name
+        message: e.message
+        sourceURL: e.sourceURL
+        lineNumber: e.line
+
+      if window.CoffeeScriptToFilename and realFilename = window.CoffeeScriptToFilename[filename]
+        e.sourceURL = realFilename
+        e.lineNumber = "~" + String(e.line)
+
+    e
 
 window.CoffeeScriptToFilename = {}
 window.CSTF = window.CoffeeScriptToFilename

data/vendor/assets/javascripts/headless_reporter_result.js

@@ -1,3 +1,4 @@
+(function() {
 
   window.HeadlessReporterResult = (function() {
 
@@ -74,3 +75,5 @@
     return HeadlessReporterResult;
 
   })();
+
+}).call(this);

data/vendor/assets/{coffeescripts → javascripts}/jasmine-extensions.coffee

@@ -30,15 +30,7 @@ if window.JHW
     this.env.reporter.reportSpecResults(this)
 
   jasmine.Spec.prototype.fail = (e) ->
-    if e and e.sourceURL and window.CoffeeScriptToFilename
-      filename = e.sourceURL.split('/').pop()
-      if realFilename = window.CoffeeScriptToFilename[filename]
-        e = {
-          name: e.name,
-          message: e.message,
-          lineNumber: "~" + String(e.line),
-          sourceURL: realFilename
-        }
+    e = JHW.createCoffeeScriptFileException(e)
 
     expectationResult = new jasmine.ExpectationResult({
       passed: false,
@@ -47,6 +39,8 @@ if window.JHW
     })
     @results_.addResult(expectationResult)
 
+    this.env.reporter.reportException(e)
+
   jasmine.NestedResults.isValidSpecLine = (line) ->
     line.match(/^\s*expect/) != null || line.match(/^\s*return\s*expect/) != null
 
@@ -92,7 +86,7 @@ if window.JHW
 
       this.addResult_(result)
 
-    for method in [ "reportSpecWaiting", "reportSpecRunning" ]
+    for method in [ "reportSpecWaiting", "reportSpecRunning", "reportException" ]
       generator = (method) ->
         (args...) ->
           for reporter in @subReporters_

data/vendor/assets/javascripts/jasmine.HeadlessReporter.Console.coffee

@@ -0,0 +1,8 @@
+#= require jasmine.HeadlessReporter.ConsoleBase
+#
+class jasmine.HeadlessReporter.Console extends jasmine.HeadlessReporter.ConsoleBase
+  displaySuccess: (spec) =>
+    this.print('.'.foreground('green'))
+
+  displayFailure: (spec) =>
+    this.print('F'.foreground('red'))

data/vendor/assets/javascripts/jasmine.HeadlessReporter.ConsoleBase.coffee

@@ -0,0 +1,92 @@
+#= require jasmine.HeadlessReporter
+
+class jasmine.HeadlessReporter.ConsoleBase extends jasmine.HeadlessReporter
+  constructor: (@callback = null) ->
+    super(@callback)
+
+    @position = 0
+    @positions = "|/-\\"
+
+  formatResultLine: (runtime) ->
+    line = []
+    line.push(@length)
+    line.push((if @length == 1 then "test" else "tests") + ',')
+
+    line.push(@failedCount)
+    line.push((if @failedCount == 1 then "failure" else "failures") + ',')
+
+    line.push(runtime)
+    line.push((if runtime == 1.0 then "sec" else "secs") + '.')
+
+    line.join(' ')
+
+  reportRunnerResults: (runner) ->
+    super()
+
+    this.print("\n")
+
+    resultLine = this.formatResultLine(this._runtime())
+
+    if @failedCount == 0
+      this.puts("PASS: #{resultLine}".foreground('green'))
+    else
+      this.puts("FAIL: #{resultLine}".foreground('red'))
+
+    for result in @results
+      this.puts(result.toString())
+
+    this.puts("\nTest ordering seed: --seed #{JHW.getSeed()}")
+
+  reportRunnerStarting: (runner) ->
+    super(runner)
+    this.puts("\nRunning Jasmine specs...".bright()) if !this.hasError()
+
+  reportSpecWaiting: ->
+    if !@timer
+      @timer = true
+      @first = true
+
+      this._waitRunner()
+
+  reportSpecRunning: ->
+    if @timer
+      clearTimeout(@timer)
+      @timer = null
+      this.print(Intense.moveBack())
+
+  reportSpecResults: (spec) ->
+    super(spec)
+
+    this._reportSpecResult(spec, {
+      success: (results) =>
+        this.displaySuccess(spec)
+      failure: (results) =>
+        this.displayFailure(spec)
+
+        this.reportFailureResult(results, new HeadlessReporterResult(spec.getFullName(), spec.getSpecSplitName()))
+    })
+
+  reportFailureResult: (results, failureResult) ->
+    testCount = 1
+
+    for result in results.getItems()
+      if result.type == 'expect' and !result.passed_
+        if foundLine = result.expectations[testCount - 1]
+          [ result.line, result.lineNumber ] = foundLine
+        failureResult.addResult(result)
+      testCount += 1
+    @results.push(failureResult)
+
+  _waitRunner: =>
+    @timer = setTimeout(
+      =>
+        if @timer
+          this.print(Intense.moveBack()) if !@first
+          this.print(@positions.substr(@position, 1).foreground('yellow'))
+          @position += 1
+          @position %= @positions.length
+          @first = false
+          this._waitRunner()
+      , 750
+    )
+

data/vendor/assets/javascripts/jasmine.HeadlessReporter.File.coffee

@@ -0,0 +1,24 @@
+#= require jasmine.HeadlessReporter
+#
+class jasmine.HeadlessReporter.File extends jasmine.HeadlessReporter
+  reportRunnerResults: (runner) ->
+    super(runner)
+
+    output = "TOTAL||#{@length}||#{@failedCount}||#{this._runtime()}||#{if JHW._hasErrors then "T" else "F"}"
+
+    this.puts(output)
+    this.puts("SEED||#{JHW.getSeed()}")
+
+  consoleLogUsed: (msg) ->
+    this.puts("CONSOLE||#{msg}")
+
+  reportSpecResults: (spec) ->
+    super(spec)
+
+    this._reportSpecResult(spec, {
+      success: (results) =>
+        this.puts("PASS||" + spec.getJHWSpecInformation())
+      failure: (results) =>
+        this.puts("FAIL||" + spec.getJHWSpecInformation())
+    })
+

data/vendor/assets/javascripts/jasmine.HeadlessReporter.Tap.coffee

@@ -0,0 +1,28 @@
+#= require jasmine.HeadlessReporter
+
+class jasmine.HeadlessReporter.Tap extends jasmine.HeadlessReporter
+  constructor: (@outputTarget = null) ->
+    super(@outputTarget)
+
+    @output = []
+
+  reportRunnerResults: (runner) ->
+    super(runner)
+
+    @output.unshift("1..#{@output.length}") if @output.length > 0
+
+    this.puts(@output.join("\n"))
+
+  reportSpecResults: (spec) ->
+    super(spec)
+
+    index = @output.length + 1
+    description = spec.getSpecSplitName().join(' ')
+
+    this._reportSpecResult(spec, {
+      success: (results) =>
+        @output.push("ok #{index} #{description}")
+      failure: (results) =>
+        @output.push("not ok #{index} #{description}")
+    })
+

data/vendor/assets/javascripts/jasmine.HeadlessReporter.Verbose.coffee

@@ -0,0 +1,64 @@
+#= require jasmine.HeadlessReporter.ConsoleBase
+#
+class jasmine.HeadlessReporter.Verbose extends jasmine.HeadlessReporter.ConsoleBase
+  @prereport = false
+
+  displaySuccess: (spec) =>
+    this.displaySpec(spec, 'green')
+
+  displayFailure: (spec) =>
+    this.displaySpec(spec, 'red')
+
+  displaySpec: (spec, color) =>
+    currentLastNames = (@lastNames || []).slice(0)
+    @lastNames = spec.getSpecSplitName()
+
+    for line in this.indentSpec(@lastNames, currentLastNames, color)
+      if line? and !_.isEmpty(line)
+        this.puts(line)
+
+  indentSpec: (current, last, color) =>
+    last = last.slice(0)
+
+    lines = []
+
+    for name in current
+      if last.shift() != name
+        lines.push(name)
+      else
+        lines.push(null)
+
+    this.indentLines(lines, color)
+
+  indentLines: (lines, color) =>
+    indent = ''
+
+    output = []
+
+    for line in lines
+      if line?
+        outputLine = indent
+        outputLine += this.colorLine(line, color)
+
+        output.push(outputLine)
+      indent += '  '
+
+    output
+
+  colorLine: (line, color) =>
+    line.foreground(color)
+
+  reportSpecStarting: (spec) =>
+    if jasmine.HeadlessReporter.Verbose.prereport
+      this.puts(spec.getSpecSplitName().join(' '))
+
+  reportException: (e) =>
+    e = JHW.createCoffeeScriptFileException(e)
+
+    if e.sourceURL && e.lineNumber
+      output = "#{e.sourceURL}:#{e.lineNumber} #{e.message}"
+    else
+      output = e.message ? e
+
+    this.puts(output.foreground('yellow'))
+