assert 2.19.1 → 2.19.6

data/lib/assert/runner.rb

@@ -14,21 +14,21 @@ module Assert
       @config = config
     end
 
-    def runner; self; end
+    def runner
+      self
+    end
 
     def run
-      self.on_start
-      self.suite.on_start
-      self.view.on_start
-
-      if self.single_test?
-        self.view.print "Running test: #{self.single_test_file_line}"
-      elsif self.tests_to_run?
-        self.view.print "Running tests in random order"
-      end
-      if self.tests_to_run?
-        self.view.puts ", seeded with \"#{self.runner_seed}\""
+      on_start
+      suite.on_start
+      view.on_start
+
+      if single_test?
+        view.print "Running test: #{single_test_file_line}"
+      elsif tests_to_run?
+        view.print "Running tests in random order"
       end
+      view.puts ", seeded with \"#{runner_seed}\"" if tests_to_run?
 
       @current_running_test = nil
 
@@ -36,46 +36,46 @@ module Assert
       # (Ctrl+T on Macs), process it
       if Signal.list.keys.include?("INFO")
         Signal.trap("INFO") do
-          self.on_info(@current_running_test)
-          self.suite.on_info(@current_running_test)
-          self.view.on_info(@current_running_test)
+          on_info(@current_running_test)
+          suite.on_info(@current_running_test)
+          view.on_info(@current_running_test)
         end
       end
 
       begin
-        self.suite.start_time = Time.now
-        self.suite.setups.each(&:call)
-        tests_to_run.tap{ self.suite.clear_tests_to_run }.delete_if do |test|
+        suite.start_time = Time.now
+        suite.setups.each(&:call)
+        tests_to_run.tap{ suite.clear_tests_to_run }.delete_if do |test|
           @current_running_test = test
 
-          self.before_test(test)
-          self.suite.before_test(test)
-          self.view.before_test(test)
+          before_test(test)
+          suite.before_test(test)
+          view.before_test(test)
           test.run do |result|
-            self.on_result(result)
-            self.suite.on_result(result)
-            self.view.on_result(result)
+            on_result(result)
+            suite.on_result(result)
+            view.on_result(result)
           end
-          self.after_test(test)
-          self.suite.after_test(test)
-          self.view.after_test(test)
+          after_test(test)
+          suite.after_test(test)
+          view.after_test(test)
 
           # always delete `test` from `tests_to_run` since it has been run
           true
         end
-        self.suite.teardowns.each(&:call)
-        self.suite.end_time = Time.now
-      rescue Interrupt => err
-        self.on_interrupt(err)
-        self.suite.on_interrupt(err)
-        self.view.on_interrupt(err)
-        raise(err)
+        suite.teardowns.each(&:call)
+        suite.end_time = Time.now
+      rescue Interrupt => ex
+        on_interrupt(ex)
+        suite.on_interrupt(ex)
+        view.on_interrupt(ex)
+        raise(ex)
       end
 
-      (self.fail_result_count + self.error_result_count).tap do
-        self.view.on_finish
-        self.suite.on_finish
-        self.on_finish
+      (fail_result_count + error_result_count).tap do
+        view.on_finish
+        suite.on_finish
+        on_finish
       end
     end
 
@@ -84,24 +84,41 @@ module Assert
     # define callback handlers to do special behavior during the test run. These
     # will be called by the test runner
 
-    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_info(test);           end
-    def on_interrupt(err);       end
+    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_info(test)
+    end
+
+    def on_interrupt(err)
+    end
 
     private
 
     def tests_to_run
-      srand self.runner_seed
-      if self.single_test?
-        [self.suite.find_test_to_run(self.single_test_file_line)].compact
+      srand runner_seed
+      if single_test?
+        [suite.find_test_to_run(single_test_file_line)].compact
       else
-        self.suite.sorted_tests_to_run{ rand self.tests_to_run_count }
+        suite.sorted_tests_to_run{ rand tests_to_run_count }
       end
     end
   end

data/lib/assert/stub.rb

@@ -27,9 +27,9 @@ module Assert
     orig_caller = caller_locations
     begin
       MuchStub.stub_send(*args, &block)
-    rescue MuchStub::NotStubbedError => err
-      err.set_backtrace(orig_caller.map(&:to_s))
-      raise err
+    rescue MuchStub::NotStubbedError => ex
+      ex.set_backtrace(orig_caller.map(&:to_s))
+      raise ex
     end
   end
 
@@ -44,4 +44,43 @@ module Assert
   def self.stub_spy(*args, &block)
     MuchStub.spy(*args, &block)
   end
+
+  StubCall = MuchStub::Call
+  class StubCall
+    def self.name
+      super.gsub("MuchStub::Call", "Assert::StubCall")
+    end
+
+    def self.to_s
+      super.gsub("MuchStub::Call", "Assert::StubCall")
+    end
+
+    def self.inspect
+      super.gsub("MuchStub::Call", "Assert::StubCall")
+    end
+
+    def inspect
+      super.gsub("MuchStub::Call", "Assert::StubCall")
+    end
+  end
+
+  StubCallSpy = MuchStub::CallSpy
+  class StubCallSpy
+    def self.name
+      super.gsub("MuchStub::CallSpy", "Assert::StubCallSpy")
+    end
+
+    def self.to_s
+      super.gsub("MuchStub::CallSpy", "Assert::StubCallSpy")
+    end
+
+    def self.inspect
+      super.gsub("MuchStub::CallSpy", "Assert::StubCallSpy")
+    end
+
+    # See MuchStub::CallSpy#inspect.
+    def inspect
+      "#<Assert::StubCallSpy:#{"0x0%x" % (__id__ << 1)}>"
+    end
+  end
 end

data/lib/assert/suite.rb

@@ -27,21 +27,31 @@ module Assert
       @end_time   = @start_time
     end
 
-    def suite; self; end
+    def suite
+      self
+    end
 
     def setup(&block)
-      self.setups << (block || proc{})
+      setups << (block || proc{})
     end
     alias_method :startup, :setup
 
     def teardown(&block)
-      self.teardowns << (block || proc{})
+      teardowns << (block || proc{})
     end
     alias_method :shutdown, :teardown
 
-    def tests_to_run?;      @tests.size > 0; end
-    def tests_to_run_count; @tests.size;     end
-    def clear_tests_to_run; @tests.clear;    end
+    def tests_to_run?
+      @tests.any?
+    end
+
+    def tests_to_run_count
+      @tests.size
+    end
+
+    def clear_tests_to_run
+      @tests.clear
+    end
 
     def find_test_to_run(file_line)
       @tests.find{ |t| t.file_line == file_line }
@@ -51,32 +61,46 @@ module Assert
       @tests.sort.sort_by(&sort_by_proc)
     end
 
-    def test_count;          end
-    def result_count;        end
-    def pass_result_count;   end
-    def fail_result_count;   end
-    def error_result_count;  end
-    def skip_result_count;   end
-    def ignore_result_count; end
+    def test_count
+    end
+
+    def result_count
+    end
+
+    def pass_result_count
+    end
+
+    def fail_result_count
+    end
+
+    def error_result_count
+    end
+
+    def skip_result_count
+    end
+
+    def ignore_result_count
+    end
 
     def run_time
       @end_time - @start_time
     end
 
     def test_rate
-      get_rate(self.test_count, self.run_time)
+      get_rate(test_count, run_time)
     end
 
     def result_rate
-      get_rate(self.result_count, self.run_time)
+      get_rate(result_count, run_time)
     end
 
     # Callbacks
 
-    # define callback handlers to do special behavior during the test run.  These
-    # will be called by the test runner
+    # define callback handlers to do special behavior during the test run.
+    # These will be called by the test runner.
 
-    def before_load(test_files); end
+    def before_load(test_files)
+    end
 
     # this is required to load tests into the suite, be sure to `super` if you
     # override this method
@@ -84,19 +108,34 @@ module Assert
       @tests << test
     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_info(test);     end
-    def on_interrupt(err); 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_info(test)
+    end
+
+    def on_interrupt(err)
+    end
 
     def inspect
       "#<#{self.class}:#{"0x0%x" % (object_id << 1)}"\
-      " test_count=#{self.test_count.inspect}"\
-      " result_count=#{self.result_count.inspect}>"
+      " test_count=#{test_count.inspect}"\
+      " result_count=#{result_count.inspect}>"
     end
   end
 end

data/lib/assert/test.rb

@@ -9,16 +9,16 @@ module Assert
     # Test is some code/method to run in the scope of a Context that may
     # produce results.
     def self.name_file_line_context_data(ci, name)
-      { :name      => ci.test_name(name),
-        :file_line => ci.called_from
+      { name: ci.test_name(name),
+        file_line: ci.called_from,
       }
     end
 
     def self.for_block(name, context_info, config, &block)
-      self.new(self.name_file_line_context_data(context_info, name).merge({
-        :context_info => context_info,
-        :config       => config,
-        :code         => block
+      new(name_file_line_context_data(context_info, name).merge({
+        context_info: context_info,
+        config: config,
+        code: block,
       }))
     end
 
@@ -31,8 +31,13 @@ module Assert
       @file_line ||= FileLine.parse((@build_data[:file_line] || "").to_s)
     end
 
-    def file_name; self.file_line.file;      end
-    def line_num;  self.file_line.line.to_i; end
+    def file_name
+      file_line.file
+    end
+
+    def line_num
+      file_line.line.to_i
+    end
 
     def name
       @name ||= (@build_data[:name] || "")
@@ -51,7 +56,7 @@ module Assert
     end
 
     def context_class
-      self.context_info.klass
+      context_info.klass
     end
 
     def config
@@ -64,22 +69,22 @@ module Assert
 
     def run(&result_callback)
       @result_callback = result_callback || proc{ |result| } # noop by default
-      scope = self.context_class.new(self, self.config, @result_callback)
+      scope = context_class.new(self, config, @result_callback)
       start_time = Time.now
       capture_output do
-        self.context_class.run_arounds(scope){ run_test(scope) }
+        context_class.run_arounds(scope){ run_test(scope) }
       end
       @result_callback = nil
       @run_time = Time.now - start_time
     end
 
-    def <=>(other_test)
-      self.name <=> other_test.name
+    def <=>(other)
+      name <=> other.name
     end
 
     def inspect
       attributes_string = ([:name, :context_info].collect do |attr|
-        "@#{attr}=#{self.send(attr).inspect}"
+        "@#{attr}=#{send(attr).inspect}"
       end).join(" ")
       "#<#{self.class}:#{"0x0%x" % (object_id << 1)} #{attributes_string}>"
     end
@@ -89,33 +94,33 @@ module Assert
     def run_test(scope)
       begin
         # run any assert style "setup do" setups
-        self.context_class.run_setups(scope)
+        context_class.run_setups(scope)
         # run any test/unit style "def setup" setups
         scope.setup if scope.respond_to?(:setup)
         # run the code block
-        scope.instance_eval(&(self.code || proc{}))
-      rescue Result::TestFailure => err
-        capture_result(Result::Fail, err)
-      rescue Result::TestSkipped => err
-        capture_result(Result::Skip, err)
-      rescue SignalException => err
-        raise(err)
-      rescue Exception => err
-        capture_result(Result::Error, err)
+        scope.instance_eval(&(code || proc{}))
+      rescue Result::TestFailure => ex
+        capture_result(Result::Fail, ex)
+      rescue Result::TestSkipped => ex
+        capture_result(Result::Skip, ex)
+      rescue SignalException => ex
+        raise(ex)
+      rescue => ex
+        capture_result(Result::Error, ex)
       ensure
         begin
           # run any assert style "teardown do" teardowns
-          self.context_class.run_teardowns(scope)
+          context_class.run_teardowns(scope)
           # run any test/unit style "def teardown" teardowns
           scope.teardown if scope.respond_to?(:teardown)
-        rescue Result::TestFailure => err
-          capture_result(Result::Fail, err)
-        rescue Result::TestSkipped => err
-          capture_result(Result::Skip, err)
-        rescue SignalException => err
-          raise(err)
-        rescue Exception => err
-          capture_result(Result::Error, err)
+        rescue Result::TestFailure => ex
+          capture_result(Result::Fail, ex)
+        rescue Result::TestSkipped => ex
+          capture_result(Result::Skip, ex)
+        rescue SignalException => ex
+          raise(ex)
+        rescue => ex
+          capture_result(Result::Error, ex)
         end
       end
     end
@@ -125,7 +130,7 @@ module Assert
     end
 
     def capture_output(&block)
-      if self.config.capture_output == true
+      if config.capture_output == true
         orig_stdout = $stdout.clone
         $stdout = capture_io
         block.call
@@ -136,7 +141,7 @@ module Assert
     end
 
     def capture_io
-      StringIO.new(self.output, "a+")
+      StringIO.new(output, "a+")
     end
   end
 end