teaspoon 0.7.9 → 0.8.0

data/lib/teaspoon/formatters/teamcity_formatter.rb

@@ -1,56 +1,94 @@
-require 'teaspoon/formatters/base_formatter'
-
 module Teaspoon
   module Formatters
-    class TeamcityFormatter < BaseFormatter
-      def runner(result)
-        log "##teamcity[testSuiteStarted name='Jasmine']"
+    class TeamcityFormatter < Base
+
+      def initialize(*args)
+        log("enteredTheMatrix timestamp='#{Time.now.to_json.gsub('"', "")}'")
+        super
+      end
+
+      protected
+
+      def log_runner(result)
+        log("testCount count='#{result.total}' timestamp='#{result.start}'")
       end
 
-      def spec(result)
-        log "##teamcity[testStarted name='#{escape result.description}' captureStandardOutput='false']"
+      def log_suite(result)
+        log_end_suite
+        log("testSuiteStarted name='#{result.label}'")
+      end
+
+      def log_passing_spec(result)
+        log_teamcity_spec(type: "testStarted", desc: escape(result.description))
+      end
+
+      def log_pending_spec(result)
+        log_teamcity_spec(type: "testIgnored", desc: escape(result.description))
+      end
 
-        unless result.passing? || result.pending?
-          log "##teamcity[testFailed name='#{escape result.description}' message='#{escape result.message}']"
+      def log_failing_spec(result)
+        log_teamcity_spec(type: "testStarted", desc: escape(result.description)) do
+          log("testFailed name='#{escape(result.description)}' message='#{escape(result.message)}'")
         end
+      end
 
-        log "##teamcity[testFinished name='#{escape result.description}']"
+      def log_error(result)
+        log("message text='#{escape(result.message)}' errorDetails='#{escape_trace(result.trace)}' status='ERROR'")
       end
 
-      def error(error)
-        log "##teamcity[message text='#{escape error.message}' errorDetails='#{escape format_trace(error.trace)}' status='ERROR']"
+      def log_result(result)
+        log_end_suite
+        @result = result
       end
 
-      def result(result)
-        log "##teamcity[testSuiteFinished name='Jasmine']"
+      def log_coverage(message)
+        log("testSuiteStarted name='Coverage summary'")
+        log_line(message)
+        log("testSuiteFinished name='Coverage summary'")
       end
 
-      def suppress_logs?
-        true
+      def log_threshold_failure(message)
+        log("testSuiteStarted name='Coverage thresholds'")
+        log_teamcity_spec(type: "testStarted", desc: "Coverage thresholds") do
+          log("testFailed name='Coverage thresholds' message='were not met'")
+          log_line(message)
+        end
+        log("testSuiteFinished name='Coverage thresholds'")
+      end
+
+      def log_complete(failure_count)
+        log_line("\nFinished in #{@result.elapsed} seconds")
+        stats = "#{pluralize("example", run_count)}, #{pluralize("failure", failure_count)}"
+        stats << ", #{pendings.size} pending" if pendings.size > 0
+        log_line(stats)
+        log_line if failure_count > 0
       end
 
       private
+
+      def log_end_suite
+        log("testSuiteFinished name='#{escape(@last_suite.label)}'") if @last_suite
+      end
+
+      def log_teamcity_spec(opts, &block)
+        log("#{opts[:type]} name='#{opts[:desc]}' captureStandardOutput='true'")
+        log_line(@stdout.gsub(/\n$/, "")) unless @stdout.blank?
+        yield if block_given?
+        log("testFinished name='#{opts[:desc]}'")
+      end
+
       def log(str)
-        STDOUT.print("#{str}\n")
+        log_line("##teamcity[#{str}]")
       end
 
       def escape(str)
-        {
-          /\|/m => "||",
-          /'/m => "|'",
-          /\n/m => "|n",
-          /\r/m => "|r",
-          /\[/m => "|[",
-          /\]/m => "|]",
-        }.inject(str) do |result, (regex, sub)|
-          result.gsub(regex, sub)
-        end
+        str = str.gsub(/[|'\[\]]/) { |c| "|#{c}" }
+        str.gsub("\n", "|n").gsub("\r", "|r")
       end
 
-      def format_trace(trace)
-        trace.map { |line|
-          ["#{line['file']}:#{line['line']}", line['function']].compact.join(' ')
-        }.join("\n")
+      def escape_trace(trace)
+        lines = trace.map { |t| ["#{t["file"]}:#{t["line"]}", t["function"]].compact.join(" ") }
+        escape(lines.join("\n"))
       end
     end
   end

data/lib/teaspoon/instrumentation.rb

@@ -4,56 +4,56 @@ module Teaspoon
   class Instrumentation
     extend Teaspoon::Utility
 
-    def self.executable
-      @executable ||= istanbul()
+    def self.add_to(response, env)
+      return response unless add?(response, env)
+      Teaspoon::Instrumentation.new(response).instrumented_response
     end
 
     def self.add?(response, env)
-      (
-        executable.present? &&                                          # we have an executable
-        env["QUERY_STRING"].to_s =~ /instrument=(1|true)/ &&            # the instrument param was provided
-        response[0] == 200 &&                                           # the status is 200
-        response[1]["Content-Type"].to_s == "application/javascript" && # the format is something that we care about
-        response[2].respond_to?(:source)                                # it looks like an asset
-      )
+      executable &&                                                   # we have an executable
+      env["QUERY_STRING"].to_s =~ /instrument=(1|true)/ &&            # the instrument param was provided
+      response[0] == 200 &&                                           # the status is 200 (304 might be needed here too)
+      response[1]["Content-Type"].to_s == "application/javascript" && # the format is something that we care about
+      response[2].respond_to?(:source)                                # it looks like an asset
     end
 
-    def self.add_to(response, env)
-      return response unless add?(response, env)
-      Teaspoon::Instrumentation.new(response)
-      response
+    def self.executable
+      return @executable if @executable_checked
+      @executable_checked = true
+      @executable = which("istanbul")
     end
 
     def initialize(response)
-      status, headers, @asset = response
-      headers, @asset = [headers.clone, @asset.clone]
-      result = process_and_instrument
-      length = result.bytesize.to_s
+      @response = response
+    end
 
-      headers["Content-Length"] = length
-      @asset.instance_variable_set(:@source, result)
-      @asset.instance_variable_set(:@length, length)
+    def instrumented_response
+      status, headers, asset = @response
+      headers, asset = [headers.clone, asset.clone]
 
-      response.replace([status, headers, @asset])
-    end
+      result = add_instrumentation(asset)
 
-    private
+      asset.instance_variable_set(:@source, result)
+      asset.instance_variable_set(:@length, headers["Content-Length"] = result.bytesize.to_s)
+
+      [status, headers, asset]
+    end
 
-    def process_and_instrument
-      file = @asset.pathname.to_s
-      Dir.mktmpdir do |path|
-        filename = File.basename(file)
-        input = File.join(path, filename).sub(/\.js.+/, ".js")
-        File.open(input, 'w') { |file| file.write(@asset.source) }
+    protected
 
-        instrument(input).gsub(input, file)
+    def add_instrumentation(asset)
+      source_path = asset.pathname.to_s
+      Dir.mktmpdir do |temp_path|
+        input_path = File.join(temp_path, File.basename(source_path)).sub(/\.js.+/, ".js")
+        File.open(input_path, 'w') { |f| f.write(asset.source) }
+        instrument(input_path).gsub(input_path, source_path)
       end
     end
 
     def instrument(input)
-      result = %x{#{Teaspoon::Instrumentation.executable} instrument --embed-source #{input.shellescape}}
-      raise "Could not generate instrumentation for #{File.basename(input)}" unless $?.exitstatus == 0
-      result
+      result = %x{#{self.class.executable} instrument --embed-source #{input.shellescape}}
+      return result if $?.exitstatus == 0
+      raise Teaspoon::DependencyFailure, "Could not generate instrumentation for #{File.basename(input)}"
     end
   end
 

data/lib/teaspoon/result.rb

@@ -13,7 +13,8 @@ module Teaspoon
     :total,
     :start,
     :level,
-    :coverage
+    :coverage,
+    :original_json,
   ]
 
   class Result < Struct.new(*RESULT_ATTRS)

data/lib/teaspoon/runner.rb

@@ -4,56 +4,68 @@ require "teaspoon/result"
 module Teaspoon
   class Runner
 
-    attr_accessor :formatters
-    attr_reader   :failure_count
+    attr_reader :failure_count
 
     def initialize(suite_name = :default)
       @suite_name = suite_name
-      @formatters = Teaspoon.configuration.formatters.map{ |f| resolve_formatter(f).new(suite_name) }
       @failure_count = 0
-    end
-
-    def suppress_logs?
-      return @suppress_logs unless @suppress_logs.nil?
-      @suppress_logs = Teaspoon.configuration.suppress_log
-      return true if @suppress_logs
-      for formatter in @formatters
-        return @suppress_logs = true if formatter.suppress_logs?
-      end
-      @suppress_logs = false
+      @formatters = Teaspoon.configuration.formatters.map{ |f| resolve_formatter(f) }
     end
 
     def process(line)
-      return if output_from(line)
-      log line unless suppress_logs?
+      if result = result_from_line(line)
+        return notify_formatters(result.type, result)
+      end
+      notify_formatters("console", line) unless Teaspoon.configuration.suppress_log
     end
 
     private
 
     def resolve_formatter(formatter)
-      Teaspoon::Formatters.const_get("#{formatter.to_s.camelize}Formatter")
+      formatter, output = formatter.to_s.split(">")
+      formatter = Teaspoon::Formatters.const_get("#{formatter.camelize}Formatter")
+      formatter.new(@suite_name, output)
+    rescue NameError
+      raise Teaspoon::UnknownFormatter, "Unknown formatter: \"#{formatter}\""
     end
 
-    def output_from(line)
+    def notify_formatters(event, result)
+      @formatters.each { |f| f.send(event, result) if f.respond_to?(event) }
+      send(:"on_#{event}", result) if respond_to?(:"on_#{event}", true)
+    end
+
+    def result_from_line(line)
       json = JSON.parse(line)
       return false unless json && json["_teaspoon"] && json["type"]
-      result = Teaspoon::Result.build_from_json(json)
-      notify_formatters result
-      @failure_count += 1 if result.failing?
-      return true
+      json["original_json"] = line
+      return result_from_json(json)
     rescue JSON::ParserError
       false
     end
 
-    def notify_formatters(result)
-      @formatters.each do |formatter|
-        event = result.type
-        formatter.send(event, result) if formatter.respond_to?(event)
-      end
+    def result_from_json(json)
+      result = Teaspoon::Result.build_from_json(json)
+      @failure_count += 1 if result.failing?
+      result
+    end
+
+    def on_exception(result)
+      raise Teaspoon::RunnerException, result.message
+    end
+
+    def on_result(result)
+      resolve_coverage(result.coverage)
+      notify_formatters("complete", @failure_count)
     end
 
-    def log(msg)
-      STDOUT.print msg
+    def resolve_coverage(data)
+      return unless Teaspoon.configuration.use_coverage && data.present?
+      coverage = Teaspoon::Coverage.new(@suite_name, Teaspoon.configuration.use_coverage, data)
+      coverage.generate_reports { |msg| notify_formatters("coverage", msg) }
+      coverage.check_thresholds do |msg|
+        notify_formatters("threshold_failure", msg)
+        @failure_count += 1
+      end
     end
   end
 end

data/lib/teaspoon/server.rb

@@ -5,51 +5,50 @@ require "webrick"
 module Teaspoon
   class Server
 
+    attr_accessor :port
+
     def initialize
-      @port = find_available_port
-      if defined?(Thin)
-        if Teaspoon.configuration.suppress_log
-          Thin::Logging.silent = true
-        else
-          Thin::Logging.trace = false
-        end
-      end
+      @port = Teaspoon.configuration.server_port || find_available_port
     end
 
     def start
-      STDOUT.print "Starting the Teaspoon server...\n" unless Teaspoon.configuration.suppress_log
-      @thread = Thread.new do
+      thread = Thread.new do
+        disable_logging
         server = Rack::Server.new(rack_options)
         server.start
       end
-      wait_until_started
+      wait_until_started(thread)
     rescue => e
-      raise "Cannot start server: #{e.message}"
-    end
-
-    def wait_until_started
-      Timeout.timeout(Teaspoon.configuration.server_timeout.to_i) { @thread.join(0.1) until responsive? }
-    rescue Timeout::Error
-      raise "Server failed to start. You may need to increase the timeout configuration."
+      raise Teaspoon::ServerException, "Cannot start server: #{e.message}"
     end
 
     def responsive?
-      return false if @thread && @thread.join(0)
       TCPSocket.new("127.0.0.1", port).close
-      return true
+      true
     rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-      return false
+      false
     end
 
     def url
       "http://127.0.0.1:#{port}"
     end
 
-    def port
-      @port
+    protected
+
+    def wait_until_started(thread)
+      Timeout.timeout(Teaspoon.configuration.server_timeout.to_i) { thread.join(0.1) until responsive? }
+    rescue Timeout::Error
+      raise Teaspoon::ServerException, "Server failed to start. You may need to increase the timeout configuration."
     end
 
-    protected
+    def disable_logging
+      return unless defined?(Thin)
+      if Teaspoon.configuration.suppress_log
+        Thin::Logging.silent = true
+      else
+        Thin::Logging.trace = false
+      end
+    end
 
     def rack_options
       {
@@ -63,7 +62,6 @@ module Teaspoon
     end
 
     def find_available_port
-      return Teaspoon.configuration.server_port if Teaspoon.configuration.server_port
       server = TCPServer.new("127.0.0.1", 0)
       server.addr[1]
     ensure

data/lib/teaspoon/suite.rb

@@ -1,78 +1,79 @@
 module Teaspoon
   class Suite
 
-    attr_accessor :config, :name
-
     def self.all
-      Teaspoon.configuration.suites.keys.map { |suite| Teaspoon::Suite.new(suite: suite) }
+      @all ||= Teaspoon.configuration.suite_configs.keys.map { |suite| Teaspoon::Suite.new(suite: suite) }
     end
 
     def self.resolve_spec_for(file)
-      suites = all
-      suites.each do |suite|
+      all.each do |suite|
         spec = suite.include_spec_for?(file)
         return {suite: suite.name, path: spec} if spec
       end
       false
     end
 
+    attr_accessor :config, :name
+    delegate      :helper, :stylesheets, :javascripts, :boot_partial, :body_partial, :no_coverage, :hooks,
+                  to: :config
+
     def initialize(options = {})
       @options = options
       @name = (@options[:suite] || :default).to_s
       @config = suite_configuration
+      @env = Rails.application.assets
     end
 
-    def stylesheets
-      config.stylesheets
-    end
-
-    def helper
-      config.helper
-    end
-
-    def javascripts
-      [core_javascripts, spec_javascripts].flatten
-    end
-
-    def core_javascripts
-      config.javascripts
+    def spec_files
+      glob.map { |file| {path: file, name: asset_from_file(file)} }
     end
 
-    def js_config
-      config.js_config
+    def spec_assets(include_helper = true)
+      assets = specs
+      assets.unshift(helper) if include_helper && helper
+      asset_tree(assets)
     end
 
-    def boot_partial
-      config.boot_partial
+    def include_spec?(file)
+      glob.include?(file)
     end
 
-    def spec_javascripts
-      [helper, specs].flatten
+    def include_spec_for?(file)
+      return file if glob.include?(file)
+      paths = glob.select { |path| path.include?(file)  }
+      return paths unless paths.empty?
+      false
     end
 
-    def spec_javascripts_for_require
-      specs.map { |path|
-        file_without_ext = path.split('.').first
-        "#{file_without_ext}"
-      }
-    end
+    protected
 
-    def suites
-      {all: Teaspoon.configuration.suites.keys, active: name}
+    def specs
+      files = specs_from_file
+      return files unless files.empty?
+      glob.map { |file| asset_from_file(file) }
     end
 
-    def spec_files
-      glob.map { |file| {path: file, name: asset_from_file(file)} }
+    def asset_tree(sources)
+      sources.collect do |source|
+        asset = @env.find_asset(source)
+        if asset && asset.respond_to?(:logical_path)
+          asset.to_a.map { |a| asset_url(a) }
+        else
+          source unless source.blank?
+        end
+      end.flatten.compact.uniq
     end
 
-    def link(params = {})
-      query = "/?#{params.to_query}" if params.present?
-      "#{Teaspoon.configuration.context}#{Teaspoon.configuration.mount_at}/#{name}#{query}"
+    def asset_url(asset)
+      params = "?body=1"
+      params << "&instrument=1" if instrument_file?(asset.pathname.to_s)
+      "#{asset.logical_path}#{params}"
     end
 
     def instrument_file?(file)
+      return false unless @options[:coverage] || Teaspoon.configuration.use_coverage
       return false if include_spec?(file)
-      for ignored in @config.no_coverage
+      for ignored in no_coverage
         if ignored.is_a?(String)
           return false if File.basename(file) == ignored
         elsif ignored.is_a?(Regexp)
@@ -82,29 +83,18 @@ module Teaspoon
       true
     end
 
-    def include_spec?(file)
-      glob.include?(file)
-    end
-
-    def include_spec_for?(file)
-      return file if glob.include?(file)
-      paths = glob.select { |path| path.include?(file)  }
-      return paths unless paths.empty?
-      false
-    end
-
-    def run_hooks(group = :default)
-      config.hooks[group.to_s].each do |hook|
-        hook.call
+    def asset_from_file(original)
+      filename = original
+      Rails.application.config.assets.paths.each do |path|
+        filename = filename.gsub(%r(^#{Regexp.escape(path.to_s)}[\/|\\]), "")
       end
-    end
 
-    protected
+      raise Teaspoon::AssetNotServable, "#{filename} is not within an asset path" if filename == original
+      normalize_js_extension(filename)
+    end
 
-    def specs
-      files = specs_from_file
-      return files unless files.empty?
-      glob.map { |file| asset_from_file(file) }
+    def normalize_js_extension(filename)
+      filename.gsub('.erb', '').gsub(/(\.js\.coffee|\.coffee)$/, ".js")
     end
 
     def glob
@@ -112,9 +102,9 @@ module Teaspoon
     end
 
     def suite_configuration
-      config = Teaspoon.configuration.suites[name]
-      raise Teaspoon::UnknownSuite unless config.present?
-      Teaspoon::Configuration::Suite.new(&config)
+      config = Teaspoon.configuration.suite_configs[name]
+      raise Teaspoon::UnknownSuite, "Unknown suite \"#{name}\"" unless config.present?
+      config[:instance] ||= Teaspoon::Configuration::Suite.new(&config[:block])
     end
 
     def specs_from_file
@@ -122,15 +112,5 @@ module Teaspoon
         asset_from_file(File.expand_path(Teaspoon.configuration.root.join(filename)))
       end
     end
-
-    def asset_from_file(original)
-      filename = original
-      Rails.application.config.assets.paths.each do |path|
-        path = path.to_s
-        filename = filename.gsub(%r(^#{Regexp.escape(path)}[\/|\\]), "")
-      end
-      raise Teaspoon::AssetNotServable, "#{filename} is not within an asset path" if filename == original
-      filename.gsub('.erb', '').gsub(/(\.js\.coffee|\.coffee)$/, ".js")
-    end
   end
 end