jasmine 1.2.0 → 1.2.1

data/lib/jasmine/runner_config.rb

@@ -0,0 +1,60 @@
+module Jasmine
+  class RunnerConfig
+    def initialize(config = Jasmine::Config.new)
+      @config = config
+    end
+
+    def css_files
+      @config.jasmine_stylesheets + @config.user_stylesheets
+    end
+
+    def jasmine_files
+      @config.jasmine_javascripts
+    end
+
+    def js_files
+      @config.js_files
+    end
+
+    def spec_files
+      @config.spec_files
+    end
+
+    def spec_files_full_paths
+      @config.spec_files_full_paths
+    end
+
+    def spec_path
+      @config.spec_path
+    end
+
+    def spec_dir
+      @config.spec_dir
+    end
+
+    def src_dir
+      @config.src_dir
+    end
+
+    def project_root
+      @config.project_root
+    end
+
+    def root_path
+      @config.root_path
+    end
+
+    def browser
+      ENV["JASMINE_BROWSER"] || 'firefox'
+    end
+
+    def jasmine_host
+      ENV["JASMINE_HOST"] || 'http://localhost'
+    end
+
+    def port
+      @port ||= ENV["JASMINE_PORT"] || Jasmine.find_unused_port
+    end
+
+  end
+end

data/lib/jasmine/runners/http.rb

@@ -0,0 +1,70 @@
+module Jasmine
+  module Runners
+    class HTTP
+      attr_accessor :suites
+
+      def initialize(client, results_processor)
+        @client = client
+        @results_processor = results_processor
+      end
+
+      def run
+        @client.connect
+        load_suite_info
+        wait_for_suites_to_finish_running
+        results = @results_processor.process(results_hash, suites)
+        @client.disconnect
+        results
+      end
+
+      private
+
+      def load_suite_info
+        started = Time.now
+        while !eval_js('return jsApiReporter && jsApiReporter.started') do
+          raise "couldn't connect to Jasmine after 60 seconds" if (started + 60 < Time.now)
+          sleep 0.1
+        end
+
+        @suites = eval_js("var result = jsApiReporter.suites(); if (window.Prototype && Object.toJSON) { return Object.toJSON(result) } else { return JSON.stringify(result) }")
+      end
+
+      def results_hash
+        spec_results = {}
+        spec_ids.each_slice(50) do |slice|
+          spec_results.merge!(eval_js("var result = jsApiReporter.resultsForSpecs(#{json_generate(slice)}); if (window.Prototype && Object.toJSON) { return Object.toJSON(result) } else { return JSON.stringify(result) }"))
+        end
+        spec_results
+      end
+
+      def spec_ids
+        map_spec_ids = lambda do |suites|
+          suites.map do |suite_or_spec|
+            if suite_or_spec['type'] == 'spec'
+              suite_or_spec['id']
+            else
+              map_spec_ids.call(suite_or_spec['children'])
+            end
+          end
+        end
+        map_spec_ids.call(@suites).compact.flatten
+      end
+
+      def wait_for_suites_to_finish_running
+        puts "Waiting for suite to finish in browser ..."
+        while !eval_js('return jsApiReporter.finished') do
+          sleep 0.1
+        end
+      end
+
+      def eval_js(script)
+        @client.eval_js(script)
+      end
+
+      def json_generate(obj)
+        @client.json_generate(obj)
+      end
+
+    end
+  end
+end

data/lib/jasmine/selenium_driver.rb

@@ -21,10 +21,6 @@ module Jasmine
       @http_address = http_address
     end
 
-    def tests_have_finished?
-      @driver.execute_script("return window.jasmine.getEnv().currentRunner.finished") == "true"
-    end
-
     def connect
       @driver.navigate.to @http_address
     end
@@ -33,16 +29,6 @@ module Jasmine
       @driver.quit
     end
 
-    def run
-      until tests_have_finished? do
-        sleep 0.1
-      end
-
-      puts @driver.execute_script("return window.results()")
-      failed_count = @driver.execute_script("return window.jasmine.getEnv().currentRunner.results().failedCount").to_i
-      failed_count == 0
-    end
-
     def eval_js(script)
       result = @driver.execute_script(script)
       JSON.parse("{\"result\":#{result}}", :max_nesting => false)["result"]

data/lib/jasmine/server.rb

@@ -1,40 +1,19 @@
-require 'rack'
-require 'rack/utils'
-require 'jasmine-core'
-require 'rack/jasmine/runner'
-require 'rack/jasmine/focused_suite'
-require 'rack/jasmine/redirect'
-require 'rack/jasmine/cache_control'
-require 'ostruct'
-
 module Jasmine
-  def self.app(config)
-    jasmine_stylesheets = ::Jasmine::Core.css_files.map {|f| "/__JASMINE_ROOT__/#{f}"}
-    config_shim = OpenStruct.new({:jasmine_files => ::Jasmine::Core.js_files.map {|f| "/__JASMINE_ROOT__/#{f}"},
-                                  :js_files => config.js_files,
-                                  :css_files => jasmine_stylesheets + (config.css_files || [])})
-    page = Jasmine::Page.new(config_shim.instance_eval { binding })
-    Rack::Builder.app do
-      use Rack::Head
-      use Rack::Jasmine::CacheControl
-      if Jasmine::Dependencies.rails_3_asset_pipeline?
-        map('/assets') do
-          run Rails.application.assets
-        end
-      end
-
-      map('/run.html')         { run Rack::Jasmine::Redirect.new('/') }
-      map('/__suite__')        { run Rack::Jasmine::FocusedSuite.new(config) }
-
-      map('/__JASMINE_ROOT__') { run Rack::File.new(Jasmine::Core.path) }
-      map(config.spec_path)    { run Rack::File.new(config.spec_dir) }
-      map(config.root_path)    { run Rack::File.new(config.project_root) }
+  class Server
+    def initialize(port = 8888, application = Jasmine::Application.app)
+      @port = port
+      @application = application
+    end
 
-      map('/') do
-        run Rack::Cascade.new([
-          Rack::URLMap.new('/' => Rack::File.new(config.src_dir)),
-          Rack::Jasmine::Runner.new(page)
-        ])
+    def start
+      if Jasmine::Dependencies.legacy_rack?
+        handler = Rack::Handler.get('webrick')
+        handler.run(@application, :Port => @port, :AccessLog => [])
+      else
+        server = Rack::Server.new(:Port => @port, :AccessLog => [])
+        # workaround for Rack bug, when Rack > 1.2.1 is released Rack::Server.start(:app => Jasmine.app(self)) will work
+        server.instance_variable_set(:@app, @application)
+        server.start
       end
     end
   end

data/lib/jasmine/tasks/jasmine.rake

@@ -27,7 +27,7 @@ namespace :jasmine do
         t.rspec_opts = ["--colour", "--format", ENV['JASMINE_SPEC_FORMAT'] || "progress"]
         t.verbose = true
         if Jasmine::Dependencies.rails_3_asset_pipeline?
-          t.ruby_opts = ["-r #{File.expand_path(File.join(::Rails.root, 'config', 'environment'))}"]
+          t.rspec_opts += ["-r #{File.expand_path(File.join(::Rails.root, 'config', 'environment'))}"]
         end
         t.pattern = [Jasmine.runner_filepath]
       end
@@ -48,7 +48,7 @@ namespace :jasmine do
     port = ENV['JASMINE_PORT'] || 8888
     puts "your tests are here:"
     puts "  http://localhost:#{port}/"
-    Jasmine::Config.new.start_server(port)
+    Jasmine::Server.new(port).start
   end
 end
 

data/lib/jasmine/version.rb

@@ -1,3 +1,3 @@
 module Jasmine
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/lib/rack/jasmine/focused_suite.rb

@@ -2,12 +2,12 @@ module Rack
   module Jasmine
 
     class FocusedSuite
-      def initialize(config)
-        @config = config
+      def initialize(runner_config)
+        @runner_config = runner_config
       end
 
       def call(env)
-        run_adapter = Rack::Jasmine::RunAdapter.new(@config)
+        run_adapter = Rack::Jasmine::RunAdapter.new(@runner_config)
         run_adapter.run(env["PATH_INFO"])
       end
     end

data/spec/application_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe "Jasmine::Application" do
+  include Rack::Test::Methods
+
+  def app
+    @root = File.join(File.dirname(__FILE__))
+    runner_config = double("config",
+                    :project_root => @root,
+                    :spec_dir => File.join(@root, "fixture", "spec"),
+                    :spec_path => "/__spec__",
+                    :root_path => "/__root__",
+                    :css_files => [],
+                    :jasmine_files => [],
+                    :js_files => ["path/file1.js", "path/file2.js"],
+                    :src_dir => File.join(@root, "fixture", "src"),
+                    :src_files => ["file1.js"],
+                    :spec_files => ["example_spec.js"])
+    Jasmine::Application.app(runner_config)
+  end
+
+  it "includes no-cache headers for specs" do
+    get "/__spec__/example_spec.js"
+    last_response.headers.should have_key("Cache-Control")
+    last_response.headers["Cache-Control"].should == "max-age=0, private, must-revalidate"
+  end
+
+  it "should serve static files from spec dir under __spec__" do
+    get "/__spec__/example_spec.js"
+    last_response.status.should == 200
+    last_response.content_type.should == "application/javascript"
+    last_response.body.should == File.read(File.join(@root, "fixture/spec/example_spec.js"))
+    end
+
+  it "should serve static files from root dir under __root__" do
+    get "/__root__/fixture/src/example.js"
+    last_response.status.should == 200
+    last_response.content_type.should == "application/javascript"
+    last_response.body.should == File.read(File.join(@root, "fixture/src/example.js"))
+  end
+
+  it "should serve static files from src dir under /" do
+    get "/example.js"
+    last_response.status.should == 200
+    last_response.content_type.should == "application/javascript"
+    last_response.body.should == File.read(File.join(@root, "fixture/src/example.js"))
+  end
+
+  it "should serve Jasmine static files under /__JASMINE_ROOT__/" do
+    get "/__JASMINE_ROOT__/jasmine.css"
+    last_response.status.should == 200
+    last_response.content_type.should == "text/css"
+    last_response.body.should == File.read(File.join(Jasmine::Core.path, "jasmine.css"))
+  end
+
+  it "should serve focused suites when prefixing spec files with /__suite__/" do
+    pending "Temporarily removing this feature (maybe permanent)"
+    Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+    get "/__suite__/file2.js"
+    last_response.status.should == 200
+    last_response.content_type.should == "text/html"
+    last_response.body.should include("\"/__spec__/file2.js")
+  end
+
+  it "should redirect /run.html to /" do
+    get "/run.html"
+    last_response.status.should == 302
+    last_response.location.should == "/"
+  end
+
+  it "should 404 non-existent files" do
+    get "/some-non-existent-file"
+    last_response.should be_not_found
+  end
+
+  describe "/ page" do
+    it "should load each js file in order" do
+      get "/"
+      last_response.status.should == 200
+      last_response.body.should include("path/file1.js")
+      last_response.body.should include("path/file2.js")
+    end
+
+    it "should return an empty 200 for HEAD requests to /" do
+      head "/"
+      last_response.status.should == 200
+      last_response.headers['Content-Type'].should == 'text/html'
+      last_response.body.should == ''
+    end
+
+    it "should tell the browser not to cache any assets" do
+      head "/"
+      ['Pragma'].each do |key|
+        last_response.headers[key].should == 'no-cache'
+      end
+    end
+  end
+end

data/spec/asset_pipeline_mapper_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Jasmine::AssetPipelineMapper do
+  describe "mapping files" do
+    it "should retrieve asset paths from the asset pipeline for passed files" do
+      #TODO: this expects all src files to be asset pipeline files
+      src_files = ["assets/application.js", "assets/other_manifest.js"]
+      asset_context = double("asset context")
+      asset_context.stub_chain(:asset_paths, :asset_for).with("application", "js").and_return(['asset1.js', 'asset2.js'])
+      asset_context.stub_chain(:asset_paths, :asset_for).with("other_manifest", "js").and_return(['asset1.js', 'asset3.js'])
+      asset_context.stub(:asset_path) do |asset|
+        "/some_location/#{asset}"
+      end
+      mapper = Jasmine::AssetPipelineMapper.new(src_files, asset_context)
+      mapper.files.should == ['some_location/asset1.js?body=true', 'some_location/asset2.js?body=true', 'some_location/asset3.js?body=true']
+    end
+  end
+end

data/spec/config_spec.rb

@@ -4,6 +4,8 @@ require 'selenium-webdriver'
 describe Jasmine::Config do
   describe "configuration" do
     before :each do
+      Jasmine::Dependencies.stub(:rails_3_asset_pipeline?) { false }
+
       temp_dir_before
 
       Dir::chdir @tmp
@@ -239,83 +241,46 @@ describe Jasmine::Config do
     end
   end
 
-  describe "environment variables" do
-    def stub_env_hash(hash)
-      ENV.stub!(:[]) do |arg|
-        hash[arg]
-      end
+
+  describe "jasmine_stylesheets" do
+    it "should return the relative web server path to the core Jasmine css stylesheets" do
+      #TODO: wrap Jasmine::Core with a class that knows about the core path and the relative mapping.
+      Jasmine::Core.stub(:css_files).and_return(["my_css_file1.css", "my_css_file2.css"])
+      Jasmine::Config.new.jasmine_stylesheets.should == ["/__JASMINE_ROOT__/my_css_file1.css", "/__JASMINE_ROOT__/my_css_file2.css"]
     end
-    describe "browser configuration" do
-      it "should use firefox by default" do
-        stub_env_hash({"JASMINE_BROWSER" => nil})
-        config = Jasmine::Config.new
-        config.stub!(:start_jasmine_server)
-        Jasmine::SeleniumDriver.should_receive(:new).
-            with("firefox", anything).
-            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-        config.start
-      end
+  end
 
-      it "should use ENV['JASMINE_BROWSER'] if set" do
-        stub_env_hash({"JASMINE_BROWSER" => "mosaic"})
-        config = Jasmine::Config.new
-        config.stub!(:start_jasmine_server)
-        Jasmine::SeleniumDriver.should_receive(:new).
-            with("mosaic", anything).
-            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-        config.start
-      end
+  describe "jasmine_javascripts" do
+    it "should return the relative web server path to the core Jasmine css javascripts" do
+      Jasmine::Core.stub(:js_files).and_return(["my_js_file1.js", "my_js_file2.js"])
+      Jasmine::Config.new.jasmine_javascripts.should == ["/__JASMINE_ROOT__/my_js_file1.js", "/__JASMINE_ROOT__/my_js_file2.js"]
     end
+  end
 
-    describe "jasmine host" do
-      it "should use http://localhost by default" do
-        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
+  describe "when the asset pipeline is active" do
+    before do
+      Jasmine::Dependencies.stub(:rails_3_asset_pipeline?) { true }
+    end
 
-      it "should use ENV['JASMINE_HOST'] if set" do
-        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)
+    let(:src_files) { ["assets/some.js", "assets/files.js"] }
 
-        Jasmine::SeleniumDriver.should_receive(:new).
-            with(anything, "http://some_host:1234/").
-            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-        config.start
+    let(:config) do
+      Jasmine::Config.new.tap do |config|
+        #TODO: simple_config should be a passed in hash
+        config.stub(:simple_config)  { { 'src_files' => src_files} }
       end
+    end
 
-      it "should use ENV['JASMINE_PORT'] if set" do
-        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
+    it "should use AssetPipelineMapper to return src_files" do
+      mapped_files =  ["some.js", "files.js"]
+      Jasmine::AssetPipelineMapper.stub_chain(:new, :files).and_return(mapped_files)
+      config.src_files.should == mapped_files
     end
 
-    describe "external selenium server" do
-      it "should use an external selenium server if SELENIUM_SERVER is set" do
-        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
-        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
+    it "should pass the config src_files to the AssetPipelineMapper" do
+      Jasmine::Config.stub(:simple_config)
+      Jasmine::AssetPipelineMapper.should_receive(:new).with(src_files).and_return(double("mapper").as_null_object)
+      config.src_files
     end
   end
-
 end