rolify 3.1.0 → 4.0.0

data/spec/rolify/shared_examples/shared_examples_for_has_any_role.rb

@@ -1,59 +1,59 @@
 shared_examples_for "#has_any_role?_examples" do |param_name, param_method|
   context "using #{param_name} as parameter" do
     context "with a global role", :scope => :global do
-      before(:all) do
+      before do
         subject.add_role "staff".send(param_method)
       end
       
-      it { subject.has_any_role?("staff".send(param_method)).should be_true }
-      it { subject.has_any_role?("admin".send(param_method), "staff".send(param_method)).should be_true }
-      it { subject.has_any_role?("admin".send(param_method), "moderator".send(param_method)).should be_true }
-      it { subject.has_any_role?("dummy".send(param_method), "dumber".send(param_method)).should be_false }
-      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "admin".send(param_method), :resource => Group }).should be_true }
-      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => :any }, { :name => "admin".send(param_method), :resource => Group }).should be_true }
-      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "staff".send(param_method), :resource => Group.last }).should be_true }
-      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "admin".send(param_method), :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => :any }).should be_true }
-      it { subject.has_any_role?({ :name => "dummy".send(param_method), :resource => Forum.first }, { :name => "dumber".send(param_method), :resource => :any }).should be_false }
-      it { subject.has_any_role?({ :name => "dummy".send(param_method), :resource => :any }, { :name => "dumber".send(param_method), :resource => :any }).should be_false }
+      it { subject.has_any_role?("staff".send(param_method)).should be_truthy }
+      it { subject.has_any_role?("admin".send(param_method), "staff".send(param_method)).should be_truthy }
+      it { subject.has_any_role?("admin".send(param_method), "moderator".send(param_method)).should be_truthy }
+      it { subject.has_any_role?("dummy".send(param_method), "dumber".send(param_method)).should be_falsey }
+      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "admin".send(param_method), :resource => Group }).should be_truthy }
+      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => :any }, { :name => "admin".send(param_method), :resource => Group }).should be_truthy }
+      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "staff".send(param_method), :resource => Group.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "admin".send(param_method), :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => :any }).should be_truthy }
+      it { subject.has_any_role?({ :name => "dummy".send(param_method), :resource => Forum.first }, { :name => "dumber".send(param_method), :resource => :any }).should be_falsey }
+      it { subject.has_any_role?({ :name => "dummy".send(param_method), :resource => :any }, { :name => "dumber".send(param_method), :resource => :any }).should be_falsey }
     end
     
     context "with a class scoped role", :scope => :class do
-      before(:all) do
+      before do
         subject.add_role "player".send(param_method), Forum
         subject.add_role "superhero".send(param_method)
       end
       
-      it { subject.has_any_role?({ :name => "player".send(param_method), :resource => Forum }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => Forum }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => :any }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => :any }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => :any }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => Forum }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => :any }).should be_true }
-      it { subject.has_any_role?({ :name => "dummy".send(param_method), :resource => Forum }, { :name => "dumber".send(param_method), :resource => Group }).should be_false }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "manager".send(param_method), :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Group }, { :name => "moderator".send(param_method), :resource => Forum.first }).should be_false }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum }).should be_true }
-      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum.last }, { :name => "warrior".send(param_method), :resource => Forum.last }).should be_true }
+      it { subject.has_any_role?({ :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => :any }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => :any }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => :any }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => Forum }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => :any }).should be_truthy }
+      it { subject.has_any_role?({ :name => "dummy".send(param_method), :resource => Forum }, { :name => "dumber".send(param_method), :resource => Group }).should be_falsey }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "manager".send(param_method), :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Group }, { :name => "moderator".send(param_method), :resource => Forum.first }).should be_falsey }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum }).should be_truthy }
+      it { subject.has_any_role?({ :name => "manager".send(param_method), :resource => Forum.last }, { :name => "warrior".send(param_method), :resource => Forum.last }).should be_truthy }
     end
     
     context "with a instance scoped role", :scope => :instance do
-      before(:all) do
+      before do
         subject.add_role "visitor".send(param_method), Forum.last
         subject.add_role "leader", Group
         subject.add_role "warrior"
       end
       
-      it { subject.has_any_role?({ :name => "visitor", :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "moderator", :resource => Forum.first }, { :name => "visitor", :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "moderator", :resource => :any }, { :name => "visitor", :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "moderator", :resource => :any }, { :name => "visitor", :resource => :any}).should be_true }
-      it { subject.has_any_role?({ :name => "moderator", :resource => Forum }, { :name => "visitor", :resource => :any }).should be_true }
-      it { subject.has_any_role?({ :name => "moderator", :resource => Forum.first }, { :name => "moderator", :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "moderator", :resource => Forum.first }, { :name => "dummy", :resource => Forum.last }).should be_true }
-      it { subject.has_any_role?({ :name => "dummy", :resource => Forum.first }, { :name => "dumber", :resource => Forum.last }).should be_false }
+      it { subject.has_any_role?({ :name => "visitor", :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "moderator", :resource => Forum.first }, { :name => "visitor", :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "moderator", :resource => :any }, { :name => "visitor", :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "moderator", :resource => :any }, { :name => "visitor", :resource => :any}).should be_truthy }
+      it { subject.has_any_role?({ :name => "moderator", :resource => Forum }, { :name => "visitor", :resource => :any }).should be_truthy }
+      it { subject.has_any_role?({ :name => "moderator", :resource => Forum.first }, { :name => "moderator", :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "moderator", :resource => Forum.first }, { :name => "dummy", :resource => Forum.last }).should be_truthy }
+      it { subject.has_any_role?({ :name => "dummy", :resource => Forum.first }, { :name => "dumber", :resource => Forum.last }).should be_falsey }
       it { subject.has_any_role?("warrior", { :name => "moderator", :resource => Forum.first }, { :name => "leader", :resource => Group }).should be(true) }
       it { subject.has_any_role?("warrior", { :name => "moderator", :resource => :any }, { :name => "leader", :resource => Forum }).should be(true) }
       it { subject.has_any_role?("warrior", { :name => "moderator", :resource => Forum.first }, { :name => "leader", :resource => :any }).should be(true) }

data/spec/rolify/shared_examples/shared_examples_for_has_role.rb

@@ -1,133 +1,133 @@
 shared_examples_for "#has_role?_examples" do |param_name, param_method|
   context "using #{param_name} as parameter" do
     context "with a global role", :scope => :global do
-      it { subject.has_role?("admin".send(param_method)).should be_true }
+      it { subject.has_role?("admin".send(param_method)).should be_truthy }
 
       context "on resource request" do
-        it { subject.has_role?("admin".send(param_method), Forum.first).should be_true }
-        it { subject.has_role?("admin".send(param_method), Forum).should be_true }
-        it { subject.has_role?("admin".send(param_method), :any).should be_true }
+        it { subject.has_role?("admin".send(param_method), Forum.first).should be_truthy }
+        it { subject.has_role?("admin".send(param_method), Forum).should be_truthy }
+        it { subject.has_role?("admin".send(param_method), :any).should be_truthy }
       end
 
       context "with another global role" do
         before(:all) { role_class.create(:name => "global") }
 
-        it { subject.has_role?("global".send(param_method)).should be_false }
-        it { subject.has_role?("global".send(param_method), :any).should be_false }
+        it { subject.has_role?("global".send(param_method)).should be_falsey }
+        it { subject.has_role?("global".send(param_method), :any).should be_falsey }
       end
 
       it "should not get an instance scoped role" do
-        subject.has_role?("moderator".send(param_method), Group.first).should be_false
+        subject.has_role?("moderator".send(param_method), Group.first).should be_falsey
       end
 
       it "should not get a class scoped role" do
-        subject.has_role?("manager".send(param_method), Forum).should be_false
+        subject.has_role?("manager".send(param_method), Forum).should be_falsey
       end
 
       context "using inexisting role" do
-        it { subject.has_role?("dummy".send(param_method)).should be_false }
-        it { subject.has_role?("dumber".send(param_method), Forum.first).should be_false }
+        it { subject.has_role?("dummy".send(param_method)).should be_falsey }
+        it { subject.has_role?("dumber".send(param_method), Forum.first).should be_falsey }
       end
     end
 
     context "with a class scoped role", :scope => :class do
       context "on class scoped role request" do
-        it { subject.has_role?("manager".send(param_method), Forum).should be_true }
-        it { subject.has_role?("manager".send(param_method), Forum.first).should be_true }
-        it { subject.has_role?("manager".send(param_method), :any).should be_true }
+        it { subject.has_role?("manager".send(param_method), Forum).should be_truthy }
+        it { subject.has_role?("manager".send(param_method), Forum.first).should be_truthy }
+        it { subject.has_role?("manager".send(param_method), :any).should be_truthy }
       end
 
       it "should not get a scoped role when asking for a global" do
-        subject.has_role?("manager".send(param_method)).should be_false
+        subject.has_role?("manager".send(param_method)).should be_falsey
       end
 
       it "should not get a global role" do
         role_class.create(:name => "admin")
-        subject.has_role?("admin".send(param_method)).should be_false
+        subject.has_role?("admin".send(param_method)).should be_falsey
       end
 
       context "with another class scoped role" do
         context "on the same resource but with a different name" do
           before(:all) { role_class.create(:name => "member", :resource_type => "Forum") }
 
-          it { subject.has_role?("member".send(param_method), Forum).should be_false }
-          it { subject.has_role?("member".send(param_method), :any).should be_false }
+          it { subject.has_role?("member".send(param_method), Forum).should be_falsey }
+          it { subject.has_role?("member".send(param_method), :any).should be_falsey }
         end
 
         context "on another resource with the same name" do
           before(:all) { role_class.create(:name => "manager", :resource_type => "Group") }
 
-          it { subject.has_role?("manager".send(param_method), Group).should be_false }
-          it { subject.has_role?("manager".send(param_method), :any).should be_true }
+          it { subject.has_role?("manager".send(param_method), Group).should be_falsey }
+          it { subject.has_role?("manager".send(param_method), :any).should be_truthy }
         end
 
         context "on another resource with another name" do
           before(:all) { role_class.create(:name => "defenders", :resource_type => "Group") }
 
-          it { subject.has_role?("defenders".send(param_method), Group).should be_false }
-          it { subject.has_role?("defenders".send(param_method), :any).should be_false }
+          it { subject.has_role?("defenders".send(param_method), Group).should be_falsey }
+          it { subject.has_role?("defenders".send(param_method), :any).should be_falsey }
         end
       end
 
       context "using inexisting role" do
-        it { subject.has_role?("dummy".send(param_method), Forum).should be_false }
-        it { subject.has_role?("dumber".send(param_method)).should be_false }
+        it { subject.has_role?("dummy".send(param_method), Forum).should be_falsey }
+        it { subject.has_role?("dumber".send(param_method)).should be_falsey }
       end
     end
 
     context "with a instance scoped role", :scope => :instance do
       context "on instance scoped role request" do
-        it { subject.has_role?("moderator".send(param_method), Forum.first).should be_true }
-        it { subject.has_role?("moderator".send(param_method), :any).should be_true }
+        it { subject.has_role?("moderator".send(param_method), Forum.first).should be_truthy }
+        it { subject.has_role?("moderator".send(param_method), :any).should be_truthy }
       end
 
       it "should not get an instance scoped role when asking for a global" do
-        subject.has_role?("moderator".send(param_method)).should be_false
+        subject.has_role?("moderator".send(param_method)).should be_falsey
       end
 
       it "should not get an instance scoped role when asking for a class scoped" do 
-        subject.has_role?("moderator".send(param_method), Forum).should be_false
+        subject.has_role?("moderator".send(param_method), Forum).should be_falsey
       end
 
       it "should not get a global role" do
         role_class.create(:name => "admin")
-        subject.has_role?("admin".send(param_method)).should be_false
+        subject.has_role?("admin".send(param_method)).should be_falsey
       end
 
       context "with another instance scoped role" do
         context "on the same resource but with a different role name" do
           before(:all) { role_class.create(:name => "member", :resource => Forum.first) }
 
-          it { subject.has_role?("member".send(param_method), Forum.first).should be_false }
-          it { subject.has_role?("member".send(param_method), :any).should be_false }
+          it { subject.has_role?("member".send(param_method), Forum.first).should be_falsey }
+          it { subject.has_role?("member".send(param_method), :any).should be_falsey }
         end
 
         context "on another resource of the same type but with the same role name" do
           before(:all) { role_class.create(:name => "moderator", :resource => Forum.last) }
 
-          it { subject.has_role?("moderator".send(param_method), Forum.last).should be_false }
-          it { subject.has_role?("moderator".send(param_method), :any).should be_true }
+          it { subject.has_role?("moderator".send(param_method), Forum.last).should be_falsey }
+          it { subject.has_role?("moderator".send(param_method), :any).should be_truthy }
         end
 
         context "on another resource of different type but with the same role name" do
           before(:all) { role_class.create(:name => "moderator", :resource => Group.last) }
 
-          it { subject.has_role?("moderator".send(param_method), Group.last).should be_false }
-          it { subject.has_role?("moderator".send(param_method), :any).should be_true }
+          it { subject.has_role?("moderator".send(param_method), Group.last).should be_falsey }
+          it { subject.has_role?("moderator".send(param_method), :any).should be_truthy }
         end
 
         context "on another resource of the same type and with another role name" do
           before(:all) { role_class.create(:name => "member", :resource => Forum.last) }
 
-          it { subject.has_role?("member".send(param_method), Forum.last).should be_false }
-          it { subject.has_role?("member".send(param_method), :any).should be_false }
+          it { subject.has_role?("member".send(param_method), Forum.last).should be_falsey }
+          it { subject.has_role?("member".send(param_method), :any).should be_falsey }
         end
 
         context "on another resource of different type and with another role name" do
           before(:all) { role_class.create(:name => "member", :resource => Group.first) }
 
-          it { subject.has_role?("member".send(param_method), Group.first).should be_false }
-          it { subject.has_role?("member".send(param_method), :any).should be_false }
+          it { subject.has_role?("member".send(param_method), Group.first).should be_falsey }
+          it { subject.has_role?("member".send(param_method), :any).should be_falsey }
         end
       end
     end

data/spec/rolify/shared_examples/shared_examples_for_only_has_role.rb

@@ -0,0 +1,174 @@
+shared_examples_for "#only_has_role?_examples" do |param_name, param_method|
+  context "using #{param_name} as parameter" do
+    context "with a global role", :scope => :global do
+      subject do 
+        user = User.create(:login => "global_user")
+        user.add_role "global_role".send(param_method)
+        user
+      end
+      
+      it { subject.only_has_role?("global_role".send(param_method)).should be_truthy }
+
+      context "on resource request" do
+        it { subject.only_has_role?("global_role".send(param_method), Forum.first).should be_truthy }
+        it { subject.only_has_role?("global_role".send(param_method), Forum).should be_truthy }
+        it { subject.only_has_role?("global_role".send(param_method), :any).should be_truthy }
+      end
+
+      context "with another global role" do
+        before(:all) { role_class.create(:name => "another_global_role") }
+
+        it { subject.only_has_role?("another_global_role".send(param_method)).should be_falsey }
+        it { subject.only_has_role?("another_global_role".send(param_method), :any).should be_falsey }
+      end
+
+      it "should not get an instance scoped role" do
+        subject.only_has_role?("moderator".send(param_method), Group.first).should be_falsey
+      end
+
+      it "should not get a class scoped role" do
+        subject.only_has_role?("manager".send(param_method), Forum).should be_falsey
+      end
+
+      context "using inexisting role" do
+        it { subject.only_has_role?("dummy".send(param_method)).should be_falsey }
+        it { subject.only_has_role?("dumber".send(param_method), Forum.first).should be_falsey }
+      end
+      
+      context "with multiple roles" do
+        before { subject.add_role "multiple_global_roles".send(param_method) }
+        
+        it { subject.only_has_role?("global_role".send(param_method)).should be_falsey }
+      end
+    end
+
+    context "with a class scoped role", :scope => :class do
+      subject do 
+        user = User.create(:login => "class_user")
+        user.add_role "class_role".send(param_method), Forum
+        user
+      end
+      
+      context "on class scoped role request" do
+        it { subject.only_has_role?("class_role".send(param_method), Forum).should be_truthy }
+        it { subject.only_has_role?("class_role".send(param_method), Forum.first).should be_truthy }
+        it { subject.only_has_role?("class_role".send(param_method), :any).should be_truthy }
+      end
+
+      it "should not get a scoped role when asking for a global" do
+        subject.only_has_role?("class_role".send(param_method)).should be_falsey
+      end
+
+      it "should not get a global role" do
+        role_class.create(:name => "global_role")
+        subject.only_has_role?("global_role".send(param_method)).should be_falsey
+      end
+
+      context "with another class scoped role" do
+        context "on the same resource but with a different name" do
+          before(:all) { role_class.create(:name => "another_class_role", :resource_type => "Forum") }
+
+          it { subject.only_has_role?("another_class_role".send(param_method), Forum).should be_falsey }
+          it { subject.only_has_role?("another_class_role".send(param_method), :any).should be_falsey }
+        end
+
+        context "on another resource with the same name" do
+          before(:all) { role_class.create(:name => "class_role", :resource_type => "Group") }
+
+          it { subject.only_has_role?("class_role".send(param_method), Group).should be_falsey }
+          it { subject.only_has_role?("class_role".send(param_method), :any).should be_truthy }
+        end
+
+        context "on another resource with another name" do
+          before(:all) { role_class.create(:name => "another_class_role", :resource_type => "Group") }
+
+          it { subject.only_has_role?("another_class_role".send(param_method), Group).should be_falsey }
+          it { subject.only_has_role?("another_class_role".send(param_method), :any).should be_falsey }
+        end
+      end
+
+      context "using inexisting role" do
+        it { subject.only_has_role?("dummy".send(param_method), Forum).should be_falsey }
+        it { subject.only_has_role?("dumber".send(param_method)).should be_falsey }
+      end
+      
+      context "with multiple roles" do
+        before { subject.add_role "multiple_class_roles".send(param_method) }
+        
+        it { subject.only_has_role?("class_role".send(param_method), Forum).should be_falsey }
+        it { subject.only_has_role?("class_role".send(param_method), Forum.first).should be_falsey }
+        it { subject.only_has_role?("class_role".send(param_method), :any).should be_falsey }  
+      end
+    end
+
+    context "with a instance scoped role", :scope => :instance do
+      subject do 
+        user = User.create(:login => "instance_user")
+        user.add_role "instance_role".send(param_method), Forum.first
+        user
+      end
+      
+      context "on instance scoped role request" do
+        it { subject.only_has_role?("instance_role".send(param_method), Forum.first).should be_truthy }
+        it { subject.only_has_role?("instance_role".send(param_method), :any).should be_truthy }
+      end
+
+      it "should not get an instance scoped role when asking for a global" do
+        subject.only_has_role?("instance_role".send(param_method)).should be_falsey
+      end
+
+      it "should not get an instance scoped role when asking for a class scoped" do 
+        subject.only_has_role?("instance_role".send(param_method), Forum).should be_falsey
+      end
+
+      it "should not get a global role" do
+        role_class.create(:name => "global_role")
+        subject.only_has_role?("global_role".send(param_method)).should be_falsey
+      end
+
+      context "with another instance scoped role" do
+        context "on the same resource but with a different role name" do
+          before(:all) { role_class.create(:name => "another_instance_role", :resource => Forum.first) }
+
+          it { subject.only_has_role?("another_instance_role".send(param_method), Forum.first).should be_falsey }
+          it { subject.only_has_role?("another_instance_role".send(param_method), :any).should be_falsey }
+        end
+
+        context "on another resource of the same type but with the same role name" do
+          before(:all) { role_class.create(:name => "moderator", :resource => Forum.last) }
+
+          it { subject.only_has_role?("instance_role".send(param_method), Forum.last).should be_falsey }
+          it { subject.only_has_role?("instance_role".send(param_method), :any).should be_truthy }
+        end
+
+        context "on another resource of different type but with the same role name" do
+          before(:all) { role_class.create(:name => "moderator", :resource => Group.last) }
+
+          it { subject.only_has_role?("instance_role".send(param_method), Group.last).should be_falsey }
+          it { subject.only_has_role?("instance_role".send(param_method), :any).should be_truthy }
+        end
+
+        context "on another resource of the same type and with another role name" do
+          before(:all) { role_class.create(:name => "another_instance_role", :resource => Forum.last) }
+
+          it { subject.only_has_role?("another_instance_role".send(param_method), Forum.last).should be_falsey }
+          it { subject.only_has_role?("another_instance_role".send(param_method), :any).should be_falsey }
+        end
+
+        context "on another resource of different type and with another role name" do
+          before(:all) { role_class.create(:name => "another_instance_role", :resource => Group.first) }
+
+          it { subject.only_has_role?("another_instance_role".send(param_method), Group.first).should be_falsey }
+          it { subject.only_has_role?("another_instance_role".send(param_method), :any).should be_falsey }
+        end
+      end
+    
+      context "with multiple roles" do
+        before { subject.add_role "multiple_instance_roles".send(param_method), Forum.first }
+        
+        it { subject.only_has_role?("instance_role".send(param_method), Forum.first).should be_falsey }
+        it { subject.only_has_role?("instance_role".send(param_method), :any).should be_falsey }
+      end
+    end
+  end
+end

data/spec/rolify/shared_examples/shared_examples_for_remove_role.rb

@@ -3,55 +3,36 @@ shared_examples_for "#remove_role_examples" do |param_name, param_method|
     context "removing a global role", :scope => :global do
       context "being a global role of the user" do
         it { expect { subject.remove_role("admin".send(param_method)) }.to change { subject.roles.size }.by(-1) }
-        
-        it { subject.has_role?("admin".send(param_method)).should be_false }
-        it { subject.has_role?("staff".send(param_method)).should be_true }
-        it { subject.has_role?("manager".send(param_method), Group).should be_true }
-        it { subject.has_role?("moderator".send(param_method), Forum.last).should be_true }
-        it { subject.has_role?("moderator".send(param_method), Group.last).should be_true }
-        it { subject.has_role?("anonymous".send(param_method), Forum.first).should be_true }
+
+        it { should_not have_role("admin".send(param_method)) }
       end
-      
+
       context "being a class scoped role to the user" do
         it { expect { subject.remove_role("manager".send(param_method)) }.to change { subject.roles.size }.by(-1) }
-        
-        it { subject.has_role?("admin".send(param_method)).should be_false }
-        it { subject.has_role?("staff".send(param_method)).should be_true }
-        it { subject.has_role?("manager".send(param_method), Group).should be_false }
-        it { subject.has_role?("moderator".send(param_method), Forum.last).should be_true }
-        it { subject.has_role?("moderator".send(param_method), Group.last).should be_true }
-        it { subject.has_role?("anonymous".send(param_method), Forum.first).should be_true }
+
+        it { should_not have_role("manager".send(param_method), Group) }
       end
-      
+
       context "being instance scoped roles to the user" do
         it { expect { subject.remove_role("moderator".send(param_method)) }.to change { subject.roles.size }.by(-2) }
-        
-        it { subject.has_role?("admin".send(param_method)).should be_false }
-        it { subject.has_role?("staff".send(param_method)).should be_true }
-        it { subject.has_role?("manager".send(param_method), Group).should be_false }
-        it { subject.has_role?("moderator".send(param_method), Forum.last).should be_false }
-        it { subject.has_role?("moderator".send(param_method), Group.last).should be_false }
-        it { subject.has_role?("anonymous".send(param_method), Forum.first).should be_true }
+
+        it { should_not have_role("moderator".send(param_method), Forum.last) }
+        it { should_not have_role("moderator".send(param_method), Group.last) }
       end
-      
+
       context "not being a role of the user" do
         it { expect { subject.remove_role("superhero".send(param_method)) }.not_to change { subject.roles.size } }
       end
-      
+
       context "used by another user" do
         before do
           user = user_class.last
           user.add_role "staff".send(param_method)
         end
-        
+
         it { expect { subject.remove_role("staff".send(param_method)) }.not_to change { role_class.count } }
-        
-        it { subject.has_role?("admin".send(param_method)).should be_false }
-        it { subject.has_role?("staff".send(param_method)).should be_false }
-        it { subject.has_role?("manager".send(param_method), Group).should be_false }
-        it { subject.has_role?("moderator".send(param_method), Forum.last).should be_false }
-        it { subject.has_role?("moderator".send(param_method), Group.last).should be_false }
-        it { subject.has_role?("anonymous".send(param_method), Forum.first).should be_true }
+
+        it { should_not have_role("staff".send(param_method)) }
       end
 
       context "not used by anyone else" do
@@ -67,29 +48,20 @@ shared_examples_for "#remove_role_examples" do |param_name, param_method|
       context "being a global role of the user" do
         it { expect { subject.remove_role("warrior".send(param_method), Forum) }.not_to change{ subject.roles.size } }
       end
-      
+
       context "being a class scoped role to the user" do
         it { expect { subject.remove_role("manager".send(param_method), Forum) }.to change{ subject.roles.size }.by(-1) }
-        
-        it { subject.has_role?("warrior").should be_true }
-        it { subject.has_role?("manager", Forum).should be_false }
-        it { subject.has_role?("player", Forum).should be_true }
-        it { subject.has_role?("moderator".send(param_method), Forum.last).should be_true }
-        it { subject.has_role?("moderator".send(param_method), Group.last).should be_true }
-        it { subject.has_role?("anonymous".send(param_method), Forum.first).should be_true }
+
+        it { should_not have_role("manager", Forum) }
       end
-      
+
       context "being instance scoped role to the user" do
         it { expect { subject.remove_role("moderator".send(param_method), Forum) }.to change { subject.roles.size }.by(-1) }
-        
-        it { subject.has_role?("warrior").should be_true }
-        it { subject.has_role?("manager", Forum).should be_false }
-        it { subject.has_role?("player", Forum).should be_true }
-        it { subject.has_role?("moderator".send(param_method), Forum.last).should be_false }
-        it { subject.has_role?("moderator".send(param_method), Group.last).should be_true }
-        it { subject.has_role?("anonymous".send(param_method), Forum.first).should be_true }
+
+        it { should_not have_role("moderator".send(param_method), Forum.last) }
+        it { should     have_role("moderator".send(param_method), Group.last) }
       end
-      
+
       context "not being a role of the user" do
         it { expect { subject.remove_role("manager".send(param_method), Group) }.not_to change { subject.roles.size } }
       end
@@ -99,23 +71,20 @@ shared_examples_for "#remove_role_examples" do |param_name, param_method|
       context "being a global role of the user" do
         it { expect { subject.remove_role("soldier".send(param_method), Group.first) }.not_to change { subject.roles.size } }
       end
-      
+
       context "being a class scoped role to the user" do
         it { expect { subject.remove_role("visitor".send(param_method), Forum.first) }.not_to change { subject.roles.size } }
       end
-      
+
       context "being instance scoped role to the user" do
         it { expect { subject.remove_role("moderator".send(param_method), Forum.first) }.to change { subject.roles.size }.by(-1) }
-        
-        it { subject.has_role?("soldier").should be_true }
-        it { subject.has_role?("visitor", Forum).should be_true }
-        it { subject.has_role?("moderator", Forum.first).should be_false }
-        it { subject.has_role?("anonymous", Forum.last).should be_true }
+
+        it { should_not have_role("moderator", Forum.first) }
       end
-      
+
       context "not being a role of the user" do
         it { expect { subject.remove_role("anonymous".send(param_method), Forum.first) }.not_to change { subject.roles.size } }
       end
     end
   end
-end
+end