assert 2.4.0 → 2.5.0

data/lib/assert/cli.rb

@@ -50,7 +50,7 @@ module Assert
     def run
       begin
         @cli.parse!(@args)
-        Assert::AssertRunner.new(@cli.args, @cli.opts).run
+        Assert::AssertRunner.new(Assert.config, @cli.args, @cli.opts).run
       rescue CLIRB::HelpExit
         puts help
       rescue CLIRB::VersionExit

data/lib/assert/config.rb

@@ -0,0 +1,56 @@
+module Assert
+
+  class Config
+
+    def self.settings(*items)
+      items.each do |item|
+        define_method(item) do |*args|
+          if !(value = args.size > 1 ? args : args.first).nil?
+            instance_variable_set("@#{item}", value)
+          end
+          instance_variable_get("@#{item}")
+        end
+      end
+    end
+
+    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
+
+    def initialize(settings = nil)
+      @suite  = Assert::Suite.new(self)
+      @view   = Assert::View::DefaultView.new($stdout, self, @suite)
+      @runner = Assert::Runner.new(self)
+
+      @test_dir    = "test"
+      @test_helper = "helper.rb"
+      @test_file_suffixes = ['_tests.rb', '_test.rb']
+      @runner_seed   = begin; srand; srand % 0xFFFF; end.to_i
+
+      @changed_proc  = Assert::U.git_changed_proc
+      @pp_proc       = Assert::U.stdlib_pp_proc
+      @use_diff_proc = Assert::U.default_use_diff_proc
+      @run_diff_proc = Assert::U.syscmd_diff_proc
+
+      # mode flags
+      @capture_output = false
+      @halt_on_fail   = true
+      @changed_only   = false
+      @pp_objects     = false
+      @debug          = false
+
+      self.apply(settings || {})
+    end
+
+    def apply(settings)
+      settings.keys.each do |name|
+        if !settings[name].nil? && self.respond_to?(name.to_s)
+          self.send(name.to_s, settings[name])
+        end
+      end
+    end
+
+  end
+
+end

data/lib/assert/context.rb

@@ -1,11 +1,21 @@
-require 'assert/utils'
-require 'assert/suite'
 require 'assert/assertions'
-require 'assert/result'
+require 'assert/context/setup_dsl'
+require 'assert/context/subject_dsl'
+require 'assert/context/suite_dsl'
+require 'assert/context/test_dsl'
 require 'assert/macros/methods'
+require 'assert/result'
+require 'assert/suite'
+require 'assert/utils'
 
 module Assert
+
   class Context
+    # put all logic in DSL methods to keep context instances pure for running tests
+    extend SetupDSL
+    extend SubjectDSL
+    extend SuiteDSL
+    extend TestDSL
     include Assert::Assertions
     include Assert::Macros::Methods
 
@@ -21,155 +31,21 @@ module Assert
       if method_name.to_s =~ Suite::TEST_METHOD_REGEX
         klass_method_name = "#{self}##{method_name}"
 
-        if Assert.suite.test_methods.include?(klass_method_name)
+        if self.suite.test_methods.include?(klass_method_name)
           puts "WARNING: redefining '#{klass_method_name}'"
           puts "  from: #{called_from}"
         else
-          Assert.suite.test_methods << klass_method_name
+          self.suite.test_methods << klass_method_name
         end
 
         ci = Suite::ContextInfo.new(self, nil, caller.first)
-        Assert.suite.tests << Test.new(method_name.to_s, ci, method_name)
-      end
-    end
-
-    # put all logic here to keep context instances pure for running tests
-    class << self
-
-      def setup_once(&block)
-        Assert.suite.setup(&block)
-      end
-      alias_method :before_once, :setup_once
-      alias_method :startup, :setup_once
-
-      def teardown_once(&block)
-        Assert.suite.teardown(&block)
-      end
-      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
-      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
-      end
-      alias_method :after, :teardown
-
-      # Add a piece of description text or return the full description for the context
-      def description(text=nil)
-        if text
-          self.descriptions << text.to_s
-        else
-          parent = self.superclass.desc if self.superclass.respond_to?(:desc)
-          own = self.descriptions
-          [parent, *own].compact.reject do |p|
-            p.to_s.empty?
-          end.join(" ")
-        end
-      end
-      alias_method :desc, :description
-      alias_method :describe, :description
-
-      def subject(&block)
-        if block_given?
-          @subject = block
-        else
-          @subject || if superclass.respond_to?(:subject)
-            superclass.subject
-          end
-        end
-      end
-
-      def test(desc_or_macro, called_from=nil, first_caller=nil, &block)
-        if desc_or_macro.kind_of?(Macro)
-          instance_eval(&desc_or_macro)
-        elsif block_given?
-          ci = Suite::ContextInfo.new(self, called_from, first_caller || caller.first)
-          test_name = desc_or_macro
-
-          # create a test from the given code block
-          Assert.suite.tests << Test.new(test_name, ci, &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 = Suite::ContextInfo.new(self, called_from, first_caller || caller.first)
-        test_name = desc_or_macro.kind_of?(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
-        Assert.suite.tests << Test.new(test_name, ci, &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?(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?(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
-
-      protected
-
-      def descriptions
-        @descriptions ||= []
+        test = Test.new(method_name.to_s, ci, self.suite.config, :code => method_name)
+        self.suite.tests << test
       end
-
-      def setups
-        @setups ||= []
-      end
-
-      def teardowns
-        @teardowns ||= []
-      end
-
     end
 
-    def initialize(running_test = nil)
-      @__running_test__ = running_test
+    def initialize(running_test, config)
+      @__running_test__, @__assert_config__ = running_test, config
     end
 
     # check if the assertion is a truthy value, if so create a new pass result, otherwise
@@ -179,7 +55,11 @@ module Assert
       if assertion
         pass
       else
-        what = block_given? ? yield : "Failed assert: assertion was `#{Assert::U.show(assertion)}`."
+        what = if block_given?
+          yield
+        else
+          "Failed assert: assertion was `#{Assert::U.show(assertion, __assert_config__)}`."
+        end
         fail(fail_message(desc, what))
       end
     end
@@ -187,7 +67,9 @@ module Assert
     # the opposite of assert, check if the assertion is a false value, if so create a new pass
     # result, otherwise create a new fail result with the desc and it's what failed msg
     def assert_not(assertion, fail_desc = nil)
-      assert(!assertion, fail_desc){ "Failed assert_not: assertion was `#{Assert::U.show(assertion)}`." }
+      assert(!assertion, fail_desc) do
+        "Failed assert_not: assertion was `#{Assert::U.show(assertion, __assert_config__)}`."
+      end
     end
     alias_method :refute, :assert_not
 
@@ -208,9 +90,9 @@ module Assert
     end
 
     # adds a Fail result to the end of the test's results
-    # break test execution if Assert.config.halt_on_fail
+    # break test execution if assert is configured to halt on failures
     def fail(message = nil)
-      if Assert.config.halt_on_fail
+      if halt_on_fail?
         raise Result::TestFailure, message || ''
       else
         capture_result do |test, backtrace|
@@ -258,16 +140,28 @@ module Assert
 
     private
 
+    def halt_on_fail?
+      __assert_config__.halt_on_fail
+    end
+
     def capture_result
       if block_given?
-        result = yield @__running_test__, caller
-        @__running_test__.results << result
+        result = yield __running_test__, caller
+        __running_test__.results << result
         result
       end
     end
 
     def current_results
-      @__running_test__.results
+      __running_test__.results
+    end
+
+    def __running_test__
+      @__running_test__
+    end
+
+    def __assert_config__
+      @__assert_config__
     end
 
   end

data/lib/assert/context/setup_dsl.rb

@@ -0,0 +1,70 @@
+module Assert; end
+class Assert::Context
+
+  module SetupDSL
+
+    def setup_once(&block)
+      self.suite.setup(&block)
+    end
+    alias_method :before_once, :setup_once
+    alias_method :startup, :setup_once
+
+    def teardown_once(&block)
+      self.suite.teardown(&block)
+    end
+    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
+    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
+    end
+    alias_method :after, :teardown
+
+    protected
+
+    def setups
+      @setups ||= []
+    end
+
+    def teardowns
+      @teardowns ||= []
+    end
+
+  end
+
+end

data/lib/assert/context/subject_dsl.rb

@@ -0,0 +1,39 @@
+module Assert; end
+class Assert::Context
+
+  module SubjectDSL
+
+    # Add a piece of description text or return the full description for the context
+    def description(text = nil)
+      if text
+        self.descriptions << text.to_s
+      else
+        parent = self.superclass.desc if self.superclass.respond_to?(:desc)
+        own = self.descriptions
+        [parent, *own].compact.reject do |p|
+          p.to_s.empty?
+        end.join(" ")
+      end
+    end
+    alias_method :desc, :description
+    alias_method :describe, :description
+
+    def subject(&block)
+      if block_given?
+        @subject = block
+      else
+        @subject || if superclass.respond_to?(:subject)
+          superclass.subject
+        end
+      end
+    end
+
+    protected
+
+    def descriptions
+      @descriptions ||= []
+    end
+
+  end
+
+end

data/lib/assert/context/suite_dsl.rb

@@ -0,0 +1,20 @@
+module Assert; end
+class Assert::Context
+
+  module SuiteDSL
+
+    def suite(suite_obj = nil)
+      if suite_obj
+        @suite = suite_obj
+      else
+        @suite || if superclass.respond_to?(:suite)
+          superclass.suite
+        else
+          Assert.suite
+        end
+      end
+    end
+
+  end
+
+end