jasmine 2.0.0.rc2 → 2.0.0.rc3

data/lib/jasmine/reporters/api_reporter.rb

@@ -1,38 +0,0 @@
-module Jasmine
-  module Reporters
-    #TODO: where does this live?
-    class ApiReporter < Struct.new(:driver, :batch_size)
-      STARTED_JS = "return jsApiReporter && jsApiReporter.started"
-      FINISHED_JS = "return jsApiReporter && jsApiReporter.finished"
-
-      def started?
-        driver.eval_js STARTED_JS
-      end
-
-      def finished?
-        driver.eval_js FINISHED_JS
-      end
-
-      def results
-        index = 0
-        spec_results = []
-
-        loop do
-          slice = get_results_slice(index)
-          spec_results << slice
-          index += batch_size
-
-          break if slice.size < batch_size
-        end
-
-        spec_results.flatten
-      end
-
-      private
-
-      def get_results_slice(index)
-        driver.eval_js("return jsApiReporter.specResults(#{index}, #{batch_size})")
-      end
-    end
-  end
-end

data/lib/jasmine/results.rb

@@ -1,38 +0,0 @@
-module Jasmine
-  class Results
-    attr_reader :results
-
-    def initialize(raw_results)
-      @results = raw_results.map {|raw| Result.new(raw) }
-    end
-
-    def failures
-      @results.select { |result|
-        result.status == "failed"
-      }
-    end
-
-    def pending_specs
-      @results.select { |result|
-        result.status == "pending"
-      }
-    end
-
-    def size
-      @results.size
-    end
-
-    class Result < OpenStruct
-      def full_name
-        fullName
-      end
-
-      def failed_expectations
-        failedExpectations.map { |e|
-          short_stack = e["stack"].split("\n").slice(0, 7).join("\n")
-          OpenStruct.new(:message => e["message"], :stack => short_stack)
-        }
-      end
-    end
-  end
-end

data/lib/jasmine/results_processor.rb

@@ -1,38 +0,0 @@
-module Jasmine
-  class ResultsProcessor
-
-    def initialize(config)
-      @config = config
-    end
-
-    def process(results_hash, suites_hash)
-      Jasmine::Results.new(results_hash, suites_hash, example_locations)
-    end
-
-    def example_locations
-      # example_locations = {}
-      # example_name_parts = []
-      # previous_indent_level = 0
-      # @config.spec_files_full_paths.each do |filename|
-        # line_number = 1
-        # File.open(filename, "r") do |file|
-          # file.readlines.each do |line|
-            # match = /^(\s*)(describe|it)\s*\(\s*["'](.*)["']\s*,\s*function/.match(line)
-             # if (match)
-               # indent_level = match[1].length / 2
-               # example_name = match[3]
-               # example_name_parts[indent_level] = example_name
-
-               # full_example_name = example_name_parts.slice(0, indent_level + 1).join(" ")
-               # example_locations[full_example_name] = "#{filename}:#{line_number}: in `it'"
-             # end
-             # line_number += 1
-          # end
-        # end
-      # end
-      # example_locations
-      {}
-    end
-
-  end
-end

data/lib/jasmine/run_specs.rb

@@ -1,33 +0,0 @@
-$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
-
-require 'rubygems'
-require 'jasmine'
-require 'rspec'
-
-Jasmine.load_configuration_from_yaml
-
-config = Jasmine.config
-
-server = Jasmine::Server.new(config.port, Jasmine::Application.app(config))
-driver = Jasmine::SeleniumDriver.new(config.browser, "#{config.host}:#{config.port}/")
-t = Thread.new do
-  begin
-    server.start
-  rescue ChildProcess::TimeoutError
-  end
-  # # ignore bad exits
-end
-t.abort_on_exception = true
-Jasmine::wait_for_listener(config.port, 'jasmine server')
-puts 'jasmine server started.'
-
-reporter = Jasmine::Reporters::ApiReporter.new(driver, config.result_batch_size)
-raw_results = Jasmine::Runners::HTTP.new(driver, reporter).run
-results = Jasmine::Results.new(raw_results)
-
-config.formatters.each do |formatter_class|
-  formatter = formatter_class.new(results)
-  formatter.format()
-end
-
-exit results.failures.size

data/lib/jasmine/runners/http.rb

@@ -1,33 +0,0 @@
-module Jasmine
-  module Runners
-    class HTTP < Struct.new(:driver, :reporter)
-      def run
-        driver.connect
-        ensure_connection_established
-        wait_for_suites_to_finish_running
-
-        results = reporter.results
-
-        driver.disconnect
-        results
-      end
-
-      private
-      
-      def ensure_connection_established
-        started = Time.now
-        until reporter.started? do
-          raise "couldn't connect to Jasmine after 60 seconds" if (started + 60 < Time.now)
-          sleep 0.1
-        end
-      end
-
-      def wait_for_suites_to_finish_running
-        puts "Waiting for suite to finish in browser ..."
-        until reporter.finished? do
-          sleep 0.1
-        end
-      end
-    end
-  end
-end

data/lib/jasmine/selenium_driver.rb

@@ -1,45 +0,0 @@
-module Jasmine
-  require 'json'
-  class SeleniumDriver
-    def initialize(browser, http_address)
-      require 'selenium-webdriver'
-
-      selenium_server = if Jasmine.config.selenium_server
-                          Jasmine.config.selenium_server
-                        elsif Jasmine.config.selenium_server_port
-                          "http://localhost:#{Jasmine.config.selenium_server_port}/wd/hub"
-                        end
-      options = if browser == 'firefox-firebug'
-                  require File.join(File.dirname(__FILE__), 'firebug/firebug')
-                  (profile = Selenium::WebDriver::Firefox::Profile.new)
-                  profile.enable_firebug
-                  {:profile => profile}
-                end || {}
-      @driver = if Jasmine.config.webdriver
-                  Jasmine.config.webdriver
-                elsif selenium_server
-                  Selenium::WebDriver.for :remote, :url => selenium_server, :desired_capabilities => browser.to_sym
-                else
-                  Selenium::WebDriver.for browser.to_sym, options
-                end
-      @http_address = http_address
-    end
-
-    def connect
-      @driver.navigate.to @http_address
-    end
-
-    def disconnect
-      @driver.quit
-    end
-
-    def eval_js(script)
-      result = @driver.execute_script(script)
-      JSON.parse("{\"result\":#{result.to_json}}", :max_nesting => false)['result']
-    end
-
-    def json_generate(obj)
-      JSON.generate(obj)
-    end
-  end
-end

data/spec/asset_expander_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Jasmine::AssetExpander do
-  it "expands asset files" do
-    bundled_asset = double(:bundled_asset, :assets => ['asset1_path', 'asset2_path'])
-    bundled_asset_factory = double(:bundled_asset_factory)
-    bundled_asset_factory.should_receive(:new).with('asset_file').and_return(bundled_asset)
-    expander = Jasmine::AssetExpander.new(bundled_asset_factory)
-    expanded_assets = expander.expand('/some_src_dir', 'asset_file')
-    expanded_assets.should == ['/asset1_path?body=true',
-                               '/asset2_path?body=true']
-  end
-end

data/spec/asset_pipeline_mapper_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Jasmine::AssetPipelineMapper do
-  it "expands asset paths if available" do
-    expander = lambda do |dir, path|
-      if dir == "/some_location/" && path == 'asset1'
-        ['asset1', 'asset2']
-      elsif dir == "/some_location/" && path == 'asset2'
-        ['asset1', 'asset3']
-      end
-
-    end
-    config = double(:config, :src_dir => "/some_location/")
-
-    mapper = Jasmine::AssetPipelineMapper.new(config, expander)
-
-    mapper.map_src_paths(['asset1', 'asset2', 'asset4']).should == ['asset1', 'asset2', 'asset3', 'asset4']
-  end
-end

data/spec/jasmine_command_line_tool_rakeless_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe "Jasmine command line tool" do
-  context "when rake has not been required yet" do
-    before :each do
-      temp_dir_before
-      Dir::chdir @tmp
-    end
-
-    after :each do
-      temp_dir_after
-    end
-
-    it "should append to an existing Rakefile" do
-      FileUtils.cp("#{@old_dir}/spec/fixture/Rakefile", @tmp)
-      output = capture_stdout { Jasmine::CommandLineTool.new.process ["init"] }
-      output.should =~ /Jasmine has been installed with example specs./
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Jasmine::Formatters::BaseFormatter do
-  it 'raises an error on summary to teach people a lesson' do
-    expect {
-      Jasmine::Formatters::BaseFormatter.new.format
-    }.to(raise_error(NotImplementedError))
-  end
-end

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

@@ -1,55 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/results_processor_spec.rb

@@ -1,3 +0,0 @@
-describe Jasmine::ResultsProcessor do
-
-end

data/spec/results_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Jasmine::Results do
-  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
-
-  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
-
-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
-