easy_admin_ui 0.4.0 → 0.5.0

data/vendor/plugins/make_resourceful/spec/callbacks_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Resourceful::Default::Callbacks, " with a few callbacks" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks   
+  end
+
+  it "should fire the :before callback with the given name when #before is called" do
+    callbacks[:before] = { :create => [ should_be_called ] }
+    @controller.before(:create)
+  end
+
+  it "should fire the :after callback with the given name when #after is called" do
+    callbacks[:after] = { :index  => [ should_be_called ] }
+    @controller.after("index")
+  end
+end
+
+describe Resourceful::Default::Callbacks, " with a few responses" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Callbacks
+    responses[:create_failed] = [[:html, nil], [:js, nil]]
+    responses[:create] = [[:html, proc { "create html" }], [:xml, proc { @xml }]]
+    @controller.instance_variable_set('@xml', 'create XML')
+    @response = Resourceful::Response.new
+  end
+
+  it "should respond to each format with a call to the given block when #response_for is called" do
+    @controller.expects(:respond_to).yields(@response)
+    @controller.response_for(:create_failed)
+    @response.formats[0][0].should == :html
+    @response.formats[0][1].call.should be_nil
+
+    @response.formats[1][0].should == :js
+    @response.formats[1][1].call.should be_nil
+  end
+
+  it "should properly scope blocks when #response_for is called" do
+    @controller.expects(:respond_to).yields(@response)
+    @controller.response_for(:create)
+    @response.formats[0][0].should == :html
+    @response.formats[0][1].call.should == "create html"
+
+    @response.formats[1][0].should == :xml
+
+    # This value comes from the instance variable in @controller.
+    # Having it be "create XML" ensures that the block was properly scoped.
+    @response.formats[1][1].call.should == "create XML"
+  end
+end
+
+describe Resourceful::Default::Callbacks, "#scope" do
+  include ControllerMocks
+  before(:each) { mock_controller Resourceful::Default::Callbacks }
+
+  it "should re-bind the block to the controller's context" do
+    block = proc { @var }
+    @controller.instance_variable_set('@var', 'value')
+
+    block.call.should == nil
+    @controller.scope(block).call.should == 'value'
+  end
+
+  it "should make the block empty if it's passed in as nil" do
+    @controller.scope(nil).call.should == nil
+  end
+end
+
+

data/vendor/plugins/make_resourceful/spec/integration_spec.rb

@@ -0,0 +1,394 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "ThingsController", "with all the resourceful actions" do
+  
+  before :each do
+    mock_resourceful do
+      actions :all
+    end
+    @objects = stub_list(5, 'Thing') do |t|
+      [:destroy, :save, :update_attributes].each { |m| t.stubs(m).returns(true) }
+      t.stubs(:to_param).returns('12')
+    end
+    @object = @objects.first
+    Thing.stubs(:find).returns(@object)
+    Thing.stubs(:new).returns(@object)
+  end
+
+  ## Default responses
+
+  (Resourceful::ACTIONS - Resourceful::MODIFYING_ACTIONS).each(&method(:should_render_html))
+  Resourceful::ACTIONS.each(&method(:should_render_js))
+  Resourceful::ACTIONS.each(&method(:shouldnt_render_xml))
+
+  ## Specs for #index
+
+  it "should find all records on GET /things" do
+    Thing.expects(:find).with(:all).returns(@objects)
+    get :index
+  end
+
+  it "should return a list of objects for #current_objects after GET /things" do
+    Thing.stubs(:find).returns(@objects)
+    get :index
+    current_objects.should == @objects
+  end
+
+  it "should assign @things to a list of objects for GET /things" do
+    Thing.stubs(:find).returns(@objects)
+    get :index
+    assigns(:things).should == @objects
+  end
+
+  ## Specs for #show
+
+  it "should find the record with id 12 on GET /things/12" do
+    Thing.expects(:find).with('12').returns(@object)
+    get :show, :id => 12
+  end
+
+  it "should return an object for #current_object after GET /things/12" do
+    Thing.stubs(:find).returns(@object)
+    get :show, :id => 12
+    current_object.should == @object
+  end
+
+  it "should assign @thing to an object for GET /things/12" do
+    Thing.stubs(:find).returns(@object)
+    get :show, :id => 12
+    assigns(:thing).should == @object
+  end  
+
+  ## Specs for #edit
+
+  it "should find the record with id 12 on GET /things/12/edit" do
+    Thing.expects(:find).with('12').returns(@object)
+    get :edit, :id => 12
+  end
+
+  it "should return an object for #current_object after GET /things/12/edit" do
+    Thing.stubs(:find).returns(@object)
+    get :edit, :id => 12
+    current_object.should == @object
+  end
+
+  it "should assign @thing to an object for GET /things/12/edit" do
+    Thing.stubs(:find).returns(@object)
+    get :edit, :id => 12
+    assigns(:thing).should == @object
+  end
+
+  ## Specs for #new
+
+  it "should create a new object from params[:thing] for GET /things/new" do
+    Thing.expects(:new).with('name' => "Herbert the thing").returns(@object)
+    get :new, :thing => {:name => "Herbert the thing"}
+  end
+
+  it "should create a new object even if there aren't any params for GET /things/new" do
+    Thing.expects(:new).with(nil).returns(@object)
+    get :new
+  end
+
+  it "should return the new object for #current_object after GET /things/new" do
+    Thing.stubs(:new).returns(@object)
+    get :new
+    current_object.should == @object
+  end
+
+  it "should assign @thing to the new object for GET /things/new" do
+    Thing.stubs(:new).returns(@object)
+    get :new
+    assigns(:thing).should == @object
+  end
+
+  ## Specs for #create
+
+  it "should create a new object from params[:thing] for POST /things" do
+    Thing.expects(:new).with('name' => "Herbert the thing").returns(@object)
+    post :create, :thing => {:name => "Herbert the thing"}
+  end
+
+  it "should create a new object even if there aren't any params for POST /things" do
+    Thing.expects(:new).with(nil).returns(@object)
+    post :create
+  end
+
+  it "should return the new object for #current_object after POST /things" do
+    Thing.stubs(:new).returns(@object)
+    post :create
+    current_object.should == @object
+  end
+
+  it "should assign @thing to the new object for POST /things" do
+    Thing.stubs(:new).returns(@object)
+    post :create
+    assigns(:thing).should == @object
+  end
+
+  it "should save the new object for POST /things" do
+    Thing.stubs(:new).returns(@object)
+    @object.expects(:save)
+    post :create
+  end
+
+  it "should set an appropriate flash notice for a successful POST /things" do
+    Thing.stubs(:new).returns(@object)
+    post :create
+    flash[:notice].should == "Create successful!"
+  end
+
+  it "should redirect to the new object for a successful POST /things" do
+    Thing.stubs(:new).returns(@object)
+    post :create
+    response.should redirect_to('/things/12')
+  end
+
+  it "should set an appropriate flash error for an unsuccessful POST /things" do
+    Thing.stubs(:new).returns(@object)
+    @object.stubs(:save).returns(false)
+    post :create
+    flash[:error].should == "There was a problem!"
+  end
+
+  it "should give a failing response for an unsuccessful POST /things" do
+    Thing.stubs(:new).returns(@object)
+    @object.stubs(:save).returns(false)
+    post :create
+    response.should_not be_success
+    response.code.should == '422'
+  end
+
+  it "should render the #new template for an unsuccessful POST /things" do
+    Thing.stubs(:new).returns(@object)
+    @object.stubs(:save).returns(false)
+    post :create
+    response.body.should include('New object')
+  end
+
+  ## Specs for #update
+
+  it "should find the record with id 12 on PUT /things/12" do
+    Thing.expects(:find).with('12').returns(@object)
+    put :update, :id => 12
+  end
+
+  it "should return an object for #current_object after PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    put :update, :id => 12
+    current_object.should == @object
+  end
+
+  it "should assign @thing to an object for PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    put :update, :id => 12
+    assigns(:thing).should == @object
+  end  
+
+  it "should update the new object for PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.expects(:update_attributes).with('name' => "Jorje")
+    put :update, :id => 12, :thing => {:name => "Jorje"}
+  end
+
+  it "should set an appropriate flash notice for a successful PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    put :update, :id => 12
+    flash[:notice].should == "Save successful!"
+  end
+
+  it "should redirect to the updated object for a successful PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    put :update, :id => 12
+    response.should redirect_to('/things/12')
+  end
+
+  it "should set an appropriate flash error for an unsuccessful PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.stubs(:update_attributes).returns(false)
+    put :update, :id => 12
+    flash[:error].should == "There was a problem saving!"
+  end
+
+  it "should give a failing response for an unsuccessful PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.stubs(:update_attributes).returns(false)
+    put :update, :id => 12
+    response.should_not be_success
+    response.code.should == '422'
+  end
+
+  it "should render the #edit template for an unsuccessful PUT /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.stubs(:update_attributes).returns(false)
+    put :update, :id => 12
+    response.body.should include('Editting object')
+  end
+
+  ## Specs for #destroy
+
+  it "should find the record with id 12 on DELETE /things/12" do
+    Thing.expects(:find).with('12').returns(@object)
+    delete :destroy, :id => 12
+  end
+
+  it "should return an object for #current_object after DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    delete :destroy, :id => 12
+    current_object.should == @object
+  end
+
+  it "should assign @thing to an object for DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    delete :destroy, :id => 12
+    assigns(:thing).should == @object
+  end  
+
+  it "should destroy the new object for DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.expects(:destroy)
+    delete :destroy, :id => 12
+  end
+
+  it "should set an appropriate flash notice for a successful DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    delete :destroy, :id => 12
+    flash[:notice].should == "Record deleted!"
+  end
+
+  it "should redirect to the object list for a successful DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    delete :destroy, :id => 12
+    response.should redirect_to('/things')
+  end
+
+  it "should set an appropriate flash error for an unsuccessful DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.stubs(:destroy).returns(false)
+    delete :destroy, :id => 12
+    flash[:error].should == "There was a problem deleting!"
+  end
+
+  it "should give a failing response for an unsuccessful DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.stubs(:destroy).returns(false)
+    delete :destroy, :id => 12
+    response.should_not be_success
+  end
+
+  it "should redirect to the previous page for an unsuccessful DELETE /things/12" do
+    Thing.stubs(:find).returns(@object)
+    @object.stubs(:destroy).returns(false)
+    delete :destroy, :id => 12
+    response.should redirect_to(:back)
+  end
+end
+
+describe "ThingsController", "with several parent objects", :type => :integration do
+  before :each do
+    mock_resourceful do
+      actions :all
+      belongs_to :person, :category
+    end
+    stub_const 'Person'
+    stub_const 'Category'
+
+    @objects = stub_list(5, 'Thing') do |t|
+      t.stubs(:save).returns(true)
+    end
+    @object = @objects.first
+    @person = stub('Person')
+    @category = stub('Category')
+    @fake_model = stub('parent_object.things')
+  end
+
+  ## No parent ids
+
+  it "should find all things on GET /things" do
+    Thing.expects(:find).with(:all).returns(@objects)
+    get :index
+    current_objects.should == @objects
+  end
+
+  it "should find the thing with id 12 regardless of scoping on GET /things/12" do
+    Thing.expects(:find).with('12').returns(@object)
+    get :show, :id => 12
+    current_object.should == @object
+  end
+
+  it "should create a new thing without a person on POST /things" do
+    Thing.expects(:new).with('name' => "Lamp").returns(@object)
+    post :create, :thing => {:name => "Lamp"}
+    current_object.should == @object
+  end
+
+  ## Person ids
+
+  it "should assign the proper parent variables and accessors to the person with id 4 for GET /people/4/things" do
+    Person.stubs(:find).returns(@person)
+    @person.stubs(:things).returns(@fake_model)
+    @fake_model.stubs(:find).with(:all).returns(@objects)
+    get :index, :person_id => 4
+    controller.instance_eval("parent_object").should == @person
+    assigns(:person).should == @person
+  end
+
+  it "should find all the things belonging to the person with id 4 on GET /people/4/things" do
+    Person.expects(:find).with('4').returns(@person)
+    @person.expects(:things).at_least_once.returns(@fake_model)
+    @fake_model.expects(:find).with(:all).returns(@objects)
+    get :index, :person_id => 4
+    current_objects.should == @objects
+  end
+
+  it "should find the thing with id 12 if it belongs to the person with id 4 on GET /person/4/things/12" do
+    Person.expects(:find).with('4').returns(@person)
+    @person.expects(:things).at_least_once.returns(@fake_model)
+    @fake_model.expects(:find).with('12').returns(@object)
+    get :show, :person_id => 4, :id => 12
+    current_object.should == @object
+  end
+
+  it "should create a new thing belonging to the person with id 4 on POST /person/4/things" do
+    Person.expects(:find).with('4').returns(@person)
+    @person.expects(:things).at_least_once.returns(@fake_model)
+    @fake_model.expects(:build).with('name' => 'Lamp').returns(@object)
+    post :create, :person_id => 4, :thing => {:name => "Lamp"}
+    current_object.should == @object
+  end
+
+  ## Category ids
+
+  it "should assign the proper parent variables and accessors to the category with id 4 for GET /people/4/things" do
+    Category.stubs(:find).returns(@category)
+    @category.stubs(:things).returns(@fake_model)
+    @fake_model.stubs(:find).with(:all).returns(@objects)
+    get :index, :category_id => 4
+    controller.instance_eval("parent_object").should == @category
+    assigns(:category).should == @category
+  end
+
+  it "should find all the things belonging to the category with id 4 on GET /people/4/things" do
+    Category.expects(:find).with('4').returns(@category)
+    @category.expects(:things).at_least_once.returns(@fake_model)
+    @fake_model.expects(:find).with(:all).returns(@objects)
+    get :index, :category_id => 4
+    current_objects.should == @objects
+  end
+
+  it "should find the thing with id 12 if it belongs to the category with id 4 on GET /category/4/things/12" do
+    Category.expects(:find).with('4').returns(@category)
+    @category.expects(:things).at_least_once.returns(@fake_model)
+    @fake_model.expects(:find).with('12').returns(@object)
+    get :show, :category_id => 4, :id => 12
+    current_object.should == @object
+  end
+
+  it "should create a new thing belonging to the category with id 4 on POST /category/4/things" do
+    Category.expects(:find).with('4').returns(@category)
+    @category.expects(:things).at_least_once.returns(@fake_model)
+    @fake_model.expects(:build).with('name' => 'Lamp').returns(@object)
+    post :create, :category_id => 4, :thing => {:name => "Lamp"}
+    current_object.should == @object
+  end
+end

data/vendor/plugins/make_resourceful/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.read_inheritable_attribute(:resourceful_callbacks).should == {}
+  end
+
+  it "should create an empty, inheritable responses hash" do
+    @kontroller.read_inheritable_attribute(:resourceful_responses).should == {}
+  end
+
+  it "should create an empty, inheritable parents array" do
+    @kontroller.read_inheritable_attribute(:parents).should == []
+  end
+
+  it "should create a made_resourceful variable set to false" do
+    @kontroller.read_inheritable_attribute(: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.write_inheritable_attribute(: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/vendor/plugins/make_resourceful/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