activeadmin 0.6.6 → 1.0.0.pre1

data/spec/unit/generators/install_spec.rb

@@ -0,0 +1,23 @@
+require 'rails_helper'
+
+describe "AA installation" do
+  context "should create" do
+
+    it "active_admin.css.scss" do
+      expect(File.exists?(Rails.root + "app/assets/stylesheets/active_admin.css.scss")).to be_truthy
+    end
+
+    it "active_admin.js.coffee" do
+      expect(File.exists?(Rails.root + "app/assets/javascripts/active_admin.js.coffee")).to be_truthy
+    end
+
+    it "the dashboard" do
+      expect(File.exists?(Rails.root + "app/admin/dashboard.rb")).to be_truthy
+    end
+
+    it "the initializer" do
+      expect(File.exists?(Rails.root + "config/initializers/active_admin.rb")).to be_truthy
+    end
+
+  end
+end

data/spec/unit/helpers/collection_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Helpers::Collection do
 
@@ -6,9 +6,9 @@ describe ActiveAdmin::Helpers::Collection do
 
   before(:all) do
     Post.delete_all
-    Post.create!(:title => "A post")
-    Post.create!(:title => "A post")
-    Post.create!(:title => "An other post")
+    Post.create!(title: "A post")
+    Post.create!(title: "A post")
+    Post.create!(title: "An other post")
   end
 
   after(:all) do
@@ -17,49 +17,49 @@ describe ActiveAdmin::Helpers::Collection do
 
   describe "#collection_size" do
     it "should return the collection size for an ActiveRecord class" do
-      collection_size(Post).should == 3
+      expect(collection_size(Post.where(nil))).to eq 3
     end
 
     it "should return the collection size for an ActiveRecord::Relation" do
-      collection_size(Post.where(:title => "A post")).should == 2
+      expect(collection_size(Post.where(title: "A post"))).to eq 2
     end
 
     it "should return the collection size for a collection with group by" do
-      collection_size(Post.group(:title)).should == 2
+      expect(collection_size(Post.group(:title))).to eq 2
     end
 
     it "should return the collection size for a collection with group by, select and custom order" do
-      collection_size(Post.select("title, count(*) as nb_posts").group(:title).order("nb_posts")).should == 2
+      expect(collection_size(Post.select("title, count(*) as nb_posts").group(:title).order("nb_posts"))).to eq 2
     end
 
     it "should take the defined collection by default" do
-      def collection; Post; end
+      def collection; Post.where(nil); end
 
-      collection_size.should == 3
+      expect(collection_size).to eq 3
 
-      def collection; Post.where(:title => "An other post"); end
+      def collection; Post.where(title: "An other post"); end
 
-      collection_size.should == 1
+      expect(collection_size).to eq 1
     end
   end
 
   describe "#collection_is_empty?" do
     it "should return true when the collection is empty" do
-      collection_is_empty?(Post.where(:title => "Non existing post")).should be_true
+      expect(collection_is_empty?(Post.where(title: "Non existing post"))).to be_truthy
     end
 
     it "should return false when the collection is not empty" do
-      collection_is_empty?(Post.where(:title => "A post")).should be_false
+      expect(collection_is_empty?(Post.where(title: "A post"))).to be_falsey
     end
 
     it "should take the defined collection by default" do
-      def collection; Post; end
+      def collection; Post.where(nil); end
 
-      collection_is_empty?.should be_false
+      expect(collection_is_empty?).to be_falsey
 
-      def collection; Post.where(:title => "Non existing post"); end
+      def collection; Post.where(title: "Non existing post"); end
 
-      collection_is_empty?.should be_true
+      expect(collection_is_empty?).to be_truthy
     end
   end
 end

data/spec/unit/helpers/scope_chain_spec.rb

@@ -1,18 +1,18 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::ScopeChain do
 
   include ActiveAdmin::ScopeChain
 
   describe "#scope_chain" do
-    let(:relation) { mock }
+    let(:relation) { double }
 
     context "when Scope has a scope method" do
       let(:scope) { ActiveAdmin::Scope.new :published }
 
       it "should call the method on the relation and return it" do
-        relation.should_receive(:published).and_return(:scoped_relation)
-        scope_chain(scope, relation).should == :scoped_relation
+        expect(relation).to receive(:published).and_return(:scoped_relation)
+        expect(scope_chain(scope, relation)).to eq :scoped_relation
       end
     end
 
@@ -20,7 +20,7 @@ describe ActiveAdmin::ScopeChain do
       let(:scope) { ActiveAdmin::Scope.new :all }
 
       it "should return the relation" do
-        scope_chain(scope, relation).should == relation
+        expect(scope_chain(scope, relation)).to eq relation
       end
     end
 
@@ -28,7 +28,7 @@ describe ActiveAdmin::ScopeChain do
       let(:scope) { ActiveAdmin::Scope.new("My Scope"){|s| :scoped_relation } }
 
       it "should instance_exec the block and return it" do
-        scope_chain(scope, relation).should == :scoped_relation
+        expect(scope_chain(scope, relation)).to eq :scoped_relation
       end
     end
   end

data/spec/unit/helpers/settings_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'active_admin/helpers/settings'
 
 describe ActiveAdmin::Settings do
@@ -12,19 +12,19 @@ describe ActiveAdmin::Settings do
 
   it "should add a new setting with a default" do
     klass.setting :my_setting, "Hello World"
-    klass.default_settings[:my_setting].should == "Hello World"
+    expect(klass.default_settings[:my_setting]).to eq "Hello World"
   end
 
   it "should initialize the defaults" do
     klass.setting :my_setting, "Hello World"
-    klass.new.my_setting.should == "Hello World"
+    expect(klass.new.my_setting).to eq "Hello World"
   end
 
   it "should support settings of nil" do
     klass.setting :my_setting, :some_val
     inst = klass.new
     inst.my_setting = nil
-    inst.my_setting.should == nil
+    expect(inst.my_setting).to eq nil
   end
 
 end

data/spec/unit/i18n_spec.rb

@@ -0,0 +1,12 @@
+require 'rails_helper'
+
+Dir.glob('config/locales/*.yml') do |locale_file|
+  describe locale_file do
+    it { is_expected.to be_parseable }
+    it { is_expected.to have_one_top_level_namespace }
+    it { is_expected.to be_named_like_top_level_namespace }
+    it { is_expected.to_not have_legacy_interpolations }
+    it { is_expected.to have_a_valid_locale }
+    it { is_expected.to be_a_subset_of 'config/locales/en.yml' }
+  end
+end

data/spec/unit/menu_collection_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::MenuCollection do
 
@@ -7,17 +7,17 @@ describe ActiveAdmin::MenuCollection do
   describe "#add" do
 
     it "should initialize a new menu when first item" do
-      menus.add :default, :label => "Hello World"
+      menus.add :default, label: "Hello World"
 
-      menus.fetch(:default).items.size.should == 1
-      menus.fetch(:default)["Hello World"].should be_an_instance_of(ActiveAdmin::MenuItem)
+      expect(menus.fetch(:default).items.size).to eq 1
+      expect(menus.fetch(:default)["Hello World"]).to be_an_instance_of(ActiveAdmin::MenuItem)
     end
 
     it "should add items to an existing menu" do
-      menus.add :default, :label => "Hello World"
-      menus.add :default, :label => "Hello World Again"
+      menus.add :default, label: "Hello World"
+      menus.add :default, label: "Hello World Again"
 
-      menus.fetch(:default).items.size.should == 2
+      expect(menus.fetch(:default).items.size).to eq 2
     end
 
   end
@@ -25,13 +25,13 @@ describe ActiveAdmin::MenuCollection do
   describe "#clear!" do
 
     it "should remove all menus" do
-      menus.add :default, :label => "Hello World"
+      menus.add :default, label: "Hello World"
 
       menus.clear!
 
       expect {
         menus.fetch(:non_default_menu)
-      }.to raise_error(ActiveAdmin::MenuCollection::NoMenuError)
+      }.to raise_error(ActiveAdmin::NoMenuError)
 
     end
 
@@ -41,20 +41,20 @@ describe ActiveAdmin::MenuCollection do
 
     it "runs a callback when fetching a menu" do
       menus.on_build do |m|
-        m.add :default, :label => "Hello World"
+        m.add :default, label: "Hello World"
       end
 
-      menus.fetch(:default)["Hello World"].should_not be_nil
+      expect(menus.fetch(:default)["Hello World"]).to_not be_nil
     end
 
     it "re-runs the callbacks when the menu is cleared" do
       menus.on_build do |m|
-        m.add :default, :label => "Hello World"
+        m.add :default, label: "Hello World"
       end
 
-      menus.fetch(:default)["Hello World"].should_not be_nil
+      expect(menus.fetch(:default)["Hello World"]).to_not be_nil
       menus.clear!
-      menus.fetch(:default)["Hello World"].should_not be_nil
+      expect(menus.fetch(:default)["Hello World"]).to_not be_nil
     end
 
   end

data/spec/unit/menu_item_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper_without_rails'
+require 'spec_helper'
 require 'active_admin/menu'
 require 'active_admin/menu_item'
 
@@ -6,116 +6,116 @@ module ActiveAdmin
   describe MenuItem do
 
     it "should have a label" do
-      item = MenuItem.new(:label => "Dashboard")
-      item.label.should == "Dashboard"
+      item = MenuItem.new(label: "Dashboard")
+      expect(item.label).to eq "Dashboard"
     end
 
     it "should have a url" do
-      item = MenuItem.new(:url => "/admin")
-      item.url.should == "/admin"
+      item = MenuItem.new(url: "/admin")
+      expect(item.url).to eq "/admin"
     end
 
     it "should have a priority of 10 by default" do
       item = MenuItem.new
-      item.priority.should == 10
+      expect(item.priority).to eq 10
     end
 
     context "conditional display" do
       it "should store a Proc internally and evaluate it when requested" do
         item = MenuItem.new
-        item.instance_variable_get(:@should_display).should be_a Proc
-        item.display?.should_not be_a Proc
+        expect(item.instance_variable_get(:@should_display)).to be_a Proc
+        expect(item.display?).to_not be_a Proc
       end
 
       it "should show the item by default" do
-        MenuItem.new.display?.should == true
+        expect(MenuItem.new.display?).to eq true
       end
 
       it "should hide the item" do
-        MenuItem.new(:if => proc{false}).display?.should == false
+        expect(MenuItem.new(if: proc{false}).display?).to eq false
       end
     end
 
     it "should default to an empty hash for html_options" do
       item = MenuItem.new
-      item.html_options.should be_empty
+      expect(item.html_options).to be_empty
     end
 
     it "should accept an options hash for link_to" do
-      item = MenuItem.new :html_options => { :target => :blank }
-      item.html_options.should include(:target => :blank)
+      item = MenuItem.new html_options: { target: :blank }
+      expect(item.html_options).to include(target: :blank)
     end
 
     context "with no items" do
       it "should be empty" do
         item = MenuItem.new
-        item.items.should be_empty
+        expect(item.items).to be_empty
       end
 
       it "should accept new children" do
-        item = MenuItem.new :label => "Dashboard"
-        item.add            :label => "My Child Dashboard"
-        item.items.first.should be_a MenuItem
-        item.items.first.label.should == "My Child Dashboard"
+        item = MenuItem.new label: "Dashboard"
+        item.add            label: "My Child Dashboard"
+        expect(item.items.first).to be_a MenuItem
+        expect(item.items.first.label).to eq "My Child Dashboard"
       end
     end
 
     context "with many children" do
       let(:item) do
-        i = MenuItem.new(:label => "Dashboard")
-        i.add :label => "Blog"
-        i.add :label => "Cars"
-        i.add :label => "Users", :priority => 1
-        i.add :label => "Settings", :priority => 2
-        i.add :label => "Analytics", :priority => 44
+        i = MenuItem.new(label: "Dashboard")
+        i.add label: "Blog"
+        i.add label: "Cars"
+        i.add label: "Users", priority: 1
+        i.add label: "Settings", priority: 2
+        i.add label: "Analytics", priority: 44
         i
       end
 
       it "should contain 5 submenu items" do
-        item.items.count.should == 5
+        expect(item.items.count).to eq 5
       end
 
       it "should give access to the menu item as an array" do
-        item['Blog'].label.should == 'Blog'
+        expect(item['Blog'].label).to eq 'Blog'
       end
 
       it "should sort items based on priority and name" do
-        item.items[0].label.should == 'Users'
-        item.items[1].label.should == 'Settings'
-        item.items[2].label.should == 'Blog'
-        item.items[3].label.should == 'Cars'
-        item.items[4].label.should == 'Analytics'
+        expect(item.items[0].label).to eq 'Users'
+        expect(item.items[1].label).to eq 'Settings'
+        expect(item.items[2].label).to eq 'Blog'
+        expect(item.items[3].label).to eq 'Cars'
+        expect(item.items[4].label).to eq 'Analytics'
       end
 
       it "children should hold a reference to their parent" do
-        item["Blog"].parent.should == item
+        expect(item["Blog"].parent).to eq item
       end
     end
 
     describe "accessing ancestory" do
-      let(:item){ MenuItem.new :label => "Blog" }
+      let(:item){ MenuItem.new label: "Blog" }
 
       context "with no parent" do
         it "should return an empty array" do
-         item.ancestors.should == []
+         expect(item.ancestors).to eq []
         end
       end
 
       context "with one parent" do
         let(:sub_item) do
-          item.add :label => "Create New"
+          item.add label: "Create New"
           item["Create New"]
         end
         it "should return an array with the parent" do
-          sub_item.ancestors.should == [item]
+          expect(sub_item.ancestors).to eq [item]
         end
       end
 
       context "with many parents" do
         before(:each) do
-          c1 = {:label => "C1"}
-          c2 = {:label => "C2"}
-          c3 = {:label => "C3"}
+          c1 = {label: "C1"}
+          c2 = {label: "C2"}
+          c3 = {label: "C3"}
 
           item.add(c1).add(c2).add(c3)
 
@@ -123,7 +123,7 @@ module ActiveAdmin
         end
         let(:sub_item){ item["C1"]["C2"]["C3"] }
         it "should return an array with the parents in reverse order" do
-          sub_item.ancestors.should == [item["C1"]["C2"], item["C1"], item]
+          expect(sub_item.ancestors).to eq [item["C1"]["C2"], item["C1"], item]
         end
       end
     end # accessing ancestory
@@ -131,11 +131,11 @@ module ActiveAdmin
 
     describe "#id" do
       it "should be normalized" do
-        MenuItem.new(:id => "Foo Bar").id.should == "foo_bar"
+        expect(MenuItem.new(id: "Foo Bar").id).to eq "foo_bar"
       end
 
       it "should not accept Procs" do
-        expect{ MenuItem.new(:id => proc{"Dynamic"}).id }.to raise_error TypeError
+        expect{ MenuItem.new(id: proc{"Dynamic"}).id }.to raise_error TypeError
       end
     end
 

data/spec/unit/menu_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'active_admin/menu'
 require 'active_admin/menu_item'
 
@@ -9,63 +9,63 @@ describe ActiveAdmin::Menu do
   context "with no items" do
     it "should have an empty item collection" do
       menu = Menu.new
-      menu.items.should be_empty
+      expect(menu.items).to be_empty
     end
 
     it "should accept new items" do
       menu = Menu.new
-      menu.add :label => "Dashboard"
-      menu.items.first.label.should == "Dashboard"
+      menu.add label: "Dashboard"
+      expect(menu.items.first.label).to eq "Dashboard"
     end
   end
 
   context "with many items" do
     let(:menu) do
       Menu.new do |m|
-        m.add :label => "Dashboard"
-        m.add :label => "Blog"
+        m.add label: "Dashboard"
+        m.add label: "Blog"
       end
     end
 
     it "should give access to the menu item as an array" do
-      menu['Dashboard'].label.should == 'Dashboard'
+      expect(menu['Dashboard'].label).to eq 'Dashboard'
     end
   end
 
   describe "adding items with children" do
     it "should add an empty item if the parent does not exist" do
       menu = Menu.new
-      menu.add :parent => "Admin", :label => "Users"
+      menu.add parent: "Admin", label: "Users"
 
-      menu["Admin"]["Users"].should be_an_instance_of(ActiveAdmin::MenuItem)
+      expect(menu["Admin"]["Users"]).to be_an_instance_of(ActiveAdmin::MenuItem)
     end
 
     it "should add a child to a parent if it exists" do
       menu = Menu.new
-      menu.add :parent => "Admin", :label => "Users"
-      menu.add :parent => "Admin", :label => "Projects"
+      menu.add parent: "Admin", label: "Users"
+      menu.add parent: "Admin", label: "Projects"
 
-      menu["Admin"]["Projects"].should be_an_instance_of(ActiveAdmin::MenuItem)
+      expect(menu["Admin"]["Projects"]).to be_an_instance_of(ActiveAdmin::MenuItem)
     end
 
     it "should assign children regardless of resource file load order" do
       menu = Menu.new
-      menu.add :parent => "Users", :label => "Posts"
-      menu.add :label  => "Users", :url   => "/some/url"
+      menu.add parent: "Users", label: "Posts"
+      menu.add label: "Users", url: "/some/url"
 
-      menu["Users"].url.should == "/some/url"
-      menu["Users"]["Posts"].should be_a ActiveAdmin::MenuItem
+      expect(menu["Users"].url).to eq "/some/url"
+      expect(menu["Users"]["Posts"]).to be_a ActiveAdmin::MenuItem
     end
   end
 
   describe "sorting items" do
     it "should sort children by the result of their label proc" do
       menu = Menu.new
-      menu.add :label => proc{ "G" }, :id => "not related 1"
-      menu.add :label => proc{ "B" }, :id => "not related 2"
-      menu.add :label => proc{ "A" }, :id => "not related 3"
+      menu.add label: proc{ "G" }, id: "not related 1"
+      menu.add label: proc{ "B" }, id: "not related 2"
+      menu.add label: proc{ "A" }, id: "not related 3"
 
-      menu.items.map(&:label).should == %w[A B G]
+      expect(menu.items.map(&:label)).to eq %w[A B G]
     end
   end
 end