jasmine 2.0.0.rc2 → 2.0.0.rc3

data/lib/jasmine/config.rb

@@ -1,4 +1,5 @@
 module Jasmine
+  ConfigNotFound = Class.new(Exception)
   require 'yaml'
   require 'erb'
   def self.configure(&block)
@@ -25,7 +26,15 @@ module Jasmine
     @config.jasmine_css_files = lambda { core_config.css_files }
     @config.add_rack_path(jasmine_path, lambda { Rack::File.new(config.jasmine_dir) })
     @config.add_rack_path(boot_path, lambda { Rack::File.new(config.boot_dir) })
-    @config.add_rack_path(spec_path, lambda { Rack::File.new(config.spec_dir) })
+    if Jasmine::Dependencies.use_asset_pipeline?
+      @config.add_rack_path(spec_path, lambda {
+        sprockets_spec_env = Sprockets::Environment.new
+        sprockets_spec_env.append_path @config.spec_dir
+        sprockets_spec_env
+      })
+    else
+      @config.add_rack_path(spec_path, lambda { Rack::File.new(config.spec_dir) })
+    end
     @config.add_rack_path(image_path, lambda { Rack::File.new(core_config.images_dir) })
     @config.add_rack_path(src_path, lambda {
       Rack::Cascade.new([
@@ -42,23 +51,24 @@ module Jasmine
         asset_expander = Jasmine::AssetExpander.new(Jasmine::AssetBundle.factory)
         Jasmine::AssetPipelineMapper.new(config, asset_expander.method(:expand))
       })
-      @config.add_rack_path(Rails.application.config.assets.prefix, lambda {
-        # In order to have asset helpers like asset_path and image_path, we need to require 'action_view/base'.  This
-        # triggers run_load_hooks on action_view which, in turn, causes sprockets/railtie to load the Sprockets asset
-        # helpers.  Alternatively, you can include the helpers yourself without loading action_view/base:
-        Rails.application.assets.context_class.instance_eval do
-          if Jasmine::Dependencies.rails3?
-            include ::Sprockets::Helpers::IsolatedHelper
-            include ::Sprockets::Helpers::RailsHelper
-          end
-          if Jasmine::Dependencies.rails4?
-            include ::Sprockets::Rails::Helper
-          end
+      # In order to have asset helpers like asset_path and image_path, we need to require 'action_view/base'.  This
+      # triggers run_load_hooks on action_view which, in turn, causes sprockets/railtie to load the Sprockets asset
+      # helpers.  Alternatively, you can include the helpers yourself without loading action_view/base:
+      Rails.application.assets.context_class.instance_eval do
+        if Jasmine::Dependencies.rails3?
+          include ::Sprockets::Helpers::IsolatedHelper
+          include ::Sprockets::Helpers::RailsHelper
         end
+        if Jasmine::Dependencies.rails4?
+          include ::Sprockets::Rails::Helper
+        end
+      end
+      @config.add_rack_path(Rails.application.config.assets.prefix, lambda {
         Rails.application.assets
       })
     end
 
+    @config.runner = lambda { |formatter, jasmine_server_url| Jasmine::Runners::PhantomJs.new(formatter, jasmine_server_url, 50) }
   end
 
   def self.config
@@ -88,6 +98,8 @@ module Jasmine
         config.spec_files = lambda { yaml_config.helpers + yaml_config.spec_files }
       end
       require yaml_config.spec_helper if File.exist?(yaml_config.spec_helper)
+    else
+     raise ConfigNotFound, "Unable to load jasmine config from #{path}"
     end
   end
 

data/lib/jasmine/configuration.rb

@@ -5,11 +5,9 @@ module Jasmine
     attr_accessor :jasmine_path, :spec_path, :boot_path, :src_path, :image_path
     attr_accessor :jasmine_dir, :spec_dir, :boot_dir, :src_dir, :images_dir
     attr_accessor :formatters
-    #TODO: these are largely client concerns, move them.
-    attr_accessor :port, :browser, :host, :result_batch_size
-    attr_accessor :selenium_server, :selenium_server_port, :webdriver
-    attr_accessor :junit_xml_path
-    attr_accessor :spec_format, :jasmine_port
+    attr_accessor :host
+    attr_accessor :spec_format
+    attr_accessor :runner
 
     def initialize()
       @rack_paths = {}
@@ -21,12 +19,11 @@ module Jasmine
       @boot_files = lambda { [] }
       @src_files = lambda { [] }
       @spec_files = lambda { [] }
+      @runner = lambda { |config| }
 
       @formatters = [Jasmine::Formatters::Console]
 
-      @browser = 'firefox'
-      @junit_xml_path = Dir.getwd
-      @jasmine_port = 8888
+      @server_port = 8888
     end
 
     def css_files
@@ -61,22 +58,30 @@ module Jasmine
       @path_mappers << mapper.call(self)
     end
 
-    def port
-      @port ||= Jasmine.find_unused_port
+    def server_port=(port)
+      @server_port = port
     end
 
-    def host
-      @host || 'http://localhost'
+    def ci_port=(port)
+      @ci_port = port
     end
 
-    def result_batch_size
-      @result_batch_size || 50
+    def port(server_type)
+      if server_type == :server
+        @server_port
+      else
+        @ci_port ||= Jasmine.find_unused_port
+      end
+    end
+
+    def host
+      @host || 'http://localhost'
     end
 
     private
 
-    def map(paths, type)
-      @path_mappers.inject(paths.call)  do |paths, mapper|
+    def map(path_procs, type)
+      @path_mappers.inject(path_procs.call) do |paths, mapper|
         if mapper.respond_to?("map_#{type}_paths")
           mapper.send("map_#{type}_paths", paths)
         else

data/lib/jasmine/dependencies.rb

@@ -23,7 +23,7 @@ module Jasmine
       end
 
       def use_asset_pipeline?
-        (rails3? || rails4?) && Rails.respond_to?(:application) && Rails.application.respond_to?(:assets) && Rails.application.assets
+        (rails3? || rails4?) && Rails.respond_to?(:application) && Rails.application.respond_to?(:assets)
       end
 
       private

data/lib/jasmine/formatters/console.rb

@@ -1,25 +1,33 @@
 module Jasmine
   module Formatters
-    class Console < BaseFormatter
-      def format
-        puts failures
-        puts summary
+    class Console
+      def initialize(outputter = Kernel.method(:puts))
+        @results = []
+        @outputter = outputter
       end
 
-      def summary
-        summary = "#{pluralize(results.size, 'spec')}, " +
-          "#{pluralize(results.failures.size, 'failure')}"
+      def format(results_batch)
+        outputter.call(failures(results_batch))
+        @results += results_batch
+      end
 
-        summary += ", #{pluralize(results.pending_specs.size, 'pending spec')}" unless results.pending_specs.empty?
+      def done
+        failure_count = results.count(&:failed?)
+        pending_count = results.count(&:pending?)
+        summary = "#{pluralize(results.size, 'spec')}, " +
+          "#{pluralize(failure_count, 'failure')}"
 
-        summary
-      end
+        summary += ", #{pluralize(pending_count, 'pending spec')}" if pending_count > 0
 
-      def failures
-        results.failures.map { |f| failure_message(f) }.join("\n\n")
+        outputter.call(summary)
       end
 
       private
+      attr_reader :results, :outputter
+
+      def failures(results)
+        results.select(&:failed?).map { |f| failure_message(f) }.join("\n\n")
+      end
 
       def pluralize(count, str)
         word = (count == 1) ? str : str + 's'
@@ -42,4 +50,4 @@ module Jasmine
       end
     end
   end
-end
+end

data/lib/jasmine/formatters/exit_code.rb

@@ -0,0 +1,21 @@
+module Jasmine
+  module Formatters
+    class ExitCode
+      def initialize
+        @results = []
+      end
+
+      def format(results)
+        @results += results
+      end
+
+      def done
+      end
+
+      def exit_code
+        @results.detect(&:failed?) ? 1 : 0
+      end
+    end
+  end
+end
+

data/lib/jasmine/formatters/multi.rb

@@ -0,0 +1,25 @@
+module Jasmine
+  module Formatters
+    class Multi
+      def initialize(formatters)
+        @formatters = formatters
+      end
+
+      def format(results)
+        go(:format, results)
+      end
+
+      def done
+        go(:done)
+      end
+
+      private
+
+      def go(method, *args)
+        (@formatters || []).each do |formatter|
+          formatter.public_send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/jasmine/result.rb

@@ -0,0 +1,46 @@
+module Jasmine
+  class Result
+
+    def self.map_raw_results(raw_results)
+      raw_results.map { |r| new(r) }
+    end
+
+    def initialize(attrs)
+      @status = attrs["status"]
+      @full_name = attrs["fullName"]
+      @description = attrs["description"]
+      @failed_expectations = map_failures(attrs["failedExpectations"])
+      @suite_name = full_name.slice(0, full_name.size - description.size - 1)
+    end
+
+    def succeeded?
+      status == 'passed'
+    end
+
+    def failed?
+      status == 'failed'
+    end
+
+    def pending?
+      status == 'pending'
+    end
+
+    attr_reader :full_name, :description, :failed_expectations, :suite_name
+
+    private
+    attr_reader :status
+
+    def map_failures(failures)
+      failures.map do |e|
+        short_stack = if e["stack"]
+                        e["stack"].split("\n").slice(0, 7).join("\n")
+                      else
+                        "No stack trace present."
+                      end
+        Failure.new(e["message"], short_stack)
+      end
+    end
+
+    class Failure < Struct.new(:message, :stack); end
+  end
+end

data/lib/jasmine/run.html.erb

@@ -2,6 +2,7 @@
 <html xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
 <head>
   <meta content="text/html;charset=UTF-8" http-equiv="Content-Type"/>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
   <title>Jasmine suite</title>
   <link rel="shortcut icon" type="image/png" href="/__images__/jasmine_favicon.png">
   <% css_files.each do |css_file| %>
@@ -12,7 +13,8 @@
   <% end %>
 
 </head>
-<body>
+<!-- TODO: turbolinks breaks spec filter links -->
+<body data-no-turbolink>
 <div id="jasmine_content"></div>
 </body>
 </html>

data/lib/jasmine/runners/phantom_jasmine_run.js

@@ -0,0 +1,54 @@
+(function() {
+  /**
+   * Wait until the test condition is true or a timeout occurs. Useful for waiting
+   * on a server response or for a ui change (fadeIn, etc.) to occur.
+   *
+   * @param testFx javascript condition that evaluates to a boolean,
+   * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
+   * as a callback function.
+   * @param onReady what to do when testFx condition is fulfilled,
+   * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
+   * as a callback function.
+   */
+  function waitFor(testFx, onReady) {
+    var condition = false,
+    interval = setInterval(function() {
+      if (!condition) {
+        condition = (typeof(testFx) === 'string' ? eval(testFx) : testFx());
+      } else {
+        if (typeof(onReady) === 'string') {
+          eval(onReady);
+        } else {
+          onReady();
+        }
+        clearInterval(interval);
+      }
+    }, 100);
+  }
+
+  var url = phantom.args[0];
+  var batchSize = parseInt(phantom.args[1], 10);
+  var page = require('webpage').create();
+
+  page.open(url, function(status) {
+    if (status !== "success") {
+      phantom.exit(1);
+    } else {
+      waitFor(function() {
+        return page.evaluate(function() {
+          return jsApiReporter && jsApiReporter.finished
+        });
+      }, function() {
+        var index = 0, results;
+        do {
+          results = page.evaluate(function(index, batchSize) {
+            return jsApiReporter.specResults(index, batchSize)
+          }, index, batchSize);
+          console.log(JSON.stringify(results));
+          index += batchSize;
+        } while (results && results.length == batchSize)
+        phantom.exit(0);
+      });
+    }
+  });
+}).call(this);

data/lib/jasmine/runners/phantom_js.rb

@@ -0,0 +1,29 @@
+require 'phantomjs'
+
+module Jasmine
+  module Runners
+    class PhantomJs
+      def initialize(formatter, jasmine_server_url, result_batch_size)
+        @formatter = formatter
+        @jasmine_server_url = jasmine_server_url
+        @result_batch_size = result_batch_size
+      end
+
+      def run
+        command = "#{Phantomjs.path} '#{File.join(File.dirname(__FILE__), 'phantom_jasmine_run.js')}' #{jasmine_server_url} #{result_batch_size}"
+        IO.popen(command) do |output|
+          output.each do |line|
+            raw_results = JSON.parse(line, :max_nesting => false)
+            results = raw_results.map { |r| Result.new(r) }
+            formatter.format(results)
+          end
+        end
+        formatter.done
+      end
+
+      private
+      attr_reader :formatter, :jasmine_server_url, :result_batch_size
+    end
+  end
+end
+

data/lib/jasmine/tasks/jasmine.rake

@@ -1,7 +1,14 @@
 namespace :jasmine do
-  require 'jasmine/config'
+  task :configure do
+    require 'jasmine/config'
 
-  Jasmine.load_configuration_from_yaml
+    begin
+      Jasmine.load_configuration_from_yaml(ENV['JASMINE_CONFIG_PATH'])
+    rescue Jasmine::ConfigNotFound => e
+      puts e.message
+      exit 1
+    end
+  end
 
   task :require do
     require 'jasmine'
@@ -17,30 +24,44 @@ namespace :jasmine do
   end
 
   desc 'Run continuous integration tests'
-  task :ci => %w(jasmine:require_json jasmine:require) do
-    require 'rspec'
-    require 'rspec/core/rake_task'
-
-    RSpec::Core::RakeTask.new(:jasmine_continuous_integration_runner) do |t|
-      t.rspec_opts = ['--colour', '--format', Jasmine.config.spec_format || 'progress']
-      t.verbose = true
-      if Jasmine::Dependencies.use_asset_pipeline?
-        t.rspec_opts += ["-r #{File.expand_path(File.join(::Rails.root, 'config', 'environment'))}"]
+  task :ci => %w(jasmine:require_json jasmine:require jasmine:configure) do
+    config = Jasmine.config
+
+    server = Jasmine::Server.new(config.port(:ci), Jasmine::Application.app(config))
+    t = Thread.new do
+      begin
+        server.start
+      rescue ChildProcess::TimeoutError
       end
-      t.pattern = [Jasmine.runner_filepath]
+      # # ignore bad exits
     end
+    t.abort_on_exception = true
+    Jasmine::wait_for_listener(config.port(:ci), 'jasmine server')
+    puts 'jasmine server started.'
+
+    formatters = config.formatters.map { |formatter_class| formatter_class.new }
+
+    exit_code_formatter = Jasmine::Formatters::ExitCode.new
+    formatters << exit_code_formatter
+
+    url = "#{config.host}:#{config.port(:ci)}/"
+    runner = config.runner.call(Jasmine::Formatters::Multi.new(formatters), url)
+    runner.run
 
-    Rake::Task['jasmine_continuous_integration_runner'].invoke
+    exit exit_code_formatter.exit_code
   end
 
-  task :server => 'jasmine:require' do
-    port = Jasmine.config.jasmine_port || 8888
-    puts 'your tests are here:'
-    puts "  http://localhost:#{port}/"
-    app = Jasmine::Application.app(Jasmine.config)
-    Jasmine::Server.new(port, app).start
+  task :server => %w(jasmine:require jasmine:configure) do
+    config = Jasmine.config
+    port = config.port(:server)
+    server = Jasmine::Server.new(port, Jasmine::Application.app(Jasmine.config))
+    puts "your server is running here: http://localhost:#{port}/"
+    puts "your tests are here:         #{config.spec_dir}"
+    puts "your source files are here:  #{config.src_dir}"
+    puts ''
+    server.start
   end
 end
 
-desc 'Run specs via server'
-task :jasmine => %w(jasmine:server)
+desc 'Run specs via server:ci'
+task :jasmine => %w(jasmine:server)