assert 0.1.0 → 0.2.0

data/Gemfile.lock

@@ -1,11 +1,13 @@
 PATH
   remote: .
   specs:
-    assert (0.1.0)
+    assert (0.2.0)
+      ansi (~> 1.3)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    ansi (1.3.0)
     rake (0.9.2)
 
 PLATFORMS

data/README.rdoc

@@ -4,16 +4,16 @@ Test::Unit style testing framework, just better than Test::Unit.
 
 == What Assert is
 
-* *A framework:* you define tests and the context they run in - Assert runs them.  Everything is pure ruby so use any 3rd party testing tools you like.  Create 3rd party tools that extend Assert behavior.
-* *First Class:* everything is a first class object and can be extended to your liking (and should be)
-* *MVC:* tests and how they are defined (M) and executed (C) are distinct from how you view the test results (V).
-* *Backwards compatible:* (assuming a few minor tweaks) with Test::Unit test suites
+* *Framework*: you define tests and the context they run in - Assert runs them.  Everything is pure ruby so use any 3rd party testing tools you like.  Create 3rd party tools that extend Assert behavior.
+* *First Class*: everything is a first class object and can be extended to your liking (and should be)
+* *MVC*: tests and how they are defined (M) and executed (C) are distinct from how you view the test results (V).
+* *Backwards compatible*: (assuming a few minor tweaks) with Test::Unit test suites
 
 == What Assert is not
 
 * *Rspec*
-* *Unit/Functional/Integration/etc:* Assert is agnostic - you define whatever kinds of tests you like (one or more of the above) and assert runs them in context.
-* *Mock/Spec/BDD/Factories/etc:* Assert is the framework and there are a variety of 3rd party tools to do such things - feel free to use whatever you like.
+* *Unit/Functional/Integration/etc*: Assert is agnostic - you define whatever kinds of tests you like (one or more of the above) and assert runs them in context.
+* *Mock/Spec/BDD/Factories/etc*: Assert is the framework and there are a variety of 3rd party tools to do such things - feel free to use whatever you like.
 
 == Description
 

data/Rakefile

@@ -1,7 +1,6 @@
-include Rake::DSL
+require 'assert/rake_tasks'
+include Assert::RakeTasks
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'lib/assert/rake_tasks'
-Assert::RakeTasks.for :test

data/assert.gemspec

@@ -18,4 +18,5 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency("bundler", ["~> 1.0"])
+  s.add_dependency("ansi", ["~> 1.3"])
 end

data/lib/assert/assertions.rb

@@ -67,7 +67,7 @@ module Assert
 
 
 
-    def assert_respond_to(object, method, fail_desc=nil)
+    def assert_respond_to(method, object, fail_desc=nil)
       what_failed_msg = [
         "Expected #{object.inspect} (#{object.class}) to ",
         "respond to ##{method}."
@@ -75,7 +75,7 @@ module Assert
       assert(object.respond_to?(method), fail_desc, what_failed_msg)
     end
 
-    def assert_not_respond_to(object, method, fail_desc=nil)
+    def assert_not_respond_to(method, object, fail_desc=nil)
       what_failed_msg = [
         "#{object.inspect} (#{object.class}) not expected to ",
         "respond to ##{method}."
@@ -86,59 +86,58 @@ module Assert
 
 
 
-    def assert_same(left, right, fail_desc=nil)
+    def assert_same(expected, actual, fail_desc=nil)
       what_failed_msg = [
-        "Expected #{left} (#{left.object_id}) to be the same ",
-        "as #{right} (#{right.object_id})."
+        "Expected #{expected} (#{expected.object_id}) to be the same ",
+        "as #{actual} (#{actual.object_id})."
       ].join
-      assert(right.equal?(left), fail_desc, what_failed_msg)
+      assert(actual.equal?(expected), fail_desc, what_failed_msg)
     end
 
-    def assert_not_same(left, right, fail_desc=nil)
+    def assert_not_same(expected, actual, fail_desc=nil)
       what_failed_msg = [
-        "#{left} (#{left.object_id}) not expected to be the same ",
-        "as #{right} (#{right.object_id})."
+        "#{expected} (#{expected.object_id}) not expected to be the same ",
+        "as #{actual} (#{actual.object_id})."
       ].join
-      assert(!right.equal?(left), fail_desc, what_failed_msg)
+      assert(!actual.equal?(expected), fail_desc, what_failed_msg)
     end
     alias_method :refute_same, :assert_not_same
 
 
 
-    def assert_equal(left, right, fail_desc=nil)
-      what_failed_msg = "Expected #{left.inspect}, not #{right.inspect}."
-      assert(right == left, fail_desc, what_failed_msg)
+    def assert_equal(expected, actual, fail_desc=nil)
+      what_failed_msg = "Expected #{expected.inspect}, not #{actual.inspect}."
+      assert(actual == expected, fail_desc, what_failed_msg)
     end
 
-    def assert_not_equal(left, right, fail_desc=nil)
+    def assert_not_equal(expected, actual, fail_desc=nil)
       what_failed_msg = [
-        "#{left.inspect} not expected to be equal ", "to #{right.inspect}."
+        "#{expected.inspect} not expected to be equal ", "to #{actual.inspect}."
       ].join
-      assert(right != left, fail_desc, what_failed_msg)
+      assert(actual != expected, fail_desc, what_failed_msg)
     end
     alias_method :refute_equal, :assert_not_equal
 
 
 
-    def assert_match(left, right, fail_desc=nil)
-      what_failed_msg = "Expected #{left.inspect} to match #{right.inspect}."
-      left = /#{Regexp.escape(left)}/ if String === left && String === right
-      assert(left =~ right, fail_desc, what_failed_msg)
+    def assert_match(expected, actual, fail_desc=nil)
+      what_failed_msg = "Expected #{actual.inspect} to match #{expected.inspect}."
+      expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
+      assert(actual =~ expected, fail_desc, what_failed_msg)
     end
 
-    def assert_not_match(left, right, fail_desc=nil)
+    def assert_not_match(expected, actual, fail_desc=nil)
       what_failed_msg = [
-        "#{left.inspect} not expected to ", "match #{right.inspect}."
+        "#{actual.inspect} not expected to ", "match #{expected.inspect}."
       ].join
-      left = /#{Regexp.escape(left)}/ if String === left && String === right
-      assert(left !~ right, fail_desc, what_failed_msg)
+      expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
+      assert(actual !~ expected, fail_desc, what_failed_msg)
     end
     alias_method :refute_match, :assert_not_match
     alias_method :assert_no_match, :assert_not_match
 
 
 
-    # TODO: tests!
     def assert_empty(collection, fail_desc=nil)
       what_failed_msg = "Expected #{collection.inspect} to be empty."
       assert(collection.empty?, fail_desc, what_failed_msg)
@@ -152,21 +151,22 @@ module Assert
 
 
 
-    # TODO: tests!
-    def assert_includes(collection, object, fail_desc=nil)
+    def assert_includes(object, collection, fail_desc=nil)
       what_failed_msg = "Expected #{collection.inspect} to include #{object.inspect}."
       assert(collection.include?(object), fail_desc, what_failed_msg)
     end
+    alias_method :assert_included, :assert_includes
 
-    def assert_not_included(collection, object, fail_desc=nil)
+    def assert_not_includes(object, collection, fail_desc=nil)
       what_failed_msg = "Expected #{collection.inspect} to not include #{object.inspect}."
       assert(!collection.include?(object), fail_desc, what_failed_msg)
     end
-    alias_method :refute_includes, :assert_not_included
+    alias_method :assert_not_included, :assert_not_includes
+    alias_method :refute_includes, :assert_not_includes
+    alias_method :refute_included, :assert_not_includes
 
 
 
-    # TODO: tests!
     def assert_nil(object, fail_desc=nil)
       what_failed_msg = "Expected nil, not #{object.inspect}."
       assert(object.nil?, fail_desc, what_failed_msg)

data/lib/assert/context.rb

@@ -1,10 +1,12 @@
 require 'assert/suite'
 require 'assert/assertions'
 require 'assert/result'
+require 'assert/macros/methods'
 
 module Assert
   class Context
     include Assert::Assertions
+    include Assert::Macros::Methods
 
     # a Context is a scope for tests to run in.  Contexts have setup and
     # teardown blocks, subjects, and descriptions.  Tests are run in the
@@ -19,7 +21,6 @@ module Assert
 
     # put all logic here to keep context instances pure for running tests
     class << self
-      attr_accessor :subject_block
 
       def setup_once(&block)
         Assert.suite.setup(&block)
@@ -31,84 +32,86 @@ module Assert
       end
       alias_method :after_once, :teardown_once
 
-      def setup(&block)
-        raise ArgumentError, "please provide a setup block" unless block_given?
-        self.setup_blocks << block
+      # Add a setup block to run before each test or run the list of teardown blocks in given scope
+      def setup(scope=nil, &block)
+        if block_given?
+          self.setups << block
+        elsif scope
+          # setup parent before child
+          self.superclass.setup(scope) if self.superclass.respond_to?(:setup)
+          self.setups.each{|setup| scope.instance_eval(&setup)}
+        end
       end
       alias_method :before, :setup
 
-      def teardown(&block)
-        raise ArgumentError, "please provide a teardown block" unless block_given?
-        self.teardown_blocks << block
+      # Add a teardown block to run after each test or run the list of teardown blocks in given scope
+      def teardown(scope=nil, &block)
+        if block_given?
+          self.teardowns << block
+        elsif scope
+          # teardown child before parent
+          self.teardowns.each{|teardown| scope.instance_eval(&teardown)}
+          self.superclass.teardown(scope) if self.superclass.respond_to?(:teardown)
+        end
       end
       alias_method :after, :teardown
 
-      def setup_blocks
-        @setup_blocks ||= []
-      end
-
-      def teardown_blocks
-        @teardown_blocks ||= []
+      # 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
 
-      def all_setup_blocks
-        inherited_blocks = if superclass.respond_to?(:all_setup_blocks)
-          superclass.all_setup_blocks
+      def subject(&block)
+        if block_given?
+          @subject = block
+        else
+          @subject || if superclass.respond_to?(:subject)
+            superclass.subject
+          end
         end
-        (inherited_blocks || []) + self.setup_blocks
       end
 
-      def all_teardown_blocks
-        inherited_blocks = if superclass.respond_to?(:all_teardown_blocks)
-          superclass.all_teardown_blocks
+      def should(desc_or_macro, &block)
+        if desc_or_macro.kind_of?(Macro)
+          instance_eval(&desc_or_macro)
+        else
+          raise ArgumentError, "please provide a test block" unless block_given?
+          method_name = "test: should #{desc_or_macro}"
+          if method_defined?(method_name)
+            from = caller.first
+            puts "WARNING: should #{desc_or_macro.inspect} is redefining #{method_name}!"
+            puts "  from: #{from}"
+          end
+          define_method(method_name, &block)
         end
-        (inherited_blocks || []) + self.teardown_blocks
       end
 
-      def desc(text)
-        raise ArgumentError, "no context description provided" if text.nil?
-        self.descriptions << text
+      def should_eventually(desc, &block)
+        should(desc) { skip }
       end
-      alias_method :description, :desc
+      alias_method :should_skip, :should_eventually
+
+      protected
 
       def descriptions
         @descriptions ||= []
       end
 
-      def full_description
-        inherited_description = if superclass.respond_to?(:full_description)
-          superclass.full_description
-        end
-        parts = [ inherited_description ].push(self.descriptions).flatten.reject do |part|
-         !part || part.to_s.empty?
-        end
-        parts.join(" ") if !parts.empty?
-      end
-
-      def subject(&block)
-        raise ArgumentError, "please provide a subject block" unless block_given?
-        self.subject_block = block
-      end
-
-      def subject_block
-        @subject_block ||= if superclass.respond_to?(:subject_block)
-          superclass.subject_block
-        end
+      def setups
+        @setups ||= []
       end
 
-      def should(desc, &block)
-        raise ArgumentError, "please provide a test block" unless block_given?
-        method_name = "test: should #{desc}"
-        if method_defined?(method_name)
-          from = caller.first
-          puts "WARNING: should #{desc.inspect} is redefining #{method_name}!"
-          puts "  from: #{from}"
-        end
-        define_method(method_name, &block)
-      end
-      
-      def should_eventually(desc, &block)
-        should(desc){ skip }
+      def teardowns
+        @teardowns ||= []
       end
 
     end
@@ -166,8 +169,8 @@ module Assert
     end
 
     def subject
-      if subject_block = self.class.subject_block
-        instance_eval(&subject_block)
+      if subj = self.class.subject
+        instance_eval(&subj)
       end
     end
 
@@ -177,6 +180,15 @@ module Assert
 
     protected
 
+    # Returns a Proc that will output a custom message along with the default fail message.
+    def fail_message(fail_desc=nil, &what_failed)
+      fail_desc.kind_of?(::Proc) ? fail_desc : Proc.new do
+        [ fail_desc, what_failed.call ].compact.join("\n")
+      end
+    end
+
+    private
+
     def capture_result
       if block_given?
         result = yield @__running_test__.name, caller
@@ -185,12 +197,5 @@ module Assert
       end
     end
 
-    # Returns a Proc that will output a custom message along with the default fail message.
-    def fail_message(fail_desc=nil, &what_failed)
-      fail_desc.kind_of?(::Proc) ? fail_desc : Proc.new do
-        [ what_failed.call, fail_desc ].compact.join("\n")
-      end
-    end
-
   end
 end

data/lib/assert/macro.rb

@@ -0,0 +1,14 @@
+module Assert
+  class Macro < ::Proc
+
+    # this class is essentially a way to define a custom set of tests using
+    # arguments.  When passed as an argument to the 'should' method, a macro
+    # will be instance_eval'd in that Assert::Context.
+
+    def initialize(*args, &block)
+      raise ArgumentError unless block_given?
+      super()
+    end
+
+  end
+end

data/lib/assert/macros/methods.rb

@@ -0,0 +1,52 @@
+require 'assert/macro'
+
+module Assert::Macros
+  module Methods
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+
+      def have_instance_method(*methods)
+        Assert::Macro.new do
+          methods.each do |method|
+            should "respond to instance method ##{method}" do
+              assert_respond_to method, subject, "#{subject.class.name} does not have instance method ##{method}"
+            end
+          end
+        end
+      end
+      alias_method :have_instance_methods, :have_instance_method
+
+      def have_class_method(*methods)
+        Assert::Macro.new do
+          methods.each do |method|
+            should "respond to class method ##{method}" do
+              assert_respond_to method, subject.class, "#{subject.class.name} does not have class method ##{method}"
+            end
+          end
+        end
+      end
+      alias_method :have_class_methods, :have_class_method
+
+      def have_reader(*methods)
+        have_instance_methods(*methods)
+      end
+      alias_method :have_readers, :have_reader
+
+      def have_writer(*methods)
+        have_instance_methods(*methods.collect{|m| "#{m}="})
+      end
+      alias_method :have_writers, :have_writer
+
+      def have_accessor(*methods)
+        have_instance_methods(*methods.collect{|m| [m, "#{m}="]}.flatten)
+      end
+      alias_method :have_accessors, :have_accessor
+
+    end
+
+  end
+end