riot_rails 0.0.6 → 0.0.7

data/Rakefile

@@ -32,7 +32,7 @@ begin
     gem.email = "gus@gusg.us"
     gem.homepage = "http://github.com/thumblemonks/riot_rails"
     gem.authors = ["Justin 'Gus' Knowlden"]
-    gem.add_development_dependency("riot", ">= 0.9.7")
+    gem.add_dependency("riot", ">= 0.10.2")
     gem.add_development_dependency("activerecord", ">= 2.3.2")
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/lib/riot/action_controller/assertion_macros.rb

@@ -1,94 +1,85 @@
-module Riot #:nodoc:
-  module ActionController #:nodoc:
+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}")
+    end
+  end
 
-    module AssertionMacros
-      # 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/)
-      def renders(expected)
-        actual_body = actual.response.body
-        if expected.kind_of?(Regexp)
-          msg = "expected response body #{actual_body.inspect} to match #{expected.inspect}"
-          actual_body =~ expected || fail(msg)
-        else
-          msg = "expected response body #{actual_body.inspect} to equal #{expected.inspect}"
-          expected == actual_body || fail(msg)
-        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 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
-      def renders_template(name)
-        name = 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+)*$/) || 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.
+  assertion(:response_code) do |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
+    expected_code == actual_code ? pass : fail("expected response code #{expected_code}, not #{actual_code}")
+  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.
-      def response_code(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
-        expected_code == actual_code || 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}")
+    end
+  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 block. This is so you can use named
-      # routes, which is - 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 :)
-      def redirected_to(&expectation_block)
-        actual_response_code = actual.response.response_code
-        if (300...400).member?(actual_response_code)
-          expected_redirect = actual.url_for(situation.instance_eval(&expectation_block))
-          actual_redirect = actual.url_for(actual.response.redirected_to)
-          msg = "expected to redirect to <#{expected_redirect}>, not <#{actual_redirect}>"
-          expected_redirect == actual_redirect || fail(msg)
-        else
-          fail("expected response to be a redirect, but was #{actual_response_code}")
-        end
-      end
-    end # AssertionMacros
-
-  end # ActionController
-end # Riot
-
-Riot::Assertion.instance_eval { include Riot::ActionController::AssertionMacros }
+end # Riot::Assertion

data/lib/riot/action_controller/context_macros.rb

@@ -28,16 +28,16 @@ module Riot #:nodoc:
       #     controlling :foos
       #     setup { get :index }
       #
-      #     controller.response_status(:found)
-      #     controller.redirected_to { new_foo_path }
+      #     asserts_controller.response_status(:found)
+      #     asserts_controller.redirected_to { new_foo_path }
       #   end
       #
       # Works the same as if you wrote the following assertions:
       #
-      #   asserts("controller") { @controller }.response_status(:found)
-      #   asserts("controller") { @controller }.redirected_to { new_foo_path }
-      def controller
-        asserts("controller") { @controller }
+      #   asserts("controller") { controller }.response_status(:found)
+      #   asserts("controller") { controller }.redirected_to { new_foo_path }
+      def asserts_controller
+        asserts("controller") { controller }
       end
     end # ContextMacros
 

data/lib/riot/active_record/assertion_macros.rb

@@ -1,107 +1,102 @@
-module Riot
-  module ActiveRecord
+class Riot::Assertion
 
-    module AssertionMacros
+  # 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
 
-      # 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
-      def validates_presence_of(attribute)
-        msg = "expected to validate presence of #{attribute.inspect}"
-        error_from_writing_value(actual, attribute, nil) || fail(msg)
-      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
-      def allows_values_for(attribute, *values)
-        bad_values = []
-        values.each do |value|
-          bad_values << value if error_from_writing_value(actual, attribute, value)
-        end
-        msg = "expected #{attribute.inspect} to allow value(s) #{bad_values.inspect}"
-        fail(msg) unless bad_values.empty?
-      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)
+    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
-      def does_not_allow_values_for(attribute, *values)
-        good_values = []
-        values.each do |value|
-          good_values << value unless error_from_writing_value(actual, attribute, value)
-        end
-        msg = "expected #{attribute.inspect} not to allow value(s) #{good_values.inspect}"
-        fail(msg) unless good_values.empty?
-      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)
+    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
-      def validates_uniqueness_of(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)
-          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) || 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)
       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.
-      #
-      #   context "a Room" do
-      #     setup { Room.new }
-      #
-      #     topic.has_many(:doors)
-      #     topic.has_many(:floors) # should probably fail given our current universe :)
-      #   end
-      def has_many(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")
-        end
-      end
-    private
-
-      def 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
+  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
+    end
+  end
 
-    end # AssertionMacros
+protected
 
-  end # ActiveRecord
-end # Riot
+  def self.error_from_writing_value(model, attribute, value)
+    model.write_attribute(attribute, value)
+    model.valid?
+    model.errors.on(attribute)
+  end
 
-Riot::Assertion.instance_eval { include Riot::ActiveRecord::AssertionMacros }
+end # Riot::Assertion

data/riot_rails.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot_rails}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-10-18}
+  s.date = %q{2009-11-27}
   s.description = %q{Riot specific test support for Rails apps. Protest the slow app.}
   s.email = %q{gus@gusg.us}
   s.extra_rdoc_files = [
@@ -30,7 +30,6 @@ Gem::Specification.new do |s|
      "lib/riot/rails.rb",
      "rails/init.rb",
      "riot_rails.gemspec",
-     "test/action_controller/action_assigns_variable_test.rb",
      "test/action_controller/controller_context_test.rb",
      "test/action_controller/redirected_to_test.rb",
      "test/action_controller/renders_template_test.rb",
@@ -51,8 +50,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Riot specific test support for Rails apps}
   s.test_files = [
-    "test/action_controller/action_assigns_variable_test.rb",
-     "test/action_controller/controller_context_test.rb",
+    "test/action_controller/controller_context_test.rb",
      "test/action_controller/redirected_to_test.rb",
      "test/action_controller/renders_template_test.rb",
      "test/action_controller/renders_test.rb",
@@ -71,14 +69,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<riot>, [">= 0.9.7"])
+      s.add_runtime_dependency(%q<riot>, [">= 0.10.2"])
       s.add_development_dependency(%q<activerecord>, [">= 2.3.2"])
     else
-      s.add_dependency(%q<riot>, [">= 0.9.7"])
+      s.add_dependency(%q<riot>, [">= 0.10.2"])
       s.add_dependency(%q<activerecord>, [">= 2.3.2"])
     end
   else
-    s.add_dependency(%q<riot>, [">= 0.9.7"])
+    s.add_dependency(%q<riot>, [">= 0.10.2"])
     s.add_dependency(%q<activerecord>, [">= 2.3.2"])
   end
 end

data/test/action_controller/controller_context_test.rb

@@ -3,65 +3,22 @@ require 'teststrap'
 class FoosController < ActionController::Base
 end
 
-context "controlling in a context" do
-
-  setup do
-    @ctx = Riot::Context.new("foo", Riot::NilReport.new)
-    @ctx.controlling :foos
-    @ctx.situation
-  end
-
-  topic.assigns(:controller)
-  topic.assigns(:request)
-  topic.assigns(:response)
-  
-  context "the assigned controller" do
-    setup { topic.controller }
-
-    topic.kind_of(FoosController)
-
-    should("have an empty params hash") do
-      topic.params
-    end.equals({})
-
-    should("return a test request when asking for request") do
-      topic.request
-    end.kind_of(::ActionController::TestRequest)
-  end # the assigned controller
-
-  context "the assigned request" do
-    setup { topic.request }
-    topic.kind_of(::ActionController::TestRequest)
-  end # the assigned request
-
-  context "the assigned response" do
-    setup { topic.response }
-    topic.kind_of(::ActionController::TestResponse)
-  end # the assigned response
-
-  context "calling controller" do
-    setup { @ctx.controller }
-
-    topic.kind_of(Riot::Assertion)
-
-    asserts("assertion name") { topic.description }.equals("foo asserts controller")
-
-    should("return the controller as the actual value") do
-      topic.actual
-    end.kind_of(FoosController)
-  end # calling controller
+context "A controller test" do
+  controlling :foos
 
-end # controlling in a context
+  asserts_controller.kind_of(FoosController)
 
-context "a controller test" do
-  controlling :foos
+  asserts("request is accessible") { request }.kind_of(::ActionController::TestRequest)
+  asserts("response is accessible") { response }.kind_of(::ActionController::TestResponse)
+  asserts("params is accessible") { controller.params }.equals({})
 
-  asserts("situation") { self }.respond_to(:get)
-  asserts("situation") { self }.respond_to(:post)
-  asserts("situation") { self }.respond_to(:put)
-  asserts("situation") { self }.respond_to(:delete)
+  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 "an unknown action" do
+  asserts("an unknown action call") do
     get :burberry
   end.raises(ActionController::UnknownAction, "No action responded to burberry")
-end # a controller
+
+end # a controller test

data/test/action_controller/redirected_to_test.rb

@@ -1,60 +1,41 @@
 require 'teststrap'
 
 class RedirectedToController < ActionController::Base
-  def index; redirect_to new_gremlin_path; end
-  def show; render :text => ""; end
-end
+  def index
+    redirect_to new_gremlin_path
+  end
 
-context "asserting the redirect of an action" do
+  def show
+    render :text => ""
+  end
+end
 
+context "Asserting the redirect of an action" do
   setup do
-    context = Riot::Context.new("redirected to", Riot::NilReport.new)
-    context.controlling :redirected_to
+    @situation = Riot::Situation.new
+    context = Riot::Context.new("redirected to") {}
+    context.controlling(:redirected_to).last.run(@situation)
     context
   end
 
   context "when doing an actual redirect" do
+    setup_for_assertion_test { get :index }
 
-    setup do
-      topic.setup { get :index }
-      topic
+    assertion_test_passes("when expected url matches actual redirect url") do
+      topic.asserts_controller.redirected_to { new_gremlin_path }
     end
 
-    should "pass when expected url matches actual redirect url" do
-      assertion = topic.controller
-      assertion.redirected_to { new_gremlin_path }
-      assertion.passed?
+    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 }
     end
-
-    context "and expected url does not match actual redirect url exactly" do
-      setup do
-        assertion = topic.controller
-        assertion.redirected_to { new_gremlin_url }
-        assertion
-      end
-
-      asserts("topic failed") { topic.failed? }
-
-      asserts("topic message") do
-        topic.result.message
-      end.matches(%r[expected to redirect to <http://test.host/gremlins/new>, not </gremlins/new>])
-    end # and expected url does not match actual redirect url exactly
-
   end # when doing an actual redirect
 
   context "when not actually doing a redirect" do
-    setup do
-      topic.setup { get :show }
-      assertion = topic.controller
-      assertion.redirected_to { new_gremlin_path }
-      assertion
+    setup_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 }
     end
-
-    asserts("topic failed") { topic.failed? }
-
-    asserts("topic message") do
-      topic.result.message
-    end.matches(%r[expected response to be a redirect, but was 200])
   end # when not actually doing a redirect
-
-end # asserting the redirect of an action
+end # Asserting the redirect of an action

data/test/action_controller/renders_template_test.rb

@@ -5,89 +5,53 @@ class RenderedTemplatesController < ActionController::Base
   def text_me; render :text => "blah"; end
 end
 
-context "asserting the rendered template for an action" do
-
+context "Asserting the rendered template for an action" do
   setup do
-    context = Riot::Context.new("rendered template", Riot::NilReport.new)
-    context.controlling :rendered_templates
+    @situation = Riot::Situation.new
+    context = Riot::Context.new("rendered_template") {}
+    context.controlling(:rendered_templates).last.run(@situation)
     context
   end
 
   context "that rendered a template" do
-    setup do
-      topic.setup { get :foo_bar }
-      topic
-    end
+    setup_for_assertion_test { get :foo_bar }
 
-    should "pass when rendered template name matches expectation" do
-      assertion = topic.controller
-      assertion.renders_template('foo_bar')
-      assertion.passed?
+    assertion_test_passes("when rendered template name matches expectation") do
+      topic.asserts_controller.renders_template('foo_bar')
     end
 
-    context "when rendered template does not match expectation" do
-      setup do
-        assertion = topic.controller
-        assertion.renders_template('bar_foo')
-        assertion
-      end
-
-      asserts("topic failed") { topic.failed? }
-
-      asserts("topic message") do
-        topic.result.message
-      end.matches(/expected template "bar_foo", not "rendered_templates\/foo_bar.html.erb"/)
-    end # when rendered template does not match expectation
-
+    assertion_test_fails("when rendered template does not match expectation",
+    %Q{expected template "bar_foo", not "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 expected" do
-    setup do
-      topic.setup { get :text_me }
-      topic
-    end
+  context "that did not render a template, as was expected" do
+    setup_for_assertion_test { get :text_me }
 
-    should "pass when providing nil as expectation" do
-      assertion = topic.controller
-      assertion.renders_template(nil)
-      assertion.passed?
+    assertion_test_passes("when providing nil as expectation") do
+      topic.asserts_controller.renders_template(nil)
     end
 
-    should "pass when providing empty string as expectation" do
-      assertion = topic.controller
-      assertion.renders_template("")
-      assertion.passed?
+    assertion_test_passes("when providing empty string as expectation") do
+      topic.asserts_controller.renders_template("")
     end
-  end # that did not render a template as expected
+  end # that did not render a template, as was expected
 
   context "that did not render a template but expected one" do
-    setup do
-      topic.setup { get :text_me }
-      assertion = topic.controller
-      assertion.renders_template('text_me')
-      assertion
+    setup_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
-
-    asserts("topic failed") { topic.failed? }
-
-    asserts("topic message") do
-      topic.result.message
-    end.matches(/expected template "text_me", not ""/)
   end # that did not render a template but expected one
 
   context "that rendered a template with a partial match on template name" do
-    setup do
-      topic.setup { get :foo_bar }
-      assertion = topic.controller
-      assertion.renders_template('foo')
-      assertion
-    end
-
-    asserts("topic failed") { topic.failed? }
+    setup_for_assertion_test { get :foo_bar }
 
-    asserts("topic message") do
-      topic.result.message
-    end.matches(/expected template "foo", not "rendered_templates\/foo_bar.html.erb"/)
+    assertion_test_fails("with message",
+    %Q{expected template "foo", not "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
 
-end # asserting the rendered template for an action
+end # Asserting the rendered template for an action

data/test/action_controller/renders_test.rb

@@ -4,53 +4,27 @@ class RendersController < ActionController::Base
   def index; render :text => "Yo mama"; end
 end
 
-context "asserting the body of a response" do
-
+context "Asserting the body of a response" do
   setup do
-    context = Riot::Context.new("renders", Riot::NilReport.new)
-    context.controlling :renders
-    context.setup { get :index }
+    @situation = Riot::Situation.new
+    context = Riot::Context.new("renders") {}
+    context.controlling(:renders).last.run(@situation)
+    context.setup { get :index }.last.run(@situation)
     context
   end
 
-  should "assert rendered action body equals expected" do
-    assertion = topic.controller
-    assertion.renders("Yo mama")
-    assertion.passed?
-  end
-
-  context "when rendered action body does not equal expected" do
-    setup do
-      assertion = topic.controller
-      assertion.renders("Yo")
-      assertion
-    end
-
-    asserts("topic failed") { topic.failed? }
+  assertion_test_passes("when body equals expected") { topic.asserts_controller.renders("Yo mama") }
 
-    asserts("topic message") do
-      topic.result.message
-    end.matches(/expected response body "Yo mama" to equal "Yo"/)
-  end # when rendered action body does not equal expected
-
-  should "assert rendered action body matches expected" do
-    assertion = topic.controller
-    assertion.renders(/mama/)
-    assertion.passed?
+  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")
   end
 
-  context "when rendered action body does not match expected" do
-    setup do
-      assertion = topic.controller
-      assertion.renders(/obama/)
-      assertion
-    end
-
-    asserts("topic failed") { topic.failed? }
+  assertion_test_passes("when body matches expected") { topic.asserts_controller.renders(/mama/) }
 
-    asserts("topic message") do
-      topic.result.message
-    end.matches(/expected response body "Yo mama" to match \/obama\//)
-  end # when rendered action body does not match expected
+  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/)
+  end
 
-end # asserting the body of a response
+end # Asserting the body of a response

data/test/action_controller/response_status_test.rb

@@ -6,83 +6,35 @@ class ResponseCodesController < ActionController::Base
   def make_me; render :text => "", :status => 201; end
 end
 
-context "asserting the response status for an action" do
-
+context "Asserting the response status for an action" do
   setup do
-    context = Riot::Context.new("response status", Riot::NilReport.new)
-    context.controlling :response_codes
+    @situation = Riot::Situation.new
+    context = Riot::Context.new("response status") {}
+    context.controlling(:response_codes).last.run(@situation)
     context
   end
 
   context "returning OK" do
-    setup do
-      topic.setup { get :ok_go }
-      topic
-    end
+    setup_for_assertion_test { get :ok_go }
 
-    should "pass when asked if :ok" do
-      assertion = topic.controller
-      assertion.response_code(:ok)
-      assertion.passed?
-    end
+    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) }
 
-    should "pass when asked if 200" do
-      assertion = topic.controller
-      assertion.response_code(200)
-      assertion.passed?
+    assertion_test_fails("when CONTINUE returned instead", %Q{expected response code 100, not 200}) do
+      topic.asserts_controller.response_code(100)
     end
-
-    context "but expected to return CONTINUE" do
-      setup do
-        assertion = topic.controller
-        assertion.response_code(100)
-        assertion
-      end
-
-      asserts("topic failed") { topic.failed? }
-
-      asserts("topic message") do
-        topic.result.message
-      end.matches(/expected response code 100, not 200/)
-    end # but expected to return CONTINUE
   end # returning OK
 
   context "that is redirecting" do
-    setup do
-      topic.setup { get :fffound }
-      topic
-    end
-
-    should "pass when asked if :ok" do
-      assertion = topic.controller
-      assertion.response_code(:found)
-      assertion.passed?
-    end
-
-    should "pass when asked if 200" do
-      assertion = topic.controller
-      assertion.response_code(302)
-      assertion.passed?
-    end
+    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) }
   end # that is redirecting
 
   context "that has explicit status" do
-    setup do
-      topic.setup { get :make_me }
-      topic
-    end
-
-    should "pass when asked if :created" do
-      assertion = topic.controller
-      assertion.response_code(:created)
-      assertion.passed?
-    end
-
-    should "pass when asked if 202" do
-      assertion = topic.controller
-      assertion.response_code(201)
-      assertion.passed?
-    end
+    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) }
   end # that has explicit status
 
-end # asserting the status of a response
+end # Asserting the status of a response

data/test/active_record/allowing_values_test.rb

@@ -1,36 +1,35 @@
 require 'teststrap'
 
-context "allows_values_for" do
-  setup_and_run_context("when attribute allows a value", 1, 0, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.allows_values_for :email, "a@b.cd"
-  end
-
-  setup_and_run_context("when attribute allows multiple values", 1, 0, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.allows_values_for :email, "a@b.cd", "e@f.gh"
-  end
-
-  setup_and_run_context("when attribute is provided a valid and an invalid value", 0, 1, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.allows_values_for :email, "a", "e@f.gh"
-  end
-end # allows_values_for
-
-context "does_not_allow_values_for" do
-  setup_and_run_context("when attribute does not allow a value", 1, 0, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.does_not_allow_values_for :email, "a"
-    test_ctx.assertions.each {|a| STDOUT.puts a.raised if a.errored?}
-  end
-
-  setup_and_run_context("when attribute does not allow multiple values", 1, 0, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.does_not_allow_values_for :email, "a", "e"
-  end
-
-  setup_and_run_context("when attribute is provided a valid and an invalid value", 0, 1, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.does_not_allow_values_for :email, "a", "e@f.gh"
-  end
-end # does_not_allow_values_for
+context "The allow_values_for assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when attribute allows a value") do
+    topic.allows_values_for(:email, "a@b.cd").run(Riot::Situation.new)
+  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])
+
+  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 # The allow_values_for assertion macro
+
+context "The does_not_allow_values_for assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  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])
+
+  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])
+
+  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

data/test/active_record/has_many_test.rb

@@ -1,46 +1,18 @@
 require 'teststrap'
 
-context "testing has_many" do
-
-  setup do
-    context = Riot::Context.new("has_many test context", Riot::NilReport.new)
-    context.setup { Room.new }
-    context.topic
-  end
-
-  context "when record has a has_many association defined for attribute" do
-    setup do
-      topic.has_many(:doors)
-      topic
-    end
-    
-    asserts("assertion passed") { topic.passed? }
-  end # when record has a has_many association defined for attribute
-
-  context "when record does not have a has_many association defined for attribute" do
-    setup do
-      topic.has_many(:windows)
-      topic
-    end
-
-    asserts("assertion failed") { topic.failed? }
-
-    asserts("failure message") do
-      topic.result.message
-    end.matches(/expected :windows to be a has_many association, but was not/)
-  end # when record does not have a has_many association defined for attribute
-
-  context "when attribute is not a has_many, but is a has_one association" do
-    setup do
-      topic.has_many(:floor)
-      topic
-    end
-
-    asserts("assertion failed") { topic.failed? }
-
-    asserts("failure message") do
-      topic.result.message
-    end.matches(/expected :floor to be a has_many association, but was a has_one instead/)
-  end # when attribute is not a has_many, but is a has_one association
-
-end # testing has_many
+context "The has_many assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a has_many association defined for attribute") do
+    topic.has_many(:doors).run(Riot::Situation.new)
+  end.equals([:pass])
+
+  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"])
+
+  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 # The has_many assertion macro

data/test/active_record/validates_presence_of_test.rb

@@ -1,13 +1,14 @@
 require 'teststrap'
 
-context "validates_presence_of" do
-  setup_and_run_context("when attribute requires presence", 1, 0, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.validates_presence_of(:location)
-  end
+context "The validates_presence_of assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
 
-  setup_and_run_context("when attribute does not require presence", 0, 1, 0) do |test_ctx|
-    test_ctx.setup { Room.new }
-    test_ctx.topic.validates_presence_of(:contents)
-  end
-end # validates_presence_of
+  should("pass when attribute requires presence") do
+    topic.validates_presence_of(:location).run(Riot::Situation.new)
+  end.equals([:pass])
+
+  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 # The validates_presence_of assertion macro

data/test/active_record/validates_uniqueness_of_test.rb

@@ -1,20 +1,23 @@
 require 'teststrap'
 
-context "validates_uniqueness_of" do
+context "The validates_uniqueness_of assertion macro" do
+  setup_test_context
 
-  setup_and_run_context("without a persisted record", 0, 1, 0) do |test_ctx|
-    test_ctx.setup { Room.new(:email => "foo@bar.baz", :foo => "what") }
-    test_ctx.topic.validates_uniqueness_of :email
-  end
+  should("fail without a persisted record") 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"])
 
-  setup_and_run_context("with a persisted record", 1, 0, 0) do |test_ctx|
-    test_ctx.setup { Room.create_with_good_data(:email => "foo@bar.baz") }
-    test_ctx.topic.validates_uniqueness_of :email
-  end
+  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])
 
-  setup_and_run_context("with a persisted record but not validating uniqueness", 0, 1, 0) do |test_ctx|
-    test_ctx.setup { Room.create_with_good_data(:email => "goo@car.caz") }
-    test_ctx.topic.validates_uniqueness_of :foo
-  end
-
-end # validates_uniqueness_of
+  should("fail with a persisted record but not validating uniqueness") do
+    topic.asserts("room") do
+      Room.new(: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 # The validates_uniqueness_of assertion macro

data/test/teststrap.rb

@@ -1,3 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
 require 'rubygems'
 require 'active_record'
 require 'action_controller'
@@ -59,29 +61,74 @@ require 'riot/rails'
 
 module RiotRails
   module Context
-    def asserts_passes_failures_errors(passes=0, failures=0, errors=0)
-      should("pass #{passes} test(s)") { topic.passes }.equals(passes)
-      should("fail #{failures} test(s)") { topic.failures }.equals(failures)
-      should("error on #{errors} test(s)") { topic.errors }.equals(errors)
+    # def asserts_passes_failures_errors(passes=0, failures=0, errors=0)
+    #   should("pass #{passes} test(s)") { topic.passes }.equals(passes)
+    #   should("fail #{failures} test(s)") { topic.failures }.equals(failures)
+    #   should("error on #{errors} test(s)") { topic.errors }.equals(errors)
+    # end
+    # 
+    # def setup_with_test_context(&block)
+    #   setup do
+    #     @test_report = Riot::SilentReporter.new
+    #     @test_context = Riot::Context.new("test context", @test_report)
+    #     yield(@test_context)
+    #     @test_context.report
+    #     @test_report
+    #   end
+    # end
+    # 
+    # def setup_and_run_context(name, *passes_failures_errors, &block)
+    #   context name do
+    #     setup_with_test_context(&block)
+    #     asserts_passes_failures_errors(*passes_failures_errors)
+    #   end
+    # end
+
+    def setup_test_context
+      setup { Riot::Context.new("test context") {} }
     end
 
-    def setup_with_test_context(&block)
+    def setup_for_assertion_test(&block)
       setup do
-        @test_report = Riot::NilReport.new
-        @test_context = Riot::Context.new("test context", @test_report)
-        yield(@test_context)
-        @test_context.report
-        @test_report
+        topic.setup(&block).last.run(@situation)
+        topic
       end
     end
+    
+    def assertion_test_passes(description, &block)
+      should("pass #{description}") do
+        instance_eval(&block).run(@situation)
+      end.equals([:pass])
+    end
 
-    def setup_and_run_context(name, *passes_failures_errors, &block)
-      context name do
-        setup_with_test_context(&block)
-        asserts_passes_failures_errors(*passes_failures_errors)
-      end
+    def assertion_test_fails(description, failure_message, &block)
+      should("fail #{description}") do
+        instance_eval(&block).run(@situation)
+      end.equals([:fail, failure_message])
     end
-  end
-end
+
+  end # Context
+end # RiotRails
 
 Riot::Context.instance_eval { include RiotRails::Context }
+
+#
+## Let's see if we can get this way working sometime in the future
+
+# def get(action, options={})
+#   @env = {}
+#   @request = ActionController::TestRequest.new(@env)
+#   # @request = Rack::MockRequest.new(@app)
+#   # @response = @request.request("GET", path, options)
+#   # request = ActionController::TestRequest.new(@env)
+#   @request.query_parameters["action"] = action
+#   @env["action_controller.rescue.request"] = @request
+#   @env["action_controller.rescue.response"] = ActionController::TestResponse.new
+#   @app.call(@env)
+# end
+
+# setup do
+  # DashboardsController.instance_eval { include ActionController::TestCase::RaiseActionExceptions }
+  # @controller_class = DashboardsController
+  # @app = DashboardsController
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riot_rails
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -9,18 +9,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-18 00:00:00 -05:00
+date: 2009-11-27 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: riot
-  type: :development
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.7
+        version: 0.10.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -55,7 +55,6 @@ files:
 - lib/riot/rails.rb
 - rails/init.rb
 - riot_rails.gemspec
-- test/action_controller/action_assigns_variable_test.rb
 - test/action_controller/controller_context_test.rb
 - test/action_controller/redirected_to_test.rb
 - test/action_controller/renders_template_test.rb
@@ -98,7 +97,6 @@ signing_key:
 specification_version: 3
 summary: Riot specific test support for Rails apps
 test_files: 
-- test/action_controller/action_assigns_variable_test.rb
 - test/action_controller/controller_context_test.rb
 - test/action_controller/redirected_to_test.rb
 - test/action_controller/renders_template_test.rb