thumblemonks-protest 0.0.3 → 0.0.4

data/lib/protest.rb

@@ -20,18 +20,40 @@ module Protest
   def self.run(writer=nil)
     writer ||= STDOUT
     start = Time.now
-    failures = @contexts.map { |context| context.run(writer) }.flatten
+    failures = @contexts.map { |context| context.run(writer) }.flatten.compact
     running_time = Time.now - start
 
     writer.puts "\n\n"
-    failures.each_with_index { |failure, idx|
-      message = ["##{idx + 1} - #{failure.to_s}"]
-      message += failure.backtrace
-      writer.puts message.join("\n") + "\n\n"
-    } unless failures.empty?
+    counter = 0
+    @contexts.each do |context|
+      context.failures.each do |failure|
+        counter += 1
+        message = ["##{counter} - #{context} asserted #{failure}"]
+        message += failure.backtrace
+        writer.puts message.join("\n") + "\n\n"
+      end
+    end
     assertions = @contexts.inject(0) { |acc, context| acc + context.assertions.length }
     writer.puts "#{@contexts.length} contexts, #{assertions} assertions: #{"%0.6f" % running_time} seconds"
   end
+
+  #
+  # Failures
+
+  class Failure < Exception
+    def asserted(assertion)
+      @assertion = assertion
+      self
+    end
+    
+    def to_s; "#{@assertion}: #{super}"; end
+  end
+  class Error < Failure
+    def initialize(message, e)
+      super(message)
+      set_backtrace(e.backtrace)
+    end
+  end
 end # Protest
 
 module Kernel

data/lib/protest/assertion.rb

@@ -1,58 +1,34 @@
 module Protest
-  class Failure < Exception; end
-  class Error < Exception
-    def initialize(message, e)
-      super(message)
-      set_backtrace(e.backtrace)
-    end
-  end
-
   class Assertion
     def initialize(description, &block)
       @description = description
-      @evaluated_expectation = true
-      @expects_raise = false
-      expectation(true, &block)
+      assert_block do |scope|
+        actual = scope.instance_eval(&block)
+        actual || failure("expected to be true, not #{actual.inspect}")
+      end
     end
 
-    def to_s
-      "#{@description}: expected [#{@expectation}]"
-    end
+    def to_s; @description; end
 
-    def not(&block)
-      @evaluated_expectation = false
-      expectation(@expectation, &block)
+    def assert_block(&block)
+      @block = block if block_given?
+      self
     end
 
-    def equals(expectation, &block)
-      expectation(expectation, &block)
+    def run(binding_scope)
+      @block.call(binding_scope)
     end
 
-    def raises(expectation, &block)
-      @expects_raise = true
-      expectation(expectation, &block)
-    end
+    def failure(message) raise(Protest::Failure, message); end
+  end # Assertion
 
+  class Denial < Assertion
     def run(binding_scope)
-      begin
-        actual = binding_scope.instance_eval(&@block)
-      rescue Exception => e
-        errored("#{binding_scope} asserted #{self}, but errored with: #{e.to_s}", e) unless @expects_raise
-        actual = e.class
-      end
-      assert(@expectation == actual, "#{binding_scope} asserted #{self}, but received [#{actual}] instead")
-    end
-  private
-    def expectation(expectation, &block)
-      @expectation = expectation
-      @block = block if block_given?
-      self
+      super
+    rescue Protest::Failure => e
+      true
+    else
+      failure("expected to fail, but did not")
     end
-    
-    def errored(message, e); raise Error.new(message, e); end
-
-    def assert(evaluation, message)
-      @evaluated_expectation == evaluation || raise(Failure, message)
-    end
-  end # Assertion
+  end
 end # Protest

data/lib/protest/context.rb

@@ -1,16 +1,16 @@
 module Protest
   class Context
-    attr_reader :assertions, :errors
+    attr_reader :assertions, :failures
     def initialize(description, parent=nil)
       @description = description
       @assertions = []
-      @errors = []
+      @failures = []
       @parent = parent
       @setup = nil
     end
 
     def to_s
-      [@parent.to_s, @description].join(' ').strip
+      @to_s ||= [@parent.to_s, @description].join(' ').strip
     end
 
     def context(description, &block)
@@ -22,9 +22,8 @@ module Protest
       self.bootstrap(self)
     end
 
-    def asserts(description, &block)
-      (assertions << Assertion.new(description, &block)).last
-    end
+    def asserts(description, &block) new_assertion(Assertion, description, &block); end
+    def denies(description, &block) new_assertion(Denial, description, &block); end
 
     def run(writer)
       assertions.each do |assertion|
@@ -32,17 +31,20 @@ module Protest
           assertion.run(self)
           writer.print '.'
         rescue Protest::Failure => e
-          writer.print 'F'; @errors << e
-        rescue Protest::Error => e
-          writer.print 'E'; @errors << e
+          writer.print 'F'; @failures << e.asserted(assertion)
+        rescue Exception => e
+          writer.print 'E'; @failures << Protest::Error.new("errored with #{e}", e).asserted(e)
         end
       end
-      @errors
     end
 
     def bootstrap(binder)
       @parent.bootstrap(binder) if @parent
       binder.instance_eval(&@setup) if @setup
     end
+  private
+    def new_assertion(klass, description, &block)
+      (assertions << klass.new(description, &block)).last
+    end
   end # Context
 end # Protest

data/lib/protest/macros.rb

@@ -1,16 +1,36 @@
 module Protest
-  module ContextMacros
-    def denies(description, &block)
-      asserts(description, &block).not
-    end
-  end # ContextMacros
-
   module AssertionMacros
+    def equals(expected, &block)
+      assert_block do |scope|
+        actual = scope.instance_eval(&block)
+        expected == actual || failure("expected #{expected.inspect}, not #{actual.inspect}")
+      end
+    end
+    
     def nil(&block)
       equals(nil, &block)
     end
-  end # ContextMacros
+
+    def raises(expected, &block)
+      assert_block do |scope|
+        begin
+          scope.instance_eval(&block)
+        rescue Exception => e
+          failure("should have raised #{expected}, not #{e.class}") unless expected == e.class
+        else
+          failure("should have raised #{expected}, but raised nothing")
+        end
+      end
+    end
+    
+    def matches(expected, &block)
+      expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
+      assert_block do |scope|
+        actual = scope.instance_eval(&block)
+        actual =~ expected || failure("expected #{expected.inspect}, not #{actual.inspect}")
+      end
+    end
+  end # AssertionMacros
 end # Protest
 
-Protest::Context.instance_eval { include Protest::ContextMacros }
 Protest::Assertion.instance_eval { include Protest::AssertionMacros }

data/protest.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "protest"
-  s.version  = "0.0.3"
-  s.date     = "2009-06-28"
+  s.version  = "0.0.4"
+  s.date     = "2009-06-29"
   s.summary  = "An extremely fast, expressive, and context-driven unit-testing framework"
   s.email    = %w[gus@gusg.us]
   s.homepage = "http://github.com/thumblemonks/protest"

data/test/assertion_test.rb

@@ -1,31 +1,54 @@
 require 'protest'
 
-context "any assertion" do
-  asserts("its description").equals("i will pass: expected [true]") do
+fake_object = Object.new
+
+context "basic assertion:" do
+  asserts("its description").equals("i will pass") do
     Protest::Assertion.new("i will pass").to_s
   end
-end # any assertion
 
-context "passing assertion" do
-  asserts("true is expected") { Protest::Assertion.new("i will pass") { true }.run(Object.new) }
-  asserts("false on denial") { Protest::Assertion.new("i will fail").not { false }.run(Object.new) }
-  asserts("actual result is nil") { Protest::Assertion.new("i will fail").nil { nil }.run(Object.new) }
+  asserts("true is expected") { Protest::Assertion.new("i will pass") { true }.run(fake_object) }
+
+  asserts("a Failure if not true").raises(Protest::Failure) do
+    Protest::Assertion.new("i will pass") { false }.run(fake_object)
+  end
+
+  asserts("an Exception error is thrown").raises(Exception) do
+    Protest::Assertion.new("error") { raise Exception, "blah" }.run(fake_object)
+  end
+end # basic assertion
 
-  asserts("provided block was executed and returned true") do
-    Protest::Assertion.new("i will pass").equals("foo bar") { "foo bar" }.run(Object.new)
+context "equals assertion:" do
+  asserts("results equals expectation") do
+    Protest::Assertion.new("i will pass").equals("foo bar") { "foo bar" }.run(fake_object)
   end
 
-  asserts("expectation does not equal actual result") do
-    Protest::Assertion.new("i will fail").not.equals("foo") { "bar" }.run(Object.new)
+  asserts("a Failure if results don't equal eachother").raises(Protest::Failure) do
+    Protest::Assertion.new("failure").equals("foo") { "bar" }.run(fake_object)
   end
-end # passing assertion
+end # equals assertion
 
-context "failing assertions:" do
-  asserts("a Failure error is thrown").raises(Protest::Failure) do
-    Protest::Assertion.new("failure") { false }.run(Object.new)
+context "nil assertion:" do
+  asserts("actual result is nil") { Protest::Assertion.new("foo").nil { nil }.run(fake_object) }
+  asserts("a Failure if not nil").raises(Protest::Failure) do
+    Protest::Assertion.new("foo").nil { "a" }.run(fake_object)
+  end
+end # nil assertion
+
+context "matching assertion:" do
+  asserts("actual result matches expression").equals(0) do
+    Protest::Assertion.new("foo").matches(%r[.]) { "a" }.run(fake_object)
+  end
+  asserts("a Failure if not nil").raises(Protest::Failure) do
+    Protest::Assertion.new("foo").matches(%r[.]) { "" }.run(fake_object)
+  end
+  asserts("string matches string").equals(0) do
+    Protest::Assertion.new("foo").matches("a") { "a" }.run(fake_object)
   end
+end # maching assertion
 
-  asserts("an Error error is thrown").raises(Protest::Error) do
-    Protest::Assertion.new("error") { raise Exception, "blah" }.run(Object.new)
+context "a denial" do
+  asserts("that a passing assertion evaluates to false") do
+    Protest::Denial.new("foo") { false }.run(fake_object)
   end
-end # failing assertions
+end # a denial

data/test/context_test.rb

@@ -16,11 +16,11 @@ context "any context" do
     end
 
     asserts("that failures are captured").equals(1) do
-      @context.errors.select{|e| e.kind_of?(Protest::Failure)}.length
+      @context.failures.select{|e| e.class == Protest::Failure}.length
     end
 
     asserts("that unexpected errors are captured").equals(1) do
-      @context.errors.select{|e| e.kind_of?(Protest::Error)}.length
+      @context.failures.select{|e| e.class == Protest::Error}.length
     end
   end # that doesn't have passing tests
 end # any context

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thumblemonks-protest
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Justin Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-28 00:00:00 -07:00
+date: 2009-06-29 00:00:00 -07:00
 default_executable: 
 dependencies: []