troles 0.5.0

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

@@ -0,0 +1,14 @@
+shared_examples_for "Common Core API" do
+  # Core API
+  specify             { lambda { user.role_field }.should raise_error } # no, role_field is a class method    
+  specify             { User.role_field.should_not be_nil } # yes, role_field is a class method    
+
+  subject { user }
+    its(:role_list)     { should include(:user) }
+    its(:roles)         { should be_a Troles::Operations }
+
+  specify             { user.static_roles?.should be_false }
+  specify             { User.static_roles?.should be_false }  
+  
+  # TODO: Add examples with other users?
+end

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

@@ -0,0 +1,9 @@
+shared_examples_for "Common Event API" do
+  # Event API
+  subject { user }
+    its(:event_manager) { should == Troles::Common::EventManager }
+
+  specify             { user.role_field_changed?(:roles).should be_false } # using dummy method on User
+  specify             { user.publish_change(:roles).should be_true }
+  specify             { user.update_roles.should be_false } # ?
+end

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

@@ -0,0 +1,55 @@
+shared_examples_for "Common Operations API" do    
+  describe '#list' do    
+    it 'should clear the roles on clear!' do
+      user.clear_roles!      
+      user.add_roles(:admin, :blogger)
+      user.role_list.should include(:admin, :blogger)      
+    end
+  end
+
+  describe '#clear!' do    
+    it 'should clear the roles on clear!' do
+      user.roles.clear!
+      expect { user.role_list }.to change{user.role_list_value }      
+      user.role_list.should be_empty      
+    end
+  end
+
+  describe '#- operator' do
+    it 'should remove the :admin role' do
+      user.clear_roles!      
+      user.add_roles(:admin, :blogger)
+      user.roles - :admin
+      expect { user.role_list }.to change{user.role_list_value }
+  
+      user.has_role?(:blogger).should be_true      
+      user.has_role?(:admin).should be_false
+    end
+  end
+  
+  describe '#+ operator' do      
+    it 'should add the :admin role' do
+      user.clear_roles!      
+      user.roles + :admin
+      expect { user.role_list }.to change{user.role_list_value }
+      user.has_role?(:admin).should be_true      
+    end
+  end
+  
+  describe '#<< operator' do
+    it 'should add the :admin role' do
+      user.clear_roles!
+      user.roles << :admin
+      expect { user.role_list }.to change{user.role_list_value }
+      user.has_role?(:admin).should be_true      
+    end
+  end
+  
+  describe 'acts as Enumerable' do
+    it 'should enable include?' do
+      user.clear_roles!
+      user.roles << :admin
+      user.roles.include?(:admin).should be_true      
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+shared_examples_for "Common Read API" do
+  specify { user.has_role?(:user).should be_true }
+  specify { user.is_role?(:user).should be_true }
+        
+  specify { user.has_roles?(:user).should be_true }
+  specify { user.has_roles?(:user, :admin).should be_false }
+        
+  specify { user.has_any_role?(:user, :admin).should be_true }
+  specify { user.has_any_role?(:admin).should be_false }       
+
+  subject { user }
+    its(:role_list)     { should include(:user) }
+
+  it 'should cache the role list' do
+    # use mock expectation : don't expect strategy to be called!
+    user.role_list.should include(:user)
+    user.expects(:strategy).never
+
+    # calling role_list multiple times should NOT invalidate the cache :)
+    expect { user.role_list }.to_not change{user.instance_variable_get "@role_list"}      
+    user.role_list.should include(:user)      
+  end
+end

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

@@ -0,0 +1,46 @@
+shared_examples_for "Common Validation API" do
+  describe '#check_valid_role?' do
+    it 'should return valid role' do
+      user.check_valid_role?(:admin).should == :admin
+    end
+  end
+
+  # @return [Array<Symbol>] returns the valid roles or empty list if no valid roles
+  describe '#check_valid_roles?' do
+    it 'should return valid roles' do
+      user.check_valid_roles?(:admin, :editor).should include(:admin)
+    end
+  end
+
+  # @return [Symbol, false, Error] a valid role name, false if invalid, or Error on some error    
+  describe '#make_valid_role?' do
+    it 'should return valid role' do
+      user.send :make_valid_role, :admin
+    end
+  end
+
+  # Ensures the role are valid
+  # @param [Symbol] list of roles
+  # @return [Array<Symbol>] the valid roles from the list of roles given
+  describe '#make_valid_roles?' do
+    it 'should return valid roles' do
+      user.send :make_valid_roles, [:admin, :editor]
+    end
+  end
+
+  # @return [Array<Symbol>] the valid roles of the role subject
+  describe '#valid_roles' do
+    it 'should get valid roles of class' do                   
+      user.send(:valid_roles).should include(:admin)
+    end
+  end
+
+  context 'Class Methods' do
+    # @return [Array<Symbol>] the valid roles of the role subject
+    describe '#valid_roles' do
+      it 'should set not valid roles again!' do                   
+        user.class.valid_roles.should include(:admin)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+shared_examples_for "Common Write API" do
+  describe '#clear_roles!' do
+    it "should clear roles and invalidate roles cache" do
+      user.set_roles :admin
+      user.clear_roles!
+      expect { user.role_list }.to change{user.role_list_value }
+      user.role_list.should be_empty      
+    end
+
+    it "successive clear roles should not invalidate roles cache" do
+      user.set_roles :admin
+      user.clear_roles!
+      expect { user.role_list }.to change{user.role_list_value }
+      user.clear_roles!      
+      expect { user.role_list }.to_not change{user.role_list_value }
+    end
+  end
+
+  describe '#set_roles' do
+    it "should set roles to :admin only" do
+      user.set_roles(:admin)
+      user.has_role?(:admin).should be_true
+      user.has_role?(:user).should be_false
+    end
+
+    it 'should invalidate the role list after roles are changed' do  
+      user.clear_roles!
+      user.set_roles :admin
+      expect { user.role_list }.to change{user.role_list_value}
+      user.has_role?(:admin).should be_true
+    end
+    
+    it 'should not set invalid role and thus not invalidate the role list' do
+      # lambda { user.set_roles(:blip) }.should raise_error # invalid role
+      user.set_roles(:blip).should be_false
+      expect { user.role_list }.to_not change{user.role_list_value}
+    end
+    
+    it "should set roles to one :admin only if duplicated in roles argument" do
+      user.set_roles(:admin, :admin)
+      expect { user.role_list }.to change{user.role_list_value}      
+      user.has_role?(:admin).should be_false
+      user.role_list.should == [:admin]
+    end    
+  end
+
+  
+  describe '#remove_roles' do
+    it "should not remove :blip role and thus not invalidate roles cache" do
+      user.remove_roles :blip
+      expect { user.role_list }.to_not change{user.role_list_value}      
+    end
+
+    it "should not remove :admin role twice if duplicated in roles argument" do
+      user.remove_roles :admin, :admin
+      expect { user.role_list }.to change{user.role_list_value}      
+      user.has_role?(:admin).should be_false
+    end
+
+    it "should remove :admin role and invalidate roles cache" do
+      user.set_roles :admin
+      expect { user.role_list }.to change{user.role_list_value}      
+      expect { user.role_list }.to_not change{user.role_list_value}      
+      
+      user.remove_roles(:admin).should be_false
+      expect { user.role_list }.to change{user.role_list_value}
+      user.has_role?(:admin).should be_false
+    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/troles/common/api_spec.rb

@@ -0,0 +1,101 @@
+# See http://blog.davidchelimsky.net/2010/11/07/specifying-mixins-with-shared-example-groups-in-rspec-2/
+# And: http://relishapp.com/rspec/rspec-core/v/2-6/dir/example-groups/shared-examples
+# Also: http://stackoverflow.com/questions/6152359/dynamically-generating-shared-examples-in-rspec-2
+
+require_all File.dirname(__FILE__) + '/api'
+
+require 'troles/common/multi_roles_spec'
+
+def define_users
+  let(:no_roles_user) { create_no_roles_user  }
+  let(:user)          { create_user  }
+  let(:admin_user)    { create_admin_user  }
+end  
+
+shared_examples_for "Common API" do
+  include UserSetup 
+     
+  it_behaves_like "Common Core API" do
+    define_users
+  end  
+
+  # 
+  # it_behaves_like "Common Event API" do
+  #   define_users
+  # end  
+  # 
+  # it_behaves_like "Common Read API" do
+  #   define_users
+  # end  
+  # 
+  # it_behaves_like "Common Validation API" do
+  #   define_users
+  # end  
+  # 
+  # it_behaves_like "Common Write API" do
+  #   define_users
+  # end  
+  # 
+  # it_behaves_like "Common Operations API" do
+  #   define_users
+  # end  
+end 
+
+shared_examples_for "Common API for multiple roles" do
+  include UserSetup 
+    
+  it_behaves_like "Common Write API for multiple roles" do
+    define_users
+  end  
+end
+
+# Customizing shared example groups
+# 
+# Here are three techniques for customizing shared groups:
+# Parameterization
+# 
+# describe Host do
+#   it_should_behave_like M, Host.new
+# end
+# 
+# Here, the result of Host.new is passed to the shared group as a block parameter, making that value available at the group level (each example group is a class), and the instance level (each example runs in an instance of that class). So …
+# 
+# shared_examples_for M do |host|
+#   it "can access #{host} in the docstring" do
+#     host.do_something # it can access the host _in_ the example
+#   end
+# end
+# 
+# Methods defined in host group
+# 
+# describe Host do
+#   let(:foo) { Host.new }
+#   it_should_behave_like M
+# end
+# 
+# In this case, the foo() method defined by let() is inherited by the generated nested group, and available within any of the examples defined in the shared group.
+# 
+# shared_examples_for M do
+#   it "does something" do
+#     foo
+#   end
+# end
+# 
+# NOTE that instance methods that are inherited like this are not available in the class scope of the generated example group, and are therefore not available for use in docstings:
+# 
+# shared_examples_for M do
+#   it "does some #{foo}" do # this would raise an error
+#     # ...
+#   end
+# end
+# 
+# Methods defined in an extension block
+# 
+# describe Host do
+#   it_should_behave_like M do
+#     let(:foo) { Host.new }
+#   end
+# end
+# 
+# The block passed to it_should_behave_like() is eval’d after the shared group is eval’d, allowing you to define default implementations of methods in the shared group. This means we can define groups that programmatically enforce rules for the host groups.
+# 

data/spec/troles/common/config_spec.rb

@@ -0,0 +1,11 @@
+shared_examples_for "Troles Common Config" do
+  describe 'config settings' do
+    describe '#default_orm' do
+      before :each do        
+        user.troles_config.orm.should == nil
+        Troles.Config.default_orm = :mongoid                
+        user.troles_config.orm.should == :mongoid
+      end
+    end
+  end
+end

data/spec/troles/common/multi_roles_spec.rb

@@ -0,0 +1,142 @@
+shared_examples_for "Common Write API for multiple roles" do
+  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 "Common 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/troles/marshaller/bitmask_spec.rb

@@ -0,0 +1,14 @@
+require 'troles_spec'
+User.troles_strategy :bit_many
+User.valid_roles = [:user, :admin, :blogger]
+
+describe Troles::Marshaller::Bitmask do
+  let(:kris)    { Factory.create :user, :troles => 4}
+  let(:bitmask) { Troles::Marshaller::Bitmask.new kris }  
+
+  subject { bitmask }
+  specify { bitmask.read.should == [:blogger] }    
+    specify { bitmask.write(:admin).should == 2 }
+    specify { bitmask.write(:user, :admin).should == 3 }    
+    
+end

data/spec/troles/playbox/shared_examples.rb

@@ -0,0 +1,68 @@
+shared_examples_for "a Many strategy for Kris" do
+  subject { kris }
+    its(:name)          { should == 'kris' }
+
+    # Core API
+    specify             { lambda { kris.role_field }.should raise_error } # is a class method    
+    specify             { User.role_field.should == :troles }
+
+    its(:roles)         { should be_a Troles::Operations }
+
+    specify             { kris.static_roles?.should be_false }
+    specify             { User.static_roles?.should be_false }
+
+    # Event API
+    its(:event_manager) { should == Troles::EventManager }
+    specify             { lambda { kris.role_field_changed?(:roles) }.should raise_error } # since not using rails here!   
+    specify             { kris.publish_change(:roles).should be_true }
+    specify             { kris.update_roles.should be_false } # since not using rails   
+
+    # Read API
+    its(:role_list)     { should include(:user) }
+    
+    it 'should cache the role list' do
+      # use mock expectation : don't expect strategy to be called!
+      kris.role_list.should include(:user)
+      kris.expects(:strategy).never
+      # calling role_list multiple times should NOT invalidate the cache :)
+      expect { kris.role_list }.to_not change{kris.instance_variable_get "@role_list"}      
+      kris.role_list.should include(:user)      
+    end
+
+    it 'should invalidate the role list after roles are changed' do
+      # expect roles changed event
+      kris.expects(:invalidate_role_cache!)
+      kris.set_roles(:admin)
+      # expect cached role_list instance variable (cache) to be changed
+      expect { kris.role_list }.to change{kris.instance_variable_get "@role_list"}
+      kris.role_list.should include(:admin)            
+    end
+    
+    specify             { kris.has_role?(:user).should be_true }
+    specify             { kris.is_role?(:user).should be_true }
+
+    specify             { kris.has_roles?(:user).should be_true }
+    specify             { kris.has_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 }       
+    
+
+
+end
+
+shared_examples_for "a Many strategy 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/troles/strategies/bit_many_spec.rb

@@ -0,0 +1,30 @@
+require 'strategy_helper'
+
+User.troles_strategy :bit_many do |c|
+  c.valid_roles = [:user, :admin, :blogger, :editor]
+end.configure!
+
+module UserSetup
+  def create_no_roles_user
+    Factory.create :user, :name => 'no roles', :troles => 0
+  end
+
+  def create_user
+    Factory.create :user, :name => 'normal', :troles => 1
+  end
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :troles => 2
+  end
+
+  def create_complex_user
+    Factory.create :user, :name => 'user and admin', :troles => 3
+  end
+end
+
+describe 'Troles strategy bit_many' do
+  it_behaves_like "Common API"
+  it_behaves_like "Common API for multiple roles"  
+
+  it_behaves_like "Troles API"  
+end    

data/spec/troles/strategies/embed_many_spec.rb

@@ -0,0 +1,35 @@
+require 'strategy_helper'
+
+User.troles_strategy :embed_many do |c|
+  c.valid_roles = [:user, :admin, :blogger, :editor]
+end.configure!
+
+
+module UserSetup
+  def create_role name
+    Role.create(name)
+  end
+
+  def create_no_roles_user
+    Factory.create :user, :name => 'no roles', :troles => []
+  end
+
+  def create_user
+    Factory.create :user, :name => 'normal', :troles => [ create_role(:user) ]
+  end
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :troles => [ create_role(:admin) ]
+  end
+
+  def create_complex_user
+    Factory.create :user, :name => 'user and admin', :troles => [ create_role(:name => :user), create_role(:name => :admin) ]
+  end
+end
+
+describe 'Troles strategy embed_many' do
+  it_behaves_like "Common API"
+  it_behaves_like "Common API for multiple roles"  
+
+  it_behaves_like "Troles API"  
+end    

data/spec/troles/strategies/ref_many_spec.rb

@@ -0,0 +1,36 @@
+require 'strategy_helper'
+
+User.troles_strategy :ref_many do |c|
+  c.valid_roles = [:user, :admin, :blogger, :editor]
+end.configure!
+
+Config.add_roles [:user, :admin, :editor, :blogger]
+
+module UserSetup
+  def find_role name
+    Role.where :name => name.to_sym
+  end
+  
+  def create_no_roles_user
+    Factory.create :user, :name => 'no roles', :troles => []
+  end
+
+  def create_user
+    Factory.create :user, :name => 'normal', :troles => [ find_role(:user) ]
+  end
+
+  def create_admin_user
+    Factory.create :user, :name => 'admin', :troles => [ find_role(:admin) ]
+  end
+
+  def create_complex_user
+    Factory.create :user, :name => 'user and admin', :troles => [ find_role(:user), find_role(:admin) ]
+  end
+end
+
+describe 'Troles strategy ref_many' do
+  it_behaves_like "Common API"
+  it_behaves_like "Common API for multiple roles"  
+
+  it_behaves_like "Troles API"  
+end