jasmine-headless-webkit 0.8.4 → 0.9.0.rc1

data/spec/javascripts/jasmine.HeadlessReporter.Tap_spec.coffee

@@ -0,0 +1,19 @@
+describe 'jasmine.HeadlessReporter.Tap', ->
+  beforeEach ->
+    @reporter = new jasmine.HeadlessReporter.Tap()
+
+  describe '#reportRunnerResults', ->
+    it 'should write nothing for nothing', ->
+      @reporter.output = []
+
+      @reporter.reportRunnerResults(null)
+
+      expect(@reporter.output[0]).not.toBeDefined()
+
+    it 'should report the length right', ->
+      @reporter.output = [ 'test' ]
+
+      @reporter.reportRunnerResults(null)
+
+      expect(@reporter.output[0]).toEqual('1..1')
+

data/spec/javascripts/jasmine.HeadlessReporter_spec.coffee

@@ -0,0 +1,27 @@
+describe 'jasmine.HeadlessReporter', ->
+  reporter = null
+
+  beforeEach ->
+    reporter = new jasmine.HeadlessReporter()
+
+  it 'should stop running specs if there are errors reported', ->
+    # otherwise it gets really confusing!
+
+    suite = { finish: -> null }
+    spec = new jasmine.Spec("env", suite, "test")
+
+    spyOn(reporter, 'hasError').andReturn(true)
+    spyOn(spec, 'finish')
+    spyOn(suite, 'finish')
+
+    reporter.reportSpecStarting(spec)
+
+    expect(spec.finish).toHaveBeenCalled()
+    expect(suite.finish).toHaveBeenCalled()
+
+  describe '#reportRunnerStarting', ->
+    it 'should start getting time', ->
+      expect(reporter.startTime).not.toBeDefined()
+      reporter.reportRunnerStarting("runner")
+      expect(reporter.startTime).toBeDefined()
+

data/spec/javascripts/support/jasmine.yml

@@ -1,8 +1,9 @@
 src_files:
-  - 'spec/javascripts/support/jquery-1.6.2.min.js'
-  - 'vendor/assets/coffeescripts/*.coffee'
+  - '**/*'
 
-spec_files: [ 'spec/javascripts/*_spec.coffee' ]
-src_dir: .
-spec_dir: .
+spec_files: [ '**/*_spec.coffee' ]
+src_dir: vendor/assets/javascripts
+spec_dir: spec/javascripts
+helpers:
+  - 'helpers/**.*'
 

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

@@ -1,25 +1,41 @@
 require 'spec_helper'
 
 describe Jasmine::Headless::FileChecker do
-  include FakeFS::SpecHelpers
-
   let(:test_class) do
     object = Object.new
     object.class.send(:include, Jasmine::Headless::FileChecker)
     object
   end
 
-  context "bad_format?" do
-    it "should return false wth correct format" do
-      test_class.bad_format?('foobar.js').should be_false
+  describe "#bad_format?" do
+    subject { test_class.bad_format?(file) }
+
+    before do
+      test_class.stubs(:excluded_formats).returns(%w{erb string})
+    end
+
+    context 'nil' do
+      let(:file) { nil }
+
+      it { should be_nil }
     end
 
-    it "should return false wth wrong format" do
-      test_class.bad_format?('foobar.js.erb').should be_true
+    context 'allowed format' do
+      let(:file) { 'foobar.js' }
+
+      it { should be_false }
     end
 
-    it "should check for the whole extension" do
-      test_class.bad_format?('foobar.string.js').should be_false
+    context 'unallowed format' do
+      let(:file) { 'foobar.erb' }
+
+      it { should be_true }
+    end
+
+    context 'check whole extension' do
+      let(:file) { 'foobar.string.js' }
+
+      it { should be_true }
     end
   end
 end

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

@@ -5,50 +5,6 @@ require 'coffee-script'
 describe Jasmine::Headless::FilesList do
   let(:files_list) { described_class.new }
 
-  describe '#initialize' do
-    it "should have default files" do
-      files_list.files.should == [
-        File.join(Jasmine::Core.path, "jasmine.js"),
-        File.join(Jasmine::Core.path, "jasmine-html.js"),
-        File.join(Jasmine::Core.path, "jasmine.css"),
-        File.expand_path('vendor/assets/javascripts/jasmine-extensions.js'),
-        File.expand_path('vendor/assets/javascripts/intense.js'),
-        File.expand_path('vendor/assets/javascripts/headless_reporter_result.js'),
-        File.expand_path('vendor/assets/javascripts/jasmine.HeadlessConsoleReporter.js'),
-        File.expand_path('vendor/assets/javascripts/jsDump.js'),
-        File.expand_path('vendor/assets/javascripts/beautify-html.js'),
-      ]
-    end
-  end
-
-  def self.no_default_files!
-    before do
-      described_class.stubs(:default_files).returns([])
-    end
-  end
-
-  it 'should have tests for #use_config!'
-  it 'should have tests for #add_files'
-
-  describe '#spec_file_line_numbers' do
-    include FakeFS::SpecHelpers
-
-    no_default_files!
-
-    before do
-      files_list.stubs(:spec_files).returns(['test.coffee', 'test2.coffee'])
-
-      File.open('test.coffee', 'w') { |fh| fh.print "describe('cat')\ndescribe('cat')" }
-      File.open('test2.coffee', 'w') { |fh| fh.print "no matches" }
-    end
-
-    it 'should generate filenames and line number info' do
-      files_list.spec_file_line_numbers.should == {
-        'test.coffee' => { 'cat' => [ 1, 2 ] }
-      }
-    end
-  end
-
   describe '.get_paths_from_gemspec' do
     include FakeFS::SpecHelpers
 
@@ -72,177 +28,195 @@ describe Jasmine::Headless::FilesList do
     it { should =~ paths }
   end
 
-  describe '#search_paths' do
-    no_default_files!
-
-    let(:files_list) { described_class.new(:config => config) }
+  describe '.asset_paths' do
+    include FakeFS::SpecHelpers
 
-    let(:config) { {
-      'src_dir' => src_dir,
-      'spec_dir' => spec_dir,
-      'asset_paths' => asset_paths
-    } }
+    let(:dir_one) { 'dir_one' }
+    let(:dir_two) { 'dir_two' }
 
-    let(:src_dir) { 'src dir' }
-    let(:spec_dir) { 'spec dir' }
-    let(:asset_paths) { [] }
-    let(:path) { 'path' }
+    let(:gem_one) { stub(:gem_dir => dir_one) }
+    let(:gem_two) { stub(:gem_dir => dir_two) }
 
     before do
-      Jasmine::Headless::FilesList.stubs(:asset_paths).returns([])
+      described_class.instance_variable_set(:@asset_paths, nil)
+      FileUtils.mkdir_p File.join(dir_two, 'vendor/assets/javascripts')
+
+      Gem::Specification.stubs(:_all).returns([gem_one, gem_two])
     end
 
-    let(:vendor_path) { Jasmine::Headless.root.join('vendor/assets/javascripts').to_s }
+    it 'should return all matching gems with vendor/assets/javascripts directories' do
+      described_class.asset_paths.should == [ File.join(dir_two, 'vendor/assets/javascripts') ]
+    end
+  end
 
-    context 'no vendored gem paths' do
-      it 'should take the src dir and spec dirs' do
-        files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, File.expand_path(src_dir), File.expand_path(spec_dir) ]
-      end
+  describe '#initialize' do
+    before do
+      described_class.any_instance.stubs(:load_initial_assets)
     end
 
-    context 'vendored gem paths' do
+    describe '#spec_file_line_numbers' do
+      include FakeFS::SpecHelpers
+
       before do
-        Jasmine::Headless::FilesList.stubs(:asset_paths).returns([ path ])
+        files_list.stubs(:spec_files).returns(['test.coffee', 'test2.coffee'])
+
+        File.open('test.coffee', 'w') { |fh| fh.print "describe('cat')\ndescribe('cat')" }
+        File.open('test2.coffee', 'w') { |fh| fh.print "no matches" }
       end
 
-      it 'should add the vendor gem paths to the list' do
-        files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, path, File.expand_path(src_dir), File.expand_path(spec_dir) ]
+      it 'should generate filenames and line number info' do
+        files_list.spec_file_line_numbers.should == {
+          'test.coffee' => { 'cat' => [ 1, 2 ] }
+        }
       end
     end
 
-    context 'multiple dirs' do
-      let(:dir_1) { 'dir 1' }
-      let(:dir_2) { 'dir 2' }
+    describe '#search_paths' do
+      let(:files_list) { described_class.new(:config => config) }
 
-      context 'src_dir is an array' do
-        let(:src_dir) { [ dir_1, dir_2 ] }
+      let(:config) { {
+        'src_dir' => src_dir,
+        'spec_dir' => spec_dir,
+        'asset_paths' => asset_paths
+      } }
 
-        it 'should take the src dir and spec dirs' do
-          files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, File.expand_path(dir_1), File.expand_path(dir_2), File.expand_path(spec_dir) ]
-        end
+      let(:src_dir) { 'src dir' }
+      let(:spec_dir) { 'spec dir' }
+      let(:asset_paths) { [] }
+      let(:path) { 'path' }
+
+      before do
+        Jasmine::Headless::FilesList.stubs(:asset_paths).returns([])
       end
 
-      context 'asset_paths has entries' do
-        let(:src_dir) { dir_1 }
-        let(:asset_paths) { [ dir_2 ] }
+      let(:vendor_path) { Jasmine::Headless.root.join('vendor/assets/javascripts').to_s }
 
+      context 'no vendored gem paths' do
         it 'should take the src dir and spec dirs' do
-          files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, File.expand_path(dir_1), File.expand_path(dir_2), File.expand_path(spec_dir) ]
+          files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, File.expand_path(src_dir), File.expand_path(spec_dir) ]
         end
       end
-    end
-  end
 
-  describe '.asset_paths' do
-    include FakeFS::SpecHelpers
+      context 'vendored gem paths' do
+        before do
+          Jasmine::Headless::FilesList.stubs(:asset_paths).returns([ path ])
+        end
 
-    let(:dir_one) { 'dir_one' }
-    let(:dir_two) { 'dir_two' }
+        it 'should add the vendor gem paths to the list' do
+          files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, path, File.expand_path(src_dir), File.expand_path(spec_dir) ]
+        end
+      end
 
-    let(:gem_one) { stub(:gem_dir => dir_one) }
-    let(:gem_two) { stub(:gem_dir => dir_two) }
+      context 'multiple dirs' do
+        let(:dir_1) { 'dir 1' }
+        let(:dir_2) { 'dir 2' }
 
-    before do
-      described_class.instance_variable_set(:@asset_paths, nil)
+        context 'src_dir is an array' do
+          let(:src_dir) { [ dir_1, dir_2 ] }
 
-      FileUtils.mkdir_p File.join(dir_two, 'vendor/assets/javascripts')
+          it 'should take the src dir and spec dirs' do
+            files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, File.expand_path(dir_1), File.expand_path(dir_2), File.expand_path(spec_dir) ]
+          end
+        end
 
-      Gem::Specification.stubs(:_all).returns([gem_one, gem_two])
-    end
+        context 'asset_paths has entries' do
+          let(:src_dir) { dir_1 }
+          let(:asset_paths) { [ dir_2 ] }
 
-    it 'should return all matching gems with vendor/assets/javascripts directories' do
-      described_class.asset_paths.should == [ File.join(dir_two, 'vendor/assets/javascripts') ]
+          it 'should take the src dir and spec dirs' do
+            files_list.search_paths.should == [ Jasmine::Core.path, vendor_path, File.expand_path(dir_1), File.expand_path(dir_2), File.expand_path(spec_dir) ]
+          end
+        end
+      end
     end
-  end
-
-  describe '#files' do
-    let(:path_one) { 'one' }
-    let(:path_two) { 'two' }
-    let(:path_three) { 'three' }
 
-    let(:file_one) { stub(:to_a => [ asset_one, asset_two ] ) }
-    let(:file_two) { stub(:to_a => [ asset_two, asset_three ] ) }
+    describe '#files' do
+      let(:path_one) { 'one' }
+      let(:path_two) { 'two' }
+      let(:path_three) { 'three' }
 
-    let(:asset_one) { stub(:pathname => Pathname(path_one), :to_ary => nil) }
-    let(:asset_two) { stub(:pathname => Pathname(path_two), :to_ary => nil) }
-    let(:asset_three) { stub(:pathname => Pathname(path_three), :to_ary => nil) }
+      let(:file_one) { stub(:to_a => [ asset_one, asset_two ] ) }
+      let(:file_two) { stub(:to_a => [ asset_two, asset_three ] ) }
 
-    before do
-      files_list.stubs(:required_files).returns(Jasmine::Headless::UniqueAssetList.new([ file_one, file_two ]))
-    end
-
-    subject { files_list.files }
+      let(:asset_one) { stub(:pathname => Pathname(path_one), :to_ary => nil) }
+      let(:asset_two) { stub(:pathname => Pathname(path_two), :to_ary => nil) }
+      let(:asset_three) { stub(:pathname => Pathname(path_three), :to_ary => nil) }
 
-    it { should == [ path_one, path_two, path_three ] }
-  end
-
-  describe '#filtered_files' do
-    let(:spec_dir) { 'spec' }
+      before do
+        files_list.stubs(:required_files).returns(Jasmine::Headless::UniqueAssetList.new([ file_one, file_two ]))
+      end
 
-    let(:file_one) { "#{spec_dir}/one" }
-    let(:file_two) { "#{spec_dir}/two" }
-    let(:file_three) { "#{spec_dir}/three" }
-    let(:file_four) { 'other/four' }
+      subject { files_list.files }
 
-    before do
-      files_list.stubs(:files).returns([
-        file_one,
-        file_two,
-        file_three,
-        file_four
-      ])
-
-      files_list.stubs(:potential_files_to_filter).returns([ file_one, file_two, file_three ])
+      it { should == [ path_one, path_two, path_three ] }
     end
 
-    subject { files_list.filtered_files }
+    describe '#filtered_files' do
+      let(:spec_dir) { 'spec' }
+
+      let(:file_one) { "#{spec_dir}/one" }
+      let(:file_two) { "#{spec_dir}/two" }
+      let(:file_three) { "#{spec_dir}/three" }
+      let(:file_four) { 'other/four' }
 
-    context 'empty filter' do
       before do
-        files_list.stubs(:spec_filter).returns([])
+        files_list.stubs(:files).returns([
+                                         file_one,
+                                         file_two,
+                                         file_three,
+                                         file_four
+        ])
+
+        files_list.stubs(:potential_files_to_filter).returns([ file_one, file_two, file_three ])
       end
 
-      it { should == [ file_one, file_two, file_three, file_four ] }
-    end
+      subject { files_list.filtered_files }
 
-    context 'with filter' do
-      before do
-        files_list.stubs(:spec_filter).returns([ "#{spec_dir}/one", '**/tw*' ])
+      context 'empty filter' do
+        before do
+          files_list.stubs(:spec_filter).returns([])
+        end
+
+        it { should == [ file_one, file_two, file_three, file_four ] }
       end
 
-      it { should == [ file_one, file_two, file_four ] }
+      context 'with filter' do
+        before do
+          files_list.stubs(:spec_filter).returns([ "#{spec_dir}/one", '**/tw*' ])
+        end
+
+        it { should == [ file_one, file_two, file_four ] }
+      end
     end
-  end
 
-  describe '#add_files' do
-    let(:files_list) { described_class.new(:seed => 100) }
+    describe '#add_files' do
+      let(:files_list) { described_class.new(:seed => 100) }
 
-    no_default_files!
+      let(:dir) { 'tmp' }
 
-    let(:dir) { 'tmp' }
+      before do
+        FileUtils.mkdir_p dir
 
-    before do
-      FileUtils.mkdir_p dir
+        10.times do |index|
+          File.open(File.join(dir, "file-#{index}.js"), 'wb')
+        end
 
-      10.times do |index|
-        File.open(File.join(dir, "file-#{index}.js"), 'wb')
+        File.open(File.join(dir, 'file.js.erb'), 'wb')
       end
 
-      File.open(File.join(dir, 'file.js.erb'), 'wb')
-    end
-
-    before do
-      files_list.send(:add_files, [ '*' ], 'spec_files', [ dir ])
-    end
+      before do
+        files_list.send(:add_files, [ '*' ], 'spec_files', [ dir ])
+      end
 
-    it 'should load spec files in a random order' do
-      files_list.files.collect { |name| name[%r{\d+}] }.should == %w{6 7 1 0 5 3 4 8 2 9}
+      it 'should load spec files in a random order' do
+        files_list.files.collect { |name| name[%r{\d+}] }.should == %w{6 7 1 0 5 3 4 8 2 9}
 
-      FileUtils.rm_rf dir
-    end
+        FileUtils.rm_rf dir
+      end
 
-    it 'should not load an excluded format' do
-      files_list.files.any? { |file| file['.erb'] }.should be_false
+      it 'should not load an excluded format' do
+        files_list.files.any? { |file| file['.erb'] }.should be_false
+      end
     end
   end
 end

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

@@ -43,6 +43,35 @@ describe Jasmine::Headless::Options do
       options[:colors].should be_true
       options[:jasmine_config].should == 'test'
     end
+
+    context 'legacy reporter' do
+      let(:file) { 'file' }
+
+      before do
+        options.expects(:warn)
+      end
+
+      it 'should add a legacy reporter' do
+        options[:reporters] = []
+
+        options.process_option("--report", file)
+
+        options[:reporters].should == [ [ 'File', file ], [ 'Console' ] ]
+      end
+    end
+
+    context 'short reporter' do
+      let(:reporter) { 'reporter' }
+      let(:file) { 'file' }
+
+      it 'should add a reporter' do
+        options[:reporters] = []
+
+        options.process_option("--format", "#{reporter}:#{file}")
+
+        options[:reporters].should == [ [ reporter, file ] ]
+      end
+    end
   end
 
   describe '#read_defaults_files' do
@@ -110,8 +139,56 @@ describe Jasmine::Headless::Options do
       end
     end
 
+    let(:test_reporter) { 'TestReporter' }
+    let(:file) { 'file' }
+
+    context 'no reporters' do
+      it 'should have the default reporter' do
+        options[:reporters].should == [ [ 'Console' ] ]
+      end
+    end
+
+    context 'one reporter' do
+      context 'stdout' do
+        before do
+          ARGV.replace([ "--format", test_reporter ])
+        end
+
+        it 'should have the new reporter on stdout' do
+          options[:reporters].should == [ [ test_reporter ] ]
+
+          options.reporters.should == [ [ test_reporter, 'stdout' ] ]
+        end
+      end
+
+      context 'file' do
+        before do
+          ARGV.replace([ "--format", test_reporter, '--out', file ])
+        end
+
+        it 'should have the new reporter on stdout' do
+          options[:reporters].should == [ [ test_reporter, file ] ]
+
+          options.reporters.should == [ [ test_reporter, 'report:0', file ] ]
+        end
+      end
+    end
+
     after do
       ARGV.replace(@argv)
     end
   end
+
+  describe '#file_reporters' do
+    subject { options.file_reporters }
+
+    let(:stdout_reporter) { [ 'Console', 'stdout' ] }
+    let(:file_reporter) { [ 'File', 'report:0', 'file' ] }
+
+    before do
+      options.stubs(:reporters).returns([ stdout_reporter, file_reporter ])
+    end
+
+    it { should == [ file_reporter ] }
+  end
 end

data/spec/lib/jasmine/headless/report_message/seed_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::ReportMessage::Seed do
+  let(:seed) { described_class.new(seed_value) }
+  let(:seed_value) { '1' }
+
+  subject { seed }
+
+  its(:seed) { should == seed_value.to_i }
+
+  describe '.new_from_parts' do
+    subject { described_class.new_from_parts(parts) }
+
+    let(:parts) { [ seed_value ] }
+
+    its(:seed) { should == seed_value.to_i }
+  end
+end

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

@@ -2,6 +2,9 @@ require 'spec_helper'
 
 describe Jasmine::Headless::Report do
   include FakeFS::SpecHelpers
+  
+  let(:report) { described_class.new(file) }
+  let(:file) { 'file' }
 
   let(:file) { 'report.txt' }
 
@@ -75,5 +78,18 @@ REPORT
       end
     end
   end
+
+  describe '#seed' do
+    subject { report.seed }
+
+    let(:seed) { stub(:seed => seed_number) }
+    let(:seed_number) { 1 }
+
+    before do
+      report.stubs(:report).returns([ seed ])
+    end
+
+    it { should == seed_number }
+  end
 end