yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/spec/unit/scope_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Scope do
 
@@ -7,41 +7,123 @@ describe ActiveAdmin::Scope do
 
     context "when just a scope method" do
       let(:scope)        { ActiveAdmin::Scope.new :published }
-      its(:name)         { should == "Published"}
-      its(:id)           { should == "published"}
-      its(:scope_method) { should == :published }
+
+      describe '#name' do
+        subject { super().name }
+        it         { is_expected.to eq("Published")}
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it           { is_expected.to eq("published")}
+      end
+
+      describe '#scope_method' do
+        subject { super().scope_method }
+        it { is_expected.to eq(:published) }
+      end
     end
 
     context "when scope method is :all" do
       let(:scope)        { ActiveAdmin::Scope.new :all }
-      its(:name)         { should == "All"}
-      its(:id)           { should == "all"}
+
+      describe '#name' do
+        subject { super().name }
+        it         { is_expected.to eq("All")}
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it           { is_expected.to eq("all")}
+      end
       # :all does not return a chain but an array of active record
       # instances. We set the scope_method to nil then.
-      its(:scope_method) { should == nil }
-      its(:scope_block)  { should == nil }
+
+      describe '#scope_method' do
+        subject { super().scope_method }
+        it { is_expected.to eq(nil) }
+      end
+
+      describe '#scope_block' do
+        subject { super().scope_block }
+        it  { is_expected.to eq(nil) }
+      end
     end
 
     context 'when a name and scope method is :all' do
       let(:scope)        { ActiveAdmin::Scope.new 'Tous', :all }
-      its(:name)         { should eq 'Tous' }
-      its(:scope_method) { should be_nil }
-      its(:scope_block)  { should be_nil }
+
+      describe '#name' do
+        subject { super().name }
+        it         { is_expected.to eq 'Tous' }
+      end
+
+      describe '#scope_method' do
+        subject { super().scope_method }
+        it { is_expected.to be_nil }
+      end
+
+      describe '#scope_block' do
+        subject { super().scope_block }
+        it  { is_expected.to be_nil }
+      end
     end
 
     context "when a name and scope method" do
       let(:scope)        { ActiveAdmin::Scope.new "With API Access", :with_api_access }
-      its(:name)         { should == "With API Access"}
-      its(:id)           { should == "with_api_access"}
-      its(:scope_method) { should == :with_api_access }
+
+      describe '#name' do
+        subject { super().name }
+        it         { is_expected.to eq("With API Access")}
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it           { is_expected.to eq("with_api_access")}
+      end
+
+      describe '#scope_method' do
+        subject { super().scope_method }
+        it { is_expected.to eq(:with_api_access) }
+      end
     end
 
     context "when a name and scope block" do
       let(:scope)        { ActiveAdmin::Scope.new("My Scope"){|s| s } }
-      its(:name)         { should == "My Scope"}
-      its(:id)           { should == "my_scope"}
-      its(:scope_method) { should == nil }
-      its(:scope_block)  { should be_a(Proc)}
+
+      describe '#name' do
+        subject { super().name }
+        it         { is_expected.to eq("My Scope")}
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it           { is_expected.to eq("my_scope")}
+      end
+
+      describe '#scope_method' do
+        subject { super().scope_method }
+        it { is_expected.to eq(nil) }
+      end
+
+      describe '#scope_block' do
+        subject { super().scope_block }
+        it  { is_expected.to be_a(Proc)}
+      end
+    end
+
+    context "when a name has a space and lowercase" do
+      let(:scope)        { ActiveAdmin::Scope.new("my scope") }
+
+      describe '#name' do
+        subject { super().name }
+        it         { is_expected.to eq("my scope")}
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it           { is_expected.to eq("my_scope")}
+      end
     end
 
     context "with a proc as the label" do
@@ -52,7 +134,7 @@ describe ActiveAdmin::Scope do
 
       it "should properly render the proc" do
         scope = ActiveAdmin::Scope.new proc{ Date.today.strftime '%A' }, :foobar
-        scope.name.should eq Date.today.strftime '%A'
+        expect(scope.name).to eq Date.today.strftime '%A'
       end
     end
 
@@ -62,12 +144,12 @@ describe ActiveAdmin::Scope do
 
     it "should return true by default" do
       scope = ActiveAdmin::Scope.new(:default)
-      scope.display_if_block.call.should == true
+      expect(scope.display_if_block.call).to eq true
     end
 
     it "should return the :if block if set" do
-      scope = ActiveAdmin::Scope.new(:with_block, nil, :if => proc{ false })
-      scope.display_if_block.call.should == false
+      scope = ActiveAdmin::Scope.new(:with_block, nil, if: proc{ false })
+      expect(scope.display_if_block.call).to eq false
     end
 
   end
@@ -75,18 +157,18 @@ describe ActiveAdmin::Scope do
   describe "#default" do
 
     it "should accept a boolean" do
-      scope = ActiveAdmin::Scope.new(:method, nil, :default => true)
-      scope.default_block.should == true
+      scope = ActiveAdmin::Scope.new(:method, nil, default: true)
+      expect(scope.default_block).to eq true
     end
 
     it "should default to a false #default_block" do
       scope = ActiveAdmin::Scope.new(:method, nil)
-      scope.default_block.call.should == false
+      expect(scope.default_block.call).to eq false
     end
 
     it "should store the :default proc" do
-      scope = ActiveAdmin::Scope.new(:with_block, nil, :default => proc{ true })
-      scope.default_block.call.should == true
+      scope = ActiveAdmin::Scope.new(:with_block, nil, default: proc{ true })
+      expect(scope.default_block.call).to eq true
     end
 
   end
@@ -94,13 +176,13 @@ describe ActiveAdmin::Scope do
   describe "show_count" do
 
     it "should allow setting of show_count to prevent showing counts" do
-      scope = ActiveAdmin::Scope.new(:default, nil, :show_count => false)
-      scope.show_count.should == false
+      scope = ActiveAdmin::Scope.new(:default, nil, show_count: false)
+      expect(scope.show_count).to eq false
     end
 
     it "should set show_count to true if not passed in" do
       scope = ActiveAdmin::Scope.new(:default)
-      scope.show_count.should == true
+      expect(scope.show_count).to eq true
     end
 
   end

data/spec/unit/settings_spec.rb

@@ -1,23 +1,23 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Settings do
 
   subject{ Class.new{ include ActiveAdmin::Settings } }
 
-  it{ should respond_to :setting }
-  it{ should respond_to :deprecated_setting }
-  it{ should respond_to :default_settings }
+  it{ is_expected.to respond_to :setting }
+  it{ is_expected.to respond_to :deprecated_setting }
+  it{ is_expected.to respond_to :default_settings }
 
   describe "class API" do
     it "should create settings" do
       subject.setting :foo, 'bar'
-      subject.default_settings[:foo].should eq 'bar'
+      expect(subject.default_settings[:foo]).to eq 'bar'
     end
 
     it "should create deprecated settings" do
-      ActiveAdmin::Deprecation.should_receive(:deprecate).twice
+      expect(ActiveAdmin::Deprecation).to receive(:deprecate).twice
       subject.deprecated_setting :baz, 32
-      subject.default_settings[:baz].should eq 32
+      expect(subject.default_settings[:baz]).to eq 32
     end
   end
 
@@ -30,16 +30,16 @@ describe ActiveAdmin::Settings do
     let(:instance) { subject.new }
 
     it "should have access to a default value" do
-      instance.foo.should eq 'bar'
+      expect(instance.foo).to eq 'bar'
       instance.foo = 'qqq'
-      instance.foo.should eq 'qqq'
+      expect(instance.foo).to eq 'qqq'
     end
 
     it "should have access to a deprecated value" do
-      ActiveAdmin::Deprecation.should_receive(:warn).exactly(3).times
-      instance.baz.should eq 32
+      expect(ActiveAdmin::Deprecation).to receive(:warn).exactly(3).times
+      expect(instance.baz).to eq 32
       instance.baz = [45]
-      instance.baz.should eq [45]
+      expect(instance.baz).to eq [45]
     end
   end
 
@@ -55,9 +55,9 @@ describe ActiveAdmin::Settings::Inheritance do
     end
   end
 
-  it{ should respond_to :settings_inherited_by }
-  it{ should respond_to :inheritable_setting }
-  it{ should respond_to :deprecated_inheritable_setting }
+  it{ is_expected.to respond_to :settings_inherited_by }
+  it{ is_expected.to respond_to :inheritable_setting }
+  it{ is_expected.to respond_to :deprecated_inheritable_setting }
 
   let(:heir) { Class.new }
 
@@ -68,20 +68,50 @@ describe ActiveAdmin::Settings::Inheritance do
   describe "class API" do
     it "should add setting to an heir" do
       subject.inheritable_setting :one, 2
-      heir.default_settings[:one].should eq 2
+      expect(heir.default_settings[:one]).to eq 2
     end
 
     it "should add deprecated setting to an heir" do
-      ActiveAdmin::Deprecation.should_receive(:deprecate).exactly(4).times
+      expect(ActiveAdmin::Deprecation).to receive(:deprecate).exactly(4).times
       subject.deprecated_inheritable_setting :three, 4
-      heir.default_settings[:three].should eq 4
+      expect(heir.default_settings[:three]).to eq 4
     end
   end
 
   describe "instance API" do
-    before{ subject.inheritable_setting :left, :right }
-    it "should work" do
-      heir.new.left.should eq :right
+    describe "the setter `config.left =`" do
+      before{ subject.inheritable_setting :left, :right }
+      it "should work" do
+        config = heir.new
+        config.left = :none
+        expect(config.left).to eq :none
+      end
+    end
+
+    describe "the getter `config.left`" do
+      before{ subject.inheritable_setting :left, :right }
+      it "should work" do
+        expect(heir.new.left).to eq :right
+      end
+    end
+
+    describe "the getter with question-mark `config.left?`" do
+      {
+        "nil" => [nil, false],
+        "false" => [false, false],
+        "true" => [true, true],
+        "string" => ["string", true],
+        "empty string" => ["", false],
+        "array" => [[1, 2], true],
+        "empty array" => [[], false]
+      }.each do |context, (value, result)|
+        context "with a #{context} value" do
+          before{ subject.inheritable_setting :left, value }
+          it "should be #{result}" do
+            expect(heir.new.left?).to eq result
+          end
+        end
+      end
     end
   end
 

data/spec/unit/view_factory_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 def it_should_have_view(key, value)
   it "should have #{value} for view key '#{key}'" do
-    subject.send(key).should  == value
+    expect(subject.send(key)).to  eq value
   end
 end
 

data/spec/unit/view_helpers/breadcrumbs_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe "Breadcrumbs" do
 
@@ -7,15 +7,19 @@ describe "Breadcrumbs" do
   describe "generating a trail from paths" do
 
     def params; {}; end
-    def link_to(name, url); {:name => name, :path => url}; end
+    def link_to(name, url); {name: name, path: url}; end
 
+    actions = ActiveAdmin::BaseController::ACTIVE_ADMIN_ACTIONS
+
+    let(:user)        { double display_name: 'Jane Doe' }
+    let(:user_config) { double find_resource: user, resource_name: double(route_key: 'users'),
+                               defined_actions: actions }
     let(:post)        { double display_name: 'Hello World' }
-    let(:post_config) { double find_resource: post }
+    let(:post_config) { double find_resource: post, resource_name: double(route_key: 'posts'),
+                               defined_actions: actions, belongs_to_config: double(target: user_config) }
 
     let :active_admin_config do
-      active_admin_config = double
-      active_admin_config.stub_chain(:belongs_to_config, :target).and_return post_config
-      active_admin_config
+      post_config
     end
 
     let(:trail) { breadcrumb_links(path) }
@@ -24,124 +28,188 @@ describe "Breadcrumbs" do
       let(:path) { "/admin" }
 
       it "should not have any items" do
-        trail.size.should == 0
+        expect(trail.size).to eq 0
+      end
+    end
+
+    context "when path 'admin/users'" do
+      let(:path) { 'admin/users' }
+
+      it 'should have one item' do
+        expect(trail.size).to eq 1
+      end
+      it 'should have a link to /admin' do
+        expect(trail[0][:name]).to eq 'Admin'
+        expect(trail[0][:path]).to eq '/admin'
       end
     end
 
-    context "when path '/admin/posts'" do
-      let(:path) { "/admin/posts" }
+    context "when path '/admin/users'" do
+      let(:path) { "/admin/users" }
 
       it "should have one item" do
-        trail.size.should == 1
+        expect(trail.size).to eq 1
       end
       it "should have a link to /admin" do
-        trail[0][:name].should == "Admin"
-        trail[0][:path].should == "/admin"
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
       end
     end
 
-    context "when path '/admin/posts/1'" do
-      let(:path) { "/admin/posts/1" }
+    context "when path '/admin/users/1'" do
+      let(:path) { "/admin/users/1" }
 
       it "should have 2 items" do
-        trail.size.should == 2
+        expect(trail.size).to eq 2
       end
       it "should have a link to /admin" do
-        trail[0][:name].should == "Admin"
-        trail[0][:path].should == "/admin"
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
       end
-      it "should have a link to /admin/posts" do
-        trail[1][:name].should == "Posts"
-        trail[1][:path].should == "/admin/posts"
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
       end
     end
 
-    context "when path '/admin/posts/1/comments'" do
-      let(:path) { "/admin/posts/1/comments" }
+    context "when path '/admin/users/1/posts'" do
+      let(:path) { "/admin/users/1/posts" }
 
       it "should have 3 items" do
-        trail.size.should == 3
+        expect(trail.size).to eq 3
       end
       it "should have a link to /admin" do
-        trail[0][:name].should == "Admin"
-        trail[0][:path].should == "/admin"
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
       end
-      it "should have a link to /admin/posts" do
-        trail[1][:name].should == "Posts"
-        trail[1][:path].should == "/admin/posts"
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
       end
 
-      context "when Post.find(1) doesn't exist" do
-        before { post_config.stub(find_resource: nil) }
-        it "should have a link to /admin/posts/1" do
-          trail[2][:name].should == "1"
-          trail[2][:path].should == "/admin/posts/1"
+      context "when User.find(1) doesn't exist" do
+        before { allow(user_config).to receive(:find_resource) }
+        it "should have a link to /admin/users/1" do
+          expect(trail[2][:name]).to eq "1"
+          expect(trail[2][:path]).to eq "/admin/users/1"
         end
       end
 
-      context "when Post.find(1) does exist" do
-        it "should have a link to /admin/posts/1 using display name" do
-          trail[2][:name].should == "Hello World"
-          trail[2][:path].should == "/admin/posts/1"
+      context "when User.find(1) does exist" do
+        it "should have a link to /admin/users/1 using display name" do
+          expect(trail[2][:name]).to eq "Jane Doe"
+          expect(trail[2][:path]).to eq "/admin/users/1"
         end
       end
     end
 
-    context "when path '/admin/posts/4e24d6249ccf967313000000/comments'" do
-      let(:path) { "/admin/posts/4e24d6249ccf967313000000/comments" }
+    context "when path '/admin/users/4e24d6249ccf967313000000/posts'" do
+      let(:path) { "/admin/users/4e24d6249ccf967313000000/posts" }
 
       it "should have 3 items" do
-        trail.size.should == 3
+        expect(trail.size).to eq 3
       end
       it "should have a link to /admin" do
-        trail[0][:name].should == "Admin"
-        trail[0][:path].should == "/admin"
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
       end
-      it "should have a link to /admin/posts" do
-        trail[1][:name].should == "Posts"
-        trail[1][:path].should == "/admin/posts"
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
       end
 
-      context "when Post.find(4e24d6249ccf967313000000) doesn't exist" do
-        before { post_config.stub(find_resource: nil) }
-        it "should have a link to /admin/posts/4e24d6249ccf967313000000" do
-          trail[2][:name].should == "4e24d6249ccf967313000000"
-          trail[2][:path].should == "/admin/posts/4e24d6249ccf967313000000"
+      context "when User.find(4e24d6249ccf967313000000) doesn't exist" do
+        before { allow(user_config).to receive(:find_resource) }
+        it "should have a link to /admin/users/4e24d6249ccf967313000000" do
+          expect(trail[2][:name]).to eq "4e24d6249ccf967313000000"
+          expect(trail[2][:path]).to eq "/admin/users/4e24d6249ccf967313000000"
         end
       end
 
-      context "when Post.find(4e24d6249ccf967313000000) does exist" do
+      context "when User.find(4e24d6249ccf967313000000) does exist" do
         before do
-          post_config.stub find_resource: double(display_name: 'Hello :)')
+          display_name = double(display_name: 'Hello :)')
+          allow(user_config).to receive(:find_resource).and_return(display_name) 
         end
-        it "should have a link to /admin/posts/4e24d6249ccf967313000000 using display name" do
-          trail[2][:name].should == "Hello :)"
-          trail[2][:path].should == "/admin/posts/4e24d6249ccf967313000000"
+        it "should have a link to /admin/users/4e24d6249ccf967313000000 using display name" do
+          expect(trail[2][:name]).to eq "Hello :)"
+          expect(trail[2][:path]).to eq "/admin/users/4e24d6249ccf967313000000"
         end
       end
     end
 
-    context "when path '/admin/posts/1/coments/1'" do
-      let(:path) { "/admin/posts/1/comments/1" }
+    context "when path '/admin/users/1/coments/1'" do
+      let(:path) { "/admin/users/1/posts/1" }
 
       it "should have 4 items" do
-        trail.size.should == 4
+        expect(trail.size).to eq 4
       end
       it "should have a link to /admin" do
-        trail[0][:name].should == "Admin"
-        trail[0][:path].should == "/admin"
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
       end
-      it "should have a link to /admin/posts" do
-        trail[1][:name].should == "Posts"
-        trail[1][:path].should == "/admin/posts"
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+      it "should have a link to /admin/users/1" do
+        expect(trail[2][:name]).to eq "Jane Doe"
+        expect(trail[2][:path]).to eq "/admin/users/1"
+      end
+      it "should have a link to /admin/users/1/posts" do
+        expect(trail[3][:name]).to eq "Posts"
+        expect(trail[3][:path]).to eq "/admin/users/1/posts"
+      end
+    end
+
+    context "when path '/admin/users/1/coments/1/edit'" do
+      let(:path) { "/admin/users/1/posts/1/edit" }
+
+      it "should have 5 items" do
+        expect(trail.size).to eq 5
       end
-      it "should have a link to /admin/posts/1" do
-        trail[2][:name].should == "Hello World"
-        trail[2][:path].should == "/admin/posts/1"
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+      it "should have a link to /admin/users/1" do
+        expect(trail[2][:name]).to eq "Jane Doe"
+        expect(trail[2][:path]).to eq "/admin/users/1"
+      end
+      it "should have a link to /admin/users/1/posts" do
+        expect(trail[3][:name]).to eq "Posts"
+        expect(trail[3][:path]).to eq "/admin/users/1/posts"
+      end
+      it "should have a link to /admin/users/1/posts/1" do
+        expect(trail[4][:name]).to eq "Hello World"
+        expect(trail[4][:path]).to eq "/admin/users/1/posts/1"
+      end
+    end
+
+    context "when the 'show' action is disabled" do
+      let(:post_config) { double find_resource: post, resource_name: double(route_key: 'posts'),
+                                 defined_actions: actions - [:show], # this is the change
+                                 belongs_to_config: double(target: user_config) }
+
+      let(:path) { "/admin/posts/1/edit" }
+
+      it "should have 3 items" do
+        expect(trail.size).to eq 3
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/posts" do
+        expect(trail[1][:name]).to eq "Posts"
+        expect(trail[1][:path]).to eq "/admin/posts"
       end
-      it "should have a link to /admin/posts/1/comments" do
-        trail[3][:name].should == "Comments"
-        trail[3][:path].should == "/admin/posts/1/comments"
+      it "should not link to the show view for the post" do
+        expect(trail[2]).to eq "Hello World"
       end
     end