yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/spec/unit/namespace/authorization_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Resource, "authorization" do
 
@@ -9,18 +9,18 @@ describe ActiveAdmin::Resource, "authorization" do
   describe "authorization_adapter" do
 
     it "should return AuthorizationAdapter by default" do
-      app.authorization_adapter.should       eq ActiveAdmin::AuthorizationAdapter
-      namespace.authorization_adapter.should eq ActiveAdmin::AuthorizationAdapter
+      expect(app.authorization_adapter).to       eq ActiveAdmin::AuthorizationAdapter
+      expect(namespace.authorization_adapter).to eq ActiveAdmin::AuthorizationAdapter
     end
 
     it "should be settable on the namespace" do
       namespace.authorization_adapter = auth
-      namespace.authorization_adapter.should eq auth
+      expect(namespace.authorization_adapter).to eq auth
     end
 
     it "should be settable on the application" do
       app.authorization_adapter = auth
-      app.authorization_adapter.should eq auth
+      expect(app.authorization_adapter).to eq auth
     end
 
   end

data/spec/unit/namespace/register_page_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Namespace, "registering a page" do
 
@@ -13,15 +13,15 @@ describe ActiveAdmin::Namespace, "registering a page" do
     end
 
     it "should store the namespaced registered configuration" do
-      namespace.resources.keys.should include('Status')
+      expect(namespace.resources.keys).to include('Status')
     end
 
     it "should create a new controller in the default namespace" do
-      defined?(Admin::StatusController).should be_true
+      expect(defined?(Admin::StatusController)).to be_truthy
     end
 
     it "should create a menu item" do
-      menu["Status"].should be_an_instance_of(ActiveAdmin::MenuItem)
+      expect(menu["Status"]).to be_an_instance_of(ActiveAdmin::MenuItem)
     end
   end # context "with no configuration"
 
@@ -42,21 +42,21 @@ describe ActiveAdmin::Namespace, "registering a page" do
       end
 
       it "should add a new menu item" do
-        menu['Status'].should_not be_nil
+        expect(menu['Status']).to_not be_nil
       end
     end # describe "adding as a top level item"
 
     describe "adding as a child" do
       before do
         namespace.register_page "Status" do
-          menu :parent => 'Extra'
+          menu parent: 'Extra'
         end
       end
       it "should generate the parent menu item" do
-        menu['Extra'].should_not be_nil
+       expect( menu['Extra']).to_not be_nil
       end
       it "should generate its own child item" do
-        menu['Extra']['Status'].should_not be_nil
+        expect(menu['Extra']['Status']).to_not be_nil
       end
     end # describe "adding as a child"
 
@@ -67,7 +67,7 @@ describe ActiveAdmin::Namespace, "registering a page" do
         end
       end
       it "should not create a menu item" do
-        menu["Status"].should be_nil
+        expect(menu["Status"]).to be_nil
       end
     end # describe "disabling the menu"
   end # describe "adding to the menu"

data/spec/unit/namespace/register_resource_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 
 # TODO: refactor this file so it doesn't depend on the Admin namespace in such a broken way.
-#       Specifically, the dashboard is already defined and we do let(:namespace) multiple times.
+#       Specifically, the dashboard is already defined.
 
 describe ActiveAdmin::Namespace, "registering a resource" do
 
@@ -16,17 +16,17 @@ describe ActiveAdmin::Namespace, "registering a resource" do
       namespace.register Category
     end
     it "should store the namespaced registered configuration" do
-      namespace.resources.keys.should include('Category')
+      expect(namespace.resources.keys).to include('Category')
     end
     it "should create a new controller in the default namespace" do
-      defined?(Admin::CategoriesController).should be_true
+      expect(defined?(Admin::CategoriesController)).to be_truthy
     end
-    pending "should not create the dashboard controller" do
-      defined?(Admin::DashboardController).should_not be_true
+    skip "should not create the dashboard controller" do
+      defined?(Admin::DashboardController).to_not be_truthy
     end
     it "should create a menu item" do
-      menu["Categories"].should be_a ActiveAdmin::MenuItem
-      menu["Categories"].instance_variable_get(:@url).should be_a Proc
+      expect(menu["Categories"]).to be_a ActiveAdmin::MenuItem
+      expect(menu["Categories"].instance_variable_get(:@url)).to be_a Proc
     end
   end # context "with no configuration"
 
@@ -47,41 +47,39 @@ describe ActiveAdmin::Namespace, "registering a resource" do
     end
 
     it "should store the namespaced registered configuration" do
-      namespace.resources.keys.should include('Mock::Resource')
+      expect(namespace.resources.keys).to include('Mock::Resource')
     end
     it "should create a new controller in the default namespace" do
-      defined?(Admin::MockResourcesController).should be_true
+      expect(defined?(Admin::MockResourcesController)).to be_truthy
     end
     it "should create a menu item" do
-      menu["Mock Resources"].should be_an_instance_of(ActiveAdmin::MenuItem)
+      expect(menu["Mock Resources"]).to be_an_instance_of(ActiveAdmin::MenuItem)
     end
 
     it "should use the resource as the model in the controller" do
-      Admin::MockResourcesController.resource_class.should == Mock::Resource
+      expect(Admin::MockResourcesController.resource_class).to eq Mock::Resource
     end
   end # context "with a resource that's namespaced"
 
   describe "finding resource instances" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
     it "should return the resource when its been registered" do
       post = namespace.register Post
-      namespace.resource_for(Post).should == post
+      expect(namespace.resource_for(Post)).to eq post
     end
 
     it 'should return nil when the resource has not been registered' do
-      namespace.resource_for(Post).should == nil
+      expect(namespace.resource_for(Post)).to eq nil
     end
 
     it "should return the parent when the parent class has been registered and the child has not" do
       user = namespace.register User
-      namespace.resource_for(Publisher).should == user
+      expect(namespace.resource_for(Publisher)).to eq user
     end
 
     it "should return the resource if it and it's parent were registered" do
       user = namespace.register User
       publisher = namespace.register Publisher
-      namespace.resource_for(Publisher).should == publisher
+      expect(namespace.resource_for(Publisher)).to eq publisher
     end
   end # describe "finding resource instances"
 
@@ -91,21 +89,21 @@ describe ActiveAdmin::Namespace, "registering a resource" do
         namespace.register Category
       end
       it "should add a new menu item" do
-        menu['Categories'].should_not be_nil
+        expect(menu['Categories']).to_not be_nil
       end
     end # describe "adding as a top level item"
 
     describe "adding as a child" do
       before do
         namespace.register Category do
-          menu :parent => 'Blog'
+          menu parent: 'Blog'
         end
       end
       it "should generate the parent menu item" do
-        menu['Blog'].should_not be_nil
+        expect(menu['Blog']).to_not be_nil
       end
       it "should generate its own child item" do
-        menu['Blog']['Categories'].should_not be_nil
+        expect(menu['Blog']['Categories']).to_not be_nil
       end
     end # describe "adding as a child"
 
@@ -116,7 +114,7 @@ describe ActiveAdmin::Namespace, "registering a resource" do
         end
       end
       it "should not create a menu item" do
-        menu["Categories"].should be_nil
+        expect(menu["Categories"]).to be_nil
       end
     end # describe "disabling the menu"
 
@@ -128,17 +126,17 @@ describe ActiveAdmin::Namespace, "registering a resource" do
           end
         end
         it "should not show up in the menu" do
-          menu["Posts"].should be_nil
+          expect(menu["Posts"]).to be_nil
         end
       end
       context "when optional" do
         before do
           namespace.register Post do
-            belongs_to :author, :optional => true
+            belongs_to :author, optional: true
           end
         end
         it "should show up in the menu" do
-          menu["Posts"].should_not be_nil
+          expect(menu["Posts"]).to_not be_nil
         end
       end
     end
@@ -149,14 +147,14 @@ describe ActiveAdmin::Namespace, "registering a resource" do
       it "should be namespaced" do
         namespace = ActiveAdmin::Namespace.new(application, :one)
         namespace.register Category
-        defined?(One::CategoriesController).should be_true
+        expect(defined?(One::CategoriesController)).to be_truthy
       end
     end
     context "when not namespaced" do
       it "should not be namespaced" do
         namespace = ActiveAdmin::Namespace.new(application, :two)
         namespace.register Category
-        defined?(Two::CategoriesController).should be_true
+        expect(defined?(Two::CategoriesController)).to be_truthy
       end
     end
   end # describe "dashboard controller name"

data/spec/unit/namespace_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Namespace do
 
@@ -8,19 +8,19 @@ describe ActiveAdmin::Namespace do
     let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
 
     it "should have an application instance" do
-      namespace.application.should == application
+      expect(namespace.application).to eq application
     end
 
     it "should have a name" do
-      namespace.name.should == :admin
+      expect(namespace.name).to eq :admin
     end
 
     it "should have no resources" do
-      namespace.resources.should be_empty
+      expect(namespace.resources).to be_empty
     end
 
     it "should not have any menu item" do
-      namespace.fetch_menu(:default).children.should be_empty
+      expect(namespace.fetch_menu(:default).children).to be_empty
     end
   end # context "when new"
 
@@ -29,13 +29,13 @@ describe ActiveAdmin::Namespace do
 
     it "should inherit the site title from the application" do
       ActiveAdmin::Namespace.setting :site_title, "Not the Same"
-      namespace.site_title.should == application.site_title
+      expect(namespace.site_title).to eq application.site_title
     end
 
     it "should be able to override the site title" do
-      namespace.site_title.should == application.site_title
+      expect(namespace.site_title).to eq application.site_title
       namespace.site_title = "My Site Title"
-      namespace.site_title.should_not == application.site_title
+      expect(namespace.site_title).to_not eq application.site_title
     end
   end
 
@@ -44,11 +44,11 @@ describe ActiveAdmin::Namespace do
     let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
 
     it "returns the menu" do
-      namespace.fetch_menu(:default).should be_an_instance_of(ActiveAdmin::Menu)
+      expect(namespace.fetch_menu(:default)).to be_an_instance_of(ActiveAdmin::Menu)
     end
 
     it "should have utility nav menu" do
-      namespace.fetch_menu(:utility_navigation).should be_an_instance_of(ActiveAdmin::Menu)
+      expect(namespace.fetch_menu(:utility_navigation)).to be_an_instance_of(ActiveAdmin::Menu)
     end
 
     it "should raise an exception if the menu doesn't exist" do
@@ -63,18 +63,18 @@ describe ActiveAdmin::Namespace do
 
     it "should set the block as a menu build callback" do
       namespace.build_menu do |menu|
-        menu.add :label => "menu item"
+        menu.add label: "menu item"
       end
 
-      namespace.fetch_menu(:default)["menu item"].should_not be_nil
+      expect(namespace.fetch_menu(:default)["menu item"]).to_not be_nil
     end
 
     it "should set a block on a custom menu" do
       namespace.build_menu :test do |menu|
-        menu.add :label => "menu item"
+        menu.add label: "menu item"
       end
 
-      namespace.fetch_menu(:test)["menu item"].should_not be_nil
+      expect(namespace.fetch_menu(:test)["menu item"]).to_not be_nil
     end
   end
 
@@ -82,20 +82,20 @@ describe ActiveAdmin::Namespace do
     let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
     let(:menu) do
       namespace.build_menu :utility_navigation do |menu|
-        menu.add :label => "ActiveAdmin.info", :url => "http://www.activeadmin.info", :html_options => { :target => :blank }
-        namespace.add_logout_button_to_menu menu, 1, :class => "matt"
+        menu.add label: "ActiveAdmin.info", url: "http://www.activeadmin.info", html_options: { target: :blank }
+        namespace.add_logout_button_to_menu menu, 1, class: "matt"
       end
       namespace.fetch_menu(:utility_navigation)
     end
 
     it "should have a logout button to the far left" do
-      menu["Logout"].should_not be_nil
-      menu["Logout"].priority.should == 1
+      expect(menu["Logout"]).to_not be_nil
+      expect(menu["Logout"].priority).to eq 1
     end
 
     it "should have a static link with a target of :blank" do
-      menu["ActiveAdmin.info"].should_not be_nil
-      menu["ActiveAdmin.info"].html_options.should include(:target => :blank)
+      expect(menu["ActiveAdmin.info"]).to_not be_nil
+      expect(menu["ActiveAdmin.info"].html_options).to include(target: :blank)
     end
 
   end

data/spec/unit/order_clause_spec.rb

@@ -0,0 +1,81 @@
+require 'rails_helper'
+
+describe ActiveAdmin::OrderClause do
+  subject { described_class.new clause }
+
+  let(:application) { ActiveAdmin::Application.new }
+  let(:namespace)   { ActiveAdmin::Namespace.new application, :admin }
+  let(:config)      { ActiveAdmin::Resource.new namespace, Post }
+
+  describe 'id_asc (existing column)' do
+    let(:clause) { 'id_asc' }
+
+    it { is_expected.to be_valid }
+
+    describe '#field' do
+      subject { super().field }
+      it { is_expected.to eq('id') }
+    end
+
+    describe '#order' do
+      subject { super().order }
+      it { is_expected.to eq('asc') }
+    end
+
+    specify '#to_sql prepends table name' do
+      expect(subject.to_sql(config)).to eq '"posts"."id" asc'
+    end
+  end
+
+  describe 'virtual_column_asc' do
+    let(:clause) { 'virtual_column_asc' }
+
+    it { is_expected.to be_valid }
+
+    describe '#field' do
+      subject { super().field }
+      it { is_expected.to eq('virtual_column') }
+    end
+
+    describe '#order' do
+      subject { super().order }
+      it { is_expected.to eq('asc') }
+    end
+
+    specify '#to_sql' do
+      expect(subject.to_sql(config)).to eq '"virtual_column" asc'
+    end
+  end
+
+  describe "hstore_col->'field'_desc" do
+    let(:clause) { "hstore_col->'field'_desc" }
+
+    it { is_expected.to be_valid }
+
+    describe '#field' do
+      subject { super().field }
+      it { is_expected.to eq("hstore_col->'field'") }
+    end
+
+    describe '#order' do
+      subject { super().order }
+      it { is_expected.to eq('desc') }
+    end
+
+    it 'converts to sql' do
+      expect(subject.to_sql(config)).to eq %Q("hstore_col"->'field' desc)
+    end
+  end
+
+  describe '_asc' do
+    let(:clause) { '_asc' }
+
+    it { is_expected.not_to be_valid }
+  end
+
+  describe 'nil' do
+    let(:clause) { nil }
+
+    it { is_expected.not_to be_valid }
+  end
+end

data/spec/unit/page_controller_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::PageController do
   let(:controller) { ActiveAdmin::PageController.new }

data/spec/unit/page_spec.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-require 'spec_helper'
+require 'rails_helper'
 require File.expand_path('config_shared_examples', File.dirname(__FILE__))
 
 module ActiveAdmin
   describe Page do
 
-    it_should_behave_like "ActiveAdmin::Config"
+    it_should_behave_like "ActiveAdmin::Resource"
     before { load_defaults! }
 
     let(:application){ ActiveAdmin::Application.new }
@@ -18,54 +18,60 @@ module ActiveAdmin
 
     describe "controller name" do
       it "should return a namespaced controller name" do
-        config.controller_name.should == "Admin::ChocolateILoveYouController"
+        expect(config.controller_name).to eq "Admin::ChocolateILoveYouController"
       end
       context "when non namespaced controller" do
         let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
         it "should return a non namespaced controller name" do
-          config.controller_name.should == "ChocolateILoveYouController"
+          expect(config.controller_name).to eq "ChocolateILoveYouController"
         end
       end
     end
 
     describe "#resource_name" do
       it "returns the name" do
-        config.resource_name.should == "Chocolate I lØve You!"
+        expect(config.resource_name).to eq "Chocolate I lØve You!"
       end
 
       it "returns the singular, lowercase name" do
-        config.resource_name.singular.should == "chocolate i lØve you!"
+        expect(config.resource_name.singular).to eq "chocolate i lØve you!"
       end
     end
 
     describe "#plural_resource_label" do
       it "returns the singular name" do
-        config.plural_resource_label.should == "Chocolate I lØve You!"
+        expect(config.plural_resource_label).to eq "Chocolate I lØve You!"
       end
     end
 
     describe "#underscored_resource_name" do
       it "returns the resource name underscored" do
-        config.underscored_resource_name.should == "chocolate_i_love_you"
+        expect(config.underscored_resource_name).to eq "chocolate_i_love_you"
       end
     end
 
     describe "#camelized_resource_name" do
       it "returns the resource name camel case" do
-        config.camelized_resource_name.should == "ChocolateILoveYou"
+        expect(config.camelized_resource_name).to eq "ChocolateILoveYou"
+      end
+    end
+
+    describe "#namespace_name" do
+      it "returns the name of the namespace" do
+        expect(config.namespace_name).to eq "admin"
       end
     end
 
     it "should not belong_to anything" do
-      config.belongs_to?.should == false
+      expect(config.belongs_to?).to eq false
     end
 
     it "should not have any action_items" do
-      config.action_items?.should == false
+      expect(config.action_items?).to eq false
     end
 
     it "should not have any sidebar_sections" do
-      config.sidebar_sections?.should == false
+      expect(config.sidebar_sections?).to eq false
     end
 
   end