rolify 3.1.0 → 4.0.0

data/spec/rolify/resourcifed_and_rolifed_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe "Resourcify and rolify on the same model" do
+  
+  before(:all) do
+    reset_defaults
+    Role.delete_all
+    HumanResource.delete_all
+  end
+  
+  let!(:user) do
+    user = HumanResource.new login: 'Samer' 
+    user.save
+    user
+  end
+  
+  it "should add the role to the user" do
+    expect { user.add_role :admin }.to change { user.roles.count }.by(1)
+  end
+      
+  it "should create a role to the roles collection" do
+    expect { user.add_role :moderator }.to change { Role.count }.by(1)
+  end
+end

data/spec/rolify/role_spec.rb

@@ -1,15 +1,14 @@
 require "spec_helper"
-require "rolify/shared_examples/shared_examples_for_roles"
-require "rolify/shared_examples/shared_examples_for_dynamic"
 
 describe Rolify do
-  it_behaves_like Rolify::Role do
-    let(:user_class) { User } 
-    let(:role_class) { Role }
-  end
 
-  it_behaves_like Rolify::Dynamic do
-    let(:user_class) { User } 
-    let(:role_class) { Role }
+  context 'cache' do
+    let(:user) { User.first }
+    before { user.grant(:zombie) }
+    specify do
+      expect(user).to have_role(:zombie)
+      user.remove_role(:zombie)
+      expect(user).to_not have_role(:zombie)
+    end
   end
 end

data/spec/rolify/shared_contexts.rb

@@ -1,7 +1,9 @@
 shared_context "global role", :scope => :global do
   subject { admin }
   
-  let(:admin) { user_class.first }
+  def admin
+    user_class.first
+  end
   
   before(:all) do
     load_roles
@@ -29,7 +31,9 @@ shared_context "class scoped role", :scope => :class do
     create_other_roles
   end
   
-  let(:manager) { user_class.where(:login => "moderator").first }
+  def manager
+    user_class.where(:login => "moderator").first
+  end
   
   def load_roles
     role_class.destroy_all
@@ -51,7 +55,9 @@ shared_context "instance scoped role", :scope => :instance do
     create_other_roles
   end
   
-  let(:moderator) { user_class.where(:login => "god").first }
+  def moderator
+    user_class.where(:login => "god").first
+  end
   
   def load_roles
     role_class.destroy_all
@@ -63,6 +69,19 @@ shared_context "instance scoped role", :scope => :instance do
   end
 end
 
+shared_context "mixed scoped roles", :scope => :mixed do
+  subject { user_class }
+  
+  before(:all) do
+    role_class.destroy_all
+  end
+    
+  let!(:root) { provision_user(user_class.first, [ :admin, :staff, [ :moderator, Group ], [ :visitor, Forum.last ] ]) }
+  let!(:modo) { provision_user(user_class.where(:login => "moderator").first, [[ :moderator, Forum ], [ :manager, Group ], [ :visitor, Group.first ]])}
+  let!(:visitor) { provision_user(user_class.last, [[ :visitor, Forum.last ]]) }
+  let!(:owner) { provision_user(user_class.first, [[:owner, Company.first]]) }
+end
+
 def create_other_roles
   role_class.create :name => "superhero"
   role_class.create :name => "admin", :resource_type => "Group"

data/spec/rolify/shared_examples/shared_examples_for_add_role.rb

@@ -10,11 +10,9 @@ shared_examples_for "#add_role_examples" do |param_name, param_method|
       end
 
       context "considering a new global role" do
-        subject { role_class.last }
-
-        its(:name) { should eq("moderator") }
-        its(:resource_type) { should be(nil) }
-        its(:resource_id) { should be(nil) }
+        it "creates a new class scoped role" do
+          expect(subject.add_role "expert".send(param_method)).to be_the_same_role("expert")
+        end
       end
 
       context "should not create another role" do
@@ -40,17 +38,15 @@ shared_examples_for "#add_role_examples" do |param_name, param_method|
       end
 
       context "considering a new class scoped role" do
-        subject { role_class.last }
-
-        its(:name) { should eq("moderator") }
-        its(:resource_type) { should eq(Forum.to_s) }
-        its(:resource_id) { should be(nil) }
+        it "creates a new class scoped role" do
+          expect(subject.add_role "boss".send(param_method), Forum).to be_the_same_role("boss", Forum)
+        end
       end
 
       context "should not create another role" do
         it "if the role was already assigned to the user" do
           subject.add_role "warrior".send(param_method), Forum
-          expect { subject.add_role "warrior".send(param_method), Forum }.not_to change { subject.roles.size }
+          expect { subject.add_role "warrior".send(param_method), Forum }.not_to change { subject.roles.count }
         end
 
         it "if already existing in the database" do
@@ -62,18 +58,15 @@ shared_examples_for "#add_role_examples" do |param_name, param_method|
 
     context "with an instance scoped role", :scope => :instance do
       it "should add the role to the user" do
-        expect { subject.add_role "visitor".send(param_method), Forum.last }.to change { subject.roles.size }.by(1)
+        expect { subject.add_role "visitor".send(param_method), Forum.last }.to change { subject.roles.count }.by(1)
       end
 
       it "should create a role in the roles table" do
         expect { subject.add_role "member".send(param_method), Forum.last }.to change { role_class.count }.by(1)
       end
 
-      context "considering a new class scoped role" do
-        subject { role_class.last }
-
-        its(:name) { should eq("member") }
-        its(:resource) { should eq(Forum.last) }
+      it "creates a new instance scoped role" do
+        expect(subject.add_role "mate".send(param_method), Forum.last).to be_the_same_role("mate", Forum.last)
       end
 
       context "should not create another role" do

data/spec/rolify/shared_examples/shared_examples_for_callbacks.rb

@@ -0,0 +1,65 @@
+shared_examples_for "Rolify.callbacks" do
+  before(:all) do
+    reset_defaults
+    Rolify.dynamic_shortcuts = false
+    role_class.destroy_all
+  end
+
+  after :each do
+    @user.roles.destroy_all
+  end
+
+  describe "rolify association callbacks", :if => (Rolify.orm == "active_record") do
+    describe "before_add" do
+      it "should receive callback" do
+        rolify_options = { :role_cname => role_class.to_s, :before_add => :role_callback }
+        rolify_options[:role_join_table_name] = join_table if defined? join_table
+        silence_warnings { user_class.rolify rolify_options }
+        @user = user_class.first
+        @user.stub(:role_callback)
+        @user.should_receive(:role_callback)
+        @user.add_role :admin
+      end
+    end
+
+    describe "after_add" do
+      it "should receive callback" do
+        rolify_options = { :role_cname => role_class.to_s, :after_add => :role_callback }
+        rolify_options[:role_join_table_name] = join_table if defined? join_table
+        silence_warnings { user_class.rolify rolify_options }
+        @user = user_class.first
+        @user.stub(:role_callback)
+        @user.should_receive(:role_callback)
+        @user.add_role :admin
+      end
+    end
+
+    describe "before_remove" do
+      it "should receive callback" do
+        rolify_options = { :role_cname => role_class.to_s, :before_remove => :role_callback }
+        rolify_options[:role_join_table_name] = join_table if defined? join_table
+        silence_warnings { user_class.rolify rolify_options }
+        @user = user_class.first
+        @user.add_role :admin
+        @user.stub(:role_callback)
+
+        @user.should_receive(:role_callback)
+        @user.remove_role :admin
+      end
+    end
+
+    describe "after_remove" do
+      it "should receive callback" do
+        rolify_options = { :role_cname => role_class.to_s, :after_remove => :role_callback }
+        rolify_options[:role_join_table_name] = join_table if defined? join_table
+        silence_warnings { user_class.rolify rolify_options }
+        @user = user_class.first
+        @user.add_role :admin
+        @user.stub(:role_callback)
+
+        @user.should_receive(:role_callback)
+        @user.remove_role :admin
+      end
+    end
+  end
+end

data/spec/rolify/shared_examples/shared_examples_for_dynamic.rb

@@ -1,17 +1,20 @@
-shared_examples_for Rolify::Dynamic do 
+shared_examples_for Rolify::Dynamic do
   before(:all) do
     Rolify.dynamic_shortcuts = true
     role_class.destroy_all
-    user_class.rolify :role_cname => role_class.to_s
-    Forum.resourcify :role_cname => role_class.to_s
-    Group.resourcify :role_cname => role_class.to_s
+    rolify_options = { :role_cname => role_class.to_s }
+    rolify_options[:role_join_table_name] = join_table if defined? join_table
+    silence_warnings { user_class.rolify rolify_options }
+    Forum.resourcify :roles, :role_cname => role_class.to_s
+    Group.resourcify :roles, :role_cname => role_class.to_s
   end
-  
+
   context "using a global role" do
-    subject do 
+    subject do
       admin = user_class.first
       admin.add_role :admin
       admin.add_role :moderator, Forum.first
+      admin.add_role :solo
       admin
     end
 
@@ -22,21 +25,30 @@ shared_examples_for Rolify::Dynamic do
     it { subject.is_admin?.should be(true) }
     it { subject.is_admin?.should be(true) }
     it { subject.is_admin?.should be(true) }
+
+    context "removing the role on the last user having it" do
+      before do
+        subject.remove_role :solo
+      end
+
+      it { should_not respond_to(:is_solo?) }
+      it { subject.is_solo?.should be(false) }
+    end
   end
-  
+
   context "using a resource scoped role" do
-    subject do 
+    subject do
       moderator = user_class.where(:login => "moderator").first
       moderator.add_role :moderator, Forum.first
+      moderator.add_role :sole_mio, Forum.last
       moderator
     end
-    
-    it { should respond_to(:is_admin?).with(0).arguments }
+
     it { should respond_to(:is_moderator?).with(0).arguments }
     it { should respond_to(:is_moderator_of?).with(1).arguments }
     it { should_not respond_to(:is_god?) }
     it { should_not respond_to(:is_god_of?) }
-    
+
     it { subject.is_moderator?.should be(false) }
     it { subject.is_moderator_of?(Forum).should be(false) }
     it { subject.is_moderator_of?(Forum.first).should be(true) }
@@ -44,23 +56,30 @@ shared_examples_for Rolify::Dynamic do
     it { subject.is_moderator_of?(Group).should be(false) }
     it { subject.is_moderator_of?(Group.first).should be(false) }
     it { subject.is_moderator_of?(Group.last).should be(false) }
+
+    context "removing the role on the last user having it" do
+      before do
+        subject.remove_role :sole_mio, Forum.last
+      end
+
+      it { should_not respond_to(:is_sole_mio?) }
+      it { subject.is_sole_mio?.should be(false) }
+    end
   end
-  
+
   context "using a class scoped role" do
-    subject do 
+    subject do
       manager = user_class.where(:login => "god").first
       manager.add_role :manager, Forum
+      manager.add_role :only_me, Forum
       manager
     end
-    
-    it { should respond_to(:is_admin?).with(0).arguments }
-    it { should respond_to(:is_moderator?).with(0).arguments }
-    it { should respond_to(:is_moderator_of?).with(1).arguments }
+
     it { should respond_to(:is_manager?).with(0).arguments }
     it { should respond_to(:is_manager_of?).with(1).arguments }
     it { should_not respond_to(:is_god?) }
     it { should_not respond_to(:is_god_of?) }
-    
+
     it { subject.is_manager?.should be(false) }
     it { subject.is_manager_of?(Forum).should be(true) }
     it { subject.is_manager_of?(Forum.first).should be(true) }
@@ -68,36 +87,46 @@ shared_examples_for Rolify::Dynamic do
     it { subject.is_manager_of?(Group).should be(false) }
     it { subject.is_manager_of?(Group.first).should be(false) }
     it { subject.is_manager_of?(Group.last).should be(false) }
+
+    context "removing the role on the last user having it" do
+      before do
+        subject.remove_role :only_me, Forum
+      end
+
+      it { should_not respond_to(:is_only_me?) }
+      it { subject.is_only_me?.should be(false) }
+    end
   end
-  
+
   context "if the role doesn't exist in the database" do
-    
+
     subject { user_class.first }
-    
+
     context "using a global role" do
       before(:all) do
         other_guy = user_class.last
         other_guy.add_role :superman
       end
-  
+
       it { should respond_to(:is_superman?).with(0).arguments }
       it { should_not respond_to(:is_superman_of?) }
       it { should_not respond_to(:is_god?) }
-      
+
       it { subject.is_superman?.should be(false) }
+      it { subject.is_god?.should be(false) }
     end
-    
+
     context "using a resource scope role" do
       before(:all) do
         other_guy = user_class.last
         other_guy.add_role :batman, Forum.first
       end
-      
+
       it { should respond_to(:is_batman?).with(0).arguments }
       it { should respond_to(:is_batman_of?).with(1).arguments }
       it { should_not respond_to(:is_god?) }
       it { should_not respond_to(:is_god_of?) }
-      
+
       it { subject.is_batman?.should be(false) }
       it { subject.is_batman_of?(Forum).should be(false) }
       it { subject.is_batman_of?(Forum.first).should be(false) }
@@ -105,6 +134,14 @@ shared_examples_for Rolify::Dynamic do
       it { subject.is_batman_of?(Group).should be(false) }
       it { subject.is_batman_of?(Group.first).should be(false) }
       it { subject.is_batman_of?(Group.last).should be(false) }
+
+      it { subject.is_god?.should be(false) }
+      it { subject.is_god_of?(Forum).should be(false) }
+      it { subject.is_god_of?(Forum.first).should be(false) }
+      it { subject.is_god_of?(Forum.last).should be(false) }
+      it { subject.is_god_of?(Group).should be(false) }
+      it { subject.is_god_of?(Group.first).should be(false) }
+      it { subject.is_god_of?(Group.last).should be(false) }
     end
   end
-end
+end

data/spec/rolify/shared_examples/shared_examples_for_finders.rb

@@ -0,0 +1,81 @@
+shared_examples_for :finders do |param_name, param_method|
+  context "using #{param_name} as parameter" do
+    describe ".with_role" do
+      it { should respond_to(:with_role).with(1).argument }
+      it { should respond_to(:with_role).with(2).arguments }
+
+      context "with a global role" do
+        it { subject.with_role("admin".send(param_method)).should eq([ root ]) }
+        it { subject.with_role("moderator".send(param_method)).should be_empty }
+        it { subject.with_role("visitor".send(param_method)).should be_empty }
+      end
+
+      context "with a class scoped role" do
+        context "on Forum class" do
+          it { subject.with_role("admin".send(param_method), Forum).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Forum).should eq([ modo ]) }
+          it { subject.with_role("visitor".send(param_method), Forum).should be_empty }
+        end
+
+        context "on Group class" do
+          it { subject.with_role("admin".send(param_method), Group).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Group).should eq([ root ]) }
+          it { subject.with_role("visitor".send(param_method), Group).should be_empty }
+        end
+      end
+
+      context "with an instance scoped role" do
+        context "on Forum.first instance" do
+          it { subject.with_role("admin".send(param_method), Forum.first).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Forum.first).should eq([ modo ]) }
+          it { subject.with_role("visitor".send(param_method), Forum.first).should be_empty }
+        end
+
+        context "on Forum.last instance" do
+          it { subject.with_role("admin".send(param_method), Forum.last).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Forum.last).should eq([ modo ]) }
+          it { subject.with_role("visitor".send(param_method), Forum.last).should include(root, visitor) } # =~ doesn't pass using mongoid, don't know why...
+        end
+
+        context "on Group.first instance" do
+          it { subject.with_role("admin".send(param_method), Group.first).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Group.first).should eq([ root ]) }
+          it { subject.with_role("visitor".send(param_method), Group.first).should eq([ modo ]) }
+        end
+
+        context "on Company.first_instance" do
+          it { subject.with_role("owner".send(param_method), Company.first).should eq([ owner ]) }
+        end
+      end
+    end
+
+    describe ".with_all_roles" do
+      it { should respond_to(:with_all_roles) }
+
+      it { subject.with_all_roles("admin".send(param_method), :staff).should eq([ root ]) }
+      it { subject.with_all_roles("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Group }).should eq([ root ]) }
+      it { subject.with_all_roles("admin".send(param_method), "moderator".send(param_method)).should be_empty }
+      it { subject.with_all_roles("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Forum }).should be_empty }
+      it { subject.with_all_roles({ :name => "moderator".send(param_method), :resource => Forum }, { :name => :manager, :resource => Group }).should eq([ modo ]) }
+      it { subject.with_all_roles("moderator".send(param_method), :manager).should be_empty }
+      it { subject.with_all_roles({ :name => "visitor".send(param_method), :resource => Forum.last }, { :name => "moderator".send(param_method), :resource => Group }).should eq([ root ]) }
+      it { subject.with_all_roles({ :name => "visitor".send(param_method), :resource => Group.first }, { :name => "moderator".send(param_method), :resource => Forum }).should eq([ modo ]) }
+      it { subject.with_all_roles({ :name => "visitor".send(param_method), :resource => :any }, { :name => "moderator".send(param_method), :resource => :any }).should =~ [ root, modo ] }
+    end
+
+    describe ".with_any_role" do
+      it { should respond_to(:with_any_role) }
+
+      it { subject.with_any_role("admin".send(param_method), :staff).should eq([ root ]) }
+      it { subject.with_any_role("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Group }).should eq([ root ]) }
+      it { subject.with_any_role("admin".send(param_method), "moderator".send(param_method)).should eq([ root ]) }
+      it { subject.with_any_role("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Forum }).should =~ [ root, modo ] }
+      it { subject.with_any_role({ :name => "moderator".send(param_method), :resource => Forum }, { :name => :manager, :resource => Group }).should eq([ modo ]) }
+      it { subject.with_any_role({ :name => "moderator".send(param_method), :resource => Group }, { :name => :manager, :resource => Group }).should =~ [ root, modo ] }
+      it { subject.with_any_role("moderator".send(param_method), :manager).should be_empty }
+      it { subject.with_any_role({ :name => "visitor".send(param_method), :resource => Forum.last }, { :name => "moderator".send(param_method), :resource => Group }).should =~ [ root, visitor ] }
+      it { subject.with_any_role({ :name => "visitor".send(param_method), :resource => Group.first }, { :name => "moderator".send(param_method), :resource => Forum }).should eq([ modo ]) }
+      it { subject.with_any_role({ :name => "visitor".send(param_method), :resource => :any }, { :name => "moderator".send(param_method), :resource => :any }).should =~ [ root, modo, visitor ] }
+    end
+  end
+end

data/spec/rolify/shared_examples/shared_examples_for_has_all_roles.rb

@@ -2,54 +2,54 @@ shared_examples_for "#has_all_roles?_examples" do |param_name, param_method|
   context "using #{param_name} as parameter" do
     context "with a global role", :scope => :global do  
       context "on global roles only request" do
-        it { subject.has_all_roles?("staff".send(param_method)).should be_true }
-        it { subject.has_all_roles?("admin".send(param_method), "staff".send(param_method)).should be_true }
-        it { subject.has_all_roles?("admin".send(param_method), "dummy".send(param_method)).should be_false }
-        it { subject.has_all_roles?("dummy".send(param_method), "dumber".send(param_method)).should be_false }
+        it { subject.has_all_roles?("staff".send(param_method)).should be_truthy }
+        it { subject.has_all_roles?("admin".send(param_method), "staff".send(param_method)).should be_truthy }
+        it { subject.has_all_roles?("admin".send(param_method), "dummy".send(param_method)).should be_falsey }
+        it { subject.has_all_roles?("dummy".send(param_method), "dumber".send(param_method)).should be_falsey }
       end
       
       context "on mixed scoped roles" do
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "admin".send(param_method), :resource => Group }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => :any }, { :name => "admin".send(param_method), :resource => Group }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "staff".send(param_method), :resource => Group.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "admin".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_false }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => :any }).should be_false}
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "admin".send(param_method), :resource => Group }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => :any }, { :name => "admin".send(param_method), :resource => Group }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "staff".send(param_method), :resource => Group.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "admin".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => :any }).should be_falsey}
       end
     end
     
     context "with a class scoped role", :scope => :class do        
       context "on class scoped roles only" do
-        it { subject.has_all_roles?({ :name => "player".send(param_method), :resource => Forum }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => Forum }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => Forum }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => :any }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => Forum }).should be_false }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => :any }).should be_false }
-        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum }, { :name => "dumber".send(param_method), :resource => Group }).should be_false }
+        it { subject.has_all_roles?({ :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => :any }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => Forum }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => :any }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum }, { :name => "dumber".send(param_method), :resource => Group }).should be_falsey }
       end
       
       context "on mixed scoped roles" do
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "manager".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Group }, { :name => "moderator".send(param_method), :resource => Forum.first }).should be_false }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum }).should be_false }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.last }, { :name => "warrior".send(param_method), :resource => Forum.last }).should be_true }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "manager".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Group }, { :name => "moderator".send(param_method), :resource => Forum.first }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.last }, { :name => "warrior".send(param_method), :resource => Forum.last }).should be_truthy }
       end
     end
     
     context "with a instance scoped role", :scope => :instance do
       context "on instance scoped roles only" do
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => :any }).should be_true }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum }).should be_false }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum.last }).should be_false }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_false }
-        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum.first }, { :name => "dumber".send(param_method), :resource => Forum.last }).should be_false }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => :any }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum.last }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum.first }, { :name => "dumber".send(param_method), :resource => Forum.last }).should be_falsey }
       end
       
       context "on mixed scoped roles" do
-        it { subject.has_all_roles?({ :name => "visitor".send(param_method), :resource => Forum.last }).should be_true }
+        it { subject.has_all_roles?({ :name => "visitor".send(param_method), :resource => Forum.last }).should be_truthy }
         it { subject.has_all_roles?("soldier".send(param_method), { :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "visitor".send(param_method), :resource => Forum }).should be(true) }
         it { subject.has_all_roles?("soldier".send(param_method), { :name => "moderator".send(param_method), :resource => Forum.last }, { :name => "visitor".send(param_method), :resource => Forum }).should be(false) }
         it { subject.has_all_roles?("soldier".send(param_method), { :name => "moderator".send(param_method), :resource => :any }, { :name => "visitor".send(param_method), :resource => Forum }).should be(true) }