teaspoon 0.7.9 → 0.8.0

data/lib/teaspoon/formatters/base.rb

@@ -0,0 +1,171 @@
+module Teaspoon
+  module Formatters
+
+    # CONTRIBUTORS:
+    # If you add a formatter you should do the following before it will be considered for merging.
+    # - add it to this list so it can be autoloaded
+    # - write specs for it
+    # - add it to the readme so it's documented
+    # - add it to the list in command_line.rb so others know it's available
+    # - add it to the initializers in /lib/generators/install/templates so it's documented there as well
+
+    autoload :CleanFormatter,         "teaspoon/formatters/clean_formatter"
+    autoload :DocumentationFormatter, "teaspoon/formatters/documentation_formatter"
+    autoload :DotFormatter,           "teaspoon/formatters/dot_formatter"
+    autoload :JsonFormatter,          "teaspoon/formatters/json_formatter"
+    autoload :JunitFormatter,         "teaspoon/formatters/junit_formatter"
+    autoload :PrideFormatter,         "teaspoon/formatters/pride_formatter"
+    autoload :SnowdayFormatter,       "teaspoon/formatters/snowday_formatter"
+    autoload :SwayzeOrOprahFormatter, "teaspoon/formatters/swayze_or_oprah_formatter"
+    autoload :TapFormatter,           "teaspoon/formatters/tap_formatter"
+    autoload :TapYFormatter,          "teaspoon/formatters/tap_y_formatter"
+    autoload :TeamcityFormatter,      "teaspoon/formatters/teamcity_formatter"
+
+    class Base
+
+      attr_accessor :total_count, :run_count, :passes, :pendings, :failures, :errors
+
+      def initialize(suite_name = :default, output_file = nil)
+        @suite_name  = suite_name.to_s
+        @output_file = output_file
+        @stdout      = ""
+        @suite       = nil
+        @last_suite  = nil
+
+        @total_count = 0
+        @run_count   = 0
+        @passes      = []
+        @pendings    = []
+        @failures    = []
+        @errors      = []
+        File.open(@output_file, "w") { |f| f.write("") } if @output_file
+      end
+
+      # beginning of the run
+      def runner(result, log = true)
+        @total_count = result.total
+        log_runner(result) if log
+      end
+
+      # each suite, before any specs
+      def suite(result, log = true)
+        @suite = result
+        log_suite(result) if log
+        @last_suite = result
+      end
+
+      # each spec, after the spec has reported to the client runner
+      def spec(result, log = true)
+        @run_count += 1
+        if result.passing?
+          @passes << result
+        elsif result.pending?
+          @pendings << result
+        else
+          @failures << result
+        end
+        log_spec(result) if log
+        @stdout = ""
+      end
+
+      # errors are reported from the onError handler in phantomjs, so they're not linked to a result
+      def error(result, log = true)
+        @errors << result
+        log_error(result) if log
+      end
+
+      # exception came from startup errors in the server (will exit after logging)
+      def exception(result = {}, log = true)
+        log_exception(result) if log
+      end
+
+      # console message come from console.log/debug/error
+      def console(message, log = true)
+        @stdout << message
+        log_console(message) if log
+      end
+
+      # final report
+      def result(result, log = true)
+        log_result(result) if log
+      end
+
+      # called with the text versions of coverage if configured to do so
+      def coverage(message, log = true)
+        log_coverage(message) if log
+      end
+
+      # called with an array of strings which explain which coverage thresholds failed
+      def threshold_failure(message, log = true)
+        log_threshold_failure(message) if log
+      end
+
+      def complete(failure_count, log = true)
+        log_complete(failure_count) if log
+      end
+
+      protected
+
+      def log_runner(result); end
+
+      def log_suite(result); end
+
+      def log_spec(result)
+        return log_passing_spec(result) if result.passing?
+        return log_pending_spec(result) if result.pending?
+        log_failing_spec(result)
+      end
+
+      def log_passing_spec(result); end
+
+      def log_pending_spec(result); end
+
+      def log_failing_spec(result); end
+
+      def log_error(result); end
+
+      def log_exception(result); end
+
+      def log_console(message); end
+
+      def log_result(result); end
+
+      def log_coverage(message); end
+
+      def log_threshold_failure(message); end
+
+      def log_complete(failure_count); end
+
+      private
+
+      def log_str(str, color_code = nil)
+        return log_to_file(str, @output_file) if @output_file
+        STDOUT.print(color_code ? colorize(str, color_code) : str)
+      end
+
+      def log_line(str = "", color_code = nil)
+        return log_to_file("#{str}\n", @output_file) if @output_file
+        STDOUT.print("#{color_code ? colorize(str, color_code) : str}\n")
+      end
+
+      def log_to_file(str, output_file)
+        @_output_file = File.open(output_file, "a") { |f| f.write(str) }
+      rescue IOError => e
+        raise Teaspoon::FileNotWritable, e.message
+      end
+
+      def colorize(str, color_code)
+        return str unless Teaspoon.configuration.color || @output_file
+        "\e[#{color_code}m#{str}\e[0m"
+      end
+
+      def pluralize(str, value)
+        value == 1 ? "#{value} #{str}" : "#{value} #{str}s"
+      end
+
+      def filename(file)
+        file.gsub(%r(^http://127.0.0.1:\d+/assets/), "").gsub(/[\?|&]?body=1/, "")
+      end
+    end
+  end
+end

data/lib/teaspoon/formatters/clean_formatter.rb

@@ -1,13 +1,11 @@
-require 'teaspoon/formatters/dot_formatter'
-
 module Teaspoon
   module Formatters
     class CleanFormatter < DotFormatter
 
+      private
+
       def log_failed_examples
-        log "\n" if failures.size > 0
       end
-
     end
   end
 end

data/lib/teaspoon/formatters/documentation_formatter.rb

@@ -0,0 +1,60 @@
+require "teaspoon/formatters/modules/report_module"
+
+module Teaspoon
+  module Formatters
+    class DocumentationFormatter < Base
+      include ReportModule
+
+      protected
+
+      def initialize(*args)
+        @level = 0
+        super
+      end
+
+      def log_suite(result)
+        log_indent_line(result.label, result.level)
+        @level = result.level
+      end
+
+      def log_passing_spec(result)
+        log_indent_spec(result.label, GREEN)
+      end
+
+      def log_pending_spec(result)
+        log_indent_spec("#{result.label} (PENDING)", YELLOW)
+      end
+
+      def log_failing_spec(result)
+        log_indent_spec("#{result.label} (FAILED - #{@failures.length})", RED)
+      end
+
+      def log_result(result)
+        log_line
+        super
+      end
+
+      private
+
+      def log_indent_spec(str, color)
+        log_indent_line(str, level = (@last_suite ? @level + 1 : 0), color)
+        log_intent_stdout(level + 1)
+      end
+
+      def log_intent_stdout(level)
+        return if @stdout.blank?
+        log_indent_line("# #{@stdout.gsub(/\n$/, "").gsub("\n", "\n# ")}", level, CYAN)
+      end
+
+      def log_indent_line(str = "", level = nil, color = nil)
+        log_line(indent(str, level || @level), color)
+      end
+
+      def indent(str = "", level = nil)
+        indent = "#{"  " * level}"
+        str.gsub!("\n", "\n#{indent}")
+        "#{indent}#{str}"
+      end
+    end
+  end
+end

data/lib/teaspoon/formatters/dot_formatter.rb

@@ -1,103 +1,25 @@
-require 'teaspoon/formatters/base_formatter'
+require "teaspoon/formatters/modules/report_module"
 
 module Teaspoon
   module Formatters
-    class DotFormatter < BaseFormatter
-
-      RED = 31
-      GREEN = 32
-      YELLOW = 33
-      CYAN = 36
-
-      def spec(result, logged = false)
-        super(result)
-        return if logged
-        if result.passing?
-          log ".", GREEN
-        elsif result.pending?
-          log "*", YELLOW
-        else
-          log "F", RED
-        end
-      end
-
-      # Errors are reported from the onError handler in Phantom, so they're not linked to a result
-      def error(error)
-        log "#{error["message"]}\n", RED
-        for trace in error["trace"] || []
-          log "  # #{filename(trace["file"])}:#{trace["line"]}#{trace["function"].present? ? " -- #{trace["function"]}" : ""}\n", CYAN
-        end
-        log "\n"
-      end
-
-      def result(results)
-        log "\n\n"
-        log_information
-        log_stats(results)
-        log_failed_examples
-        super
-      end
+    class DotFormatter < Base
+      include ReportModule
 
       protected
 
-      def log_information
-        log_pending if pendings.size > 0
-        log_failures if failures.size > 0
-      end
-
-      def log_pending
-        log "Pending:\n"
-        pendings.each do |result|
-          log "  #{result.description}\n", YELLOW
-          log "    # Not yet implemented\n\n", CYAN
-        end
-      end
-
-      def log_failures
-        log "Failures:\n\n"
-        failures.each_with_index do |failure, index|
-          log "  #{index + 1}) #{failure.description}\n"
-          log "     Failure/Error: #{failure.message}\n\n", RED
-        end
+      def log_spec(result)
+        return log_str(".", GREEN) if result.passing?
+        return log_str("*", YELLOW) if result.pending?
+        log_str("F", RED)
       end
 
-      def log_stats(results)
-        log "Finished in #{results["elapsed"]} seconds\n"
-        stats = "#{pluralize("example", total)}, #{pluralize("failure", failures.size)}"
-        stats << ", #{pendings.size} pending" if pendings.size > 0
-        log "#{stats}\n", stats_color
-        log "\n" unless failures.size == 0
+      def log_console(message)
+        log_str(message)
       end
 
-      def log_failed_examples
-        return if failures.size == 0
-        log "Failed examples:\n\n"
-        failures.each do |failure|
-          log "teaspoon -s #{@suite_name} --filter=\"#{failure.link}\"\n", RED
-        end
-      end
-
-      private
-
-      def log(str, color_code = nil)
-        STDOUT.print(color_code ? colorize(str, color_code) : str)
-      end
-
-      def colorize(str, color_code)
-        return str unless Teaspoon.configuration.color
-        "\e[#{color_code}m#{str}\e[0m"
-      end
-
-      def pluralize(str, value)
-        value == 1 ? "#{value} #{str}" : "#{value} #{str}s"
-      end
-
-      def stats_color
-        failures.size > 0 ? RED : pendings.size > 0 ? YELLOW : GREEN
-      end
-
-      def filename(file)
-        file.gsub(%r(^http://127.0.0.1:\d+/assets/), "").gsub(/[\?|&]?body=1/, "")
+      def log_result(result)
+        log_line("\n")
+        super
       end
     end
   end

data/lib/teaspoon/formatters/json_formatter.rb

@@ -0,0 +1,36 @@
+module Teaspoon
+  module Formatters
+    class JsonFormatter < Base
+
+      protected
+
+      def log_runner(result)
+        log_result(result)
+      end
+
+      def log_suite(result)
+        log_result(result)
+      end
+
+      def log_spec(result)
+        log_result(result)
+      end
+
+      def log_error(result)
+        log_result(result)
+      end
+
+      def log_exception(result)
+        log_result(result)
+      end
+
+      def log_console(message)
+        log_line(%Q{{"type":"console","log":"#{message.gsub(/\n$/, "").gsub("\n", "\\n")}"}})
+      end
+
+      def log_result(result)
+        log_str(result.original_json)
+      end
+    end
+  end
+end

data/lib/teaspoon/formatters/junit_formatter.rb

@@ -1,59 +1,78 @@
-require 'teaspoon/formatters/base_formatter'
+require "cgi"
 
 module Teaspoon
   module Formatters
-    class JunitFormatter < BaseFormatter
+    class JunitFormatter < Base
 
-      def runner(result)
-        @count = result.total;
+      protected
 
-        log "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-        log "<testsuites name=\"jasmine\"><testsuite name=\"#{result.suite}\" tests=\"#{@count}\">"
+      def log_runner(result)
+        log_line(%Q{<?xml version="1.0" encoding="UTF-8"?>})
+        log_line(%Q{<testsuites name="Teaspoon">})
+        log_line(%Q{<testsuite name="#{@suite_name}" tests="#{@total_count}" time="#{result.start}">})
       end
 
-      def spec(result)
-        super
-        @result = result
-        return passing_spec if result.passing?
-        return pending_spec if result.pending?
-        failing_spec
+      def log_suite(result)
+        log_end_suite
+        log_line(%Q{<testsuite name="#{result.label}">})
       end
 
-      def error(error)
-        @errors << error
+      def log_passing_spec(result)
+        log_junit_spec(suite: result.suite, label: result.label)
       end
 
-      def result(result)
-        log "</testsuite></testsuites>"
+      def log_pending_spec(result)
+        log_junit_spec(suite: result.suite, label: result.label) do
+          log_line(%Q{  <skipped/>})
+        end
       end
 
-      def suppress_logs?
-        false
+      def log_failing_spec(result)
+        log_junit_spec(suite: result.suite, label: result.label) do
+          log_line(%Q{  <failure type="AssertionFailed">#{cdata(result.message)}</failure>})
+        end
       end
 
-      private
+      def log_result(result)
+        log_end_suite
+      end
 
-      def passing_spec
-        log %Q[<testcase classname="#{@result.suite}" name="#{@result.label}"></testcase>\n]
+      def log_coverage(message)
+        log_line(%Q{<testsuite name="Coverage summary" tests="0">\n<properties>#{cdata(message)}<properties>\n</testsuite>})
       end
 
-      def pending_spec
-        log %Q[<testcase classname="#{@result.suite}" name="#{@result.label}"><skipped /></testcase>\n]
+      def log_threshold_failure(message)
+        log_line(%Q{<testsuite name="Coverage thresholds" tests="1">})
+        log_junit_spec(suite: "Coverage thresholds", label: "were not met") do
+          log_line(%Q{  <failure type="AssertionFailed">#{cdata(message)}</failure>})
+        end
+        log_line(%Q{</testsuite>})
       end
 
-      def failing_spec
-        str = <<EOL;
-<testcase classname="#{@result.suite}" name="#{@result.label}">
-<failure type="AssertionFailed">#{@result.message}</failure>
-</testcase>\n
-EOL
-        log str
+      def log_complete(failure_count)
+        log_line(%Q{</testsuite>\n</testsuites>})
       end
 
-      def log(str)
-        STDOUT.print("#{str}\n")
+      private
+
+      def log_end_suite
+        log_line(%Q{</testsuite>}) if @last_suite
       end
 
+      def log_junit_spec(opts, &block)
+        log_line(%Q{<testcase classname="#{escape(opts[:suite])}" name="#{escape(opts[:label])}">})
+        yield if block_given?
+        log_line(%Q{<system-out>#{cdata(@stdout)}</system-out>}) unless @stdout.blank?
+        log_line(%Q{</testcase>})
+      end
+
+      def escape(str)
+        CGI::escapeHTML(str)
+      end
+
+      def cdata(str)
+        "\n<![CDATA[\n#{str.gsub(/\n$/, "")}\n]]>\n"
+      end
     end
   end
 end