jasmine 1.3.0 → 1.3.1

data/spec/asset_expander_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Jasmine::AssetExpander do
+  it "expands asset files" do
+    bundled_asset = double(:bundled_asset,
+                           :to_a => ['asset1', 'asset2'],
+                           :pathname => double(:pathname, :to_s => '/some_src_dir/asset_file'))
+
+    bundled_asset_getter = lambda do |filepath, ext|
+      if filepath == 'asset_file' && ext == 'js'
+        bundled_asset
+      end
+    end
+
+    asset_path_getter = lambda do |asset|
+      if asset == 'asset1'
+        'asset1_path'
+      elsif asset == 'asset2'
+        'asset2_path'
+      end
+    end
+
+    expander = Jasmine::AssetExpander.new(bundled_asset_getter, asset_path_getter)
+    expanded_assets = expander.expand('/some_src_dir', 'asset_file')
+    expanded_assets.should == ['/asset_file?body=true',
+                               '/asset1_path?body=true',
+                               '/asset2_path?body=true']
+  end
+
+  it "return nil if no bundled asset is found" do
+    bundled_asset = nil
+    bundled_asset_getter = lambda do |filepath, ext|
+      if filepath == 'asset_file' && ext == 'js'
+        bundled_asset
+      end
+    end
+
+    expander = Jasmine::AssetExpander.new(bundled_asset_getter, lambda {})
+    expanded_assets = expander.expand('/some_src_dir', 'asset_file')
+    expanded_assets.should be_nil
+  end
+end

data/spec/asset_pipeline_mapper_spec.rb

@@ -1,18 +1,19 @@
 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}"
+  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
-      mapper = Jasmine::AssetPipelineMapper.new(asset_context)
-      mapper.files(src_files).should == ['some_location/asset1.js?body=true', 'some_location/asset2.js?body=true', 'some_location/asset3.js?body=true']
+
     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/base_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Jasmine do
+  it "should provide the root path" do
+    File.stub(:dirname).and_return('lib/jasmine')
+    File.should_receive(:expand_path) { |path| path }
+    Jasmine.root.should == 'lib/jasmine'
+  end
+  it "should append passed file paths" do
+    File.stub(:dirname).and_return('lib/jasmine')
+    File.should_receive(:expand_path) { |path| path }
+    Jasmine.root('subdir1', 'subdir2').should == File.join('lib/jasmine', 'subdir1', 'subdir2')
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Jasmine::Configuration do
+  let(:test_mapper1) do
+    Class.new do
+      def initialize(config)
+        @config = config
+      end
+      def map_src_paths(paths)
+        paths.map { |f| "mapped_src/#{f}" }
+      end
+      def map_jasmine_paths(paths)
+        paths.map { |f| "mapped_jasmine/#{f}" }
+      end
+      def map_spec_paths(paths)
+        paths.map { |f| "mapped_spec/#{f}" }
+      end
+      def map_boot_paths(paths)
+        paths.map { |f| "mapped_boot/#{f}" }
+      end
+    end
+  end
+  let(:test_mapper2) do
+    Class.new do
+      def initialize(config)
+        @config = config
+      end
+      def map_src_paths(paths)
+        paths.map { |f| "#{f}/src" }
+      end
+      def map_jasmine_paths(paths)
+        paths.map { |f| "#{f}/jasmine" }
+      end
+      def map_spec_paths(paths)
+        paths.map { |f| "#{f}/spec" }
+      end
+      def map_boot_paths(paths)
+        paths.map { |f| "#{f}/boot" }
+      end
+    end
+  end
+  let(:test_mapper3) do
+    Class.new do
+      def initialize(config)
+        @config = config
+      end
+    end
+  end
+
+  describe "returning css files" do
+    it "returns mapped jasmine_css_files + css_files" do
+      config = Jasmine::Configuration.new()
+      config.add_path_mapper(lambda { |c| test_mapper1.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper2.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper3.new(c) })
+      config.css_files.should == []
+      config.jasmine_css_files = lambda { ["jasmine_css"] }
+      config.css_files = lambda { ["css"] }
+      config.css_files.should == ['mapped_jasmine/jasmine_css/jasmine', 'mapped_src/css/src']
+    end
+  end
+
+  describe "returning javascript files" do
+    it "returns the jasmine core files, then srcs, then specs, then boot" do
+      config = Jasmine::Configuration.new()
+      config.add_path_mapper(lambda { |c| test_mapper1.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper2.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper3.new(c) })
+      config.js_files.should == []
+      config.jasmine_files = lambda { ['jasmine'] }
+      config.src_files = lambda  { ['src'] }
+      config.boot_files = lambda { ['boot'] }
+      config.spec_files = lambda { ['spec'] }
+      config.js_files.should == [
+        'mapped_jasmine/jasmine/jasmine',
+        'mapped_src/src/src',
+        'mapped_spec/spec/spec',
+        'mapped_boot/boot/boot',
+      ]
+    end
+  end
+
+  describe "returning rack map" do
+    it "permits arbitrary rack app path mapping" do
+      config = Jasmine::Configuration.new()
+      result = double
+      config.add_rack_path('some/path', lambda { result })
+      map = config.rack_path_map
+      map['some/path'].should be
+      map['some/path'].call.should == result
+    end
+
+  end
+
+  describe "rack apps" do
+    it "permits the addition of arbitary rack apps" do
+      config = Jasmine::Configuration.new()
+      app = double
+      config.add_rack_app(app)
+      config.rack_apps.should == [[app, nil]]
+    end
+    it "permits the addition of arbitary rack apps with arbitrary config" do
+      config = Jasmine::Configuration.new()
+      app = double
+      block = lambda { "foo" }
+      config.add_rack_app(app, &block)
+      config.rack_apps.should == [[app, block]]
+    end
+  end
+
+  describe "port" do
+    it "returns new port and caches return value" do
+      config = Jasmine::Configuration.new()
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port.should == '1234'
+      Jasmine.stub(:find_unused_port).and_return('4321')
+      config.port.should == '1234'
+    end
+    it "returns port if configured" do
+      config = Jasmine::Configuration.new()
+      config.port = '5678'
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port.should == '5678'
+    end
+  end
+
+  describe "browser" do
+    it "should default to firefox" do
+      Jasmine::Configuration.new().browser.should == 'firefox'
+    end
+
+    it "returns browser if set" do
+      config = Jasmine::Configuration.new()
+      config.browser = 'foo'
+      config.browser.should == 'foo'
+    end
+  end
+
+  describe "result_batch_size" do
+    it "should default to 50" do
+      Jasmine::Configuration.new().result_batch_size.should == 50
+    end
+
+    it "returns result_batch_size if set" do
+      config = Jasmine::Configuration.new()
+      config.result_batch_size = 25
+      config.result_batch_size.should == 25
+    end
+  end
+
+  describe "host" do
+    it "should default to localhost" do
+      Jasmine::Configuration.new().host.should == 'http://localhost'
+    end
+
+    it "returns host if set" do
+      config = Jasmine::Configuration.new()
+      config.host = 'foo'
+      config.host.should == 'foo'
+    end
+  end
+end
+

data/spec/jasmine_self_test_spec.rb

@@ -1,9 +1,16 @@
 require 'spec_helper'
-require 'jasmine_self_test_config'
 
-jasmine_runner_config = Jasmine::RunnerConfig.new(JasmineSelfTestConfig.new)
-server = Jasmine::Server.new(jasmine_runner_config.port, Jasmine::Application.app(jasmine_runner_config))
-client = Jasmine::SeleniumDriver.new(jasmine_runner_config.browser, jasmine_runner_config.jasmine_server_url)
+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
@@ -13,10 +20,10 @@ t = Thread.new do
   # # ignore bad exits
 end
 t.abort_on_exception = true
-Jasmine::wait_for_listener(jasmine_runner_config.port, "jasmine server")
+Jasmine::wait_for_listener(config.port, "jasmine server")
 puts "jasmine server started."
 
-results_processor = Jasmine::ResultsProcessor.new(jasmine_runner_config)
-results = Jasmine::Runners::HTTP.new(client, results_processor, jasmine_runner_config.result_batch_size).run
+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

@@ -6,15 +6,13 @@ 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"],
-                     :jasmine_files => ["jasmine_file1.js", "jasmine_file2.js"])
+      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 == ["jasmine_file1.js", "jasmine_file2.js", "file1.js", "file2.js"]
+      js_files.map { |file| file["src"] }.compact.should == ["file1.js", "file2.js"]
     end
 
     it "should render css files in the correct order" do

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

@@ -27,14 +27,14 @@ describe Jasmine::Server do
     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
+      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.start
+      Jasmine::Server.new('8888', double(:app)).start
     end
 
     it "should set the app as the instance variable on the rack server" do