cancancan 1.17.0 → 3.5.0

data/spec/cancan/exceptions_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe CanCan::AccessDenied do
-  describe 'with action and subject' do
-    before(:each) do
-      @exception = CanCan::AccessDenied.new(nil, :some_action, :some_subject)
-    end
-
-    it 'has action and subject accessors' do
-      expect(@exception.action).to eq(:some_action)
-      expect(@exception.subject).to eq(:some_subject)
-    end
-
-    it 'has a changable default message' do
-      expect(@exception.message).to eq('You are not authorized to access this page.')
-      @exception.default_message = 'Unauthorized!'
-      expect(@exception.message).to eq('Unauthorized!')
-    end
-  end
-
-  describe 'with only a message' do
-    before(:each) do
-      @exception = CanCan::AccessDenied.new('Access denied!')
-    end
-
-    it 'has nil action and subject' do
-      expect(@exception.action).to be_nil
-      expect(@exception.subject).to be_nil
-    end
-
-    it 'has passed message' do
-      expect(@exception.message).to eq('Access denied!')
-    end
-  end
-
-  describe 'i18n in the default message' do
-    after(:each) do
-      I18n.backend = nil
-    end
-
-    it 'uses i18n for the default message' do
-      I18n.backend.store_translations :en, unauthorized: { default: 'This is a different message' }
-      @exception = CanCan::AccessDenied.new
-      expect(@exception.message).to eq('This is a different message')
-    end
-
-    it 'defaults to a nice message' do
-      @exception = CanCan::AccessDenied.new
-      expect(@exception.message).to eq('You are not authorized to access this page.')
-    end
-
-    it 'does not use translation if a message is given' do
-      @exception = CanCan::AccessDenied.new("Hey! You're not welcome here")
-      expect(@exception.message).to eq("Hey! You're not welcome here")
-      expect(@exception.message).to_not eq('You are not authorized to access this page.')
-    end
-  end
-end

data/spec/cancan/inherited_resource_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe CanCan::InheritedResource do
-  let(:ability) { Ability.new(nil) }
-  let(:params) { HashWithIndifferentAccess.new(controller: 'models') }
-  let(:controller_class) { Class.new }
-  let(:controller) { controller_class.new }
-
-  before(:each) do
-    class Model
-      attr_accessor :name
-
-      def initialize(attributes = {})
-        attributes.each do |attribute, value|
-          send("#{attribute}=", value)
-        end
-      end
-    end
-
-    allow(controller).to receive(:params) { params }
-    allow(controller).to receive(:current_ability) { ability }
-    allow(controller_class).to receive(:cancan_skipper) { { authorize: {}, load: {} } }
-  end
-
-  it 'show loads resource through controller.resource' do
-    params.merge!(action: 'show', id: 123)
-    allow(controller).to receive(:resource) { :model_resource }
-    CanCan::InheritedResource.new(controller).load_resource
-    expect(controller.instance_variable_get(:@model)).to eq(:model_resource)
-  end
-
-  it 'new loads through controller.build_resource' do
-    params[:action] = 'new'
-    allow(controller).to receive(:build_resource) { :model_resource }
-    CanCan::InheritedResource.new(controller).load_resource
-    expect(controller.instance_variable_get(:@model)).to eq(:model_resource)
-  end
-
-  it 'index loads through controller.association_chain when parent' do
-    params[:action] = 'index'
-    allow(controller).to receive(:association_chain) { controller.instance_variable_set(:@model, :model_resource) }
-    CanCan::InheritedResource.new(controller, parent: true).load_resource
-    expect(controller.instance_variable_get(:@model)).to eq(:model_resource)
-  end
-
-  it 'index loads through controller.end_of_association_chain' do
-    params[:action] = 'index'
-    allow(Model).to receive(:accessible_by).with(ability, :index) { :projects }
-    allow(controller).to receive(:end_of_association_chain) { Model }
-    CanCan::InheritedResource.new(controller).load_resource
-    expect(controller.instance_variable_get(:@models)).to eq(:projects)
-  end
-
-  it 'builds a new resource with attributes from current ability' do
-    params[:action] = 'new'
-    ability.can(:create, Model, name: 'from conditions')
-    allow(controller).to receive(:build_resource) { Struct.new(:name).new }
-    resource = CanCan::InheritedResource.new(controller)
-    resource.load_resource
-    expect(controller.instance_variable_get(:@model).name).to eq('from conditions')
-  end
-
-  it 'overrides initial attributes with params' do
-    params.merge!(action: 'new', model: { name: 'from params' })
-    ability.can(:create, Model, name: 'from conditions')
-    allow(controller).to receive(:build_resource) { Struct.new(:name).new }
-    resource = CanCan::ControllerResource.new(controller)
-    resource.load_resource
-    expect(controller.instance_variable_get(:@model).name).to eq('from params')
-  end
-end

data/spec/cancan/matchers_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe 'be_able_to' do
-  it 'delegates to can?' do
-    expect(object = double).to receive(:can?).with(:read, 123) { true }
-    expect(object).to be_able_to(:read, 123)
-  end
-
-  it 'reports a nice failure message for should' do
-    expect(object = double).to receive(:can?).with(:read, 123) { false }
-    expect do
-      expect(object).to be_able_to(:read, 123)
-    end.to raise_error('expected to be able to :read 123')
-  end
-
-  it 'reports a nice failure message for should not' do
-    expect(object = double).to receive(:can?).with(:read, 123) { true }
-    expect do
-      expect(object).to_not be_able_to(:read, 123)
-    end.to raise_error('expected not to be able to :read 123')
-  end
-
-  it 'delegates additional arguments to can? and reports in failure message' do
-    expect(object = double).to receive(:can?).with(:read, 123, 456) { false }
-    expect do
-      expect(object).to be_able_to(:read, 123, 456)
-    end.to raise_error('expected to be able to :read 123 456')
-  end
-end

data/spec/cancan/model_adapters/active_record_4_adapter_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-
-if defined? CanCan::ModelAdapters::ActiveRecord4Adapter
-  describe CanCan::ModelAdapters::ActiveRecord4Adapter do
-    context 'with sqlite3' do
-      before :each do
-        ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-        ActiveRecord::Migration.verbose = false
-        ActiveRecord::Schema.define do
-          create_table(:parents) do |t|
-            t.timestamps null: false
-          end
-
-          create_table(:children) do |t|
-            t.timestamps null: false
-            t.integer :parent_id
-          end
-        end
-
-        class Parent < ActiveRecord::Base
-          has_many :children, -> { order(id: :desc) }
-        end
-
-        class Child < ActiveRecord::Base
-          belongs_to :parent
-        end
-
-        (@ability = double).extend(CanCan::Ability)
-      end
-
-      it 'respects scope on included associations' do
-        @ability.can :read, [Parent, Child]
-
-        parent = Parent.create!
-        child1 = Child.create!(parent: parent, created_at: 1.hours.ago)
-        child2 = Child.create!(parent: parent, created_at: 2.hours.ago)
-
-        expect(Parent.accessible_by(@ability).order(created_at: :asc).includes(:children).first.children)
-          .to eq [child2, child1]
-      end
-
-      if ActiveRecord::VERSION::MINOR >= 1
-        it 'allows filters on enums' do
-          ActiveRecord::Schema.define do
-            create_table(:shapes) do |t|
-              t.integer :color, default: 0, null: false
-            end
-          end
-
-          class Shape < ActiveRecord::Base
-            enum color: [:red, :green, :blue]
-          end
-
-          red = Shape.create!(color: :red)
-          green = Shape.create!(color: :green)
-          blue = Shape.create!(color: :blue)
-
-          # A condition with a single value.
-          @ability.can :read, Shape, color: Shape.colors[:green]
-
-          expect(@ability.cannot?(:read, red)).to be true
-          expect(@ability.can?(:read, green)).to be true
-          expect(@ability.cannot?(:read, blue)).to be true
-
-          accessible = Shape.accessible_by(@ability)
-          expect(accessible).to contain_exactly(green)
-
-          # A condition with multiple values.
-          @ability.can :update, Shape, color: [Shape.colors[:red],
-                                               Shape.colors[:blue]]
-
-          expect(@ability.can?(:update, red)).to be true
-          expect(@ability.cannot?(:update, green)).to be true
-          expect(@ability.can?(:update, blue)).to be true
-
-          accessible = Shape.accessible_by(@ability, :update)
-          expect(accessible).to contain_exactly(red, blue)
-        end
-
-        it 'allows dual filter on enums' do
-          ActiveRecord::Schema.define do
-            create_table(:discs) do |t|
-              t.integer :color, default: 0, null: false
-              t.integer :shape, default: 3, null: false
-            end
-          end
-
-          class Disc < ActiveRecord::Base
-            enum color: [:red, :green, :blue]
-            enum shape: { triangle: 3, rectangle: 4 }
-          end
-
-          red_triangle = Disc.create!(color: Disc.colors[:red], shape: Disc.shapes[:triangle])
-          green_triangle = Disc.create!(color: Disc.colors[:green], shape: Disc.shapes[:triangle])
-          green_rectangle = Disc.create!(color: Disc.colors[:green], shape: Disc.shapes[:rectangle])
-          blue_rectangle = Disc.create!(color: Disc.colors[:blue], shape: Disc.shapes[:rectangle])
-
-          # A condition with a dual filter.
-          @ability.can :read, Disc, color: Disc.colors[:green], shape: Disc.shapes[:rectangle]
-
-          expect(@ability.cannot?(:read, red_triangle)).to be true
-          expect(@ability.cannot?(:read, green_triangle)).to be true
-          expect(@ability.can?(:read, green_rectangle)).to be true
-          expect(@ability.cannot?(:read, blue_rectangle)).to be true
-
-          accessible = Disc.accessible_by(@ability)
-          expect(accessible).to contain_exactly(green_rectangle)
-        end
-      end
-    end
-
-    if Gem::Specification.find_all_by_name('pg').any?
-      context 'with postgresql' do
-        before :each do
-          ActiveRecord::Base.establish_connection(adapter: 'postgresql',
-                                                  database: 'postgres',
-                                                  schema_search_path: 'public')
-          ActiveRecord::Base.connection.drop_database('cancan_postgresql_spec')
-          ActiveRecord::Base.connection.create_database('cancan_postgresql_spec',
-                                                        'encoding' => 'utf-8',
-                                                        'adapter' => 'postgresql')
-          ActiveRecord::Base.establish_connection(adapter: 'postgresql',
-                                                  database: 'cancan_postgresql_spec')
-          ActiveRecord::Migration.verbose = false
-          ActiveRecord::Schema.define do
-            create_table(:parents) do |t|
-              t.timestamps null: false
-            end
-
-            create_table(:children) do |t|
-              t.timestamps null: false
-              t.integer :parent_id
-            end
-          end
-
-          class Parent < ActiveRecord::Base
-            has_many :children, -> { order(id: :desc) }
-          end
-
-          class Child < ActiveRecord::Base
-            belongs_to :parent
-          end
-
-          (@ability = double).extend(CanCan::Ability)
-        end
-
-        it 'allows overlapping conditions in SQL and merge with hash conditions' do
-          @ability.can :read, Parent, children: { parent_id: 1 }
-          @ability.can :read, Parent, children: { parent_id: 1 }
-
-          parent = Parent.create!
-          Child.create!(parent: parent, created_at: 1.hours.ago)
-          Child.create!(parent: parent, created_at: 2.hours.ago)
-
-          expect(Parent.accessible_by(@ability)).to eq([parent])
-        end
-      end
-    end
-  end
-end