jasmine-headless-webkit-firstbanco 0.9.0.rc.2

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

@@ -0,0 +1,35 @@
+describe 'jasmine.HeadlessReporter.ConsoleBase', ->
+  reporter = null
+
+  beforeEach ->
+    reporter = new jasmine.HeadlessReporter.ConsoleBase()
+
+  describe '#formatResultLine', ->
+    context 'length = 1', ->
+      it 'should format', ->
+        reporter.length = 1
+        expect(reporter.formatResultLine(0)).toMatch(/test,/)
+
+    context 'length != 1', ->
+      it 'should format', ->
+        reporter.length = 2
+        expect(reporter.formatResultLine(0)).toMatch(/tests,/)
+
+    context 'failedCount = 1', ->
+      it 'should format', ->
+        reporter.failedCount = 1
+        expect(reporter.formatResultLine(0)).toMatch(/failure,/)
+
+    context 'failedCount != 1', ->
+      it 'should format', ->
+        reporter.failedCount = 0
+        expect(reporter.formatResultLine(0)).toMatch(/failures,/)
+
+    context 'runtime = 1', ->
+      it 'should format', ->
+        expect(reporter.formatResultLine(1)).toMatch(/sec./)
+
+    context 'runtime != 1', ->
+      it 'should format', ->
+        expect(reporter.formatResultLine(0)).toMatch(/secs./)
+

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

@@ -0,0 +1,3 @@
+describe 'jasmine.HeadlessReporter.Console', ->
+  describe '#reportSpecResults', ->
+

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

@@ -0,0 +1,9 @@
+src_files:
+  - '**/*'
+
+spec_files: [ '**/*_spec.coffee' ]
+src_dir: vendor/assets/javascripts
+spec_dir: spec/javascripts
+helpers:
+  - 'helpers/**.*'
+

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

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::CacheableAction do
+  include FakeFS::SpecHelpers
+
+  let(:file) { 'dir/file.whatever' }
+  let(:data) { 'data' }
+  let(:compiled) { 'compiled' }
+
+  before do
+    FileUtils.mkdir_p File.dirname(file)
+
+    File.open(file, 'wb') { |fh| fh.print(data) }
+
+    described_class.cache_dir = cache_dir
+    described_class.cache_type = cache_type
+  end
+
+  let(:action_runs!) do
+    described_class.any_instance.expects(:action).returns(compiled)
+  end
+
+  let(:cache_type) { 'action' }
+  let(:cache_dir) { 'cache' }
+  let(:cache_file) { File.join(cache_dir, cache_type, file) + '.js' }
+  let(:cache_file_data) { YAML.load(File.read(cache_file)) }
+
+  let(:cache_object) { described_class.new(file) }
+
+  describe '.for' do
+    context 'cache disabled' do
+      before do
+        described_class.enabled = false
+      end
+
+      it 'should compile' do
+        action_runs!
+        described_class.for(file).should == compiled
+        cache_file.should_not be_a_file
+
+        cache_object.should_not be_cached
+      end
+    end
+
+    context 'cache enabled' do
+      before do
+        described_class.enabled = true
+        FileUtils.mkdir_p(cache_dir)
+
+        File.stubs(:mtime).with(file).returns(Time.at(10))
+        File.stubs(:mtime).with(File.expand_path(cache_file)).returns(Time.at(cache_file_mtime))
+      end
+
+      context 'cache empty' do
+        let(:cache_file_mtime) { 0 }
+
+        it 'should compile' do
+          action_runs!
+          described_class.for(file).should == compiled
+
+          cache_file_data.should == compiled
+          cache_object.should be_cached
+        end
+      end
+
+      context 'cache fresh' do
+        let(:cache_file_mtime) { 15 }
+
+        before do
+          FileUtils.mkdir_p File.split(cache_file).first
+          File.open(cache_file, 'wb') { |fh| fh.print compiled }
+        end
+
+        it 'should not compile' do
+          action_runs!.never
+
+          described_class.for(file).should == compiled
+
+          cache_file_data.should == compiled
+          cache_object.should be_cached
+        end
+      end
+
+      context 'cache stale' do
+        let(:cache_file_mtime) { 5 }
+
+        it 'should compile' do
+          action_runs!
+
+          described_class.for(file).should == compiled
+
+          cache_file_data.should == compiled
+          cache_object.should be_cached
+        end
+      end
+    end
+  end
+
+  describe '#relative_cache_file' do
+    context 'file is an absolute windows file' do
+      let(:current_path) { 'C:/path' }
+      let(:filename) { "file.coffee" }
+      let(:windows_path) { File.join(current_path, filename) }
+      let(:cache_dir) { 'cache dir' }
+      let(:cache_type) { 'cache type' }
+
+      before do
+        cache_object.stubs(:file).returns(windows_path)
+
+        described_class.stubs(:cache_dir).returns(cache_dir)
+        described_class.stubs(:cache_type).returns(cache_type)
+
+        Dir.stubs(:pwd).returns(current_path)
+      end
+
+      subject { cache_object.relative_cache_file }
+
+      it { should == File.join(cache_dir, cache_type, filename) }
+    end
+  end
+end
+

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::CoffeeScriptCache do
+  include FakeFS::SpecHelpers
+
+  describe '#action' do
+    let(:file) { 'file' }
+    let(:data) { 'data' }
+    let(:compiled) { 'compiled' }
+
+    before do
+      CoffeeScript.expects(:compile).with(data).returns(compiled)
+      File.open(file, 'wb') { |fh| fh.print(data) }
+    end
+
+    it 'should compile coffeescript' do
+      described_class.new(file).action.should == compiled
+    end
+  end
+end
+

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::CoffeeTemplate do
+  let(:data) { 'data' }
+  let(:path) { 'path.coffee' }
+
+  let(:template) { described_class.new(path) { data } }
+
+  subject { template.render }
+
+  let(:handle_expectation) { Jasmine::Headless::CoffeeScriptCache.any_instance.stubs(:handle) }
+
+  context 'compilation error' do
+    let(:error) { CoffeeScript::CompilationError.new("fail") }
+
+    before do
+      handle_expectation.raises(error)
+    end
+
+    it 'should pass along the error' do
+      expect { subject }.to raise_error(CoffeeScript::CompilationError)
+    end
+  end
+
+  context 'compiles fine' do
+    let(:source) { 'source' }
+
+    before do
+      Jasmine::Headless::CoffeeScriptCache.any_instance.stubs(:cached?).returns(cache_return)
+      handle_expectation.returns(source)
+    end
+
+    context 'cached' do
+      let(:file_path) { 'dir/file.js' }
+      let(:cache_return) { true }
+
+      before do
+        Jasmine::Headless::CoffeeScriptCache.any_instance.stubs(:cache_file).returns(file_path)
+      end
+
+      it 'should return the cached file' do
+        subject.should include(%{<script type="text/javascript" src="#{file_path}"></script>})
+      end
+    end
+
+    context 'not cached' do
+      let(:cache_return) { false }
+
+      it 'should return the generated js' do
+        subject.should include(%{<script type="text/javascript">#{source}</script>})
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::CSSTemplate do
+  include FakeFS::SpecHelpers
+
+  let(:template) { described_class.new(file) { data } }
+  let(:file) { 'file' }
+  let(:data) { 'data' }
+
+  subject { template.render }
+
+  before do
+    File.open(file, 'wb') if file
+  end
+
+  context "no file'" do
+    let(:file) { nil }
+
+    it { should == data }
+  end
+
+  context 'file' do
+    it { should == %{<link rel="stylesheet" href="#{file}" type="text/css" />} }
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::FileChecker do
+  let(:test_class) do
+    object = Object.new
+    object.class.send(:include, Jasmine::Headless::FileChecker)
+    object
+  end
+
+  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
+
+    context 'allowed format' do
+      let(:file) { 'foobar.js' }
+
+      it { should be_false }
+    end
+
+    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

@@ -0,0 +1,194 @@
+require 'spec_helper'
+require 'fakefs/spec_helpers'
+require 'coffee-script'
+
+describe Jasmine::Headless::FilesList do
+  let(:files_list) { described_class.new }
+
+  describe '#initialize' do
+    before do
+      described_class.any_instance.stubs(:load_initial_assets)
+    end
+
+    describe '#spec_file_line_numbers' do
+      include FakeFS::SpecHelpers
+
+      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 '#search_paths' do
+      let(:files_list) { described_class.new(:config => config) }
+
+      let(:config) { {
+        'src_dir' => src_dir,
+        'spec_dir' => spec_dir,
+        'asset_paths' => asset_paths
+      } }
+
+      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
+
+      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(src_dir), File.expand_path(spec_dir) ]
+        end
+      end
+
+      context 'vendored gem paths' do
+        before do
+          Jasmine::Headless::FilesList.stubs(:asset_paths).returns([ path ])
+        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) ]
+        end
+      end
+
+      context 'multiple dirs' do
+        let(:dir_1) { 'dir 1' }
+        let(:dir_2) { 'dir 2' }
+
+        context 'src_dir is an array' do
+          let(:src_dir) { [ dir_1, dir_2 ] }
+
+          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
+
+        context 'asset_paths has entries' do
+          let(:src_dir) { dir_1 }
+          let(:asset_paths) { [ dir_2 ] }
+
+          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
+
+    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 ] ) }
+
+      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) }
+
+      before do
+        files_list.stubs(:required_files).returns(Jasmine::Headless::UniqueAssetList.new([ file_one, file_two ]))
+      end
+
+      subject { files_list.files }
+
+      it { should == [ path_one, path_two, path_three ] }
+    end
+
+    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' }
+
+      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 ])
+      end
+
+      subject { files_list.filtered_files }
+
+      context 'empty filter' do
+        before do
+          files_list.stubs(:spec_filter).returns([])
+        end
+
+        it { should == [ file_one, file_two, file_three, file_four ] }
+      end
+
+      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
+
+    describe '#add_files' do
+      let(:files_list) { described_class.new(:seed => 100) }
+
+      let(:dir) { 'tmp' }
+
+      before do
+        FileUtils.mkdir_p dir
+
+        10.times do |index|
+          File.open(File.join(dir, "file-#{index}.js"), 'wb')
+        end
+
+        File.open(File.join(dir, 'file.js.erb'), 'wb')
+      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}
+
+        FileUtils.rm_rf dir
+      end
+
+      it 'should not load an excluded format' do
+        files_list.files.any? { |file| file['.erb'] }.should be_false
+      end
+    end
+
+    describe "#register_engine!" do
+
+      before(:each) do
+        Jasmine::Headless::FilesList.reset!
+      end
+
+      it "should register code added via configure blocks" do
+        template_class = mock()
+        described_class.register_engine ".foo", template_class
+        Sprockets.expects(:register_engine).with(".foo", template_class)
+        described_class.new
+      end
+
+    end
+  end
+end
+