jasmine-multi_json 1.3.1.1

data/spec/jasmine_rails3_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+if Jasmine::Dependencies.rails3?
+
+  describe "A Rails 3 app" do
+
+    before :each do
+      temp_dir_before
+      Dir::chdir @tmp
+
+      create_rails 'rails-example'
+      Dir::chdir 'rails-example'
+      open('Gemfile', 'a') { |f| f.puts "gem \"jasmine\", \"#{Jasmine::VERSION}\"" }
+    end
+
+    after :each do
+      temp_dir_after
+    end
+
+    context "when Jasmine has been required" do
+      it "should show the Jasmine generators" do
+        output = `rails g`
+        output.should include("jasmine:install")
+        output.should include("jasmine:examples")
+      end
+
+      it "should show jasmine:install help" do
+        output = `rails g jasmine:install --help`
+        output.should include("rails generate jasmine:install")
+      end
+
+      it "should have the jasmine rake task" do
+        output = `rake -T`
+        output.should include("jasmine ")
+      end
+
+      it "should have the jasmine:ci rake task" do
+        output = `rake -T`
+        output.should include("jasmine:ci")
+      end
+
+      context "and then installed" do
+        before :each do
+          @output = `rails g jasmine:install`
+        end
+
+        it "should have the Jasmine config files" do
+          @output.should include("create")
+
+          File.exists?("spec/javascripts/helpers/.gitkeep").should == true
+          File.exists?("spec/javascripts/support/jasmine.yml").should == true
+        end
+      end
+
+      context "and the jasmine examples have been installed" do
+        it "should find the Jasmine example files" do
+          output = `rails g jasmine:examples`
+          output.should include("create")
+
+          File.exists?("app/assets/javascripts/jasmine_examples/Player.js").should == true
+          File.exists?("app/assets/javascripts/jasmine_examples/Song.js").should == true
+
+          File.exists?("spec/javascripts/jasmine_examples/PlayerSpec.js").should == true
+          File.exists?("spec/javascripts/helpers/SpecHelper.js").should == true
+        end
+      end
+    end
+  end
+end

data/spec/jasmine_self_test_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+Jasmine.configure do |config|
+  root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  config.src_dir = File.join(root, 'src')
+  config.spec_dir = Jasmine::Core.path
+  config.spec_files = lambda { (Jasmine::Core.html_spec_files + Jasmine::Core.core_spec_files).map {|f| File.join(config.spec_dir, f) } }
+end
+
+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."
+
+results_processor = Jasmine::ResultsProcessor.new(config)
+results = Jasmine::Runners::HTTP.new(driver, results_processor, config.result_batch_size).run
+formatter = Jasmine::RspecFormatter.new
+formatter.format_results(results)

data/spec/page_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'nokogiri'
+require 'ostruct'
+
+describe Jasmine::Page do
+  describe "#render" do
+    subject { Nokogiri::HTML(page.render) }
+    let(:fake_config) do
+      OpenStruct.new(:js_files => ["file1.js", "file2.js"], :css_files => ["file1.css", "file2.css"])
+    end
+    let(:context) { fake_config }
+    let(:page) { Jasmine::Page.new(context) }
+    it "should render javascript files in the correct order" do
+      js_files = subject.css("script")
+      js_files.map { |file| file["src"] }.compact.should == ["file1.js", "file2.js"]
+    end
+
+    it "should render css files in the correct order" do
+      css_files = subject.css("link[type='text/css']")
+      css_files.map { |file| file["href"] }.compact.should == ["file1.css", "file2.css"]
+    end
+  end
+end

data/spec/path_expander_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Jasmine::PathExpander do
+  it "returns absolute paths" do
+    dir_glob = lambda do |pattern|
+      case pattern
+      when 'some_base/src1*'
+        ['some_base/src1.js', 'some_base/src15.js']
+      when 'some_base/src2*'
+        ['some_base/src2.js']
+      else
+        raise "Unexpected pattern received: #{pattern}"
+      end
+    end
+
+    expanded_files = Jasmine::PathExpander.expand(
+      'some_base',
+      ['src1*', 'src2*'],
+      dir_glob
+    )
+
+    expanded_files.should == [
+      File.join('some_base', 'src1.js'),
+      File.join('some_base', 'src15.js'),
+      File.join('some_base', 'src2.js')
+    ]
+  end
+
+  it "uniqs files" do
+    dir_glob = lambda do |pattern|
+      case pattern
+      when 'some_base/src1*'
+        ['some_base/src1.js', 'some_base/src15.js', 'some_base/src1.js']
+      when 'some_base/src2*'
+        ['some_base/src2.js']
+      else
+        raise "Unexpected pattern received: #{pattern}"
+      end
+    end
+
+    expanded_files = Jasmine::PathExpander.expand(
+      'some_base',
+      ['src1*', 'src2*'],
+      dir_glob
+    )
+
+    expanded_files.should == [
+      File.join('some_base', 'src1.js'),
+      File.join('some_base', 'src15.js'),
+      File.join('some_base', 'src2.js')
+    ]
+  end
+
+  it "supports negation of passed patterns" do
+    dir_glob = lambda do |pattern|
+      case pattern
+      when 'some_base/src1*'
+        ['some_base/src1.js', 'some_base/src15.js']
+      when 'some_base/src1.js'
+        ['some_base/src1.js']
+      when 'some_base/src2*'
+        ['some_base/src2.js']
+      else
+        raise "Unexpected pattern received: #{pattern}"
+      end
+    end
+
+    expanded_files = Jasmine::PathExpander.expand(
+      'some_base',
+      ['src1*', '!src1.js', 'src2*'],
+      dir_glob
+    )
+
+    expanded_files.should == [
+      File.join('some_base', 'src15.js'),
+      File.join('some_base', 'src2.js')
+    ]
+  end
+
+  it "passes through files that are not found by the globber and are not negations and not globs" do
+    #this is designed to support asset pipeline files that aren't found.
+    dir_glob = lambda do |pattern|
+      []
+    end
+
+    expanded_files = Jasmine::PathExpander.expand(
+      'some_base',
+      ['src1*', '!src1.js', 'src2.js'],
+      dir_glob
+    )
+
+    expanded_files.should == [
+      File.join('some_base', 'src2.js')
+    ]
+  end
+end

data/spec/path_mapper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Jasmine::PathMapper do
+  it "correctly remaps src files" do
+    config = double(:config, :src_dir => '/src_dir', :src_path => '/__src__')
+    mapper = Jasmine::PathMapper.new(config)
+    mapper.map_src_paths(['/src_dir/foo']).should == ['/__src__/foo']
+    mapper.map_src_paths(['foo/bar']).should == ['/__src__/foo/bar']
+  end
+  it "correctly remaps spec files" do
+    config = double(:config, :spec_dir => '/spec_dir', :spec_path => '/__spec__')
+    mapper = Jasmine::PathMapper.new(config)
+    mapper.map_spec_paths(['/spec_dir/foo']).should == ['/__spec__/foo']
+    mapper.map_spec_paths(['foo/bar']).should == ['/__spec__/foo/bar']
+  end
+  it "correctly remaps jasmine files" do
+    config = double(:config, :jasmine_dir => '/jasmine_dir', :jasmine_path => '/__jasmine__')
+    mapper = Jasmine::PathMapper.new(config)
+    mapper.map_jasmine_paths(['/jasmine_dir/foo']).should == ['/__jasmine__/foo']
+    mapper.map_jasmine_paths(['foo/bar']).should == ['/__jasmine__/foo/bar']
+  end
+  it "correctly remaps boot files" do
+    config = double(:config, :boot_dir => '/boot_dir', :boot_path => '/__boot__')
+    mapper = Jasmine::PathMapper.new(config)
+    mapper.map_boot_paths(['/boot_dir/foo']).should == ['/__boot__/foo']
+    mapper.map_boot_paths(['foo/bar']).should == ['/__boot__/foo/bar']
+  end
+  it "handles edge case where dir == path" do
+    config = double(:config, :src_dir => '/src_dir', :src_path => '/src_dir')
+    mapper = Jasmine::PathMapper.new(config)
+    mapper.map_src_paths(['/src_dir/foo']).should == ['/src_dir/foo']
+  end
+end

data/spec/rack/jasmine/runner_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'rack/jasmine/runner'
+
+describe Rack::Jasmine::Runner do
+  describe "#call" do
+    let(:content) { "some content" }
+    let(:page) { double(Jasmine::Page, :render => content)}
+    let(:runner) { Rack::Jasmine::Runner.new(page)}
+    subject { runner.call("PATH_INFO" => path) }
+    context "PATH_INFO is /" do
+      let(:expected_headers) { {"Content-Type" => "text/html"} }
+      let(:path) { "/" }
+      it "should return a response with the passed content" do
+        subject.should == [200, expected_headers, [content]]
+      end
+    end
+    context "PATH_INFO is not /" do
+      let(:path) { "/some_foo" }
+      let(:expected_headers) { {"Content-Type" => "text/plain", "X-Cascade" => "pass"} }
+      it "should return a 404" do
+        subject.should == [404, expected_headers, ["File not found: #{path}\n"]]
+      end
+    end
+  end
+end

data/spec/results_processor_spec.rb

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

data/spec/results_spec.rb

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

data/spec/rspec_formatter_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Jasmine::RspecFormatter do
+  describe "environment variables" do
+    def stub_env_hash(hash)
+      ENV.stub!(:[]) do |arg|
+        hash[arg]
+      end
+    end
+    describe "browser configuration" do
+      it "should use firefox by default" do
+        pending
+        stub_env_hash({"JASMINE_BROWSER" => nil})
+        config = double('config')
+        formatter = Jasmine::RspecFormatter.new(config)
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with("firefox", anything).
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        formatter.start
+      end
+
+      it "should use ENV['JASMINE_BROWSER'] if set" do
+        pending
+        stub_env_hash({"JASMINE_BROWSER" => "mosaic"})
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with("mosaic", anything).
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        formatter.start
+      end
+    end
+
+    describe "jasmine host" do
+      it "should use http://localhost by default" do
+        pending
+        stub_env_hash({})
+        config = Jasmine::Config.new
+        config.instance_variable_set(:@jasmine_server_port, '1234')
+        config.stub!(:start_jasmine_server)
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with(anything, "http://localhost:1234/").
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
+
+      it "should use ENV['JASMINE_HOST'] if set" do
+        pending
+        stub_env_hash({"JASMINE_HOST" => "http://some_host"})
+        config = Jasmine::Config.new
+        config.instance_variable_set(:@jasmine_server_port, '1234')
+        config.stub!(:start_jasmine_server)
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with(anything, "http://some_host:1234/").
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
+
+      it "should use ENV['JASMINE_PORT'] if set" do
+        pending
+        stub_env_hash({"JASMINE_PORT" => "4321"})
+        config = Jasmine::Config.new
+        Jasmine.stub!(:wait_for_listener)
+        config.stub!(:start_server)
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with(anything, "http://localhost:4321/").
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
+    end
+
+    describe "external selenium server" do
+      it "should use an external selenium server if SELENIUM_SERVER is set" do
+        pending
+        stub_env_hash({"SELENIUM_SERVER" => "http://myseleniumserver.com:4441"})
+        Selenium::WebDriver.should_receive(:for).with(:remote, :url => "http://myseleniumserver.com:4441", :desired_capabilities => :firefox)
+        Jasmine::SeleniumDriver.new('firefox', 'http://localhost:8888')
+      end
+      it "should use an local selenium server with a specific port if SELENIUM_SERVER_PORT is set" do
+        pending
+        stub_env_hash({"SELENIUM_SERVER_PORT" => "4441"})
+        Selenium::WebDriver.should_receive(:for).with(:remote, :url => "http://localhost:4441/wd/hub", :desired_capabilities => :firefox)
+        Jasmine::SeleniumDriver.new('firefox', 'http://localhost:8888')
+      end
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Jasmine::Server do
+  describe "rack ~> 1.0" do
+    before do
+      Jasmine::Dependencies.stub(:legacy_rack?).and_return(true)
+    end
+
+    it "should run the handler with the application" do
+      server = double(:server)
+      port = 1234
+      application = double(:application)
+      Rack::Handler.should_receive(:get).with("webrick").and_return(server)
+      server.should_receive(:run).with(application, hash_including(:Port => port))
+      Jasmine::Server.new(port, application).start
+    end
+  end
+
+  describe "rack >= 1.1" do
+    before do
+      Jasmine::Dependencies.stub(:legacy_rack?).and_return(false)
+      if !Rack.constants.include?(:Server)
+        Rack::Server = double("Rack::Server")
+      end
+    end
+
+    it "should create a Rack::Server with the correct port when passed" do
+      port = 1234
+      Rack::Server.should_receive(:new).with(hash_including(:Port => port)).and_return(double(:server).as_null_object)
+      Jasmine::Server.new(port, double(:app)).start
+    end
+
+    it "should start the server" do
+      server = double(:server)
+      Rack::Server.should_receive(:new) { server.as_null_object }
+      server.should_receive(:start)
+      Jasmine::Server.new('8888', double(:app)).start
+    end
+
+    it "should set the app as the instance variable on the rack server" do
+      app = double('application')
+      server = double(:server)
+      Rack::Server.should_receive(:new) { server.as_null_object }
+      Jasmine::Server.new(1234, app).start
+      server.instance_variable_get(:@app).should == app
+    end
+  end
+end