thumblemonks-protest 0.0.7 → 0.0.8

data/README.markdown

@@ -43,7 +43,7 @@ For example:
 
 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:
+The `equals` modifier works with any type of value, including nil's. However, if you wanted to test for nil explicitly, you could simply do this:
 
     context "a new user" do
       setup { @user = User.new }
@@ -91,7 +91,7 @@ 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)
+      asserts("invalid data") { @user.save! }.raises(ActiveRecord::RecordInvalid)
     end
 
 #### Example: Kind Of
@@ -100,7 +100,7 @@ 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)
+      asserts("its balance") { @user.balance }.kind_of(Currency)
     end
 
 #### Example: Nested contexts
@@ -224,7 +224,7 @@ 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.
+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. Porting is made somewhat easier if you're already using Shoulda; you can replace the `TestCase` definition with a `context` of the same name as the class under test I suppose.
 
 ## Extending Protest with Macros
 
@@ -281,13 +281,14 @@ Notice in the new macro we defined the use of the magical **actual** variable. `
 
 TONS OF STUFF
 
-1. Documentation
+1. Documentation about the `topic` method
+1. Better documentation for everything
 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. Need to know where in backtrace a test failed (line number, etc.); i.e. backtrace filtering for clarity
 1. More assertion macros: throws, etc.
 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. Better error messages?
 1. Perhaps: Multiple setup blocks in one context
 1. Perhaps: association macro chaining
-1. Perhaps: Uhhhhh ... a teardown method (maybe :)
+1. Perhaps: Uhhhhh ... a teardown method (only maybe. not sold :)

data/Rakefile

@@ -15,6 +15,11 @@ task :flog do
   puts %x[find ./lib -name *.rb | xargs flog]
 end
 
+desc "Run Flay against library (except tests)"
+task :flay do
+  puts %x[find ./lib -name *.rb | xargs flay]
+end
+
 desc "Run Roodi against library (except tests)"
 task :roodi do
   puts %x[find ./lib -name *.rb | xargs roodi]

data/lib/protest.rb

@@ -29,9 +29,11 @@ module Protest
 
   #
   # Reporter
-  
+
   def self.reporter; @reporter ||= TextReport.new; end
   def self.reporter=(report); @reporter = report; end
+  def self.silently!; @silently = true; end
+  def self.silently?; @silently || false; end
 
   #
   # Exception

data/lib/protest/assertion.rb

@@ -1,10 +1,10 @@
 module Protest
 
   class Assertion
-    attr_reader :raised, :to_s
-    def initialize(description, target, &block)
+    attr_reader :raised, :to_s, :description
+    def initialize(description, situation, &block)
       @description = @to_s = description
-      actualize(target, &block)
+      actualize(situation, &block)
     end
 
     def actual
@@ -12,26 +12,24 @@ module Protest
       @actual
     end
 
-    def failure(message)
-      raise Failure.new(message, self)
-    rescue Failure => e
-      @failure = e # Smelly (for now)
+    def fail(message)
+      @failure = Failure.new(message, self) unless errored?
     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 failed?; !@failure.nil?; end
+    def errored?; !@raised.nil?; end
+    def passed?; !(failed? || errored?); end
     def result; @failure || error; end
   private
-    def actualize(target, &block)
-      @actual = target.instance_eval(&block)
-      @default_failure = failure("expected true, not #{@actual.inspect}") unless @actual
+    def actualize(situation, &block)
+      @actual = situation.instance_eval(&block)
+      @default_failure = fail("expected true, not #{@actual.inspect}") unless @actual
     rescue Exception => e
       @raised = e
     end
+
+    def error
+      Error.new("errored with #{@raised}", self, @raised) if errored?
+    end
   end # Assertion
 end # Protest

data/lib/protest/context.rb

@@ -1,45 +1,57 @@
 module Protest
   class Context
-    attr_reader :description, :assertions
+    # The protein
+    attr_reader :description, :assertions, :situation
     def initialize(description, reporter, parent=nil)
-      @reporter = reporter
-      @description = description
+      @description, @reporter = description, reporter
       @assertions = []
       @parent = parent
-      @setup = nil
-      bootstrap(self)
+      @situation = Object.new
+      bootstrap(@situation)
     end
 
-    def bootstrap(binder)
-      @parent.bootstrap(binder) if @parent
-      binder.instance_eval(&@setup) if @setup
+    def bootstrap(a_situation)
+      @parent.bootstrap(a_situation) if @parent # Walk it out
+      induce_local_setup(a_situation)
     end
 
+    # something smelly between setup() and bootstrap()
     def setup(&block)
       @setup = block
-      self.instance_eval(&block)
+      make_situation_topical(induce_local_setup(situation))
     end
 
-    def to_s; @to_s ||= [@parent.to_s, @description].join(' ').strip; end
-
+    # DSLee stuff
     def context(description, &block) Protest.context(description, @reporter, self, &block); end
     def asserts(description, &block) new_assertion("asserts #{description}", &block); end
     def should(description, &block) new_assertion("should #{description}", &block); end
 
+    # In conclusion
     def report
+       # we should just be passing assertions to the reporter and building better descriptions earlier
       assertions.each do |assertion|
         if assertion.passed?
           @reporter.passed
         else
           result = assertion.result.contextualize(self)
-          @reporter.errored(result) if assertion.error?
-          @reporter.failed(result) if assertion.failure?
+          @reporter.send( (assertion.errored? ? :errored : :failed), result)
         end
       end
     end
+
+    def to_s; @to_s ||= [@parent.to_s, @description].join(' ').strip; end
   private
     def new_assertion(description, &block)
-      (assertions << Assertion.new(description, self, &block)).last
+      (assertions << Assertion.new(description, @situation, &block)).last
+    end
+
+    def induce_local_setup(a_situation)
+      a_situation.instance_eval(&@setup) if @setup
+    end
+
+    def make_situation_topical(topic)
+      situation.instance_variable_set(:@topic, topic)
+      situation.instance_eval { def topic; @topic; end }
     end
   end # Context
 end # Protest

data/lib/protest/macros.rb

@@ -4,22 +4,22 @@ module Protest
     #   asserts("test") { "foo" }.equals("foo")
     #   should("test") { "foo" }.equals("foo")
     def equals(expected)
-      expected == actual || failure("expected #{expected.inspect}, not #{actual.inspect}")
+      expected == actual || fail("expected #{expected.inspect}, not #{actual.inspect}")
     end
 
     # Asserts that the result of the test is nil
     #   asserts("test") { nil }.nil
     #   should("test") { nil }.nil
     def nil
-      actual.nil? || failure("expected nil, not #{actual.inspect}")
+      actual.nil? || fail("expected nil, not #{actual.inspect}")
     end
 
     # Asserts that the test raises the expected Exception
     #   asserts("test") { raise My::Exception }.raises(My::Exception)
     #   should("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
+      fail("should have raised #{expected}, but raised nothing") unless raised
+      fail("should have raised #{expected}, not #{error.class}") unless expected == raised.class
       @raised = nil
     end
 
@@ -28,14 +28,14 @@ module Protest
     #   should("test") { "12345" }.matches(/\d+/)
     def matches(expected)
       expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
-      actual =~ expected || failure("expected #{expected.inspect} to match #{actual.inspect}")
+      actual =~ expected || fail("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)
     #   should("test") { "foo" }.kind_of(String)
     def kind_of(expected)
-      actual.kind_of?(expected) || failure("expected kind of #{expected}, not #{actual.inspect}")
+      actual.kind_of?(expected) || fail("expected kind of #{expected}, not #{actual.inspect}")
     end
   end # AssertionMacros
 end # Protest

data/lib/protest/report.rb

@@ -1,3 +1,5 @@
+require 'stringio'
+
 module Protest
   class Report
     attr_reader :bad_results, :passes, :failures, :errors, :time_taken
@@ -31,7 +33,7 @@ module Protest
   class TextReport < Report
     def initialize(writer=nil)
       super()
-      @writer ||= STDOUT
+      @writer ||= (Protest.silently? ? StringIO.new : STDOUT)
     end
 
     def passed
@@ -71,9 +73,6 @@ module Protest
   end # TextReport
 
   class NilReport < Report
-    def passed; end
-    def failed(failure); end
-    def errored(error); end
     def results; end
     def time(&block); yield; end
   end # NilReport

data/protest.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "protest"
-  s.version  = "0.0.7"
-  s.date     = "2009-08-12"
+  s.version  = "0.0.8"
+  s.date     = "2009-09-12"
   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"
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
   s.test_files = %w[
     Rakefile
     test/assertion_test.rb
+    test/benchmark/simple_context_and_assertions.rb
     test/context_test.rb
   ]
 end

data/test/assertion_test.rb

@@ -12,11 +12,11 @@ context "basic assertion:" do
   end
 
   asserts "failure? is true when assertion does not pass" do
-    Protest::Assertion.new("i will pass", fake_context) { false }.failure?
+    Protest::Assertion.new("i will pass", fake_context) { false }.failed?
   end
 
   asserts "error? is true when an unexpected Exception is raised" do
-    Protest::Assertion.new("error", fake_context) { raise Exception, "blah" }.error?
+    Protest::Assertion.new("error", fake_context) { raise Exception, "blah" }.errored?
   end
 end
 

data/test/benchmark/simple_context_and_assertions.rb

@@ -0,0 +1,76 @@
+$:.concat ['./lib']
+require 'benchmark'
+
+#
+# Model
+
+class Room
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+end
+
+#
+# Protest
+
+require 'protest'
+Protest.silently! # Do this before any contexts are defined
+
+context "a room" do
+  setup { @room = Room.new("bed") }
+
+  asserts("name") { @room.name }.equals("bed")
+end # a room
+ 
+#
+# Test::Unit
+
+require 'test/unit'
+Test::Unit.run = false
+
+require 'test/unit/ui/console/testrunner'
+
+class RoomTest < Test::Unit::TestCase
+  def setup
+    @room = Room.new("bed")
+  end
+
+  def test_room_should_be_named_bed
+    assert_equal "bed", @room.name
+  end
+end
+
+#
+# Shoulda
+
+require 'rubygems'
+require 'shoulda'
+
+class ShouldaRoomTest < Test::Unit::TestCase
+  def setup
+    @room = Room.new("bed")
+  end
+
+  should("be named 'bed'") { assert_equal "bed", @room.name }
+end
+
+#
+# Benchmarking
+
+n = 100 * 100
+
+Benchmark.bmbm do |x|
+  x.report("Protest") do
+    n.times { Protest.report }
+  end
+
+  x.report("Test::Unit") do
+    n.times { Test::Unit::UI::Console::TestRunner.new(RoomTest, Test::Unit::UI::SILENT) }
+  end
+
+  x.report("Shoulda") do
+    n.times { Test::Unit::UI::Console::TestRunner.new(ShouldaRoomTest, Test::Unit::UI::SILENT) }
+  end
+end
+

data/test/context_test.rb

@@ -7,19 +7,26 @@ context "any context" do
     @context = Protest::Context.new("a", @reporter)
   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.should("a") { true }
       @context.should("b") { false }
       @context.should("c") { raise Exception, "blah" }
+      @context.report
     end
 
     asserts("passed test count") { @reporter.passes }.equals(1)
     asserts("failure count") { @reporter.failures }.equals(1)
     asserts("unexpected errors count") { @reporter.errors }.equals(1)
   end # that doesn't have passing tests
+
+  context "when running setup:" do
+    setup { @context.setup { "foo" } }
+
+    asserts "topic becomes available to test as result of setup" do
+      @context.should("bar") { topic }.actual
+    end.equals("foo")
+  end # when running setup
 end # any context
 
 # 
@@ -36,8 +43,8 @@ context "test context" do
   should("confirm context description") { test_context.to_s }.equals("foo")
   should("confirm assertion count") { test_context.assertions.length }.equals(2)
 
-  should("call setup once") do
-    test_context.instance_variable_get(:@test_counter)
+  should("call setup once per context") do
+    test_context.situation.instance_variable_get(:@test_counter) # yuck
   end.equals(2)
 end # test context
 
@@ -67,12 +74,12 @@ context "nested context" do
   end
   
   should("inherit parent context") do
-    inner_nested_context.instance_variable_get(:@test_counter)
+    inner_nested_context.situation.instance_variable_get(:@test_counter)
   end.equals(10)
 
   should("chain context names") { inner_nested_context.to_s }.equals("foo baz")
 
   asserts "parent setup is called even if setup not defined for self" do
-    other_nested_context.instance_variable_get(:@foo)
+    other_nested_context.situation.instance_variable_get(:@foo)
   end.equals("bar")
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thumblemonks-protest
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Justin Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-12 00:00:00 -07:00
+date: 2009-09-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -33,7 +33,6 @@ files:
 - protest.gemspec
 has_rdoc: false
 homepage: http://github.com/thumblemonks/protest
-licenses: 
 post_install_message: 
 rdoc_options: 
 - --main
@@ -55,11 +54,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: An extremely fast, expressive, and context-driven unit-testing framework
 test_files: 
 - Rakefile
 - test/assertion_test.rb
+- test/benchmark/simple_context_and_assertions.rb
 - test/context_test.rb