the_role 2.5.4 → 3.0.0

data/spec/dummy_app/spec/models/hash_spec.rb

@@ -1,272 +0,0 @@
-require 'spec_helper'
-
-describe Hash do
-  context "METHODS" do
-    it "underscorify_keys" do
-      Hash.new.respond_to?(:underscorify_keys).should eq true 
-    end
-
-    it "underscorify_keys!" do
-      Hash.new.respond_to?(:underscorify_keys!).should eq true 
-    end
-
-    it "deep_reset" do
-      Hash.new.respond_to?(:deep_reset).should eq true 
-    end
-    
-    it "deep_reset!" do
-      Hash.new.respond_to?(:deep_reset!).should eq true 
-    end
-
-    it "deep_merge" do
-      Hash.new.respond_to?(:deep_merge).should eq true
-    end
-    
-    it "deep_merge!" do
-      Hash.new.respond_to?(:deep_merge!).should eq true
-    end
-  end
-
-  context "deep HASH.underscorify_keys" do
-    it "UNDERSCORIFY hash keys" do
-      hash = {
-        'a b' => 1,
-        "x y" => {
-          :hello => 1,
-          :'hello-world' => 1,
-          'good MorninG mom!' => 1
-        }
-      }
-      result = {
-        'a_b' => 1,
-        'x_y' => {
-          'hello' => 1,
-          'hello_world' => 1,
-          'good_morning_mom' => 1
-        }
-      }
-      hash.underscorify_keys.should eq result
-      hash.should_not               eq result
-    end
-
-    it "UNDERSCORIFY! hash keys" do
-      hash = {
-        'a b' => 1,
-        "x y" => {
-          'hello' => 1
-        }
-      }
-      result = {
-        'a_b' => 1,
-        'x_y' => {
-          'hello' => 1
-        }
-      }
-      hash.underscorify_keys!.should eq result
-      hash.should                    eq result
-    end    
-  end
-
-  context "HASH.deep_reset" do
-    before(:each) do
-      @hash = {
-        :pages => {
-          :index   => true,
-          :show    => true,
-          :new     => false,
-          :edit    => false,
-          :update  => false,
-          :destroy => false
-        },
-        :articles => {
-          :index   => true,
-          :show    => true
-        }
-      }
-    end
-
-    it "DEEP RESET hash values to nil" do
-      result = {
-        :pages => {
-          :index   => nil,
-          :show    => nil,
-          :new     => nil,
-          :edit    => nil,
-          :update  => nil,
-          :destroy => nil
-        },
-        :articles => {
-          :index   => nil,
-          :show    => nil
-        }
-      }
-      hash = @hash.deep_reset
-      hash.should eq result
-    end
-
-    it "DEEP RESET hash values to nil :test" do
-      result = {
-        :pages => {
-          :index   => :test,
-          :show    => :test,
-          :new     => :test,
-          :edit    => :test,
-          :update  => :test,
-          :destroy => :test
-        },
-        :articles => {
-          :index   => :test,
-          :show    => :test
-        }
-      }
-      hash = @hash.deep_reset(:test)
-      hash.should eq result
-    end
-
-    it "DEEP RESET! hash values to nil" do
-      result = {
-        :pages => {
-          :index   => :test,
-          :show    => :test,
-          :new     => :test,
-          :edit    => :test,
-          :update  => :test,
-          :destroy => :test
-        },
-        :articles => {
-          :index   => :test,
-          :show    => :test
-        }
-      }
-      hash = @hash.deep_reset(:test)
-      hash.should      eq  result
-      @hash.should_not eq result
-    end
-  end
-
-  context "DEEP RESET! with different keys types" do
-    it "work fine" do
-      hash = {
-        'pages' => {
-          :index => true,
-          'edit' => true
-        }
-      }
-      result = {
-        'pages' => {
-          :index => nil,
-          'edit' => nil
-        }
-      }
-      hash.deep_reset!(nil).should eq result
-    end
-  end
-
-  context "DEEP MERGE" do
-    it " => hashes" do
-      first_hash = {
-        'pages' => {
-          'index' => false,
-          'edit'  => false
-        }
-      }
-
-      second_hash = {
-        'pages' => {
-          'index'   => true,
-          'edit'    => false,
-          'destroy' => true
-        }
-      }
-
-      result = {
-        'pages' => {
-          'index'   => true,
-          'edit'    => false,
-          'destroy' => true
-        }
-      }
-
-      first_hash.deep_merge!(second_hash).should eq result
-    end
-
-    it "should merge 2 hash (1st 3-lavels, 2nd - 2 levels => 2 level)" do
-      first_hash = {
-        'pages' => {
-          'index' => false,
-          'edit'  => {
-            'one' => 1,
-            'two' => 2
-          }
-        }
-      }
-
-      second_hash = {
-        'pages' => {
-          'index'   => true,
-          'edit'    => false,
-          'destroy' => true
-        }
-      }
-
-      result = {
-        'pages' => {
-          'index'   => true,
-          'edit'    => false,
-          'destroy' => true
-        }
-      }
-
-      first_hash.deep_merge!(second_hash).should eq result
-    end
-  end
-
-  context "DEEP MERGE!" do
-    before(:each) do
-      @incoming_hash = {
-        'pages' => {
-          'edit'    => true,
-          'manage'  => true,
-          'destroy' => true
-        }
-      }
-      @base_hash = {
-        'pages' => {
-          'index'   => true,
-          'edit'    => false,
-          'destroy' => false,
-          'banners' => false
-        }
-      }
-    end
-
-    it 'should reset base hash to false' do
-      result = {
-        'pages' => {
-          'index'   => nil,
-          'edit'    => nil,
-          'destroy' => nil,
-          'banners' => nil
-        }
-      }
-      @base_hash.deep_reset!
-      @base_hash.should == result
-    end
-
-    it 'should merge 2 hashes' do
-      result = {
-        'pages' => {
-          'index'   => false,
-          'edit'    => true,
-          'manage'  => true,
-          'destroy' => true,
-          'banners' => false
-        }
-      }
-
-      @base_hash.deep_reset!(false)
-      @base_hash.deep_merge! @incoming_hash
-      @base_hash.should == result
-    end
-  end
-end

data/spec/dummy_app/spec/models/param_process_spec.rb

@@ -1,39 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe "String to slug" do
-  it 'string process 1' do
-    'hello world!'.to_slug_param(sep: '_').should eq 'hello_world'
-  end
-
-  it 'string process 2' do
-    :hello_world!.to_slug_param(sep: '_').should eq 'hello_world'
-  end
-
-  it 'string process 3' do
-    "hello !      world".to_slug_param(sep: '_').should eq 'hello_world'
-  end
-
-  it 'string process 4' do
-    "HELLO  $!= WorlD".to_slug_param(sep: '_').should eq 'hello_world'
-  end
-
-  it 'string process 5' do
-    "HELLO---WorlD".to_slug_param(sep: '_').should eq 'hello_world'
-  end
-
-  it "should work with Controller Name" do
-    ctrl = PagesController.new
-    ctrl.controller_path
-    ctrl.controller_path.to_slug_param(sep: '_').should eq 'pages'
-  end
-
-  it "should work with Nested Controller Name" do
-    class Admin::PagesController < ApplicationController; end
-    ctrl = Admin::PagesController.new
-    ctrl.controller_path
-
-    ctrl.controller_path.to_slug_param(sep: '_').should eq 'admin_pages'
-  end
-end

data/spec/dummy_app/spec/models/role_spec.rb

@@ -1,218 +0,0 @@
-require 'spec_helper'
-
-describe Role do
-  context "Role *Create* methods" do
-    it "New/Create invalid" do
-      role = Role.new
-      role.save.should be_false
-      
-      role.should have(1).error_on(:name)
-      role.should have(1).error_on(:title)
-      role.should have(1).error_on(:description)
-    end
-
-    it "New/Create valid, without Role hash" do
-      role = Role.new
-
-      role.name        = :user
-      role.title       = :user_title
-      role.description = :role_description
-      
-      role.save.should be_true
-    end
-
-    it "New/Create valid, without Role hash (2)" do
-      Role.new(
-        name: :user,
-        title: :user_title,
-        description: :role_description
-      ).save.should be_true
-    end
-
-    it "New/Create, without Role hash, default Role hash value" do
-      role = FactoryGirl.create :role_without_rules
-      role.the_role.should == "{}"
-      role.to_hash.should  == {}
-    end
-
-    it "New/Create, role methods result types" do
-      role = FactoryGirl.create :role_without_rules
-      role.the_role.should be_an_instance_of String
-      role.to_hash.should  be_an_instance_of Hash
-    end
-  end
-
-  context "Role *Section/Rule create* methods" do
-    before(:each) do
-      @role = FactoryGirl.create :role_without_rules
-    end
-
-    it "should have empty Role hash" do
-      @role.to_hash.should == {}
-    end
-
-    it "Create section" do
-      @role.create_section(:articles)
-      @role.to_hash.should == { "articles" => {} }
-    end
-
-    it "Create rule (with section)" do
-      @role.create_section(:articles)
-      @role.create_rule(:articles, :index)
-      @role.to_hash.should == { "articles" => { "index" => false } }
-    end
-
-    it "Create rule (without section)" do
-      @role.create_rule(:articles, :index)
-      @role.to_hash.should == { "articles" => { "index" => false } }
-    end
-  end
-
-  context "*has?* is aliace of *has_role?*" do
-    before(:each) do
-      @role = FactoryGirl.create :role_user
-    end
-    
-    it "aliace methods" do
-      @role.has?(:pages, :index).should      be_true
-      @role.has_role?(:pages, :index).should be_true
-
-      @role.has?(:pages, :secret).should      be_false
-      @role.has_role?(:pages, :secret).should be_false
-    end
-  end
-
-  context "Rule *On/Off* methods" do
-    before(:each) do
-      @role = FactoryGirl.create :role_user
-    end
-
-    it "has access to pages/index" do
-      @role.has_role?(:pages, :index).should be_true
-    end
-
-    it "set pages/index on false" do
-      @role.rule_off(:pages, :index)
-      @role.has_role?(:pages, :index).should be_false
-    end
-
-    it "has no access to pages/secret" do
-      @role.has_role?(:pages, :secret).should be_false
-    end
-
-    it "set pages/secret on true" do
-      @role.rule_on(:pages, :secret)
-      @role.has_role?(:pages, :secret).should be_true
-    end
-  end
-
-  context "Class Methods" do
-    before(:each) do
-      @role = FactoryGirl.create :role_user
-    end
-
-    it "Role.with_name(:name) method" do
-      Role.with_name(:user).should  be_an_instance_of Role
-      Role.with_name('user').should be_an_instance_of Role
-      
-      Role.with_name(:moderator).should  be_nil
-      Role.with_name('moderator').should be_nil
-    end
-  end
-
-  context "*Delete* methods" do
-    before(:each) do
-      @role = FactoryGirl.create :role_user
-    end
-
-    it "*has_section?* method" do
-      @role.has_section?(:pages).should    be_true
-      @role.has_section?(:articles).should be_false
-    end
-
-    it "has pages section" do
-      @role.to_hash['pages'].should be_an_instance_of Hash
-    end
-
-    it "has pages/index value" do
-      @role.to_hash['pages']['index'].should be_true
-    end
-
-    it "delete rule pages/index" do
-      @role.delete_rule(:pages, :index)
-      @role.to_hash['pages']['index'].should be_nil
-    end
-
-    it "delete section pages" do
-      @role.delete_section(:pages)
-      @role.to_hash['pages'].should be_nil
-    end
-  end
-
-  context "*helper* methods" do
-    before(:each) do
-      @role = FactoryGirl.create :role_without_rules
-    end
-
-    it "to_hash on empty rules set" do
-      @role.to_hash.should == {}
-    end
-
-    it "to_json on empty rules set" do
-      @role.to_json.should == "{}"
-    end
-  end
-
-  context "Update method" do
-    before(:each) do
-      @role = FactoryGirl.create :role_user
-    end
-
-    it "should has true rules" do
-      @role.has?(:pages, :index).should  be_true
-      @role.has?(:pages, :edit).should   be_true
-      @role.has?(:pages, :update).should be_true
-      @role.has?(:pages, :secret).should be_false
-
-      @role.has?(:articles, :index).should be_false
-    end
-
-    it "should has true rules" do
-      @role.update_role({ articles: { index: true } })
-
-      @role.has?(:pages, :index).should  be_false
-      @role.has?(:pages, :edit).should   be_false
-      @role.has?(:pages, :update).should be_false
-      @role.has?(:pages, :secret).should be_false
-
-      @role.has?(:articles, :index).should be_true
-    end
-
-    it "should has any rules 1" do
-      @role.has?(:pages, :index).should  be_true
-      @role.has?(:pages, :update).should be_true
-
-      @role.any?({ pages: :index  }).should be_true
-      @role.any?({ pages: :update }).should be_true
-      @role.any?({ pages: :index, pages: :update}).should be_true
-    end
-
-    it "should has any rules 2" do
-      @role.has?(:pages,    :index).should be_true
-      @role.has?(:articles, :index).should be_false
-
-      @role.any?({ pages:    :index }).should be_true
-      @role.any?({ articles: :index }).should be_false
-
-      @role.any?({ articles: :index }).should be_false
-      @role.any?({ pages: :index, articles: :index}).should be_true
-      @role.any?({ pages: :index, pages:    :update}).should be_true
-    end
-
-    it "should has any rules 3, easy syntaxis" do
-      @role.any?(articles: :index).should be_false
-      @role.any?(pages: :index, articles: :index).should be_true
-      @role.any?(pages: :index, pages:    :update).should be_true
-    end
-  end
-end

data/spec/dummy_app/spec/models/user_spec.rb

@@ -1,164 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe User do
-  describe "Owner check for User and object" do
-    context "Regular user" do
-      before(:each) do
-        @user_1 = FactoryGirl.create(:user)
-        @user_2 = FactoryGirl.create(:user)
-
-        @user_1_page = FactoryGirl.create(:page, user: @user_1)
-        @user_2_page = FactoryGirl.create(:page, user: @user_2)
-      end
-
-      it 'should have test varaibles' do
-        @user_1.should be_instance_of User
-        @user_2.should be_instance_of User
-
-        @user_1_page.should be_instance_of Page
-        @user_2_page.should be_instance_of Page
-      end
-
-      it 'should be owner of page' do
-        @user_1.owner?(@user_1_page).should be_true
-        @user_2.owner?(@user_2_page).should be_true
-      end
-
-      it 'should not be owner of page' do
-        @user_1.owner?(@user_2_page).should be_false
-        @user_2.owner?(@user_1_page).should be_false
-      end
-    end
-
-    context "Moderator" do
-      before(:each) do
-        mrole = FactoryGirl.create(:role_moderator)
-
-        @moderator = FactoryGirl.create(:user, role: mrole)
-        @user      = FactoryGirl.create(:user)
-
-        @moderator_page = FactoryGirl.create(:page, user: @moderator)
-        @user_page      = FactoryGirl.create(:page, user: @user)
-      end
-
-      it 'Moderator is owner of any Page' do
-        @moderator.owner?(@moderator_page).should be_true
-        @moderator.owner?(@user_page).should      be_true
-      end
-
-      it 'User is owner of his Pages' do
-        @user.owner?(@user_page).should      be_true
-        @user.owner?(@moderator_page).should be_false
-      end
-    end
-
-    context "Admin" do
-      # not important. to implement later
-    end
-
-    # context "Custom Page relation to User" do
-    #   before(:each) do
-    #     Page.class_eval do
-    #       belongs_to :user, class_name: User, foreign_key: 'person_id'
-    #     end
-
-    #     @user = FactoryGirl.create(:user)
-    #     @page = FactoryGirl.create(:page, user: @user)
-    #   end
-
-    #   it 'relation via person_id' do
-    #     @page.user_id.should   eq @user.id
-    #     @page.person_id.should eq @user.id
-    #   end
-    # end
-  end
-
-  describe "Create user without any Role" do
-    before(:each) do
-      FactoryGirl.create(:user)
-      @user = User.first
-    end
-
-    it "Create test user" do
-      User.count.should be 1
-    end
-
-    it "User have not any role" do
-      @user.role.should be_nil
-    end
-
-    it "User should gives false on any request" do
-      @user.has_role?(:pages, :index).should     be_false
-      @user.has_role?(:moderator, :pages).should be_false
-    end
-  end
-
-  describe "Create user with default Role" do
-    before(:each) do
-      TheRole.config.default_user_role = :user
-      FactoryGirl.create(:role_user)
-      FactoryGirl.create(:user)
-      @user = User.first
-    end
-    
-    it "User and Role should exists" do
-      Role.count.should be 1
-      User.count.should be 1
-    end
-
-    it "Role should nave name :user" do
-      Role.first.name.should eq 'user'
-    end
-
-    it "User should have default Role" do
-      @user.role.should_not be_nil
-    end
-
-    it "User has Role for Pages" do
-      @user.has_role?(:pages, :index).should   be_true
-      @user.has_role?(:pages, :destroy).should be_true
-    end
-
-    it "User has disabled rule" do
-      @user.has_role?(:pages, :secret).should be_false
-    end
-
-    it "User try to have access to undefined rule" do
-      @user.has_role?(:pages, :wrong_name).should be_false
-    end
-
-    it "User has not Role for Atricles" do
-      @user.has_role?(:articles, :index).should be_false
-    end
-
-    # Any
-    it "should has any rules 1" do
-      @user.has_role?(:pages, :index).should  be_true
-      @user.has_role?(:pages, :update).should be_true
-
-      @user.any_role?({ pages: :index  }).should be_true
-      @user.any_role?({ pages: :update }).should be_true
-      @user.any_role?({ pages: :index, pages: :update}).should be_true
-    end
-
-    it "should has any rules 2" do
-      @user.has_role?(:pages,    :index).should be_true
-      @user.has_role?(:articles, :index).should be_false
-
-      @user.any_role?({ pages:    :index }).should be_true
-      @user.any_role?({ articles: :index }).should be_false
-
-      @user.any_role?({ articles: :index }).should be_false
-      @user.any_role?({ pages: :index, articles: :index}).should be_true
-      @user.any_role?({ pages: :index, pages:    :update}).should be_true
-    end
-
-    it "should has any rules 3, easy syntaxis" do
-      @user.any_role?(articles: :index).should be_false
-      @user.any_role?(pages: :index, articles: :index).should be_true
-      @user.any_role?(pages: :index, pages:    :update).should be_true
-    end
-  end
-end