thumblemonks-protest 0.0.2 → 0.0.3

data/lib/protest/assertion.rb

@@ -1,10 +1,17 @@
 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
-      @boolean_expectation = true
+      @evaluated_expectation = true
+      @expects_raise = false
       expectation(true, &block)
     end
 
@@ -13,7 +20,7 @@ module Protest
     end
 
     def not(&block)
-      @boolean_expectation = false
+      @evaluated_expectation = false
       expectation(@expectation, &block)
     end
 
@@ -21,9 +28,19 @@ module Protest
       expectation(expectation, &block)
     end
 
-    def run(context)
-      actual = context.instance_eval(&@block)
-      assert(@expectation == actual, "#{context} asserted #{self}, but received [#{actual}] instead")
+    def raises(expectation, &block)
+      @expects_raise = true
+      expectation(expectation, &block)
+    end
+
+    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)
@@ -32,8 +49,10 @@ module Protest
       self
     end
     
-    def assert(expression, msg)
-      @boolean_expectation == expression || raise(Failure, msg)
+    def errored(message, e); raise Error.new(message, e); end
+
+    def assert(evaluation, message)
+      @evaluated_expectation == evaluation || raise(Failure, message)
     end
   end # Assertion
 end # Protest

data/lib/protest/context.rb

@@ -1,10 +1,10 @@
 module Protest
   class Context
-    attr_reader :assertions
+    attr_reader :assertions, :errors
     def initialize(description, parent=nil)
       @description = description
       @assertions = []
-      @failures = []
+      @errors = []
       @parent = parent
       @setup = nil
     end
@@ -32,11 +32,12 @@ module Protest
           assertion.run(self)
           writer.print '.'
         rescue Protest::Failure => e
-          writer.print 'F'
-          @failures << e
+          writer.print 'F'; @errors << e
+        rescue Protest::Error => e
+          writer.print 'E'; @errors << e
         end
       end
-      @failures
+      @errors
     end
 
     def bootstrap(binder)

data/lib/protest/macros.rb

@@ -4,6 +4,13 @@ module Protest
       asserts(description, &block).not
     end
   end # ContextMacros
+
+  module AssertionMacros
+    def nil(&block)
+      equals(nil, &block)
+    end
+  end # ContextMacros
 end # Protest
 
-Protest::Context.instance_eval { include Protest::ContextMacros }
+Protest::Context.instance_eval { include Protest::ContextMacros }
+Protest::Assertion.instance_eval { include Protest::AssertionMacros }

data/lib/protest.rb

@@ -26,7 +26,7 @@ module Protest
     writer.puts "\n\n"
     failures.each_with_index { |failure, idx|
       message = ["##{idx + 1} - #{failure.to_s}"]
-      # message += failure.backtrace
+      message += failure.backtrace
       writer.puts message.join("\n") + "\n\n"
     } unless failures.empty?
     assertions = @contexts.inject(0) { |acc, context| acc + context.assertions.length }

data/protest.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = "protest"
-  s.version  = "0.0.2"
+  s.version  = "0.0.3"
   s.date     = "2009-06-28"
   s.summary  = "An extremely fast, expressive, and context-driven unit-testing framework"
   s.email    = %w[gus@gusg.us]

data/test/assertion_test.rb

@@ -7,35 +7,25 @@ context "any assertion" do
 end # any assertion
 
 context "passing assertion" do
-  asserts("true is expected") do
-    Protest::Assertion.new("i will pass") { true }.run(Object.new)
-  end
+  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("provided block was executed and returned true") do
     Protest::Assertion.new("i will pass").equals("foo bar") { "foo bar" }.run(Object.new)
   end
 
-  asserts("false on denial") do
-    Protest::Assertion.new("i will fail").not { false }.run(Object.new)
-  end
-
   asserts("expectation does not equal actual result") do
     Protest::Assertion.new("i will fail").not.equals("foo") { "bar" }.run(Object.new)
   end
 end # passing assertion
 
-context "failing assertion" do
-  setup do
-    @expected_message = "test context asserted failure: expected [true], but received [false] instead"
-    assertion = Protest::Assertion.new("failure") { false }
-    begin
-      assertion.run(Protest::Context.new("test context"))
-    rescue Protest::Failure => e
-      @result = e
-    end
+context "failing assertions:" do
+  asserts("a Failure error is thrown").raises(Protest::Failure) do
+    Protest::Assertion.new("failure") { false }.run(Object.new)
   end
-  
-  asserts("failure message").equals(@expected_message) do
-    @result.to_s
+
+  asserts("an Error error is thrown").raises(Protest::Error) do
+    Protest::Assertion.new("error") { raise Exception, "blah" }.run(Object.new)
   end
-end # failing assertion
+end # failing assertions

data/test/context_test.rb

@@ -2,10 +2,28 @@ require 'protest'
 require 'stringio'
 
 context "any context" do
-  denies("two contexts with same name are the same").equals(Protest::Context.new("a")) do
-    Protest::Context.new("a")
+  setup do
+    @context = Protest::Context.new("a")
   end
-end
+
+  denies("two contexts with same name are the same").equals(@context) { Protest::Context.new("a") }
+
+  context "that doesn't have passing tests" do
+    setup do
+      @context.asserts("b") { false }
+      @context.asserts("c") { raise Exception, "blah" }
+      @context.run(StringIO.new)
+    end
+
+    asserts("that failures are captured").equals(1) do
+      @context.errors.select{|e| e.kind_of?(Protest::Failure)}.length
+    end
+
+    asserts("that unexpected errors are captured").equals(1) do
+      @context.errors.select{|e| e.kind_of?(Protest::Error)}.length
+    end
+  end # that doesn't have passing tests
+end # any context
 
 # 
 # Test Context

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thumblemonks-protest
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Justin Knowlden