rolify 3.1.0 → 3.2.0

data/spec/generators/rolify/role/role_generator_spec.rb

@@ -46,7 +46,7 @@ describe Rolify::Generators::RoleGenerator do
     
     describe 'app/models/user.rb' do
       subject { file('app/models/user.rb') }
-      it { should contain "rolify" }
+      it { should contain /class User < ActiveRecord::Base\n  rolify\n/ }
     end
     
     describe 'migration file' do
@@ -88,10 +88,10 @@ describe Rolify::Generators::RoleGenerator do
       it { should contain "belongs_to :resource, :polymorphic => true" }
     end
     
-    describe 'app/models/client.rb' do
+    describe 'app/models/admin_user.rb' do
       subject { file('app/models/admin_user.rb') }
       
-      it { should contain "rolify" }
+      it { should contain /class AdminUser < ActiveRecord::Base\n  rolify :role_cname => 'AdminRole'\n/ }
     end
     
     describe 'migration file' do
@@ -103,61 +103,19 @@ describe Rolify::Generators::RoleGenerator do
     end
   end
   
-  describe 'specifying dynamic shortcuts' do
-    before(:all) { arguments [ "Role", "User", "--dynamic_shortcuts" ] }
-    
-    before { 
-      capture(:stdout) {
-        generator.create_file "app/models/user.rb" do
-          "class User < ActiveRecord::Base\nend"
-        end
-      }
-      run_generator
-    }
-      
-    describe 'config/initializers/rolify.rb' do
-      subject { file('config/initializers/rolify.rb') }
-      it { should exist }
-      it { should contain "Rolify.configure do |config|"}
-      it { should_not contain "# config.use_dynamic_shortcuts" }
-      it { should contain "# config.use_mongoid" }
-    end
-    
-    describe 'app/models/role.rb' do
-      subject { file('app/models/role.rb') }
-      it { should exist }
-      it { should contain "class Role < ActiveRecord::Base" }
-      it { should contain "has_and_belongs_to_many :users, :join_table => :users_roles" }
-      it { should contain "belongs_to :resource, :polymorphic => true" }
-    end
-    
-    describe 'app/models/user.rb' do
-      subject { file('app/models/user.rb') }
-      it { should contain "rolify" }
-    end
-    
-    describe 'migration file' do
-      subject { migration_file('db/migrate/rolify_create_roles.rb') }
-      
-      it { should be_a_migration }
-      it { should contain "create_table(:roles) do" }
-      it { should contain "create_table(:users_roles, :id => false) do" }
-    end
-  end
-  
   describe 'specifying orm adapter' do 
     before(:all) { arguments [ "Role", "User", "mongoid" ] }
     
     before { 
       capture(:stdout) {
         generator.create_file "app/models/user.rb" do
-          <<-CLASS 
-          class User
-            include Mongoid::Document
+<<-CLASS 
+class User
+  include Mongoid::Document
 
-            field :login, :type => String
-          end
-          CLASS
+  field :login, :type => String
+end
+CLASS
         end
       }
       run_generator
@@ -178,20 +136,18 @@ describe Rolify::Generators::RoleGenerator do
       it { should contain "has_and_belongs_to_many :users\n" }
       it { should contain "belongs_to :resource, :polymorphic => true" }
       it { should contain "field :name, :type => String" }
-      it { should contain "index :name, unique: true" }
-      it { should contain "  index(\n"
-                          "    [\n"
-                          "      [:name, Mongo::ASCENDING],\n"
-                          "      [:resource_type, Mongo::ASCENDING],\n"
-                          "      [:resource_id, Mongo::ASCENDING]\n"
-                          "    ],\n"
-                          "    unique: true\n"
-                          "  )\n" }
+      it { should contain "index({ :name => 1 }, { :unique => true })" }
+      it { should contain "  index({\n"
+                          "      { :name => 1 },\n"
+                          "      { :resource_type => 1 },\n"
+                          "      { :resource_id => 1 }\n"
+                          "    },\n"
+                          "    { unique => true })"}
     end
     
     describe 'app/models/user.rb' do
       subject { file('app/models/user.rb') }
-      it { should contain "rolify" }
+      it { should contain /class User\n  include Mongoid::Document\n  rolify\n/ }
     end
   end
 end

data/spec/rolify/custom_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 require "rolify/shared_examples/shared_examples_for_roles"
 require "rolify/shared_examples/shared_examples_for_dynamic"
+require "rolify/shared_examples/shared_examples_for_scopes"
+require "rolify/shared_examples/shared_examples_for_callbacks"  
 
 describe "Using Rolify with custom User and Role class names" do
   it_behaves_like Rolify::Role do
@@ -8,8 +10,18 @@ describe "Using Rolify with custom User and Role class names" do
     let(:role_class) { Privilege }
   end
 
+  it_behaves_like "Role.scopes" do
+    let(:user_class) { Customer } 
+    let(:role_class) { Privilege }
+  end
+
   it_behaves_like Rolify::Dynamic do
     let(:user_class) { Customer } 
     let(:role_class) { Privilege }
   end
+
+  it_behaves_like "Rolify.callbacks" do
+    let(:user_class) { Customer }
+    let(:role_class) { Privilege }
+  end
 end

data/spec/rolify/resource_spec.rb

@@ -6,6 +6,7 @@ describe Rolify::Resource do
     User.rolify :role_cname => "Role"
     Forum.resourcify :role_cname => "Role"
     Group.resourcify :role_cname => "Role"
+    Role.destroy_all
   end
 
   # Users
@@ -16,6 +17,7 @@ describe Rolify::Resource do
   let!(:forum_role)      { admin.add_role(:forum, Forum.first) }
   let!(:godfather_role)  { admin.add_role(:godfather, Forum) }
   let!(:group_role)      { admin.add_role(:group, Group.last) }
+  let!(:grouper_role)    { admin.add_role(:grouper, Group.first) }
   let!(:tourist_role)    { tourist.add_role(:forum, Forum.last) }
   let!(:sneaky_role)     { tourist.add_role(:group, Forum.first) }
 
@@ -30,10 +32,10 @@ describe Rolify::Resource do
         subject { Forum }
 
         it "should include Forum instances with forum role" do 
-          subject.with_role(:forum).should include(Forum.first, Forum.last)
+          subject.with_role(:forum).should =~ [ Forum.first, Forum.last ]
         end
         it "should include Forum instances with godfather role" do 
-          subject.with_role(:godfather).should eq(Forum.all)
+          subject.with_role(:godfather).should =~ Forum.all.to_a
         end
       end
 
@@ -41,26 +43,36 @@ describe Rolify::Resource do
         subject { Group }
 
         it "should include Group instances with group role" do
-          subject.with_role(:group).should include(Group.last)
+          subject.with_role(:group).should =~ [ Group.last ]
         end
       end
 
     end
 
+    context "with an array of role names as argument" do 
+      context "on the Group class" do 
+        subject { Group }
+        
+        it "should include Group instances with both group and grouper roles" do 
+          subject.with_roles([:group, :grouper]).should =~ [ Group.first, Group.last ]
+        end
+      end
+    end
+
     context "with a role name and a user as arguments" do
       context "on the Forum class" do 
         subject { Forum }
 
         it "should get all Forum instances binded to the forum role and the admin user" do
-          subject.with_role(:forum, admin).should include(Forum.first)
+          subject.with_role(:forum, admin).should =~ [ Forum.first ]
         end
 
         it "should get all Forum instances binded to the forum role and the tourist user" do
-          subject.with_role(:forum, tourist).should include(Forum.last)
+          subject.with_role(:forum, tourist).should =~ [ Forum.last ]
         end
 
         it "should get all Forum instances binded to the godfather role and the admin user" do
-          subject.with_role(:godfather, admin).should == Forum.all
+          subject.with_role(:godfather, admin).should =~ Forum.all.to_a
         end
 
         it "should get all Forum instances binded to the godfather role and the tourist user" do
@@ -68,7 +80,7 @@ describe Rolify::Resource do
         end
 
         it "should get Forum instances binded to the group role and the tourist user" do
-          subject.with_role(:group, tourist).should include(Forum.first)
+          subject.with_role(:group, tourist).should =~ [ Forum.first ]
         end
 
         it "should not get Forum instances not binded to the group role and the tourist user" do
@@ -80,7 +92,7 @@ describe Rolify::Resource do
         subject { Group }
 
         it "should get all resources binded to the group role and the admin user" do
-          subject.with_role(:group, admin).should include(Group.last)
+          subject.with_role(:group, admin).should =~ [ Group.last ]
         end
 
         it "should not get resources not binded to the group role and the admin user" do
@@ -88,6 +100,27 @@ describe Rolify::Resource do
         end
       end
     end
+
+    context "with an array of role names and a user as arguments" do
+      context "on the Forum class" do 
+        subject { Forum }
+
+        it "should get Forum instances binded to the forum and group roles and the tourist user" do
+          subject.with_roles([:forum, :group], tourist).should =~ [ Forum.first, Forum.last ]
+        end
+
+      end
+
+      context "on the Group class" do 
+        subject { Group }
+
+        it "should get Group instances binded to the group and grouper roles and the admin user" do
+          subject.with_roles([:group, :grouper], admin).should =~ [ Group.first, Group.last ]
+        end
+
+      end
+    end
+
   end
 
   describe ".find_role" do
@@ -98,7 +131,7 @@ describe Rolify::Resource do
         subject { Forum }
 
         it "should get all roles binded to a Forum class or instance" do
-          subject.find_roles.should include(forum_role, godfather_role, tourist_role, sneaky_role)
+          subject.find_roles.to_a.should =~ [ forum_role, godfather_role, tourist_role, sneaky_role ]
         end
 
         it "should not get roles not binded to a Forum class or instance" do
@@ -107,7 +140,7 @@ describe Rolify::Resource do
 
         context "using :any parameter" do
           it "should get all roles binded to any Forum class or instance" do
-            subject.find_roles(:any, :any).should include(forum_role, godfather_role, tourist_role, sneaky_role)
+            subject.find_roles(:any, :any).to_a.should =~ [ forum_role, godfather_role, tourist_role, sneaky_role ]
           end
 
           it "should not get roles not binded to a Forum class or instance" do
@@ -120,7 +153,7 @@ describe Rolify::Resource do
         subject { Group }
         
         it "should get all roles binded to a Group class or instance" do
-          subject.find_roles.should include(group_role)
+          subject.find_roles.to_a.should =~ [ group_role, grouper_role ]
         end
 
         it "should not get roles not binded to a Group class or instance" do
@@ -129,7 +162,7 @@ describe Rolify::Resource do
 
         context "using :any parameter" do
           it "should get all roles binded to Group class or instance" do
-            subject.find_roles(:any, :any).should include(group_role)
+            subject.find_roles(:any, :any).to_a.should =~ [ group_role, grouper_role ]
           end
 
           it "should not get roles not binded to a Group class or instance" do
@@ -155,7 +188,7 @@ describe Rolify::Resource do
 
         context "using a user parameter" do
           it "should get all roles binded to any resource" do
-            subject.find_roles(:forum, admin).should include(forum_role)
+            subject.find_roles(:forum, admin).to_a.should =~ [ forum_role ]
           end
 
           it "should not get roles not binded to the admin user and forum role name" do
@@ -286,15 +319,30 @@ describe Rolify::Resource do
     it { should respond_to :roles }
 
     context "on a Forum instance" do 
-      its(:roles) { should include(forum_role, sneaky_role) } 
+      its(:roles) { should eq([ forum_role, sneaky_role ]) }
       its(:roles) { subject.should_not include(group_role, godfather_role, tourist_role) }
     end
 
     context "on a Group instance" do
       subject { Group.last }
 
-      its(:roles) { should include(group_role) } 
+      its(:roles) { should eq([ group_role ]) } 
       its(:roles) { should_not include(forum_role, godfather_role, sneaky_role, tourist_role) }
+      
+      context "when deleting a Group instance" do
+        subject do 
+          Group.create(:name => "to delete")
+        end
+        
+        before do
+          subject.roles.create :name => "group_role1"
+          subject.roles.create :name => "group_role2"
+        end
+        
+        it "should remove the roles binded to this instance" do
+          expect { subject.destroy }.to change { Role.count }.by(-2)
+        end
+      end
     end
   end
 
@@ -302,14 +350,14 @@ describe Rolify::Resource do
     context "on a Forum instance" do
       subject { Forum.first }
 
-      its(:applied_roles) { should include(forum_role, godfather_role, sneaky_role) }
+      its(:applied_roles) { should =~ [ forum_role, godfather_role, sneaky_role ] }
       its(:applied_roles) { should_not include(group_role, tourist_role) }
     end
 
     context "on a Group instance" do
       subject { Group.last }
 
-      its(:applied_roles) { should include(group_role) }
+      its(:applied_roles) { should =~ [ group_role ] }
       its(:applied_roles) { should_not include(forum_role, godfather_role, sneaky_role, tourist_role) }
     end
   end

data/spec/rolify/role_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 require "rolify/shared_examples/shared_examples_for_roles"
 require "rolify/shared_examples/shared_examples_for_dynamic"
+require "rolify/shared_examples/shared_examples_for_scopes"
+require "rolify/shared_examples/shared_examples_for_callbacks"
 
 describe Rolify do
   it_behaves_like Rolify::Role do
@@ -8,8 +10,18 @@ describe Rolify do
     let(:role_class) { Role }
   end
 
+  it_behaves_like "Role.scopes" do
+    let(:user_class) { User } 
+    let(:role_class) { Role }
+  end
+
   it_behaves_like Rolify::Dynamic do
     let(:user_class) { User } 
     let(:role_class) { Role }
   end
+
+  it_behaves_like "Rolify.callbacks" do
+    let(:user_class) { User }
+    let(:role_class) { Role }
+  end
 end

data/spec/rolify/shared_contexts.rb

@@ -63,6 +63,18 @@ 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 ]]) }
+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_callbacks.rb

@@ -0,0 +1,57 @@
+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
+        user_class.rolify :before_add => :role_callback, :role_cname => role_class.to_s
+        @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
+        user_class.rolify :after_add => :role_callback, :role_cname => role_class.to_s
+        @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
+        user_class.rolify :before_remove => :role_callback, :role_cname => role_class.to_s
+        @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
+        user_class.rolify :after_remove => :role_callback, :role_cname => role_class.to_s
+        @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_finders.rb

@@ -0,0 +1,77 @@
+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
+      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