assert 2.4.0 → 2.5.0

data/lib/assert/context/test_dsl.rb

@@ -0,0 +1,51 @@
+require 'assert/macro'
+require 'assert/suite'
+require 'assert/test'
+
+module Assert; end
+class Assert::Context
+
+  module TestDSL
+
+    def test(desc_or_macro, called_from=nil, first_caller=nil, &block)
+      if desc_or_macro.kind_of?(Assert::Macro)
+        instance_eval(&desc_or_macro)
+      elsif block_given?
+        ci = Assert::Suite::ContextInfo.new(self, called_from, first_caller || caller.first)
+        test_name = desc_or_macro
+
+        # create a test from the given code block
+        self.suite.tests << Assert::Test.new(test_name, ci, self.suite.config, &block)
+      else
+        test_eventually(desc_or_macro, called_from, first_caller || caller.first, &block)
+      end
+    end
+
+    def test_eventually(desc_or_macro, called_from=nil, first_caller=nil, &block)
+      ci = Assert::Suite::ContextInfo.new(self, called_from, first_caller || caller.first)
+      test_name = desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro
+      skip_block = block.nil? ? Proc.new { skip 'TODO' } : Proc.new { skip }
+
+      # create a test from a proc that just skips
+      self.suite.tests << Assert::Test.new(test_name, ci, self.suite.config, &skip_block)
+    end
+    alias_method :test_skip, :test_eventually
+
+    def should(desc_or_macro, called_from=nil, first_caller=nil, &block)
+      if !desc_or_macro.kind_of?(Assert::Macro)
+        desc_or_macro = "should #{desc_or_macro}"
+      end
+      test(desc_or_macro, called_from, first_caller || caller.first, &block)
+    end
+
+    def should_eventually(desc_or_macro, called_from=nil, first_caller=nil, &block)
+      if !desc_or_macro.kind_of?(Assert::Macro)
+        desc_or_macro = "should #{desc_or_macro}"
+      end
+      test_eventually(desc_or_macro, called_from, first_caller || caller.first, &block)
+    end
+    alias_method :should_skip, :should_eventually
+
+  end
+
+end

data/lib/assert/runner.rb

@@ -1,8 +1,14 @@
+require 'assert/suite'
+
 module Assert
 
   class Runner
 
-    # Runner runs a suite of tests.
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
 
     def run(suite, view)
       raise ArgumentError if !suite.kind_of?(Suite)
@@ -27,7 +33,7 @@ module Assert
     protected
 
     def tests_to_run(suite)
-      srand Assert.config.runner_seed
+      srand self.config.runner_seed
       suite.tests.sort.sort_by { rand suite.tests.size }
     end
 

data/lib/assert/suite.rb

@@ -3,24 +3,15 @@ require 'assert/test'
 module Assert
   class Suite
 
-    class ContextInfo
-      attr_reader :called_from, :klass, :file
-
-      def initialize(klass, called_from=nil, first_caller=nil)
-        @called_from = called_from || first_caller
-        @klass = klass
-        @file = @called_from.gsub(/\:[0-9]+.*$/, '') if @called_from
-      end
-    end
-
     TEST_METHOD_REGEX = /^test./
 
     # A suite is a set of tests to run.  When a test class subclasses
     # the Context class, that test class is pushed to the suite.
 
-    attr_accessor :tests, :test_methods, :start_time, :end_time
+    attr_accessor :config, :tests, :test_methods, :start_time, :end_time
 
-    def initialize
+    def initialize(config)
+      @config = config
       @tests = []
       @test_methods = []
       @start_time = 0
@@ -31,6 +22,14 @@ module Assert
       @end_time - @start_time
     end
 
+    def test_rate
+      get_rate(self.tests.size, self.run_time.to_f)
+    end
+
+    def result_rate
+      get_rate(self.results.size, self.run_time.to_f)
+    end
+
     alias_method :ordered_tests, :tests
 
     def results
@@ -91,6 +90,12 @@ module Assert
     end
     alias_method :shutdown, :teardown
 
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)}"\
+      " test_count=#{self.test_count.inspect}"\
+      " result_count=#{self.result_count.inspect}>"
+    end
+
     protected
 
     def setups
@@ -118,6 +123,22 @@ module Assert
       methods.uniq.delete_if {|method_name| method_name !~ TEST_METHOD_REGEX }
     end
 
+    private
+
+    def get_rate(count, time)
+      time == 0 ? 0.0 : (count.to_f / time.to_f)
+    end
+
+    class ContextInfo
+      attr_reader :called_from, :klass, :file
+
+      def initialize(klass, called_from=nil, first_caller=nil)
+        @called_from = called_from || first_caller
+        @klass = klass
+        @file = @called_from.gsub(/\:[0-9]+.*$/, '') if @called_from
+      end
+    end
+
   end
 
 end

data/lib/assert/test.rb

@@ -7,15 +7,18 @@ module Assert
     # a Test is some code/method to run in the scope of a Context.  After a
     # a test runs, it should have some assertions which are its results.
 
-    attr_reader :name, :code, :context_info
+    attr_reader :name, :context_info, :config, :code
     attr_accessor :results, :output
 
-    def initialize(name, suite_context_info, code = nil, &block)
-      @context_info = suite_context_info
-      @name = name_from_context(name)
-      @code = (code || block)
+    def initialize(name, suite_ci, config, opts = nil, &block)
+      @context_info = suite_ci
+      @name, @config = name_from_context(name), config
+
+      o = opts || {}
+      @code = o[:code] || block || Proc.new{}
+
       @results = Result::Set.new
-      @output = ""
+      @output  = ""
     end
 
     def context_class
@@ -25,7 +28,7 @@ module Assert
     def run(&result_callback)
       # setup the a new test run
       @results = Result::Set.new(result_callback)
-      run_scope = self.context_class.new(self)
+      run_scope = self.context_class.new(self, self.config)
 
       # run the test, capturing its output
       begin
@@ -114,7 +117,7 @@ module Assert
     end
 
     def capture_output(&block)
-      if Assert.config.capture_output == true
+      if self.config.capture_output == true
         orig_stdout = $stdout.clone
         $stdout = capture_io
         block.call

data/lib/assert/utils.rb

@@ -6,9 +6,8 @@ module Assert
 
     # show objects in a human-readable manner.  Either inspects or pretty-prints
     # them depending on settings.
-
-    def self.show(obj)
-      out = Assert.config.pp_objects ? Assert.config.pp_proc.call(obj) : obj.inspect
+    def self.show(obj, config)
+      out = config.pp_objects ? config.pp_proc.call(obj) : obj.inspect
       out = out.encode(Encoding.default_external) if defined?(Encoding)
       out
     end
@@ -16,13 +15,11 @@ module Assert
     # show objects in a human-readable manner and make the output diff-able. This
     # expands on the basic `show` util by escaping newlines and making object id
     # hex-values generic.
-
-    def self.show_for_diff(obj)
-      show(obj).gsub(/\\n/, "\n").gsub(/:0x[a-fA-F0-9]{4,}/m, ':0xXXXXXX')
+    def self.show_for_diff(obj, config)
+      show(obj, config).gsub(/\\n/, "\n").gsub(/:0x[a-fA-F0-9]{4,}/m, ':0xXXXXXX')
     end
 
     # open a tempfile and yield it
-
     def self.tempfile(name, content)
       require "tempfile"
       Tempfile.open(name) do |tmpfile|
@@ -32,14 +29,12 @@ module Assert
     end
 
     # Get a proc that uses stdlib `PP.pp` to pretty print objects
-
     def self.stdlib_pp_proc(width = nil)
       require 'pp'
-      Proc.new{ |obj| "\n#{PP.pp(obj, '', width || 79).strip}\n" }
+      Proc.new{ |obj| PP.pp(obj, '', width || 79).strip }
     end
 
     # Return true if if either show output has newlines or is bigger than 29 chars
-
     def self.default_use_diff_proc
       Proc.new do |exp_show_output, act_show_output|
         exp_show_output.include?("\n") || exp_show_output.size > 29 ||
@@ -47,12 +42,13 @@ module Assert
       end
     end
 
+    # use `diff` system cmd to show exp/act show output
     def self.syscmd_diff_proc(syscmd = "diff --unified=-1")
       Proc.new do |exp_show_output, act_show_output|
         result = ""
         tempfile('exp_show_output', exp_show_output) do |a|
           tempfile('act_show_output', act_show_output) do |b|
-            result = `#{syscmd} #{a.path} #{b.path}`
+            result = `#{syscmd} #{a.path} #{b.path}`.strip
             result.sub!(/^\-\-\- .+/, "--- expected")
             result.sub!(/^\+\+\+ .+/, "+++ actual")
             result = "--- expected\n+++ actual" if result.empty?
@@ -62,6 +58,22 @@ module Assert
       end
     end
 
+    # use git to determine which files have changes
+    def self.git_changed_proc
+      Proc.new do |config, test_paths|
+        files = []
+        cmd = [
+          "git diff --no-ext-diff --name-only",       # changed files
+          "git ls-files --others --exclude-standard"  # added files
+        ].map{ |c| "#{c} -- #{test_paths.join(' ')}" }.join(' && ')
+        Assert::CLI.bench('Load only changed files') do
+          files = `#{cmd}`.split("\n")
+        end
+        puts Assert::CLI.debug_msg("  `#{cmd}`") if config.debug
+        files
+      end
+    end
+
   end
 
   # alias for brevity

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 end

data/lib/assert/view.rb

@@ -6,16 +6,18 @@ module Assert::View
   # 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)
-    views_file = File.join(Assert.config.user_test_dir, 'views', view, 'lib', view)
+  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) || File.exists?(view+'.rb')
-      require view
-    elsif File.exists?(views_file+'.rb')
+    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.inspect} view."
-      msg << " Did you install it in `~/.assert/views`?" if !view.match(/\A\//)
+      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

data/lib/assert/view/base.rb

@@ -1,3 +1,5 @@
+require 'assert/config'
+require 'assert/suite'
 require 'assert/result'
 
 module Assert::View
@@ -17,13 +19,33 @@ module Assert::View
     option 'skip_abbrev',   'S'
     option 'error_abbrev',  'E'
 
-    def initialize(output_io, suite=nil)
-      @output_io, @suite = output_io, suite
+    attr_reader :config, :suite
+
+    def initialize(output_io, *args)
+      @output_io = output_io
+      @suite, @config = [
+        args.last.kind_of?(Assert::Suite)  ? args.pop : nil,
+        args.last.kind_of?(Assert::Config) ? args.pop : nil
+      ]
+
       @output_io.sync = true if @output_io.respond_to?(:sync=)
     end
 
-    def view; self; end
-    def suite; @suite || Assert.suite; end
+    def is_tty?
+      !!@output_io.isatty
+    end
+
+    def view
+      self
+    end
+
+    def config
+      @config ||= Assert.config
+    end
+
+    def suite
+      @suite ||= Assert.suite
+    end
 
     def fire(callback, *args)
       self.send(callback, *args)

data/lib/assert/view/default_view.rb

@@ -68,7 +68,7 @@ module Assert::View
 
       puts "#{result_count_statement}: #{styled_results_sentence}"
       puts
-      puts "(#{run_time} seconds)"
+      puts "(#{run_time} seconds, #{test_rate} tests/s, #{result_rate} results/s)"
     end
 
   end

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

@@ -9,7 +9,7 @@ module Assert::View::Helpers
     end
 
     def ansi_styled_msg(msg, styles=[])
-      if !(style = ansi_style(*styles)).empty?
+      if !(style = ansi_style(*styles)).empty? && self.is_tty?
         style + msg + ANSI.send(:reset)
       else
         msg

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

@@ -6,13 +6,8 @@ module Assert::View::Helpers
       receiver.class_eval{ extend ClassMethods }
     end
 
-    # get the formatted suite run time
-    def run_time(format='%.6f')
-      format % self.suite.run_time
-    end
-
     def runner_seed
-      Assert.config.runner_seed
+      self.config.runner_seed
     end
 
     def count(type)
@@ -27,6 +22,21 @@ module Assert::View::Helpers
       self.count(:pass) == self.count(:results)
     end
 
+    # get the formatted suite run time
+    def run_time(format = '%.6f')
+      format % self.suite.run_time
+    end
+
+    # get the formatted suite test rate
+    def test_rate(format = '%.6f')
+      format % self.suite.test_rate
+    end
+
+    # get the formatted suite result rate
+    def result_rate(format = '%.6f')
+      format % self.suite.result_rate
+    end
+
     # get a uniq list of contexts for the test suite
     def suite_contexts
       @suite_contexts ||= self.suite.tests.inject([]) do |contexts, test|

data/test/helper.rb

@@ -7,97 +7,4 @@ $LOAD_PATH.unshift(ROOT_PATH)
 
 # require pry for debugging (`binding.pry`)
 require 'pry'
-
-# Force tests to run without halting on failures (needed so all tests will run
-# properly).  For halt on fail behavior testing, the context of those tests
-# configures Assert temporarily as needed.
-
-class Assert::Context
-  def setup
-    Assert.config.halt_on_fail false
-    # Note: don't mess with the `capture_output` setting in this setup block. Doing
-    # so will break the capture output tests.  If you really need to set it one
-    # way or the other, do so in the `.assert.rb` local settings file.
-  end
-
-  # a context for use in testing all the different context singleton methods
-  class ContextSingletonTests < Assert::Context
-    desc "Assert context singleton"
-    setup do
-      @orig_assert_suite = Assert.suite
-      Assert.config.suite TEST_ASSERT_SUITE
-      @test = Factory.test
-      @context_class = @test.context_class
-    end
-    teardown do
-      TEST_ASSERT_SUITE.tests.clear
-      Assert.config.suite @orig_assert_suite
-    end
-    subject{ @context_class }
-
-  end
-
-end
-
-
-# A Suite for use in the tests.  It is seperate from `Assert.suite`
-# (which is the actual suite being used to run the tests). Don't use
-# `Assert.suite` in your tests, use TEST_ASSERT_SUITE
-
-TEST_ASSERT_SUITE = Assert::Suite.new
-
-# A context for use in the tests and also in the `context_class` factory. This
-# will ensure any contexts defined as part of the tests will add their methods
-# to `TEST_ASSERT_SUITE`
-
-class TestContext < Assert::Context
-  def self.method_added(meth)
-    if meth.to_s =~ Assert::Suite::TEST_METHOD_REGEX
-      ci = Assert::Suite::ContextInfo.new(self, Factory.context_info_called_from)
-      TEST_ASSERT_SUITE.tests << Assert::Test.new(meth.to_s, ci, meth)
-    end
-  end
-end
-
-module Factory
-
-  def self.context_info_called_from
-    "/path/to_file.rb:1234"
-  end
-
-  def self.context_info(context_class)
-    Assert::Suite::ContextInfo.new(context_class, context_info_called_from)
-  end
-
-  # Generate an anonymous `Context` inherited from `TestContext` by default.
-  # This provides a common interface for all contexts used in testing.
-
-  def self.context_class(inherit_from=nil, &block)
-    inherit_from ||= TestContext
-    klass = Class.new(inherit_from, &block)
-    default = (const_name = "FactoryAssertContext").dup
-
-    while(Object.const_defined?(const_name)) do
-      const_name = "FactoryAssertContext#{rand(Time.now.to_i)}"
-    end
-    Object.const_set(const_name, klass)
-    klass
-  end
-
-  # Generate a no-op test for use in testing.
-
-  def self.test(*args, &block)
-    name = (args[0] || "a test").to_s
-    context_info = args[1] || self.context_info(self.context_class)
-    test_block = (block || args[2] || ::Proc.new{})
-
-    Assert::Test.new(name, context_info, &test_block)
-  end
-
-  # Generate a skip result for use in testing.
-
-  def self.skip_result(name, exception)
-    Assert::Result::Skip.new(Factory.test(name), exception)
-  end
-
-end
+require 'test/support/factory'