jasmine 1.3.2 → 2.0.0.rc2

data/spec/lib/jasmine/formatters/console_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Jasmine::Formatters::Console do
+  describe '#failures' do
+    it 'shows the failure messages' do
+      results = OpenStruct.new(:size => 2, :failures => [failing_result, failing_result], :pending_specs => [])
+      subject = Jasmine::Formatters::Console.new(results)
+
+      subject.failures.should match(/a suite with a failing spec/)
+      subject.failures.should match(/a failure message/)
+      subject.failures.should match(/a stack trace/)
+    end
+  end
+
+  describe '#summary' do
+    describe 'when the full suite passes' do
+      it 'shows the spec counts' do
+        results = OpenStruct.new(:size => 1, :failures => [], :pending_specs => [])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should match(/1 spec/)
+        subject.summary.should match(/0 failures/)
+      end
+
+      it 'shows the spec counts (pluralized)' do
+        results = OpenStruct.new(:size => 2, :failures => [], :pending_specs=> [])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should match(/2 specs/)
+        subject.summary.should match(/0 failures/)
+      end
+    end
+
+    describe 'when there are failures' do
+      it 'shows the spec counts' do
+        results = OpenStruct.new(:size => 2, :failures => [failing_result], :pending_specs=> [])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should match(/2 specs/)
+        subject.summary.should match(/1 failure/)
+      end
+
+      it 'shows the spec counts (pluralized)' do
+        results = OpenStruct.new(:size => 2, :failures => [failing_result, failing_result], :pending_specs=> [])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should match(/2 specs/)
+        subject.summary.should match(/2 failures/)
+      end
+    end
+
+    describe 'when there are pending specs' do
+      it 'shows the spec counts' do
+        results = OpenStruct.new(:size => 2, :failures => [failing_result], :pending_specs => [pending_result])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should match(/1 pending spec/)
+      end
+
+      it 'shows the spec counts (pluralized)' do
+        results = OpenStruct.new(:size => 2, :failures => [], :pending_specs => [pending_result, pending_result])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should match(/2 pending specs/)
+      end
+    end
+
+    describe 'when there are no pending specs' do
+
+      it 'should not mention pending specs' do
+        results = OpenStruct.new(:size => 2, :failures => [], :pending_specs => [])
+        subject = Jasmine::Formatters::Console.new(results)
+
+        subject.summary.should_not match(/pending spec[s]/)
+      end
+    end
+  end
+
+  def failing_result
+    OpenStruct.new(:full_name => 'a suite with a failing spec', :failed_expectations => [
+        OpenStruct.new(:message => 'a failure message', :stack => 'a stack trace')
+    ])
+  end
+
+  def passing_result
+    OpenStruct.new(passing_raw_result)
+  end
+
+  def pending_result
+    OpenStruct.new(pending_raw_result)
+  end
+end

data/spec/lib/jasmine/formatters/junit_xml_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'nokogiri'
+
+describe Jasmine::Formatters::JUnitXml do
+  describe '#summary' do
+    describe 'when the full suite passes' do
+      it 'shows the spec counts' do
+        results = OpenStruct.new(:size => 1, :failures => [], :pending_specs => [],
+                                 :results => [passing_result(fullName: 'Passing test', description: 'test')])
+        subject = Jasmine::Formatters::JUnitXml.new(results)
+
+        xml = Nokogiri::XML(subject.summary)
+
+        testsuite = xml.xpath('/testsuites/testsuite').first
+        testsuite['tests'].should == '1'
+        testsuite['failures'].should == '0'
+        testsuite['name'].should == 'Passing'
+
+        xml.xpath('//testcase').size.should == 1
+        xml.xpath('//testcase').first['name'].should == 'test'
+      end
+    end
+
+    describe 'when there are failures' do
+      it 'shows the spec counts' do
+        results = OpenStruct.new(:size => 2, :failures => [failing_result], :pending_specs=> [],
+                                 :results => [passing_result, failing_result])
+        subject = Jasmine::Formatters::JUnitXml.new(results)
+
+        xml = Nokogiri::XML(subject.summary)
+
+        testsuite = xml.xpath('/testsuites/testsuite').first
+        testsuite['tests'].should == '1'
+        testsuite['failures'].should == '0'
+
+        testsuite = xml.xpath('/testsuites/testsuite')[1]
+        testsuite['tests'].should == '1'
+        testsuite['failures'].should == '1'
+
+        xml.xpath('//testcase').size.should == 2
+        xml.xpath('//testcase/failure').size.should == 1
+        xml.xpath('//testcase/failure').first['message'].should == 'a failure message'
+        xml.xpath('//testcase/failure').first.content.should == 'a stack trace'
+      end
+    end
+  end
+
+  def failing_result(options = {})
+    Jasmine::Results::Result.new(failing_raw_result.merge(options))
+  end
+
+  def passing_result(options = {})
+    Jasmine::Results::Result.new(passing_raw_result.merge(options))
+  end
+end

data/spec/lib/jasmine/reporters/api_reporter_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Jasmine::Reporters::ApiReporter do
+  let(:driver) { FakeSeleniumDriver.new }
+  let(:batch_size) { 3 }
+  subject { Jasmine::Reporters::ApiReporter.new(driver, batch_size) }
+
+  describe '#started?' do
+    it "reflects that Jasmine has started" do
+      driver.should_receive(:eval_js).with(Jasmine::Reporters::ApiReporter::STARTED_JS).and_return(false)
+
+      driver.start
+
+      subject.should_not be_started
+
+      driver.should_receive(:eval_js).with(Jasmine::Reporters::ApiReporter::STARTED_JS).and_return(true)
+
+      driver.start
+
+      subject.should be_started
+    end
+  end
+
+  describe '#finished?' do
+    it "reflects that Jasmine has finished" do
+      driver.should_receive(:eval_js).with(Jasmine::Reporters::ApiReporter::FINISHED_JS).and_return(false)
+
+      subject.should_not be_finished
+
+      driver.should_receive(:eval_js).with(Jasmine::Reporters::ApiReporter::FINISHED_JS).and_return(true)
+
+      driver.finish
+
+      subject.should be_finished
+    end
+  end
+
+  describe "#results" do
+    it "gets all of the results" do
+      driver.should_receive(:eval_js).with("return jsApiReporter.specResults(0, 3)").and_return(driver.results.slice(0, 3))
+      driver.should_receive(:eval_js).with("return jsApiReporter.specResults(3, 3)").and_return(driver.results.slice(3, 4))
+
+      results = subject.results
+
+      results.size.should == 4
+      results[0]['id'].should == 1
+      results[1]['id'].should == 2
+      results[2]['id'].should == 3
+      results[3]['id'].should == 4
+    end
+  end
+
+end

data/spec/lib/jasmine/runners/http_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Jasmine::Runners::HTTP do
+  let(:driver) { FakeSeleniumDriver.new }
+  let(:batch_size) { 3 }
+  let(:reporter) { Jasmine::Reporters::ApiReporter.new(driver, batch_size) }
+  subject { Jasmine::Runners::HTTP.new(driver, reporter) }
+
+  describe '#run' do
+    it "gets the results from the Jasmine HTML page" do
+      driver.should_receive(:connect)
+      driver.should_receive(:disconnect)
+      reporter.should_receive(:results).and_return(driver.results)
+      reporter.stub(:started?).and_return(true)
+      reporter.stub(:finished?).and_return(true)
+
+      results = subject.run
+      results.size.should == 4
+    end
+  end
+end

data/spec/path_expander_spec.rb

@@ -51,6 +51,31 @@ describe Jasmine::PathExpander do
     ]
   end
 
+  it "sorts files" do
+    dir_glob = lambda do |pattern|
+      case pattern
+      when 'some_base/src0*'
+        ['some_base/src0.js']
+      when 'some_base/src1*'
+        ['some_base/src1zzz.js', 'some_base/src1.js']
+      else
+        raise "Unexpected pattern received: #{pattern}"
+      end
+    end
+
+    expanded_files = Jasmine::PathExpander.expand(
+      'some_base',
+      ['src1*', 'src0*'],
+      dir_glob
+    )
+
+    expanded_files.should == [
+      File.join('some_base', 'src1.js'),
+      File.join('some_base', 'src1zzz.js'),
+      File.join('some_base', 'src0.js')
+    ]
+  end
+
   it "supports negation of passed patterns" do
     dir_glob = lambda do |pattern|
       case pattern

data/spec/results_spec.rb

@@ -1,27 +1,69 @@
 require 'spec_helper'
 
 describe Jasmine::Results do
-  it "should be able to return suites" do
-    suites = {:some => 'suite'}
-    Jasmine::Results.new({}, suites, {}).suites.should == suites
+  describe "#failures" do
+    it "should report all the failing spec" do
+      subject = Jasmine::Results.new([failing_raw_result, failing_raw_result])
+      subject.failures.size.should == 2
+
+      subject = Jasmine::Results.new([failing_raw_result, passing_raw_result])
+      subject.failures.size.should == 1
+    end
+  end
+
+  describe "#pending_specs" do
+    it "should report all the pending specs" do
+      subject = Jasmine::Results.new([pending_raw_result, pending_raw_result])
+      subject.pending_specs.size.should == 2
+
+      subject = Jasmine::Results.new([pending_raw_result, passing_raw_result])
+      subject.pending_specs.size.should == 1
+    end
   end
 
-  it "should return a result for a particular spec id" do
-    result1 = {:some => 'result'}
-    result2 = {:some => 'other result'}
-    raw_results = {'1' => result1, '2' => result2 }
-    results = Jasmine::Results.new(raw_results, {}, {})
-    results.for_spec_id('1').should == result1
-    results.for_spec_id('2').should == result2
+  describe "#size" do
+    it "should report the spec count" do
+      subject = Jasmine::Results.new([failing_raw_result, failing_raw_result])
+      subject.size.should == 2
+
+      subject = Jasmine::Results.new([failing_raw_result])
+      subject.size.should == 1
+    end
   end
 
-  it "should return an example location for a particular string" do
-    example_location1 = {:some => 'spec location'}
-    example_location2 = {:some => 'other spec location'}
-    example_locations = {'foo bar' => example_location1, 'baz quux' => example_location2 }
-    results = Jasmine::Results.new({}, {}, example_locations)
-    results.example_location_for('foo bar').should == example_location1
-    results.example_location_for('baz quux').should == example_location2
+end
+
+describe Jasmine::Results::Result do
+  describe "data accessors" do
+    it "delegates to raw results" do
+      result = Jasmine::Results::Result.new("status" => "failed")
+      result.status.should == "failed"
+    end
+
+    it "remaps important camelCase names to snake_case" do
+      result = Jasmine::Results::Result.new(failing_raw_result)
+      result.full_name.should == "a suite with a failing spec"
+    end
+
+    it "exposes failed expectations" do
+      result = Jasmine::Results::Result.new(failing_raw_result)
+
+      expectation = result.failed_expectations[0]
+      expectation.message.should == "a failure message"
+      expectation.stack.should == "a stack trace"
+    end
+
+    it "exposes only the last 7 lines of the stack trace" do
+      raw_result = failing_raw_result
+      raw_result["failedExpectations"][0]["stack"] = "1\n2\n3\n4\n5\n6\n7\n8\n9"
+
+      result = Jasmine::Results::Result.new(raw_result)
+      expectation = result.failed_expectations[0].stack
+      expectation.should match(/1/)
+      expectation.should match(/7/)
+      expectation.should_not match(/8/)
+      expectation.should_not match(/9/)
+    end
   end
 end
 

data/spec/spec_helper.rb

@@ -1,28 +1,19 @@
-require "rubygems"
-require "bundler"
+require 'rubygems'
+require 'bundler'
 require 'stringio'
 require 'tmpdir'
 
 envs = [:default, :development]
-envs << :debug if ENV["DEBUG"]
+envs << :debug if ENV['DEBUG']
 Bundler.setup(*envs)
 
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "../lib")))
-require "jasmine"
-
-if Jasmine::Dependencies.rspec2?
-  require 'rspec'
-else
-  require 'spec'
-end
-
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../lib')))
+require 'jasmine'
+require 'rspec'
+require 'support/fake_selenium_driver'
 
 def create_rails(name)
-  if Jasmine::Dependencies.rails3?
-    `rails new #{name}`
-  else
-    `rails #{name}`
-  end
+  `rails new #{name}`
 end
 
 def create_temp_dir
@@ -33,7 +24,7 @@ def create_temp_dir
 end
 
 def temp_dir_before
-  @root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  @root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
   @old_dir = Dir::pwd
   @tmp = create_temp_dir
 end
@@ -53,3 +44,30 @@ module Kernel
     $stdout = STDOUT
   end
 end
+
+def passing_raw_result
+  raw_result('passed', {fullName: 'Passing test', description: 'Passing'})
+end
+
+def pending_raw_result
+  raw_result('pending', {fullName: 'Passing test', description: 'Passing'})
+end
+
+def failing_raw_result
+  raw_result('failed', {
+      'id' => 124,
+      'description' => 'a failing spec',
+      'fullName' => 'a suite with a failing spec',
+      'failedExpectations' => [
+          {
+              'message' => 'a failure message',
+              'stack' => 'a stack trace'
+          }
+      ]
+  })
+end
+
+def raw_result(status, options = {})
+  {'status' => status}.merge(options)
+end
+

data/spec/support/fake_selenium_driver.rb

@@ -0,0 +1,35 @@
+class FakeSeleniumDriver
+  attr_reader :results
+
+  def initialize
+    @state = :stopped
+    @results = [ {'id' => 1}, {'id' => 2}, {'id' => 3}, {'id' => 4} ]
+  end
+
+  def eval_js(str)
+
+    case str
+      when Jasmine::Reporters::ApiReporter::STARTED_JS
+        @state == :started
+      when Jasmine::Reporters::ApiReporter::FINISHED_JS
+        @state == :finished
+      else
+        # TODO: When we drop support for Ruby < 1.9, USE NAMED CAPTURES HEYAH
+        if matches = /specResults\((\d+), (\d+)\)/.match(str)
+          length = matches[1]
+          index = matches[2]
+          slice = @results.slice(length.to_i, length.to_i + index.to_i)
+
+          slice.nil? ? [] : slice
+        end
+    end
+  end
+
+  def start
+    @state = :started
+  end
+
+  def finish
+    @state = :finished
+  end
+end