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

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::JSTemplate 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 == %{<script type="text/javascript" src="#{file}"></script>} }
+  end
+
+  context 'script as first thing' do
+    let(:data) { '<script type="text/javascript"' }
+
+    it { should == data }
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::JSTTemplate do
+  include FakeFS::SpecHelpers
+
+  let(:template) { described_class.new(file) }
+  let(:file) { 'file' }
+  let(:data) { 'data' }
+
+  let(:context) { stub(:logical_path => 'path') }
+
+  before do
+    File.open(file, 'wb') { |fh| fh.print data }
+  end
+
+  subject { template.render(context) }
+
+  it { should include(%{<script type="text/javascript">}) }
+  it { should include(data) }
+end
+

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::NilTemplate do
+  include FakeFS::SpecHelpers
+
+  let(:template) { described_class.new(file) { data } }
+  let(:file) { 'file' }
+  let(: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 == '' }
+  end
+
+  context 'script as first thing' do
+    let(:data) { '' }
+
+    it { should == data }
+  end
+end

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

@@ -0,0 +1,194 @@
+require 'spec_helper'
+require 'jasmine/headless/options'
+require 'fakefs/spec_helpers'
+
+describe Jasmine::Headless::Options do
+  let(:options) { Jasmine::Headless::Options.new(opts) }
+  let(:opts) { {} }
+
+  describe '#initialize' do
+    let(:default_config) {  'spec/javascripts/support/jasmine.yml' }
+
+    context 'empty' do
+      it "should have default options" do
+        options[:jasmine_config].should == default_config
+      end
+    end
+    
+    context 'with provided' do
+      let(:opts) { { :jasmine_config => 'test' } }
+
+      it 'should override an option' do
+        options[:jasmine_config].should == 'test'
+      end
+    end
+    
+    context 'with nil provided' do
+      let(:opts) { { :jasmine_config => nil } }
+
+      it 'should override an option' do
+        options[:jasmine_config].should == default_config
+      end
+    end
+  end
+
+  describe '#process_option' do
+    it 'should process the option and update the object in place' do
+      options[:colors].should be_false
+      options[:jasmine_config].should == 'spec/javascripts/support/jasmine.yml'
+
+      options.process_option('--colors')
+      options.process_option('-j', 'test')
+
+      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
+    include FakeFS::SpecHelpers
+
+    let(:global_test_data) { '--colors' }
+    let(:test_data) { '-j test' }
+
+    before do
+      FileUtils.mkdir_p File.split(Jasmine::Headless::Options::GLOBAL_DEFAULTS_FILE).first
+      FileUtils.mkdir_p File.split(Jasmine::Headless::Options::DEFAULTS_FILE).first
+
+      File.open(Jasmine::Headless::Options::GLOBAL_DEFAULTS_FILE, 'w') { |fh| fh.puts global_test_data }
+      File.open(Jasmine::Headless::Options::DEFAULTS_FILE, 'w') { |fh| fh.puts test_data }
+    end
+
+    it "should read the options" do
+      options[:colors].should be_true
+      options[:jasmine_config].should == 'test'
+    end
+  end
+
+  describe '.from_command_line' do
+    before do
+      @argv = ARGV.dup
+    end
+
+    let(:options) { described_class.from_command_line }
+
+    context 'no files specified' do
+      before do
+        ARGV.replace([])
+      end
+
+      it 'should have no files' do
+        options[:files].should == []
+      end
+    end
+
+    context 'files specified' do
+      before do
+        ARGV.replace([ "test" ])
+      end
+
+      it 'should have files' do
+        options[:files].should == [ "test" ]
+      end
+    end
+
+    context 'specify no seed' do
+      it 'should have a seed' do
+        options[:seed].should_not be_nil
+      end
+    end
+
+    context 'specify random order seed' do
+      let(:seed) { 12345 }
+
+      before do
+        ARGV.replace([ "--seed", seed ])
+      end
+
+      it 'should specify the seed' do
+        options[:seed].should == seed
+      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_message/spec_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::ReportMessage::Spec do
+  subject { spec }
+
+  context 'with filename' do
+    let(:filename) { 'file.js' }
+    let(:spec) { described_class.new("Test", "#{filename}:23") }
+
+    its(:filename) { should == filename }
+  end
+
+  context 'without filename' do
+    let(:filename) { 'file.js' }
+    let(:spec) { described_class.new("Test", "") }
+
+    its(:filename) { should be_nil }
+  end
+end
+

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Jasmine::Headless::Report do
+  include FakeFS::SpecHelpers
+  
+  let(:report) { described_class.new(file) }
+  let(:file) { 'file' }
+
+  let(:file) { 'report.txt' }
+
+  describe '.load' do
+    let(:report) { described_class.load(file) }
+
+    context 'no file' do
+      it 'should raise an exception' do
+        expect { report }.to raise_error(Errno::ENOENT)
+      end
+    end
+
+    context 'file' do
+      before do
+        File.open(file, 'wb') { |fh| fh.puts <<-REPORT }
+PASS||Statement||One||file.js:23
+FAIL||Statement||Two||file2.js:23
+FAIL||Statement||Three||file2.js:23
+CONSOLE||Yes
+ERROR||Uh oh||file3.js:23
+TOTAL||1||2||3||T
+REPORT
+      end
+
+      it 'should read the report file' do
+        report.length.should == 6
+
+        report[0].should == Jasmine::Headless::ReportMessage::Pass.new("Statement One", "file.js:23")
+        report[1].should == Jasmine::Headless::ReportMessage::Fail.new("Statement Two", "file2.js:23")
+        report[2].should == Jasmine::Headless::ReportMessage::Fail.new("Statement Three", "file2.js:23")
+        report[3].should == Jasmine::Headless::ReportMessage::Console.new("Yes")
+        report[4].should == Jasmine::Headless::ReportMessage::Error.new("Uh oh", "file3.js:23")
+        report[5].should == Jasmine::Headless::ReportMessage::Total.new(1, 2, 3, true)
+
+        report.total.should == 1
+        report.failed.should == 2
+        report.should have_used_console
+        report.time.should == 3.0
+
+        report.should be_valid
+
+        report.should have_failed_on("Statement Two")
+        report.failed_files.should == [ 'file2.js' ]
+      end
+    end
+
+    context 'nil filed file' do
+      before do
+        File.open(file, 'wb') { |fh| fh.puts <<-REPORT }
+FAIL||Statement||Two||
+TOTAL||1||2||3||T
+REPORT
+      end
+
+      it 'should read the report file' do
+        report.failed_files.should == []
+      end
+    end
+
+    context 'multi line console' do
+      before do
+        File.open(file, 'wb') { |fh| fh.puts <<-REPORT }
+CONSOLE||test
+test2
+TOTAL||1||2||3||T
+REPORT
+      end
+
+      it 'should read the report file' do
+        report[0].should == Jasmine::Headless::ReportMessage::Console.new("test\ntest2")
+      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
+

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

@@ -0,0 +1,247 @@
+require 'spec_helper'
+require 'fakefs/spec_helpers'
+require 'jasmine/headless/runner'
+
+describe Jasmine::Headless::Runner do
+  let(:runner) { Jasmine::Headless::Runner.new(options) }
+  let(:options) { Jasmine::Headless::Options.new(opts) }
+
+  describe '#initialize' do
+    let(:opts) { { :test => 'test', :jasmine_config => nil } }
+
+    it 'should have default options' do
+      runner.options[:test].should == 'test'
+      runner.options[:jasmine_config].should == 'spec/javascripts/support/jasmine.yml'
+    end
+
+    it 'should have a template writer' do
+      runner.template_writer.should be_a_kind_of(Jasmine::Headless::TemplateWriter)
+      runner.template_writer.runner.should == runner
+    end
+  end
+
+  describe '#load_config' do
+    include FakeFS::SpecHelpers
+
+    let(:runner_filename) { 'ext/jasmine-webkit-specrunner/jasmine-webkit-specrunner' }
+
+    before do
+      FileUtils.mkdir_p File.split(runner_filename).first
+
+      File.open(runner_filename, 'w')
+    end
+
+    let(:config_filename) { 'test.yml' }
+    let(:opts) { { :jasmine_config => config_filename } }
+
+    context 'file exists' do
+      before do
+        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
+      it 'should raise an exception' do
+        expect { runner.jasmine_config }.to raise_error(Jasmine::Headless::JasmineConfigNotFound, /#{config_filename}/)
+      end
+    end
+  end
+
+  describe '#jasmine_command' do
+    subject { runner.jasmine_command(target) }
+
+    let(:target) { 'target' }
+
+    let(:options) { {} }
+    let(:reporters) { [] }
+
+    before do
+      runner.stubs(:options).returns(options)
+      options.stubs(:file_reporters).returns(reporters)
+    end
+
+    def self.it_should_have_basics
+      it { should include(target) }
+    end
+
+    context 'colors' do
+      before do
+        options[:colors] = true
+      end
+
+      it_should_have_basics
+      it { should include('-c') }
+    end
+
+    context 'reporters' do
+      let(:reporter) { [ 'Reporter', 'identifier', file ] }
+      let(:reporters) { [ reporter ] }
+
+      let(:file) { 'file' }
+
+      it_should_have_basics
+      it { should include("-r #{file}") }
+    end
+
+    context 'quiet' do
+      before do
+        options[:quiet] = true
+      end
+
+      it_should_have_basics
+      it { should include("-q") }
+    end
+  end
+
+  describe '#runner_filename' do
+    let(:runner_filename) { runner.runner_filename }
+    let(:yaml_output) { 'yaml output' }
+
+    context 'not in options' do
+      let(:opts) { { :runner_output_filename => false } }
+
+      context 'not in yaml file' do
+        before do
+          runner.stubs(:jasmine_config).returns('runner_output' => '')
+        end
+
+        it 'should reverse the remove_html_file option' do
+          runner_filename.should == false
+        end
+      end
+
+      context 'in yaml file' do
+        before do
+          runner.stubs(:jasmine_config).returns('runner_output' => yaml_output)
+        end
+
+        it 'should use the yaml file definition' do
+          runner_filename.should == yaml_output
+        end
+      end
+    end
+    
+    context 'in options' do
+      let(:filename) { 'filename.html' }
+      let(:opts) { { :runner_output_filename => filename } }
+
+      context 'not in yaml file' do
+        before do
+          runner.stubs(:jasmine_config).returns('runner_output' => '')
+        end
+
+        it 'should reverse the remove_html_file option' do
+          runner.runner_filename.should == filename
+        end
+      end
+
+      context 'in yaml file' do
+        before do
+          runner.stubs(:jasmine_config).returns('runner_output' => yaml_output)
+        end
+
+        it 'shoulduse the command line filename' do
+          runner.runner_filename.should == filename
+        end
+      end
+    end
+  end
+
+  describe '#jasmine_config' do
+    let(:opts) { {} }
+
+    before do
+      runner.stubs(:jasmine_config_data).returns('spec_files' => nil)
+    end
+
+    it 'should not merge in things with nil values' 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