riot 0.10.9 → 0.10.10

data/test/assertion_test.rb

@@ -6,7 +6,7 @@ context "An assertion" do
     asserts("to_s") { topic.to_s == "foo" }
 
     asserts(":pass is returned when evaluated") do
-      topic.run(Riot::Situation.new) == [:pass]
+      topic.run(Riot::Situation.new) == [:pass, nil]
     end
   end # that is passing
 
@@ -32,7 +32,7 @@ context "An assertion" do
     end
   end # that is erroring
 
-  context "with no block to provide the actual" do
+  context "with no block to provide the actual value" do
     setup do
       @situation = Riot::Situation.new
       @situation.topic = "hello"
@@ -41,8 +41,8 @@ context "An assertion" do
     should("uses block returning topic as default") do
       topic.equals("hello")
       result = topic.run(@situation)
-    end.equals([:pass])
-  end
+    end.equals([:pass, %Q{is equal to "hello"}])
+  end # with no block to provide the actual value
   
   context "with block expectation" do
     setup do
@@ -54,11 +54,16 @@ context "An assertion" do
     should("use block returning topic as default") do
       topic.equals { "hello" }
       result = topic.run(@situation)
-    end.equals([:pass])
+    end.equals([:pass, %Q{is equal to "hello"}])
 
     asserts("block expectation has access to the situation items") do
       topic.equals { @topic }
       topic.run(@situation)
-    end.equals([:pass])
+    end.equals([:pass, %Q{is equal to "hello"}])
+  end # with block expectation
+
+  context "with symbolic description" do
+    setup { "foo" }
+    asserts(:upcase).equals("FOO")
   end
 end # An assertion block

data/test/context_test.rb

@@ -24,7 +24,7 @@ context "Defining a context with multiple setups" do
     end
     @a_context.run(MockReporter.new)
   end
-  asserts("has setups") { @a_context.setups.count }.equals(2)
+  asserts("has setups") { @a_context.setups.size }.equals(2)
   asserts("all tests pass") { topic.passes == 1 }
 end # Defining a context with multiple setups
 
@@ -86,57 +86,5 @@ context "The asserts_topic shortcut" do
   should("return the actual topic as the result of evaling the assertion") do
     (situation = Riot::Situation.new).topic = "bar"
     topic.equals("bar").run(situation)
-  end.equals([:pass])
+  end.equals([:pass, %Q{is equal to "bar"}])
 end # The asserts_topic shortcut
-
-context "Setting assertion extensions" do
-  fake_mod_one, fake_mod_two = Module.new, Module.new
-
-  setup do
-    Riot::Context.new("foo") do
-      extend_assertions fake_mod_one, fake_mod_two
-    end.asserts_topic
-  end
-
-  should("still return an Assertion") { topic }.kind_of(Riot::Assertion)
-
-  should("have included the given assertion extension modules in the assertion") do
-    topic.class.included_modules.include?(fake_mod_one) && topic.class.included_modules.include?(fake_mod_two)
-  end
-
-  context "involving subcontexts without the subcontext extending assertions" do
-    assertion_one = assertion_two = nil
-
-    setup do 
-      Riot::Context.new "bleh" do
-        extend_assertions Module.new
-        assertion_one = asserts_topic
-        context("foo") { assertion_two = asserts_topic } 
-      end
-    end
-    
-    should "not create separate instances of the assertion class in subcontexts" do
-      assertion_one && assertion_two && assertion_one.class.object_id == assertion_two.class.object_id
-    end
-  end # involving subcontexts without the subcontext extending assertions
-
-  context "involving subcontexts with the subcontext extending assertions" do
-    assertion_one = assertion_two = nil
-    
-    setup do
-      Riot::Context.new "bah" do
-        extend_assertions Module.new
-        assertion_one = asserts_topic
-        context("meh") do
-          extend_assertions Module.new
-          assertion_two = asserts_topic
-        end
-      end
-    end
-
-    should "create separate instances of the assertion class in subcontexts" do
-      assertion_one && assertion_two && assertion_one.class.object_id != assertion_two.class.object_id
-    end
-
-  end # involving subcontexts with the subcontext extending assertions
-end   # Setting assertion extensions

data/test/report_test.rb

@@ -3,7 +3,7 @@ require 'teststrap'
 context "A reporter" do
   setup do
     Class.new(Riot::Reporter) do
-      def pass(d) "passed(#{d})"; end
+      def pass(d, message) "passed(#{d}, #{message.inspect})"; end
       def fail(d, message) "failed(#{d}, #{message})"; end
       def error(d, e) "errored(#{d}, #{e})"; end
     end.new
@@ -18,7 +18,7 @@ context "A reporter" do
 
   asserts("description sent to #pass") do
     topic.report("hi mom", [:pass])
-  end.equals("passed(hi mom)")
+  end.equals("passed(hi mom, nil)")
 
   # fail
 
@@ -56,6 +56,11 @@ context "StoryReporter" do
     Riot::StoryReporter.new(@out)
   end
 
+  asserts("success message is stripped if nil") do
+    topic.pass("foo", nil)
+    ColorHelper.uncolored(@out.string)
+  end.equals("  + foo\n")
+
   context 'reporting on an empty context' do
     setup do
       context = Riot::Context.new('empty context') do

data/test/teststrap.rb

@@ -1,13 +1,16 @@
 $:.unshift(File.dirname(__FILE__)+"/../lib/")
 require 'riot'
+Riot.verbose
 
 module Riot
   module AssertionTestContextMacros
 
-    def assertion_test_passes(description, &block)
+    def assertion_test_passes(description, success_message=nil, &block)
       context(description) do
         setup(&block)
-        asserts("passes") { topic.run(Riot::Situation.new) }.equals([:pass])
+        setup { topic.run(Riot::Situation.new) }
+        asserts("pass") { topic.first }.equals(:pass)
+        asserts("success message") { topic.last }.equals(success_message)
       end
     end
 
@@ -25,8 +28,14 @@ end # Riot
 Riot::Context.instance_eval { include Riot::AssertionTestContextMacros }
 
 class MockReporter < Riot::Reporter
-  def pass(description); end
+  def pass(description, message); end
   def fail(description, message); end
   def error(description, e); end
   def results; end
 end
+
+class ColorHelper
+  require 'rubygems'
+  require 'term/ansicolor'
+  extend Term::ANSIColor
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
-  version: 0.10.9
+  version: 0.10.10
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-15 00:00:00 -06:00
+date: 2009-12-29 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,7 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - .gitignore
+- CHANGELOG
 - MIT-LICENSE
 - README.markdown
 - Rakefile
@@ -39,7 +40,20 @@ files:
 - 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/lib/riot/assertion_macros.rb

@@ -1,136 +0,0 @@
-module Riot
-  class Assertion
-    # Asserts that the result of the test equals the expected value. Using the +===+ operator to assert
-    # equality.
-    #   asserts("test") { "foo" }.equals("foo")
-    #   should("test") { "foo" }.equals("foo")
-    #   asserts("test") { "foo" }.equals { "foo" }
-    assertion(:equals) do |actual, expected|
-      expected === actual ? pass : 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
-    assertion(:nil) do |actual|
-      actual.nil? ? pass : fail("expected nil, not #{actual.inspect}")
-    end
-
-    # Asserts that the result of the test is a non-nil value. This is useful in the case where you don't want
-    # to translate the result of the test into a boolean value
-    #   asserts("test") { "foo" }.exists
-    #   should("test") { 123 }.exists
-    #   asserts("test") { "" }.exists
-    #   asserts("test") { nil }.exists # This would fail
-    assertion(:exists) do |actual|
-      !actual.nil? ? pass : fail("expected a non-nil value")
-    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)
-    assertion(:kind_of) do |actual, expected|
-      actual.kind_of?(expected) ? pass : fail("expected kind of #{expected}, not #{actual.class.inspect}")
-    end
-
-    # Asserts that an instance variable is defined for the result of the assertion. Value of instance
-    # variable is expected to not be nil
-    #   setup { User.new(:email => "foo@bar.baz") }
-    #   topic.assigns(:email)
-    #
-    # If a value is provided in addition to the variable name, the actual value of the instance variable
-    # must equal the expected value
-    #   setup { User.new(:email => "foo@bar.baz") }
-    #   topic.assigns(:email, "foo@bar.baz")
-    assertion(:assigns) do |actual, *expectings|
-      variable, expected_value = expectings
-      variable_name            = "@#{variable}"
-      actual_value             = actual.instance_variable_defined?(variable_name) ? actual.instance_variable_get(variable_name) : nil
-      if actual_value.nil?
-        fail("expected @#{variable} to be assigned a value")
-      elsif !expected_value.nil? && expected_value != actual_value
-        fail(%Q[expected @#{variable} to be equal to #{expected_value.inspect}, not #{actual_value.inspect}])
-      else
-        pass
-      end
-    end
-
-    # Asserts that the result of the test equals matches against the proved expression
-    #   asserts("test") { "12345" }.matches(/\d+/)
-    #   should("test") { "12345" }.matches(/\d+/)
-    assertion(:matches) do |actual, expected|
-      expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
-      actual =~ expected ? pass : fail("expected #{expected.inspect} to match #{actual.inspect}")
-    end
-
-    # 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)
-    assertion(:respond_to) do |actual, expected|
-      actual.respond_to?(expected) ? pass : fail("expected method #{expected.inspect} is not defined")
-    end
-
-    # 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"])
-    assertion(:same_elements) do |actual, expected|
-      require 'set'
-      same = (Set.new(expected) == Set.new(actual))
-      same ? pass : fail("expected elements #{expected.inspect} to match #{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)
-    #
-    # 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/)
-    assertion(:raises, expect_exception=true) do |actual_exception, expected_class, expected_message|
-      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
-        pass
-      end
-    end
-
-    # Asserts the result is empty
-    #   asserts("a string") { "" }.empty
-    #   asserts("an array") { [] }.empty
-    #   asserts("a hash") { Hash.new }.empty
-    assertion(:empty) do |actual|
-      actual.length == 0 ? pass : fail("expected #{actual.inspect} to be empty")
-    end
-
-    # Asserts the result has items
-    #   asserts("an array") { [1] }.any
-    #   asserts("a hash") { {:name => 'washington'} }.any
-    assertion(:any) do |actual|
-      actual.any? ? pass : fail("expected #{actual.inspect} to have items")
-    end
-
-    # 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)
-    assertion(:size) do |actual, expected|
-      expected === actual.size ? pass : fail("size of #{actual.inspect} expected to be #{expected} but is #{actual.size}")
-    end
-
-    # Asserts the result contains the expected element
-    #   asserts("a string") { "world" }.includes('o')
-    #   asserts("an array") { [1,2,3] }.includes(2)
-    #   asserts("a range") { (1..15) }.includes(10)
-    assertion(:includes) do |actual, expected|
-      actual.include?(expected) ? pass : fail("expected #{actual.inspect} to include #{expected.inspect}")
-    end
-
-  end # Assertion
-end # Riot