hubbub 0.0.6

data/lib/vendor/plugins/make_resourceful/spec/responses_spec.rb

@@ -0,0 +1,314 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Resourceful::Default::Responses', " with a _flash parameter for :error" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Responses
+    @flash = {}
+    @controller.stubs(:flash).returns(@flash)
+    @params = {:_flash => {:error => 'Oh no, an error!'}}
+    @controller.stubs(:params).returns(@params)
+  end
+
+  it "should set the flash for :error to the parameter's value when set_default_flash is called on :error" do
+    @controller.set_default_flash(:error, "Aw there's no error!")
+    @flash[:error].should == 'Oh no, an error!'
+  end
+
+  it "should set the flash for :message to the default value when set_default_flash is called on :message" do
+    @controller.set_default_flash(:message, "All jim dandy!")
+    @flash[:message].should == 'All jim dandy!'
+  end
+
+  it "shouldn't set the flash for :error when set_default_flash is called on :message" do
+    @controller.set_default_flash(:message, "All jim dandy!")
+    @flash[:error].should be_nil
+  end
+end
+
+describe 'Resourceful::Default::Responses', " with a _redirect parameter on :failure" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Responses
+    @params = {:_redirect_on => {:failure => 'http://hamptoncatlin.com/'}}
+    @controller.stubs(:params).returns(@params)
+  end
+
+  it "should set the redirect for :failure to the parameter's value when set_default_redirect is called on :failure" do
+    @controller.expects(:redirect_to).with('http://hamptoncatlin.com/')
+    @controller.set_default_redirect(:back, :status => :failure)
+  end
+
+  it "should set the redirect for :success to the default value when set_default_redirect is called on :success" do
+    @controller.expects(:redirect_to).with(:back)
+    @controller.set_default_redirect(:back, :status => :success)
+  end
+
+  it "shouldn't set the redirect for :failure when set_default_redirect is called on :success" do
+    @controller.expects(:redirect_to).with(:back)
+    @controller.expects(:redirect_to).with('http://hamptoncatlin.com/').never
+    @controller.set_default_redirect(:back, :status => :success)
+  end
+
+  it "should set the default redirect for :success by default" do
+    @controller.expects(:redirect_to).with(:back)
+    @controller.set_default_redirect(:back)
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for show' do
+  include ControllerMocks
+  before :each do
+    mock_kontroller
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+  end
+
+  it "should have an empty HTML response" do
+    responses[:show].find { |f, p| f == :html }[1].call.should == nil
+  end
+
+  it "should have an empty JS response" do
+    responses[:show].find { |f, p| f == :js }[1].call.should == nil
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for index' do
+  include ControllerMocks
+  before :each do
+    mock_kontroller
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+  end
+
+  it "should have an empty HTML response" do
+    responses[:index].find { |f, p| f == :html }[1].call.should == nil
+  end
+
+  it "should have an empty JS response" do
+    responses[:index].find { |f, p| f == :js }[1].call.should == nil
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for edit' do
+  include ControllerMocks
+  before :each do
+    mock_kontroller
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+  end
+
+  it "should have an empty HTML response" do
+    responses[:edit].find { |f, p| f == :html }[1].call.should == nil
+  end
+
+  it "should have an empty JS response" do
+    responses[:edit].find { |f, p| f == :js }[1].call.should == nil
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for new' do
+  include ControllerMocks
+  before :each do
+    mock_kontroller
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+  end
+
+  it "should have an empty HTML response" do
+    responses[:new].find { |f, p| f == :html }[1].call.should == nil
+  end
+
+  it "should have an empty JS response" do
+    responses[:new].find { |f, p| f == :js }[1].call.should == nil
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for show_fails' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+  end
+
+  it "should give a 404 error for HTML" do
+    @controller.expects(:render).with(:text => "No item found", :status => 404)
+    @controller.scope(responses[:show_fails].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should give a 404 error for JS" do
+    @controller.expects(:render).with(:text => "No item found", :status => 404)
+    @controller.scope(responses[:show_fails].find { |f, p| f == :js }[1]).call
+  end
+
+  it "should give a 404 error for XML" do
+    @controller.expects(:render).with(:text => "No item found", :status => 404)
+    @controller.scope(responses[:show_fails].find { |f, p| f == :xml }[1]).call
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for create' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+
+    [:set_default_flash, :set_default_redirect, :object_path].each(&@controller.method(:stubs))
+  end
+
+  it "should have an empty JS response" do
+    responses[:create].find { |f, p| f == :js }[1].call.should == nil
+  end
+
+  it "should flash a success message to :notice by default for HTML" do
+    @controller.expects(:set_default_flash).with(:notice, "Create successful!")
+    @controller.scope(responses[:create].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should redirect to object_path by default for HTML" do
+    @controller.stubs(:object_path).returns("/posts/12")
+    @controller.expects(:set_default_redirect).with("/posts/12")
+    @controller.scope(responses[:create].find { |f, p| f == :html }[1]).call
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for create_fails' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+
+    [:set_default_flash, :render].each(&@controller.method(:stubs))
+  end
+
+  it "should have an empty JS response" do
+    responses[:create_fails].find { |f, p| f == :js }[1].call.should == nil
+  end
+
+  it "should flash a failure message to :error by default for HTML" do
+    @controller.expects(:set_default_flash).with(:error, "There was a problem!")
+    @controller.scope(responses[:create_fails].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should render new with a 422 error for HTML" do
+    @controller.expects(:render).with(:action => :new, :status => 422)
+    @controller.scope(responses[:create_fails].find { |f, p| f == :html }[1]).call
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for update' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+
+    [:set_default_flash, :set_default_redirect, :object_path].each(&@controller.method(:stubs))
+  end
+
+  it "should have an empty JS response" do
+    responses[:update].find { |f, p| f == :js }[1].call.should == nil
+  end
+
+  it "should flash a success message to :notice by default for HTML" do
+    @controller.expects(:set_default_flash).with(:notice, "Save successful!")
+    @controller.scope(responses[:update].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should redirect to object_path by default for HTML" do
+    @controller.stubs(:object_path).returns("/posts/12")
+    @controller.expects(:set_default_redirect).with("/posts/12")
+    @controller.scope(responses[:update].find { |f, p| f == :html }[1]).call
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for update_fails' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+
+    [:set_default_flash, :render].each(&@controller.method(:stubs))
+  end
+
+  it "should have an empty JS response" do
+    responses[:update_fails].find { |f, p| f == :js }[1].call.should == nil
+  end
+
+  it "should flash a failure message to :error by default for HTML" do
+    @controller.expects(:set_default_flash).with(:error, "There was a problem saving!")
+    @controller.scope(responses[:update_fails].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should render edit with a 422 error for HTML" do
+    @controller.expects(:render).with(:action => :edit, :status => 422)
+    @controller.scope(responses[:update_fails].find { |f, p| f == :html }[1]).call
+  end
+end
+
+
+describe 'Resourceful::Default::Responses', ' for destroy' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+
+    [:set_default_flash, :set_default_redirect, :objects_path].each(&@controller.method(:stubs))
+  end
+
+  it "should have an empty JS response" do
+    responses[:destroy].find { |f, p| f == :js }[1].call.should == nil
+  end
+
+  it "should flash a success message to :notice by default for HTML" do
+    @controller.expects(:set_default_flash).with(:notice, "Record deleted!")
+    @controller.scope(responses[:destroy].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should redirect to objects_path by default for HTML" do
+    @controller.stubs(:objects_path).returns("/posts")
+    @controller.expects(:set_default_redirect).with("/posts")
+    @controller.scope(responses[:destroy].find { |f, p| f == :html }[1]).call
+  end
+end
+
+describe 'Resourceful::Default::Responses', ' for destroy_fails' do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    create_builder
+    made_resourceful(Resourceful::Default::Responses)
+    @builder.apply
+
+    [:set_default_flash, :set_default_redirect, :render].each(&@controller.method(:stubs))
+  end
+
+  it "should have an empty JS response" do
+    responses[:destroy_fails].find { |f, p| f == :js }[1].call.should == nil
+  end
+
+  it "should flash a failure message to :error by default for HTML" do
+    @controller.expects(:set_default_flash).with(:error, "There was a problem deleting!")
+    @controller.scope(responses[:destroy_fails].find { |f, p| f == :html }[1]).call
+  end
+
+  it "should redirect back on failure by default for HTML" do
+    @controller.expects(:set_default_redirect).with(:back, :status => :failure)
+    @controller.scope(responses[:destroy_fails].find { |f, p| f == :html }[1]).call
+  end
+end

data/lib/vendor/plugins/make_resourceful/spec/rspec-rails/redirect_to.rb

@@ -0,0 +1,113 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class RedirectTo  #:nodoc:
+
+        def initialize(request, expected)
+          @expected = expected
+          @request = request
+        end
+
+        def matches?(response)
+          @redirected = response.redirect?
+          @actual = response.redirect_url
+          return false unless @redirected
+          if @expected.instance_of? Hash
+            return false unless @actual =~ %r{^\w+://#{@request.host}}
+            return false unless actual_redirect_to_valid_route
+            return actual_hash == expected_hash
+          else
+            return @actual == expected_url
+          end
+        end
+
+        def actual_hash
+          hash_from_url @actual
+        end
+
+        def expected_hash
+          hash_from_url expected_url
+        end
+
+        def actual_redirect_to_valid_route
+          actual_hash
+        end
+
+        def hash_from_url(url)
+          query_hash(url).merge(path_hash(url)).with_indifferent_access
+        end
+
+        def path_hash(url)
+          path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
+          ActionController::Routing::Routes.recognize_path path
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          QueryParameterParser.parse_query_parameters(query, @request)
+        end
+
+       def expected_url
+          case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+            when :back
+              return @request.env['HTTP_REFERER']
+            when %r{^\w+://.*}
+              return @expected
+            else
+              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+          end
+        end
+
+        def failure_message
+          if @redirected
+            return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+          else
+            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+          end
+        end
+
+        def negative_failure_message
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+        end
+
+        def description
+          "redirect to #{@actual.inspect}"
+        end
+
+        class QueryParameterParser
+          def self.parse_query_parameters(query, request)
+            if defined?(CGIMethods)
+              CGIMethods.parse_query_parameters(query)
+            else
+              request.class.parse_query_parameters(query)
+            end
+          end
+        end
+      end
+
+      # :call-seq:
+      #   response.should redirect_to(url)
+      #   response.should redirect_to(:action => action_name)
+      #   response.should redirect_to(:controller => controller_name, :action => action_name)
+      #   response.should_not redirect_to(url)
+      #   response.should_not redirect_to(:action => action_name)
+      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+      #
+      # Passes if the response is a redirect to the url, action or controller/action.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # == Examples
+      #
+      #   response.should redirect_to("path/to/action")
+      #   response.should redirect_to("http://test.host/path/to/action")
+      #   response.should redirect_to(:action => 'list')
+      def redirect_to(opts)
+        RedirectTo.new(request, opts)
+      end
+    end
+
+  end
+end

data/lib/vendor/plugins/make_resourceful/spec/rspec-rails/render_template.rb

@@ -0,0 +1,90 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class RenderTemplate #:nodoc:
+    
+        def initialize(expected, controller)
+          @controller = controller
+          @expected = expected
+        end
+      
+        def matches?(response)
+          
+          if response.respond_to?(:rendered_file)
+            @actual = response.rendered_file
+          else
+            @actual = response.rendered_template.to_s
+          end
+          return false if @actual.blank?
+          given_controller_path, given_file = path_and_file(@actual)
+          expected_controller_path, expected_file = path_and_file(@expected)
+          given_controller_path == expected_controller_path && given_file.match(expected_file)
+        end
+        
+        def failure_message
+          "expected #{@expected.inspect}, got #{@actual.inspect}"
+        end
+        
+        def negative_failure_message
+          "expected not to render #{@expected.inspect}, but did"
+        end
+        
+        def description
+          "render template #{@expected.inspect}"
+        end
+      
+        private
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? current_controller_path : parts.join('/')
+            return controller, file
+          end
+        
+          def controller_path_from(path)
+            parts = path.split('/')
+            parts.pop
+            parts.join('/')
+          end
+
+          def current_controller_path
+            @controller.class.to_s.underscore.gsub(/_controller$/,'')
+          end
+        
+      end
+
+      # :call-seq:
+      #   response.should render_template(path)
+      #   response.should_not render_template(path)
+      #
+      # Passes if the specified template is rendered by the response.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # <code>path</code> can include the controller path or not. It
+      # can also include an optional extension (no extension assumes .rhtml).
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Examples
+      #
+      #   response.should render_template('list')
+      #   response.should render_template('same_controller/list')
+      #   response.should render_template('other_controller/list')
+      #
+      #   #rjs
+      #   response.should render_template('list.rjs')
+      #   response.should render_template('same_controller/list.rjs')
+      #   response.should render_template('other_controller/list.rjs')
+      #
+      #   #partials
+      #   response.should render_template('_a_partial')
+      #   response.should render_template('same_controller/_a_partial')
+      #   response.should render_template('other_controller/_a_partial')
+      def render_template(path)
+        RenderTemplate.new(path.to_s, @controller)
+      end
+
+    end
+  end
+end

data/lib/vendor/plugins/make_resourceful/spec/serialize_spec.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Resourceful::Serialize, ".normalize_attributes" do
+  it "should return nil if given nil" do
+    Resourceful::Serialize.normalize_attributes(nil).should be_nil
+  end
+
+  it "should return a basic hash if given a non-injectable attribute" do
+    Resourceful::Serialize.normalize_attributes(:foo).should == {:foo => nil}
+    Resourceful::Serialize.normalize_attributes(12).should == {12 => nil}
+  end
+
+  it "should return a basic hash with a symbol key if given a string attribute" do
+    Resourceful::Serialize.normalize_attributes("foo").should == {:foo => nil}
+  end
+
+  it "should preserve hashes" do
+    Resourceful::Serialize.normalize_attributes({:foo => nil, :bar => nil, :baz => nil}).should ==
+      {:foo => nil, :bar => nil, :baz => nil}
+    Resourceful::Serialize.normalize_attributes({:foo => 3, :bar => 1, :baz => 4}).should ==
+      {:foo => 3, :bar => 1, :baz => 4}
+    Resourceful::Serialize.normalize_attributes({:foo => 3, :bar => 1, :baz => [:foo, :bar]}).should ==
+      {:foo => 3, :bar => 1, :baz => [:foo, :bar]}
+  end
+
+  it "should merge injectable attributes into one big hash" do
+    Resourceful::Serialize.normalize_attributes([:foo, :bar, :baz]).should ==
+      {:foo => nil, :bar => nil, :baz => nil}
+    Resourceful::Serialize.normalize_attributes([:foo, :bar, {:baz => nil},
+                                                 :boom, {:bop => nil, :blat => nil}]).should ==
+      {:foo => nil, :bar => nil, :baz => nil, :boom => nil, :bop => nil, :blat => nil}
+    Resourceful::Serialize.normalize_attributes([:foo, :bar, {:baz => 12},
+                                                 :boom, {:bop => "foo", :blat => [:fee, :fi, :fo]}]).should ==
+      {:foo => nil, :bar => nil, :baz => 12, :boom => nil, :bop => "foo", :blat => [:fee, :fi, :fo]}
+  end
+end
+
+describe Array, " of non-serializable objects" do
+  before :each do
+    @array = [1, 2, 3, 4, "foo"]
+  end
+
+  it "should return itself for #to_serializable" do
+    @array.to_serializable(nil).should == @array
+  end
+
+  it "should raise an error for #serialize" do
+    lambda { @array.serialize(:yaml, :attributes => [:foo]) }.should raise_error("Not all elements respond to to_serializable")
+  end
+end
+
+describe Array, " of serializable objects" do
+  before :each do
+    @cat = stub_model("Cat")
+    @dog = stub_model("Dog")
+    @array = %w{brown yellow green}.zip(%w{rex rover fido}).
+      map { |c, d| @cat.new(:fur => c, :friend => @dog.new(:name => d)) }
+  end
+
+  it "should return an array of serializable hashes for #to_serializable" do
+    @array.to_serializable([:fur]).should == [{'fur' => 'brown'}, {'fur' => 'yellow'}, {'fur' => 'green'}]
+  end
+
+  it "should follow deep attributes for #to_serializable" do
+    @array.to_serializable([:fur, {:friend => :name}]).should ==
+      [{'fur' => 'brown',  'friend' => {'name' => 'rex'}},
+       {'fur' => 'yellow', 'friend' => {'name' => 'rover'}},
+       {'fur' => 'green',  'friend' => {'name' => 'fido'}}]
+  end
+
+  it "should raise an error if #serialize is called without the :attributes option" do
+    lambda { @array.serialize(:yaml, {}) }.should raise_error("Must specify :attributes option")
+  end
+
+  it "should serialize to a hash with a pluralized root for #serialize" do
+    YAML.load(@array.serialize(:yaml, :attributes => [:fur, {:friend => :name}])).should ==
+      {"cats" => [{'fur' => 'brown',  'friend' => {'name' => 'rex'}},
+                  {'fur' => 'yellow', 'friend' => {'name' => 'rover'}},
+                  {'fur' => 'green',  'friend' => {'name' => 'fido'}}]}
+  end
+
+  it "should serialize to an XML document with a pluralized root for #serialize(:xml, ...)" do
+    doc = REXML::Document.new(@array.serialize(:xml, :attributes => [:fur, {:friend => :name}]),
+                              :ignore_whitespace_nodes => :all)
+    doc.root.name.should == "cats"
+    cats = doc.get_elements('/cats/cat')
+    cats.size.should == 3
+    cats.zip(%w{brown yellow green}, %w{rex rover fido}) do |cat, fur, dog|
+      cat.children.find { |e| e.name == "fur" }.text.should == fur
+      cat.children.find { |e| e.name == "friend" }.children[0].text.should == dog
+    end
+  end
+end
+
+describe ActiveRecord::Base, " with a few attributes and an association" do
+  before :each do
+    @person = stub_model("Person")
+    @party_hat = stub_model("PartyHat")
+    @model = @person.new(:name => "joe", :eye_color => "blue", :hairs => 567,
+                         :party_hat => @party_hat.new(:color => 'blue', :size => 12, :pattern => 'stripey'))
+  end
+
+  it "should raise an error if #to_serializable is called without attributes" do
+    lambda { @model.to_serializable(nil) }.should raise_error("Must specify attributes for #<Person>.to_serializable")
+  end
+
+  it "should return an attributes hash for #to_serializable" do
+    @model.to_serializable([:name, :hairs, {:party_hat => [:color, :size]}]).should ==
+      {'name' => 'joe', 'hairs' => 567, 'party_hat' => {
+        'color' => 'blue', 'size' => 12
+      }}
+  end
+
+  it "should raise an error if #serialize is called without the :attributes option" do
+    lambda { @model.serialize(:yaml, {}) }.should raise_error("Must specify :attributes option")
+  end
+
+  it "should serialize to a hash for #serialize" do
+    YAML.load(@model.serialize(:yaml, :attributes => [:hairs, :eye_color, {:party_hat => :size}])).should ==
+      {"person" => {'hairs' => 567, 'eye_color' => 'blue', 'party_hat' => {'size' => 12}}}
+  end
+
+  it "should serialize to an XML document for #serialize(:xml, ...)" do
+    doc = REXML::Document.new(@model.serialize(:xml, :attributes => [:name, :eye_color, {:party_hat => :pattern}]),
+                              :ignore_whitespace_nodes => :all)
+    doc.root.name.should == "person"
+    doc.root.children.find { |e| e.name == "name"      }.text.should == "joe"
+    doc.root.children.find { |e| e.name == "eye-color" }.text.should == "blue"
+
+    hat = doc.root.children.find { |e| e.name == "party-hat" }
+    hat.children.find { |e| e.name == "pattern" }.text.should == "stripey"
+  end
+end