activeadministration 0.0.1

data/spec/unit/resource/scopes_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module ActiveAdmin
+  describe Resource, "Scopes" do
+
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+    describe "adding a scope" do
+
+      it "should add a scope" do
+        config.scope :published
+        expect(config.scopes.first).to be_a(ActiveAdmin::Scope)
+        expect(config.scopes.first.name).to eq "Published"
+      end
+
+      it "should retrive a scope by its id" do
+        config.scope :published
+        expect(config.get_scope_by_id(:published).name).to eq "Published"
+      end
+
+      it "should retrieve a string scope with spaces by its id without conflicts" do
+        aspace_1 = config.scope "a space"
+        aspace_2 = config.scope "as pace"
+        expect(config.get_scope_by_id(aspace_1.id).name).to eq "a space"
+        expect(config.get_scope_by_id(aspace_2.id).name).to eq "as pace"
+      end
+
+      it "should not add a scope with the same name twice" do
+        config.scope :published
+        config.scope :published
+        expect(config.scopes.size).to eq 1
+      end
+
+      it "should update a scope with the same id" do
+        config.scope :published
+        expect(config.scopes.first.scope_block).to be_nil
+        config.scope(:published){  }
+        expect(config.scopes.first.scope_block).to_not be_nil
+      end
+
+    end
+  end
+end

data/spec/unit/resource/sidebars_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Resource::Sidebars do
+
+  let(:resource) do
+    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+    namespace.register(Post)
+  end
+
+  let(:sidebar) { ActiveAdmin::SidebarSection.new(:help) }
+
+  describe "adding a new sidebar section" do
+
+    before do
+      resource.clear_sidebar_sections!
+      resource.sidebar_sections << sidebar
+    end
+
+    it "should add a sidebar section" do
+      expect(resource).to have(1).sidebar_sections
+    end
+
+  end
+
+  describe "retrieving sections for a controller action" do
+
+    let(:only_index){ ActiveAdmin::SidebarSection.new(:help, only: :index) }
+    let(:only_show){ ActiveAdmin::SidebarSection.new(:help, only: :show) }
+
+    before do
+      resource.clear_sidebar_sections!
+      resource.sidebar_sections << only_index
+      resource.sidebar_sections << only_show
+    end
+
+    it "should only return the relevant action items" do
+      expect(resource).to have(2).sidebar_sections
+      expect(resource.sidebar_sections_for("index")).to eq [only_index]
+    end
+
+  end
+
+end

data/spec/unit/resource_collection_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'active_admin/resource_collection'
+
+describe ActiveAdmin::ResourceCollection do
+  let(:application) { ActiveAdmin::Application.new }
+  let(:namespace)   { ActiveAdmin::Namespace.new application, :admin }
+  let(:collection)  { ActiveAdmin::ResourceCollection.new }
+  let(:resource)    { double resource_name: "MyResource" }
+
+  it { should respond_to :[]       }
+  it { should respond_to :add      }
+  it { should respond_to :each     }
+  it { should respond_to :has_key? }
+  it { should respond_to :keys     }
+  it { should respond_to :values   }
+  it { should respond_to :size     }
+  it { should respond_to :to_a     }
+
+  it "should have no resources when new" do
+    expect(collection).to be_empty
+  end
+
+  it "should be enumerable" do
+    collection.add(resource)
+    collection.each{ |r| expect(r).to eq resource }
+  end
+
+  it "should return the available keys" do
+    collection.add resource
+    expect(collection.keys).to eq [resource.resource_name]
+  end
+
+  describe "#add" do
+    it "should return the resource" do
+      expect(collection.add(resource)).to eq resource
+    end
+
+    it "should add a new resource" do
+      collection.add(resource)
+      expect(collection.values).to eq [resource]
+    end
+
+    it "should be available by name" do
+      collection.add(resource)
+      expect(collection[resource.resource_name]).to eq resource
+    end
+
+    it "shouldn't happen twice" do
+      collection.add(resource); collection.add(resource)
+      expect(collection.values).to eq [resource]
+    end
+
+    it "shouldn't allow a resource name mismatch to occur" do
+      expect {
+        ActiveAdmin.register Category
+        ActiveAdmin.register Post, as: "Category"
+      }.to raise_error ActiveAdmin::ResourceCollection::ConfigMismatch
+    end
+
+    it "shouldn't allow a Page/Resource mismatch to occur" do
+      expect {
+        ActiveAdmin.register User
+        ActiveAdmin.register_page 'User'
+      }.to raise_error ActiveAdmin::ResourceCollection::IncorrectClass
+    end
+
+    describe "should store both renamed and non-renamed resources" do
+      let(:resource) { ActiveAdmin::Resource.new namespace, Category }
+      let(:renamed)  { ActiveAdmin::Resource.new namespace, Category, as: "Subcategory" }
+
+      it "when the renamed version is added first" do
+        collection.add renamed
+        collection.add resource
+        expect(collection.values).to include(resource, renamed)
+      end
+
+      it "when the renamed version is added last" do
+        collection.add resource
+        collection.add renamed
+        expect(collection.values).to include(resource, renamed)
+      end
+    end
+  end
+
+  describe "#[]" do
+    let(:resource)              { ActiveAdmin::Resource.new namespace, resource_class }
+    let(:inherited_resource)    { ActiveAdmin::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
+        expect(collection[resource_class]).to eq resource
+      end
+
+      it "should find resource by class string" do
+        expect(collection[resource_class.to_s]).to eq resource
+      end
+
+      it "should find inherited resource by class" do
+        expect(collection[inherited_resource_class]).to eq inherited_resource
+      end
+
+      it "should find inherited resource by class string" do
+        expect(collection[inherited_resource_class.to_s]).to eq 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
+        expect(collection[double]).to eq nil
+      end
+
+      it "should return nil when a resource class is NOT in the collection" do
+        expect(collection[unregistered_class]).to eq nil
+      end
+    end
+
+    context "without inherited resources" do
+      before do
+        collection.add resource
+      end
+
+      it "should find resource by inherited class" do
+        expect(collection[inherited_resource_class]).to eq resource
+      end
+    end
+
+    context "with a renamed resource" do
+      let(:renamed_resource) { ActiveAdmin::Resource.new namespace, resource_class, as: name }
+      let(:name)             { "Administrators" }
+
+      before do
+        collection.add renamed_resource
+      end
+
+      it "should find resource by class" do
+        expect(collection[resource_class]).to eq renamed_resource
+      end
+
+      it "should find resource by class string" do
+        expect(collection[resource_class.to_s]).to eq renamed_resource
+      end
+
+      it "should find resource by name" do
+        expect(collection[name]).to eq renamed_resource
+      end
+    end
+  end
+
+  pending "specs for subclasses of Page and Resource"
+
+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"
+      expect(chain).to receive(:ransack).with(params[:q]).once.and_return(Post.ransack)
+      controller.send :apply_filtering, chain
+    end
+  end
+
+  describe "sorting" do
+
+    context "valid clause" do
+      let(:params) {{ order: "id_asc" }}
+
+      it "reorders chain" do
+        chain = double "ChainObj"
+        expect(chain).to receive(:reorder).with('"posts"."id" asc').once.and_return(Post.search)
+        controller.send :apply_sorting, chain
+      end
+    end
+
+    context "invalid clause" do
+      let(:params) {{ order: "_asc" }}
+
+      it "returns chain untouched" do
+        chain = double "ChainObj"
+        expect(chain).not_to receive(:reorder)
+        expect(controller.send(:apply_sorting, chain)).to eq 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"
+        expect(controller.send(:apply_scoping, chain)).to eq chain
+        expect(controller.send(:collection_before_scope)).to eq 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 }
+
+        expect(controller).to receive(:scope_chain).with(current_scope, chain) { scoped_chain }
+        expect(controller.send(:apply_scoping, chain)).to eq scoped_chain
+        expect(controller.send(:collection_before_scope)).to eq chain
+      end
+    end
+  end
+
+end

data/spec/unit/resource_controller/decorators_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ResourceController::Decorators do
+  let(:controller_class) do
+    Class.new do
+      def self.name
+        "Test Controller using Decorators"
+      end
+
+      def self.helper_method(method)
+        # STUB
+      end
+
+      include ActiveAdmin::ResourceController::Decorators
+
+      public :apply_decorator, :apply_collection_decorator
+    end
+  end
+
+  let(:controller) { controller_class.new }
+  let(:active_admin_config) { double(decorator_class: decorator_class) }
+  before { controller.stub(active_admin_config: active_admin_config) }
+  before { controller.stub(action_name: action) }
+
+
+  describe '#apply_decorator' do
+    let(:action) { 'show' }
+    let(:resource) { Post.new }
+    subject(:applied) { controller.apply_decorator(resource) }
+
+    context 'with a decorator configured' do
+      let(:decorator_class) { PostDecorator }
+      it { should be_kind_of(PostDecorator) }
+    end
+
+    context 'with no decorator configured' do
+      let(:decorator_class) { nil }
+      it { should be_kind_of(Post) }
+    end
+  end
+
+  describe '#apply_collection_decorator' do
+    before { Post.create! }
+    let(:action) { 'index' }
+    let(:collection) { Post.scoped }
+    subject(:applied) { controller.apply_collection_decorator(collection) }
+
+    context 'when a decorator is configured' do
+      context 'and it is using a recent version of draper' do
+        let(:decorator_class) { PostDecorator }
+
+        it 'calling certain scope collections work' do
+          # This is an example of one of the methods that was consistently
+          # failing before this feature existed
+          expect(applied.reorder('').count).to eq applied.count
+        end
+
+        it 'has a good description for the generated class' do
+          expect(applied.class.name).to eq "Draper::CollectionDecorator of PostDecorator with ActiveAdmin extensions"
+        end
+
+      end
+    end
+  end
+
+  describe 'form actions' do
+    let(:action) { 'edit' }
+    let(:resource) { Post.new }
+    let(:form_presenter) { double options: { decorate: decorate_form } }
+    let(:decorator_class) { PostDecorator }
+    before { active_admin_config.stub(:get_page_presenter).with(:form).and_return form_presenter }
+
+    subject(:applied) { controller.apply_decorator(resource) }
+
+    context 'when the form is not configured to decorate' do
+      let(:decorate_form) { false }
+      it { should be_kind_of(Post) }
+    end
+
+    context 'when the form is configured to decorate' do
+      let(:decorate_form) { true }
+      it { should be_kind_of(PostDecorator) }
+    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)
+      expect(@actual).to eq expected
+    end
+
+    failure_message_for_should do |filter|
+      message = "expected before_filter to set @skip_sidebar to '#{expected}', but was '#{@actual}'"
+    end
+  end
+end