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

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::SpecFileAnalyzer do
+
+  let(:file) { 'file' }
+  let(:analyzer) { described_class.new(file) }
+
+  describe '#action' do
+    let(:line_numbers) do
+      analyzer.action
+    end
+
+    context 'fake files' do
+      include FakeFS::SpecHelpers
+
+      before do
+        File.open(file, 'wb') { |fh| fh.print file_data }
+      end
+
+      context 'coffeescript' do
+        let(:file_data) do
+          <<-SPEC
+  describe 'test', ->
+    context 'yes', ->
+      it 'should do something', ->
+        "yes"
+  SPEC
+        end
+
+        it 'should get the line numbers' do
+          line_numbers['test'].should == [ 1 ]
+          line_numbers['yes'].should == [ 2 ]
+          line_numbers['should do something'].should == [ 3 ]
+        end
+      end
+
+      context 'javascript' do
+        let(:file_data) do
+          <<-SPEC
+  describe('test', function() {
+    context('yes', function() {
+      it('should do something', function() {
+
+      });
+    });
+  });
+  SPEC
+        end
+
+        it 'should get the line numbers' do
+          line_numbers['test'].should == [ 1 ]
+          line_numbers['yes'].should == [ 2 ]
+          line_numbers['should do something'].should == [ 3 ]
+        end
+      end
+    end
+
+    context 'utf 8' do
+      let(:analyzer) { described_class.new('spec/files/UTF-8-test.txt') }
+      let(:file_data) { '' }
+
+      it 'should not explode' do
+        line_numbers
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'fakefs/spec_helpers'
+require 'jasmine/headless/task'
+require 'mocha'
+
+describe Jasmine::Headless::Task do
+  before do
+    Jasmine::Headless::Task.any_instance.stubs(:desc)
+    Jasmine::Headless::Task.any_instance.stubs(:task)
+  end
+
+  after do
+    Object.send(:remove_const, :Rails) if defined?(Rails)
+  end
+
+  describe 'define task' do
+    context 'without Rails' do
+      it 'should not explode when Rails is undefined' do
+        Jasmine::Headless::Task.new('jasmine:headless')
+      end
+    end
+
+    context 'with Rails' do
+      context 'without version' do
+        before do
+          module Rails
+            def self.version
+              return "0"
+            end
+          end
+        end
+
+        it 'should be OK if rails is defined' do
+          Jasmine::Headless::Task.new('jasmine:headless')
+        end
+      end
+
+      context 'with version' do
+        before do
+          module Rails
+            def self.version
+              return "0"
+            end
+          end
+        end
+
+        it 'should be OK if rails is defined' do
+          Jasmine::Headless::Task.new('jasmine:headless')
+        end
+      end
+    end
+  end
+
+  describe 'jasmine:headless integration test' do
+    context 'with successful test' do
+      let(:test) do
+        described_class.new do |t|
+          t.jasmine_config = "spec/jasmine/success/success.yml"
+        end
+      end
+
+      it 'should do nothing on success' do
+        expect { test.send(:run_rake_task) }.to_not raise_error
+      end
+    end
+
+    context 'with failing test' do
+      let(:test) do
+        described_class.new do |t|
+          t.jasmine_config = "spec/jasmine/failure/failure.yml"
+        end
+      end
+
+      it 'should raise an exception on failure' do
+        expect { test.send(:run_rake_task) }.to raise_error(Jasmine::Headless::TestFailure)
+      end
+    end
+
+    context 'with console.log using test' do
+      let(:test) do
+        described_class.new do |t|
+          t.jasmine_config = "spec/jasmine/console_log/console_log.yml"
+        end
+      end
+
+      it 'should raise an exception on console.log usage' do
+        expect { test.send(:run_rake_task) }.to raise_error(Jasmine::Headless::ConsoleLogUsage)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'fakefs/spec_helpers'
+
+describe Jasmine::Headless::TemplateWriter do
+  let(:runner) { stub }
+  let(:template_writer) { described_class.new(runner) }
+
+  describe '#all_tests_filename' do
+    let(:all_tests_filename) { template_writer.all_tests_filename }
+
+    context 'runner does not care about filename' do
+      before do
+        runner.stubs(:runner_filename).returns(false)
+      end
+
+      it 'should use a specrunner.html file' do
+        all_tests_filename.should_not include('tmp')
+        all_tests_filename.should include('jhw')
+        all_tests_filename.should include('.html')
+      end
+    end
+
+    context 'runner cares about filename' do
+      let(:filename) { 'filename.html' }
+
+      before do
+        runner.stubs(:runner_filename).returns(filename)
+      end
+
+      it 'should use a specrunner.html file' do
+        all_tests_filename.should == filename
+      end
+    end
+  end
+
+  describe '#filtered_tests_filename' do
+    before do
+      template_writer.stubs(:all_tests_filename).returns("test.html")
+    end
+
+    it 'should filter the filename for all tests' do
+      template_writer.filtered_tests_filename.should == 'test.filter.html'
+    end
+  end
+
+  describe '#render' do
+    subject { template_writer.render }
+
+    let(:all_files) { 'all files' }
+    let(:template) { 'template' }
+
+    before do
+      template_writer.stubs(:all_files).returns(all_files)
+
+      template_writer.expects(:template_for).with(all_files).returns(template)
+    end
+
+    it { should == template }
+  end
+
+  describe '#all_files' do
+    subject { template_writer.all_files }
+
+    let(:files_list) { stub }
+    let(:files) { 'files' }
+
+    before do
+      template_writer.stubs(:files_list).returns(files_list)
+
+      files_list.stubs(:files_to_html).returns(files)
+    end
+
+    it { should == files }
+  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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::UniqueAssetList do
+  let(:list) { described_class.new }
+
+  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)
+  end
+
+  it 'should not add the same asset with the same logical path twice' do
+    list << first
+    list << second
+    list << third
+
+    list.to_a.should == [ first, second ]
+  end
+end
+

data/spec/lib/jasmine/headless_spec.rb

@@ -0,0 +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/lib/qt/qmake_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'qt/qmake'
+require 'rbconfig'
+require 'rubygems/version'
+
+describe Qt::Qmake do
+  describe '.make_installed?' do
+    subject { described_class }
+
+    before do
+      Qt::Qmake.stubs(:make_path).returns(path)
+    end
+
+    context 'not installed' do
+      let(:path) { nil }
+
+      it { should_not be_make_installed }
+    end
+
+    context 'installed' do
+      let(:path) { '/here/there/make' }
+
+      it { should be_make_installed }
+    end
+  end
+
+  describe '.installed?' do
+    subject { described_class }
+
+    before do
+      Qt::Qmake.stubs(:path).returns(path) 
+    end
+
+    context 'not installed' do
+      let(:path) { nil }
+
+      it { should_not be_installed }
+    end
+
+    context 'installed' do
+      let(:path) { '/here/there/qmake' }
+
+      it { should be_installed }
+    end
+  end
+
+  describe '.command' do
+    subject { described_class.command }
+
+    before do
+      Qt::Qmake.stubs(:platform).returns(platform)
+      Qt::Qmake.stubs(:path).returns("qmake")
+    end
+
+    context 'linux' do
+      let(:platform) { :linux }
+
+      it { should =~ /^qmake/ }
+      it { should =~ /-spec linux-g\+\+$/ }
+    end
+
+    context 'mac os x' do
+      let(:platform) { :mac_os_x }
+
+      it { should =~ /^qmake/ }
+      it { should =~ /-spec macx-g\+\+$/ }
+    end
+  end
+
+  describe '.best_qmake' do
+    before do
+      Qt::Qmake.stubs(:get_exe_path).with('qmake-qt4').returns(path_one)
+      Qt::Qmake.stubs(:get_exe_path).with('qmake').returns(path_two)
+
+      Qt::Qmake.stubs(:qt_version_of).with(path_one).returns(Gem::Version.create(version_one))
+      Qt::Qmake.stubs(:qt_version_of).with(path_two).returns(Gem::Version.create(version_two))
+    end
+
+    subject { described_class.best_qmake }
+
+    let(:path_one) { nil }
+    let(:path_two) { nil }
+    let(:version_one) { nil }
+    let(:version_two) { nil }
+
+    context 'nothing found' do
+      it { should be_nil }
+    end
+
+    context 'one found' do
+      let(:path_one) { 'one' }
+
+      context 'not good' do
+        let(:version_one) { '4.5' }
+
+        it { should be_nil }
+      end
+
+      context 'good' do
+        let(:version_one) { '4.7' }
+
+        it { should == path_one }
+      end
+    end
+
+    context 'two found' do
+      let(:path_one) { 'one' }
+      let(:path_two) { 'two' }
+
+      context 'neither good' do
+        let(:version_one) { '4.5' }
+        let(:version_two) { '4.5' }
+
+        it { should be_nil }
+      end
+
+      context 'one good' do
+        let(:version_one) { '4.7' }
+        let(:version_two) { '4.5' }
+
+        it { should == path_one }
+      end
+
+      context 'both good' do
+        context 'one better' do
+          let(:version_one) { '4.7' }
+          let(:version_two) { '4.8' }
+
+          it { should == path_two }
+        end
+
+        context 'both same' do
+          let(:version_one) { '4.7' }
+          let(:version_two) { '4.7' }
+
+          it { should == path_one }
+        end
+      end
+    end
+  end
+end
+