admission 0.4.5 → 0.4.6

data/spec/unit/privilege_spec.rb

@@ -1,178 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Admission::Privilege do
-
-  def new_privilege *args
-    Admission::Privilege.new *args
-  end
-
-  let(:privilege){ new_privilege :man }
-
-  let(:privilege_superman){ new_privilege :superman }
-  let(:privilege_uberman){ new_privilege :uberman }
-
-
-  describe '#new' do
-
-    it 'create base privilege' do
-      expect(new_privilege :man).to have_attributes(name: :man, level: :base)
-    end
-
-    it 'creates with level' do
-      expect(new_privilege :man, :lvl1).to have_attributes(name: :man, level: :lvl1)
-    end
-
-    it 'changes names to symbols' do
-      expect(new_privilege 'man', 'lvl1').to have_attributes(name: :man, level: :lvl1)
-    end
-
-    it 'hash is combination of name and level' do
-      expect(privilege.hash).to eq([:man, :base].hash)
-    end
-
-  end
-
-
-  describe '#inherited' do
-
-    it 'nothing' do
-      expect(privilege.inherited).to be_nil
-    end
-
-    it 'single item' do
-      privilege.inherits_from privilege_superman
-      expect(privilege.inherited).to contain_exactly(privilege_superman)
-    end
-
-    it 'arguments list' do
-      privilege.inherits_from privilege_superman, privilege_uberman
-      expect(privilege.inherited).to contain_exactly(privilege_superman, privilege_uberman)
-    end
-
-  end
-
-
-  describe '#eql?' do
-
-    it 'compares by hash' do
-      p1 = new_privilege :man
-      p2 = new_privilege :man
-      expect(p1).to eql(p2)
-
-      p2.instance_variable_set :@hash, nil.hash
-      expect(p1).not_to eql(p2)
-
-      expect(p1).not_to eql(new_privilege :self)
-    end
-
-  end
-
-
-  describe '#eql_or_inherits?' do
-
-    it 'returns true since it equals sought privilege' do
-      expect(privilege.eql_or_inherits? privilege).to eq(true)
-    end
-
-    it 'return false when does not inherit any' do
-      expect(privilege_superman.eql_or_inherits? privilege_uberman).to eq(false)
-    end
-
-    it 'finds nested inherited privilege and therefore evaluates to true' do
-      top_privilege = new_privilege 'man', 'top'
-      top_privilege.inherits_from new_privilege('man', 'branch'),
-          new_privilege('man', 'middle').tap{|p| p.inherits_from new_privilege('man')}
-
-      sought = new_privilege 'man'
-      expect(top_privilege.eql_or_inherits? sought).to eq(true)
-      expect(top_privilege.eql_or_inherits? new_privilege('man', 'nope')).to eq(false)
-    end
-
-    it 'ignores context' do
-      expect(privilege.eql_or_inherits? privilege.dup_with_context(:czech)).to eq(true)
-    end
-
-  end
-
-
-  describe '#inspect' do
-
-    it 'prints name and level' do
-      expect(privilege).to receive(:text_key).and_call_original
-      expect(privilege.inspect).to eq('#<Privilege key=man>')
-    end
-
-    it 'prints inheritance' do
-      privilege_superman.inherits_from privilege
-      expect(privilege).to receive(:text_key).and_call_original
-      expect(privilege_superman.inspect).to eq(
-          '#<Privilege key=superman inherited=[man]>'
-      )
-    end
-
-  end
-
-  describe '#to_s' do
-
-    it 'prints name and level' do
-      expect(privilege).to receive(:text_key).and_call_original
-      expect(privilege.to_s).to eq('privilege man')
-    end
-
-    it 'prints inheritance' do
-      privilege2 = new_privilege('mans', 'not').dup_with_context 'hot'
-      expect(privilege2).to receive(:text_key).and_call_original
-      expect(privilege2.to_s).to eq('privilege mans-not, context hot')
-    end
-
-  end
-
-
-  describe '#dup_with_context' do
-
-    it 'self when context is nil' do
-      p2 = privilege.dup_with_context
-      expect(p2).to be_a(Admission::Privilege)
-      expect(p2).to equal(privilege)
-
-      p2 = privilege.dup_with_context nil
-      expect(p2).to be_a(Admission::Privilege)
-      expect(p2).to equal(privilege)
-    end
-
-    it 'duplicates only change context' do
-      p2 = privilege.dup_with_context :moon
-      expect(p2).to be_a(Admission::Privilege)
-      expect(p2).not_to equal(privilege)
-      expect(p2).to eql(privilege)
-      expect(p2).to have_attributes(name: :man, level: :base, context: :moon)
-    end
-
-  end
-
-
-  describe '.get_from_order' do
-
-    it 'returns nil for bad name' do
-      index = Admission::Privilege::OrderDefiner.define{ privilege :man }
-      expect(Admission::Privilege.get_from_order index, :woman).to be_nil
-    end
-
-    it 'returns base privilege' do
-      index = Admission::Privilege::OrderDefiner.define{ privilege :man }
-      expect(Admission::Privilege.get_from_order index, :man).to be_eql(privilege)
-    end
-
-    it 'returns specific level privilege' do
-      index = Admission::Privilege::OrderDefiner.define{ privilege :vassal, levels: %i[lord] }
-      expect(Admission::Privilege.get_from_order index, :vassal, :lord).to be_eql(new_privilege :vassal, :lord)
-    end
-
-    it 'returns nil for bad level' do
-      index = Admission::Privilege::OrderDefiner.define{ privilege :vassal, levels: %i[lord] }
-      expect(Admission::Privilege.get_from_order index, :vassal, :pope).to be_nil
-    end
-
-  end
-
-end

data/spec/unit/rails/action_admission_spec.rb

@@ -1,188 +0,0 @@
-require_relative '../../spec_helper'
-
-RSpec.describe Admission::Rails::ActionAdmission do
-
-  let(:instance){ Admission::Rails::ActionAdmission.new 'aaa' }
-
-  def mock_resolver_creation
-    allow(Admission::Rails::ScopeResolver).to receive(:using).
-        and_return(Admission::Rails::ScopeResolver.void)
-  end
-
-  it '.new' do
-    expect(instance.controller).to eq('aaa')
-    expect(instance.resolvers).to eq({})
-  end
-
-  describe '#set_resolver' do
-
-    it 'sets single resolver' do
-      instance.send :set_resolver, 'a1', :resolver
-      expect(instance.resolvers).to eq({
-          'a1' => :resolver
-      })
-    end
-
-    it 'sets array of resolvers' do
-      instance.send :set_resolver, %w[a1 b2], :resolver
-      expect(instance.resolvers).to eq({
-          'a1' => :resolver,
-          'b2' => :resolver
-      })
-    end
-
-    it 'converts actions to string' do
-      instance.send :set_resolver, 1, :resolver
-      instance.send :set_resolver, [:aaa, true], :resolver
-      expect(instance.resolvers).to eq({
-          '1' => :resolver,
-          'aaa' => :resolver,
-          'true' => :resolver
-      })
-    end
-
-  end
-
-  describe '#for' do
-
-    it 'uses keyword argument as the resolver' do
-      resolver = :resolver
-      expect(Admission::Rails::ScopeResolver).to receive(:using).
-          twice.and_return(resolver)
-      instance.for :act1, resolve_to: resolver
-      expect(instance.resolvers).to eq({'act1' => resolver})
-      instance.for(:act1, resolve_to: resolver){}
-      expect(instance.resolvers).to eq({'act1' => resolver})
-    end
-
-    it 'uses block as the resolver' do
-      resolver = :resolver
-      expect(Admission::Rails::ScopeResolver).to receive(:using).
-          and_return(resolver)
-      instance.for(:act1){}
-      expect(instance.resolvers).to eq({'act1' => resolver})
-    end
-
-    it 'accepts list of actions' do
-      instance.for :a1, :b2, resolve_to: ->{}
-      expect(instance.resolvers.keys).to eq(%w[a1 b2])
-    end
-
-  end
-
-  describe '#for_all' do
-
-    it 'passes resolver as argument' do
-      resolver = ->{}
-      expect(instance).to receive(:for).with(
-          Admission::Rails::ActionAdmission::ALL_ACTIONS,
-          hash_including(resolve_to: resolver)
-      )
-      instance.for_all resolver
-    end
-
-    it 'passes resolver as block' do
-      resolver = ->{}
-      expect(instance).to receive(:for).with(
-          Admission::Rails::ActionAdmission::ALL_ACTIONS,
-          hash_including(resolve_to: resolver)
-      )
-      instance.for_all &resolver
-    end
-
-    it 'passes no resolver -> default' do
-      expect(instance).to receive(:for).with(
-          Admission::Rails::ActionAdmission::ALL_ACTIONS,
-          hash_including(resolve_to: Admission::Rails::ScopeResolver.default)
-      )
-      instance.for_all
-    end
-
-  end
-
-  describe '#for_resource' do
-
-    class RailsString < String
-      attr_reader :singularize
-      def initialize singular, plural
-        super plural
-        @singularize = singular
-      end
-    end
-
-    let(:instance) {
-      controller = double('controller')
-      allow(controller).to receive(:controller_name).
-          and_return(RailsString.new('user', 'users'))
-      Admission::Rails::ActionAdmission.new controller
-    }
-
-    it 'uses resource finder as the resolver' do
-      instance.for_resource :aaa
-      resolver = instance.resolvers['aaa']
-      expect(resolver.instance_variable_get '@scope').to eq(:find_user)
-      expect(instance.resolvers.keys.length).to eq(1)
-    end
-
-    it 'uses scope helper as the resolver' do
-      instance.for_resource :aaa, nested: true
-      resolver = instance.resolvers['aaa']
-      expect(resolver.instance_variable_get '@scope').to eq(:users_admission_scope)
-      expect(instance.resolvers.keys.length).to eq(1)
-    end
-
-    it 'sets the finder for all actions' do
-      instance.for_resource all: true
-      resolver = instance.resolvers[Admission::Rails::ActionAdmission::ALL_ACTIONS]
-      expect(resolver.instance_variable_get '@scope').to eq(:find_user)
-      expect(instance.resolvers.keys.length).to eq(1)
-    end
-
-    it 'accepts list of actions' do
-      instance.for_resource :a1, :b2
-      expect(instance.resolvers.keys).to eq(%w[a1 b2])
-    end
-
-  end
-
-  describe '#skip' do
-
-    it 'uses vois resolver' do
-      instance.skip :a1
-      expect(instance.resolvers).to eq('a1' => Admission::Rails::ScopeResolver.void)
-    end
-
-    it 'accepts list of actions' do
-      instance.skip :a1, :b2
-      expect(instance.resolvers.keys).to eq(%w[a1 b2])
-    end
-
-  end
-
-  describe '#scope_for_action' do
-
-    it 'takes particular action resolver' do
-      instance.resolvers['a1'] = :find_user
-      expect(instance.scope_for_action 'a1').to eq(:find_user)
-    end
-
-    it 'takes fallback all-action resolver' do
-      instance.resolvers[Admission::Rails::ActionAdmission::ALL_ACTIONS] = :find_user
-      expect(instance.scope_for_action 'a1').to eq(:find_user)
-    end
-
-    it 'takes scope from parent object' do
-      class RootController
-        def self.action_admission
-          @action_admission ||= Admission::Rails::ActionAdmission.new(self)
-        end
-      end
-      ChildController = Class.new RootController
-
-      RootController.action_admission.resolvers['a1'] = :find_user
-      expect(ChildController.action_admission.scope_for_action 'a1').to eq(:find_user)
-    end
-
-  end
-
-end

data/spec/unit/rails/controller_addon_spec.rb

@@ -1,68 +0,0 @@
-require_relative '../../spec_helper'
-
-RSpec.describe Admission::Rails::ControllerAddon do
-
-  ADDON = Admission::Rails::ControllerAddon
-
-  def stub_action_admission
-    action_admission = double('ActionAdmission')
-    stub_const('Admission::Rails::ActionAdmission', action_admission)
-
-    instance = double('ActionAdmission.new')
-    allow(instance).to receive(:for_all)
-    allow(action_admission).to receive(:new).and_return(instance)
-
-    [action_admission, instance]
-  end
-
-  let(:controller){
-    controller = Class.new do
-      def action_name; 'home'; end
-      def self.before_action *_; end
-    end
-    controller.include ADDON
-  }
-
-  it 'sets default configuration on inclusion' do
-    stub_action_admission
-    controller
-    expect(controller.action_admission).to have_received(:for_all).with(no_args)
-  end
-
-  it 'caches action_admission instance' do
-    klass, _ = stub_action_admission
-    controller.action_admission
-    controller.action_admission
-    child_controller = Class.new controller
-    child_controller.action_admission
-    child_controller.action_admission
-    expect(klass).to have_received(:new).with(controller)
-    expect(klass).to have_received(:new).with(child_controller)
-  end
-
-  it 'adds instance methods' do
-    stub_action_admission
-    expect(controller.private_method_defined? :request_admission!).to be_truthy
-    expect(controller.private_method_defined? :assure_admission).to be_truthy
-  end
-
-  it '#assure_admission raises no scope error' do
-    _, instance = stub_action_admission
-    allow(instance).to receive(:scope_for_action)
-    expect{
-      controller.new.send :assure_admission
-    }.to raise_error(Admission::Rails::ScopeNotDefined)
-  end
-
-  it '#assure_admission request admission with particular scope' do
-    _, instance = stub_action_admission
-    scope_resolver = double('scope_resolver')
-    allow(scope_resolver).to receive(:apply).and_yield(:application)
-    allow(instance).to receive(:scope_for_action).and_return(scope_resolver)
-
-    controller_instance = controller.new
-    expect(controller_instance).to receive(:request_admission!).with(:home, :application)
-    controller_instance.send :assure_admission
-  end
-
-end

data/spec/unit/rails/scope_resolver_spec.rb

@@ -1,72 +0,0 @@
-require_relative '../../spec_helper'
-
-RSpec.describe Admission::Rails::ScopeResolver do
-
-  it '.new freezes the instance' do
-    instance = Admission::Rails::ScopeResolver.new nil
-    expect(instance.instance_variable_get '@scope').to be_nil
-    expect(instance).to be_frozen
-  end
-
-  describe '#apply' do
-
-    it 'Symbol scope' do
-      instance = Admission::Rails::ScopeResolver.new :to_s
-      applied = false
-
-      instance.apply 42 do |value|
-        expect(value).to eq('42')
-        applied = true
-      end
-
-      expect(applied).to be_truthy
-    end
-
-    it 'Proc scope' do
-      instance = Admission::Rails::ScopeResolver.new ->{ to_s }
-      applied = false
-
-      instance.apply 42 do |value|
-        expect(value).to eq('42')
-        applied = true
-      end
-
-      expect(applied).to be_truthy
-    end
-
-    it 'nil scope' do
-      instance = Admission::Rails::ScopeResolver.new nil
-
-      instance.apply 42 do
-        fail 'should not be called'
-      end
-    end
-
-  end
-
-  describe '.using' do
-
-    it 'returns the very same instance' do
-      instance = Admission::Rails::ScopeResolver.using Admission::Rails::ScopeResolver.void
-      expect(instance).to be(Admission::Rails::ScopeResolver.void)
-    end
-
-    it 'creates instance' do
-      instance = Admission::Rails::ScopeResolver.using :to_s
-      expect(instance.instance_variable_get '@scope').to be(:to_s)
-
-      proc = ->{}
-      instance = Admission::Rails::ScopeResolver.using proc
-      expect(instance.instance_variable_get '@scope').to be(proc)
-    end
-
-    it 'prints nice error message' do
-      expect{ Admission::Rails::ScopeResolver.using nil }.to raise_error(
-          'Function to resolve the admission scope needed.'+
-              ' Pass a block or `resolve_to:` parameter.'
-      )
-    end
-
-  end
-
-end