cancancan 1.17.0 → 3.5.0

data/spec/cancan/model_adapters/sequel_adapter_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-if defined? CanCan::ModelAdapters::SequelAdapter
-  describe CanCan::ModelAdapters::SequelAdapter do
-    DB = if RUBY_PLATFORM == 'java'
-           Sequel.connect('jdbc:sqlite:db.sqlite3')
-         else
-           Sequel.sqlite
-         end
-
-    DB.create_table :users do
-      primary_key :id
-      String :name
-    end
-
-    class User < Sequel::Model
-      one_to_many :articles
-    end
-
-    DB.create_table :articles do
-      primary_key :id
-      String :name
-      TrueClass :published
-      TrueClass :secret
-      Integer :priority
-      foreign_key :user_id, :users
-    end
-
-    class Article < Sequel::Model
-      many_to_one :user
-      one_to_many :comments
-    end
-
-    DB.create_table :comments do
-      primary_key :id
-      TrueClass :spam
-      foreign_key :article_id, :articles
-    end
-
-    class Comment < Sequel::Model
-      many_to_one :article
-    end
-
-    before(:each) do
-      Comment.dataset.delete
-      Article.dataset.delete
-      User.dataset.delete
-      (@ability = double).extend(CanCan::Ability)
-    end
-
-    it 'should be for only sequel model classes' do
-      expect(CanCan::ModelAdapters::SequelAdapter).to_not be_for_class(Object)
-      expect(CanCan::ModelAdapters::SequelAdapter).to be_for_class(Article)
-      expect(CanCan::ModelAdapters::AbstractAdapter.adapter_class(Article)).to eq CanCan::ModelAdapters::SequelAdapter
-    end
-
-    it 'should find record' do
-      article = Article.create
-      expect(CanCan::ModelAdapters::SequelAdapter.find(Article, article.id)).to eq article
-    end
-
-    it 'should not fetch any records when no abilities are defined' do
-      Article.create
-      expect(Article.accessible_by(@ability).all).to be_empty
-    end
-
-    it 'should fetch all articles when one can read all' do
-      @ability.can :read, Article
-      article = Article.create
-      expect(Article.accessible_by(@ability).all).to eq [article]
-    end
-
-    it 'should fetch only the articles that are published' do
-      @ability.can :read, Article, published: true
-      article1 = Article.create(published: true)
-      Article.create(published: false)
-      expect(Article.accessible_by(@ability).all).to eq [article1]
-    end
-
-    it 'should fetch any articles which are published or secret' do
-      @ability.can :read, Article, published: true
-      @ability.can :read, Article, secret: true
-      article1 = Article.create(published: true, secret: false)
-      article2 = Article.create(published: true, secret: true)
-      article3 = Article.create(published: false, secret: true)
-      Article.create(published: false, secret: false)
-      expect(Article.accessible_by(@ability).all).to eq([article1, article2, article3])
-    end
-
-    it 'should fetch only the articles that are published and not secret' do
-      @ability.can :read, Article, published: true
-      @ability.cannot :read, Article, secret: true
-      article1 = Article.create(published: true, secret: false)
-      Article.create(published: true, secret: true)
-      Article.create(published: false, secret: true)
-      Article.create(published: false, secret: false)
-      expect(Article.accessible_by(@ability).all).to eq [article1]
-    end
-
-    it 'should only read comments for articles which are published' do
-      @ability.can :read, Comment, article: { published: true }
-      comment1 = Comment.create(article: Article.create(published: true))
-      Comment.create(article: Article.create(published: false))
-      expect(Comment.accessible_by(@ability).all).to eq [comment1]
-    end
-
-    it "should only read comments for articles which are published and user is 'me'" do
-      @ability.can :read, Comment, article: { user: { name: 'me' }, published: true }
-      user1 = User.create(name: 'me')
-      comment1 = Comment.create(article: Article.create(published: true, user: user1))
-      Comment.create(article: Article.create(published: true))
-      Comment.create(article: Article.create(published: false, user: user1))
-      expect(Comment.accessible_by(@ability).all).to eq [comment1]
-    end
-
-    it 'should allow conditions in SQL and merge with hash conditions' do
-      @ability.can :read, Article, published: true
-      @ability.can :read, Article, ['secret=?', true], &:secret
-      @ability.cannot :read, Article, 'priority > 1' do |article|
-        article.priority > 1
-      end
-      article1 = Article.create(published: true, secret: false, priority: 1)
-      article2 = Article.create(published: true, secret: true, priority: 1)
-      Article.create(published: true, secret: true, priority: 2)
-      Article.create(published: false, secret: false, priority: 2)
-      expect(Article.accessible_by(@ability).all).to eq [article1, article2]
-    end
-  end
-end

data/spec/cancan/rule_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'ostruct' # for OpenStruct below
-
-# Most of Rule functionality is tested in Ability specs
-describe CanCan::Rule do
-  before(:each) do
-    @conditions = {}
-    @rule = CanCan::Rule.new(true, :read, Integer, @conditions, nil)
-  end
-
-  it 'returns no association joins if none exist' do
-    expect(@rule.associations_hash).to eq({})
-  end
-
-  it 'returns no association for joins if just attributes' do
-    @conditions[:foo] = :bar
-    expect(@rule.associations_hash).to eq({})
-  end
-
-  it 'returns single association for joins' do
-    @conditions[:foo] = { bar: 1 }
-    expect(@rule.associations_hash).to eq(foo: {})
-  end
-
-  it 'returns multiple associations for joins' do
-    @conditions[:foo] = { bar: 1 }
-    @conditions[:test] = { 1 => 2 }
-    expect(@rule.associations_hash).to eq(foo: {}, test: {})
-  end
-
-  it 'returns nested associations for joins' do
-    @conditions[:foo] = { bar: { 1 => 2 } }
-    expect(@rule.associations_hash).to eq(foo: { bar: {} })
-  end
-
-  it 'returns no association joins if conditions is nil' do
-    rule = CanCan::Rule.new(true, :read, Integer, nil, nil)
-    expect(rule.associations_hash).to eq({})
-  end
-
-  it 'is not mergeable if conditions are not simple hashes' do
-    meta_where = OpenStruct.new(name: 'metawhere', column: 'test')
-    @conditions[meta_where] = :bar
-
-    expect(@rule).to be_unmergeable
-  end
-
-  it 'is not mergeable if conditions is an empty hash' do
-    @conditions = {}
-    expect(@rule).to_not be_unmergeable
-  end
-end

data/spec/matchers.rb

@@ -1,13 +0,0 @@
-RSpec::Matchers.define :orderlessly_match do |original_string|
-  match do |given_string|
-    original_string.split('').sort == given_string.split('').sort
-  end
-
-  failure_message do |given_string|
-    "expected \"#{given_string}\" to have the same characters as \"#{original_string}\""
-  end
-
-  failure_message_when_negated do |given_string|
-    "expected \"#{given_string}\" not to have the same characters as \"#{original_string}\""
-  end
-end

data/spec/spec.opts

@@ -1,2 +0,0 @@
---color
---backtrace

data/spec/spec_helper.rb

@@ -1,27 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-Bundler.require
-
-require 'matchers'
-require 'cancan/matchers'
-
-# I8n setting to fix deprecation.
-if defined?(I18n) && I18n.respond_to?('enforce_available_locales=')
-  I18n.enforce_available_locales = false
-end
-
-# Add support to load paths
-$LOAD_PATH.unshift File.expand_path('../support', __FILE__)
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-RSpec.configure do |config|
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-  config.mock_with :rspec
-  config.order = 'random'
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/support/ability.rb

@@ -1,6 +0,0 @@
-class Ability
-  include CanCan::Ability
-
-  def initialize(user)
-  end
-end