cantango 0.8.0

data/spec/active_record/scenarios/user_accounts/docs/basic_rules_spec_possible_samples.txt

@@ -0,0 +1,84 @@
+exit
+require 'active_record/spec_helper'
+
+describe Permits::Ability do
+  include Config::Basic
+  
+  context "Guest user" do
+    before :each do
+      basic_config :guest
+    end
+
+    it "should be able to :read Comment and Post but NOT Article" do
+      @ability.can?(:read, Comment).should be_true
+      @ability.can?(:read, @comment).should be_true
+      
+      @ability.can?(:read, Post).should be_true      
+      @ability.can?(:read, @post).should be_true      
+      
+      @ability.can?(:read, Article).should be_false
+      @ability.can?(:read, @article).should be_false      
+    end
+
+    it "should be not able to :update only Comment" do
+      @ability.can?(:update, Comment).should be_true
+      @ability.can?(:update, @comment).should be_true      
+      
+      @ability.can?(:update, Post).should be_false
+      @ability.can?(:update, @post).should be_false
+    end
+  end
+  
+  context "Admin user" do
+    before do
+      basic_config :admin
+    end
+
+    it "should be able to :read anything" do
+      @ability.can?(:read, Comment).should be_true
+      @ability.can?(:read, Post).should be_true      
+    end
+  
+    it "should be not able to :update everything" do
+      @ability.can?(:update, Comment).should be_true
+      @ability.can?(:update, Post).should be_true
+    end
+  
+    it "should be not able to :create everything" do
+      @ability.can?(:create, Comment).should be_true
+      @ability.can?(:create, Post).should be_true      
+    end
+  
+    it "should be not able to :update everything" do
+      @ability.can?(:destroy, Comment).should be_true
+      @ability.can?(:destroy, Post).should be_true
+    end
+  end
+ 
+  context "Admin Account having admin role" do
+    before do
+      basic_config :admin_account
+    end
+
+    it "should be able to :read anything" do
+      @ability.can?(:read, Comment).should be_true
+      @ability.can?(:read, Post).should be_true      
+    end
+  
+    it "should be not able to :update everything" do
+      @ability.can?(:update, Comment).should be_true
+      @ability.can?(:update, Post).should be_true
+    end
+  
+    it "should be not able to :create everything" do
+      @ability.can?(:create, Comment).should be_true
+      @ability.can?(:create, Post).should be_true      
+    end
+  
+    it "should be not able to :update everything" do
+      @ability.can?(:destroy, Comment).should be_true
+      @ability.can?(:destroy, Post).should be_true
+    end
+  end
+     
+end

data/spec/active_record/scenarios/user_accounts/guest_account_spec.rb

@@ -0,0 +1,34 @@
+require 'active_record/spec_helper'
+require 'active_record/scenarios/user_accounts/helpers'
+
+require_all File.dirname(__FILE__) + "/../shared"
+
+describe 'Scenario: Guest account' do
+  include UserFactory
+
+  let(:user_profile) { create_user }
+  let(:user_account) { create_user_account user_profile, :guest }
+
+  before(:each) do
+    user_account = create_user_account user_profile, :guest
+    @user_profile = create_user
+  end
+
+  describe 'User profile' do
+    it_should_behave_like "Guest role" do
+      let(:user) { @user_profile }
+      let(:own_article) { Article.create!(:user_id => @user_profile.id) }
+      let(:own_post)    { Post.create(:user_id => @user_profile.id) }
+      let(:own_comment) { Comment.create(:user_id => @user_profile.id) }
+    end
+  end
+
+  context 'GuestAccount himself' do
+    it_should_behave_like "Guest role" do
+      let(:user) { user_account }
+      let(:own_article) { Article.create!(:user_id => @user_profile.id) }
+      let(:own_post)    { Post.create(:user_id => @user_profile.id) }
+      let(:own_comment) { Comment.create(:user_id => @user_profile.id) }
+    end
+  end
+end

data/spec/active_record/scenarios/user_accounts/helpers.rb

@@ -0,0 +1,5 @@
+require 'active_record/scenarios/user_accounts/helpers/user_factory'
+require 'active_record/scenarios/user_accounts/helpers/account_setup'
+
+
+

data/spec/active_record/scenarios/user_accounts/helpers/account_setup.rb

@@ -0,0 +1,41 @@
+module AbstractAccount
+  include_and_extend SimpleRoles
+end
+
+# a user account always belongs to one user, a user can have multiple accounts!
+class Account < ActiveRecord::Base
+  include_and_extend AbstractAccount
+  belongs_to :user
+
+end
+
+class UserAccount < Account
+  # specifics for normal user account
+  tango_user_account # see macros
+end
+
+class AdminAccount < Account
+  # specifics for admin user account
+  tango_user_account
+
+end
+
+# 'belongs' to a Guest user
+class GuestAccount
+  include_and_extend AbstractAccount
+
+  tango_user_account
+
+  attr_reader :user, :role
+
+  def self.create options
+    self.new options
+  end
+
+  def initialize options = {}
+    options.each_pair do |name, value|
+      var = :"@#{name}"
+      self.instance_variable_set(var, value)
+    end
+  end
+end

data/spec/active_record/scenarios/user_accounts/helpers/user_factory.rb

@@ -0,0 +1,19 @@
+module UserFactory 
+  def create_user role = :user
+    # ||= here is important!
+    @user ||= user_class(role).create(:name => "Kristian") 
+  end
+
+  def create_user_account user, role = :user
+    user.active_account = account_class(role).create :role => role, :user => user
+    user.active_account
+  end
+
+  def user_class role
+    "#{role.to_s.camelize}".constantize
+  end
+
+  def account_class role
+    "#{role.to_s.camelize}Account".constantize
+  end
+end

data/spec/active_record/scenarios/user_accounts/permits/admin_account_permit.rb

@@ -0,0 +1,28 @@
+module AdminAccountPermits
+  class AdminRolePermit < CanTango::RolePermit
+    def initialize(ability, options = {})
+      super
+    end
+
+    def static_rules
+      author_of(Article, :scope => :account) do |author|
+        author.can :manage
+      end
+      can :manage, :all
+
+      # # can :manage, :all
+      # scope :account do |account|
+      #   account.author_of(Article) do |author|
+      #     author.can :manage
+      #     author.cannot :delete
+      #   end
+      #
+      #   account.writer_of(Post).can :manage
+      # end
+      #
+      # scope :user do |user|
+      #   user.writer_of(Comment).can :manage
+      # end
+    end
+  end
+end

data/spec/active_record/scenarios/user_accounts/permits/guest_account_permit.rb

@@ -0,0 +1,14 @@
+module GuestAccountPermits
+  class GuestRolePermit < CanTango::RolePermit
+    def initialize(ability, options = {})
+      super
+    end
+
+    def static_rules
+      can :read, Post
+      can :read, Article
+      can :read, Comment
+      cannot :read, User      
+    end
+  end
+end

data/spec/active_record/scenarios/user_accounts/permits/user_account_permit.rb

@@ -0,0 +1,43 @@
+module UserAccountPermits
+  class UserRolePermit < CanTango::RolePermit
+    def initialize(ability, options = {})
+      super
+    end
+
+    def static_rules
+      cannot :manage, User
+
+      can :read, Comment
+      can :read, Post
+      can :read, Article
+
+      author_of(Article, :scope => :account) do |author|
+        author.can :manage
+      end
+
+      author_of(Post, :scope => :account) do |author|
+        author.can :manage
+      end
+      
+      author_of(Comment, :scope => :account) do |author|
+        author.can :manage
+      end
+
+     can :manage, user_account.user
+   
+      # # can :manage, :all    
+      # scope :account do |account|
+      #   account.author_of(Article) do |author|
+      #     author.can :manage
+      #     author.cannot :delete
+      #   end          
+      #     
+      #   account.writer_of(Post).can :manage
+      # end
+      # 
+      # scope :user do |user|      
+      #   user.writer_of(Comment).can :manage
+      # end
+    end  
+  end
+end

data/spec/active_record/scenarios/user_accounts/user_account_spec.rb

@@ -0,0 +1,36 @@
+require 'active_record/spec_helper'
+require 'active_record/scenarios/user_accounts/helpers'
+
+require_all File.dirname(__FILE__) + "/../shared"
+
+describe 'Scenario: User account' do
+  include UserFactory
+  
+  let(:user_profile) { create_user }
+  let(:user_account) { create_user_account user_profile, :user }
+
+  before(:each) do
+    user_account = create_user_account user_profile, :user
+    @user_profile = create_user
+  end 
+
+  context 'User profile' do
+    it_should_behave_like "User role" do
+      let(:user) { @user_profile }
+      let(:own_article) { Article.create!(:user_id => @user_profile.id) }
+      let(:own_post)    { Post.create(:user_id => @user_profile.id) }
+      let(:own_comment) { Comment.create(:user_id => @user_profile.id) }
+    end
+  end
+
+  context 'UserAccount himself' do
+    it_should_behave_like "User role" do
+      let(:user) { user_account }
+      let(:own_article) { Article.create!(:user_id => @user_profile.id) }
+      let(:own_post)    { Post.create(:user_id => @user_profile.id) }
+      let(:own_comment) { Comment.create(:user_id => @user_profile.id) }
+    end
+  end
+end
+
+

data/spec/active_record/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'rails'
+require 'active_record'
+require 'arel'
+require 'meta_where'
+require 'yaml'
+require 'logger'
+require 'database_cleaner'
+require 'require_all'
+require 'active_record/helper/ar_config'
+require 'active_record/helper/rspec_config'
+require 'active_record/helper/permits_config'
+require 'active_record/helper/rails_config'
+
+Cutter::Inspection.loud!
+
+CanTango.configure do |config|
+  config.permits.set :on
+end

data/spec/cantango/README.textile

@@ -0,0 +1,3 @@
+h1. README
+
+This folder is for creating specs to test the internals of CanTango.

data/spec/cantango/ability/cache/compiler_spec.rb

@@ -0,0 +1,45 @@
+require 'rspec'
+require 'cantango'
+require 'sourcify'
+
+describe CanTango::Ability::Cache::Kompiler do
+
+module Cachestub
+  
+  class << self
+  include CanTango::Ability::Cache::Kompiler
+
+  def compile_rules rules
+    compile_rules! rules
+  end
+
+  def decompile_rules rules
+    decompile_rules! rules
+  end
+
+  end
+end
+  
+  before(:each) { 
+    $b = [:a,:b,:c]
+    @condition_block = Proc.new { |arg| $b = [1, 2, 3, arg] } 
+    @rules = [CanCan::Rule.new(true, :read, :all, nil, @condition_block) ]
+  }
+
+  it "should compile! rules" do
+    Cachestub.compile_rules(@rules).first.block.should == "proc { |arg| $b = [1, 2, 3, arg] }"
+  end
+
+  # Direct testing doesn't work here because raw_rules.first.eval.to_source raises exception.
+  # Sourcify::CannotParseEvalCodeError: Sourcify::CannotParseEvalCodeError
+  #
+  # I.e. things like eval( (Proc.new{}).to_source ).to_source do not work. 
+  # But for our needs basic two operations flow like Proc -> String -> (evaled)Proc is pretty enough
+  it "should decompile! rules" do
+    compiled_rules = Cachestub.compile_rules(@rules)
+    raw_rules = Cachestub.decompile_rules compiled_rules
+    raw_rules.first.block.call(4)
+    $b.should == [1,2,3,4]
+  end
+
+end

data/spec/cantango/ability/cache/session_cache_spec.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'cantango'
+
+describe CanTango::Ability::Cache::SessionCache do
+  subject { CanTango::Ability::Cache::SessionCache.new :roles, :session => {} }
+    its(:name)  { should == :roles}
+    its(:store) { should_not be_nil}
+    its(:store) { should be_a CanTango::Cache::MonetaCache }
+
+end
+

data/spec/cantango/ability/cache_spec.rb

@@ -0,0 +1,107 @@
+require 'rspec'
+require 'cantango'
+require 'fixtures/models'
+
+class CacheStub
+  attr_accessor :user
+
+  def initialize user
+    @user = user
+  end
+
+  def rules
+    @rules ||= [:rule_a, :rule_b]
+  end
+
+  protected
+
+  def static_rules
+    rules << :rule_c
+  end
+
+  def dynamic_rules
+    rules << :rule_d
+  end
+  
+  include CanTango::Ability::Cache
+end
+
+
+def setup
+  let (:user) do
+    User.new 'kris'
+  end
+
+  let (:user2) do
+    User.new 'stan'
+  end
+
+  let (:user_account) do
+    ua = UserAccount.new user
+    user.account = ua
+  end
+end
+
+
+describe CanTango::Ability::Cache do
+  setup
+
+  let(:cache2) { CacheStub.new :stan }
+
+  subject { CacheStub.new :kris }
+
+  #its(:rules_cache) { should be_empty}
+  its(:rules) { should_not be_empty }
+
+=begin
+  describe '#cache_key' do
+    it { subject.cache_key.should be_a(String) }
+
+    it 'should return the same key for same user' do
+      subject.cache_key.should == subject.cache_key
+    end
+
+    it 'should return a unique key for each user' do
+      subject.cache_key.should_not == cache2.cache_key
+    end
+  end
+
+  describe '#cached_permit_rules?' do
+    it 'should initially have no cached permit rules' do
+      subject.cached_permit_rules?.should be_nil
+    end
+  end
+
+  describe '#cache_rules!' do
+    it 'should cache permit rules' do
+      subject.cache_rules!.should_not be_nil
+      subject.cached_permit_rules.should_not be_nil
+      subject.cached_permit_rules?.should_not be_nil
+      subject.cached_permit_rules.should include(:rule_a, :rule_b)
+    end
+  end
+
+  describe '#cache_permit_rules!' do
+    it 'should set static_rules and perform their caching' do
+      subject.cache_permit_rules!.should_not be_nil
+      subject.cached_permit_rules.should include(:rule_a, :rule_b, :rule_c)
+    end
+  end
+  
+  describe '#permit_rules!' do
+    it 'should set dynamic rules without any caching' do
+      subject.cached_permit_rules.should be_nil
+      subject.permit_rules!
+      subject.rules.should include(:rule_d)
+      subject.cached_permit_rules.should be_nil
+    end
+  end
+
+  describe '#get_permit_rules' do
+    it 'should get all the rules - cached static rules + dynamic rules' do
+      rules = subject.get_permit_rules
+      rules.should include(:rule_a, :rule_b, :rule_c, :rule_d)
+    end
+  end
+=end
+end