riot_rails 0.0.7 → 0.0.8

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/lib/riot/action_controller/assertion_macros.rb

@@ -1,85 +1,109 @@
-class Riot::Assertion
-  # Asserts that the body of the response equals or matches the expected expression. Expects actual to
-  # be the controller.
-  #
-  #   controller.renders("a bunch of html")
-  #   controller.renders(/bunch of/)
-  assertion(:renders) do |actual, expected|
-    actual_body = actual.response.body
-    if (expected.kind_of?(Regexp) ? (actual_body =~ expected) : (expected == actual_body))
-      pass
-    else
-      verb = expected.kind_of?(Regexp) ? "match" : "equal"
-      fail("expected response body #{actual_body.inspect} to #{verb} #{expected.inspect}")
+module RiotRails
+  module ActionController
+    # Asserts that the body of the response equals or matches the expected expression. Expects actual to
+    # be the controller.
+    #
+    #   controller.renders("a bunch of html")
+    #   controller.renders(/bunch of/)
+    class RendersMacro < Riot::AssertionMacro
+      register :renders
+
+      def evaluate(actual, expected)
+        actual_body = actual.response.body
+        if (expected.kind_of?(Regexp) ? (actual_body =~ expected) : (expected == actual_body))
+          pass
+        else
+          verb = expected.kind_of?(Regexp) ? "match" : "equal"
+          fail("expected response body #{actual_body.inspect} to #{verb} #{expected.inspect}")
+        end
+      end
+    end
+
+    # Asserts that the name you provide is the basename of the rendered template. For instance, if you
+    # expect the rendered template is named "foo_bar.html.haml" and you pass "foo_bar" into
+    # renders_template, the assertion would pass. If instead you pass "foo" into renders_template, the
+    # assertion will fail. Using Rails' assert_template both assertions would pass
+    #
+    #   controlling :things
+    #   controller.renders_template(:index)
+    #   controller.renders_template("index")
+    #   controller.renders_template("index.erb") # fails even if that's the name of the template
+    class RendersTemplateMacro < Riot::AssertionMacro
+      register :renders_template
+      
+      def evaluate(actual, expected_name)
+        name = expected_name.to_s
+        actual_template_path = actual.response.rendered[:template].to_s
+        actual_template_name = File.basename(actual_template_path)
+        if actual_template_name.to_s.match(/^#{name}(\.\w+)*$/)
+          pass("renders template #{name.inspect}")
+        else
+          fail("expected template #{name.inspect}, not #{actual_template_path.inspect}")
+        end
+      end
     end
-  end
 
-  # Asserts that the name you provide is the basename of the rendered template. For instance, if you
-  # expect the rendered template is named "foo_bar.html.haml" and you pass "foo_bar" into
-  # renders_template, the assertion would pass. If instead you pass "foo" into renders_template, the
-  # assertion will fail. Using Rails' assert_template both assertions would pass
-  #
-  #   controlling :things
-  #   controller.renders_template(:index)
-  #   controller.renders_template("index")
-  #   controller.renders_template("index.erb") # fails even if that's the name of the template
-  assertion(:renders_template) do |actual, expected_name|
-    name = expected_name.to_s
-    actual_template_path = actual.response.rendered[:template].to_s
-    actual_template_name = File.basename(actual_template_path)
-    msg = "expected template #{name.inspect}, not #{actual_template_path.inspect}"
-    actual_template_name.to_s.match(/^#{name}(\.\w+)*$/) ? pass : fail(msg)
-  end
+    # Asserts that the HTTP response code equals your expectation. You can use the symbolized form of the
+    # status code or the integer code itself. Not currently supporting status ranges; such as: +:success+,
+    # +:redirect+, etc.
+    #
+    #   controller.response_code(:ok)
+    #   controller.response_code(200)
+    #   
+    #   controller.response_code(:not_found)
+    #   controller.response_code(404)
+    #   
+    #   # A redirect
+    #   controller.response_code(:found)
+    #   controller.response_code(302)
+    #
+    # See +ActionController::StatusCodes+ for the list of available codes.
+    class ResponseCodeMacro < Riot::AssertionMacro
+      register :response_code
 
-  # Asserts that the HTTP response code equals your expectation. You can use the symbolized form of the
-  # status code or the integer code itself. Not currently supporting status ranges; such as: +:success+,
-  # +:redirect+, etc.
-  #
-  #   controller.response_code(:ok)
-  #   controller.response_code(200)
-  #   
-  #   controller.response_code(:not_found)
-  #   controller.response_code(404)
-  #   
-  #   # A redirect
-  #   controller.response_code(:found)
-  #   controller.response_code(302)
-  #
-  # See +ActionController::StatusCodes+ for the list of available codes.
-  assertion(:response_code) do |actual, expected_code|
-    if expected_code.kind_of?(Symbol)
-      expected_code = ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[expected_code]
+      def evaluate(actual, expected_code)
+        if expected_code.kind_of?(Symbol)
+          expected_code = ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[expected_code]
+        end
+        actual_code = actual.response.response_code
+        if expected_code == actual_code
+          pass("returns response code #{expected_code}")
+        else
+          fail("expected response code #{expected_code}, not #{actual_code}")
+        end
+      end
     end
-    actual_code = actual.response.response_code
-    expected_code == actual_code ? pass : fail("expected response code #{expected_code}, not #{actual_code}")
-  end
 
-  # Asserts that the response from an action is a redirect and that the path or URL matches your
-  # expectations. If the response code is not in the 300s, the assertion will fail. If the reponse code
-  # is fine, but the redirect-to path or URL do not exactly match your expectation, the assertion will
-  # fail.
-  #
-  # +redirected_to+ expects you to provide your expected path in a lambda. This is so you can use named
-  # routes, which are - as it turns out - handy. It's also what I would expect to be able to do.
-  #
-  #   controlling :people
-  #   setup do
-  #     post :create, :person { ... }
-  #   end
-  #
-  #   controller.redirected_to { person_path(...) }
-  #
-  # PS: There is a difference between saying +named_route_path+ and +named_route_url+ and Riot Rails will
-  # be very strict (read: annoying) about it :)
-  assertion(:redirected_to) do |actual, expected_redirect|
-    actual_response_code = actual.response.response_code
-    if (300...400).member?(actual_response_code)
-      actual_redirect = actual.url_for(actual.response.redirected_to)
-      msg = "expected to redirect to <#{expected_redirect}>, not <#{actual_redirect}>"
-      expected_redirect == actual_redirect ? pass : fail(msg)
-    else
-      fail("expected response to be a redirect, but was #{actual_response_code}")
+    # Asserts that the response from an action is a redirect and that the path or URL matches your
+    # expectations. If the response code is not in the 300s, the assertion will fail. If the reponse code
+    # is fine, but the redirect-to path or URL do not exactly match your expectation, the assertion will
+    # fail.
+    #
+    # +redirected_to+ expects you to provide your expected path in a lambda. This is so you can use named
+    # routes, which are - as it turns out - handy. It's also what I would expect to be able to do.
+    #
+    #   controlling :people
+    #   setup do
+    #     post :create, :person { ... }
+    #   end
+    #
+    #   controller.redirected_to { person_path(...) }
+    #
+    # PS: There is a difference between saying +named_route_path+ and +named_route_url+ and Riot Rails will
+    # be very strict (read: annoying) about it :)
+    class RedirectedToMacro < Riot::AssertionMacro
+      register :redirected_to
+      def evaluate(actual, expected_redirect)
+        actual_response_code = actual.response.response_code
+        if (300...400).member?(actual_response_code)
+          actual_redirect = actual.url_for(actual.response.redirected_to)
+          msg = "expected to redirect to <#{expected_redirect}>, not <#{actual_redirect}>"
+          expected_redirect == actual_redirect ? pass("redirected to #{expected_redirect}") : fail(msg)
+        else
+          fail("expected response to be a redirect, but was #{actual_response_code}")
+        end
+      end
     end
-  end
 
-end # Riot::Assertion
+  end # ActionController
+end # RiotRails

data/lib/riot/active_record/assertion_macros.rb

@@ -1,102 +1,158 @@
-class Riot::Assertion
+module RiotRails
+  module ActiveRecord
 
-  # An ActiveRecord assertion that expects to fail when a given attribute is validated after a nil value
-  # is provided to it.
-  #
-  #    context "a User" do
-  #      setup { User.new }
-  #      topic.validates_presence_of(:name)
-  #    end
-  assertion(:validates_presence_of) do |actual, attribute|
-    msg = "expected to validate presence of #{attribute.inspect}"
-    error_from_writing_value(actual, attribute, nil) ? pass : fail(msg)
-  end
+    class AssertionMacro < ::Riot::AssertionMacro
+      def error_from_writing_value(model, attribute, value)
+        model.write_attribute(attribute, value)
+        model.valid?
+        model.errors.on(attribute)
+      end
+    end
 
-  # An ActiveRecord assertion that expects to pass with a given value or set of values for a given
-  # attribute.
-  #
-  #    context "a User" do
-  #      setup { User.new }
-  #      topic.allows_values_for :email, "a@b.cd"
-  #      topic.allows_values_for :email, "a@b.cd", "e@f.gh"
-  #    end
-  assertion(:allows_values_for) do |actual, attribute, *values|
-    bad_values = []
-    values.each do |value|
-      bad_values << value if error_from_writing_value(actual, attribute, value)
+    # An ActiveRecord assertion that expects to fail when a given attribute is validated after a nil value
+    # is provided to it.
+    #
+    #    context "a User" do
+    #      setup { User.new }
+    #      topic.validates_presence_of(:name)
+    #    end
+    class ValidatesPresenceOfMacro < AssertionMacro
+      register :validates_presence_of
+
+      def evaluate(actual, attribute)
+        if error_from_writing_value(actual, attribute, nil)
+          pass("validates presence of #{attribute.inspect}")
+        else
+          fail("expected to validate presence of #{attribute.inspect}")
+        end
+      end
     end
-    msg = "expected #{attribute.inspect} to allow value(s) #{bad_values.inspect}"
-    bad_values.empty? ? pass : fail(msg)
-  end
 
-  # An ActiveRecord assertion that expects to fail with a given value or set of values for a given
-  # attribute.
-  #
-  #    context "a User" do
-  #      setup { User.new }
-  #      topic.does_not_allow_values_for :email, "a"
-  #      topic.does_not_allow_values_for :email, "a@b", "e f@g.h"
-  #    end
-  assertion(:does_not_allow_values_for) do |actual, attribute, *values|
-    good_values = []
-    values.each do |value|
-      good_values << value unless error_from_writing_value(actual, attribute, value)
+    # An ActiveRecord assertion that expects to pass with a given value or set of values for a given
+    # attribute.
+    #
+    #    context "a User" do
+    #      setup { User.new }
+    #      topic.allows_values_for :email, "a@b.cd"
+    #      topic.allows_values_for :email, "a@b.cd", "e@f.gh"
+    #    end
+    class AllowsValuesForMacro < AssertionMacro
+      register :allows_values_for
+
+      def evaluate(actual, attribute, *values)
+        bad_values = []
+        values.each do |value|
+          bad_values << value if error_from_writing_value(actual, attribute, value)
+        end
+        failure_msg = "expected %s to allow value(s) %s"
+        bad_values.empty? ? pass : fail(failure_msg % [attribute.inspect, bad_values.inspect])
+      end
     end
-    msg = "expected #{attribute.inspect} not to allow value(s) #{good_values.inspect}"
-    good_values.empty? ? pass : fail(msg)
-  end
 
-  # An ActiveRecord assertion that expects to fail with an attribute is not valid for record because the
-  # value of the attribute is not unique. Requires the topic of the context to be a created record; one
-  # that returns false for a call to +new_record?+.
-  #
-  #    context "a User" do
-  #      setup { User.create(:email => "a@b.cde", ... ) }
-  #      topic.validates_uniqueness_of :email
-  #    end
-  assertion(:validates_uniqueness_of) do |actual, attribute|
-    actual_record = actual
-    if actual_record.new_record?
-      fail("topic is not a new record when testing uniqueness of #{attribute}")
-    else
-      copied_model = actual_record.class.new
-      actual_record.attributes.each do |dup_attribute, dup_value|
-        copied_model.write_attribute(dup_attribute, dup_value)
+    # An ActiveRecord assertion that expects to fail with a given value or set of values for a given
+    # attribute.
+    #
+    #    context "a User" do
+    #      setup { User.new }
+    #      topic.does_not_allow_values_for :email, "a"
+    #      topic.does_not_allow_values_for :email, "a@b", "e f@g.h"
+    #    end
+    class DoesNotAllowValuesForMacro < AssertionMacro
+      register :does_not_allow_values_for
+      def evaluate(actual, attribute, *values)
+        good_values = []
+        values.each do |value|
+          good_values << value unless error_from_writing_value(actual, attribute, value)
+        end
+        failure_msg = "expected %s not to allow value(s) %s"
+        good_values.empty? ? pass : fail(failure_msg % [attribute.inspect, good_values.inspect])
       end
-      copied_value = actual_record.read_attribute(attribute)
-      msg = "expected to fail because #{attribute.inspect} is not unique"
-      error_from_writing_value(copied_model, attribute, copied_value) ? pass : fail(msg)
     end
-  end
 
-  # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as +has_many+
-  # association. Will fail if an association is not defined for the attribute and if the association is
-  # not +has_many.jekyll
-  #
-  #   context "a Room" do
-  #     setup { Room.new }
-  #
-  #     topic.has_many(:doors)
-  #     topic.has_many(:floors) # should probably fail given our current universe :)
-  #   end
-  assertion(:has_many) do |actual, attribute|
-    reflection = actual.class.reflect_on_association(attribute)
-    static_msg = "expected #{attribute.inspect} to be a has_many association, but was "
-    if reflection.nil?
-      fail(static_msg + "not")
-    elsif "has_many" != reflection.macro.to_s
-      fail(static_msg + "a #{reflection.macro} instead")
-    else
-      pass
+    # An ActiveRecord assertion that expects to fail with invalid value for an attribute. Optionally, the 
+    # error message can be provided as the exact string or as regular expression.
+    #
+    #    context "a User" do
+    #      setup { User.new }
+    #      topic.is_invalid_when :email, "fake", "is invalid"
+    #      topic.is_invalid_when :email, "another fake", /invalid/
+    #    end
+    class IsInvalidWhenMacro < AssertionMacro
+      register :is_invalid_when
+
+      def evaluate(actual, attribute, value, expected_error=nil)
+        actual_errors = Array(error_from_writing_value(actual, attribute, value))
+        if actual_errors.empty?
+          fail("expected #{attribute.inspect} to be invalid when value is #{value.inspect}")
+        elsif expected_error && !has_error_message?(expected_error, actual_errors)
+          message = "expected %s to be invalid with error message %s"
+          fail(message % [attribute.inspect, expected_error.inspect])
+        else
+          pass("attribute #{attribute.inspect} is invalid")
+        end
+      end
+    private
+      def has_error_message?(expected, errors)
+        return true unless expected
+        expected.kind_of?(Regexp) ? errors.any? {|e| e =~ expected } : errors.any? {|e| e == expected }
+      end
     end
-  end
 
-protected
+    # An ActiveRecord assertion that expects to fail with an attribute is not valid for record because the
+    # value of the attribute is not unique. Requires the topic of the context to be a created record; one
+    # that returns false for a call to +new_record?+.
+    #
+    #    context "a User" do
+    #      setup { User.create(:email => "a@b.cde", ... ) }
+    #      topic.validates_uniqueness_of :email
+    #    end
+    class ValidatesUniquenessOfMacro < AssertionMacro
+      register :validates_uniqueness_of
+      
+      def evaluate(actual, attribute)
+        actual_record = actual
+        if actual_record.new_record?
+          fail("topic is not a new record when testing uniqueness of #{attribute.inspect}")
+        else
+          copied_model = actual_record.class.new
+          actual_record.attributes.each do |dup_attribute, dup_value|
+            copied_model.write_attribute(dup_attribute, dup_value)
+          end
+          copied_value = actual_record.read_attribute(attribute)
+          if error_from_writing_value(copied_model, attribute, copied_value)
+            pass("#{attribute.inspect} is unique")
+          else
+            fail("expected to fail because #{attribute.inspect} is not unique")
+          end
+        end
+      end
+    end
 
-  def self.error_from_writing_value(model, attribute, value)
-    model.write_attribute(attribute, value)
-    model.valid?
-    model.errors.on(attribute)
-  end
+    # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as +has_many+
+    # association. Will fail if an association is not defined for the attribute and if the association is
+    # not +has_many.jekyll
+    #
+    #   context "a Room" do
+    #     setup { Room.new }
+    #
+    #     topic.has_many(:doors)
+    #     topic.has_many(:floors) # should probably fail given our current universe :)
+    #   end
+    class HasManyMacro < AssertionMacro
+      register :has_many
+      
+      def evaluate(actual, attribute)
+        reflection = actual.class.reflect_on_association(attribute)
+        static_msg = "expected #{attribute.inspect} to be a has_many association, but was "
+        if reflection.nil?
+          fail(static_msg + "not")
+        elsif "has_many" != reflection.macro.to_s
+          fail(static_msg + "a #{reflection.macro} instead")
+        else
+          pass("has many #{attribute.inspect}")
+        end
+      end
+    end
 
-end # Riot::Assertion
+  end # ActiveRecord
+end # RiotRails

data/riot_rails.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot_rails}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-11-27}
+  s.date = %q{2009-12-29}
   s.description = %q{Riot specific test support for Rails apps. Protest the slow app.}
   s.email = %q{gus@gusg.us}
   s.extra_rdoc_files = [

data/test/action_controller/controller_context_test.rb

@@ -19,6 +19,6 @@ context "A controller test" do
 
   asserts("an unknown action call") do
     get :burberry
-  end.raises(ActionController::UnknownAction, "No action responded to burberry")
+  end.raises(::ActionController::UnknownAction, "No action responded to burberry")
 
 end # a controller test

data/test/action_controller/redirected_to_test.rb

@@ -14,14 +14,14 @@ context "Asserting the redirect of an action" do
   setup do
     @situation = Riot::Situation.new
     context = Riot::Context.new("redirected to") {}
-    context.controlling(:redirected_to).last.run(@situation)
+    context.controlling(:redirected_to).run(@situation)
     context
   end
 
   context "when doing an actual redirect" do
     setup_for_assertion_test { get :index }
 
-    assertion_test_passes("when expected url matches actual redirect url") do
+    assertion_test_passes("when expected url matches actual redirect url", "redirected to /gremlins/new") do
       topic.asserts_controller.redirected_to { new_gremlin_path }
     end
 

data/test/action_controller/renders_template_test.rb

@@ -9,14 +9,14 @@ context "Asserting the rendered template for an action" do
   setup do
     @situation = Riot::Situation.new
     context = Riot::Context.new("rendered_template") {}
-    context.controlling(:rendered_templates).last.run(@situation)
+    context.controlling(:rendered_templates).run(@situation)
     context
   end
 
   context "that rendered a template" do
     setup_for_assertion_test { get :foo_bar }
 
-    assertion_test_passes("when rendered template name matches expectation") do
+    assertion_test_passes("when rendered template name matches expectation", %Q{renders template "foo_bar"}) do
       topic.asserts_controller.renders_template('foo_bar')
     end
 
@@ -29,11 +29,11 @@ context "Asserting the rendered template for an action" do
   context "that did not render a template, as was expected" do
     setup_for_assertion_test { get :text_me }
 
-    assertion_test_passes("when providing nil as expectation") do
+    assertion_test_passes("when providing nil as expectation", %Q{renders template ""}) do
       topic.asserts_controller.renders_template(nil)
     end
 
-    assertion_test_passes("when providing empty string as expectation") do
+    assertion_test_passes("when providing empty string as expectation", %Q{renders template ""}) do
       topic.asserts_controller.renders_template("")
     end
   end # that did not render a template, as was expected

data/test/action_controller/renders_test.rb

@@ -8,8 +8,8 @@ context "Asserting the body of a response" do
   setup do
     @situation = Riot::Situation.new
     context = Riot::Context.new("renders") {}
-    context.controlling(:renders).last.run(@situation)
-    context.setup { get :index }.last.run(@situation)
+    context.controlling(:renders).run(@situation)
+    context.setup { get :index }.run(@situation)
     context
   end
 

data/test/action_controller/response_status_test.rb

@@ -10,15 +10,20 @@ context "Asserting the response status for an action" do
   setup do
     @situation = Riot::Situation.new
     context = Riot::Context.new("response status") {}
-    context.controlling(:response_codes).last.run(@situation)
+    context.controlling(:response_codes).run(@situation)
     context
   end
 
   context "returning OK" do
     setup_for_assertion_test { get :ok_go }
 
-    assertion_test_passes("when asked if :ok") { topic.asserts_controller.response_code(:ok) }
-    assertion_test_passes("when asked if 200") { topic.asserts_controller.response_code(200) }
+    assertion_test_passes("when asked if :ok", "returns response code 200") do
+      topic.asserts_controller.response_code(:ok)
+    end
+
+    assertion_test_passes("when asked if 200", "returns response code 200") do
+      topic.asserts_controller.response_code(200)
+    end
 
     assertion_test_fails("when CONTINUE returned instead", %Q{expected response code 100, not 200}) do
       topic.asserts_controller.response_code(100)
@@ -27,14 +32,26 @@ context "Asserting the response status for an action" do
 
   context "that is redirecting" do
     setup_for_assertion_test { get :fffound }
-    assertion_test_passes("when asked if :ok") { topic.asserts_controller.response_code(:found) }
-    assertion_test_passes("when asked if 200") { topic.asserts_controller.response_code(302) }
+
+    assertion_test_passes("when asked if :found", "returns response code 302") do
+      topic.asserts_controller.response_code(:found)
+    end
+
+    assertion_test_passes("when asked if 302", "returns response code 302") do
+      topic.asserts_controller.response_code(302)
+    end
   end # that is redirecting
 
   context "that has explicit status" do
     setup_for_assertion_test { get :make_me }
-    assertion_test_passes("when asked if :created") { topic.asserts_controller.response_code(:created) }
-    assertion_test_passes("when asked if 202") {topic.asserts_controller.response_code(201) }
+
+    assertion_test_passes("when asked if :created", "returns response code 201") do
+      topic.asserts_controller.response_code(:created)
+    end
+
+    assertion_test_passes("when asked if 201", "returns response code 201") do
+      topic.asserts_controller.response_code(201)
+    end
   end # that has explicit status
 
 end # Asserting the status of a response

data/test/active_record/allowing_values_test.rb

@@ -6,11 +6,11 @@ context "The allow_values_for assertion macro" do
 
   should("pass when attribute allows a value") do
     topic.allows_values_for(:email, "a@b.cd").run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, nil])
 
   should("pass when attribute allows multiple values") do
     topic.allows_values_for(:email, "a@b.cd", "e@f.gh").run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, nil])
 
   should("fail when attribute is provided a valid and an invalid value") do
     topic.allows_values_for(:email, "a", "e@f.gh").run(Riot::Situation.new)
@@ -23,13 +23,42 @@ context "The does_not_allow_values_for assertion macro" do
 
   should("pass when attribute does not allow a value") do
     topic.does_not_allow_values_for(:email, "a").run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, nil])
 
   should("pass when attribute does not allow multiple values") do
     topic.does_not_allow_values_for(:email, "a", "e").run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, nil])
 
   should("fail when attribute is provided a valid and an invalid value") do
     topic.does_not_allow_values_for(:email, "a", "e@f.gh").run(Riot::Situation.new)
   end.equals([:fail, %Q{expected :email not to allow value(s) ["e@f.gh"]}])
 end # The does_not_allow_values_for assertion macro
+
+context "The is_invalid_when assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when attribute is invalid") do
+    topic.is_invalid_when(:email, "fake").run(Riot::Situation.new)
+  end.equals([:pass, %Q{attribute :email is invalid}])
+
+  should("pass when error message equals one in its list of errors") do
+    topic.is_invalid_when(:email, "fake", "is invalid").run(Riot::Situation.new)
+  end.equals([:pass, %Q{attribute :email is invalid}])
+
+  should("pass when error message matches one in its list of errors") do
+    topic.is_invalid_when(:email, "fake", /invalid/).run(Riot::Situation.new)
+  end.equals([:pass, %Q{attribute :email is invalid}])
+
+  should("fail when attribute is valid") do
+    topic.is_invalid_when(:email, "a@b.cd", "is invalid").run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to be invalid when value is "a@b.cd"}])
+
+  should("fail when exact error message not found") do
+    topic.is_invalid_when(:email, "fake", "can't be blank").run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to be invalid with error message "can't be blank"}])
+
+  should("fail when error message not matched to returned errors") do
+    topic.is_invalid_when(:email, "fake", /blank/).run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to be invalid with error message /blank/}])
+end # The is_invalid_when assertion macro

data/test/active_record/has_many_test.rb

@@ -6,7 +6,7 @@ context "The has_many assertion macro" do
 
   should("pass when record has a has_many association defined for attribute") do
     topic.has_many(:doors).run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, "has many :doors"])
 
   should("fail when record does not have a has_many association defined for attribute") do
     topic.has_many(:windows).run(Riot::Situation.new)

data/test/active_record/validates_presence_of_test.rb

@@ -6,7 +6,7 @@ context "The validates_presence_of assertion macro" do
 
   should("pass when attribute requires presence") do
     topic.validates_presence_of(:location).run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, "validates presence of :location"])
 
   should("fail when attribute does not require presence") do
     topic.validates_presence_of(:contents).run(Riot::Situation.new)

data/test/active_record/validates_uniqueness_of_test.rb

@@ -7,17 +7,17 @@ context "The validates_uniqueness_of assertion macro" do
     topic.asserts("room") do
       Room.new(:email => "foo@bar.baz", :foo => "what")
     end.validates_uniqueness_of(:email).run(Riot::Situation.new)
-  end.equals([:fail, "topic is not a new record when testing uniqueness of email"])
+  end.equals([:fail, "topic is not a new record when testing uniqueness of :email"])
 
   should("pass with a persisted record") do
     topic.asserts("room") do
       Room.create_with_good_data(:email => "foo@bar.baz")
     end.validates_uniqueness_of(:email).run(Riot::Situation.new)
-  end.equals([:pass])
+  end.equals([:pass, ":email is unique"])
 
   should("fail with a persisted record but not validating uniqueness") do
     topic.asserts("room") do
-      Room.new(:email => "goo@car.caz")
+      Room.create_with_good_data(:email => "goo@car.caz")
     end.validates_uniqueness_of(:foo).run(Riot::Situation.new)
-  end.equals([:fail, "topic is not a new record when testing uniqueness of foo"])
+  end.equals([:fail, "expected to fail because :foo is not unique"])
 end # The validates_uniqueness_of assertion macro

data/test/teststrap.rb

@@ -90,15 +90,15 @@ module RiotRails
 
     def setup_for_assertion_test(&block)
       setup do
-        topic.setup(&block).last.run(@situation)
+        topic.setup(&block).run(@situation)
         topic
       end
     end
     
-    def assertion_test_passes(description, &block)
+    def assertion_test_passes(description, success_message=nil, &block)
       should("pass #{description}") do
         instance_eval(&block).run(@situation)
-      end.equals([:pass])
+      end.equals([:pass, success_message])
     end
 
     def assertion_test_fails(description, failure_message, &block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riot_rails
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-27 00:00:00 -06:00
+date: 2009-12-29 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency