riot-rails 0.0.10.pre.3

data/lib/riot/active_record/validation_macros.rb

@@ -0,0 +1,187 @@
+module RiotRails
+  module ActiveRecord
+  protected
+
+    class ValidationAssertionMacro < Riot::AssertionMacro
+    private
+      def errors_from_writing_value(model, attribute, value)
+        # TODO: Fix me to not use __send__
+        model.__send__(:write_attribute, attribute, value)
+        model.valid?
+        model.errors[attribute]
+      end
+
+      def errors_from_writing_value?(*args)
+        errors_from_writing_value(*args).any?
+      end
+    end
+
+  public
+
+    # An ActiveRecord assertion that expects to pass with a given value or set of values for a given
+    # attribute.
+    #
+    #    rails_context User do
+    #      asserts_topic.allows_values_for :email, "a@b.cd"
+    #      asserts_topic.allows_values_for :email, "a@b.cd", "e@f.gh"
+    #    end
+    class AllowsValuesForMacro < ValidationAssertionMacro
+      register :allows_values_for
+
+      def evaluate(actual, attribute, *values)
+        bad_values = []
+        values.each do |value|
+          bad_values << value if errors_from_writing_value?(actual, attribute, value)
+        end
+        bad_values.empty? ? pass : fail(expected_message(attribute).to_allow_values(bad_values))
+      end
+    end
+
+    # An ActiveRecord assertion that expects to fail with a given value or set of values for a given
+    # attribute.
+    #
+    #    rails_context User do
+    #      asserts_topic.does_not_allow_values_for :email, "a"
+    #      asserts_topic.does_not_allow_values_for :email, "a@b", "e f@g.h"
+    #    end
+    class DoesNotAllowValuesForMacro < ValidationAssertionMacro
+      register :does_not_allow_values_for
+      def evaluate(actual, attribute, *values)
+        good_values = []
+        values.each do |value|
+          good_values << value unless errors_from_writing_value?(actual, attribute, value)
+        end
+        good_values.empty? ? pass : fail(expected_message(attribute).not_to_allow_values(good_values))
+      end
+    end
+
+    # 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.
+    #
+    #    rails_context User do
+    #      asserts_topic.is_invalid_when :email, "fake", "is invalid"
+    #      asserts_topic.is_invalid_when :email, "another fake", /invalid/
+    #    end
+    class IsInvalidWhenMacro < ValidationAssertionMacro
+      register :is_invalid_when
+
+      def evaluate(actual, attribute, value, expected_error=nil)
+        actual_errors = errors_from_writing_value(actual, attribute, value)
+        if actual_errors.empty?
+          fail expected_message(attribute).to_be_invalid_when_value_is(value)
+        elsif expected_error && !has_error_message?(expected_error, actual_errors)
+          fail expected_message(attribute).to_be_invalid_with_error_message(expected_error)
+        else
+          pass new_message.attribute(attribute).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
+
+    # An ActiveRecord assertion that expects to fail when a given attribute is validated after a nil value
+    # is provided to it.
+    #
+    #    rails_context User do
+    #      asserts_topic.validates_presence_of(:name)
+    #    end
+    class ValidatesPresenceOfMacro < ValidationAssertionMacro
+      register :validates_presence_of
+
+      def evaluate(actual, attribute)
+        if errors_from_writing_value?(actual, attribute, nil)
+          pass new_message.validates_presence_of(attribute)
+        else
+          fail expected_message.to_validate_presence_of(attribute)
+        end
+      end
+    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?+.
+    #
+    #    rails_context User do
+    #      setup { User.create(:email => "a@b.cde", ... ) }
+    #      asserts_topic.validates_uniqueness_of :email
+    #    end
+    class ValidatesUniquenessOfMacro < ValidationAssertionMacro
+      register :validates_uniqueness_of
+      
+      def evaluate(actual, attribute)
+        actual_record = actual
+        if actual_record.new_record?
+          fail new_message.must_use_a_persisted_record_when_testing_uniqueness_of(attribute)
+        else
+          copied_model = actual_record.class.new
+          actual_record.attributes.each do |dup_attribute, dup_value|
+            copied_model.__send__(:write_attribute, dup_attribute, dup_value)
+          end
+          copied_value = actual_record.__send__(:read_attribute, attribute)
+          if errors_from_writing_value?(copied_model, attribute, copied_value)
+            pass new_message(attribute).is_unique
+          else
+            fail expected_message.to_fail_because(attribute).is_not_unique
+          end
+        end
+      end
+    end
+
+    # An ActiveRecord assertion to test that the length of the value of an attribute must be within a 
+    # specified range. Assertion fails if: there are errors when min/max characters are used, there are no 
+    # errors when min-1/max+1 characters are used.
+    #
+    #    rails_context User do
+    #      asserts_topic.validates_length_of :name, (2..36)
+    #    end
+    #
+    # TODO: allow for options on what to validate
+    class ValidatesLengthOfMacro < ValidationAssertionMacro
+      register :validates_length_of
+
+      def evaluate(actual, attribute, range)
+        min, max = range.first, range.last
+        [min, max].each do |length|
+          if errors_from_writing_value?(actual, attribute, "r" * length)
+            return fail(new_message(attribute).should_be_able_to_be(length).characters)
+          end
+        end
+
+        if (min-1) > 0 && !errors_from_writing_value?(actual, attribute, "r" * (min-1))
+          fail new_message(attribute).expected_to_be_more_than(min - 1).characters
+        elsif !errors_from_writing_value?(actual, attribute, "r" * (max+1))
+          fail new_message(attribute).expected_to_be_less_than(max + 1).characters
+        else
+          pass new_message.validates_length_of(attribute).is_within(range)
+        end
+      end
+    end
+
+    # An ActiveRecord assertion to test that an attribute is invalid along with the expected error message
+    # (or error message partial). The assumption is that a value has already been set.
+    #
+    #    rails_context User do
+    #      hookup { topic.bio = "I'm a goofy clown" }
+    #      asserts_topic.attribute_is_invalid :bio, "cannot contain adjectives"
+    #    end
+    class AttributeIsInvalidMacro < ValidationAssertionMacro
+      register :attribute_is_invalid
+
+      def evaluate(actual, attribute, error_message)
+        actual.valid?
+        errors = actual.errors[attribute]
+        if errors.empty?
+          fail new_message(attribute).expected_to_be_invalid
+        elsif errors.include?(error_message)
+          pass new_message(attribute).is_invalid
+        else
+          fail new_message(attribute).is_invalid.but(error_message).is_not_a_valid_error_message
+        end
+      end
+    end
+
+  end # ActiveRecord
+end # RiotRails

data/lib/riot/active_record.rb

@@ -0,0 +1,4 @@
+require 'riot/rails'
+require 'riot/active_record/assertion_macros'
+require 'riot/active_record/context_middleware'
+require 'riot/active_record/transactional_middleware'

data/lib/riot/rails.rb

@@ -0,0 +1 @@
+require 'riot'

data/rails/init.rb

@@ -0,0 +1 @@
+require 'riot/rails' if RAILS_ENV == 'test'

data/riot-rails.gemspec

@@ -0,0 +1,130 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{riot-rails}
+  s.version = "0.0.10.pre.3"
+
+  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{2010-06-04}
+  s.description = %q{Riot specific test support for Rails apps. Protest the slow app.}
+  s.email = %q{gus@gusg.us}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/riot/action_controller.rb",
+     "lib/riot/action_controller/context_macros/asserts_response.rb",
+     "lib/riot/action_controller/context_middleware.rb",
+     "lib/riot/action_controller/http_methods.rb",
+     "lib/riot/active_record.rb",
+     "lib/riot/active_record/assertion_macros.rb",
+     "lib/riot/active_record/context_middleware.rb",
+     "lib/riot/active_record/database_macros.rb",
+     "lib/riot/active_record/reflection_macros.rb",
+     "lib/riot/active_record/transactional_middleware.rb",
+     "lib/riot/active_record/validation_macros.rb",
+     "lib/riot/rails.rb",
+     "rails/init.rb",
+     "riot-rails.gemspec",
+     "test/action_controller/context_macros/asserts_response_test.rb",
+     "test/action_controller/context_middleware_test.rb",
+     "test/action_controller/delete_request_test.rb",
+     "test/action_controller/get_request_test.rb",
+     "test/action_controller/post_request_test.rb",
+     "test/action_controller/put_request_test.rb",
+     "test/action_controller/restful_delete_request_test.rb",
+     "test/action_controller/restful_get_request_test.rb",
+     "test/action_controller/restful_post_request_test.rb",
+     "test/action_controller/restful_put_request_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/context_middleware_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_root/app/controllers/gremlins_controller.rb",
+     "test/rails_root/app/controllers/parties_controller.rb",
+     "test/rails_root/app/controllers/rooms_controller.rb",
+     "test/rails_root/app/views/rendered_templates/foo_bar.html.erb",
+     "test/rails_root/config/database.yml",
+     "test/rails_root/config/environment.rb",
+     "test/rails_root/config/routes.rb",
+     "test/rails_root/db/schema.rb",
+     "test/teststrap.rb",
+     "test/transactional_middleware_test.rb"
+  ]
+  s.homepage = %q{http://github.com/thumblemonks/riot-rails}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Riot specific test support for Rails apps}
+  s.test_files = [
+    "test/action_controller/context_macros/asserts_response_test.rb",
+     "test/action_controller/context_middleware_test.rb",
+     "test/action_controller/delete_request_test.rb",
+     "test/action_controller/get_request_test.rb",
+     "test/action_controller/post_request_test.rb",
+     "test/action_controller/put_request_test.rb",
+     "test/action_controller/restful_delete_request_test.rb",
+     "test/action_controller/restful_get_request_test.rb",
+     "test/action_controller/restful_post_request_test.rb",
+     "test/action_controller/restful_put_request_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/context_middleware_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_root/app/controllers/gremlins_controller.rb",
+     "test/rails_root/app/controllers/parties_controller.rb",
+     "test/rails_root/app/controllers/rooms_controller.rb",
+     "test/rails_root/config/environment.rb",
+     "test/rails_root/config/routes.rb",
+     "test/rails_root/db/schema.rb",
+     "test/teststrap.rb",
+     "test/transactional_middleware_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<riot>, [">= 0.11.0"])
+      s.add_runtime_dependency(%q<rack-test>, [">= 0.5.3"])
+      s.add_development_dependency(%q<activerecord>, [">= 3.0.0.beta3"])
+      s.add_development_dependency(%q<actionpack>, [">= 3.0.0.beta3"])
+    else
+      s.add_dependency(%q<riot>, [">= 0.11.0"])
+      s.add_dependency(%q<rack-test>, [">= 0.5.3"])
+      s.add_dependency(%q<activerecord>, [">= 3.0.0.beta3"])
+      s.add_dependency(%q<actionpack>, [">= 3.0.0.beta3"])
+    end
+  else
+    s.add_dependency(%q<riot>, [">= 0.11.0"])
+    s.add_dependency(%q<rack-test>, [">= 0.5.3"])
+    s.add_dependency(%q<activerecord>, [">= 3.0.0.beta3"])
+    s.add_dependency(%q<actionpack>, [">= 3.0.0.beta3"])
+  end
+end
+

data/test/action_controller/context_macros/asserts_response_test.rb

@@ -0,0 +1,35 @@
+require 'teststrap'
+
+context "An asserts_response context macro" do
+  context "for context not representing an ActionController" do
+    setup { Riot::Context.new("Hello") {} }
+    asserts("asserts_response returns") { topic.asserts_response }.raises(NoMethodError)
+  end # for context not representing an ActionController
+
+  helper(:situation) do
+    a_situation = Riot::Situation.new
+    a_situation.helper(:response) { OpenStruct.new(:status => 200) }
+    a_situation
+  end
+
+  setup do
+    Riot::Context.new(RoomsController) {}
+  end
+
+  context "when referenced without arguments" do
+    setup { topic.asserts_response }
+
+    asserts_topic.kind_of(Riot::Assertion)
+    asserts(:to_s).equals("asserts response")
+
+    asserts("the result of assertion responds to :status") do
+      topic.responds_to(:status).run(situation).first
+    end.equals(:pass)
+  end # when referenced without arguments
+
+  context "with method name provided" do
+    setup { topic.asserts_response(:status).equals(200) }
+    asserts(:to_s).equals("asserts response #status")
+    asserts("output of running the test") { topic.run(situation).first }.equals(:pass)
+  end
+end # An asserts_response context macro

data/test/action_controller/context_middleware_test.rb

@@ -0,0 +1,66 @@
+require 'teststrap'
+
+context "ActionController middleware" do
+  setup_test_context
+
+  helper(:assigned) { |var| topic.instance_variable_get(var) }
+
+  context "pre-request state" do
+    setup do
+      situation = Riot::Situation.new
+      topic.context(RoomsController) {}.local_run(Riot::SilentReporter.new, situation)
+      situation
+    end
+
+    asserts(:topic).equals(RoomsController)
+
+    asserts("@app") { assigned(:@app).to_s }.equals { ::Rails.application.to_s }
+    asserts("helper app") { topic.app.to_s }.equals { assigned(:@app).to_s }
+
+    asserts("@env") { assigned(:@env) }.equals({})
+    asserts("helper env") { topic.env }.equals { assigned(:@env) }
+
+    asserts("helper controller") { topic.controller }.equals { assigned(:@controller) }
+
+    asserts("request before any request made") do
+      topic.request
+    end.raises(Exception, "No request made yet")
+
+    asserts("response before any request made") do
+      topic.response
+    end.raises(Exception, "No response since no request made yet")
+
+    asserts_topic.responds_to(:get)
+    asserts_topic.responds_to(:post)
+    asserts_topic.responds_to(:put)
+    asserts_topic.responds_to(:delete)
+  end # pre-request state
+
+  context "post-request state" do
+    setup do
+      situation = Riot::Situation.new
+      topic.context(RoomsController) do
+        setup { get("/rooms") }
+      end.local_run(Riot::SilentReporter.new, situation)
+      situation
+    end
+
+    asserts(:topic).kind_of(Array)
+    asserts(:topic).size(3)
+    asserts("#topic first element response status") { topic.topic[0] }.equals(200)
+    asserts("#topic second element") { topic.topic[1] }.kind_of(Hash)
+    asserts("#topic second element") { topic.topic[1] }.includes("ETag")
+    asserts("#topic last element") { topic.topic[2] }.kind_of(ActionDispatch::Response)
+
+    asserts("helper env") { topic.env }.includes("action_controller.instance")
+
+    asserts("helper controller") { topic.controller }.kind_of(RoomsController)
+    asserts("env['action_controller.instance']") do
+      topic.env["action_controller.instance"]
+    end.kind_of(RoomsController)
+
+    asserts("helper request") { topic.request }.kind_of(Rack::Request)
+    asserts("helper response") { topic.response }.kind_of(Rack::Response)
+  end # post-request state
+
+end # ActionController middleware

data/test/action_controller/delete_request_test.rb

@@ -0,0 +1,45 @@
+require 'teststrap'
+
+context RoomsController do
+
+  asserts("DELETEs unknown action for existing controller") do
+    delete "/rooms/blah"
+  end.raises(AbstractController::ActionNotFound, "The action 'blah' could not be found")
+
+  context "for a DELETE request" do
+    helper(:action_name) { env['action_dispatch.request.path_parameters'][:action] }
+
+    context "without parameters" do
+      setup { delete "/rooms/destroy" }
+
+      asserts("request method") { request.request_method }.equals("DELETE")
+      asserts("action name") { action_name }.equals("destroy")
+      asserts("response status") { response.status }.equals(200)
+      asserts("response body") { response.body }.equals { "destroyed #{controller.params.inspect}" }
+
+      context "response headers" do
+        setup { response.headers.keys }
+        asserts_topic.includes("Content-Type")
+        asserts_topic.includes("ETag")
+        asserts_topic.includes("Cache-Control")
+      end # response headers
+    end # without parameters
+
+    context "with parameters" do
+      setup { delete "/rooms/destroy", {:momma => "loves you", "love_you_too" => "mom"} }
+
+      asserts("request method") { request.request_method }.equals("DELETE")
+      asserts("action name") { action_name }.equals("destroy")
+      asserts("response status") { response.status }.equals(200)
+
+      asserts("response body") { response.body }.equals do
+        "destroyed #{controller.params.inspect}"
+      end
+
+      asserts("params") { controller.params }.includes("momma")
+      asserts("params") { controller.params }.includes("love_you_too")
+    end # with parameters
+
+  end # for a DELETE request
+
+end # RoomsController

data/test/action_controller/get_request_test.rb

@@ -0,0 +1,37 @@
+require 'teststrap'
+
+context RoomsController do
+
+  asserts("GETs unknown action for existing controller") do
+    get "/rooms/blah"
+  end.raises(AbstractController::ActionNotFound, "The action 'blah' could not be found")
+
+  context "for a GET request" do
+    helper(:action_name) { env['action_dispatch.request.path_parameters'][:action] }
+
+    context "without parameters" do
+      setup { get "/rooms/index" }
+
+      asserts("action name") { action_name }.equals("index")
+      asserts("response status") { response.status }.equals(200)
+      asserts("response body") { response.body }.equals("foo")
+      asserts("request method") { request.request_method }.equals("GET")
+
+      context "response headers" do
+        setup { response.headers.keys }
+        asserts_topic.includes("Content-Type")
+        asserts_topic.includes("ETag")
+        asserts_topic.includes("Cache-Control")
+      end # response headers
+    end # without parameters
+
+    context "with parameters" do
+      setup { get "/rooms/echo_params", {:name => "Juiceton", :foo => "blaz"} }
+
+      asserts("action name") { action_name }.equals("echo_params")
+      asserts("response body") { response.body }.equals("controller=rooms,foo=blaz,name=Juiceton")
+    end # with with parameters
+
+  end # for a GET request
+
+end # RoomsController

data/test/action_controller/post_request_test.rb

@@ -0,0 +1,45 @@
+require 'teststrap'
+
+context RoomsController do
+
+  asserts("POSTs unknown action for existing controller") do
+    post "/rooms/blah"
+  end.raises(AbstractController::ActionNotFound, "The action 'blah' could not be found")
+
+  context "for a POST request" do
+    helper(:action_name) { env['action_dispatch.request.path_parameters'][:action] }
+
+    context "without parameters" do
+      setup { post "/rooms/create" }
+
+      asserts("request method") { request.request_method }.equals("POST")
+      asserts("action name") { action_name }.equals("create")
+      asserts("response status") { response.status }.equals(200)
+      asserts("response body") { response.body }.equals { "created #{controller.params.inspect}" }
+
+      context "response headers" do
+        setup { response.headers.keys }
+        asserts_topic.includes("Content-Type")
+        asserts_topic.includes("ETag")
+        asserts_topic.includes("Cache-Control")
+      end # response headers
+    end # without parameters
+
+    context "with parameters" do
+      setup { post "/rooms/create", {:momma => "loves you", "love_you_too" => "mom"} }
+
+      asserts("request method") { request.request_method }.equals("POST")
+      asserts("action name") { action_name }.equals("create")
+      asserts("response status") { response.status }.equals(200)
+
+      asserts("response body") { response.body }.equals do
+        "created #{controller.params.inspect}"
+      end
+
+      asserts("params") { controller.params }.includes("momma")
+      asserts("params") { controller.params }.includes("love_you_too")
+    end # with parameters
+
+  end # for a POST request
+
+end # RoomsController

data/test/action_controller/put_request_test.rb

@@ -0,0 +1,45 @@
+require 'teststrap'
+
+context RoomsController do
+
+  asserts("PUTs unknown action for existing controller") do
+    put "/rooms/blah"
+  end.raises(AbstractController::ActionNotFound, "The action 'blah' could not be found")
+
+  context "for a PUT request" do
+    helper(:action_name) { env['action_dispatch.request.path_parameters'][:action] }
+
+    context "without parameters" do
+      setup { put "/rooms/update" }
+
+      asserts("request method") { request.request_method }.equals("PUT")
+      asserts("action name") { action_name }.equals("update")
+      asserts("response status") { response.status }.equals(200)
+      asserts("response body") { response.body }.equals { "updated #{controller.params.inspect}" }
+
+      context "response headers" do
+        setup { response.headers.keys }
+        asserts_topic.includes("Content-Type")
+        asserts_topic.includes("ETag")
+        asserts_topic.includes("Cache-Control")
+      end # response headers
+    end # without parameters
+
+    context "with parameters" do
+      setup { put "/rooms/update", {:momma => "loves you", "love_you_too" => "mom"} }
+
+      asserts("request method") { request.request_method }.equals("PUT")
+      asserts("action name") { action_name }.equals("update")
+      asserts("response status") { response.status }.equals(200)
+
+      asserts("response body") { response.body }.equals do
+        "updated #{controller.params.inspect}"
+      end
+
+      asserts("params") { controller.params }.includes("momma")
+      asserts("params") { controller.params }.includes("love_you_too")
+    end # with parameters
+
+  end # for a PUT request
+
+end # RoomsController

data/test/action_controller/restful_delete_request_test.rb

@@ -0,0 +1,28 @@
+require 'teststrap'
+
+context "RESTful DELETE request on resource" do
+
+  context GremlinsController do
+    setup { delete("/gremlins/2") }
+
+    asserts("request method") { request.request_method }.equals("DELETE")
+    asserts("controller name") { controller.controller_name }.equals("gremlins")
+    asserts("action name") { controller.action_name }.equals("destroy")
+    asserts("id param") { controller.params["id"] }.equals("2")
+    asserts("response body") { response.body }.equals("spendin' money")
+  end # on a top level resource
+
+  context PartiesController do
+    setup { delete("/gremlins/2/parties/3", "foo" => "bar") }
+
+    asserts("request method") { request.request_method }.equals("DELETE")
+    asserts("controller name") { controller.controller_name }.equals("parties")
+    asserts("action name") { controller.action_name }.equals("destroy")
+
+    asserts("gremlin_id param") { controller.params["gremlin_id"] }.equals("2")
+    asserts("id param") { controller.params["id"] }.equals("3")
+    asserts("foo param") { controller.params["foo"] }.equals("bar")
+
+    asserts("response body") { response.body }.equals("all gone")
+  end # on a nested resource
+end # RESTful DELETE request

data/test/action_controller/restful_get_request_test.rb

@@ -0,0 +1,25 @@
+require 'teststrap'
+
+context "RESTful GET request on resource" do
+
+  context GremlinsController do
+    setup { get("/gremlins/1") }
+
+    asserts("request method") { request.request_method }.equals("GET")
+    asserts("controller name") { controller.controller_name }.equals("gremlins")
+    asserts("action name") { controller.action_name }.equals("show")
+    asserts("id param") { controller.params["id"] }.equals("1")
+    asserts("response body") { response.body }.equals("show me the money")
+  end # on a top level resource
+
+  context PartiesController do
+    setup { get("/gremlins/1/parties/2") }
+
+    asserts("request method") { request.request_method }.equals("GET")
+    asserts("controller name") { controller.controller_name }.equals("parties")
+    asserts("action name") { controller.action_name }.equals("show")
+    asserts("gremlin_id param") { controller.params["gremlin_id"] }.equals("1")
+    asserts("id param") { controller.params["id"] }.equals("2")
+    asserts("response body") { response.body }.equals("woot")
+  end # on a nested resource
+end # RESTful GET request