assert 2.5.0 → 2.6.0

data/lib/assert/cli.rb

@@ -42,6 +42,9 @@ module Assert
         option 'pp_objects', 'pretty-print objects in fail messages', {
           :abbrev => 'p'
         }
+        option 'profile', 'output test profile info', {
+          :abbrev => 'e'
+        }
         # show loaded test files, cli err backtraces, etc
         option 'debug', 'run in debug mode'
       end

data/lib/assert/config.rb

@@ -16,7 +16,8 @@ module Assert
     settings :view, :suite, :runner
     settings :test_dir, :test_helper, :test_file_suffixes, :runner_seed
     settings :changed_proc, :pp_proc, :use_diff_proc, :run_diff_proc
-    settings :capture_output, :halt_on_fail, :changed_only, :pp_objects, :debug
+    settings :capture_output, :halt_on_fail, :changed_only, :pp_objects
+    settings :debug, :profile
 
     def initialize(settings = nil)
       @suite  = Assert::Suite.new(self)
@@ -39,6 +40,7 @@ module Assert
       @changed_only   = false
       @pp_objects     = false
       @debug          = false
+      @profile        = false
 
       self.apply(settings || {})
     end

data/lib/assert/context/setup_dsl.rb

@@ -15,48 +15,26 @@ class Assert::Context
     alias_method :after_once, :teardown_once
     alias_method :shutdown, :teardown_once
 
-    # Add a setup block to run before each test or run the list of teardown blocks in given scope
-    def setup(scope_or_method_name = nil, &block)
-      is_method = scope_or_method_name.kind_of?(String) || scope_or_method_name.kind_of?(Symbol)
-      if block_given? || is_method
-        # arg is a block or method that needs to be stored as a setup
-        self.setups << (block || scope_or_method_name)
-      elsif !is_method
-        # arg is an instance of this class (the scope for a test),
-        # run the setups for this context in the scope
-        scope = scope_or_method_name
-        # setup parent...
-        self.superclass.setup(scope) if self.superclass.respond_to?(:setup)
-        # ... before child
-        self.setups.each do |setup|
-          setup.kind_of?(::Proc) ? scope.instance_eval(&setup) : scope.send(setup)
-        end
-      end
+    def around(&block)
+      self.arounds << block
+    end
+
+    def setup(method_name = nil, &block)
+      self.setups << (block || method_name)
     end
     alias_method :before, :setup
 
-    # Add a teardown block to run after each test or run the list of teardown blocks in given scope
-    def teardown(scope_or_method_name = nil, &block)
-      is_method = scope_or_method_name.kind_of?(String) || scope_or_method_name.kind_of?(Symbol)
-      if block_given? || is_method
-        # arg is a block or method that needs to be stored as a teardown
-        self.teardowns << (block || scope_or_method_name)
-      elsif !is_method
-        # arg is an instance of this class (the scope for a test),
-        # run the setups for this context in the scope
-        scope = scope_or_method_name
-        # teardown child...
-        self.teardowns.each do |teardown|
-          teardown.kind_of?(::Proc) ? scope.instance_eval(&teardown) : scope.send(teardown)
-        end
-        # ... before parent
-        self.superclass.teardown(scope) if self.superclass.respond_to?(:teardown)
-      end
+    def teardown(method_name = nil, &block)
+      self.teardowns << (block || method_name)
     end
     alias_method :after, :teardown
 
     protected
 
+    def arounds
+      @arounds ||= []
+    end
+
     def setups
       @setups ||= []
     end
@@ -65,6 +43,36 @@ class Assert::Context
       @teardowns ||= []
     end
 
+    def run_arounds(scope, &run_block)
+      context_block = self.arounds.compact.reverse.inject(run_block) do |run_b, around_b|
+        Proc.new{ scope.instance_exec(run_b, &around_b) }
+      end
+
+      if self.superclass.respond_to?(:run_arounds)
+        self.superclass.run_arounds(scope, &context_block)
+      else
+        context_block.call
+      end
+    end
+
+    def run_setups(scope)
+      # setup the parent...
+      self.superclass.run_setups(scope) if self.superclass.respond_to?(:run_setups)
+      # ... before you setup the child
+      self.setups.compact.each do |setup|
+        setup.kind_of?(::Proc) ? scope.instance_eval(&setup) : scope.send(setup)
+      end
+    end
+
+    def run_teardowns(scope)
+      # teardown the child...
+      self.teardowns.compact.each do |teardown|
+        teardown.kind_of?(::Proc) ? scope.instance_eval(&teardown) : scope.send(teardown)
+      end
+      # ... before the parent
+      self.superclass.run_teardowns(scope) if self.superclass.respond_to?(:run_teardowns)
+    end
+
   end
 
 end

data/lib/assert/suite.rb

@@ -23,11 +23,11 @@ module Assert
     end
 
     def test_rate
-      get_rate(self.tests.size, self.run_time.to_f)
+      get_rate(self.tests.size, self.run_time)
     end
 
     def result_rate
-      get_rate(self.results.size, self.run_time.to_f)
+      get_rate(self.results.size, self.run_time)
     end
 
     alias_method :ordered_tests, :tests

data/lib/assert/test.rb

@@ -8,7 +8,7 @@ module Assert
     # a test runs, it should have some assertions which are its results.
 
     attr_reader :name, :context_info, :config, :code
-    attr_accessor :results, :output
+    attr_accessor :results, :output, :run_time
 
     def initialize(name, suite_ci, config, opts = nil, &block)
       @context_info = suite_ci
@@ -19,6 +19,8 @@ module Assert
 
       @results = Result::Set.new
       @output  = ""
+      @run_time = 0
+      @result_rate = 0
     end
 
     def context_class
@@ -26,36 +28,15 @@ module Assert
     end
 
     def run(&result_callback)
-      # setup the a new test run
       @results = Result::Set.new(result_callback)
-      run_scope = self.context_class.new(self, self.config)
 
-      # run the test, capturing its output
-      begin
-        run_test_setup(run_scope)
-        run_test_code(run_scope)
-      rescue Result::TestFailure => err
-        @results << Result::Fail.new(self, err)
-      rescue Result::TestSkipped => err
-        @results << Result::Skip.new(self, err)
-      rescue SignalException => err
-        raise(err)
-      rescue Exception => err
-        @results << Result::Error.new(self, err)
-      ensure
-        begin
-          run_test_teardown(run_scope)
-        rescue Result::TestFailure => err
-          @results << Result::Fail.new(self, err)
-        rescue Result::TestSkipped => err
-          @results << Result::Skip.new(self, err)
-        rescue SignalException => err
-          raise(err)
-        rescue Exception => teardown_err
-          @results << Result::Error.new(self, teardown_err)
-        end
+      scope = self.context_class.new(self, self.config)
+      start_time = Time.now
+      capture_output do
+        self.context_class.send('run_arounds', scope){ run_test_main(scope) }
       end
-      # return the results of the test run
+      @run_time = Time.now - start_time
+
       @results
     end
 
@@ -73,6 +54,10 @@ module Assert
       end
     end
 
+    def result_rate
+      get_rate(self.result_count, self.run_time)
+    end
+
     def <=>(other_test)
       self.name <=> other_test.name
     end
@@ -86,34 +71,55 @@ module Assert
 
     protected
 
+    def run_test_main(scope)
+      begin
+        run_test_setup(scope)
+        run_test_code(scope)
+      rescue Result::TestFailure => err
+        @results << Result::Fail.new(self, err)
+      rescue Result::TestSkipped => err
+        @results << Result::Skip.new(self, err)
+      rescue SignalException => err
+        raise(err)
+      rescue Exception => err
+        @results << Result::Error.new(self, err)
+      ensure
+        begin
+          run_test_teardown(scope)
+        rescue Result::TestFailure => err
+          @results << Result::Fail.new(self, err)
+        rescue Result::TestSkipped => err
+          @results << Result::Skip.new(self, err)
+        rescue SignalException => err
+          raise(err)
+        rescue Exception => teardown_err
+          @results << Result::Error.new(self, teardown_err)
+        end
+      end
+    end
+
     def run_test_setup(scope)
-      capture_output do
-        # run any assert style 'setup do' setups
-        self.context_class.setup(scope)
+      # run any assert style 'setup do' setups
+      self.context_class.send('run_setups', scope)
 
-        # run any classic test/unit style 'def setup' setups
-        scope.setup if scope.respond_to?(:setup)
-      end
+      # run any classic test/unit style 'def setup' setups
+      scope.setup if scope.respond_to?(:setup)
     end
 
     def run_test_code(scope)
-      capture_output do
-        if @code.kind_of?(::Proc)
-          scope.instance_eval(&@code)
-        elsif scope.respond_to?(@code.to_s)
-          scope.send(@code.to_s)
-        end
+      if @code.kind_of?(::Proc)
+        scope.instance_eval(&@code)
+      elsif scope.respond_to?(@code.to_s)
+        scope.send(@code.to_s)
       end
     end
 
     def run_test_teardown(scope)
-      capture_output do
-        # run any classic test/unit style 'def teardown' teardowns
-        scope.teardown if scope.respond_to?(:teardown)
+      # run any classic test/unit style 'def teardown' teardowns
+      scope.teardown if scope.respond_to?(:teardown)
 
-        # run any assert style 'teardown do' teardowns
-        self.context_class.teardown(scope)
-      end
+      # run any assert style 'teardown do' teardowns
+      self.context_class.send('run_teardowns', scope)
     end
 
     def capture_output(&block)
@@ -137,5 +143,11 @@ module Assert
       ].compact.reject{|p| p.empty?}.join(" ")
     end
 
+    private
+
+    def get_rate(count, time)
+      time == 0 ? 0.0 : (count.to_f / time.to_f)
+    end
+
   end
 end

data/lib/assert/version.rb

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

data/lib/assert/view/default_view.rb

@@ -61,6 +61,17 @@ module Assert::View
         end
       end
 
+      # show profile output
+      if show_test_profile_info?
+        ordered_profile_tests.each do |test|
+          puts "#{test_run_time(test)} seconds,"\
+               " #{test.result_count} results,"\
+               " #{test_result_rate(test)} results/s --"\
+               " #{test.context_class}: #{test.name.inspect}"
+        end
+        puts
+      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))

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

@@ -37,6 +37,16 @@ module Assert::View::Helpers
       format % self.suite.result_rate
     end
 
+    # 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 a uniq list of contexts for the test suite
     def suite_contexts
       @suite_contexts ||= self.suite.tests.inject([]) do |contexts, test|
@@ -59,6 +69,14 @@ module Assert::View::Helpers
       self.suite_files.sort{|a,b| a.to_s <=> b.to_s}
     end
 
+    def ordered_profile_tests
+      suite.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
+    end
+
+    def show_test_profile_info?
+      !!config.profile
+    end
+
     # get all the result details for a set of tests
     def result_details_for(tests, result_order=:normal)
       test_index = 0

data/test/system/running_tests.rb

@@ -262,8 +262,8 @@ class RunningSystemTests < Assert::Context
 
   end
 
-  class WithSetupTests < RunningSystemTests
-    desc "has assertions that depend on setups"
+  class WithSetupsTests < RunningSystemTests
+    desc "has tests that depend on setups"
     setup do
       assert_style_msg = @asm = "set by assert style setup"
       testunit_style_msg = @tusm = "set by test/unit style setup"
@@ -307,8 +307,8 @@ class RunningSystemTests < Assert::Context
 
   end
 
-  class WithTeardownTests < RunningSystemTests
-    desc "has assertions with teardowns"
+  class WithTeardownsTests < RunningSystemTests
+    desc "has tests that depend on teardowns"
     setup do
       assert_style_msg = @asm = "set by assert style teardown"
       testunit_style_msg = @tusm = "set by test/unit style teardown"
@@ -351,4 +351,54 @@ class RunningSystemTests < Assert::Context
 
   end
 
+  class WithAroundsTests < RunningSystemTests
+    desc "has arounds (in addition to setups/teardowns)"
+    setup do
+      @parent_class = Factory.modes_off_context_class do
+        around do |block|
+          @__running_test__.output += "p-around start, "
+          block.call
+          @__running_test__.output += "p-around end."
+        end
+        setup{ @__running_test__.output += "p-setup, " }
+        teardown{ @__running_test__.output += "p-teardown, " }
+      end
+
+      @context_class = Factory.modes_off_context_class(@parent_class) do
+        attr_accessor :out_status
+
+        setup{ @__running_test__.output += "c-setup1, " }
+        around do |block|
+          @__running_test__.output += "c-around1 start, "
+          block.call
+          @__running_test__.output += "c-around1 end, "
+        end
+        teardown{ @__running_test__.output += "c-teardown1, " }
+        setup{ @__running_test__.output += "c-setup2, " }
+        around do |block|
+          @__running_test__.output += "c-around2 start, "
+          block.call
+          @__running_test__.output += "c-around2 end, "
+        end
+        teardown{ @__running_test__.output += "c-teardown2, " }
+      end
+
+
+      @test = Factory.test("something amazing", Factory.context_info(@context_class)) do
+        @__running_test__.output += "TEST, "
+      end
+      @test.run
+    end
+
+    should "run the arounds outside of the setups/teardowns/test" do
+      exp = "p-around start, c-around1 start, c-around2 start, "\
+            "p-setup, c-setup1, c-setup2, "\
+            "TEST, "\
+            "c-teardown1, c-teardown2, p-teardown, "\
+            "c-around2 end, c-around1 end, p-around end."
+      assert_equal exp, subject.output
+    end
+
+  end
+
 end

data/test/unit/config_tests.rb

@@ -13,7 +13,8 @@ class Assert::Config
     should have_imeths :suite, :view, :runner
     should have_imeths :test_dir, :test_helper, :test_file_suffixes, :runner_seed
     should have_imeths :changed_proc, :pp_proc, :use_diff_proc, :run_diff_proc
-    should have_imeths :capture_output, :halt_on_fail, :changed_only, :pp_objects, :debug
+    should have_imeths :capture_output, :halt_on_fail, :changed_only, :pp_objects
+    should have_imeths :debug, :profile
     should have_imeths :apply
 
     should "default the view, suite, and runner" do
@@ -42,6 +43,7 @@ class Assert::Config
       assert_not subject.changed_only
       assert_not subject.pp_objects
       assert_not subject.debug
+      assert_not subject.profile
     end
 
     should "apply settings given from a hash" do

data/test/unit/context/setup_dsl_tests.rb

@@ -91,13 +91,57 @@ module Assert::Context::SetupDSL
     end
 
     should "run it's parent and it's own blocks in the correct order" do
-      subject.setup(obj = @test_status_class.new)
+      subject.send('run_setups', obj = @test_status_class.new)
       assert_equal "the setup has been run with something", obj.setup_status
 
-      subject.teardown(obj = @test_status_class.new)
+      subject.send('run_teardowns', obj = @test_status_class.new)
       assert_equal "with something has been run the teardown", obj.teardown_status
     end
 
   end
 
+  class AroundMethodTests < UnitTests
+    desc "with multiple `around` calls"
+    setup do
+      @parent_class = Factory.modes_off_context_class do
+        around do |block|
+          self.out_status ||= ''
+          self.out_status += "p-around start, "
+          block.call
+          self.out_status += "p-around end."
+        end
+      end
+
+      @context_class = Factory.modes_off_context_class(@parent_class) do
+        around do |block|
+          self.out_status += "c-around1 start, "
+          block.call
+          self.out_status += "c-around1 end, "
+        end
+        around do |block|
+          self.out_status += "c-around2 start, "
+          block.call
+          self.out_status += "c-around2 end, "
+        end
+      end
+
+      @test_status_class = Class.new do
+        attr_accessor :out_status
+      end
+    end
+
+    should "run it's parent and it's own blocks in the correct order" do
+      obj = @test_status_class.new
+      subject.send('run_arounds', obj) do
+        obj.instance_eval{ self.out_status += 'TEST, ' }
+      end
+
+      exp = "p-around start, c-around1 start, c-around2 start, "\
+            "TEST, "\
+            "c-around2 end, c-around1 end, p-around end."
+      assert_equal exp, obj.out_status
+    end
+
+  end
+
 end

data/test/unit/context_tests.rb

@@ -19,8 +19,9 @@ class Assert::Context
     should have_cmeths :description, :desc, :describe, :subject, :suite
     should have_cmeths :setup_once, :before_once, :startup
     should have_cmeths :teardown_once, :after_once, :shutdown
-    should have_cmeths :setup, :before, :setups
-    should have_cmeths :teardown, :after, :teardowns
+    should have_cmeths :setup, :before, :setups, :run_setups
+    should have_cmeths :teardown, :after, :teardowns, :run_teardowns
+    should have_cmeths :around, :arounds, :run_arounds
     should have_cmeths :test, :test_eventually, :test_skip
     should have_cmeths :should, :should_eventually, :should_skip
 

data/test/unit/suite_tests.rb

@@ -25,7 +25,7 @@ class Assert::Suite
       assert_equal(exp, act)
     end
 
-    should "have a zero run time, test rate and result by default" do
+    should "have a zero run time, test rate and result rate by default" do
       assert_equal 0, subject.run_time
       assert_equal 0, subject.test_rate
       assert_equal 0, subject.result_rate

data/test/unit/test_tests.rb

@@ -16,8 +16,8 @@ class Assert::Test
     subject{ @test }
 
     should have_readers :name, :context_info, :config, :code
-    should have_accessors :results, :output
-    should have_imeths :run, :result_count, :context_class
+    should have_accessors :results, :output, :run_time
+    should have_imeths :run, :result_count, :result_rate, :context_class
     should have_imeths *Assert::Result.types.keys.collect{ |k| "#{k}_results" }
 
     should "build its name from the context description" do
@@ -47,6 +47,17 @@ class Assert::Test
       assert_equal 0, subject.result_count
     end
 
+    should "have a zero run time and result rate by default" do
+      assert_equal 0, subject.run_time
+      assert_equal 0, subject.result_rate
+    end
+
+    should "have a non-zero run time and result rate after it is run" do
+      subject.run
+      assert_not_equal 0, subject.run_time
+      assert_not_equal 0, subject.result_rate
+    end
+
     should "have a custom inspect that only shows limited attributes" do
       attrs_string = [:name, :context_info, :results].collect do |method|
         "@#{method}=#{subject.send(method).inspect}"

data/test/unit/view_tests.rb

@@ -22,9 +22,11 @@ class Assert::View::Base
     # common methods
     should have_imeths :runner_seed, :count, :tests?, :all_pass?
     should have_imeths :run_time, :test_rate, :result_rate
+    should have_imeths :test_run_time, :test_result_rate
     should have_imeths :suite_contexts, :ordered_suite_contexts
     should have_imeths :suite_files, :ordered_suite_files
-    should have_imeths :result_details_for, :show_result_details?
+    should have_imeths :ordered_profile_tests, :show_test_profile_info?
+    should have_imeths :result_details_for, :matched_result_details_for, :show_result_details?
     should have_imeths :ocurring_result_types, :result_summary_msg
     should have_imeths :all_pass_result_summary_msg, :results_summary_sentence
     should have_imeths :test_count_statement, :result_count_statement

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 2
-  - 5
+  - 6
   - 0
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,11 +16,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-01-02 00:00:00 Z
+date: 2014-01-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: ansi
   prerelease: false
+  type: :runtime
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,8 +31,8 @@ dependencies:
         - 1
         - 3
         version: "1.3"
-  type: :runtime
   version_requirements: *id001
+  name: ansi
 description: Test::Unit style testing framework, just better than Test::Unit.
 email: 
 - kelly@kellyredding.com