riot 0.10.9 → 0.10.10

data/lib/riot/assertion_macros/raises.rb

@@ -0,0 +1,31 @@
+module Riot
+  # Asserts that the test raises the expected Exception
+  #   asserts("test") { raise My::Exception }.raises(My::Exception)
+  #   should("test") { raise My::Exception }.raises(My::Exception)
+  #
+  # You can also check to see if the provided message equals or matches your expectations. The message
+  # from the actual raised exception will be converted to a string before any comparison is executed.
+  #   asserts("test") { raise My::Exception, "Foo" }.raises(My::Exception, "Foo")
+  #   asserts("test") { raise My::Exception, "Foo Bar" }.raises(My::Exception, /Bar/)
+  class RaisesMacro < AssertionMacro
+    register :raises
+    expects_exception!
+
+    def evaluate(actual_exception, expected_class, expected_message=nil)
+      actual_message = actual_exception && actual_exception.message
+      if actual_exception.nil?
+        fail("should have raised #{expected_class}, but raised nothing")
+      elsif expected_class != actual_exception.class
+        fail("should have raised #{expected_class}, not #{actual_exception.class}")
+      elsif expected_message && !(actual_message.to_s =~ %r[#{expected_message}])
+        fail("expected #{expected_message.inspect} for message, not #{actual_message.inspect}")
+      else
+        if expected_message
+          pass("raises #{expected_class.inspect} with message #{expected_message.inspect}")
+        else
+          pass("raises #{expected_class.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/respond_to.rb

@@ -0,0 +1,16 @@
+module Riot
+  # Asserts that the result of the test is an object that responds to the given method
+  #   asserts("test") { "foo" }.respond_to(:to_s)
+  #   should("test") { "foo" }.respond_to(:to_s)
+  class RespondToMacro < AssertionMacro
+    register :respond_to
+
+    def evaluate(actual, expected)
+      if actual.respond_to?(expected)
+        pass("responds to #{expected.inspect}")
+      else
+        fail("expected method #{expected.inspect} is not defined")
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/same_elements.rb

@@ -0,0 +1,14 @@
+module Riot
+  # Asserts that two arrays contain the same elements, the same number of times.
+  #   asserts("test") { ["foo", "bar"] }.same_elements(["bar", "foo"])
+  #   should("test") { ["foo", "bar"] }.same_elements(["bar", "foo"])
+  class SameElementsMacro < AssertionMacro
+    register :same_elements
+
+    def evaluate(actual, expected)
+      require 'set'
+      same = (Set.new(expected) == Set.new(actual))
+      same ? pass : fail("expected elements #{expected.inspect} to match #{actual.inspect}")
+    end
+  end
+end

data/lib/riot/assertion_macros/size.rb

@@ -0,0 +1,15 @@
+module Riot
+  # Asserts that result's size is as expected. Expected size can be specified as
+  # a number or a range.
+  #   asserts("a string") { 'washington' }.size(9..12)
+  #   asserts("an array") { [1, 2, 3] }.size(3)
+  #   asserts("a hash") { {:name => 'washington'} }.size(1)
+  class SizeMacro < AssertionMacro
+    register :size
+
+    def evaluate(actual, expected)
+      failure_message = "size of #{actual.inspect} expected to be #{expected} but is #{actual.size}"
+      expected === actual.size ? pass("is of size #{expected}") : fail(failure_message)
+    end
+  end
+end

data/lib/riot/context.rb

@@ -1,9 +1,5 @@
 module Riot
-  RootContext = Struct.new(:setups, :teardowns) do
-    def assertion_class
-      Assertion
-    end
-  end 
+  RootContext = Struct.new(:setups, :teardowns)
 
   class Context
     attr_reader :description
@@ -28,23 +24,12 @@ module Riot
       @contexts << self.class.new("#{@description} #{description}", self, &definition)
     end
     
-    def extend_assertions(*extension_modules)
-      @assertion_class = Class.new(Assertion) do
-        include *extension_modules
-      end
-    end
-
     def run(reporter)
       reporter.describe_context(self) unless @assertions.empty?
       local_run(reporter, Situation.new)
       run_sub_contexts(reporter)
       reporter
     end
-
-    def assertion_class
-      @assertion_class ||= @parent.assertion_class
-    end
-
   private
 
     def local_run(reporter, situation)
@@ -56,7 +41,14 @@ module Riot
     def run_sub_contexts(reporter) @contexts.each { |ctx| ctx.run(reporter) }; end
 
     def new_assertion(scope, what, &definition)
-      (@assertions << assertion_class.new("#{scope} #{what}", &definition)).last
+      if what.kind_of?(Symbol)
+        definition ||= lambda { topic.send(what) }
+        description = "#{scope} ##{what}"
+      else
+        description = "#{scope} #{what}"
+      end
+
+      (@assertions << Assertion.new(description, &definition)).last
     end
   end # Context
 end # Riot

data/lib/riot/reporter.rb

@@ -20,7 +20,7 @@ module Riot
       case code
       when :pass then
         @passes += 1
-        pass(description)
+        pass(description, result)
       when :fail then
         @failures += 1
         fail(description, result)
@@ -36,24 +36,25 @@ module Riot
   end # Reporter
 
   class IOReporter < Reporter
-    attr_reader :writer
     def initialize(writer=STDOUT)
       super()
       @writer = writer
     end
-    def say(message) writer.puts(message); end
+    def puts(message) @writer.puts(message); end
+    def print(message) @writer.print(message); end
 
     def results(time_taken)
       values = [passes, failures, errors, ("%0.6f" % time_taken)]
-      say "\n%d passes, %d failures, %d errors in %s seconds" % values
+      puts "\n%d passes, %d failures, %d errors in %s seconds" % values
     end
 
     def format_error(e)
-      format = "    #{e.class.name} occured"
-      format += "\n#{e.to_s}\n"
-      e.backtrace.each { |line| format += "\n      at #{line}" }
+      format = []
+      format << "    #{e.class.name} occurred"
+      format << "#{e.to_s}"
+      e.backtrace.each { |line| format << "      at #{line}" }
 
-      format
+      format.join("\n")
     end
 
     begin
@@ -71,46 +72,49 @@ module Riot
   class StoryReporter < IOReporter
     def describe_context(context)
       super
-      say context.description
+      puts context.description
     end
-    def pass(description) say "  + " + green(description); end
-    def fail(description, message) say "  - " + yellow("#{description}: #{message}"); end
-    def error(description, e) say "  ! " + red("#{description}: #{e.message}"); end
+    def pass(description, message) puts "  + " + green("#{description} #{message}".strip); end
+    def fail(description, message) puts "  - " + yellow("#{description}: #{message}"); end
+    def error(description, e) puts "  ! " + red("#{description}: #{e.message}"); end
   end
 
   class VerboseStoryReporter < StoryReporter
     def error(description, e)
-      super(description, e)
-      say red(format_error(e))
+      super
+      puts red(format_error(e))
     end
   end
 
   class DotMatrixReporter < IOReporter
-    def pass(description); writer.write green("."); end
-
     def initialize(writer=STDOUT)
       super
       @details = []
     end
+
+    def pass(description, message)
+      print green(".")
+    end
+
     def fail(description, message)
-      writer.write yellow("F")
+      print yellow("F")
       @details << "FAILURE - #{current_context.description} #{description} => #{message}"
     end
 
     def error(description, e)
-      writer.write red("E")
+      print red("E")
       @details << "ERROR - #{current_context.description} #{description} => #{format_error(e)}"
     end
 
     def results(time_taken)
-      say "\n"
-      @details.each { |detail| say detail }
+      puts "\n" unless @details.empty?
+      @details.each { |detail| puts detail }
       super
     end
   end
 
   class SilentReporter < Reporter
-    def pass(description); end
+    def pass(description, message); end
     def fail(description, message); end
     def error(description, e); end
     def results(time_taken); end

data/riot.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot}
-  s.version = "0.10.9"
+  s.version = "0.10.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-12-15}
+  s.date = %q{2009-12-29}
   s.description = %q{An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test.}
   s.email = %q{gus@gusg.us}
   s.extra_rdoc_files = [
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     "CHANGELOG",
      "MIT-LICENSE",
      "README.markdown",
      "Rakefile",
@@ -24,7 +25,20 @@ Gem::Specification.new do |s|
      "VERSION",
      "lib/riot.rb",
      "lib/riot/assertion.rb",
-     "lib/riot/assertion_macros.rb",
+     "lib/riot/assertion_macro.rb",
+     "lib/riot/assertion_macros/any.rb",
+     "lib/riot/assertion_macros/assigns.rb",
+     "lib/riot/assertion_macros/empty.rb",
+     "lib/riot/assertion_macros/equals.rb",
+     "lib/riot/assertion_macros/exists.rb",
+     "lib/riot/assertion_macros/includes.rb",
+     "lib/riot/assertion_macros/kind_of.rb",
+     "lib/riot/assertion_macros/matches.rb",
+     "lib/riot/assertion_macros/nil.rb",
+     "lib/riot/assertion_macros/raises.rb",
+     "lib/riot/assertion_macros/respond_to.rb",
+     "lib/riot/assertion_macros/same_elements.rb",
+     "lib/riot/assertion_macros/size.rb",
      "lib/riot/context.rb",
      "lib/riot/reporter.rb",
      "lib/riot/runnable.rb",

data/test/assertion_macros/any_test.rb

@@ -7,12 +7,12 @@ context "An any assertion macro" do
     end
   end
 
-  assertion_test_passes("when an array has items") { assert_any([1]) }
+  assertion_test_passes("when an array has items", "is not empty") { assert_any([1]) }
   assertion_test_fails("when an array is empty", "expected [] to have items") do
     assert_any([])
   end
 
-  assertion_test_passes("when a hash has items") { assert_any({:name => 'washington'}) }
+  assertion_test_passes("when a hash has items", "is not empty") { assert_any({:name => 'washington'}) }
   assertion_test_fails("when a hash is empty", "expected {} to have items") do
     assert_any({})
   end

data/test/assertion_macros/equals_test.rb

@@ -1,6 +1,6 @@
 require 'teststrap'
 
-# Using == to verify the tes because this is the test for :equals itself. Look at assertion_test_passes
+# Using == to verify the test because this is the test for :equals itself. Look at assertion_test_passes
 # and assertion_test_fails for testing other macros.
 
 context "An equals assertion macro" do
@@ -9,7 +9,7 @@ context "An equals assertion macro" do
   end
 
   asserts(":pass when expectation met") do
-    topic.equals("foo").run(Riot::Situation.new) == [:pass]
+    topic.equals("foo").run(Riot::Situation.new) == [:pass, %Q{is equal to "foo"}]
   end
 
   context "that is failing" do
@@ -25,7 +25,7 @@ context "An equals assertion macro" do
     end
 
     asserts(":pass when in expected range") do
-      topic.equals(30000..32000).run(Riot::Situation.new) == [:pass]
+      topic.equals(30000..32000).run(Riot::Situation.new) == [:pass, "is equal to 30000..32000"]
     end
 
     context "when not in expected range" do
@@ -39,7 +39,7 @@ context "An equals assertion macro" do
   context "with block as the expectation" do
     asserts(":pass when block expectation met") do
       topic.equals { "foo" }.run(Riot::Situation.new)
-    end.equals([:pass])
+    end.equals([:pass, %Q{is equal to "foo"}])
 
     asserts(":fail with message when block expectation not met") do
       topic.equals { "bar" }.run(Riot::Situation.new)

data/test/assertion_macros/exists_test.rb

@@ -5,11 +5,11 @@ context "An exists assertion macro" do
 
   asserts(":pass when result has a value") do
     Riot::Assertion.new("foo") { "foo" }.exists.run(topic)
-  end.equals([:pass])
+  end.equals([:pass, "is not nil"])
 
   asserts(":pass because empty string is considered a value") do
     Riot::Assertion.new("foo") { "" }.exists.run(topic)
-  end.equals([:pass])
+  end.equals([:pass, "is not nil"])
 
   asserts(":fail with message when value is nil") do
     Riot::Assertion.new("foo") { nil }.exists.run(topic)

data/test/assertion_macros/includes_test.rb

@@ -5,7 +5,7 @@ context "An includes assertion macro" do
     Riot::Assertion.new("an array") { [1, 6, 42, 7] }
   end
 
-  assertion_test_passes("when array includes 42") { topic.includes(42) }
+  assertion_test_passes("when array includes 42", "includes 42") { topic.includes(42) }
 
   assertion_test_fails("when 99 not included in array", "expected [1, 6, 42, 7] to include 99") do
     topic.includes(99)

data/test/assertion_macros/kind_of_test.rb

@@ -5,7 +5,7 @@ context "A kind_of assertion macro" do
 
   asserts ":pass when specific result is a kind of String" do
     Riot::Assertion.new("foo") { "a" }.kind_of(String).run(topic)
-  end.equals([:pass])
+  end.equals([:pass, %Q{is a kind of String}])
 
   asserts ":fail when not a kind of String" do
     Riot::Assertion.new("foo") { 0 }.kind_of(String).run(topic)

data/test/assertion_macros/matching_test.rb

@@ -3,7 +3,7 @@ require 'teststrap'
 context "A matching assertion macro" do
   setup { Riot::Assertion.new("foo") { "abc" } }
 
-  assertion_test_passes("when expression matches actual") { topic.matches(/abc/) }
+  assertion_test_passes("when expression matches actual", %Q{matches /abc/}) { topic.matches(/abc/) }
 
   assertion_test_fails("when expression fails to match", "expected /abcd/ to match \"abc\"") do
     topic.matches(/abcd/)

data/test/assertion_macros/nil_test.rb

@@ -5,7 +5,7 @@ context "A nil assertion macro" do
 
   asserts(":pass when result is nil") do
     Riot::Assertion.new("foo") { nil }.nil.run(topic)
-  end.equals([:pass])
+  end.equals([:pass, "is nil"])
 
   asserts(":fail with message") do
     Riot::Assertion.new("foo") { "a" }.nil.run(topic)

data/test/assertion_macros/raises_test.rb

@@ -3,7 +3,7 @@ require 'teststrap'
 class Whoops < Exception; end
 
 context "A raises assertion macro" do
-  assertion_test_passes("when expected exception is raised") do
+  assertion_test_passes("when expected exception is raised", "raises Whoops") do
     Riot::Assertion.new("foo") { raise Whoops }.raises(Whoops)
   end
 
@@ -15,7 +15,7 @@ context "A raises assertion macro" do
     assertion = Riot::Assertion.new("foo") { "barf" }.raises(Whoops)
   end
   
-  assertion_test_passes("when provided message equals expected message") do
+  assertion_test_passes("when provided message equals expected message", %Q{raises Whoops with message "Mom"}) do
     Riot::Assertion.new("foo") { raise Whoops, "Mom" }.raises(Whoops, "Mom")
   end
 
@@ -23,7 +23,7 @@ context "A raises assertion macro" do
     Riot::Assertion.new("foo") { raise Whoops, "Dad" }.raises(Whoops, "Mom")
   end
 
-  assertion_test_passes("when provided message matches expected message") do
+  assertion_test_passes("when provided message matches expected message", %Q{raises Whoops with message /Mom/}) do
     Riot::Assertion.new("foo") { raise Whoops, "Mom" }.raises(Whoops, /Mom/)
   end
 

data/test/assertion_macros/respond_to_test.rb

@@ -3,7 +3,7 @@ require 'teststrap'
 context "A respond_to assertion macro" do
   setup { Riot::Assertion.new("foo") { "bar" } }
 
-  assertion_test_passes("when method is defined") { topic.respond_to(:each_byte) }
+  assertion_test_passes("when method is defined", "responds to :each_byte") { topic.respond_to(:each_byte) }
 
   assertion_test_fails("when method not defined", "expected method :goofballs is not defined") do
     topic.respond_to(:goofballs)

data/test/assertion_macros/size_test.rb

@@ -7,8 +7,13 @@ context "A size assertion macro" do
     end
   end
 
-  assertion_test_passes("when string's size is as expected") { assert_size("washington", 10) }
-  assertion_test_passes("when string's size is in given range") { assert_size("washington", 9..12) }
+  assertion_test_passes("when string's size is as expected", "is of size 10") do
+    assert_size("washington", 10)
+  end
+  assertion_test_passes("when string's size is in given range", "is of size 9..12") do
+    assert_size("washington", 9..12)
+  end
+
   assertion_test_fails("when string's size is not as expected", "size of \"washington\" expected to be 11 but is 10") do
     assert_size("washington", 11)
   end
@@ -16,8 +21,10 @@ context "A size assertion macro" do
     assert_size("washington", 11..13)
   end
 
-  assertion_test_passes("when an array's size is as expected") { assert_size([1, 2, 3], 3) }
-  assertion_test_passes("when an array's size is in given range") { assert_size([1, 2, 3], 3..4) }
+  assertion_test_passes("when an array's size is as expected", "is of size 3") { assert_size([1, 2, 3], 3) }
+  assertion_test_passes("when an array's size is in given range", "is of size 3..4") do
+    assert_size([1, 2, 3], 3..4)
+  end
   assertion_test_fails("when an array's size is not as expected", "size of [1, 2, 3] expected to be 2 but is 3") do
     assert_size([1, 2, 3], 2)
   end
@@ -25,8 +32,12 @@ context "A size assertion macro" do
     assert_size([1, 2, 3], 4..6)
   end
 
-  assertion_test_passes("when a hash size is as expected") { assert_size({:name => 'washington'}, 1) }
-  assertion_test_passes("when a hash size is in range") { assert_size({:name => 'washington'}, 1...3) }
+  assertion_test_passes("when a hash size is as expected", "is of size 1") do
+    assert_size({:name => 'washington'}, 1)
+  end
+  assertion_test_passes("when a hash size is in range", "is of size 1...3") do
+    assert_size({:name => 'washington'}, 1...3)
+  end
   assertion_test_fails("when a hash size is not as expected", "size of {} expected to be 2 but is 0") do
     assert_size({}, 2)
   end