rally-jasmine 1.2.0

data/spec/dependencies_spec.rb

@@ -0,0 +1,327 @@
+require 'spec_helper'
+
+#rspec 1 fails to stub respond_to
+if Jasmine::Dependencies.rspec2?
+  describe Jasmine::Dependencies do
+    module Rails
+    end
+
+    context "with ruby_gems > 1.8" do
+      before do
+        Gem::Specification.should_receive(:respond_to?).with(:find_by_name).and_return(true)
+      end
+
+      describe ".rspec2?" do
+        subject { Jasmine::Dependencies.rspec2? }
+        context "when rspec 2 is present" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rspec", ">= 2.0").and_return(true)
+          end
+          it { should be_true }
+        end
+        context "when rspec 2 is not present" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rspec", ">= 2.0").and_raise(Gem::LoadError)
+          end
+          it { should be_false }
+        end
+      end
+
+      describe ".rails2?" do
+        subject { Jasmine::Dependencies.rails2? }
+        context "when rails 2 is present and running" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", "~> 2.3").and_return(true)
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:running_rails_version) { "2.3.11" }
+          it { should be_true }
+        end
+        context "when rails 2 is present but not running" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", "~> 2.3").and_raise(Gem::LoadError)
+          end
+          it { should be_false }
+        end
+        context "when rails 2 is not present" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", "~> 2.3").and_raise(Gem::LoadError)
+          end
+          it { should be_false }
+        end
+      end
+
+      describe ".legacy_rails?" do
+        subject { Jasmine::Dependencies.legacy_rails? }
+        context "when rails < 2.3.11 is present and running" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", "< 2.3.11").and_return(true)
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:running_rails_version) { "2.3.8" }
+          it { should be_true }
+        end
+        context "when rails < 2.3.11 is present but not running" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", "< 2.3.11").and_return(true)
+          end
+          it { should be_false }
+        end
+        context "when rails < 2.3.11 is not present" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", "< 2.3.11").and_raise(Gem::LoadError)
+          end
+          it { should be_false }
+        end
+      end
+
+      describe ".rails3?" do
+        subject { Jasmine::Dependencies.rails3? }
+        context "when rails 3 is present and running" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:running_rails_version) { "3.2" }
+          it { should be_true }
+        end
+        context "when rails 3 is present but not running" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
+          end
+          it { should be_false }
+        end
+        context "when rails 3 is not present" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_raise(Gem::LoadError)
+          end
+          it { should be_false }
+        end
+      end
+
+      describe ".rails_3_asset_pipeline?" do
+        subject { Jasmine::Dependencies.rails_3_asset_pipeline? }
+        let(:application) { double(:application) }
+        let(:running_rails_version) { "3.2" }
+        before do
+          Rails.stub(:respond_to?).with(:application).and_return(respond_to_application)
+          Rails.stub(:application).and_return(application)
+          Rails.stub(:respond_to?).with(:version).and_return(true)
+          Rails.stub(:version).and_return(running_rails_version)
+        end
+        context "when rails 3 is present and the application pipeline is in use" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
+            application.stub(:assets).and_return(rails_application_assets)
+          end
+          let(:rails3_present) { true }
+          let(:respond_to_application) { true }
+          let(:rails_application_assets) { true }
+          it { should be_true }
+        end
+        context "when rails 3 is present and the application pipeline is not in use" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
+            application.stub(:assets).and_return(rails_application_assets)
+          end
+          let(:rails3_present) { true }
+          let(:respond_to_application) { true }
+          let(:rails_application_assets) { false }
+          it { should be_false }
+        end
+        context "when rails 3 is present but not loaded" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
+            application.stub(:assets).and_return(rails_application_assets)
+          end
+          let(:rails3_present) { true }
+          let(:respond_to_application) { false }
+          let(:rails_application_assets) { false }
+          it { should be_false }
+        end
+        context "when rails 3 is present but doesn't respond to assets" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
+          end
+          let(:rails3_present) { true }
+          let(:respond_to_application) { true }
+          it { should be_false }
+        end
+        context "when rails 3 is not present" do
+          before do
+            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_raise(Gem::LoadError)
+          end
+          let(:rails3_present) { false }
+          let(:respond_to_application) { false }
+          let(:rails_application_assets) { false }
+          it { should be_false }
+        end
+      end
+    end
+
+    context "with ruby_gems < 1.8" do
+      before do
+        Gem::Specification.should_receive(:respond_to?).with(:find_by_name).and_return(false)
+      end
+
+      describe ".rspec2?" do
+        subject { Jasmine::Dependencies.rspec2? }
+        before do
+          Gem.should_receive(:available?).with("rspec", ">= 2.0").and_return(rspec2_present)
+        end
+        context "when rspec 2 is present" do
+          let(:rspec2_present) { true }
+          it { should be_true }
+        end
+        context "when rspec 2 is not present" do
+          let(:rspec2_present) { false }
+          it { should be_false }
+        end
+      end
+
+      describe ".rails2?" do
+        subject { Jasmine::Dependencies.rails2? }
+        before do
+          Gem.should_receive(:available?).with("rails", "~> 2.3").and_return(rails2_present)
+        end
+        context "when rails 2 is present and running" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+
+          let(:running_rails_version) { "2.3" }
+          let(:rails2_present) { true }
+          it { should be_true }
+        end
+        context "when rails 2 is present but not running" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+
+          let(:running_rails_version) { "3.2" }
+          let(:rails2_present) { true }
+          it { should be_false }
+        end
+        context "when rails 2 is not present" do
+          let(:rails2_present) { false }
+          it { should be_false }
+        end
+      end
+
+      describe ".legacy_rails?" do
+        subject { Jasmine::Dependencies.legacy_rails? }
+        before do
+          Gem.should_receive(:available?).with("rails", "< 2.3.11").and_return(legacy_rails_present)
+        end
+        context "when rails < 2.3.11 is present and running" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:running_rails_version) { "2.3.8" }
+          let(:legacy_rails_present) { true }
+          it { should be_true }
+        end
+
+        context "when rails < 2.3.11 is present but not running" do
+          let(:legacy_rails_present) { true }
+          it { should be_false }
+        end
+
+        context "when rails < 2.3.11 is not present" do
+          let(:legacy_rails_present) { false }
+          it { should be_false }
+        end
+      end
+
+      describe ".rails3?" do
+        subject { Jasmine::Dependencies.rails3? }
+        before do
+          Gem.should_receive(:available?).with("rails", ">= 3.0").and_return(rails3_present)
+        end
+        context "when rails 3 is present" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:running_rails_version) { "3.2" }
+          let(:rails3_present) { true }
+          it { should be_true }
+        end
+        context "when rails 3 is not present" do
+          let(:rails3_present) { false }
+          it { should be_false }
+        end
+      end
+
+      describe ".rails_3_asset_pipeline?" do
+        subject { Jasmine::Dependencies.rails_3_asset_pipeline? }
+        let(:application) { double(:application, :assets => rails_application_assets)}
+        before do
+          Gem.should_receive(:available?).with("rails", ">= 3.0").and_return(rails3_present)
+          Rails.stub(:respond_to?).with(:application).and_return(respond_to_application)
+          Rails.stub(:respond_to?).with(:version).and_return(true)
+          Rails.stub(:application).and_return(application)
+        end
+
+        context "when rails 3 is present, running, and the application pipeline is in use" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:rails3_present) { true }
+          let(:running_rails_version) { "3.2" }
+          let(:respond_to_application) { true }
+          let(:rails_application_assets) { true }
+          it { should be_true }
+        end
+        context "when rails 3 is present, running, and the application pipeline is not in use" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(true)
+            Rails.stub(:version).and_return(running_rails_version)
+          end
+          let(:rails3_present) { true }
+          let(:running_rails_version) { "3.2" }
+          let(:respond_to_application) { true }
+          let(:rails_application_assets) { false }
+          it { should be_false }
+        end
+        context "when rails 3 is present but not loaded" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(false)
+          end
+          let(:rails3_present) { true }
+          let(:respond_to_application) { false }
+          let(:rails_application_assets) { false }
+          it { should be_false }
+        end
+        context "when rails 3 is not present" do
+          before do
+            Rails.stub(:respond_to?).with(:version).and_return(false)
+          end
+          let(:rails3_present) { false }
+          let(:respond_to_application) { false }
+          let(:rails_application_assets) { false }
+          it { should be_false }
+        end
+      end
+    end
+
+    describe "legacy_rack?" do
+      it "should return false if Rack::Server exists" do
+        Rack.stub(:constants).and_return([:Server])
+        Jasmine::Dependencies.legacy_rack?.should be_false
+      end
+      it "should return true if Rack::Server does not exist" do
+        Rack.stub(:constants).and_return([])
+        Jasmine::Dependencies.legacy_rack?.should be_true
+      end
+    end
+  end
+
+end

data/spec/fixture/Rakefile

@@ -0,0 +1,4 @@
+desc "A flunk task that does not want to be trampled"
+task :jasmine_flunk do
+  nil
+end

data/spec/fixture/jasmine.erb.yml

@@ -0,0 +1,4 @@
+src_files:
+<% 3.times do |i| %>
+  - <%= "file#{i}.js" %>
+<% end %>

data/spec/fixture/spec/example_spec.js

@@ -0,0 +1,5 @@
+describe("example_spec", function() {
+  it("should be here for path loading tests", function() {
+    expect(true).toBe(true);
+  }
+})

data/spec/fixture/src/example.js

@@ -0,0 +1,3 @@
+function Example() {
+  this.is_here = "for path loading tests";
+}

data/spec/jasmine_command_line_tool_rakeless_spec.rb

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe "Jasmine command line tool" do
+  before :each do
+    temp_dir_before
+    Dir::chdir @tmp
+  end
+
+  after :each do
+    temp_dir_after
+  end
+
+  it "should create files on init" do
+    output = capture_stdout { Jasmine::CommandLineTool.new.process ["init"] }
+    output.should =~ /Jasmine has been installed with example specs./
+
+    my_jasmine_lib = File.expand_path(File.join(@root, "lib"))
+    bootstrap = "$:.unshift('#{my_jasmine_lib}')"
+
+    ENV['JASMINE_GEM_PATH'] = "#{@root}/lib"
+    ci_output = `rake -E "#{bootstrap}" --trace jasmine:ci`
+    ci_output.should =~ (/[1-9][0-9]* examples, 0 failures/)
+  end
+
+  it "should include license info" do
+    output = capture_stdout { Jasmine::CommandLineTool.new.process ["license"] }
+    output.should =~ /Copyright/
+  end
+end

data/spec/jasmine_pojs_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "POJS jasmine install" do
+
+  before :each do
+    temp_dir_before
+    Dir::chdir @tmp
+    @install_directory = 'pojs-example'
+    Dir::mkdir @install_directory
+    Dir::chdir @install_directory
+  end
+
+  after :each do
+    temp_dir_after
+  end
+
+  context "when the Jasmine generators are available" do
+    before :each do
+      `jasmine init`
+    end
+
+    it "should find the Jasmine configuration files" do
+      File.exists?("spec/javascripts/support/jasmine.yml").should == true
+    end
+
+    it "should find the Jasmine example files" do
+      File.exists?("public/javascripts/Player.js").should == true
+      File.exists?("public/javascripts/Song.js").should == true
+
+      File.exists?("spec/javascripts/PlayerSpec.js").should == true
+      File.exists?("spec/javascripts/helpers/SpecHelper.js").should == true
+
+      File.exists?("spec/javascripts/support/jasmine.yml").should == true
+    end
+
+    it "should show jasmine rake task" do
+      output = `rake -T`
+      output.should include("jasmine ")
+      output.should include("jasmine:ci")
+    end
+
+    it "should successfully run rake jasmine:ci" do
+      output = `rake jasmine:ci`
+    end
+
+  end
+end

data/spec/jasmine_rails2_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+if Jasmine::Dependencies.rails2? && !Jasmine::Dependencies.legacy_rails?
+
+  describe "A Rails 2 app" do
+
+    before :each do
+      temp_dir_before
+      Dir::chdir @tmp
+      create_rails 'rails-example'
+      Dir::chdir 'rails-example'
+    end
+
+    after :each do
+      temp_dir_after
+    end
+
+    context "before Jasmine has been installed" do
+
+      it "should not show the jasmine:install generator" do
+        output = `./script/generate --help`
+        output.should_not include('jasmine:install')
+      end
+
+      it "should not show jasmine:install help" do
+        output = `rails g`
+        output.should_not include('This will create')
+      end
+
+      it "should not show jasmine rake task" do
+        output = `rake -T`
+        output.should_not include("jasmine ")
+      end
+
+      it "should not show jasmine:ci rake task" do
+        output = `rake -T`
+        output.should_not include("jasmine:ci")
+      end
+
+    end
+
+    context "when the Jasmine generators are available" do
+      before :each do
+        `mkdir -p lib/generators && ln -s #{@root}/generators/jasmine lib/generators/jasmine`
+      end
+
+      it "should show the Jasmine generator" do
+        output = `./script/generate --help`
+        output.should include("Lib: jasmine")
+      end
+
+      it "should show jasmine:install help" do
+        output = `./script/generate jasmine --help`
+
+        output.should include("Usage: ./script/generate jasmine")
+      end
+
+      context "and been run" do
+        before :each do
+          `./script/generate jasmine`
+        end
+
+        it "should find the Jasmine configuration files" do
+          File.exists?("spec/javascripts/support/jasmine.yml").should == true
+        end
+
+        it "should find the Jasmine example files" do
+          File.exists?("public/javascripts/Player.js").should == true
+          File.exists?("public/javascripts/Song.js").should == true
+
+          File.exists?("spec/javascripts/PlayerSpec.js").should == true
+          File.exists?("spec/javascripts/helpers/SpecHelper.js").should == true
+
+          File.exists?("spec/javascripts/support/jasmine.yml").should == true
+        end
+
+        it "should show jasmine rake task" do
+          output = `rake -T`
+          output.should include("jasmine ")
+        end
+
+        it "should show jasmine:ci rake task" do
+          output = `rake -T`
+          output.should include("jasmine:ci")
+        end
+      end
+    end
+  end
+end

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_config.rb

@@ -0,0 +1,19 @@
+require 'jasmine'
+
+class JasmineSelfTestConfig < Jasmine::Config
+  def project_root
+    File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  end
+
+  def src_dir
+    File.join(project_root, 'src')
+  end
+
+  def spec_dir
+    Jasmine::Core.path
+  end
+
+  def spec_files
+    Jasmine::Core.html_spec_files + Jasmine::Core.core_spec_files
+  end
+end

data/spec/jasmine_self_test_spec.rb

@@ -0,0 +1,22 @@
+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)
+
+t = Thread.new do
+  begin
+    server.start
+  rescue ChildProcess::TimeoutError
+  end
+  # # ignore bad exits
+end
+t.abort_on_exception = true
+Jasmine::wait_for_listener(jasmine_runner_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
+formatter = Jasmine::RspecFormatter.new
+formatter.format_results(results)

data/spec/page_spec.rb

@@ -0,0 +1,25 @@
+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"],
+                     :jasmine_files => ["jasmine_file1.js", "jasmine_file2.js"])
+    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"]
+    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