riot_rails 0.0.8 → 0.0.9.pre

data/riot_rails.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot_rails}
-  s.version = "0.0.8"
+  s.version = "0.0.9.pre"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-12-29}
+  s.date = %q{2010-02-20}
   s.description = %q{Riot specific test support for Rails apps. Protest the slow app.}
   s.email = %q{gus@gusg.us}
   s.extra_rdoc_files = [
@@ -17,17 +17,24 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     "CHANGELOG",
      "MIT-LICENSE",
      "README.markdown",
      "Rakefile",
      "VERSION",
      "lib/riot/action_controller.rb",
      "lib/riot/action_controller/assertion_macros.rb",
+     "lib/riot/action_controller/context_helper.rb",
      "lib/riot/action_controller/context_macros.rb",
      "lib/riot/action_controller/situation_macros.rb",
      "lib/riot/active_record.rb",
      "lib/riot/active_record/assertion_macros.rb",
+     "lib/riot/active_record/context_helper.rb",
+     "lib/riot/active_record/database_macros.rb",
+     "lib/riot/active_record/reflection_macros.rb",
+     "lib/riot/active_record/validation_macros.rb",
      "lib/riot/rails.rb",
+     "lib/riot/rails_context.rb",
      "rails/init.rb",
      "riot_rails.gemspec",
      "test/action_controller/controller_context_test.rb",
@@ -36,10 +43,18 @@ Gem::Specification.new do |s|
      "test/action_controller/renders_test.rb",
      "test/action_controller/response_status_test.rb",
      "test/active_record/allowing_values_test.rb",
+     "test/active_record/attribute_is_invalid_test.rb",
+     "test/active_record/belongs_to_test.rb",
+     "test/active_record/has_and_belongs_to_many_test.rb",
+     "test/active_record/has_database_index_on_test.rb",
      "test/active_record/has_many_test.rb",
+     "test/active_record/has_one_test.rb",
+     "test/active_record/validates_length_of_test.rb",
      "test/active_record/validates_presence_of_test.rb",
      "test/active_record/validates_uniqueness_of_test.rb",
+     "test/rails_context_test.rb",
      "test/rails_root/app/views/rendered_templates/foo_bar.html.erb",
+     "test/rails_root/config/environment.rb",
      "test/rails_root/config/routes.rb",
      "test/rails_root/db/schema.rb",
      "test/teststrap.rb"
@@ -56,9 +71,17 @@ Gem::Specification.new do |s|
      "test/action_controller/renders_test.rb",
      "test/action_controller/response_status_test.rb",
      "test/active_record/allowing_values_test.rb",
+     "test/active_record/attribute_is_invalid_test.rb",
+     "test/active_record/belongs_to_test.rb",
+     "test/active_record/has_and_belongs_to_many_test.rb",
+     "test/active_record/has_database_index_on_test.rb",
      "test/active_record/has_many_test.rb",
+     "test/active_record/has_one_test.rb",
+     "test/active_record/validates_length_of_test.rb",
      "test/active_record/validates_presence_of_test.rb",
      "test/active_record/validates_uniqueness_of_test.rb",
+     "test/rails_context_test.rb",
+     "test/rails_root/config/environment.rb",
      "test/rails_root/config/routes.rb",
      "test/rails_root/db/schema.rb",
      "test/teststrap.rb"
@@ -69,15 +92,18 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<riot>, [">= 0.10.2"])
-      s.add_development_dependency(%q<activerecord>, [">= 2.3.2"])
+      s.add_runtime_dependency(%q<riot>, [">= 0.10.13.pre"])
+      s.add_development_dependency(%q<activerecord>, [">= 3.0.0.pre"])
+      s.add_development_dependency(%q<actionpack>, [">= 3.0.0.pre"])
     else
-      s.add_dependency(%q<riot>, [">= 0.10.2"])
-      s.add_dependency(%q<activerecord>, [">= 2.3.2"])
+      s.add_dependency(%q<riot>, [">= 0.10.13.pre"])
+      s.add_dependency(%q<activerecord>, [">= 3.0.0.pre"])
+      s.add_dependency(%q<actionpack>, [">= 3.0.0.pre"])
     end
   else
-    s.add_dependency(%q<riot>, [">= 0.10.2"])
-    s.add_dependency(%q<activerecord>, [">= 2.3.2"])
+    s.add_dependency(%q<riot>, [">= 0.10.13.pre"])
+    s.add_dependency(%q<activerecord>, [">= 3.0.0.pre"])
+    s.add_dependency(%q<actionpack>, [">= 3.0.0.pre"])
   end
 end
 

data/test/action_controller/controller_context_test.rb

@@ -1,24 +1,54 @@
 require 'teststrap'
 
 class FoosController < ActionController::Base
+  def index
+    @thing = "hoo ray"
+    render :text => ''
+  end
 end
 
-context "A controller test" do
+rails_context "A controller test" do
   controlling :foos
 
   asserts_controller.kind_of(FoosController)
+  asserts_topic.kind_of(FoosController)
 
-  asserts("request is accessible") { request }.kind_of(::ActionController::TestRequest)
-  asserts("response is accessible") { response }.kind_of(::ActionController::TestResponse)
+  asserts("request is accessible") { request }.kind_of(::ActionDispatch::TestRequest)
+  asserts("response is accessible") { response }.kind_of(::ActionDispatch::TestResponse)
   asserts("params is accessible") { controller.params }.equals({})
 
-  asserts("http method shortcut for get") { self }.respond_to(:get)
-  asserts("http method shortcut for post") { self }.respond_to(:post)
-  asserts("http method shortcut for put") { self }.respond_to(:put)
-  asserts("http method shortcut for delete") { self }.respond_to(:delete)
+  asserts("http method shortcut for get") { self }.responds_to(:get)
+  asserts("http method shortcut for post") { self }.responds_to(:post)
+  asserts("http method shortcut for put") { self }.responds_to(:put)
+  asserts("http method shortcut for delete") { self }.responds_to(:delete)
+  asserts("http method shortcut for xml_http_request") { self }.responds_to(:xml_http_request)
+  asserts("http method shortcut for xhr") { self }.responds_to(:xhr)
 
   asserts("an unknown action call") do
     get :burberry
-  end.raises(::ActionController::UnknownAction, "No action responded to burberry")
+  end.raises(::ActionController::UnknownAction, "The action 'burberry' could not be found")
+end # A controller test
 
-end # a controller test
+rails_context "A controller test using class as argument" do
+  controlling FoosController
+
+  asserts_controller.kind_of(FoosController)
+end # A controller test using class as argument
+
+rails_context FoosController do
+  hookup do
+    @actual_class_name = topic.class.name
+    get :index
+  end
+
+  asserts("actual class name") { @actual_class_name }.equals("FoosController")
+
+  asserts_assigned(:thing).equals("hoo ray")
+  asserts_assigned(:that).nil
+
+  asserts_response.kind_of(::ActionDispatch::TestResponse)
+  asserts_response(:response_code).equals(200)
+
+  asserts_request.kind_of(::ActionDispatch::TestRequest)
+  asserts_request(:cookies).kind_of(Hash)
+end # A controller test with a hookup using the controller

data/test/action_controller/redirected_to_test.rb

@@ -13,29 +13,24 @@ end
 context "Asserting the redirect of an action" do
   setup do
     @situation = Riot::Situation.new
-    context = Riot::Context.new("redirected to") {}
+    context = RiotRails::RailsContext.new("redirected to") {}
     context.controlling(:redirected_to).run(@situation)
     context
   end
 
   context "when doing an actual redirect" do
-    setup_for_assertion_test { get :index }
+    hookup_for_assertion_test { get :index }
 
-    assertion_test_passes("when expected url matches actual redirect url", "redirected to /gremlins/new") do
-      topic.asserts_controller.redirected_to { new_gremlin_path }
-    end
-
-    assertion_test_fails("when expected url does not exactly match actual redirect url",
-    "expected to redirect to <http://test.host/gremlins/new>, not </gremlins/new>") do
-      topic.asserts_controller.redirected_to { new_gremlin_url }
+    assertion_test_passes("when expected url matches actual redirect url", "redirected to http://test.host/gremlins/new") do
+      topic.asserts(:response).redirected_to { new_gremlin_url }
     end
   end # when doing an actual redirect
 
   context "when not actually doing a redirect" do
-    setup_for_assertion_test { get :show }
+    hookup_for_assertion_test { get :show }
     assertion_test_fails("with message about expecting a redirect",
     "expected response to be a redirect, but was 200") do
-      topic.asserts_controller.redirected_to { new_gremlin_path }
+      topic.asserts(:response).redirected_to { new_gremlin_path }
     end
   end # when not actually doing a redirect
 end # Asserting the redirect of an action

data/test/action_controller/renders_template_test.rb

@@ -8,26 +8,26 @@ end
 context "Asserting the rendered template for an action" do
   setup do
     @situation = Riot::Situation.new
-    context = Riot::Context.new("rendered_template") {}
+    context = RiotRails::RailsContext.new("rendered_template") {}
     context.controlling(:rendered_templates).run(@situation)
     context
   end
 
   context "that rendered a template" do
-    setup_for_assertion_test { get :foo_bar }
+    hookup_for_assertion_test { get :foo_bar }
 
     assertion_test_passes("when rendered template name matches expectation", %Q{renders template "foo_bar"}) do
       topic.asserts_controller.renders_template('foo_bar')
     end
 
     assertion_test_fails("when rendered template does not match expectation",
-    %Q{expected template "bar_foo", not "rendered_templates/foo_bar.html.erb"}) do
+    %Q{expected template "bar_foo", not "app/views/rendered_templates/foo_bar.html.erb"}) do
       topic.asserts_controller.renders_template('bar_foo')
     end
   end # that rendered a template
 
   context "that did not render a template, as was expected" do
-    setup_for_assertion_test { get :text_me }
+    hookup_for_assertion_test { get :text_me }
 
     assertion_test_passes("when providing nil as expectation", %Q{renders template ""}) do
       topic.asserts_controller.renders_template(nil)
@@ -39,17 +39,17 @@ context "Asserting the rendered template for an action" do
   end # that did not render a template, as was expected
 
   context "that did not render a template but expected one" do
-    setup_for_assertion_test { get :text_me }
+    hookup_for_assertion_test { get :text_me }
     assertion_test_fails("with message", %Q{expected template "text_me", not ""}) do
       topic.asserts_controller.renders_template('text_me')
     end
   end # that did not render a template but expected one
 
   context "that rendered a template with a partial match on template name" do
-    setup_for_assertion_test { get :foo_bar }
+    hookup_for_assertion_test { get :foo_bar }
 
     assertion_test_fails("with message",
-    %Q{expected template "foo", not "rendered_templates/foo_bar.html.erb"}) do
+    %Q{expected template "foo", not "app/views/rendered_templates/foo_bar.html.erb"}) do
       topic.asserts_controller.renders_template('foo')
     end
   end # that rendered a template with a partial match on template name

data/test/action_controller/renders_test.rb

@@ -7,24 +7,24 @@ end
 context "Asserting the body of a response" do
   setup do
     @situation = Riot::Situation.new
-    context = Riot::Context.new("renders") {}
+    context = RiotRails::RailsContext.new("renders") {}
     context.controlling(:renders).run(@situation)
-    context.setup { get :index }.run(@situation)
+    context.hookup { get :index }.run(@situation)
     context
   end
 
-  assertion_test_passes("when body equals expected") { topic.asserts_controller.renders("Yo mama") }
+  assertion_test_passes("when body equals expected") { topic.asserts(:response).renders("Yo mama") }
 
   assertion_test_fails("when rendered action body does not equal expected",
   %Q{expected response body "Yo mama" to equal "Yo"}) do
-    topic.asserts_controller.renders("Yo")
+    topic.asserts(:response).renders("Yo")
   end
 
-  assertion_test_passes("when body matches expected") { topic.asserts_controller.renders(/mama/) }
+  assertion_test_passes("when body matches expected") { topic.asserts(:response).renders(/mama/) }
 
   assertion_test_fails("when rendered action body does not match expected",
   %Q{expected response body "Yo mama" to match /obama/}) do
-    topic.asserts_controller.renders(/obama/)
+    topic.asserts(:response).renders(/obama/)
   end
 
 end # Asserting the body of a response

data/test/action_controller/response_status_test.rb

@@ -9,48 +9,48 @@ end
 context "Asserting the response status for an action" do
   setup do
     @situation = Riot::Situation.new
-    context = Riot::Context.new("response status") {}
+    context = RiotRails::RailsContext.new("response status") {}
     context.controlling(:response_codes).run(@situation)
     context
   end
 
   context "returning OK" do
-    setup_for_assertion_test { get :ok_go }
+    hookup_for_assertion_test { get :ok_go }
 
     assertion_test_passes("when asked if :ok", "returns response code 200") do
-      topic.asserts_controller.response_code(:ok)
+      topic.asserts(:response).code(:ok)
     end
 
     assertion_test_passes("when asked if 200", "returns response code 200") do
-      topic.asserts_controller.response_code(200)
+      topic.asserts(: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)
+      topic.asserts(:response).code(100)
     end
   end # returning OK
 
   context "that is redirecting" do
-    setup_for_assertion_test { get :fffound }
+    hookup_for_assertion_test { get :fffound }
 
     assertion_test_passes("when asked if :found", "returns response code 302") do
-      topic.asserts_controller.response_code(:found)
+      topic.asserts(:response).code(:found)
     end
 
     assertion_test_passes("when asked if 302", "returns response code 302") do
-      topic.asserts_controller.response_code(302)
+      topic.asserts(:response).code(302)
     end
   end # that is redirecting
 
   context "that has explicit status" do
-    setup_for_assertion_test { get :make_me }
+    hookup_for_assertion_test { get :make_me }
 
     assertion_test_passes("when asked if :created", "returns response code 201") do
-      topic.asserts_controller.response_code(:created)
+      topic.asserts(:response).code(:created)
     end
 
     assertion_test_passes("when asked if 201", "returns response code 201") do
-      topic.asserts_controller.response_code(201)
+      topic.asserts(:response).code(201)
     end
   end # that has explicit status
 

data/test/active_record/allowing_values_test.rb

@@ -6,15 +6,15 @@ 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, nil])
+  end.equals([:pass, ""])
 
   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, nil])
+  end.equals([:pass, ""])
 
   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)
-  end.equals([:fail, %Q{expected :email to allow value(s) ["a"]}])
+  end.equals([:fail, %Q{expected :email to allow values ["a"]}, blah, blah])
 end # The allow_values_for assertion macro
 
 context "The does_not_allow_values_for assertion macro" do
@@ -23,15 +23,15 @@ 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, nil])
+  end.equals([:pass, ""])
 
   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, nil])
+  end.equals([:pass, ""])
 
   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.equals([:fail, %Q{expected :email not to allow values ["e@f.gh"]}, blah, blah])
 end # The does_not_allow_values_for assertion macro
 
 context "The is_invalid_when assertion macro" do
@@ -52,13 +52,13 @@ context "The is_invalid_when assertion macro" do
 
   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"}])
+  end.equals([:fail, %Q{expected :email to be invalid when value is "a@b.cd"}, blah, blah])
 
   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"}])
+  end.equals([:fail, %Q{expected :email to be invalid with error message "can't be blank"}, blah, blah])
 
   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.equals([:fail, %Q{expected :email to be invalid with error message /blank/}, blah, blah])
 end # The is_invalid_when assertion macro

data/test/active_record/attribute_is_invalid_test.rb

@@ -0,0 +1,20 @@
+require 'teststrap'
+
+context "The attribute_is_invalid macro" do
+  setup_test_context
+
+  should("fail when attribute is not invalid") do
+    assertion = topic.asserts("room") { Room.new(:location => "barn burner") }
+    assertion.attribute_is_invalid(:location, "not yet").run(Riot::Situation.new)
+  end.equals([:fail, ":location expected to be invalid", blah, blah])
+
+  should("fail when attribute is invalid, but the message could not be found") do
+    assertion = topic.asserts("room") { Room.new }
+    assertion.attribute_is_invalid(:location, "child please").run(Riot::Situation.new)
+  end.equals([:fail, %Q{:location is invalid, but "child please" is not a valid error message}, blah, blah])
+
+  should("pass when attribute is invalid and error message is found") do
+    assertion = topic.asserts("room") { Room.new }
+    assertion.attribute_is_invalid(:location, "can't be blank").run(Riot::Situation.new)
+  end.equals([:pass, %Q{:location is invalid}])
+end # The attribute_is_invalid macro

data/test/active_record/belongs_to_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The belongs_to assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a belongs_to association defined for attribute") do
+    topic.belongs_to(:house).run(Riot::Situation.new)
+  end.equals([:pass, ":house is a belongs_to association"])
+
+  should("fail when record does not have a belongs_to association defined for attribute") do
+    topic.belongs_to(:someone_else).run(Riot::Situation.new)
+  end.equals([:fail, ":someone_else is not a belongs_to association", blah, blah])
+
+  should("fail when attribute is not a belongs_to, but is a has_one association") do
+    topic.belongs_to(:floor).run(Riot::Situation.new)
+  end.equals([:fail, ":floor is not a belongs_to association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.belongs_to(:owner, :class_name => "Person").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected belongs_to :owner with {:class_name=>"Person"}], blah, blah])
+end # The has_many assertion macro

data/test/active_record/has_and_belongs_to_many_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The has_and_belongs_to_many assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a has_and_belongs_to_many association defined for attribute") do
+    topic.has_and_belongs_to_many(:walls).run(Riot::Situation.new)
+  end.equals([:pass, ":walls is a has_and_belongs_to_many association"])
+
+  should("fail when record does not have a has_and_belongs_to_many association defined for attribute") do
+    topic.has_and_belongs_to_many(:windows).run(Riot::Situation.new)
+  end.equals([:fail, ":windows is not a has_and_belongs_to_many association", blah, blah])
+
+  should("fail when attribute is not a has_and_belongs_to_many, but is a has_many association") do
+    topic.has_and_belongs_to_many(:doors).run(Riot::Situation.new)
+  end.equals([:fail, ":doors is not a has_and_belongs_to_many association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.has_and_belongs_to_many(:walls, :join_table => "blueprints").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected has_and_belongs_to_many :walls with {:join_table=>"blueprints"}], blah, blah])
+end # The has_and_belongs_to_many assertion macro

data/test/active_record/has_database_index_on_test.rb

@@ -0,0 +1,73 @@
+require 'teststrap'
+require 'ostruct'
+
+context "The has_database_index_on macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  hookup do
+    MockConnection = Class.new do
+      def initialize(index_lookup) @index_lookup = index_lookup; end
+      def indexes(table) @index_lookup[table]; end
+    end
+
+    def build_assertion(table, columns, unique=false)
+      database_connection = MockConnection.new({table => [ define_index(table, columns, unique) ]})
+      # I'll inject your dependency! ;)
+      RiotRails::ActiveRecord::HasDatabaseIndexOnMacro.new(database_connection)
+    end
+
+    def define_index(table, columns, unique)
+      ActiveRecord::ConnectionAdapters::IndexDefinition.new(table, columns.join(','), unique, columns)
+    end
+  end
+
+  should("fail when no index for column") do
+    topic.has_database_index_on(:foo).run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected index on [:foo]}, blah, blah])
+
+  should("fail when no index for column set") do
+    topic.has_database_index_on(:foo, :bar).run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected index on [:foo, :bar]}, blah, blah])
+
+  should("fail when index found for column, but it's not unique") do
+    build_assertion("rooms", ["foo"], false).
+      evaluate(Room.new, :foo, :unique => true)
+  end.equals([:fail, %Q{expected unique index on [:foo]}, blah, blah])
+
+  should("fail when index found for column, but it's unique and should not be") do
+    build_assertion("rooms", ["foo"], true).
+      evaluate(Room.new, :foo, :unique => false)
+  end.equals([:fail, %Q{expected index on [:foo]}, blah, blah])
+
+  should("pass when index found for column") do
+    build_assertion("rooms", ["foo"], false).
+      evaluate(Room.new, :foo)
+  end.equals([:pass, %Q{has index on [:foo]}])
+
+  should("pass when index found for column set") do
+    build_assertion("rooms", ["foo", "bar"], false).
+      evaluate(Room.new, :foo, :bar)
+  end.equals([:pass, %Q{has index on [:foo, :bar]}])
+
+  should("pass when unique index found for column") do
+    build_assertion("rooms", ["foo"], true).
+      evaluate(Room.new, :foo, :unique => true)
+  end.equals([:pass, %Q{has unique index on [:foo]}])
+
+  should("pass when unique index found for column set") do
+    build_assertion("rooms", ["foo", "bar"], true).
+      evaluate(Room.new, :foo, :bar, :unique => true)
+  end.equals([:pass, %Q{has unique index on [:foo, :bar]}])
+
+  should("pass when non-unique index found for column") do
+    build_assertion("rooms", ["foo"], false).
+      evaluate(Room.new, :foo, :unique => false)
+  end.equals([:pass, %Q{has index on [:foo]}])
+
+  should("pass when non-unique index found for column set") do
+    build_assertion("rooms", ["foo", "bar"], false).
+      evaluate(Room.new, :foo, :bar, :unique => false)
+  end.equals([:pass, %Q{has index on [:foo, :bar]}])
+
+end # The attribute_is_invalid macro

data/test/active_record/has_many_test.rb

@@ -6,13 +6,17 @@ 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, "has many :doors"])
+  end.equals([:pass, ":doors is a has_many association"])
 
   should("fail when record does not have a has_many association defined for attribute") do
     topic.has_many(:windows).run(Riot::Situation.new)
-  end.equals([:fail, "expected :windows to be a has_many association, but was not"])
+  end.equals([:fail, ":windows is not a has_many association", blah, blah])
 
   should("fail when attribute is not a has_many, but is a has_one association") do
     topic.has_many(:floor).run(Riot::Situation.new)
-  end.equals([:fail, "expected :floor to be a has_many association, but was a has_one instead"])
+  end.equals([:fail, ":floor is not a has_many association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.has_many(:doors, :class_name => "Portal").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected has_many :doors with {:class_name=>"Portal"}], blah, blah])
 end # The has_many assertion macro

data/test/active_record/has_one_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The has_one assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a has_one association defined for attribute") do
+    topic.has_one(:floor).run(Riot::Situation.new)
+  end.equals([:pass, ":floor is a has_one association"])
+
+  should("fail when record does not have a has_one association defined for attribute") do
+    topic.has_one(:windows).run(Riot::Situation.new)
+  end.equals([:fail, ":windows is not a has_one association", blah, blah])
+
+  should("fail when attribute is not a has_one, but is a has_many association") do
+    topic.has_one(:doors).run(Riot::Situation.new)
+  end.equals([:fail, ":doors is not a has_one association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.has_one(:floor, :class_name => "Surface").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected has_one :floor with {:class_name=>"Surface"}], blah, blah])
+end # The has_one assertion macro

data/test/active_record/validates_length_of_test.rb

@@ -0,0 +1,31 @@
+require 'teststrap'
+
+context "The validates_length_of assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("fail when minimum length causes an error") do
+    topic.validates_length_of(:name, (4..15)).run(Riot::Situation.new)
+  end.equals([:fail, ":name should be able to be 4 characters", blah, blah])
+
+  should("fail when value less than minimum value does not cause an error") do
+    topic.validates_length_of(:name, (6..15)).run(Riot::Situation.new)
+  end.equals([:fail, ":name expected to be more than 5 characters", blah, blah])
+
+  should("fail when maximum length causes an error") do
+    topic.validates_length_of(:name, (5..21)).run(Riot::Situation.new)
+  end.equals([:fail, ":name should be able to be 21 characters", blah, blah])
+
+  should("fail when value greater than maximum value does not cause an error") do
+    topic.validates_length_of(:name, (5..19)).run(Riot::Situation.new)
+  end.equals([:fail, ":name expected to be less than 20 characters", blah, blah])
+
+  should("pass when only a value can only be within the specific range") do
+    topic.validates_length_of(:name, (5..20)).run(Riot::Situation.new)
+  end.equals([:pass, "validates length of :name is within 5..20"])
+
+  should("pass even when minimum value is zero") do
+    topic.validates_length_of(:contents, (0..100)).run(Riot::Situation.new)
+  end.equals([:pass, "validates length of :contents is within 0..100"])
+
+end # The validates_length_of assertion macro

data/test/active_record/validates_presence_of_test.rb

@@ -10,5 +10,5 @@ context "The validates_presence_of assertion macro" do
 
   should("fail when attribute does not require presence") do
     topic.validates_presence_of(:contents).run(Riot::Situation.new)
-  end.equals([:fail, "expected to validate presence of :contents"])
+  end.equals([:fail, "expected to validate presence of :contents", blah, blah])
 end # The validates_presence_of assertion macro

data/test/active_record/validates_uniqueness_of_test.rb

@@ -5,9 +5,9 @@ context "The validates_uniqueness_of assertion macro" do
 
   should("fail without a persisted record") do
     topic.asserts("room") do
-      Room.new(:email => "foo@bar.baz", :foo => "what")
+      Room.new(:email => "foo@bar.baz")
     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, "must use a persisted record when testing uniqueness of :email", blah, blah])
 
   should("pass with a persisted record") do
     topic.asserts("room") do
@@ -19,5 +19,5 @@ context "The validates_uniqueness_of assertion macro" do
     topic.asserts("room") do
       Room.create_with_good_data(:email => "goo@car.caz")
     end.validates_uniqueness_of(:foo).run(Riot::Situation.new)
-  end.equals([:fail, "expected to fail because :foo is not unique"])
+  end.equals([:fail, "expected to fail because :foo is not unique", blah, blah])
 end # The validates_uniqueness_of assertion macro