teaspoon 0.7.9 → 0.8.0

data/lib/teaspoon/configuration.rb

@@ -1,77 +1,152 @@
 require "singleton"
 
 module Teaspoon
+
+  autoload :Formatters, "teaspoon/formatters/base"
+  autoload :Drivers,    "teaspoon/drivers/base"
+
   class Configuration
     include Singleton
 
-    cattr_accessor :mount_at, :context, :root, :asset_paths, :fixture_path, :suites, :driver_cli_options
-    @@mount_at           = "/teaspoon"
-    @@context            = nil # will default to Rails #relative_url_root
-    @@root               = nil # will default to Rails.root
-    @@asset_paths        = ["spec/javascripts", "spec/javascripts/stylesheets", "test/javascripts", "test/javascripts/stylesheets"]
-    @@fixture_path       = "spec/javascripts/fixtures"
-    @@suites             = {"default" => proc{}}
-    @@driver_cli_options = nil
+    # CONTRIBUTORS:
+    # If you add a configuration option you should do the following before it will be considered for merging.
+    # - think about if it should be a suite, coverage, or global configuration
+    # - write specs for it, and add it to existing specs in spec/teaspoon/configuration_spec.rb
+    # - add it to the readme so it's documented
+    # - add it to the command_line.rb if appropriate (_only_ if it's appropriate)
+    # - add it to ENV_OVERRIDES if it can be overridden from ENV
+    # - add it to the initializers in /lib/generators/install/templates so it's documented there as well
+
+    cattr_accessor   :mount_at, :root, :asset_paths, :fixture_paths
+    @@mount_at       = "/teaspoon"
+    @@root           = nil # will default to Rails.root
+    @@asset_paths    = ["spec/javascripts", "spec/javascripts/stylesheets", "test/javascripts", "test/javascripts/stylesheets"]
+    @@fixture_paths  = ["spec/javascripts/fixtures", "test/javascripts/fixtures"]
 
     # console runner specific
-    cattr_accessor :driver, :server_timeout, :server_port, :fail_fast, :formatters, :suppress_log, :color, :coverage, :coverage_reports, :coverage_output_dir, :server, :statements_coverage_threshold, :functions_coverage_threshold, :branches_coverage_threshold, :lines_coverage_threshold
-    @@driver                        = "phantomjs"
-    @@server                        = nil
-    @@server_port                   = nil
-    @@server_timeout                = 20
-    @@fail_fast                     = true
-    @@formatters                    = "dot"
-    @@suppress_log                  = false
-    @@color                         = true
-    @@coverage                      = false
-    @@coverage_reports              = nil
-    @@coverage_output_dir           = "coverage"
-    @@statements_coverage_threshold = nil
-    @@functions_coverage_threshold  = nil
-    @@branches_coverage_threshold   = nil
-    @@lines_coverage_threshold      = nil
+
+    cattr_accessor   :driver, :driver_options, :driver_timeout, :server, :server_port, :server_timeout, :fail_fast,
+                     :formatters, :color, :suppress_log,
+                     :use_coverage
+    @@driver         = "phantomjs"
+    @@driver_options = nil
+    @@driver_timeout = 180
+    @@server         = nil
+    @@server_port    = nil
+    @@server_timeout = 20
+    @@fail_fast      = true
+
+    @@formatters     = ["dot"]
+    @@color          = true
+    @@suppress_log   = false
+
+    @@use_coverage   = nil
+
+    # options that can be specified in the ENV
+
+    ENV_OVERRIDES = {
+      boolean: %w(FAIL_FAST SUPPRESS_LOG COLOR),
+      integer: %w(DRIVER_TIMEOUT SERVER_TIMEOUT),
+      string:  %w(DRIVER DRIVER_OPTIONS SERVER SERVER_PORT FORMATTERS USE_COVERAGE)
+    }
+
+    # suite configurations
+
+    cattr_accessor :suite_configs
+    @@suite_configs = {"default" => {block: proc{}}}
+
+    def self.suite(name = :default, &block)
+      @@suite_configs[name.to_s] = {block: block, instance: Suite.new(&block)}
+    end
 
     class Suite
-      attr_accessor :matcher, :helper, :stylesheets, :javascripts, :no_coverage, :boot_partial, :js_config, :hooks
+
+      FRAMEWORKS = {
+        jasmine: ["1.3.1", "2.0.0"],
+        mocha: ["1.10.0", "1.17.1"],
+        qunit: ["1.12.0", "1.14.0"],
+        angular: ["1.0.5"],
+      }
+
+      attr_accessor   :matcher, :helper, :javascripts, :stylesheets,
+                      :boot_partial, :body_partial,
+                      :no_coverage,
+                      :hooks
 
       def initialize
-        @matcher         = "{spec/javascripts,app/assets}/**/*_spec.{js,js.coffee,coffee}"
-        @helper          = "spec_helper"
-        @javascripts     = ["teaspoon-jasmine"]
-        @stylesheets     = ["teaspoon"]
-        @no_coverage     = [%r{/lib/ruby/gems/}, %r{/vendor/assets/}, %r{/support/}, %r{/(.+)_helper.}]
-        @boot_partial    = nil
-        @js_config       = {}
-
-        @hooks = Hash.new {|h, k| h[k] = [] }
-
-        default = Teaspoon.configuration.suites["default"]
-        self.instance_eval(&default) if default
+        @matcher      = "{spec/javascripts,app/assets}/**/*_spec.{js,js.coffee,coffee}"
+        @helper       = "spec_helper"
+        @javascripts  = ["jasmine/1.3.1", "teaspoon-jasmine"]
+        @stylesheets  = ["teaspoon"]
+
+        @boot_partial = "boot"
+        @body_partial = "body"
+
+        @no_coverage  = [%r{/lib/ruby/gems/}, %r{/vendor/assets/}, %r{/support/}, %r{/(.+)_helper.}]
+
+        @hooks        = Hash.new{ |h, k| h[k] = [] }
+
+        default = Teaspoon.configuration.suite_configs["default"]
+        self.instance_eval(&default[:block]) if default
         yield self if block_given?
       end
 
-      def use_require=(val) # todo: deprecated in version 0.7.4
-        puts "Deprecation Notice: use_require will be removed, set config.boot_partial to 'require_js' instead."
-        self.boot_partial = 'require_js' if val
+      def use_framework(name, version = nil)
+        name = name.to_sym
+        version ||= FRAMEWORKS[name].last if FRAMEWORKS[name]
+        unless FRAMEWORKS[name] && FRAMEWORKS[name].include?(version)
+          message = "Unknown framework \"#{name}\""
+          message += " with version #{version} -- available versions #{FRAMEWORKS[name].join(", ")}" if FRAMEWORKS[name] && version
+          raise Teaspoon::UnknownFramework, message
+        end
+
+        @javascripts = [[name, version].join("/"), "teaspoon-#{name}"]
+        case name.to_sym
+        when :qunit
+          @matcher = "{test/javascripts,app/assets}/**/*_test.{js,js.coffee,coffee}"
+          @helper  = "test_helper"
+        else
+        end
       end
+      alias_method :use_framework=, :use_framework
 
       def hook(group = :default, &block)
         @hooks[group.to_s] << block
       end
     end
 
-    def self.root=(path)
-      @@root = Pathname.new(path.to_s) if path.present?
+    # coverage configurations
+
+    cattr_accessor :coverage_configs
+    @@coverage_configs = {"default" => {block: proc{}}}
+
+    def self.coverage(name = :default, &block)
+      @@coverage_configs[name.to_s] = {block: block, instance: Coverage.new(&block)}
     end
 
-    def self.suite(name = :default, &block)
-      @@suites[name.to_s] = block
+    class Coverage
+      attr_accessor   :reports, :output_path,
+                      :statements, :functions, :branches, :lines
+
+      def initialize
+        @reports      = ["text-summary"]
+        @output_path  = "coverage"
+
+        @statements   = nil
+        @functions    = nil
+        @branches     = nil
+        @lines        = nil
+
+        default = Teaspoon.configuration.coverage_configs["default"]
+        self.instance_eval(&default[:block]) if default
+        yield self if block_given?
+      end
     end
 
-    def self.coverage_reports
-      return ["text-summary"] if @@coverage_reports.blank?
-      return @@coverage_reports if @@coverage_reports.is_a?(Array)
-      @@coverage_reports.to_s.split(/,\s?/)
+    # custom getters / setters
+
+    def self.root=(path)
+      @@root = Pathname.new(path.to_s) if path.present?
     end
 
     def self.formatters
@@ -79,29 +154,32 @@ module Teaspoon
       return @@formatters if @@formatters.is_a?(Array)
       @@formatters.to_s.split(/,\s?/)
     end
-  end
 
-  autoload :Formatters, "teaspoon/formatters/base_formatter"
-  autoload :Drivers,    "teaspoon/drivers/base_driver"
+    # override from env or options
 
-  mattr_accessor :configuration
-  @@configuration = Configuration
+    def self.override_from_options(options)
+      options.each { |k, v| override(k, v) }
+    end
 
-  def self.setup
-    yield @@configuration
-    override_from_env
+    def self.override_from_env(env)
+      ENV_OVERRIDES[:boolean].each { |o| override(o, env[o] == "true") if env[o].present? }
+      ENV_OVERRIDES[:integer].each { |o| override(o, env[o].to_i) if env[o].present? }
+      ENV_OVERRIDES[:string].each  { |o| override(o, env[o]) if env[o].present? }
+    end
+
+    def self.override(config, value)
+      setter = "#{config.to_s.downcase}="
+      send(setter, value) if respond_to?(setter)
+    end
   end
 
-  private
+  mattr_accessor :configured, :configuration
+  @@configured = false
+  @@configuration = Configuration
 
-  def self.override_from_env
-    %w(FAIL_FAST SUPPRESS_LOG COLOR COVERAGE).each do |directive|
-      next unless ENV[directive].present?
-      @@configuration.send("#{directive.downcase}=", ENV[directive] == "true")
-    end
-    %w(DRIVER DRIVER_CLI_OPTIONS SERVER SERVER_TIMEOUT SERVER_PORT FORMATTERS COVERAGE_REPORTS COVERAGE_OUTPUT_DIR).each do |directive|
-      next unless ENV[directive].present?
-      @@configuration.send("#{directive.downcase}=", ENV[directive])
-    end
+  def self.configure
+    yield @@configuration
+    @@configured = true
+    @@configuration.override_from_env(ENV)
   end
 end

data/lib/teaspoon/console.rb

@@ -1,49 +1,62 @@
-require 'open-uri'
-require 'teaspoon/environment'
+require "teaspoon/environment"
 
 module Teaspoon
   class Console
 
-    def initialize(options = nil, files = [])
-      @options = options || {}
+    def initialize(options = {})
+      @options = options
       @suites = {}
-      @files = []
-
       Teaspoon::Environment.load(@options)
 
-      start_server
-      resolve(files)
+      @server = start_server
+    rescue Teaspoon::ServerException => e
+      abort(e.message)
     end
 
-    def execute(options = {}, files = [])
-      @options = @options.merge(options) if options.present?
-      resolve(files)
+    def failures?
+      !execute
+    end
 
-      failure_count = 0
-      suites.each do |suite|
-        STDOUT.print "Teaspoon running #{suite} suite at #{url(suite)}\n" unless Teaspoon.configuration.suppress_log
-        failure_count += run_specs(suite, @options[:driver_cli_options] || Teaspoon.configuration.driver_cli_options)
-      end
-      failure_count > 0
+    def execute(options = {})
+      execute_without_handling(options)
     rescue Teaspoon::Failure
-      true
-    rescue Teaspoon::RunnerException
-      true
+      false
+    rescue Teaspoon::Error => e
+      abort(e.message)
     end
 
-    def run_specs(suite, driver_cli_options = nil)
-      url = url(suite)
-      url += url.include?("?") ? "&" : "?"
-      url += "reporter=Console"
-      driver.run_specs(suite, url, driver_cli_options)
+    def execute_without_handling(options = {})
+      @options.merge!(options)
+      @suites = {}
+      resolve(@options[:files])
+
+      0 == suites.inject(0) do |failures, suite|
+        export(suite) if @options.include?(:export)
+        failures += run_specs(suite)
+        log("") # empty line for space
+        failures
+      end
+    end
+
+    def run_specs(suite)
+      raise Teaspoon::UnknownSuite, "Unknown suite: \"#{suite}\"" unless Teaspoon.configuration.suite_configs[suite.to_s]
+      log("Teaspoon running #{suite} suite at #{base_url_for(suite)}")
+      runner = Teaspoon::Runner.new(suite)
+      driver.run_specs(runner, url_for(suite))
+      raise Teaspoon::Failure if Teaspoon.configuration.fail_fast && runner.failure_count > 0
+      runner.failure_count
+    end
+
+    def export(suite)
+      raise Teaspoon::UnknownSuite, "Unknown suite: \"#{suite}\"" unless Teaspoon.configuration.suite_configs[suite.to_s]
+      log("Teaspoon exporting #{suite} suite at #{base_url_for(suite)}")
+      Teaspoon::Exporter.new(suite, url_for(suite, false), @options[:export]).export
     end
 
     protected
 
-    def resolve(files)
-      return if files.length == 0
-      @suites = {}
-      @files = files
+    def resolve(files = [])
+      return if files.blank?
       files.uniq.each do |path|
         if result = Teaspoon::Suite.resolve_spec_for(path)
           suite = @suites[result[:suite]] ||= []
@@ -53,30 +66,50 @@ module Teaspoon
     end
 
     def start_server
-      @server = Teaspoon::Server.new
-      @server.start
+      log("Starting the Teaspoon server...")
+      server = Teaspoon::Server.new
+      server.start
+      server
     end
 
     def suites
       return [@options[:suite]] if @options[:suite].present?
       return @suites.keys if @suites.present?
-      Teaspoon.configuration.suites.keys
+      Teaspoon.configuration.suite_configs.keys
     end
 
     def driver
-      @driver ||= Teaspoon::Drivers.const_get("#{Teaspoon.configuration.driver.to_s.camelize}Driver").new
+      return @driver if @driver
+      klass = "#{Teaspoon.configuration.driver.to_s.camelize}Driver"
+      @driver = Teaspoon::Drivers.const_get(klass).new(Teaspoon.configuration.driver_options)
+    rescue NameError
+      raise Teaspoon::UnknownDriver, "Unknown driver: \"#{Teaspoon.configuration.driver}\""
+    end
+
+    def base_url_for(suite)
+      ["#{@server.url}#{Teaspoon.configuration.mount_at}", suite].join('/')
+    end
+
+    def url_for(suite, console = true)
+      url = [base_url_for(suite), filter(suite)].compact.join('?')
+      url += "#{(url.include?("?") ? "&" : "?")}reporter=Console" if console
+      url
     end
 
     def filter(suite)
       parts = []
       parts << "grep=#{URI::encode(@options[:filter])}" if @options[:filter].present?
-      (@suites[suite] || @files).flatten.each { |file| parts << "file[]=#{URI::encode(file)}" }
+      (@suites[suite] || @options[:files] || []).flatten.each { |file| parts << "file[]=#{URI::encode(file)}" }
       "#{parts.join('&')}" if parts.present?
     end
 
-    def url(suite)
-      base_url = ["#{@server.url}#{Teaspoon.configuration.mount_at}", suite].join('/')
-      [base_url, filter(suite)].compact.join('?')
+    def log(str, force = false)
+      STDOUT.print("#{str}\n") if force || !Teaspoon.configuration.suppress_log
+    end
+
+    def abort(message = nil)
+      log(message, true) if message
+      exit(1)
     end
   end
 end

data/lib/teaspoon/coverage.rb

@@ -1,36 +1,63 @@
 module Teaspoon
   class Coverage
-    include Teaspoon::Utility
 
-    def initialize(data, suite_name)
-      @data = data
+    def initialize(suite_name, config_name, data)
       @suite_name = suite_name
+      @data = data
+      @executable = Teaspoon::Instrumentation.executable
+      @config = coverage_configuration(config_name.to_s)
     end
 
-    def reports
-      Dir.mktmpdir do |path|
-        input = File.join(path, 'coverage.json')
-        File.open(input, 'w') { |file| file.write(@data.to_json) }
+    def generate_reports(&block)
+      input_path do |input|
         results = []
-        for format in Teaspoon.configuration.coverage_reports
+        for format in @config.reports
           result = generate_report(input, format)
           results << result if ["text", "text-summary"].include?(format.to_s)
         end
-        Teaspoon::CheckCoverage.new(input).check_coverage
-        "\n#{results.join("\n\n")}\n"
+        block.call(results.join("\n\n")) unless results.blank?
+      end
+    end
+
+    def check_thresholds(&block)
+      args = threshold_args
+      return if args.blank?
+      input_path do |input|
+        result = %x{#{@executable} check-coverage #{args.join(" ")} #{input.shellescape} 2>&1}
+        return if $?.exitstatus == 0
+        result = result.scan(/ERROR: .*$/).join("\n").gsub("ERROR: ", "")
+        block.call(result) unless result.blank?
       end
     end
 
     private
 
+    def coverage_configuration(name)
+      config = Teaspoon.configuration.coverage_configs[name]
+      raise Teaspoon::UnknownCoverage, "Unknown coverage configuration \"#{name}\"" unless config.present?
+      config[:instance] ||= Teaspoon::Configuration::Coverage.new(&config[:block])
+    end
+
+    def input_path(&block)
+      Dir.mktmpdir do |temp_path|
+        input_path = File.join(temp_path, "coverage.json")
+        File.open(input_path, "w") { |f| f.write(@data.to_json) }
+        block.call(input_path)
+      end
+    end
+
     def generate_report(input, format)
-      result = %x{#{executable} report #{format} #{input.shellescape} --dir #{File.join(Teaspoon.configuration.coverage_output_dir, @suite_name)}}
-      raise "Could not generate coverage report for #{format}" unless $?.exitstatus == 0
-      result.gsub("Done", "").gsub("Using reporter [#{format}]", "").strip
+      output_path = File.join(@config.output_path, @suite_name)
+      result = %x{#{@executable} report #{format} #{input.shellescape} --dir #{output_path} 2>&1}
+      return result.gsub("Done", "").gsub("Using reporter [#{format}]", "").strip if $?.exitstatus == 0
+      raise Teaspoon::DependencyFailure, "Could not generate coverage report for #{format}"
     end
 
-    def executable
-      @executable ||= istanbul()
+    def threshold_args
+      %w{statements functions branches lines}.map do |assert|
+        threshold = @config.send(:"#{assert}")
+        "--#{assert}=#{threshold}" if threshold
+      end.compact
     end
   end
 end