rally-jasmine 1.2.0

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/runner_config_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'selenium-webdriver'
+
+describe Jasmine::RunnerConfig do
+  describe "css_files" do
+    it "should return the jasmine stylesheets and any user defined stylesheets" do
+      jasmine_stylesheets = ['some/css/file']
+      user_stylesheets = ['some/user/file']
+      user_config = double("config", :jasmine_stylesheets => jasmine_stylesheets, :user_stylesheets => user_stylesheets)
+      Jasmine::RunnerConfig.new(user_config).css_files.should == jasmine_stylesheets + user_stylesheets
+    end
+  end
+
+  describe "jasmine_files" do
+    it "should return the jasmine files from the config" do
+      jasmine_files = ['some/file']
+      user_config = double('config', :jasmine_javascripts => jasmine_files)
+      Jasmine::RunnerConfig.new(user_config).jasmine_files.should == jasmine_files
+    end
+  end
+
+  describe "js_files" do
+    it "should return the user js files from the config" do
+      js_files = ['some/file']
+      user_config = double('config', :js_files => js_files)
+      Jasmine::RunnerConfig.new(user_config).js_files.should == js_files
+    end
+  end
+
+  describe "spec_files" do
+    it "should return the user spec_files from the config" do
+      spec_files = ['some/file']
+      user_config = double('config', :spec_files => spec_files)
+      Jasmine::RunnerConfig.new(user_config).spec_files.should == spec_files
+    end
+  end
+
+  describe "spec_files_full_paths" do
+    it "should return the user spec_files_full_paths from the config" do
+      spec_files_full_paths = ['some/file_path']
+      user_config = double('config', :spec_files_full_paths => spec_files_full_paths)
+      Jasmine::RunnerConfig.new(user_config).spec_files_full_paths.should == spec_files_full_paths
+    end
+  end
+
+  describe "spec_path" do
+    it "should return the user spec_path from the config" do
+      spec_path = ['some/path']
+      user_config = double('config', :spec_path => spec_path)
+      Jasmine::RunnerConfig.new(user_config).spec_path.should == spec_path
+    end
+  end
+
+  describe "spec_dir" do
+    it "should return the user spec_dir from the config" do
+      spec_dir = ['some/dir']
+      user_config = double('config', :spec_dir => spec_dir)
+      Jasmine::RunnerConfig.new(user_config).spec_dir.should == spec_dir
+    end
+  end
+
+  describe "src_dir" do
+    it "should return the user src_dir from the config" do
+      src_dir = ['some/dir']
+      user_config = double('config', :src_dir => src_dir)
+      Jasmine::RunnerConfig.new(user_config).src_dir.should == src_dir
+    end
+  end
+
+  describe "project_root" do
+    it "should return the user project_root from the config" do
+      project_root = ['some/dir']
+      user_config = double('config', :project_root => project_root)
+      Jasmine::RunnerConfig.new(user_config).project_root.should == project_root
+    end
+  end
+
+  describe "root_path" do
+    it "should return the user root_path from the config" do
+      root_path = ['some/path']
+      user_config = double('config', :root_path => root_path)
+      Jasmine::RunnerConfig.new(user_config).root_path.should == root_path
+    end
+  end
+
+  describe "browser" do
+    it "should default to firefox" do
+      Jasmine::RunnerConfig.new.browser.should == 'firefox'
+    end
+
+    it "should use ENV['JASMINE_BROWSER'] if it exists" do
+      ENV.stub(:[], "JASMINE_BROWSER").and_return("foo")
+      Jasmine::RunnerConfig.new.browser.should == 'foo'
+    end
+  end
+
+
+  describe "src_mapper" do
+    it "should update the src_mapper in the user_config" do
+      config = Jasmine::RunnerConfig.new(user_config = Jasmine::Config.new)
+      mapper = double("mapper")
+      config.src_mapper = mapper
+      config.src_mapper.should == mapper
+      user_config.src_mapper.should == mapper
+    end
+  end
+
+  describe "jasmine_server_url" do
+    it "should return the correct server url" do
+      host = "the host"
+      port =  "484"
+      user_config = double('config', :jasmine_host => host, :port => port)
+      Jasmine::RunnerConfig.new(user_config).jasmine_server_url.should == "#{host}:#{port}/"
+    end
+  end
+
+  describe "port" do
+    it "should return the port from the config" do
+      user_config = double('config', :port => 80)
+      Jasmine::RunnerConfig.new(user_config).port.should == 80
+    end
+  end
+  describe "result batch size" do
+    subject { Jasmine::RunnerConfig.new.result_batch_size }
+
+    context "when not specified" do
+      it("should use default") { should == 50 }
+    end
+
+    context "when overridden" do
+      before { ENV.stub(:[], "JASMINE_RESULT_BATCH_SIZE").and_return("500") }
+      it { should be(500) }
+    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).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.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

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require "rubygems"
+require "bundler"
+require 'stringio'
+require 'tmpdir'
+
+envs = [:default, :development]
+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
+
+
+def create_rails(name)
+  if Jasmine::Dependencies.rails3?
+    `rails new #{name}`
+  else
+    `rails #{name}`
+  end
+end
+
+def create_temp_dir
+  tmp = File.join(Dir.tmpdir, "jasmine-gem-test_#{Time.now.to_f}")
+  FileUtils.rm_r(tmp, :force => true)
+  FileUtils.mkdir(tmp)
+  tmp
+end
+
+def temp_dir_before
+  @root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  @old_dir = Dir::pwd
+  @tmp = create_temp_dir
+end
+
+def temp_dir_after
+  Dir::chdir @old_dir
+  FileUtils.rm_r @tmp
+end
+
+module Kernel
+  def capture_stdout
+    out = StringIO.new
+    $stdout = out
+    yield
+    return out.string
+  ensure
+    $stdout = STDOUT
+  end
+end

data/spec/sprockets_mapper_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Jasmine::SprocketsMapper do
+  describe "mapping files" do
+    it "should retrieve asset paths from the the sprockets environment for passed files" do
+      src_files = ["assets/application.js", "assets/other_manifest.js"]
+      asset1 = double("asset1", :logical_path => "asset1.js")
+      asset2 = double("asset2", :logical_path => "asset2.js")
+      asset3 = double("asset3", :logical_path => "asset3.js")
+      asset_context = double("Sprockets::Environment")
+      asset_context.stub_chain(:find_asset).with("application").and_return([asset1, asset2])
+      asset_context.stub_chain(:find_asset).with("other_manifest").and_return([asset1, asset3])
+      mapper = Jasmine::SprocketsMapper.new(asset_context, 'some_location')
+      mapper.files(src_files).should == ['some_location/asset1.js?body=true', 'some_location/asset2.js?body=true', 'some_location/asset3.js?body=true']
+    end
+  end
+end