assert 0.7.3 → 0.8.0

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "0.7.3"
+  VERSION = "0.8.0"
 end

data/lib/assert/view/base.rb

@@ -0,0 +1,75 @@
+require 'assert/result'
+require 'assert/options'
+
+module Assert::View
+
+  class Base
+
+    # setup some default options for all views
+
+    include Assert::Options
+    options do
+      default_pass_abbrev   '.'
+      default_fail_abbrev   'F'
+      default_ignore_abbrev 'I'
+      default_skip_abbrev   'S'
+      default_error_abbrev  'E'
+    end
+
+    # include a bunch of common helper methods
+
+    require 'assert/view/helpers/common'
+    include Helpers::Common
+
+    attr_accessor :suite, :output_io
+
+    def initialize(output_io, suite=Assert.suite)
+      @output_io = output_io
+      @suite     = suite
+
+      if @output_io.respond_to?(:sync=)
+        @output_io.sync = true
+      end
+    end
+
+    def view; self; end
+
+    def fire(callback, *args)
+      self.send(callback, *args)
+    end
+
+    # Callbacks
+
+    # define callback handlers to output information.  handlers are
+    # instance_eval'd in the scope of the view instance.  any stdout is captured
+    # and sent to the io stream.
+
+    # available callbacks from the runner:
+    # * `before_load`: called at the beginning, before the suite is loaded
+    # * `after_load`:  called after the suite is loaded, just before `on_start`
+    #                  functionally equivalent to `on_start`
+    # * `on_start`:    called when a loaded test suite starts running
+    # * `before_test`: called before a test starts running
+    #                  the test is passed as an arg
+    # * `on_result`:   called when a running tests generates a result
+    #                  the result is passed as an arg
+    # * `after_test`:  called after a test finishes running
+    #                  the test is passed as an arg
+    # * `on_finish`:   called when the test suite is finished running
+
+    def before_load;       end
+    def after_load;        end
+    def on_start;          end
+    def before_test(test); end
+    def on_result(result); end
+    def after_test(test);  end
+    def on_finish;         end
+
+    # IO capture
+
+    def puts(*args); @output_io.puts(*args); end
+    def print(*args); @output_io.print(*args); end
+
+  end
+
+end

data/lib/assert/view/default_view.rb

@@ -0,0 +1,75 @@
+require 'assert/view/base'
+
+module Assert::View
+
+  # This is the default view used by assert.  It renders ansi test output
+  # designed for terminal viewing.
+
+  class DefaultView < Base
+    require 'assert/view/helpers/capture_output'
+    include Helpers::CaptureOutput
+
+    require 'assert/view/helpers/ansi_styles'
+    include Helpers::AnsiStyles
+
+    options do
+      styled         true
+      pass_styles    :green
+      fail_styles    :red, :bold
+      error_styles   :yellow, :bold
+      skip_styles    :cyan
+      ignore_styles  :magenta
+    end
+
+    def after_load
+      puts "Loaded suite (#{test_count_statement})"
+    end
+
+    def on_start
+      if tests?
+        puts "Running tests in random order, seeded with \"#{runner_seed}\""
+      end
+    end
+
+    def on_result(result)
+      result_abbrev = options.send("#{result.to_sym}_abbrev")
+      styled_abbrev = ansi_styled_msg(result_abbrev, result_ansi_styles(result))
+
+      print styled_abbrev
+    end
+
+    def on_finish
+      if tests?
+        print "\n"
+        puts
+
+        # output detailed results for the tests in reverse test/result order
+        tests = suite.ordered_tests.reverse
+        result_details_for(tests, :reversed).each do |details|
+          if show_result_details?(details.result)
+            # output the styled result details
+            result = details.result
+            puts ansi_styled_msg(result.to_s, result_ansi_styles(result))
+
+            # output any captured stdout
+            output = details.output
+            puts captured_output(output) if output && !output.empty?
+
+            puts
+          end
+        end
+      end
+
+      # style the summaries of each result set
+      styled_results_sentence = results_summary_sentence do |summary, sym|
+        ansi_styled_msg(summary, result_ansi_styles(sym))
+      end
+
+      puts "#{result_count_statement}: #{styled_results_sentence}"
+      puts
+      puts "(#{run_time} seconds)"
+    end
+
+  end
+
+end

data/lib/assert/view/helpers/ansi_styles.rb

@@ -0,0 +1,25 @@
+require 'ansi/code'
+
+module Assert::View::Helpers
+
+  module AnsiStyles
+
+    def result_ansi_styles(result)
+      view.options.styled ? view.options.send("#{result.to_sym}_styles") : []
+    end
+
+    def ansi_styled_msg(msg, styles=[])
+      if !(style = ansi_style(*styles)).empty?
+        style + msg + ANSI.send(:reset)
+      else
+        msg
+      end
+    end
+
+    def ansi_style(*ansi_codes)
+      ansi_codes.collect{|code| ANSI.send(code) rescue nil}.compact.join('')
+    end
+
+  end
+
+end

data/lib/assert/view/helpers/capture_output.rb

@@ -0,0 +1,23 @@
+module Assert::View::Helpers
+
+  module CaptureOutput
+
+    def captured_output(output)
+      if !output.empty?
+        # TODO: move to the base view
+        [ captured_output_start_msg,
+          output + captured_output_end_msg
+        ].join("\n")
+      end
+    end
+
+    def captured_output_start_msg
+      "--- stdout ---"
+    end
+    def captured_output_end_msg
+      "--------------"
+    end
+
+  end
+
+end

data/lib/assert/view/helpers/common.rb

@@ -0,0 +1,154 @@
+module Assert::View::Helpers
+
+  class ResultDetails
+
+    attr_reader :result, :test_index, :test, :output
+
+    def initialize(result, test, test_index)
+      @result = result
+      @test = test
+      @test_index = test_index
+      @output = test.output
+    end
+  end
+
+  module Common
+
+    # get the formatted suite run time
+    def run_time(format='%.6f')
+      format % self.suite.run_time
+    end
+
+    def runner_seed
+      self.suite.runner_seed
+    end
+
+    def count(type)
+      self.suite.count(type)
+    end
+
+    def tests?
+      self.count(:tests) > 0
+    end
+
+    def all_pass?
+      self.count(:pass) == self.count(:results)
+    end
+
+    # get a uniq list of contexts for the test suite
+    def suite_contexts
+      @suite_contexts ||= self.suite.tests.inject([]) do |contexts, test|
+        contexts << test.context_info.klass
+      end.uniq
+    end
+
+    def ordered_suite_contexts
+      self.suite_contexts.sort{|a,b| a.to_s <=> b.to_s}
+    end
+
+    # get a uniq list of files containing contexts for the test suite
+    def suite_files
+      @suite_files ||= self.suite.tests.inject([]) do |files, test|
+        files << test.context_info.file
+      end.uniq
+    end
+
+    def ordered_suite_files
+      self.suite_files.sort{|a,b| a.to_s <=> b.to_s}
+    end
+
+    # get all the result details for a set of tests
+    def result_details_for(tests, result_order=:normal)
+      test_index = 0
+      tests.collect do |test|
+        test_index += 1
+
+        details = test.results.
+          collect { |result| ResultDetails.new(result, test, test_index) }
+
+        details.reverse! if result_order == :reversed
+
+        details
+      end.compact.flatten
+    end
+
+    # get all the result details for a set of tests matching a file or context
+    def matched_result_details_for(match, tests, result_order=:normal)
+      context_match = match.kind_of?(Class) && match.ancestors.include?(Assert::Context)
+      file_match = match.kind_of?(String)
+
+      matching_tests = if context_match
+        tests.select {|test| test.context_info.klass == match}
+      elsif file_match
+        tests.select {|test| test.context_info.file == match}
+      else
+        tests
+      end
+
+      result_details_for(matching_tests, result_order)
+    end
+
+    # only show result details for failed or errored results
+    # show result details if a skip or passed result was issues w/ a message
+    def show_result_details?(result)
+      ([:fail, :error].include?(result.to_sym)) ||
+      ([:skip, :ignore].include?(result.to_sym) && result.message)
+    end
+
+    # return a list of result symbols that have actually occurred
+    def ocurring_result_types
+      @result_types ||= [
+        :pass, :fail, :ignore, :skip, :error
+      ].select { |result_sym| self.count(result_sym) > 0 }
+    end
+
+    # print a result summary message for a given result type
+    def result_summary_msg(result_type)
+      if result_type == :pass && self.all_pass?
+        self.all_pass_result_summary_msg
+      else
+        "#{self.count(result_type)} #{result_type.to_s}"
+      end
+    end
+
+    # generate an appropriate result summary msg for all tests passing
+    def all_pass_result_summary_msg
+      if self.count(:results) < 1
+        "uhh..."
+      elsif self.count(:results) == 1
+        "pass"
+      else
+        "all pass"
+      end
+    end
+
+    # generate a sentence fragment describing the breakdown of test results
+    # if a block is given, yield each msg in the breakdown for custom formatting
+    def results_summary_sentence
+      summaries = self.ocurring_result_types.collect do |result_sym|
+        summary_msg = self.result_summary_msg(result_sym)
+        block_given? ? yield(summary_msg, result_sym) : summary_msg
+      end
+      self.to_sentence(summaries)
+    end
+
+    def test_count_statement
+      "#{self.count(:tests)} test#{'s' if self.count(:tests) != 1}"
+    end
+
+    def result_count_statement
+      "#{self.count(:results)} result#{'s' if self.count(:results) != 1}"
+    end
+
+    # generate a comma-seperated sentence fragment given a list of things
+    def to_sentence(things)
+      if things.size <= 2
+        things.join(things.size == 2 ? ' and ' : '')
+      else
+        [things[0..-2].join(", "), things.last].join(", and ")
+      end
+    end
+
+  end
+
+end

data/test/assertions/assert_file_exists_test.rb

@@ -0,0 +1,43 @@
+require 'assert'
+
+class Assert::Assertions::AssertFileExistsTests < Assert::Context
+  desc "the assert_file_exists helper run in a test"
+  setup do
+    fail_desc = @fail_desc = "assert file exists empty fail desc"
+    fail_args = @fail_args = [ '/a/path/to/some/file/that/no/exists', fail_desc ]
+    @test = Factory.test do
+      assert_file_exists(__FILE__) # pass
+      assert_file_exists(*fail_args) # fail
+    end
+    @test.run
+  end
+  subject{ @test }
+
+  should "have 2 total results" do
+    assert_equal 2, subject.result_count
+  end
+  should "have 1 pass result" do
+    assert_equal 1, subject.result_count(:pass)
+  end
+  should "have 1 fail result" do
+    assert_equal 1, subject.result_count(:fail)
+  end
+
+  class FailMessageTest < AssertFileExistsTests
+    desc "with a failed result"
+    setup do
+      @expected = [
+        @fail_args[1],
+        "Expected #{@fail_args[0].inspect} to exist."
+      ].join("\n")
+      @fail_message = @test.fail_results.first.message
+    end
+    subject{ @fail_message }
+
+    should "have a fail message with an explanation of what failed and my fail description" do
+      assert_equal @expected, subject
+    end
+
+  end
+
+end

data/test/assertions/assert_not_file_exists_test.rb

@@ -0,0 +1,43 @@
+require 'assert'
+
+class Assert::Assertions::AssertNotFileExistsTests < Assert::Context
+  desc "the assert_not_file_exists helper run in a test"
+  setup do
+    fail_desc = @fail_desc = "assert not file exists empty fail desc"
+    fail_args = @fail_args = [ __FILE__, fail_desc ]
+    @test = Factory.test do
+      assert_not_file_exists('/a/path/to/some/file/that/no/exists') # pass
+      assert_not_file_exists(*fail_args) # fail
+    end
+    @test.run
+  end
+  subject{ @test }
+
+  should "have 2 total results" do
+    assert_equal 2, subject.result_count
+  end
+  should "have 1 pass result" do
+    assert_equal 1, subject.result_count(:pass)
+  end
+  should "have 1 fail result" do
+    assert_equal 1, subject.result_count(:fail)
+  end
+
+  class FailMessageTest < AssertNotFileExistsTests
+    desc "with a failed result"
+    setup do
+      @expected = [
+        @fail_args[1],
+        "Expected #{@fail_args[0].inspect} to not exist."
+      ].join("\n")
+      @fail_message = @test.fail_results.first.message
+    end
+    subject{ @fail_message }
+
+    should "have a fail message with an explanation of what failed and my fail description" do
+      assert_equal @expected, subject
+    end
+
+  end
+
+end