josephholsten-jasmine 1.1.0.pre.1

data/lib/jasmine/spec_builder.rb

@@ -0,0 +1,162 @@
+require 'enumerator'
+
+module Jasmine
+  class SpecBuilder
+    attr_accessor :suites
+
+    def initialize(config)
+      @config = config
+      @spec_files = config.spec_files
+      @runner = config
+      @spec_ids = []
+    end
+
+    def start
+      guess_example_locations
+
+      @runner.start
+      load_suite_info
+      wait_for_suites_to_finish_running
+    end
+
+    def stop
+      @runner.stop
+    end
+
+    def script_path
+      File.expand_path(__FILE__)
+    end
+
+    def guess_example_locations
+      @example_locations = {}
+
+      example_name_parts = []
+      previous_indent_level = 0
+      @config.spec_files_full_paths.each do |filename|
+        line_number = 1
+        File.open(filename, "r") do |file|
+          file.readlines.each do |line|
+            match = /^(\s*)(describe|it)\s*\(\s*["'](.*)["']\s*,\s*function/.match(line)
+            if (match)
+              indent_level = match[1].length / 2
+              example_name = match[3]
+              example_name_parts[indent_level] = example_name
+
+              full_example_name = example_name_parts.slice(0, indent_level + 1).join(" ")
+              @example_locations[full_example_name] = "#{filename}:#{line_number}: in `it'"
+            end
+            line_number += 1
+          end
+        end
+      end
+    end
+
+    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_for(spec_id)
+      @spec_results ||= load_results
+      @spec_results[spec_id.to_s]
+    end
+
+    def load_results
+      @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 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 declare_suites
+      me = self
+      suites.each do |suite|
+        declare_suite(self, suite)
+      end
+    end
+
+    def declare_suite(parent, suite)
+      me = self
+      parent.describe suite["name"] do
+        suite["children"].each do |suite_or_spec|
+          type = suite_or_spec["type"]
+          if type == "suite"
+            me.declare_suite(self, suite_or_spec)
+          elsif type == "spec"
+            me.declare_spec(self, suite_or_spec)
+          else
+            raise "unknown type #{type} for #{suite_or_spec.inspect}"
+          end
+        end
+      end
+    end
+
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      @spec_ids << spec["id"]
+      backtrace = @example_locations[parent.description + " " + example_name]
+      if Jasmine::rspec2?
+        parent.it example_name, {} do
+          me.report_spec(spec["id"])
+        end
+      else
+        parent.it example_name, {}, backtrace do
+          me.report_spec(spec["id"])
+        end
+      end
+    end
+
+    def report_spec(spec_id)
+      spec_results = results_for(spec_id)
+      out = ""
+      messages = spec_results['messages'].each do |message|
+        case
+          when message["type"] == "log"
+            puts message["text"]
+            puts "\n"
+          else
+            unless message["message"] =~ /^Passed.$/
+              STDERR << message["message"]
+              STDERR << "\n"
+
+              out << message["message"]
+              out << "\n"
+            end
+
+            if !message["passed"] && message["trace"]["stack"]
+              stack_trace = message["trace"]["stack"].gsub(/<br \/>/, "\n").gsub(/<\/?b>/, " ")
+              STDERR << stack_trace.gsub(/\(.*\)@http:\/\/localhost:[0-9]+\/specs\//, "/spec/")
+              STDERR << "\n"
+            end
+        end
+
+      end
+      fail out unless spec_results['result'] == 'passed'
+      puts out unless out.empty?
+    end
+
+    private
+
+    def eval_js(js)
+      @runner.eval_js(js)
+    end
+
+    def json_generate(obj)
+      @runner.json_generate(obj)
+    end
+  end
+end

data/lib/jasmine/tasks/jasmine.rake

@@ -0,0 +1,44 @@
+namespace :jasmine do
+  task :require do
+    require 'jasmine'
+  end
+
+  desc "Run continuous integration tests"
+  task :ci => "jasmine:require" do
+    if Jasmine::rspec2?
+      require "rspec"
+      require "rspec/core/rake_task"
+    else
+      require "spec"
+      require 'spec/rake/spectask'
+    end
+
+    if Jasmine::rspec2?
+      RSpec::Core::RakeTask.new(:jasmine_continuous_integration_runner) do |t|
+        t.rspec_opts = ["--colour", "--format", "progress"]
+        t.verbose = true
+        t.pattern = ['spec/javascripts/support/jasmine_runner.rb']
+      end
+    else
+      Spec::Rake::SpecTask.new(:jasmine_continuous_integration_runner) do |t|
+        t.spec_opts = ["--color", "--format", "specdoc"]
+        t.verbose = true
+        t.spec_files = ['spec/javascripts/support/jasmine_runner.rb']
+      end
+    end
+    Rake::Task["jasmine_continuous_integration_runner"].invoke
+  end
+
+  task :server => "jasmine:require" do
+    jasmine_config_overrides = './spec/javascripts/support/jasmine_config.rb'
+    require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+
+    puts "your tests are here:"
+    puts "  http://localhost:8888/"
+
+    Jasmine::Config.new.start_server
+  end
+end
+
+desc "Run specs via server"
+task :jasmine => ['jasmine:server']

data/lib/jasmine/version.rb

@@ -0,0 +1,3 @@
+module Jasmine
+  VERSION = "1.1.0.pre.1"
+end

data/lib/jasmine.rb

@@ -0,0 +1,14 @@
+jasmine_files = ['base',
+                 'config',
+                 'server',
+                 'selenium_driver',
+                 'spec_builder',
+                 'command_line_tool']
+
+jasmine_files.each do |file|
+  require File.join('jasmine', file)
+end
+
+require File.join('jasmine', "railtie") if Jasmine.rails3?
+
+

data/spec/config_spec.rb

@@ -0,0 +1,308 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'selenium-webdriver'
+
+describe Jasmine::Config do
+  describe "configuration" do
+    before :each do
+      temp_dir_before
+
+      Dir::chdir @tmp
+      dir_name = "test_js_project"
+      `mkdir -p #{dir_name}`
+      Dir::chdir dir_name
+      `#{@root}/bin/jasmine init .`
+
+      @project_dir  = Dir.pwd
+
+      @template_dir = File.expand_path(File.join(@root, "generators/jasmine/templates"))
+      @config       = Jasmine::Config.new
+    end
+
+    after(:each) do
+      temp_dir_after
+    end
+
+    describe "defaults" do
+      it "src_dir uses root when src dir is blank" do
+        @config.stub!(:project_root).and_return('some_project_root')
+        @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
+        YAML.stub!(:load).and_return({'src_dir' => nil})
+        @config.src_dir.should == 'some_project_root'
+      end
+
+      it "should use correct default yaml config" do
+        @config.stub!(:project_root).and_return('some_project_root')
+        @config.simple_config_file.should == (File.join('some_project_root', 'spec/javascripts/support/jasmine.yml'))
+      end
+    end
+
+    describe "simple_config" do
+      before(:each) do
+        @config.stub!(:src_dir).and_return(File.join(@project_dir, "."))
+        @config.stub!(:spec_dir).and_return(File.join(@project_dir, "spec/javascripts"))
+      end
+
+      describe "using default jasmine.yml" do
+        before(:each) do
+          @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
+        end
+
+        it "should find the source files" do
+          @config.src_files.should =~ ['public/javascripts/Player.js', 'public/javascripts/Song.js']
+        end
+
+        it "should find the stylesheet files" do
+          @config.stylesheets.should == []
+        end
+
+        it "should find the spec files" do
+          @config.spec_files.should == ['PlayerSpec.js']
+        end
+
+        it "should find any helpers" do
+          @config.helpers.should == ['helpers/SpecHelper.js']
+        end
+
+        it "should build an array of all the JavaScript files to include, source files then spec files" do
+          @config.js_files.should == [
+                  '/public/javascripts/Player.js',
+                  '/public/javascripts/Song.js',
+                  '/__spec__/helpers/SpecHelper.js',
+                  '/__spec__/PlayerSpec.js'
+          ]
+        end
+
+        it "should allow the js_files to be filtered" do
+          @config.js_files("PlayerSpec.js").should == [
+                  '/public/javascripts/Player.js',
+                  '/public/javascripts/Song.js',
+                  '/__spec__/helpers/SpecHelper.js',
+                  '/__spec__/PlayerSpec.js'
+          ]
+        end
+
+        it "should report the full paths of the spec files" do
+          @config.spec_files_full_paths.should == [File.join(@project_dir, 'spec/javascripts/PlayerSpec.js')]
+        end
+      end
+
+      it "should parse ERB" do
+        @config.stub!(:simple_config_file).and_return(File.expand_path(File.join(@root, 'spec', 'fixture','jasmine.erb.yml')))
+        Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+        @config.src_files.should == ['file0.js', 'file1.js', 'file2.js',]
+      end
+
+      describe "if jasmine.yml not found" do
+        before(:each) do
+          File.stub!(:exist?).and_return(false)
+        end
+
+        it "should default to loading no source files" do
+          @config.src_files.should be_empty
+        end
+
+        it "should default to loading no stylesheet files" do
+          @config.stylesheets.should be_empty
+        end
+
+      end
+
+      describe "if jasmine.yml is empty" do
+        before(:each) do
+          @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
+          YAML.stub!(:load).and_return(false)
+        end
+
+        it "should default to loading no source files" do
+          @config.src_files.should be_empty
+        end
+
+        it "should default to loading no stylesheet files" do
+          @config.stylesheets.should be_empty
+        end
+      end
+
+      describe "should use the first appearance of duplicate filenames" do
+        before(:each) do
+          Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+          fake_config = Hash.new.stub!(:[]).and_return { |x| ["file1.ext", "file2.ext", "file1.ext"] }
+          @config.stub!(:simple_config).and_return(fake_config)
+        end
+
+        it "src_files" do
+          @config.src_files.should == ['file1.ext', 'file2.ext']
+        end
+
+        it "stylesheets" do
+          @config.stylesheets.should == ['file1.ext', 'file2.ext']
+        end
+
+        it "spec_files" do
+          @config.spec_files.should == ['file1.ext', 'file2.ext']
+        end
+
+        it "helpers" do
+          @config.spec_files.should == ['file1.ext', 'file2.ext']
+        end
+
+        it "js_files" do
+          @config.js_files.should == ["/file1.ext",
+                                      "/file2.ext",
+                                      "/__spec__/file1.ext",
+                                      "/__spec__/file2.ext",
+                                      "/__spec__/file1.ext",
+                                      "/__spec__/file2.ext"]
+        end
+
+        it "spec_files_full_paths" do
+          @config.spec_files_full_paths.should == [
+                  File.expand_path("spec/javascripts/file1.ext", @project_dir),
+                  File.expand_path("spec/javascripts/file2.ext", @project_dir)
+          ]
+        end
+      end
+
+      describe "should allow .gitignore style negation (!pattern)" do
+        before(:each) do
+          Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+          fake_config = Hash.new.stub!(:[]).and_return { |x| ["file1.ext", "!file1.ext", "file2.ext"] }
+          @config.stub!(:simple_config).and_return(fake_config)
+        end
+
+        it "should not contain negated files" do
+          @config.src_files.should == ["file2.ext"]
+        end
+      end
+
+      it "simple_config stylesheets" do
+        @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
+
+        YAML.stub!(:load).and_return({'stylesheets' => ['foo.css', 'bar.css']})
+        Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+
+        @config.stylesheets.should == ['foo.css', 'bar.css']
+      end
+
+      it "using rails jasmine.yml" do
+        ['public/javascripts/prototype.js',
+         'public/javascripts/effects.js',
+         'public/javascripts/controls.js',
+         'public/javascripts/dragdrop.js',
+         'public/javascripts/application.js'].each { |f| `touch #{f}` }
+
+        @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine-rails.yml'))
+
+        @config.spec_files.should == ['PlayerSpec.js']
+        @config.helpers.should == ['helpers/SpecHelper.js']
+        @config.src_files.should == ['public/javascripts/prototype.js',
+                                     'public/javascripts/effects.js',
+                                     'public/javascripts/controls.js',
+                                     'public/javascripts/dragdrop.js',
+                                     'public/javascripts/application.js',
+                                     'public/javascripts/Player.js',
+                                     'public/javascripts/Song.js']
+        @config.js_files.should == [
+                '/public/javascripts/prototype.js',
+                '/public/javascripts/effects.js',
+                '/public/javascripts/controls.js',
+                '/public/javascripts/dragdrop.js',
+                '/public/javascripts/application.js',
+                '/public/javascripts/Player.js',
+                '/public/javascripts/Song.js',
+                '/__spec__/helpers/SpecHelper.js',
+                '/__spec__/PlayerSpec.js',
+        ]
+        @config.js_files("PlayerSpec.js").should == [
+                '/public/javascripts/prototype.js',
+                '/public/javascripts/effects.js',
+                '/public/javascripts/controls.js',
+                '/public/javascripts/dragdrop.js',
+                '/public/javascripts/application.js',
+                '/public/javascripts/Player.js',
+                '/public/javascripts/Song.js',
+                '/__spec__/helpers/SpecHelper.js',
+                '/__spec__/PlayerSpec.js'
+        ]
+      end
+    end
+  end
+
+  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
+        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
+
+      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
+    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
+
+      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)
+
+        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
+        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
+        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
+    end
+  end
+end

data/spec/fixture/jasmine.erb.yml

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

data/spec/jasmine_command_line_tool_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "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,51 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "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
+      File.exists?("spec/javascripts/support/jasmine_runner.rb").should == true
+      File.exists?("spec/javascripts/support/jasmine_config.rb").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
+      File.exists?("spec/javascripts/support/jasmine_runner.rb").should == true
+      File.exists?("spec/javascripts/support/jasmine_config.rb").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