yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/spec/unit/resource/pagination_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module ActiveAdmin
   describe Resource, "Pagination" do
@@ -14,24 +14,24 @@ module ActiveAdmin
 
     describe "#paginate" do
       it "should default to true" do
-        config.paginate.should == true
+        expect(config.paginate).to eq true
       end
 
       it "should be settable to false" do
         config.paginate = false
-        config.paginate.should == false
+        expect(config.paginate).to eq false
       end
     end
 
     describe "#per_page" do
       it "should default to namespace.default_per_page" do
-        namespace.should_receive(:default_per_page).and_return(5)
-        config.per_page.should == 5
+        expect(namespace).to receive(:default_per_page).and_return(5)
+        expect(config.per_page).to eq 5
       end
 
       it "should be settable" do
         config.per_page = 5
-        config.per_page.should == 5
+        expect(config.per_page).to eq 5
       end
     end
   end

data/spec/unit/resource/routes_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper' 
+require 'rails_helper' 
 
 module ActiveAdmin
   describe Resource::Routes do
@@ -10,27 +10,27 @@ module ActiveAdmin
         let(:category) { Category.new { |c| c.id = 123 } }
 
         it "should return the route prefix" do
-          config.route_prefix.should eq 'admin'
+          expect(config.route_prefix).to eq 'admin'
         end
 
         it "should return the route collection path" do
-          config.route_collection_path.should eq '/admin/categories'
+          expect(config.route_collection_path).to eq '/admin/categories'
         end
 
         it "should return the route instance path" do
-          config.route_instance_path(category).should eq '/admin/categories/123'
+          expect(config.route_instance_path(category)).to eq '/admin/categories/123'
         end
       end
 
       context "when in the root namespace" do
-        let!(:config) { ActiveAdmin.register Category, :namespace => false }
+        let!(:config) { ActiveAdmin.register Category, namespace: false }
         it "should have a nil route_prefix" do
-          config.route_prefix.should be_nil
+          expect(config.route_prefix).to be_nil
         end
 
         it "should generate a correct route" do
           reload_routes!
-          config.route_collection_path.should == "/categories"
+          expect(config.route_collection_path).to eq "/categories"
         end
       end
 
@@ -40,7 +40,7 @@ module ActiveAdmin
         before{ reload_routes! }
 
         it "should return the plural route with _index" do
-          config.route_collection_path.should == "/admin/news"
+          expect(config.route_collection_path).to eq "/admin/news"
         end
       end
 
@@ -61,11 +61,11 @@ module ActiveAdmin
         before{ reload_routes! }
 
         it "should nest the collection path" do
-          config.route_collection_path(category_id: 1).should == "/admin/categories/1/posts"
+          expect(config.route_collection_path(category_id: 1)).to eq "/admin/categories/1/posts"
         end
 
         it "should nest the instance path" do
-          config.route_instance_path(post).should == "/admin/categories/1/posts/3"
+          expect(config.route_instance_path(post)).to eq "/admin/categories/1/posts/3"
         end
       end
     end

data/spec/unit/resource/scopes_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module ActiveAdmin
   describe Resource, "Scopes" do
@@ -16,26 +16,33 @@ module ActiveAdmin
 
       it "should add a scope" do
         config.scope :published
-        config.scopes.first.should be_a(ActiveAdmin::Scope)
-        config.scopes.first.name.should == "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
-        config.get_scope_by_id(:published).name.should == "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
-        config.scopes.size.should == 1
+        expect(config.scopes.size).to eq 1
       end
 
       it "should update a scope with the same id" do
         config.scope :published
-        config.scopes.first.scope_block.should be_nil
+        expect(config.scopes.first.scope_block).to be_nil
         config.scope(:published){  }
-        config.scopes.first.scope_block.should_not be_nil
+        expect(config.scopes.first.scope_block).to_not be_nil
       end
 
     end

data/spec/unit/resource/sidebars_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Resource::Sidebars do
 
@@ -17,15 +17,15 @@ describe ActiveAdmin::Resource::Sidebars do
     end
 
     it "should add a sidebar section" do
-      resource.should have(1).sidebar_sections
+      expect(resource.sidebar_sections.size).to eq(1)
     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) }
+    let(:only_index){ ActiveAdmin::SidebarSection.new(:help, only: :index) }
+    let(:only_show){ ActiveAdmin::SidebarSection.new(:help, only: :show) }
 
     before do
       resource.clear_sidebar_sections!
@@ -34,8 +34,8 @@ describe ActiveAdmin::Resource::Sidebars do
     end
 
     it "should only return the relevant action items" do
-      resource.should have(2).sidebar_sections
-      resource.sidebar_sections_for("index").should == [only_index]
+      expect(resource.sidebar_sections.size).to eq(2)
+      expect(resource.sidebar_sections_for("index")).to eq [only_index]
     end
 
   end

data/spec/unit/resource_collection_spec.rb

@@ -1,54 +1,90 @@
-require 'spec_helper'
+require 'rails_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" }
+  let(:namespace)   { ActiveAdmin::Namespace.new application, :admin }
+  let(:collection)  { ActiveAdmin::ResourceCollection.new }
+  let(:resource)    { double resource_name: "MyResource" }
+
+  it { is_expected.to respond_to :[]       }
+  it { is_expected.to respond_to :add      }
+  it { is_expected.to respond_to :each     }
+  it { is_expected.to respond_to :has_key? }
+  it { is_expected.to respond_to :keys     }
+  it { is_expected.to respond_to :values   }
+  it { is_expected.to respond_to :size     }
+  it { is_expected.to respond_to :to_a     }
 
   it "should have no resources when new" do
-    collection.should be_empty
+    expect(collection).to be_empty
   end
 
   it "should be enumerable" do
     collection.add(resource)
-    collection.each{ |r| r.should == resource }
+    collection.each{ |r| expect(r).to eq resource }
   end
 
   it "should return the available keys" do
     collection.add resource
-    collection.keys.should == [resource.resource_name]
+    expect(collection.keys).to eq [resource.resource_name]
   end
 
-  describe "adding a new resource" do
+  describe "#add" do
     it "should return the resource" do
-      collection.add(resource).should == resource
+      expect(collection.add(resource)).to eq resource
     end
 
     it "should add a new resource" do
       collection.add(resource)
-      collection.values.should == [resource]
+      expect(collection.values).to eq [resource]
     end
 
     it "should be available by name" do
       collection.add(resource)
-      collection[resource.resource_name].should == resource
+      expect(collection[resource.resource_name]).to eq resource
     end
 
     it "shouldn't happen twice" do
       collection.add(resource); collection.add(resource)
-      collection.values.should == [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)              { Resource.new(namespace, resource_class) }
-    let(:inherited_resource)    { Resource.new(namespace, inherited_resource_class) }
+    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 }
@@ -61,27 +97,27 @@ describe ActiveAdmin::ResourceCollection do
       end
 
       it "should find resource by class" do
-        collection[resource_class].should == resource
+        expect(collection[resource_class]).to eq resource
       end
 
       it "should find resource by class string" do
-        collection[resource_class.to_s].should == resource
+        expect(collection[resource_class.to_s]).to eq resource
       end
 
       it "should find inherited resource by class" do
-        collection[inherited_resource_class].should == inherited_resource
+        expect(collection[inherited_resource_class]).to eq inherited_resource
       end
 
       it "should find inherited resource by class string" do
-        collection[inherited_resource_class.to_s].should == inherited_resource
+        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
-        collection[double].should == nil
+        expect(collection[double]).to eq nil
       end
 
       it "should return nil when a resource class is NOT in the collection" do
-        collection[unregistered_class].should == nil
+        expect(collection[unregistered_class]).to eq nil
       end
     end
 
@@ -91,12 +127,12 @@ describe ActiveAdmin::ResourceCollection do
       end
 
       it "should find resource by inherited class" do
-        collection[inherited_resource_class].should == resource
+        expect(collection[inherited_resource_class]).to eq resource
       end
     end
 
     context "with a renamed resource" do
-      let(:renamed_resource) { Resource.new(namespace, resource_class, :as => name) }
+      let(:renamed_resource) { ActiveAdmin::Resource.new namespace, resource_class, as: name }
       let(:name)             { "Administrators" }
 
       before do
@@ -104,57 +140,19 @@ describe ActiveAdmin::ResourceCollection do
       end
 
       it "should find resource by class" do
-        collection[resource_class].should == renamed_resource
+        expect(collection[resource_class]).to eq renamed_resource
       end
 
       it "should find resource by class string" do
-        collection[resource_class.to_s].should == renamed_resource
+        expect(collection[resource_class.to_s]).to eq renamed_resource
       end
 
       it "should find resource by name" do
-        collection[name].should == renamed_resource
+        expect(collection[name]).to eq 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
+  skip "specs for subclasses of Page and Resource"
 
 end

data/spec/unit/resource_controller/data_access_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::ResourceController::DataAccess do
   let(:params) do
@@ -7,39 +7,40 @@ describe ActiveAdmin::ResourceController::DataAccess do
 
   let(:controller) do
     rc = Admin::PostsController.new
-    rc.stub(:params) do
+    allow(rc).to receive(:params) do
       params
     end
     rc
   end
 
   describe "searching" do
-    let(:params){ {:q => {} }}
+    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)
+      expect(chain).to 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
+    context "valid clause" do
+      let(:params) {{ order: "id_asc" }}
+
+      it "reorders chain" do
         chain = double "ChainObj"
-        chain.should_receive(:reorder).with('"posts"."id" asc').once.and_return(Post.search)
+        expect(chain).to 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
+    context "invalid clause" do
+      let(:params) {{ order: "_asc" }}
+
+      it "returns chain untouched" do
         chain = double "ChainObj"
-        chain.should_receive(:reorder).with('"virtual_id" asc').once.and_return(Post.search)
-        controller.send :apply_sorting, chain
+        expect(chain).not_to receive(:reorder)
+        expect(controller.send(:apply_sorting, chain)).to eq chain
       end
     end
 
@@ -50,8 +51,8 @@ describe ActiveAdmin::ResourceController::DataAccess 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
+        expect(controller.send(:apply_scoping, chain)).to eq chain
+        expect(controller.send(:collection_before_scope)).to eq chain
       end
     end
 
@@ -60,14 +61,31 @@ describe ActiveAdmin::ResourceController::DataAccess do
         chain         = double "ChainObj"
         scoped_chain  = double "ScopedChain"
         current_scope = double "CurrentScope"
-        controller.stub(:current_scope) { current_scope }
+        allow(controller).to receive(: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
+        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
 
+  describe "includes" do
+    context "with no includes" do
+      it "should return the chain" do
+        chain = double "ChainObj"
+        expect(controller.send(:apply_includes, chain)).to eq chain
+      end
+    end
+
+    context "with includes" do
+      it "should return the chain with the includes" do
+        chain = double "ChainObj"
+        chain_with_includes = double "ChainObjWithIncludes"
+        expect(chain).to receive(:includes).with(:taggings, :author).and_return(chain_with_includes)
+        expect(controller.send(:active_admin_config)).to receive(:includes).twice.and_return([:taggings, :author])
+        expect(controller.send(:apply_includes, chain)).to eq chain_with_includes
+      end
+    end
+  end
 end