activeadmin 1.0.0.pre4 → 2.4.0

data/spec/unit/resource/menu_spec.rb

@@ -1,18 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  describe Resource, "Menu" 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
-
-    # TODO...
-
-  end
-end

data/spec/unit/resource/naming_spec.rb

@@ -1,122 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-require 'rails_helper'
-
-module ActiveAdmin
-  describe Resource, "Naming" 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
-
-    module ::Mock class Resource < ActiveRecord::Base; end; end
-    module NoActiveModel class Resource; end; end
-
-    describe "singular resource name" do
-      context "when class" do
-        it "should be the underscored singular resource name" do
-          expect(config.resource_name.singular).to eq "category"
-        end
-      end
-      context "when a class in a module" do
-        it "should underscore the module and the class" do
-          expect(Resource.new(namespace, Mock::Resource).resource_name.singular).to eq "mock_resource"
-        end
-      end
-      context "when you pass the 'as' option" do
-        it "should underscore the passed through string" do
-          expect(config(as: "Blog Category").resource_name.singular).to eq "blog_category"
-        end
-      end
-    end
-
-    describe "resource label" do
-      it "should return a pretty name" do
-        expect(config.resource_label).to eq "Category"
-      end
-
-      it "should return the plural version" do
-        expect(config.plural_resource_label).to eq "Categories"
-      end
-
-      context "when the :as option is given" do
-        it "should return the custom name" do
-          expect(config(as: "My Category").resource_label).to eq "My Category"
-        end
-      end
-
-      context "when a class in a module" do
-        it "should include the module and the class" do
-          expect(Resource.new(namespace, Mock::Resource).resource_label).to eq "Mock Resource"
-        end
-
-        it "should include the module and the pluralized class" do
-          expect(Resource.new(namespace, Mock::Resource).plural_resource_label).to eq "Mock Resources"
-        end
-      end
-
-      describe "I18n integration" do
-        describe "singular label" do
-          it "should return the titleized model_name.human" do
-            expect(config.resource_name).to receive(:translate).and_return "Da category"
-
-            expect(config.resource_label).to eq "Da category"
-          end
-        end
-
-        describe "plural label" do
-          it "should return the titleized plural version defined by i18n if available" do
-            expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Da categories"
-            expect(config.plural_resource_label).to eq "Da categories"
-          end
-        end
-
-        describe "plural label with not default locale" do
-          it "should return the titleized plural version defined by i18n with custom :count if available" do
-            expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Категории"
-            expect(config.plural_resource_label(count: 3)).to eq "Категории"
-          end
-        end
-
-        context "when the :as option is given" do
-          describe "singular label" do
-            it "should translate the custom name" do
-              config = config(as: 'My Category')
-              expect(config.resource_name).to receive(:translate).and_return "Translated category"
-              expect(config.resource_label).to eq "Translated category"
-            end
-          end
-
-          describe "plural label" do
-            it "should translate the custom name" do
-              config = config(as: 'My Category')
-              expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Translated categories"
-              expect(config.plural_resource_label).to eq "Translated categories"
-            end
-          end
-        end
-
-      end
-    end
-
-    describe "duplicate resource names" do
-      let(:resource_name) { config.resource_name }
-      let(:duplicate_resource_name) { Resource.new(namespace, Category).resource_name }
-
-      [:==, :===, :eql?].each do |method|
-        it "are equivalent when compared with #{method}" do
-          expect(resource_name.public_send(method, duplicate_resource_name)).to eq true
-        end
-      end
-
-      it "have identical hash values" do
-        expect(resource_name.hash).to eq duplicate_resource_name.hash
-      end
-    end
-  end
-end

data/spec/unit/resource/page_presenters_spec.rb

@@ -1,44 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::Resource::PagePresenters do
-
-  let(:namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin) }
-  let(:resource){ namespace.register(Post) }
-
-  it "should have an empty set of configs on initialize" do
-    expect(resource.page_presenters).to eq ({})
-  end
-
-  it "should add a show page presenter" do
-    page_presenter = ActiveAdmin::PagePresenter.new
-    resource.set_page_presenter(:show, page_presenter)
-    expect(resource.page_presenters[:show]).to eq page_presenter
-  end
-
-  it "should add an index page presenter" do
-    page_presenter = ActiveAdmin::PagePresenter.new({as: :table})
-    resource.set_page_presenter(:index, page_presenter)
-    expect(resource.page_presenters[:index].default).to eq page_presenter
-  end
-
-  describe "#get_page_presenter" do
-
-    it "should return a page config when set" do
-      page_presenter = ActiveAdmin::PagePresenter.new
-      resource.set_page_presenter(:index, page_presenter)
-      expect(resource.get_page_presenter(:index)).to eq page_presenter
-    end
-
-    it "should return a specific index page config when set" do
-      page_presenter = ActiveAdmin::PagePresenter.new
-      resource.set_page_presenter(:index, page_presenter)
-      expect(resource.get_page_presenter(:index, "table")).to eq page_presenter
-    end
-
-    it "should return nil when no page config set" do
-      expect(resource.get_page_presenter(:index)).to eq nil
-    end
-
-  end
-
-end

data/spec/unit/resource/pagination_spec.rb

@@ -1,38 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  describe Resource, "Pagination" 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 "#paginate" do
-      it "should default to true" do
-        expect(config.paginate).to eq true
-      end
-
-      it "should be settable to false" do
-        config.paginate = false
-        expect(config.paginate).to eq false
-      end
-    end
-
-    describe "#per_page" do
-      it "should default to namespace.default_per_page" do
-        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
-        expect(config.per_page).to eq 5
-      end
-    end
-  end
-end

data/spec/unit/resource/routes_spec.rb

@@ -1,77 +0,0 @@
-require 'rails_helper' 
-
-module ActiveAdmin
-  describe Resource::Routes do
-
-    after :all do
-      load_defaults!
-      reload_routes!
-    end
-
-    describe "route names" do
-      context "when in the admin namespace" do
-        let!(:config)  { ActiveAdmin.register Category }
-        let(:category) { Category.new { |c| c.id = 123 } }
-
-        it "should return the route prefix" do
-          expect(config.route_prefix).to eq 'admin'
-        end
-
-        it "should return the route collection path" do
-          expect(config.route_collection_path).to eq '/admin/categories'
-        end
-
-        it "should return the route instance path" do
-          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 }
-        it "should have a nil route_prefix" do
-          expect(config.route_prefix).to eq nil
-        end
-
-        it "should generate a correct route" do
-          reload_routes!
-          expect(config.route_collection_path).to eq "/categories"
-        end
-      end
-
-      context "when registering a plural resource" do
-        class ::News; def self.has_many(*); end end
-        let!(:config) { ActiveAdmin.register News }
-        before{ reload_routes! }
-
-        it "should return the plural route with _index" do
-          expect(config.route_collection_path).to eq "/admin/news"
-        end
-      end
-
-      context "when the resource belongs to another resource" do
-        let! :config do
-          ActiveAdmin.register Post do
-            belongs_to :category
-          end
-        end
-
-        let :post do
-          Post.new do |p|
-            p.id = 3
-            p.category = Category.new{ |c| c.id = 1 }
-          end
-        end
-
-        before{ reload_routes! }
-
-        it "should nest the collection path" do
-          expect(config.route_collection_path(category_id: 1)).to eq "/admin/categories/1/posts"
-        end
-
-        it "should nest the instance path" do
-          expect(config.route_instance_path(post)).to eq "/admin/categories/1/posts/3"
-        end
-      end
-    end
-  end
-end

data/spec/unit/resource/scopes_spec.rb

@@ -1,50 +0,0 @@
-require 'rails_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 eq nil
-        config.scope(:published){  }
-        expect(config.scopes.first.scope_block).to_not eq nil
-      end
-
-    end
-  end
-end

data/spec/unit/resource/sidebars_spec.rb

@@ -1,43 +0,0 @@
-require 'rails_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.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) }
-
-    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.sidebar_sections.size).to eq(2)
-      expect(resource.sidebar_sections_for("index")).to eq [only_index]
-    end
-
-  end
-
-end

data/spec/unit/resource_collection_spec.rb

@@ -1,175 +0,0 @@
-require 'rails_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 { 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
-    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
-
-    context "with a resource and a renamed resource added in disorder" do
-      let(:resource) { ActiveAdmin::Resource.new namespace, resource_class }
-      let(:renamed_resource) do
-        ActiveAdmin::Resource.new namespace, resource_class, as: name
-      end
-      let(:name) { "Administrators" }
-
-      before do
-        collection.add renamed_resource
-        collection.add resource
-      end
-
-      it "should find a resource by class when there are two resources with that class" do
-        expect(collection[resource_class]).to eq resource
-      end
-    end
-  end
-
-  skip "specs for subclasses of Page and Resource"
-
-end