yousty-activeadmin 1.0.0.pre

data/spec/unit/resource_collection_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'active_admin/resource_collection'
+
+include ActiveAdmin
+
+describe ActiveAdmin::ResourceCollection do
+  let(:application) { ActiveAdmin::Application.new }
+  let(:namespace)   { ActiveAdmin::Namespace.new(application, :admin) }
+
+  let(:collection){ ResourceCollection.new }
+
+  let(:resource){ double resource_name: "MyResource" }
+
+  it "should have no resources when new" do
+    collection.should be_empty
+  end
+
+  it "should be enumerable" do
+    collection.add(resource)
+    collection.each{ |r| r.should == resource }
+  end
+
+  it "should return the available keys" do
+    collection.add resource
+    collection.keys.should == [resource.resource_name]
+  end
+
+  describe "adding a new resource" do
+    it "should return the resource" do
+      collection.add(resource).should == resource
+    end
+
+    it "should add a new resource" do
+      collection.add(resource)
+      collection.values.should == [resource]
+    end
+
+    it "should be available by name" do
+      collection.add(resource)
+      collection[resource.resource_name].should == resource
+    end
+
+    it "shouldn't happen twice" do
+      collection.add(resource); collection.add(resource)
+      collection.values.should == [resource]
+    end
+  end
+
+  describe "#[]" do
+    let(:resource)              { Resource.new(namespace, resource_class) }
+    let(:inherited_resource)    { Resource.new(namespace, inherited_resource_class) }
+
+    let(:resource_class)           { User }
+    let(:inherited_resource_class) { Publisher }
+    let(:unregistered_class)       { Category }
+
+    context "with resources" do
+      before do
+        collection.add resource
+        collection.add inherited_resource
+      end
+
+      it "should find resource by class" do
+        collection[resource_class].should == resource
+      end
+
+      it "should find resource by class string" do
+        collection[resource_class.to_s].should == resource
+      end
+
+      it "should find inherited resource by class" do
+        collection[inherited_resource_class].should == inherited_resource
+      end
+
+      it "should find inherited resource by class string" do
+        collection[inherited_resource_class.to_s].should == inherited_resource
+      end
+
+      it "should return nil when the resource_class does not respond to base_class and it is not in the collection" do
+        collection[double].should == nil
+      end
+
+      it "should return nil when a resource class is NOT in the collection" do
+        collection[unregistered_class].should == nil
+      end
+    end
+
+    context "without inherited resources" do
+      before do
+        collection.add resource
+      end
+
+      it "should find resource by inherited class" do
+        collection[inherited_resource_class].should == resource
+      end
+    end
+
+    context "with a renamed resource" do
+      let(:renamed_resource) { Resource.new(namespace, resource_class, :as => name) }
+      let(:name)             { "Administrators" }
+
+      before do
+        collection.add renamed_resource
+      end
+
+      it "should find resource by class" do
+        collection[resource_class].should == renamed_resource
+      end
+
+      it "should find resource by class string" do
+        collection[resource_class.to_s].should == renamed_resource
+      end
+
+      it "should find resource by name" do
+        collection[name].should == renamed_resource
+      end
+    end
+  end
+
+  describe ".add" do
+    let(:resource)         { Resource.new(namespace, Category) }
+    let(:resource_renamed) { Resource.new(namespace, Category, as: "Subcategory") }
+
+    context "when renamed resource is added first" do
+      before do
+        collection.add(resource_renamed)
+        collection.add(resource)
+      end
+
+      it "contains both resources" do
+        collection.values.should include(resource, resource_renamed)
+      end
+    end
+
+    context "when resource is added first" do
+      before do
+        collection.add(resource)
+        collection.add(resource_renamed)
+      end
+
+      it "contains both resources" do
+        collection.values.should include(resource, resource_renamed)
+      end
+    end
+
+    context "when a duplicate resource is added" do
+      let(:resource_duplicate) { Resource.new(namespace, Category) }
+
+      before do
+        collection.add(resource)
+        collection.add(resource_duplicate)
+      end
+
+      it "the collection contains one instance of that resource" do
+        collection.values.should eq([resource])
+      end
+    end
+  end
+
+end

data/spec/unit/resource_controller/data_access_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ResourceController::DataAccess do
+  let(:params) do
+    {}
+  end
+
+  let(:controller) do
+    rc = Admin::PostsController.new
+    rc.stub(:params) do
+      params
+    end
+    rc
+  end
+
+  describe "searching" do
+    let(:params){ {:q => {} }}
+    it "should call the search method" do
+      chain = double "ChainObj"
+      chain.should_receive(:ransack).with(params[:q]).once.and_return(Post.ransack)
+      controller.send :apply_filtering, chain
+    end
+
+  end
+
+  describe "sorting" do
+
+    context "for table columns" do
+      let(:params){ {:order => "id_asc" }}
+      it "should prepend the table name" do
+        chain = double "ChainObj"
+        chain.should_receive(:reorder).with('"posts"."id" asc').once.and_return(Post.search)
+        controller.send :apply_sorting, chain
+      end
+    end
+
+    context "for virtual columns" do
+      let(:params){ {:order => "virtual_id_asc" }}
+      it "should not prepend the table name" do
+        chain = double "ChainObj"
+        chain.should_receive(:reorder).with('"virtual_id" asc').once.and_return(Post.search)
+        controller.send :apply_sorting, chain
+      end
+    end
+
+  end
+
+  describe "scoping" do
+
+    context "when no current scope" do
+      it "should set collection_before_scope to the chain and return the chain" do
+        chain = double "ChainObj"
+        controller.send(:apply_scoping, chain).should == chain
+        controller.send(:collection_before_scope).should == chain
+      end
+    end
+
+    context "when current scope" do
+      it "should set collection_before_scope to the chain and return the scoped chain" do
+        chain         = double "ChainObj"
+        scoped_chain  = double "ScopedChain"
+        current_scope = double "CurrentScope"
+        controller.stub(:current_scope) { current_scope }
+
+        controller.should_receive(:scope_chain).with(current_scope, chain) { scoped_chain }
+        controller.send(:apply_scoping, chain).should == scoped_chain
+        controller.send(:collection_before_scope).should == chain
+      end
+    end
+
+  end
+
+end

data/spec/unit/resource_controller/sidebars_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ResourceController::Sidebars do
+  let(:controller){ Admin::PostsController }
+
+  context 'without before_filter' do
+    before do
+      ActiveAdmin.register Post
+    end
+
+    subject { find_before_filter controller, :skip_sidebar! }
+
+    it { should set_skip_sidebar_to nil }
+  end
+
+  describe '#skip_sidebar!' do
+    before do
+      ActiveAdmin.register Post do
+        before_filter :skip_sidebar!
+      end
+    end
+
+    subject { find_before_filter controller, :skip_sidebar! }
+
+    it { should set_skip_sidebar_to true }
+  end
+
+  def find_before_filter(controller, filter)
+    #raise controller._process_action_callbacks.map(&:filter).inspect
+    controller._process_action_callbacks.detect { |f| f.raw_filter == filter.to_sym }
+  end
+
+  RSpec::Matchers.define :set_skip_sidebar_to do |expected|
+    match do |filter|
+      klass = filter && filter.klass || controller
+      object = klass.new
+      object.send filter.raw_filter if filter
+      @actual = object.instance_variable_get(:@skip_sidebar)
+      @actual == expected
+    end
+
+    failure_message_for_should do |filter|
+      message = "expected before_filter to set @skip_sidebar to '#{expected}', but was '#{@actual}'"
+    end
+  end
+end

data/spec/unit/resource_controller_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ResourceController do
+
+  before(:all) { load_defaults! }
+
+  let(:controller) { ActiveAdmin::ResourceController.new }
+
+  describe "authenticating the user" do
+    let(:controller){ Admin::PostsController.new }
+
+    it "should do nothing when no authentication_method set" do
+      namespace = controller.class.active_admin_config.namespace
+      namespace.should_receive(:authentication_method).once.and_return(nil)
+
+      controller.send(:authenticate_active_admin_user)
+    end
+
+    it "should call the authentication_method when set" do
+      namespace = controller.class.active_admin_config.namespace
+
+      namespace.should_receive(:authentication_method).twice.
+        and_return(:authenticate_admin_user!)
+
+      controller.should_receive(:authenticate_admin_user!).and_return(true)
+
+      controller.send(:authenticate_active_admin_user)
+    end
+
+  end
+
+  describe "retrieving the current user" do
+    let(:controller){ Admin::PostsController.new }
+
+    it "should return nil when no current_user_method set" do
+      namespace = controller.class.active_admin_config.namespace
+      namespace.should_receive(:current_user_method).once.and_return(nil)
+
+      controller.send(:current_active_admin_user).should == nil
+    end
+
+    it "should call the current_user_method when set" do
+      user = double
+      namespace = controller.class.active_admin_config.namespace
+
+      namespace.should_receive(:current_user_method).twice.
+        and_return(:current_admin_user)
+
+      controller.should_receive(:current_admin_user).and_return(user)
+
+      controller.send(:current_active_admin_user).should == user
+    end
+  end
+
+
+  describe "callbacks" do
+    before :all do
+      application = ::ActiveAdmin::Application.new
+      namespace = ActiveAdmin::Namespace.new(application, :admin)
+      namespace.register Post do
+        after_build :call_after_build
+        before_save :call_before_save
+        after_save :call_after_save
+        before_create :call_before_create
+        after_create :call_after_create
+        before_update :call_before_update
+        after_update :call_after_update
+        before_destroy :call_before_destroy
+        after_destroy :call_after_destroy
+
+        controller do
+          def call_after_build(obj); end
+          def call_before_save(obj); end
+          def call_after_save(obj); end
+          def call_before_create(obj); end
+          def call_after_create(obj); end
+          def call_before_update(obj); end
+          def call_after_update(obj); end
+          def call_before_destroy(obj); end
+          def call_after_destroy(obj); end
+        end
+      end
+    end
+
+    describe "performing create" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ double("Resource", :save => true) }
+
+      before do
+        resource.should_receive(:save)
+      end
+
+      it "should call the before create callback" do
+        controller.should_receive(:call_before_create).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the before save callback" do
+        controller.should_receive(:call_before_save).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the after save callback" do
+        controller.should_receive(:call_after_save).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the after create callback" do
+        controller.should_receive(:call_after_create).with(resource)
+        controller.send :create_resource, resource
+      end
+    end
+
+    describe "performing update" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ double("Resource", :attributes= => true, :save => true) }
+      let(:attributes){ [{}] }
+
+      before do
+        resource.should_receive(:attributes=).with(attributes[0])
+        resource.should_receive(:save)
+      end
+
+      it "should call the before update callback" do
+        controller.should_receive(:call_before_update).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the before save callback" do
+        controller.should_receive(:call_before_save).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the after save callback" do
+        controller.should_receive(:call_after_save).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the after create callback" do
+        controller.should_receive(:call_after_update).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+    end
+
+    describe "performing destroy" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ double("Resource", :destroy => true) }
+
+      before do
+        resource.should_receive(:destroy)
+      end
+
+      it "should call the before destroy callback" do
+        controller.should_receive(:call_before_destroy).with(resource)
+        controller.send :destroy_resource, resource
+      end
+
+      it "should call the after destroy callback" do
+        controller.should_receive(:call_after_destroy).with(resource)
+        controller.send :destroy_resource, resource
+      end
+    end
+  end
+end
+
+describe Admin::PostsController, :type => "controller" do
+
+  describe 'retreiving the resource' do
+    let(:controller){ Admin::PostsController.new }
+    let(:post) { Post.new :title => "An incledibly unique Post Title" }
+
+    before do
+      Post.stub(:find).and_return(post)
+      controller.class_eval { public :resource }
+      controller.stub(:params).and_return({ :id => '1' })
+    end
+
+    subject { controller.resource }
+
+    it "returns a Post" do
+      subject.should be_kind_of(Post)
+    end
+
+    context 'with a decorator' do
+      let(:config) { controller.class.active_admin_config }
+      before { config.decorator_class_name = '::PostDecorator' }
+      it 'returns a PostDecorator' do
+        subject.should be_kind_of(PostDecorator)
+      end
+
+      it 'returns a PostDecorator that wraps the post' do
+        subject.title.should == post.title
+      end
+    end
+  end
+
+  describe 'retreiving the resource collection' do
+    let(:controller){ Admin::PostsController.new }
+    before do
+      Post.create!(:title => "An incledibly unique Post Title") if Post.count == 0
+      controller.class_eval { public :collection }
+    end
+
+    subject { controller.collection }
+
+    it {
+      pending # doesn't pass when running whole spec suite (WTF)
+      should be_kind_of(ActiveRecord::Relation)
+    }
+
+    it "returns a collection of posts" do
+      pending # doesn't pass when running whole spec suite (WTF)
+      subject.first.should be_kind_of(Post)
+    end
+
+    context 'with a decorator' do
+      let(:config) { controller.class.active_admin_config }
+      before { config.decorator_class_name = '::PostDecorator' }
+
+      it 'returns a PostDecorator' do
+        pending # doesn't pass when running whole spec suite (WTF)
+        subject.should be_kind_of(PostDecorator::DecoratedEnumerableProxy)
+      end
+
+      it 'returns a PostDecorator that wraps the post' do
+        pending # doesn't pass when running whole spec suite (WTF)
+        subject.first.title.should == Post.first.title
+      end
+    end
+  end
+
+
+  describe "performing batch_action" do
+    let(:controller){ Admin::PostsController.new }
+    before do
+      batch_action = ActiveAdmin::BatchAction.new :flag, "Flag" do
+        redirect_to collection_path
+      end
+
+      controller.class.active_admin_config.stub(:batch_actions).and_return([batch_action])
+    end
+
+    describe "when params batch_action matches existing BatchAction" do
+      it "should call the block with args" do
+        pending # dont know how to check if the block was called
+      end
+    end
+
+    describe "when params batch_action doesn't match a BatchAction" do
+      it "should raise an error" do
+        pending # doesn't pass when running whole spec suite (WTF)
+
+        expect {
+          post(:batch_action, :batch_action => "derp", :collection_selection => ["1"])
+        }.to raise_error("Couldn't find batch action \"derp\"")
+      end
+    end
+
+    describe "when params batch_action is blank" do
+      it "should raise an error" do
+        pending # doesn't pass when running whole spec suite (WTF)
+
+        expect {
+          post(:batch_action, :collection_selection => ["1"])
+        }.to raise_error("Couldn't find batch action \"\"")
+      end
+    end
+
+  end
+
+end

data/spec/unit/resource_registration_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Registering an object to administer" do
+  application = ActiveAdmin::Application.new
+
+  context "with no configuration" do
+    namespace = ActiveAdmin::Namespace.new(application, :admin)
+    it "should call register on the namespace" do
+      application.namespaces[namespace.name] = namespace
+      namespace.should_receive(:register)
+
+      application.register Category
+    end
+
+    it "should dispatch a Resource::RegisterEvent" do
+      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
+      application.register Category
+    end
+  end
+
+  context "with a different namespace" do
+    it "should call register on the namespace" do
+      namespace = ActiveAdmin::Namespace.new(application, :hello_world)
+      application.namespaces[namespace.name] = namespace
+      namespace.should_receive(:register)
+
+      application.register Category, :namespace => :hello_world
+    end
+
+    it "should generate a Namespace::RegisterEvent and a Resource::RegisterEvent" do
+      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
+      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
+      application.register Category, :namespace => :not_yet_created
+    end
+  end
+
+  context "with no namespace" do
+    it "should call register on the root namespace" do
+      namespace = ActiveAdmin::Namespace.new(application, :root)
+      application.namespaces[namespace.name] = namespace
+      namespace.should_receive(:register)
+
+      application.register Category, :namespace => false
+    end
+  end
+
+  context "when being registered multiple times" do
+    it "should run the dsl in the same config object" do
+      config_1 = ActiveAdmin.register(Category) { filter :name }
+      config_2 = ActiveAdmin.register(Category) { filter :id }
+      config_1.should == config_2
+      config_1.filters.size.should == 2
+    end
+  end
+
+end