make_resourceful_rails2 1.0.1

data/spec/maker_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Resourceful::Maker, "when extended" do
+  include ControllerMocks
+  before(:each) { mock_kontroller }
+
+  it "should create an empty, inheritable callbacks hash" do
+    @kontroller.resourceful_callbacks.should == {}
+  end
+
+  it "should create an empty, inheritable responses hash" do
+    @kontroller.resourceful_responses.should == {}
+  end
+
+  it "should create an empty, inheritable parents array" do
+    @kontroller.parents.should == []
+  end
+
+  it "should create a made_resourceful variable set to false" do
+    @kontroller.made_resourceful.should be_false
+  end
+
+  it "should create a made_resourceful? method on the controller that returns the variable" do
+    @kontroller.should_not be_made_resourceful
+    @kontroller.made_resourceful = true
+    @kontroller.should be_made_resourceful
+  end
+end
+
+describe Resourceful::Maker, "when made_resourceful" do
+  include ControllerMocks
+  before(:each) do
+    mock_kontroller
+    mock_builder
+  end
+
+  it "should include Resourceful::Base" do
+    @kontroller.expects(:include).with(Resourceful::Base)
+    @kontroller.make_resourceful {}
+  end
+
+  it "should use Resourceful::Builder to build the controller" do
+    Resourceful::Builder.expects(:new).with(@kontroller).returns(@builder)
+    @kontroller.make_resourceful {}
+  end
+
+  it "should evaluate the made_resourceful callbacks in the context of the builder" do
+    procs = (1..5).map { should_be_called { with(@builder) } }
+    Resourceful::Base.stubs(:made_resourceful).returns(procs)
+    @kontroller.make_resourceful {}
+  end
+
+  it "should evaluate the :include callback in the context of the builder" do
+    @kontroller.make_resourceful(:include => should_be_called { with(@builder) }) {}
+  end
+
+  it "should evaluate the given block in the context of the builder" do
+    @kontroller.make_resourceful(&(should_be_called { with(@builder) }))
+  end
+end
+
+describe Resourceful::Maker, "when made_resourceful with an inherited controller" do
+  include ControllerMocks
+  before(:each) do
+    mock_kontroller
+    mock_builder :inherited
+  end
+  
+  it "should include Resourceful::Base" do
+    @kontroller.expects(:include).with(Resourceful::Base)
+    @kontroller.make_resourceful {}
+  end
+
+  it "should use Resourceful::Builder to build the controller" do
+    Resourceful::Builder.expects(:new).with(@kontroller).returns(@builder)
+    @kontroller.make_resourceful {}
+  end
+
+  it "should not evaluate the made_resourceful callbacks in the context of the builder" do
+    Resourceful::Base.expects(:made_resourceful).never
+    @kontroller.make_resourceful {}
+  end
+
+  it "should evaluate the :include callback in the context of the builder" do
+    @kontroller.make_resourceful(:include => should_be_called { with(@builder) }) {}
+  end
+
+  it "should evaluate the given block in the context of the builder" do
+    @kontroller.make_resourceful(&(should_be_called { with(@builder) }))
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Resourceful::Response, "when first created" do
+  before(:each) { @response = Resourceful::Response.new }
+
+  it "should have an empty formats array" do
+    @response.formats.should == []
+  end
+end
+
+describe Resourceful::Response, "with a few formats" do
+  before :each do
+    @response = Resourceful::Response.new
+    @response.html
+    @response.js  {'javascript'}
+    @response.xml {'xml'}
+  end
+
+  it "should store the formats and blocks" do
+    @response.formats.should have_any {|f,p| f == :js  && p.call == 'javascript'}
+    @response.formats.should have_any {|f,p| f == :xml && p.call == 'xml'}
+  end
+
+  it "should give formats without a block an empty block" do
+    @response.formats.should have_any {|f,p| f == :html && Proc === p && p.call.nil?}
+  end
+
+  it "shouldn't allow duplicate formats" do
+    @response.js {'not javascript'}
+    @response.formats.should     have_any {|f,p| f == :js && p.call == 'javascript'}
+    @response.formats.should_not have_any {|f,p| f == :js && p.call == 'not javascript'}
+  end
+
+  it "should keep the formats in sorted order" do
+    @response.formats.map(&:first).should == [:html, :js, :xml]
+  end
+end

data/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/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