assert 2.14.0 → 2.15.0

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.14.0"
+  VERSION = "2.15.0"
 end

data/lib/assert/view.rb

@@ -1,25 +1,112 @@
-require 'assert/view/default_view'
-
-module Assert::View
-
-  # this method is used to bring in custom user-specific views
-  # require views by passing either a full path to the view ruby file
-  # or passing the name of a view installed in ~/.assert/views
-
-  def self.require_user_view(view_name)
-    views_file = File.expand_path(
-      File.join("#{ENV['HOME']}/.assert/views", view_name, 'lib', view_name)
-    )
-
-    if File.exists?(view_name) || File.exists?(view_name + '.rb')
-      require view_name
-    elsif File.exists?(views_file + '.rb')
-      require views_file
-    else
-      msg = "[WARN] Can't find or require #{view_name.inspect} view."
-      msg << " Did you install it in `~/.assert/views`?" if !view_name.match(/\A\//)
-      warn msg
+require 'assert/config'
+require 'assert/suite'
+require 'assert/view_helpers'
+
+module Assert
+
+  module View
+
+    # this method is used to bring in custom user-specific views
+    # require views by passing either a full path to the view ruby file
+    # or passing the name of a view installed in ~/.assert/views
+
+    def self.require_user_view(view_name)
+      views_file = File.expand_path(
+        File.join("#{ENV['HOME']}/.assert/views", view_name, 'lib', view_name)
+      )
+
+      if File.exists?(view_name) || File.exists?(view_name + '.rb')
+        require view_name
+      elsif File.exists?(views_file + '.rb')
+        require views_file
+      else
+        msg = "[WARN] Can't find or require #{view_name.inspect} view."
+        msg << " Did you install it in `~/.assert/views`?" if !view_name.match(/\A\//)
+        warn msg
+      end
+    end
+
+    class Base
+      include Assert::ViewHelpers
+
+      # setup options and their default values
+
+      option 'styled',        false
+      option 'pass_styles'    # none
+      option 'fail_styles'    # none
+      option 'error_styles'   # none
+      option 'skip_styles'    # none
+      option 'ignore_styles'  # none
+
+      option 'pass_abbrev',   '.'
+      option 'fail_abbrev',   'F'
+      option 'ignore_abbrev', 'I'
+      option 'skip_abbrev',   'S'
+      option 'error_abbrev',  'E'
+
+      attr_reader :config
+
+      def initialize(config, output_io)
+        @config , @output_io, = config, output_io
+        @output_io.sync = true if @output_io.respond_to?(:sync=)
+      end
+
+      def view
+        self
+      end
+
+      def is_tty?
+        !!@output_io.isatty
+      end
+
+      def ansi_styled_msg(msg, result_or_sym)
+        return msg if !self.is_tty? || !self.styled
+        code = Assert::ViewHelpers::Ansi.code_for(*self.send("#{result_or_sym.to_sym}_styles"))
+        return msg if code.empty?
+        code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)
+      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.
+
+      def fire(callback, *args)
+        self.send(callback, *args)
+      end
+
+      # 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
+      # * `on_interrupt`: called when the test suite is interrupted while running
+      #                   the interrupt exception is passed as an arg
+
+      def before_load(test_files); 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
+      def on_interrupt(err);       end
+
+      # IO capture
+
+      def puts(*args); @output_io.puts(*args); end
+      def print(*args); @output_io.print(*args); end
+
     end
+
   end
 
 end

data/lib/assert/view_helpers.rb

@@ -0,0 +1,238 @@
+require 'assert/config_helpers'
+
+module Assert
+
+  module ViewHelpers
+
+    def self.included(receiver)
+      receiver.class_eval do
+        include Assert::ConfigHelpers
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+
+      def option(name, *default_vals)
+        default = default_vals.size > 1 ? default_vals : default_vals.first
+        define_method(name) do |*args|
+          if !(value = args.size > 1 ? args : args.first).nil?
+            instance_variable_set("@#{name}", value)
+          end
+          (val = instance_variable_get("@#{name}")).nil? ? default : val
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      # get the formatted run time for an idividual test
+      def test_run_time(test, format = '%.6f')
+        format % test.run_time
+      end
+
+      # get the formatted result rate for an individual test
+      def test_result_rate(test, format = '%.6f')
+        format % test.result_rate
+      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 do |result|
+            ResultDetails.new(result, test, test_index)
+          end
+          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
+
+      # show any captured output
+      def captured_output(output)
+        "--- stdout ---\n"\
+        "#{output}"\
+        "--------------"
+      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 items
+      def to_sentence(items)
+        if items.size <= 2
+          items.join(items.size == 2 ? ' and ' : '')
+        else
+          [items[0..-2].join(", "), items.last].join(", and ")
+        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
+
+      # 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 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.map 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
+
+    end
+
+    module Ansi
+
+      # Table of supported styles/codes (http://en.wikipedia.org/wiki/ANSI_escape_code)
+
+      CODES = {
+        :clear            => 0,
+        :reset            => 0,
+        :bright           => 1,
+        :bold             => 1,
+        :faint            => 2,
+        :dark             => 2,
+        :italic           => 3,
+        :underline        => 4,
+        :underscore       => 4,
+        :blink            => 5,
+        :slow_blink       => 5,
+        :rapid            => 6,
+        :rapid_blink      => 6,
+        :invert           => 7,
+        :inverse          => 7,
+        :reverse          => 7,
+        :negative         => 7,
+        :swap             => 7,
+        :conceal          => 8,
+        :concealed        => 8,
+        :hide             => 9,
+        :strike           => 9,
+
+        :default_font     => 10,
+        :font_default     => 10,
+        :font0            => 10,
+        :font1            => 11,
+        :font2            => 12,
+        :font3            => 13,
+        :font4            => 14,
+        :font5            => 15,
+        :font6            => 16,
+        :font7            => 17,
+        :font8            => 18,
+        :font9            => 19,
+        :fraktur          => 20,
+        :bright_off       => 21,
+        :bold_off         => 21,
+        :double_underline => 21,
+        :clean            => 22,
+        :italic_off       => 23,
+        :fraktur_off      => 23,
+        :underline_off    => 24,
+        :blink_off        => 25,
+        :inverse_off      => 26,
+        :positive         => 26,
+        :conceal_off      => 27,
+        :show             => 27,
+        :reveal           => 27,
+        :crossed_off      => 29,
+        :crossed_out_off  => 29,
+
+        :black            => 30,
+        :red              => 31,
+        :green            => 32,
+        :yellow           => 33,
+        :blue             => 34,
+        :magenta          => 35,
+        :cyan             => 36,
+        :white            => 37,
+
+        :on_black         => 40,
+        :on_red           => 41,
+        :on_green         => 42,
+        :on_yellow        => 43,
+        :on_blue          => 44,
+        :on_magenta       => 45,
+        :on_cyan          => 46,
+        :on_white         => 47,
+
+        :frame            => 51,
+        :encircle         => 52,
+        :overline         => 53,
+        :frame_off        => 54,
+        :encircle_off     => 54,
+        :overline_off     => 55,
+      }
+
+      def self.code_for(*style_names)
+        style_names.map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }.compact.join('')
+      end
+
+    end
+
+    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
+
+  end
+
+end

data/test/support/factory.rb

@@ -32,19 +32,36 @@ module Factory
   # Generate a no-op test for use in testing.
 
   def self.test(*args, &block)
-    opts, config, context_info, name = [
-      args.last.kind_of?(::Hash) ? args.pop.dup : {},
+    config, context_info, name = [
       args.last.kind_of?(Assert::Config) ? args.pop : self.modes_off_config,
       args.last.kind_of?(Assert::Suite::ContextInfo) ? args.pop : self.context_info,
       args.last.kind_of?(::String) ? args.pop : 'a test'
     ]
-    Assert::Test.new(name, context_info, config, opts, &block)
+    Assert::Test.for_block(name, context_info, config, &block)
   end
 
-  # Generate a skip result for use in testing.
+  # Generate results for use in testing.
 
-  def self.skip_result(name, exception)
-    Assert::Result::Skip.new(Factory.test(name), exception)
+  def self.pass_result(msg = nil)
+    Assert::Result::Pass.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+  end
+
+  def self.ignore_result(msg = nil)
+    Assert::Result::Ignore.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+  end
+
+  def self.fail_result(msg = nil)
+    Assert::Result::Fail.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+  end
+
+  def self.skip_result(exception = nil)
+    exception ||= Assert::Result::TestSkipped.new
+    Assert::Result::Skip.for_test(Factory.test(Factory.string), exception)
+  end
+
+  def self.error_result(exception = nil)
+    exception ||= StandardError.new
+    Assert::Result::Error.for_test(Factory.test(Factory.string), exception)
   end
 
   def self.modes_off_config

data/test/system/test_tests.rb

@@ -0,0 +1,359 @@
+require 'assert'
+
+class Assert::Test
+
+  class SystemTests < Assert::Context
+    desc "Assert::Test"
+    subject{ @test }
+
+  end
+
+  class NoResultsTests < SystemTests
+    desc "when producing no results"
+    setup do
+      @test = Factory.test
+      @test.run
+    end
+
+    should "have 0 results" do
+      assert_equal 0, subject.result_count
+    end
+
+  end
+
+  class PassTests < SystemTests
+    desc "when passing a single assertion"
+    setup do
+      @test = Factory.test{ assert(1 == 1) }
+      @test.run
+    end
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+  end
+
+  class FailTests < SystemTests
+    desc "when failing a single assertion"
+    setup do
+      @test = Factory.test{ assert(1 == 0) }
+      @test.run
+    end
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+  end
+
+  class SkipTests < SystemTests
+    desc "when skipping once"
+    setup do
+      @test = Factory.test{ skip }
+      @test.run
+    end
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+
+    should "have 1 skip result" do
+      assert_equal 1, subject.result_count(:skip)
+    end
+
+  end
+
+  class ErrorTests < SystemTests
+    desc "when erroring once"
+    setup do
+      @test = Factory.test{ raise("WHAT") }
+      @test.run
+    end
+
+    should "have 1 result" do
+      assert_equal 1, subject.result_count
+    end
+
+    should "have 1 error result" do
+      assert_equal 1, subject.result_count(:error)
+    end
+
+  end
+
+  class MixedTests < SystemTests
+    desc "when passing 1 assertion and failing 1 assertion"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        assert(1 == 0)
+      end
+      @test.run
+    end
+
+    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
+
+  end
+
+  class MixedSkipTests < SystemTests
+    desc "when passing 1 assertion and failing 1 assertion with a skip call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        skip
+        assert(1 == 0)
+      end
+      @test.run
+    end
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have a skip for its last result" do
+      assert_kind_of Assert::Result::Skip, subject.results.last
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 skip result" do
+      assert_equal 1, subject.result_count(:skip)
+    end
+
+    should "have 0 fail results" do
+      assert_equal 0, subject.result_count(:fail)
+    end
+
+  end
+
+  class MixedErrorTests < SystemTests
+    desc "when passing 1 assertion and failing 1 assertion with an exception raised in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        raise Exception, "something errored"
+        assert(1 == 0)
+      end
+      @test.run
+    end
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have an error for its last result" do
+      assert_kind_of Assert::Result::Error, subject.results.last
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 error result" do
+      assert_equal 1, subject.result_count(:error)
+    end
+
+    should "have 0 fail results" do
+      assert_equal 0, subject.result_count(:fail)
+    end
+
+  end
+
+  class MixedPassTests < SystemTests
+    desc "when passing 1 assertion and failing 1 assertion with a pass call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 1)
+        pass
+        assert(1 == 0)
+      end
+      @test.run
+    end
+
+    should "have 3 total results" do
+      assert_equal 3, subject.result_count
+    end
+
+    should "have a fail for its last result" do
+      assert_kind_of Assert::Result::Fail, subject.results.last
+    end
+
+    should "have 2 pass results" do
+      assert_equal 2, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+  end
+
+  class MixedFailTests < SystemTests
+    desc "when failing 1 assertion and passing 1 assertion with a fail call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 0)
+        fail
+        assert(1 == 1)
+      end
+      @test.run
+    end
+
+    should "have 3 total results" do
+      assert_equal 3, subject.result_count
+    end
+
+    should "have a pass for its last result" do
+      assert_kind_of Assert::Result::Pass, subject.results.last
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 2 fail results" do
+      assert_equal 2, subject.result_count(:fail)
+    end
+
+  end
+
+  class MixedFlunkTests < SystemTests
+    desc "has failing 1 assertion and passing 1 assertion with a flunk call in between"
+    setup do
+      @test = Factory.test do
+        assert(1 == 0)
+        flunk
+        assert(1 == 1)
+      end
+      @test.run
+    end
+
+    should "have 3 total results" do
+      assert_equal 3, subject.result_count
+    end
+
+    should "have a pass for its last result" do
+      assert_kind_of Assert::Result::Pass, subject.results.last
+    end
+
+    should "have 1 pass results" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 2 fail results" do
+      assert_equal 2, subject.result_count(:fail)
+    end
+
+  end
+
+  class WithSetupsTests < SystemTests
+    desc "that has setup logic"
+    setup do
+      @context_class = Factory.context_class do
+        # assert style
+        setup{ pass 'assert style setup' }
+        # test/unit style
+        def setup; pass 'test/unit style setup'; end
+      end
+      @test = Factory.test("t", Factory.context_info(@context_class)){ pass 'TEST' }
+      @test.run
+    end
+
+    should "execute all setup logic when run" do
+      assert_equal 3, subject.result_count(:pass)
+
+      exp = ['assert style setup', 'test/unit style setup', 'TEST']
+      assert_equal exp, subject.results.map(&:message)
+    end
+
+  end
+
+  class WithTeardownsTests < SystemTests
+    desc "that has teardown logic"
+    setup do
+      @context_class = Factory.context_class do
+        # assert style
+        teardown{ pass 'assert style teardown' }
+        # test/unit style
+        def teardown; pass 'test/unit style teardown'; end
+      end
+      @test = Factory.test("t", Factory.context_info(@context_class)){ pass 'TEST' }
+      @test.run
+    end
+
+    should "execute all teardown logic when run" do
+      assert_equal 3, subject.result_count(:pass)
+
+      exp = ['TEST', 'assert style teardown', 'test/unit style teardown']
+      assert_equal exp, subject.results.map(&:message)
+    end
+
+  end
+
+  class WithAroundsTests < SystemTests
+    desc "that has around logic (in addition to setups/teardowns)"
+    setup do
+      @parent_context_class = Factory.modes_off_context_class do
+        around do |block|
+          pass "parent around start"
+          block.call
+          pass "parent around end"
+        end
+        setup{ pass "parent setup" }
+        teardown{ pass "parent teardown" }
+      end
+      @context_class = Factory.modes_off_context_class(@parent_context_class) do
+        setup{ pass "child setup1" }
+        around do |block|
+          pass "child around1 start"
+          block.call
+          pass "child around1 end"
+        end
+        teardown{ pass "child teardown1" }
+        setup{ pass "child setup2" }
+        around do |block|
+          pass "child around2 start"
+          block.call
+          pass "child around2 end"
+        end
+        teardown{ pass "child teardown2" }
+      end
+      @test = Factory.test("t", Factory.context_info(@context_class)){ pass "TEST" }
+      @test.run
+    end
+
+    should "run the arounds outside of the setups/teardowns/test" do
+      assert_equal 13, subject.result_count(:pass)
+
+      exp = [
+        'parent around start', 'child around1 start', 'child around2 start',
+        'parent setup', 'child setup1', 'child setup2', 'TEST',
+        'child teardown1', 'child teardown2', 'parent teardown',
+        'child around2 end', 'child around1 end', 'parent around end'
+      ]
+      assert_equal exp, subject.results.map(&:message)
+    end
+
+  end
+
+end