response_for_rails 0.4.0

data/spec/controllers/error_in_template_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module ErrorInTemplateSpec
+  class TestController < ApplicationController
+    response_for :action_rendering_erroneous_template do |format|
+      format.html { render :action => 'error_in_template' }
+    end
+    
+    def action_rendering_erroneous_template
+    end
+  end
+
+  describe TestController do
+    render_views
+    
+    it "GET :action_rendering_erroneous_template should raise \"Boom!\"" do
+      lambda { get :action_rendering_erroneous_template }.should raise_error("Boom!")
+    end
+  end
+end

data/spec/controllers/inherited_controllers_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+module InheritedControllerSpec
+  # example setup
+  class SuperController < ApplicationController
+    response_for :a_response do |format|
+      format.html { super_inside_a_response }
+    end
+    
+    def a_response
+    end
+    
+    def an_action
+      inside_an_action
+    end
+    
+    def performing_action
+      respond_to do |format|
+        format.html { redirect_to 'http://redirected.from.an_action_which_performs' }
+      end
+    end
+    
+  protected
+    def super_inside_a_response; end
+    def inside_an_action; end
+  end
+  
+  class SubController < SuperController
+    response_for :a_response do |format|
+      format.html { sub_inside_a_response }
+    end
+    
+    response_for :an_action do |format|
+      format.html do
+        redirect_to 'http://redirected.from.response_for'
+      end
+    end
+  
+    response_for :performing_action do |format|
+      never_reached_because_action_performs
+    end
+    
+  protected
+    def sub_inside_a_response; end
+  end
+  
+  # specs
+  describe "action_responses", :type => :spec do
+    it "SuperController.action_responses should not == SubController.action_responses" do
+      SuperController.action_responses.should_not == SubController.action_responses
+    end
+    
+    it "SuperController should have one action_response for 'a_response'" do
+      SuperController.action_responses.keys.should == ['a_response']
+      SuperController.action_responses['a_response'].size.should == 1
+    end
+    
+    it "SubController should have two action_responses for 'a_response', and one each for 'an_action', and 'performing_action'" do
+      SubController.action_responses.keys.sort.should == ['a_response', 'an_action', 'performing_action']
+      SubController.action_responses['a_response'].size.should == 2
+      SubController.action_responses['an_action'].size.should == 1
+      SubController.action_responses['performing_action'].size.should == 1
+    end
+  end
+  
+  describe SuperController do
+    describe "GET :an_action" do
+      
+      it "should execute action" do
+        @controller.should_receive :inside_an_action
+        get :an_action
+      end
+    
+      it "should render :an_action" do
+        get :an_action
+        response.should render_template('inherited_controller_spec/super/an_action')
+      end
+    end
+    
+    describe "GET :a_response" do
+      it "should execute inside the super response block" do
+        @controller.should_receive :super_inside_a_response
+        get :a_response
+      end
+      
+      it "should NOT execute inside the sub response block" do
+        @controller.should_not_receive :sub_inside_a_response
+        get :a_response
+      end
+    end
+    
+    describe "GET :performing_action" do
+      it "should redirect" do
+        get :performing_action
+        response.should redirect_to('http://redirected.from.an_action_which_performs')
+      end
+    end
+  end
+
+  describe SubController do
+    describe "GET :an_action (decorated with redirecting response_for)" do
+      it "should execute action" do
+        @controller.should_receive :inside_an_action
+        get :an_action
+      end
+    
+      it "should redirect" do
+        get :an_action
+        response.should redirect_to('http://redirected.from.response_for')
+      end
+    end
+    
+    describe "GET :a_response (decorated with a new response)" do
+      it "should NOT execute the super response" do
+        @controller.should_not_receive :super_inside_a_response
+        get :a_response
+      end
+
+      it "should execute the sub response" do
+        @controller.should_receive :sub_inside_a_response
+        get :a_response
+      end
+    end
+    
+    describe "GET :performing_action" do
+      it "should NOT execute the sub response" do
+        @controller.should_not_receive :never_reached_because_action_performs
+        get :performing_action
+      end
+      
+      it "should redirect as per the super def" do
+        get :performing_action
+        response.should redirect_to('http://redirected.from.an_action_which_performs')
+      end
+    end
+  end
+end

data/spec/controllers/no_response_if_performed_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module NoResponseIfPerformedSpec
+  # example setup
+  class TestController < ApplicationController
+    before_filter :do_redirect
+    
+    response_for :an_action do |format|
+      format.html { render :text => "in response for" }
+    end
+    
+    def an_action
+    end
+    
+  protected
+    def do_redirect
+      redirect_to 'http://redirected.from.before_filter'
+    end
+  end
+  
+  describe TestController do
+    describe "(when before_filter redirects)" do
+      it "GET :an_action should redirect to 'http://redirected.from.before_filter'" do
+        get :an_action
+        response.should redirect_to('http://redirected.from.before_filter')
+      end
+    end
+    
+    describe "(when before_filter doesn't redirect)" do
+      before do
+        @controller.stub!(:do_redirect)
+      end
+      
+      it "GET :an_action should execute inside response for" do
+        get :an_action
+        response.body.should == 'in response for'
+      end
+    end
+  end
+end

data/spec/controllers/pick_template_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+module PickTemplateSpec
+  # example setup
+  class TemplateOnlyController < ApplicationController
+  end
+
+  class RespondToTypesController < TemplateOnlyController
+    def an_action
+      respond_to :atom, :xml, :html, :js
+    end
+  end
+
+  class RespondToBlockController < TemplateOnlyController
+    def an_action
+      respond_to do |format|
+        format.atom
+        format.xml
+        format.html
+        format.js
+      end
+    end
+  end
+
+  class ResponseForTypesController < TemplateOnlyController
+    response_for :an_action, :types => [:atom, :xml, :html, :js]
+  end
+
+  class ResponseForBlockController < TemplateOnlyController
+    response_for :an_action do |format|
+      format.atom
+      format.xml
+      format.html
+      format.js
+    end
+  end
+
+  class ResponseForMixOfBlockAndTypesController < TemplateOnlyController
+    # response_for gives priority to most recent declarations, and
+    # gives priority of blocks over types.
+    response_for :an_action, :types => :js
+    response_for :an_action, :types => :html
+    response_for :an_action, :types => :xml do |format|
+      format.atom
+    end
+  end
+
+  class SuperclassController < TemplateOnlyController
+    response_for :an_action, :types => :js
+  end
+
+  class InheritedController < SuperclassController
+    response_for :an_action, :types => [:xml, :html] do |format|
+      format.atom
+    end
+  end
+  
+  # specs
+  shared_examples_for "Standard behaviour of respond_to :atom, :xml, :html, :js" do
+    it "GET :an_action, should render an_action.html" do
+      get :an_action
+      response.body.should == 'body of an_action.html'
+    end
+    
+    describe "GET :an_action, HTTP_ACCEPT =" do
+      it "text/html, should render an_action.html" do
+        request.env["HTTP_ACCEPT"] = 'text/html'
+        get :an_action
+        response.body.should == 'body of an_action.html'
+      end
+
+      it "application/xml, should render an_action.xml" do
+        request.env["HTTP_ACCEPT"] = 'application/xml'
+        get :an_action
+        response.body.should == 'body of an_action.xml'
+      end
+
+      it "text/javascript, should render an_action.js" do
+        request.env["HTTP_ACCEPT"] = 'text/javascript'
+        get :an_action
+        response.body.should == 'body of an_action.js'
+      end
+
+      it "application/atom+xml, should render an_action.atom" do
+        request.env["HTTP_ACCEPT"] = 'application/atom+xml'
+        get :an_action
+        response.body.should == 'body of an_action.atom'
+      end
+    end
+    
+    describe "GET :an_action, :format =>" do
+      it ":html, should render an_action.html" do
+        get :an_action, :format => 'html'
+        response.body.should == 'body of an_action.html'
+      end
+
+      it ":js, should render an_action.js" do
+        get :an_action, :format => 'js'
+        response.body.should == 'body of an_action.js'
+      end
+
+      it ":xml, should render an_action.xml" do
+        get :an_action, :format => 'xml'
+        response.body.should == 'body of an_action.xml'
+      end
+
+      it ":atom, should render an_action.atom" do
+        get :an_action, :format => 'atom'
+        response.body.should == 'body of an_action.atom'
+      end
+    end
+  end
+
+  describe "Picking template" do
+    render_views
+
+    describe TemplateOnlyController do
+      describe "GET :an_action, HTTP_ACCEPT =" do
+        it "text/html, should render an_action.html" do
+          request.env["HTTP_ACCEPT"] = 'text/html'
+          get :an_action
+          response.body.should == 'body of an_action.html'
+        end
+
+        it "application/xml, should render an_action.xml" do
+          request.env["HTTP_ACCEPT"] = 'application/xml'
+          get :an_action
+          response.body.should == 'body of an_action.xml'
+        end
+      end
+    end
+
+    describe "[:atom, :xml, :html, :js]" do
+      describe RespondToTypesController do
+        it_should_behave_like "Standard behaviour of respond_to :atom, :xml, :html, :js"
+      end
+
+      describe RespondToBlockController do
+        it_should_behave_like "Standard behaviour of respond_to :atom, :xml, :html, :js"
+      end
+
+      describe ResponseForTypesController do
+        it_should_behave_like "Standard behaviour of respond_to :atom, :xml, :html, :js"
+      end
+
+      describe ResponseForBlockController do
+        it_should_behave_like "Standard behaviour of respond_to :atom, :xml, :html, :js"
+      end
+
+      describe ResponseForMixOfBlockAndTypesController do
+        it_should_behave_like "Standard behaviour of respond_to :atom, :xml, :html, :js"
+      end
+  
+      describe InheritedController do
+        it_should_behave_like "Standard behaviour of respond_to :atom, :xml, :html, :js"
+      end
+    end
+  end
+end

data/spec/controllers/remove_response_for_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module RemoveResponseForSpec
+  class TheController < ApplicationController
+    response_for :foo, :bar, :types => :html
+    response_for :foo, :types => :js
+  end
+  
+  describe TheController do
+    it "should have action_responses for :foo and :bar" do
+      TheController.action_responses.keys.sort.should == ['bar', 'foo']
+    end
+    
+    describe ".remove_response_for :bar" do
+      before do
+        TheController.remove_response_for :bar
+      end
+      
+      it "should hanve action_responses for :foo" do
+        TheController.action_responses.keys.should == ['foo']
+      end
+    end
+    
+    describe ".remove_response_for" do
+      before do
+        TheController.remove_response_for
+      end
+      
+      it "should have empty action_responses" do
+        TheController.action_responses.should be_empty
+      end
+    end
+  end
+end

data/spec/controllers/responses_module_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module ResponsesModuleSpec
+  module MyActionsAndResponses
+    
+    def self.included(controller)
+      controller.class_eval do
+        def defined_by_included; end
+      end
+    end
+    
+    extend ResponseFor::ResponsesModule
+    
+    def foo; end
+    
+    response_for :foo do |format|
+      format.html {}
+    end
+  end
+  
+  class MyController < ApplicationController
+    include MyActionsAndResponses
+  end
+  
+  describe MyController do
+    it "should have action_response for :foo" do
+      @controller.class.action_responses['foo'].should_not == nil
+    end
+    
+    it "should have action :foo" do
+      @controller.should respond_to(:foo)
+    end
+    
+    it "should have method defined by included" do
+      @controller.should respond_to(:defined_by_included)
+    end
+  end
+end

data/spec/controllers/stacking_responses_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+# this spec shows how to stack responses - the important thing to note is that
+# once a format block is executed, that will stop all subsequent blocks of that
+# type being called.
+module StackingResponsesSpec
+  class TestController < ApplicationController
+    response_for :foo do |format|
+      format.html do
+        render :text => "default"
+      end
+    end
+    
+    response_for :foo do |format|
+      in_first
+      if params[:first]
+        format.html do
+          in_first_html
+          redirect_to 'http://first'
+        end
+      end
+    end
+    
+    response_for :foo do |format|
+      in_second
+      if params[:second]
+        format.html do
+          in_second_html
+          redirect_to 'http://second'
+        end
+      end
+    end
+    
+    def foo
+    end
+        
+  protected
+    def in_first; end
+    def in_first_html; end
+    def in_second; end
+    def in_second_html; end
+  end
+  
+  describe TestController, "with responses conditionally executed" do
+    describe "GET :foo (no conditions)" do
+      it "should execute second, then first, response" do
+        @controller.should_receive(:in_second).once.ordered
+        @controller.should_receive(:in_first).once.ordered
+        get :foo
+      end
+      
+      it "should NOT execute the html response in first" do
+        @controller.should_not_receive(:in_first_html)
+        get :foo
+      end
+      
+      it "should NOT execute the html response in second" do
+        @controller.should_not_receive(:in_second_html)
+        get :foo
+      end
+      
+      it "should render the default response" do
+        get :foo
+        response.body.should == "default"
+      end
+    end
+    
+    describe "GET :foo, :second => true" do
+      it "should execute second, then first, then html second, response" do
+        @controller.should_receive(:in_second).once.ordered
+        @controller.should_receive(:in_first).once.ordered
+        @controller.should_receive(:in_second_html).once.ordered
+        get :foo, :second => true
+      end
+
+      it "should redirect from second response" do
+        get :foo, :second => true
+        response.should redirect_to('http://second')
+      end
+
+      it "should NOT execute first html response" do
+        @controller.should_not_receive(:in_first_html)
+        get :foo, :second => true
+      end
+    end
+    
+    describe "GET :foo, :first => true" do
+      it "should execute second, then first, then first html response" do
+        @controller.should_receive(:in_second).once.ordered
+        @controller.should_receive(:in_first).once.ordered
+        @controller.should_receive(:in_first_html).once.ordered
+        get :foo, :first => true
+      end
+
+      it "should redirect from first response" do
+        get :foo, :first => true
+        response.should redirect_to('http://first')
+      end
+      
+      it "should NOT execute second html response" do
+        @controller.should_not_receive(:in_second_html)
+        get :foo, :first => true
+      end
+    end
+    
+    describe "GET :foo, :first => true, :second => true (can't execute two html blocks)" do
+      it "should execute second, then first, then second html response" do
+        @controller.should_receive(:in_second).once.ordered
+        @controller.should_receive(:in_first).once.ordered
+        @controller.should_receive(:in_second_html).once.ordered
+        get :foo, :first => true, :second => true
+      end
+
+      it "should redirect from second response" do
+        get :foo, :first => true, :second => true
+        response.should redirect_to('http://second')
+      end
+      
+      it "should NOT execute first html response" do
+        @controller.should_not_receive(:in_first_html)
+        get :foo, :first => true, :second => true
+      end
+    end
+  end
+end

data/spec/controllers/stop_at_respond_to_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module StopAtRespondToSpec
+  class TestController < ApplicationController
+    def index
+      respond_to do |format|
+        format.html do
+          @html = true
+        end
+        format.atom do
+          @atom = true
+        end
+      end
+    end
+  end
+
+  shared_examples_for "Standard respond_to behaviour" do
+    it "should render the respond_to html response" do
+      request.env["HTTP_ACCEPT"] = 'text/html'
+      get :index
+      assigns['html'].should == true
+      response.body.should =~ /body of index\.html\.erb/
+    end
+    
+    it "should render the respond_to atom response" do
+      request.env["HTTP_ACCEPT"] = 'application/atom+xml'
+      get :index
+      assigns['atom'].should == true
+      response.body.should =~ /body of index\.atom\.builder/
+    end
+  end
+  
+  describe TestController do
+    render_views
+    
+    it_should_behave_like "Standard respond_to behaviour"
+    
+    describe "with a redundant response_for" do
+      before do
+        # this should be ignored, because index has a respond_to
+        TestController.response_for :index do |format|
+          format.html
+          format.js
+          format.xml
+        end
+      end
+      
+      it_should_behave_like "Standard respond_to behaviour"
+    end      
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+ENV["RAILS_ENV"] ||= "test"
+require 'rails/all'
+require 'rspec'
+require 'rspec/rails'
+require File.expand_path('../../lib/response_for', __FILE__)
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures  = false
+end
+
+module ResponseForTest
+  class Application < Rails::Application
+    config.active_support.deprecation = :stderr
+    paths['config/database'] = File.expand_path('../app/database.yml', __FILE__)
+    paths['log'] = File.expand_path('../../../tmp/log', __FILE__)
+  end
+end
+
+class ApplicationController < ActionController::Base
+  self.view_paths = [File.expand_path('../app/views', __FILE__)]
+end
+  
+ResponseForTest::Application.initialize!
+Rails.application.routes.draw do
+  match '*controller/:action'
+end