troles 0.5.0

data/spec/trole/api_spec.rb

@@ -0,0 +1,60 @@
+require_all File.dirname(__FILE__) + '/api'
+
+require 'trole/two_roles_spec'
+require 'trole/multi_roles_spec'
+
+shared_examples_for "Trole API" do
+  include UserSetup 
+     
+  it_behaves_like "Trole Core API" do
+    define_users
+  end  
+
+  it_behaves_like "Trole Cache API" do
+    define_users
+  end  
+
+  it_behaves_like "Trole Event API" do
+    define_users
+  end  
+
+  it_behaves_like "Trole Read API" do
+    define_users
+  end  
+
+  it_behaves_like "Trole Validation API" do
+    define_users
+  end  
+
+  it_behaves_like "Trole Write API" do
+    define_users  
+  end  
+end  
+
+# All strategies EXCEPT :bit_one strategy
+
+shared_examples_for "Trole API for multiple roles" do
+  include UserSetup 
+    
+  it_behaves_like "Trole Write API for multiple roles" do
+    define_users
+  end  
+  
+  it_behaves_like "Trole Operations API for multiple roles" do
+    define_users
+  end  
+end
+
+# Specs for :bit_one strategy
+
+shared_examples_for "Trole API for two roles :bit_one" do
+  include UserSetup 
+    
+  it_behaves_like "Trole Write API for two roles :bit_one" do
+    define_users
+  end  
+  
+  it_behaves_like "Trole Operations API for two roles :bit_one" do
+    define_users
+  end  
+end

data/spec/trole/multi_roles_spec.rb

@@ -0,0 +1,163 @@
+shared_examples_for "Trole Write API for multiple roles" do
+  describe '#add_roles' do
+    it "should be that after adding :admin role, he has that role" do
+      lambda { user.add_roles(:admin) }.should raise_error # since it already has :user role and only allows one role!
+      user.has_role?(:admin).should be_false
+    end
+
+    it "should be that after adding :admin role, he has that role" do
+      user.clear_roles!
+      expect { user.add_roles(:admin) }.to change{ user.role_value }
+      user.has_role?(:admin).should be_true
+    end
+    
+    it 'should invalidate the role list after roles are changed' do
+      # expect roles changed event
+      lambda { user.set_roles(:blip) }.should raise_error # invalid role
+      user.set_role :editor # editor should be a valid role
+      expect { user.role_list }.to change{user.instance_variable_get "@role_list"}
+      user.role_name.should == :editor
+    end    
+  end  
+
+  describe '#clear_roles!' do
+    it "should clear all roles and invalidate roles cache" do
+      user.set_roles :admin, :editor, :blogger
+      user.clear_roles!
+      expect { user.role_list }.to change{user.role_list_value }
+      user.role_list.should be_empty      
+    end
+  end
+
+  describe '#set_roles' do
+    it "should set multiple valid roles" do
+      user.set_roles :admin, :editor, :blogger
+      user.has_role?(:admin).should be_true
+      user.has_role?(:user).should be_false
+      user.has_any_role?(:admin, :editor).should be_true
+      user.has_any_role?(:admin, :user).should be_false
+      user.has_all_roles?(:admin, :editor, :blogger).should be_true      
+    end
+
+    it "should only set valid roles" do
+      user.set_roles :admin, nil, :hello, :editor, :blogger, :admin, nil, 'hello'
+      user.has_role?(:admin).should be_true
+      user.has_role?(:user).should be_false
+      user.has_any_role?(:admin, :editor).should be_true
+      user.has_any_role?(:admin, :user).should be_false
+      user.has_all_roles?(:admin, :editor, :blogger).should be_true      
+    end
+  end
+  
+  describe '#remove_roles' do
+    it "should remove multiple valid roles and invalidate roles cache" do
+      user.set_roles :admin, :editor, :blogger, :user
+      user.remove_roles :admin, :blogger
+      expect { user.role_list }.to change{user.role_list_value}      
+
+      user.has_any_role?(:admin, :blogger).should be_false
+      user.has_any_role?(:admin, :editor).should be_true
+      user.has_any_role?(:blogger, :user).should be_true
+      
+      user.has_all_roles?(:admin, :blogger).should be_false
+      user.has_all_roles?(:editor).should be_true
+      user.has_role?(:editor).should be_true
+    end
+
+    it "should not remove :admin role twice if duplicated in roles argument" do
+      user.set_roles :admin, :editor, :blogger
+      user.remove_roles :admin, :admin
+      expect { user.role_list }.to change{user.role_list_value}      
+      user.has_role?(:admin).should be_false
+      user.roles.list.should == [:editor, :blogger]
+    end
+  end
+
+  describe '#static_role!' do
+    pending 'TODO'
+
+    it "should set set roles to :user only" do
+      user.static_role!(:guest)
+      user.has_role?(:guest).should be_true
+      user.valid_roles.should include(:guest)
+      lambda { user.set_roles(:admin) }.should raise_error
+    end
+  end  
+end
+
+shared_examples_for "Trole Operations API for multiple roles" do
+  describe '#clear!' do
+    it "should clear all roles and invalidate roles cache" do
+      user.set_roles :admin
+      user.roles << [:admin, :editor, :blogger]
+      user.roles.list.should == [:admin, :editor, :blogger]
+      user.roles.clear!
+      expect { user.role_list }.to change{user.role_list_value }
+      user.role_list.should be_empty      
+    end
+  end
+
+  describe '#+' do
+    it "should add multiple valid roles" do
+      user.set_roles :admin
+      user.roles + [:admin, :editor, :blogger]
+
+      user.roles.list.should == [:admin, :editor, :blogger]
+      user.has_role?(:admin).should be_true
+      user.has_role?(:user).should be_false
+
+      user.has_any_role?(:admin, :editor).should be_true
+
+      user.has_all_roles?(:admin, :user).should be_false
+      user.has_all_roles?(:admin, :editor, :blogger).should be_true      
+    end
+
+    it "should only set valid roles" do
+      user.set_roles :admin
+      user.roles + [:admin, nil, :hello, :editor, :blogger, :admin, nil, 'hello']
+
+      user.has_role?(:hello).should be_false
+      user.has_role?(:admin).should be_true
+      user.has_role?(:user).should be_false
+
+      user.has_any_role?(:admin, :editor).should be_true
+      user.has_any_role?(:admin, :user).should be_false
+
+      user.has_all_roles?(:admin, :editor, :blogger).should be_true      
+    end
+  end
+  
+  describe '#-' do
+    it "should remove multiple valid roles and invalidate roles cache" do
+      user.set_roles :admin, :blogger, :editor, :user
+      user.roles - [:admin, :blogger]
+      expect { user.role_list }.to change{user.role_list_value}      
+      user.has_any_role?(:admin, :blogger).should be_false
+      user.has_any_role?(:admin, :editor).should be_true
+      user.has_any_role?(:blogger, :user).should be_true
+      
+      user.has_all_roles?(:admin, :blogger).should be_false
+      user.has_all_roles?(:editor).should be_true
+      user.has_role?(:editor).should be_true
+    end
+
+    it "should not remove :admin role twice if duplicated in roles argument" do
+      user.set_roles :admin, :editor, :blogger
+      user.remove_roles :admin, :editor, :admin, nil, :blip
+      expect { user.role_list }.to change{user.role_list_value}      
+      user.has_role?(:admin).should be_false
+      user.roles.list.should == [:blogger]
+    end
+  end
+
+  describe '#static_role!' do
+    pending 'TODO'
+
+    it "should set set roles to :user only" do
+      user.static_role!(:guest)
+      user.has_role?(:guest).should be_true
+      user.valid_roles.should include(:guest)
+      lambda { user.set_roles(:admin) }.should raise_error
+    end
+  end    
+end

data/spec/trole/operations/read_spec.rb

@@ -0,0 +1,18 @@
+# module Troles
+#   module ReadOperations
+#     # check if the roles list has the given role
+#     def contains? role
+#      list.include? role
+#     end
+#     alias_method :includes?, :contains?
+# 
+#     # symbol list
+#     def list
+#     end
+# 
+#     # filter list of symbols 
+#     # on whether they are present as roles
+#     def get *roles
+#     end
+#   end
+# end

data/spec/trole/playbox/shared_examples.rb

@@ -0,0 +1,107 @@
+shared_examples_for "Using a :single role strategy for Kris" do
+  subject { kris }
+    its(:role)          { should be_a Trole::Operations  }
+   
+    # 
+    # specify             { kris.has_role?(:user).should be_true }
+    # specify             { kris.is_role?(:user).should be_true }
+    # 
+    # specify             { kris.has_all_roles?(:user).should be_true }
+    # specify             { kris.has_all_roles?(:user, :admin).should be_false }
+    # 
+    # specify             { kris.has_any_role?(:user, :admin).should be_true }
+    # specify             { kris.has_any_role?(:admin).should be_false }       
+    
+    # # Store Api
+    # specify do 
+    #   kris.set_role(:admin)
+    #   kris.has_role?(:admin).should be_true
+    #   kris.has_role?(:user).should be_false
+    # end       
+    # 
+    # specify do 
+    #   kris.set_roles(:admin)
+    #   kris.has_role?(:admin).should be_true
+    #   kris.has_role?(:user).should be_false
+    # end       
+    # 
+    # specify do 
+    #   expect { kris.clear_roles! }.to change{kris.instance_variable_get "@trole"}
+    #   kris.role_list.should be_empty      
+    # end
+    # 
+    # # Write Api
+    # specify do       
+    #   expect { kris.add_roles(:admin) }.to change{kris.instance_variable_get "@trole"}
+    #   expect { kris.remove_roles(:user) }.to change{kris.instance_variable_get "@trole"}                   
+    #   kris.has_role?(:admin).should be_true
+    #   kris.has_role?(:user).should be_false
+    # end
+    # 
+    # # # roles - operator
+    # specify { lambda { kris.add_roles(:admin, :blogger) }.should raise_error } 
+    # 
+    # specify do       
+    #   expect { kris.add_role(:admin) }.to change{kris.instance_variable_get "@trole"}
+    #   expect { kris.remove_role(:user) }.to change{kris.instance_variable_get "@trole"}                   
+    #   kris.has_role?(:admin).should be_true
+    #   kris.has_role?(:user).should be_false
+    # end
+    # 
+    # # # roles Operations object
+    # specify do 
+    #   expect { kris.roles.clear! }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.list.should be_empty      
+    # end
+    # 
+    # specify do 
+    #   expect { kris.role.clear! }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.list.should be_empty      
+    # end
+    #   
+    # # # roles + operator
+    # specify do 
+    #   expect { kris.roles + :admin }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.contains?(:admin).should be_true      
+    # end
+    # 
+    # # # roles + operator
+    # specify do 
+    #   expect { kris.roles - :admin }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.contains?(:admin).should be_true      
+    # end
+    # 
+    # specify do 
+    #   expect { kris.roles - [:admin, :blogger] }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.contains?(:admin).should be_true      
+    # end
+    # 
+    # # # roles << operator
+    # specify do 
+    #   kris.clear_roles!
+    #   expect { kris.roles << :admin }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.contains?(:admin).should be_true      
+    # end
+    # 
+    # specify do 
+    #   kris.clear_roles!
+    #   expect { kris.roles << [:admin, :blogger] }.to change{kris.instance_variable_get "@trole"}
+    #   kris.roles.contains?(:admin).should be_true      
+    # end
+end
+
+shared_examples_for "a Many Single for Susan" do
+  subject { susan }
+    its(:name)          { should == 'susan' }
+    
+    # Core API
+    its(:role_list)     { should include(:admin) }
+end
+
+shared_examples_for "a Many strategy for Jack" do
+  subject { jack }
+    its(:name)          { should == 'jack' }
+    
+    # Core API
+    its(:role_list)     { should include(:user, :admin) }
+end

data/spec/trole/strategies/bit_one_spec.rb

@@ -0,0 +1,22 @@
+require 'trole/strategy_helper'
+
+User.troles_strategy :bit_one, :generic => true do |c|
+  # c.valid_roles = [:user, :admin]
+end.configure!
+
+module UserSetup
+  def create_user
+    Factory.create :user, :name => 'user', :trole => false
+  end
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :trole => true
+  end
+end
+
+describe 'Trole strategy bit_one' do
+  it_behaves_like "Common API"
+  it_behaves_like "Trole API for two roles :bit_one"
+
+  it_behaves_like "Trole API"  
+end    

data/spec/trole/strategies/embed_one_spec.rb

@@ -0,0 +1,32 @@
+require 'strategy_helper'
+
+User.troles_strategy :embed_one do |c|
+  c.valid_roles = [:user, :admin, :editor, :blogger]
+end.configure!
+
+Config.add_roles [:user, :admin, :editor, :blogger]
+
+module UserSetup
+  def create_role name
+    Role.create(name)
+  end
+
+  def create_no_roles
+    Factory.create :user, :name => 'no roles', :trole => [ ]
+  end
+
+  def create_user
+    Factory.create :user, :name => 'user', :trole => [ create_role(:user) ]
+  end                                            
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :trole => [ create_role(:admin) ]
+  end
+end
+
+describe 'Trole strategy :embed_one' do
+  it_behaves_like "Common API"
+  it_behaves_like "Common API for multiple roles"  
+
+  it_behaves_like "Trole API"  
+end    

data/spec/trole/strategies/ref_one_spec.rb

@@ -0,0 +1,29 @@
+require 'strategy_helper'
+
+User.troles_strategy :ref_one do |c|
+  c.valid_roles = [:user, :admin, :editor, :blogger]
+end.configure!
+
+Config.add_roles [:user, :admin, :editor, :blogger]
+
+module UserSetup
+  def create_no_roles
+    Factory.create :user, :name => 'no roles', :trole => [ ]
+  end
+
+  def create_user
+    Factory.create :user, :name => 'user', :trole => [ Role.where(:name => :user) ]
+  end
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :trole => [ Role.where(:name => :admin) ]
+  end
+end
+
+describe 'Trole strategy ref_one' do
+  it_behaves_like "Common API"
+  it_behaves_like "Common API for multiple roles"  
+
+  it_behaves_like "Trole API"  
+end    
+

data/spec/trole/strategies/string_one_spec.rb

@@ -0,0 +1,26 @@
+require 'strategy_helper'
+
+User.troles_strategy :string_one do |c|
+  c.valid_roles = [:user, :admin, :editor, :blogger]
+end.configure!
+
+module UserSetup
+  def create_no_roles
+    Factory.create :user, :name => 'no roles', :trole => ''
+  end
+
+  def create_user
+    Factory.create :user, :name => 'user', :trole => 'user'
+  end
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :trole => 'admin'
+  end
+end
+
+describe 'Trole strategy string_one' do
+  it_behaves_like "Common API"
+  it_behaves_like "Common API for multiple roles"  
+
+  it_behaves_like "Trole API"  
+end    

data/spec/trole/strategy_helper.rb

@@ -0,0 +1,3 @@
+require 'trole_spec_helper'
+require 'trole_spec'      
+require 'generic/models'

data/spec/trole/two_roles_spec.rb

@@ -0,0 +1,76 @@
+shared_examples_for "Trole Write API for two roles :bit_one" do
+  describe '#add_role' do
+    it "should be that after adding :admin role, he has that role" do
+      # lambda { user.add_roles(:admin) }.should raise_error # since it already has :user role and only allows one role!
+      user.add_role(:admin)
+      user.has_role?(:admin).should be_false
+    end
+  end
+
+  describe '#add_roles' do
+    it "should be that after adding :admin role, he has that role" do
+      # lambda { user.add_roles(:admin) }.should raise_error # since it already has :user role and only allows one role!
+      user.add_roles(:admin)
+      user.has_role?(:admin).should be_false
+    end
+
+    it "should be that after adding :admin role, he has that role" do
+      user.clear_roles!
+      expect { user.add_roles(:admin) }.to_not change{ user.role_value }
+      user.has_role?(:admin).should be_false
+    end    
+  end    
+  
+  describe '#set_role' do
+    it 'should invalidate the role list after roles are changed' do
+      user.set_role :admin # editor should be a valid role
+      expect { user.role_list }.to change{user.instance_variable_get "@role_list"}
+      user.role_name.should == :admin
+    end    
+  end
+
+  describe '#set_roles' do
+    it 'should invalidate the role list after roles are removed' do
+      user.set_role :admin # editor should be a valid role
+      user.clear_roles!      
+      expect { user.role_list }.to change{user.instance_variable_get "@role_list"}
+      user.role_name.should == :user
+    end    
+  end
+
+  describe '#set_roles' do
+    it 'should invalidate the role list after roles are changed' do
+      user.set_roles :admin # editor should be a valid role
+      expect { user.role_list }.to change{user.instance_variable_get "@role_list"}
+      user.role_name.should == :admin
+    end    
+  end
+end
+
+shared_examples_for "Trole Operations API for two roles :bit_one" do
+  describe '#+' do
+    it "should be that trying to add :admin role, he will not be given that role" do
+      # lambda { user.add_roles(:admin) }.should raise_error # since it already has :user role and only allows one role!
+      user.roles + [:admin]
+      user.has_role?(:admin).should be_false
+    end
+  end
+
+  describe '#-' do
+    it "should be that removing :admin role (true) sets him back to :user role (false)" do
+      # lambda { user.add_roles(:admin) }.should raise_error # since it already has :user role and only allows one role!
+      user.set_roles :admin
+      user.roles - [:admin]
+      user.has_role?(:admin).should be_false
+      user.has_role?(:user).should be_true
+    end
+
+    it "should be that removing :user role (true) from user with that role, sets him back to :user role (false) anyways!" do
+      # lambda { user.add_roles(:admin) }.should raise_error # since it already has :user role and only allows one role!
+      user.set_roles :user
+      user.roles - [:user]
+      user.has_role?(:admin).should be_false
+      user.has_role?(:user).should be_true
+    end
+  end  
+end

data/spec/trole_spec.rb

@@ -0,0 +1,12 @@
+require 'trole'
+require 'trole/macros'
+require 'troles'
+
+require 'troles/common/api_spec' # Common API examples
+require 'trole/api_spec'  # Trole API examples
+
+describe Trole do
+  it "should be a module" do
+    Trole.should be_a(Module)
+  end
+end

data/spec/trole_spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rspec'
+require 'require_all'
+require 'factory_girl'
+require 'mocha'
+require 'factories'
+require 'support/shared_examples'
+
+module Config
+  def self.create_role name
+    Role.create(:name => name.to_s)
+  end
+
+  def self.add_roles *names
+    names.flatten.each {|n| create_role(n) }
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/troles/api/cache_api_spec.rb

@@ -0,0 +1,2 @@
+shared_examples_for "Troles Cache API" do
+end

data/spec/troles/api/core_api_spec.rb

@@ -0,0 +1,4 @@
+shared_examples_for "Troles Core API" do
+  subject { User }
+    its(:role_field) { should == :troles }
+end

data/spec/troles/api/event_api.rb

@@ -0,0 +1,2 @@
+shared_examples_for "Troles Event API" do
+end

data/spec/troles/api/read_api_spec.rb

@@ -0,0 +1,2 @@
+shared_examples_for "Troles Read API" do
+end

data/spec/troles/api/validation_api_spec.rb

@@ -0,0 +1,2 @@
+shared_examples_for "Troles Validation API" do
+end

data/spec/troles/api/write_api_spec.rb

@@ -0,0 +1,2 @@
+shared_examples_for "Troles Write API" do
+end

data/spec/troles/api_spec.rb

@@ -0,0 +1,41 @@
+require_all File.dirname(__FILE__) + '/api'
+
+shared_examples_for "Troles API" do
+  include UserSetup 
+     
+  it_behaves_like "Troles Core API" do
+    let(:no_roles_user) { create_no_roles_user  }
+    let(:user)          { create_user  }
+    let(:admin_user)    { create_admin_user  }
+  end  
+
+  it_behaves_like "Troles Cache API" do
+    let(:no_roles_user) { create_no_roles_user  }
+    let(:user)          { create_user  }
+    let(:admin_user)    { create_admin_user  }
+  end  
+
+  it_behaves_like "Troles Event API" do
+    let(:no_roles_user) { create_no_roles_user  }
+    let(:user)          { create_user  }
+    let(:admin_user)    { create_admin_user  }
+  end  
+
+  it_behaves_like "Troles Read API" do
+    let(:no_roles_user) { create_no_roles_user  }
+    let(:user)          { create_user  }
+    let(:admin_user)    { create_admin_user  }
+  end  
+
+  it_behaves_like "Troles Validation API" do
+    let(:no_roles_user) { create_no_roles_user  }
+    let(:user)          { create_user  }
+    let(:admin_user)    { create_admin_user  }
+  end  
+
+  it_behaves_like "Troles Write API" do
+    let(:no_roles_user) { create_no_roles_user  }
+    let(:user)          { create_user  }
+    let(:admin_user)    { create_admin_user  }
+  end  
+end

data/spec/troles/common/api/cache_api_spec.rb

@@ -0,0 +1,31 @@
+shared_examples_for "Common Cache API" do
+  describe '#invalidate_role_cache!' do
+    before :each do
+      user.role_list
+      user.invalidate_role_cache!                                     
+    end
+
+    # should invalidate role cache, forcing update of @role_list instance var    
+    expect { user.role_list }.to change { user.instance_variable_get "@role_list" }
+  end
+end
+
+# specify { user.role_list.should == [:admin, :blogger] }
+# it { should be_valid }            
+# its(:errors) { should be_empty }
+# ################################################################################
+# # specify (generated descriptions)
+# # instead of repeating expectation with: it "should not be published"...)
+# specify { blog_post.should_not be_published }
+# 
+# ################################################################################
+# # subject (delegate should/should_not to subject)
+# subject { BlogPost.new :title => 'foo', :body => 'bar' }
+#  it "sets published timestamp" do
+#    subject.publish!
+#    subject.should be_published
+#  end
+# 
+# it { should be_valid }
+# its(:errors) { should be_empty }
+# its(:title) { should == 'foo' }