thumblemonks-protest 0.0.5 → 0.0.6

data/README.markdown

@@ -1,42 +1,284 @@
 # Protest
 
-An extremely fast-running, context-driven, unit testing framework.
+An extremely fast, expressive, and context-driven unit-testing framework.
 
-    context "Foo" do
-      setup do
-        # some setup stuff
-        @foo = Foo.new
+#### Example: Basic booleans
+
+**NOTE:** For no specific reason, I'm going to use an ActiveRecord model in the following examples.
+
+At it's very basic, Protest simply tries to assert that an expression is true or false. Protest does this through its `asserts` and `denies` tests. An `asserts` test will pass if the result of running the test is neither `nil` or `false`. A `denies` test confirms just the opposite.
+
+For instance, given a test file named `foo_test.rb`, you might have the following code in it:
+
+    require 'protest'
+    
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("that it is not yet created") { @user.new_record? }
+      denies("that it is valid") { @user.valid? }
+    end
+
+Notice that you do not define a class anywhere. That would be the entire contents of that test file.
+
+#### Example: Equality
+
+One of the most common assertions you will (or do already) utilize is that of equality; is this equal to that? Protest supports this in a slightly different manner than most other frameworks. With Protest, you add the expectation to the assertion itself.
+
+For example:
+
+    context "a new user" do
+      setup { @user = User.new(:email => 'foo@bar.com') }
+      asserts("email address") { @user.email }.equals('foo@bar.com')
+    end
+
+Here, you should begin to notice that tests themselves return the actual value. You do not write assertions into the test. Assertions are "aspected" onto the test. If the test above did not return 'foo@bar.com' for `@user.email`, the assertion would have failed.
+
+The `equals` modifier works with any type of value, including nil's. However, if you wanted to test for nil explicitly, you could simple do this:
+
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("email address") { @user.email }.nil
+    end
+
+Notice the `nil` modifier added to asserts. Also notice how the test almost reads as "a new user asserts email address *is* nil". With Test::Unit, you would have probably written:
+
+    class UserTest < Test::Unit::TestCase
+      def setup
+        @user = User.new
       end
       
-      asserts("this block returns true") do
-        true
+      def test_email_address_is_nil
+        assert_nil @user.email
       end
+    end
 
-      asserts("this block returns a specific string").equals("my friend") do
-        @foo.your_mom
+Which, to me, seems like a redundancy. The test already says it's nil! Maybe Shoulda woulda helped:
+
+    class UserTest < Test::Unit::TestCase
+      def setup
+        @user = User.new
       end
+  
+      should "have nil email" { assert_nil @user.email }
     end
 
-MORE TO COME
+In my opinion, the same redundancy exists. Sure, I could write a macro like `should_be_nil {@user.email}`, but the redundancy exists in the framework itself.
+
+#### Example: Matches
+
+If you need to assert that a test result matches a regular expression, use the `matches` modifier like so:
+
+    context "a new user" do
+      setup { @user = User.new }
+
+      # I'm a contrived example
+      asserts("random phone number") { @user.random_phone_number }.matches(/^\d{3}-\d{3}-\d{4}$/)
+    end
+
+#### Example: Raises
+
+Sometimes, your test raises an exception that you actually expected.
+
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("with bad data") { @user.save! }.raises(ActiveRecord::RecordInvalid)
+    end
+
+#### Example: Kind Of
+
+When you want to test that an expression returns an object of an expected type:
+
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("the balance") { @user.balance }.kind_of(Currency)
+    end
+
+#### Example: Nested contexts
+
+Oh yeah, Protest does those, too. The `setup` from each parent is "loaded" into the context and then the context is executed as normal. Test naming is a composite of the parent contexts' names. Here, we'll do a little Sinatra testing (see below for instructions on how to make it Protest work seamlessly with Sinatra tests).
+
+    context "My App:" do
+      setup { @app = MyApp }
+
+      context "get /" do
+        setup { get '/' }
+        # ...
+        # assertions
+
+        context "renders a body" do
+          setup { @body = last_response.body }
+          # ...
+          # assertions 
+        end
+      end
+      
+      context "get /books/1" do
+        setup { get '/books/1' }
+        # ...
+        # assertions
+      end
+    end
+
+#### More examples/documentation
+
+There are many more basic assertion modifiers to come. See below for writing Protest extensions if you want to help out.
+
+See the TODO section for everything that's missing.
+
+Also, see [the wiki](http://wiki.github.com/thumblemonks/protest) for more examples and documentation.
 
 ## You say, "OMG! Why did you write this?"
 
-#### Some background, I guess
+### Some background, I guess
 
 You start a new project. You get all excited. You're adding tests. You're adding factories. You're fixturating your setups. You're adding more tests. Your tests start slowing down, but you need to keep pushing because your backlog has a lot of new, nifty features in it. You've got 3000+ lines of test code, 2000+ assertions. Your tests are annoyingly slow. Your tests have become a burden.
 
-I hate this and it happens a lot, even when I'm conscience that it's happening.
+I hate this and it happens a lot, even when I'm conscience that it's happening. Even when I'm not hitting the database and I'm mocking the crap out my code.
 
-#### How Protest is different
+I really, really hate slow test suites.
 
-Protest differs in that it does not rerun setup for each test in a context. Each assertion should not mangle the context and therefore not require setup to be run more than once. Contexts can be nested and setups inherited, but setup is called only once per context.
+#### Did ... you look at Shoulda
+
+I should say that I love Shoulda in theory and in practice. It changed the way I coded. I added macros all over the place. I built macros into the gems I wrote for the gem itself. But, alas, Shoulda is slow. Shoulda is based on Test::Unit. Shoulda reruns setups for every should. Shoulda could make my life even easier with even more expressiveness.
+
+#### Did ... you look at RSpec
+
+:| yes, no, I don't care. It's slow, too. Anyways, I was at [ObjectMentor](http://objectmentor.com) many, many moons ago when Dave Astels (accompanied by David Chelimsky) were explaining this brand new approach to testing called BDD. Mr. Astels explained to us that we if we already understood TDD, then BDD wouldn't help a bunch. Why argue with him?
+
+### How Protest is the same
+
+1. It defines a context
+1. It prints .'s, F's, and E's when tests pass, fail, or error
+1. It tells you how long it took to run just the tests
+1. Contexts can be nested and setups inherited
+
+### How Protest is different
+
+Protest differs primarily in that it does not rerun setup for each test in a context. I know this is going to shock and awe a lot of folks. However, over the past several years of my doing TDD in some capacity or another, there are certain habits I have tried to pick up on any many others I have tried to drop.
+
+For instance, I believe that no assertion should mangle the context of the test data it is running in. Following this allows me to require setup be run only once for a collection of related assertions. Even in a nested context where setups are inherited, the setup's are called only once per the specific context.
+
+Following all of this allows me to have very fast tests (so far).
 
 ...
 
-You say, "Ok, but Shoulda is like this!"
+Protest is also different in that assertions are not added to the test block. Each test block is it's own assertion (and assertion block). Whatever the result is of processing an assertion block will be used to determine if an assertion passed or failed. Each assertion block can have a specific validator tied to it for asserting any number of things, like: the result of the test **equals** some expected value, the result of the test **matches** some expected expression, or the result of the test **raises** some exception.
+
+I like this approach because I only want to test one thing, but that one thing may require some work on my behalf to get the value. Protest does not let me cheat in this regard. There is no way for me to add more than one assertion to an assertion block.
+
+...
+
+I imagine this approach will persuade many of you to avoid Protest altogether. I don't blame you. A few years ago I would have avoided it, too. As of this writing though, I have ported Chicago and Slvu (which were previously written in Test::Unit + Shoulda) to Protest, cut the number of lines of code in almost half, definitely more than halved the amount of time the tests took to run, and did so in less than half a day (I was building Protest while porting them :).
+
+## Running tests
+
+Create or modify your existing Rakefile to define a test task like so:
+
+    desc 'Default task: run all tests'
+    task :default => [:test]
+    
+    desc "Run all tests"
+    task :test do
+      require 'protest'
+      $:.concat ['./lib', './test']
+      Dir.glob("./test/*_test.rb").each { |test| require test }
+      Protest.report
+    end
+
+Then, from the command line, you only need to run `rake` or `rake test`. Please make sure to remove all references to any other testing frameworks before running tests. For instance, do not require `test/unit`, `shoulda`, `minitest`, or anything else like it.
+
+### With Sinatra
+
+Protest definitely works with the latest Sinatra. I personally use it to run tests for [Chicago](http://github.com/thumblemonks/chicago) and [Slvu](http://github.com/jaknowlden/slvu). Setup is pretty easy and very much like getting your tests to run with Test::Unit. In a test helper file that gets loaded into all of your tests (that need it), enter the following:
+
+    require 'protest'
+    class Protest::Context
+      include Rack::Test::Methods
+      def app; @app; end
+    end
+
+And then define a context (or many) for testing your Sinatra app. For instance:
+
+    require 'test_helper'
+    
+    context 'Some App' do
+      setup { @app = SomeApp }
+      
+      context "/index" do
+        setup { get '/' }
+        # ...
+      end
+    end
+
+Make sure to check out the Protest + Sinatra testing macros in Chicago.
+
+### With Rails
+    
+It's doubtful that Protest works with Rails very easily as Protest completely replaces Test::Unit. I haven't tried it yet, but intend to with my next new Rails project. Porting would probably take some time unless you only have a few test cases.
+
+## Extending Protest with Macros
+
+To extend Protest, similar to how you would with Shoulda, you simply need to include your methods into the `Protest::Context` class. For example, let's say you wanted to add a helpful macro for asserting the response status of some HTTP result in Sinatra. You could do this easily by defining your macro like so:
+
+    module Custom
+      module Macros
+        def asserts_response_status(expected)
+          asserts("response status is #{expected}") do
+            last_response.status
+          end.equals(expected)
+        end
+      end # Macros
+    end # Custom
+    Protest::Context.instance_eval { include Custom::Macros }
+
+And then in your actual test, you might do the following:
+
+    context 'Some App' do
+      setup { @app = SomeApp }
+  
+      context "/index" do
+        setup { get '/' }
+        asserts_response_status 200
+      end
+    end
+
+**COMING SOON:** Protest will look into test/protest\_macros, but not today.
+
+#### Assertion macros
+
+If you want to add special macros to an Assertion, this is as easy as adding them to a Context. Similar to Context macros, Assertion macros are included into the Assertion class.
+
+For instance, let's say you wanted to add a macro for verifying that the result of an assertion is the same kind\_of object as you would expect. You would define the macro like so:
+
+    module Custom
+      module AssertionMacros
+        def kind_of(expected_class)
+          actual.kind_of?(expected) || failure("expected kind of #{expected}, not #{actual.inspect}")
+        end
+      end # AssertionMacros
+    end # Custom
+    Protest::Assertion.instance_eval { include Custom::AssertionMacros }
+
+And in your context, you would use it like so:
+
+    context "example" do
+      asserts("a hash is defined") { {:foo => 'bar'} }.kind_of(Hash)
+    end
+
+Notice in the new macro we defined the use of the magical **actual** variable. `actual` is evaluated when the assertion is defined and made available to any Assertion macro. If you think you might want to chain assertions checks together, know that only the last failure will get recorded.
 
-Well, it is ... sort of. I love Shoulda. It changed the way I coded. But, Shoulda is slow. Shoulda is based on Test::Unit. Shoulda reruns setups for every should. Shoulda could make my life even easier with some more expressiveness.
+## TODO
 
-#### How Protest is the same
+TONS OF STUFF
 
-It defines a context. It prints .'s, F's, and E's when tests pass, fail, or error.
+1. Documentation
+1. Refactor reporting; some abstracting is needed for recording a result (for instance)
+1. Need to know where in backtrace a test failed (line number, etc.)
+1. More assertion macros: throws, etc.
+1. Handle denies macro different, so that an entire failure message can translated to the 'negative' assertion. I don't want to add deny\_this and deny\_that macros
+1. Aliases for context "with, without, when, ..."; add those words to test description
+1. Optimization and simplification (ex. flog is complaining print\_result\_stack)
+1. Better error messages (maybe need to rename asserts to should for better readability)
+1. Perhaps: Multiple setup blocks in one context
+1. Perhaps: association macro chaining
+1. Perhaps: Uhhhhh ... a teardown method (maybe :)

data/Rakefile

@@ -7,5 +7,10 @@ desc "Run tests"
 task :test do
   $:.concat ['./test', './lib']
   Dir.glob("./test/*_test.rb").each { |test| require test }
-  Protest.run
+  Protest.report
+end
+
+desc "Run flog against library (except tests)"
+task :flog do
+  puts %x[find ./lib -name *.rb | xargs flog]
 end

data/lib/protest/assertion.rb

@@ -1,31 +1,59 @@
 module Protest
 
   class Assertion
-    def initialize(description, &block)
+    attr_reader :raised
+    def initialize(description, target, &block)
       @description = description
-      assert_block do |scope|
-        actual = scope.instance_eval(&block)
-        actual || failure("expected to be true, not #{actual.inspect}")
-      end
+      actualize(target, &block)
     end
 
-    def assert_block(&block)
-      @block = block if block_given?
-      self
+    def actual
+      @default_failure = @failure = nil if @default_failure
+      @actual
     end
 
-    def run(binding_scope) @block.call(binding_scope); end
-    def failure(message) raise Protest::Failure.new(message, self); end
+    def failure(message)
+      raise Failure.new(message, self)
+    rescue Failure => e
+      @failure = e # Smelly (for now)
+    end
+
+    def error
+      Error.new("errored with #{raised}", self, raised) if error?
+    end
+
+    def failure?; @failure; end
+    def error?; !failure? && raised; end
+    def passed?; !failure? && !error?; end
+    def result; @failure || error; end
     def to_s; @description; end
+  private
+    def actualize(target, &block)
+      @actual = target.instance_eval(&block)
+      @default_failure = base_assertion
+    rescue Exception => e
+      @raised = e
+    end
+
+    def base_assertion
+      failure("expected true, not #{@actual.inspect}") unless @actual
+    end
   end # Assertion
 
+  # Denial will evaulate to true if the assertion failed in some way. Errors pass through. A Failure
+  # is generated if the assertion actually passed.
   class Denial < Assertion
-    def run(binding_scope)
-      super
-    rescue Protest::Failure => e
-      true
-    else
-      failure("expected to fail, but did not")
+    def actual
+      @actual # Do not forget default failure unless a failure is thrown
+    end
+    
+    alias :actual_failure :failure
+    def failure(message)
+      @default_failure = @failure = nil # this is a good thing
+    end
+  private
+    def base_assertion
+      actual_failure("expected assertion to fail") if @actual
     end
   end # Denial
 

data/lib/protest/context.rb

@@ -1,7 +1,8 @@
 module Protest
   class Context
     attr_reader :description, :assertions
-    def initialize(description, parent=nil)
+    def initialize(description, reporter, parent=nil)
+      @reporter = reporter
       @description = description
       @assertions = []
       @parent = parent
@@ -20,27 +21,25 @@ module Protest
     end
 
     def to_s; @to_s ||= [@parent.to_s, @description].join(' ').strip; end
-    def context(description, &block) Protest.context(description, self, &block); end
 
+    def context(description, &block) Protest.context(description, @reporter, self, &block); end
     def asserts(description, &block) new_assertion(Assertion, description, &block); end
     def denies(description, &block) new_assertion(Denial, description, &block); end
 
-    def run(report)
+    def report
       assertions.each do |assertion|
-        begin
-          result = assertion.run(self)
-        rescue Protest::Failure => e
-          result = e
-        rescue Exception => e
-          result = Protest::Error.new("errored with #{e}", assertion, e)
-        ensure
-          report.record self, result
+        if assertion.passed?
+          @reporter.passed
+        else
+          result = assertion.result.contextualize(self)
+          @reporter.errored(result) if assertion.error?
+          @reporter.failed(result) if assertion.failure?
         end
       end
     end
   private
     def new_assertion(klass, description, &block)
-      (assertions << klass.new(description, &block)).last
+      (assertions << klass.new(description, self, &block)).last
     end
   end # Context
 end # Protest

data/lib/protest/macros.rb

@@ -1,34 +1,36 @@
 module Protest
   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
+    # Asserts that the result of the test equals the expected value
+    #   asserts("test") { "foo" }.equals("foo")
+    def equals(expected)
+      expected == actual || failure("expected #{expected.inspect}, not #{actual.inspect}")
     end
-    
-    def nil(&block)
-      equals(nil, &block)
+
+    # Asserts that the result of the test is nil
+    #   asserts("test") { nil }.nil
+    def nil
+      actual.nil? || failure("expected nil, not #{actual.inspect}")
     end
 
-    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
+    # Asserts that the test raises the expected Exception
+    #   asserts("test") { raise My::Exception }.raises(My::Exception)
+    def raises(expected)
+      failure("should have raised #{expected}, but raised nothing") unless raised
+      failure("should have raised #{expected}, not #{error.class}") unless expected == raised.class
+      @raised = nil
     end
-    
-    def matches(expected, &block)
+
+    # Asserts that the result of the test equals matches against the proved expression
+    #   asserts("test") { "12345" }.matches(/\d+/)
+    def matches(expected)
       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} to match #{actual.inspect}")
-      end
+      actual =~ expected || failure("expected #{expected.inspect} to match #{actual.inspect}")
+    end
+
+    # Asserts that the result of the test is an object that is a kind of the expected type
+    #   asserts("test") { "foo" }.kind_of(String)
+    def kind_of(expected)
+      actual.kind_of?(expected) || failure("expected kind of #{expected}, not #{actual.inspect}")
     end
   end # AssertionMacros
 end # Protest

data/lib/protest/report.rb

@@ -1,32 +1,30 @@
 module Protest
   class Report
-    attr_reader :bad_results, :passes, :failures, :errors
+    attr_reader :bad_results, :passes, :failures, :errors, :time_taken
     def initialize
       @bad_results = []
-      @passes, @failures, @errors = 0, 0 ,0
+      @passes, @failures, @errors, @time_taken = 0, 0, 0, 0.0
     end
 
     def passed?; failures + errors == 0; end
     def assertions; passes + failures + errors; end
 
-    def start; @start = Time.now; end
-    def stop; @stop = Time.now; end
-    def time_taken; @stop - @start; end
+    def time(&block)
+      @start = Time.now
+      yield
+      @time_taken += (Time.now - @start).to_f
+    end
+
+    def passed; @passes += 1; end
     
-    def record(context, object)
-      case object
-      when Protest::Error then
-        @bad_results << [context, object]
-        @errors += 1
-        errored
-      when Protest::Failure then
-        @bad_results << [context, object]
-        @failures += 1
-        failed
-      else
-        @passes += 1
-        passed
-      end
+    def failed(failure)
+      @failures += 1
+      @bad_results << failure
+    end
+
+    def errored(error)
+      @errors += 1
+      @bad_results << error
     end
   end # Report
 
@@ -36,29 +34,46 @@ module Protest
       @writer ||= STDOUT
     end
 
-    def passed; @writer.print('.'); end
-    def failed; @writer.print('F'); end
-    def errored; @writer.print('E'); end
+    def passed
+      super
+      @writer.print('.')
+    end
+
+    def failed(failure)
+      super
+      @writer.print('F')
+    end
+
+    def errored(error)
+      super
+      @writer.print('E')
+    end
 
     def results
       @writer.puts "\n\n"
-      bad_results.each_with_index do |recorded, idx|
-        ctx, failure = recorded
-        @writer.puts "#%d - %s asserted %s: %s" % [idx + 1, ctx.to_s, failure.assertion.to_s, failure.to_s]
-        @writer.puts "  " + failure.backtrace.join("\n  ") + "\n\n"
-      end
+      print_result_stack
       format = "%d assertions, %d failures, %d errors in %s seconds"
       @writer.puts format % [assertions, failures, errors, ("%0.6f" % time_taken)]
     end
   private
-    def bad_results_stack
+    def print_result_stack
+      bad_results.each_with_index do |result, idx|
+        @writer.puts render_result(idx + 1, result)
+        @writer.puts "  " + result.backtrace.join("\n  ") + "\n\n"
+      end
+    end
+
+    def render_result(idx, result)
+      format_args = [idx, result.context.to_s, result.assertion.to_s, result.to_s]
+      "#%d - %s asserts %s: %s" % format_args
     end
-  end
+  end # TextReport
 
   class NilReport < Report
     def passed; end
-    def failed; end
-    def errored; end
+    def failed(failure); end
+    def errored(error); end
     def results; end
-  end
+    def time(&block); yield; end
+  end # NilReport
 end # Protest

data/lib/protest.rb

@@ -10,9 +10,11 @@ module Protest
     @contexts ||= []
   end
 
-  def self.context(description, parent = nil, &block)
-    context = Context.new(description, parent)
-    context.instance_eval(&block)
+  def self.context(description, reporter = nil, parent = nil, &block)
+    reporter ||= self.reporter
+    context = Context.new(description, reporter, parent)
+    reporter.time { context.instance_eval(&block) }
+    context.report # Results get buffered this way, not necessarily the best
     (contexts << context).last
   end
 
@@ -20,29 +22,35 @@ module Protest
     contexts.delete(context)
   end
 
-  def self.run(report=nil)
-    report ||= TextReport.new
-    report.start
-    @contexts.each { |context| context.run(report) }
-    report.stop
-    report.results
-    at_exit { exit false unless report.passed? }
+  def self.report
+    reporter.results
+    at_exit { exit false unless reporter.passed? }
   end
 
+  #
+  # Reporter
+  
+  def self.reporter; @reporter ||= TextReport.new; end
+  def self.reporter=(report); @reporter = report; end
+
   #
   # Exception
 
   class Failure < Exception
-    attr_reader :assertion
+    attr_reader :assertion, :context
     def initialize(message, assertion)
       super(message)
       @assertion = assertion
     end
+    def contextualize(ctx)
+      @context = ctx
+      self
+    end
   end
   class Error < Failure
-    def initialize(message, assertion, e)
+    def initialize(message, assertion, error)
       super(message, assertion)
-      set_backtrace(e.backtrace)
+      set_backtrace(error.backtrace)
     end
   end
 end # Protest

data/protest.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "protest"
-  s.version  = "0.0.5"
-  s.date     = "2009-06-29"
+  s.version  = "0.0.6"
+  s.date     = "2009-07-05"
   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,54 +1,79 @@
 require 'protest'
 
-fake_object = Object.new
+fake_context = Object.new
 
 context "basic assertion:" do
-  asserts("its description").equals("i will pass") do
-    Protest::Assertion.new("i will pass").to_s
+  asserts("its description") do
+    Protest::Assertion.new("i will pass", fake_context).to_s
+  end.equals("i will pass")
+
+  asserts("passed? if assertion returns true") do
+    Protest::Assertion.new("i will pass", fake_context) { true }.passed?
+  end
+
+  asserts("failure? when assertion does not pass") do
+    Protest::Assertion.new("i will pass", fake_context) { false }.failure?
   end
 
-  asserts("true is expected") { Protest::Assertion.new("i will pass") { true }.run(fake_object) }
+  asserts("error? when an unexpected Exception is raised") do
+    Protest::Assertion.new("error", fake_context) { raise Exception, "blah" }.error?
+  end
+end
 
-  asserts("a Failure if not true").raises(Protest::Failure) do
-    Protest::Assertion.new("i will pass") { false }.run(fake_object)
+context "basic denial:" do
+  asserts("false assertion passes") do
+    Protest::Denial.new("i will pass", fake_context) { false }.passed?
   end
 
-  asserts("an Exception error is thrown").raises(Exception) do
-    Protest::Assertion.new("error") { raise Exception, "blah" }.run(fake_object)
+  asserts("true assertion fails") do
+    Protest::Denial.new("i will not pass", fake_context) { true }.failure?
   end
 end # basic assertion
 
 context "equals assertion:" do
   asserts("results equals expectation") do
-    Protest::Assertion.new("i will pass").equals("foo bar") { "foo bar" }.run(fake_object)
+    Protest::Assertion.new("i will pass", fake_context) { "foo bar" }.equals("foo bar")
   end
 
-  asserts("a Failure if results don't equal eachother").raises(Protest::Failure) do
-    Protest::Assertion.new("failure").equals("foo") { "bar" }.run(fake_object)
-  end
+  asserts("a Failure if results don't equal eachother") do
+    Protest::Assertion.new("failure", fake_context) { "bar" }.equals("foo")
+  end.kind_of(Protest::Failure)
+
+  asserts("a non-matching string is a good thing when in denial") do
+    Protest::Denial.new("pass", fake_context) { "bar" }.equals("foo")
+  end.nil
 end # equals assertion
 
 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
+  asserts("actual result is nil") { Protest::Assertion.new("foo", fake_context) { nil }.nil }
+  asserts("a Failure if not nil") do
+    Protest::Assertion.new("foo", fake_context) { "a" }.nil
+  end.kind_of(Protest::Failure)
 end # nil assertion
 
+context "raises assertion:" do
+  asserts("an Exception is raised") { raise Exception }.raises(Exception)
+end # maching 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
+  asserts("actual result matches expression") do
+    Protest::Assertion.new("foo", fake_context) { "a" }.matches(%r[.])
+  end.equals(0)
+
+  asserts("a Failure if not nil") do
+    Protest::Assertion.new("foo", fake_context) { "" }.matches(%r[.])
+  end.kind_of(Protest::Failure)
+
+  asserts("string matches string") do
+    Protest::Assertion.new("foo", fake_context) { "a" }.matches("a")
+  end.equals(0)
 end # maching assertion
 
-context "a denial" do
-  asserts("that a passing assertion evaluates to false") do
-    Protest::Denial.new("foo") { false }.run(fake_object)
+context "kind_of assertion:" do
+  asserts("result is kind of String") do
+    Protest::Assertion.new("foo", fake_context) { "a" }.kind_of(String)
   end
-end # a denial
+  asserts("a Failure if not a kind of String") do
+    Protest::Assertion.new("foo", fake_context) { 0 }.kind_of(String)
+  end.kind_of(Protest::Failure)
+end # kind_of assertion

data/test/context_test.rb

@@ -3,30 +3,35 @@ require 'stringio'
 
 context "any context" do
   setup do
-    @context = Protest::Context.new("a")
+    @reporter = Protest::NilReport.new
+    @context = Protest::Context.new("a", @reporter)
   end
 
-  denies("two contexts with same name are the same").equals(@context) { Protest::Context.new("a") }
+  # 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
-      @report = Protest::NilReport.new
       @context.asserts("a") { true }
       @context.asserts("b") { false }
       @context.asserts("c") { raise Exception, "blah" }
-      @context.run(@report)
     end
 
-    asserts("that passes are disctinct").equals(1) { @report.passes }
-    asserts("that failures are captured").equals(1) { @report.failures }
-    asserts("that unexpected errors are captured").equals(2) { @report.errors }
+    asserts("that passes are disctinct") { @reporter.passes }.equals(1)
+    asserts("that failures are captured") { @reporter.failures }.equals(1)
+    asserts("that unexpected errors are captured") { @reporter.errors }.equals(1)
   end # that doesn't have passing tests
 end # any context
 
+context "when denying things" do
+  denies("true is false") { false }
+  denies("bar equals foo") { "bar" }.equals("foo")
+  denies("bar matches only digits") { "bar" }.matches(/^\d+$/)
+end
+
 # 
 # Test Context
 
-test_context = context "foo" do
+test_context = context("foo", Protest::NilReport.new) do
   setup { @test_counter = 0 }
   asserts("a block returns true") { @test_counter += 1; true }
   asserts("another block returns true") { @test_counter += 1; true }
@@ -34,20 +39,19 @@ end # A CONTEXT THAT IS DEQUEUED
 
 context "test context" do
   setup { Protest.dequeue_context(test_context) }
-  asserts("context description").equals("foo") { test_context.to_s }
-  asserts("assertion count").equals(2) { test_context.assertions.length }
+  asserts("context description") { test_context.to_s }.equals("foo")
+  asserts("assertion count") { test_context.assertions.length }.equals(2)
 
-  asserts("setup runs only once").equals(2) do
-    test_context.run(Protest::NilReport.new)
+  asserts("setup runs only once") do
     test_context.instance_variable_get(:@test_counter)
-  end
+  end.equals(2)
 end
 
 # 
 # Nested Context
 
 inner_nested_context, other_nested_context = nil, nil
-nested_context = context "foo" do
+nested_context = context("foo", Protest::NilReport.new) do
   setup do
     @test_counter = 0
     @foo = "bar"
@@ -65,19 +69,16 @@ context "nested context" do
   setup do
     [nested_context, inner_nested_context, other_nested_context].each do |c|
       Protest.dequeue_context(c)
-      c.run(Protest::NilReport.new)
     end
   end
   
-  asserts("inner context inherits parent context setup").equals(10) do
+  asserts("inner context inherits parent context setup") do
     inner_nested_context.instance_variable_get(:@test_counter)
-  end
+  end.equals(10)
 
-  asserts("nested context name").equals("foo baz") do
-    inner_nested_context.to_s
-  end
+  asserts("nested context name") { inner_nested_context.to_s }.equals("foo baz")
 
-  asserts("inner context without setup is still bootstrapped").equals("bar") do
+  asserts("inner context without setup is still bootstrapped") do
     other_nested_context.instance_variable_get(:@foo)
-  end
+  end.equals("bar")
 end

metadata

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