coast 0.9.1 → 0.9.3

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Nathan Hopkins
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,186 @@
+# Coast
+
+## Providing resourceful behavior for [Rails controllers](http://guides.rubyonrails.org/action_controller_overview.html)
+
+![Coast GEM](http://hopsoft.github.com/coast/images/coast.png)
+
+### ...if only the REST of life were this easy
+
+Simply include the Coast module in your controller and get these actions for free.
+
+`new` `edit` `index` `show` `create` `update` `destroy`
+
+But wait... there's more.
+
+* **Lightweight** - about 200 lines of code... *you can grok it in 5 minutes by skimming lib/coast.rb*
+* **Unobtrusive** - no monkey patches
+* **Flexible** - support for html, xml, and json formats
+* **Familiar** - simple DSL for hooking into action callbacks
+* **Secure** - implicit authorization with your favorite libs... *such as [CanCan](https://github.com/ryanb/cancan)*
+
+### Works best when you stick to [Rails conventions](http://guides.rubyonrails.org/getting_started.html)
+
+## Quick-start for the lazy
+
+Assume you have a simple app structure for beach bums.
+
+```bash
+app/controllers/beach_bums_controller.rb
+app/models/beach_bum.rb
+```
+
+Install the GEM.
+
+```bash
+$gem install coast
+```
+
+Tweak some files.
+
+```ruby
+# config/routes.rb
+Beach::Application.routes.draw do
+  resources :beach_bums
+end
+```
+
+```ruby
+# app/controllers/beach_bums_controller.rb
+class BeachBumsController < ApplicationController
+  include Coast
+end
+```
+
+Congratulations... you now have a RESTful API for **beach bums**.
+
+## Callbacks
+
+Coast uses a [Sinatra](http://www.sinatrarb.com/) like DSL to provide hooks into the action lifecycle.
+
+The following hooks are supported for each action.
+
+* `before` *- before any other action logic is performed... just like a [Rails before_filter](http://guides.rubyonrails.org/action_controller_overview.html#filters)*
+* `respond_to` *- after authorization and db work but before rendering or redirecting*
+* `after` *- after all other action logic is performed... just like a [Rails after_filter](http://guides.rubyonrails.org/action_controller_overview.html#filters)*
+
+### How to use the callbacks
+
+```ruby
+# app/controllers/beach_bums_controller.rb
+class BeachBumsController < ApplicationController
+  include Coast
+
+  before :show do
+    # take control and load a 'beach_bum' instead of letting Coast do it for us
+    @resourceful_item = BeachBum.find(params[:id])
+
+    # Coast will implicitly create an @beach_bum variable that references @resourceful_item
+    # cool eh?
+  end
+
+  respond_to :show do
+    # take control of rendering or redirecting instead of letting Coast do it for us
+    render :text => "Out surfing."
+  end
+
+  after :show do
+    # do some last minute housekeeping after every thing else is done
+    Rails.logger.info "Hey brah... we just completed the show action."
+  end
+
+end
+```
+
+## Authorization
+
+Coast implicitly calls an authorize method prior to executing any action logic.
+
+You have complete control over this method. Here's an example.
+
+```ruby
+# app/controllers/beach_bums_controller.rb
+class BeachBumsController < ApplicationController
+  include Coast
+  set_authorize_method :authorize
+
+  def authorize(action, data, request)
+    # restrict all RESTful actions
+    raise "Unauthorized"
+  end
+
+  rescue_from Exception do |ex|
+    render :text => "Not Allowed", :status => 401
+  end
+end
+```
+
+Note the authorize method signature. The first arg is the **action** being performed. The second arg is the **record(s)** being operated on. The last arg is the **request** object.
+
+While originally written to support [CanCan](https://github.com/ryanb/cancan), its pretty simple to take control and manage authorization yourself.
+
+## Advanced Usage
+
+Coast comes with few tricks up its sleeve.
+
+If your model and controller names deviate from Rails conventions, you can explicitly set the model like so.
+
+```ruby
+# app/controllers/beach_bums_controller.rb
+class BeachBumsController < ApplicationController
+  include Coast
+  set_resourceful_model SurferDude
+end
+```
+
+You can conditionally prevent mutating behavior on the server by setting an instance variable like so. *It's a little arcane, but that's on purpose.*
+
+```ruby
+# app/controllers/beach_bums_controller.rb
+class BeachBumsController < ApplicationController
+  include Coast
+
+  before :create do
+    # prevent the user from actually creating a record
+    @skip_db_create = true
+  end
+
+  before :update do
+    # prevent the user from actually saving a record
+    @skip_db_update = true
+  end
+
+  before :destroy do
+    # prevent the user from actually destroying a record
+    @skip_db_destroy = true
+  end
+
+end
+```
+
+## Testing
+
+There are some interesting additions to MiniTest::Mock since I mock some of Rails to make testing fast & fun.
+
+Poke around the test code and let me know what you think.
+
+How to run the tests.
+
+```bash
+$rvm 1.9.3
+$gem install bundler
+$bundle
+$rake test
+```
+
+Ahh... passing tests.
+
+## Contributing
+
+I'm looking for hand-outs, so please fork and submit pull requests. Bug fixes, features, whatever...
+
+## Nods
+
+[I'm tired of writing RESTful boilerplate (& scaffold is overkill), so I'm stoked natehop released the Coast gem.](https://twitter.com/tehviking/status/189739333857710080)
+
+-- Brandon Hayes, April 10, 2012
+

data/lib/coast.rb

@@ -1,3 +1,8 @@
+require "rubygems"
+require "bundler"
+Bundler.require :default
+require File.join(File.dirname(__FILE__), "coast", "version")
+
 # Makes any controller resourceful by providing the following actions:
 # * new
 # * edit
@@ -32,6 +37,14 @@
 module Coast
 
   module ClassMethods
+    def set_localized(arg)
+      @set_localized = arg
+    end
+    alias :localized= :set_localized
+
+    def localized?
+      @set_localized
+    end
 
     def set_authorize_method(arg)
       @authorize_method = arg
@@ -155,7 +168,7 @@ module Coast
     unless performed?
       respond_to do |format|
         if success
-          flash[:notice] = "#{resourceful_model.name} was successfully created."
+          write_to_flash :notice, "#{resourceful_model.name} was successfully created."
           format.html { redirect_to(@resourceful_item) }
           format_json_and_xml(format, @resourceful_item, :status => :created, :location => @resourceful_item)
         else
@@ -177,7 +190,7 @@ module Coast
     unless performed?
       respond_to do |format|
         if success
-          flash[:notice] = "#{resourceful_model.name} was successfully updated."
+          write_to_flash :notice, "#{resourceful_model.name} was successfully updated."
           format.html { redirect_to(@resourceful_item) }
           format_json_and_xml(format, @resourceful_item)
         else
@@ -197,7 +210,7 @@ module Coast
     @resourceful_item.destroy unless @skip_db_destroy
     invoke_callback(:respond_to_destroy)
     unless performed?
-      flash[:notice] = "#{resourceful_model.name} was successfully destroyed" if @resourceful_item.destroyed?
+      write_to_flash(:notice, "#{resourceful_model.name} was successfully destroyed.") if @resourceful_item.destroyed?
       respond_to do |format|
         format.html { redirect_to root_url }
         format_json_and_xml(format, @resourceful_item)
@@ -233,6 +246,15 @@ module Coast
 
   private
 
+  def write_to_flash(key, message)
+    if self.class.localized?
+      message_key = message.downcase.strip.gsub(/\W+$/, "").gsub(/\W/, "_")
+      flash[key] = I18n.translate(message_key)
+    else
+      flash[key] = message
+    end
+  end
+
   def invoke_callback(name)
     send(name) if respond_to?(name)
   end

data/lib/coast/version.rb

@@ -0,0 +1,3 @@
+module Coast
+  VERSION = "0.9.3"
+end

data/test/test_coast.rb

@@ -0,0 +1,248 @@
+require "rubygems"
+require "bundler"
+Bundler.require(:default, :test)
+require "active_support/all"
+require File.join(File.dirname(__FILE__), "..", "lib", "coast")
+
+class TestCoast < MicroTest::Test
+
+  RESTFUL_METHODS = %w(index show new edit create update destroy)
+  ITEM_METHODS    = %w(show new edit create update destroy)
+  UI_METHODS      = %w(new edit)
+  READ_METHODS    = %w(index show)
+  MUTATE_METHODS  = %w(create update destroy)
+
+  # Creates a mock model instance [ActiveRecord::Base].
+  def self.mock_model
+    mock = MicroMock.make.new
+    mock.stub(:destroy) { @destroyed = true }
+    mock.stub(:destroyed?) { @destroyed }
+    mock.stub(:update_attributes) { |*args| @attributes_updated = true }
+    mock.stub(:save) { |*args| @saved = true }
+    mock.stub(:table_name) { "mocks" }
+    mock.class.stub(:find) { |*args| TestCoast.mock_model }
+    mock.class.stub(:all) { [1..5].map { TestCoast.mock_model } }
+    mock
+  end
+
+  # Creates a mock request instance [ActionDispatch::Request].
+  def self.mock_request
+    mock = MicroMock.make.new
+    mock.stub(:request) { @request ||= MicroMock.make.new }
+    mock.stub(:params) { @params ||= {} }
+    mock.stub(:flash) { @flash ||= {} }
+    mock
+  end
+
+  # Creates a mock controller instance [ActionController::Base].
+  def self.mock_controller
+    mock = MicroMock.make.new
+    mock.class.send :include, Coast
+    mock.stub(:authorize!) { |*args| @authorize_invoked = true }
+    mock.stub(:authorize_invoked?) { @authorize_invoked }
+    mock.stub(:respond_to) { |&block| @responded = true; block.call(format) }
+    mock.stub(:responded?) { @responded }
+    mock.stub(:render) { |*args| @performed = @rendered = true }
+    mock.stub(:performed?) { @performed }
+    mock.stub(:rendered?) { @rendered }
+    mock.stub(:redirect_to) { |*args| @redirected = true; render }
+    mock.stub(:redirected?) { @redirected }
+    mock.stub(:request) { @request ||= TestCoast.mock_request }
+    mock.stub(:params) { request.params }
+    mock.stub(:flash) { request.flash }
+    mock.stub(:format) { @format ||= TestCoast.mock_format }
+    mock.stub(:root_url) { "/" }
+    mock
+  end
+
+  # Creates a mock format instance [ActionController::MimeResponds::Collector].
+  def self.mock_format
+    mock = MicroMock.make.new
+    mock.stub(:html) { |&block| @html = true; block.call if block }
+    mock.stub(:xml) { |&block| @xml = true; block.call if block }
+    mock.stub(:json) { |&block| @json = true; block.call if block }
+    mock
+  end
+
+  before do
+    @model = TestCoast.mock_model
+    @controller = TestCoast.mock_controller
+    @controller.class.set_resourceful_model @model.class
+  end
+
+  test ".set_localized" do
+    @controller.class.set_localized true
+    assert @controller.class.localized?
+  end
+
+  test ".localized=" do
+    @controller.class.localized = true
+    assert @controller.class.localized?
+  end
+
+  test ".set_authorize_method" do
+    @controller.class.set_authorize_method :authorize!
+    assert @controller.class.authorize_method == :authorize!
+  end
+
+  test ".authorize=" do
+    @controller.class.authorize_method = :authorize!
+    assert @controller.class.authorize_method == :authorize!
+  end
+
+  test ".set_resourceful_model" do
+    model = Object.new
+    @controller.class.set_resourceful_model model
+    assert @controller.class.resourceful_model == model
+  end
+
+  test ".resourceful_model=" do
+    model = Object.new
+    @controller.class.resourceful_model = model
+    assert @controller.class.resourceful_model == model
+  end
+
+  test "set before callbacks" do
+    RESTFUL_METHODS.each do |method|
+      assert !@controller.respond_to?("before_#{method}")
+      @controller.class.before(method) {}
+      assert @controller.respond_to?("before_#{method}")
+    end
+  end
+
+  test "set respond_to callbacks" do
+    RESTFUL_METHODS.each do |method|
+      assert !@controller.respond_to?("respond_to_#{method}")
+      @controller.class.respond_to(method) {}
+      assert @controller.respond_to?("respond_to_#{method}")
+    end
+  end
+
+  test "set after callbacks" do
+    RESTFUL_METHODS.each do |method|
+      assert !@controller.respond_to?("after_#{method}")
+      @controller.class.after(method) {}
+      assert @controller.respond_to?("after_#{method}")
+    end
+  end
+
+  test "RESTful methods exist" do
+    RESTFUL_METHODS.each do |method|
+      assert @controller.respond_to?(method)
+    end
+  end
+
+  test "<create> flash message" do
+    @controller.create
+    assert @controller.flash[:notice].ends_with?("was successfully created.")
+  end
+
+  test "<create> localized flash message" do
+    @controller.class.localized = true
+    @controller.create
+    assert @controller.flash[:notice] =~ /translation missing: .+was_successfully_created/
+  end
+
+  test "<update> flash message" do
+    @controller.update
+    assert @controller.flash[:notice].ends_with?("was successfully updated.")
+  end
+
+  test "<update> localized flash message" do
+    @controller.class.localized = true
+    @controller.update
+    assert @controller.flash[:notice] =~ /translation missing: .+was_successfully_updated/
+  end
+
+  test "<destroy> flash message" do
+    @controller.destroy
+    assert @controller.flash[:notice].ends_with?("was successfully destroyed.")
+  end
+
+  test "<destroy> localized flash message" do
+    @controller.class.localized = true
+    @controller.destroy
+    assert @controller.flash[:notice] =~ /translation missing: .+was_successfully_destroyed/
+  end
+
+  RESTFUL_METHODS.each do |method|
+
+    test "<#{method}> responds and renders" do
+      @controller.send(method)
+      assert @controller.responded?
+      assert @controller.rendered?
+    end
+
+    test "<#{method}> renders for the formats html, xml, json" do
+      @controller.send(method)
+      assert(@controller.format.instance_eval { @html })
+      assert(@controller.format.instance_eval { @xml })
+      assert(@controller.format.instance_eval { @json })
+    end
+
+    test "<#{method}> invokes before, respond_to, after callbacks" do
+      callbacks = []
+      @controller.class.before(method) { callbacks << :before }
+      @controller.class.respond_to(method) { callbacks << :respond_to }
+      @controller.class.after(method) { callbacks << :after }
+      @controller.send(method)
+      assert callbacks.include?(:before)
+      assert callbacks.include?(:respond_to)
+      assert callbacks.include?(:after)
+    end
+
+    test "<#{method}> allows :respond_to callback to perform the render" do
+      @controller.class.respond_to(method) { @performed = true }
+      @controller.send(method)
+      assert @controller.performed?
+      assert !@controller.responded?
+    end
+
+    test "<#{method}> invokes the authorize_method when set" do
+      @controller.class.authorize_method = :authorize!
+      @controller.send(method)
+      assert @controller.authorize_invoked?
+    end
+
+  end
+
+  ITEM_METHODS.each do |method|
+    test "<#{method}> allows :before callback to set the resourceful_item" do
+      item = TestCoast.mock_model
+      @controller.class.before(method) { @resourceful_item = item }
+      @controller.send(method)
+      assert @controller.instance_eval { @resourceful_item.object_id } == item.object_id
+    end
+
+    test "<#{method}> sets a custom named instance variable for the item" do
+      item = TestCoast.mock_model
+      @controller.class.before(method) { @resourceful_item = item }
+      @controller.send(method)
+      variable = @controller.instance_eval { instance_variable_get(item_instance_var_name) }
+      assert variable.object_id == item.object_id
+    end
+  end
+
+  MUTATE_METHODS.each do |method|
+    test "<#{method}> redirects" do
+      @controller.send(method)
+      assert @controller.redirected?
+    end
+  end
+
+  test "<index> allows :before callback to set the list" do
+    list = TestCoast.mock_model.class.all
+    @controller.class.before(:index) { @resourceful_list = list }
+    @controller.index
+    assert @controller.instance_eval{ @resourceful_list }.object_id == list.object_id
+  end
+
+  test "<index> sets a custom named instance variable for the item" do
+    list = TestCoast.mock_model.class.all
+    @controller.class.before(:index) { @resourceful_list = list }
+    @controller.index
+    variable = @controller.instance_eval { instance_variable_get(list_instance_var_name) }
+    assert variable.object_id == list.object_id
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coast
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-06 00:00:00.000000000 Z
+date: 2012-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2160361220 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,16 +21,104 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2160361220
-description: Resourceful behavior for Rails controllers with a Sinatra like DSL.
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: micro_test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0.rc4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0.rc4
+- !ruby/object:Gem::Dependency
+  name: micro_mock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Resourceful behavior for Rails controllers with a simple DSL.
 email:
-- nate.hop@gmail.com
+- natehop@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/coast.rb
-- spec/coast_spec.rb
+- lib/coast/version.rb
+- LICENSE.txt
+- README.md
+- test/test_coast.rb
 homepage: https://github.com/hopsoft/coast
 licenses:
 - MIT
@@ -52,9 +140,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Coast
+summary: A small mixin for Rails controllers that provides restful behavior.
 test_files:
-- spec/coast_spec.rb
+- test/test_coast.rb
+has_rdoc: 

data/spec/coast_spec.rb

@@ -1,245 +0,0 @@
-require "rubygems"
-
-# fix MiniTest issue with 1.9
-unless defined? Gem::Deprecate
-  module Gem
-    Deprecate = Module.new do
-      include Deprecate
-    end
-  end
-end
-
-require "bundler/setup"
-require "minitest/autorun"
-require "active_support/all"
-require "turn"
-require "pry"
-
-dirname = File.dirname(__FILE__)
-require File.join(dirname, "mock")
-Dir.glob(File.join(dirname, "..", "lib", "*.rb")) { |f| require f }
-MODEL_PATH = File.join(dirname, "testable_model.rb")
-CONTROLLER_PATH = File.join(dirname, "testable_controller.rb")
-load MODEL_PATH
-load CONTROLLER_PATH
-
-
-
-
-describe Coast do
-  RESTFUL_METHODS = %w(index show new edit create update destroy)
-  ITEM_METHODS    = %w(show new edit create update destroy)
-  UI_METHODS      = %w(new edit)
-  READ_METHODS    = %w(index show)
-  MUTATE_METHODS  = %w(create update destroy)
-
-  # Resets the mock class defs.
-  def reset
-    Coast.send(:remove_const, :TestableController)
-    Coast.send(:remove_const, :TestableModel)
-    load MODEL_PATH
-    load CONTROLLER_PATH
-    Coast::TestableController.set_resourceful_model Coast::TestableModel
-  end
-
-  # class method tests ============================================================================
-
-  describe :set_authorize_method do
-    it "sets the method used to perform authorization checks" do
-      reset
-      Coast::TestableController.set_authorize_method :authorize!
-      assert Coast::TestableController.authorize_method == :authorize!
-    end
-  end
-
-  describe :authorize_method= do
-    it "sets the method used to perform authorization checks" do
-      reset
-      Coast::TestableController.authorize_method = :authorize!
-      assert Coast::TestableController.authorize_method == :authorize!
-    end
-  end
-
-  describe :set_resourceful_model do
-    it "sets the model that the controller manages" do
-      reset
-      model = Object.new
-      Coast::TestableController.set_resourceful_model model
-      assert Coast::TestableController.resourceful_model == model
-    end
-  end
-
-  describe :resourceful_model= do
-    it "sets the model that the controller manages" do
-      reset
-      model = Object.new
-      Coast::TestableController.resourceful_model = model
-      assert Coast::TestableController.resourceful_model == model
-    end
-  end
-
-  def verify_callback_setter(event, action)
-    reset
-    Coast::TestableController.send(event, action, &(lambda {}))
-    assert Coast::TestableController.new.respond_to?("#{event}_#{action}")
-  end
-
-  describe :before do
-    it "stores a before callback for all RESTful actions" do
-      RESTFUL_METHODS.each { |m| verify_callback_setter :before, m }
-    end
-  end
-
-  describe :respond_to do
-    it "stores a respond_to callback for all RESTful actions" do
-      RESTFUL_METHODS.each { |m| verify_callback_setter :respond_to, m }
-    end
-  end
-
-  describe :after do
-    it "stores an after callback for all RESTful actions" do
-      RESTFUL_METHODS.each { |m| verify_callback_setter :after, m }
-    end
-  end
-
-
-
-
-
-
-
-
-
-
-
-  # instance method tests =========================================================================
-
-
-  it "supports all RESTful methods" do
-    reset
-    controller = Coast::TestableController.new
-    RESTFUL_METHODS.each { |m| controller.must_respond_to m }
-  end
-
-  # %w(index show new).each do |method|
-  RESTFUL_METHODS.each do |method|
-    describe "##{method}" do
-      before do
-        reset
-      end
-
-      it "responds and renders" do
-        controller = Coast::TestableController.new
-        controller.send(method)
-        assert controller.responded?, "Did not respond"
-        assert controller.rendered?, "Did not render"
-      end
-
-      it "renders for the formats html, xml, json" do
-        controller = Coast::TestableController.new
-        controller.send(method)
-        assert controller.html, "Did not respond to the html format"
-        assert controller.xml, "Did not respond to the xml format"
-        assert controller.json, "Did not respond to the json format"
-      end
-
-      it "invokes the callbacks before, respond_to, after" do
-        callbacks = []
-
-        Coast::TestableController.class_eval do
-          before(method) { callbacks << :before }
-          respond_to(method) { callbacks << :respond_to }
-          after(method) { callbacks << :after }
-        end
-
-        controller = Coast::TestableController.new
-        controller.send(method)
-        assert callbacks.include?(:before), "Did not invoke the before callback"
-        assert callbacks.include?(:respond_to), "Did not invoke the respond_to callback"
-        assert callbacks.include?(:after), "Did not invoke the after callback"
-      end
-
-      it "allows :respond_to callback to perform the render" do
-        Coast::TestableController.respond_to(method) { @performed = true }
-        controller = Coast::TestableController.new
-        controller.send(method)
-        assert controller.responded? == false, "Did not allow :respond_to callback to perform the render"
-      end
-
-      it "invokes the authorize_method when set" do
-        Coast::TestableController.authorize_method = :authorize!
-        controller = Coast::TestableController.new
-        controller.send(:index)
-        assert controller.authorize_invoked?, "Did not invoke the authorize_method"
-      end
-
-    end
-  end
-
-  ITEM_METHODS.each do |method|
-    describe "##{method}" do
-      before do
-        reset
-      end
-
-      it "allows :before callback to set the item" do
-        item = Object.new
-        Coast::TestableController.before(:index) { @resourceful_item = item }
-        controller = Coast::TestableController.new
-        controller.index
-        assert controller.instance_eval { @resourceful_item } == item, "Did not allow :before callback to set the resourceful_item"
-      end
-
-      it "sets a custom named instance variable for the item" do
-        item = Object.new
-        Coast::TestableController.before(:index) { @resourceful_item = item }
-        controller = Coast::TestableController.new
-        controller.index
-        variable = controller.instance_eval { instance_variable_get(item_instance_var_name) }
-        assert variable != nil, "Did not set a custom instance variable for the item"
-        assert variable == item, "Did not set a custom instance variable for the item to the correct value"
-      end
-
-    end
-  end
-
-  MUTATE_METHODS.each do |method|
-    describe "##{method}" do
-      before do
-        reset
-      end
-
-      it "redirects" do
-        controller = Coast::TestableController.new
-        controller.send(method)
-        assert controller.redirected?, "Did not redirect"
-      end
-    end
-  end
-
-
-  describe "#index" do
-    before do
-      reset
-    end
-
-    it "allows :before callback to set the list" do
-      list = [ Object.new ]
-      Coast::TestableController.before(:index) { @resourceful_list = list }
-      controller = Coast::TestableController.new
-      controller.index
-      assert controller.instance_eval { @resourceful_list } == list, "Did not allow :before callback to set the resourceful_list"
-    end
-
-    it "sets a custom named instance variable for the item" do
-      list = [ Object.new ]
-      Coast::TestableController.before(:index) { @resourceful_list = list }
-      controller = Coast::TestableController.new
-      controller.index
-      variable = controller.instance_eval { instance_variable_get(list_instance_var_name) }
-      assert variable != nil, "Did not set a custom instance variable for the item"
-      assert variable == list, "Did not set a custom instance variable for the item to the correct value"
-    end
-  end
-
-end