shamu 0.0.1 → 0.0.2

data/spec/lib/shamu/security/policy_spec.rb

@@ -0,0 +1,158 @@
+require "spec_helper"
+
+describe Shamu::Security::Policy do
+  let( :principal ) { Shamu::Security::Principal.new }
+  let( :roles )     { [] }
+  let( :policy )    { klass.new principal: principal, roles: roles }
+  let( :klass ) do
+    Class.new( Shamu::Security::Policy ) do
+      role :super_user, inherits: :admin
+      role :admin, inherits: :user
+      role :user
+
+      public :in_role?, :add_rule, :rules, :permit, :deny, :when_elevated,
+             :alias_action, :expand_aliases
+    end
+  end
+
+  describe "#authorize" do
+    it "raises when not permitted" do
+      allow( policy ).to receive( :permit? ).and_return false
+
+      expect do
+        policy.authorize! :read, :stuff
+      end.to raise_error Shamu::Security::AccessDeniedError
+    end
+
+    it "raises when maybe permitted" do
+      allow( policy ).to receive( :permit? ).and_return :maybe
+
+      expect do
+        policy.authorize! :read, :stuff
+      end.to raise_error Shamu::Security::AccessDeniedError
+    end
+
+    it "returns the authorized resource" do
+      allow( policy ).to receive( :permit? ).and_return :yes
+      resource = double
+      expect( policy.authorize!( :read, resource ) ).to be resource
+    end
+  end
+
+  describe "#in_role?" do
+    it "is true for :user when principal is signed in" do
+      allow( policy.principal ).to receive( :user_id ).and_return 1
+
+      expect( policy.in_role?( :user ) ).to be_truthy
+    end
+
+    it "is false for :user when principal is anonymous" do
+      allow( policy.principal ).to receive( :user_id ).and_return nil
+
+      expect( policy.in_role?( :user ) ).to be_falsy
+    end
+
+    it "is true for an explicitly assigned role" do
+      roles << :admin
+      expect( policy.in_role?( :admin ) ).to be_truthy
+    end
+
+    it "is true for an implicitly assigned role" do
+      roles << :super_user
+      expect( policy.in_role?( :admin ) ).to be_truthy
+    end
+
+    it "is false for empty roles list" do
+      expect( policy.in_role? ).to be_falsy
+    end
+  end
+
+  describe "#permit?" do
+    let( :rule )         { double Shamu::Security::PolicyRule }
+    let( :second_rule )  { double Shamu::Security::PolicyRule }
+    before( :each ) do
+      allow( policy ).to receive( :rules ).and_return [ rule, second_rule ]
+
+      [ rule, second_rule ].each do |r|
+        allow( r ).to receive( :match? ).and_return false
+      end
+    end
+
+    it "permits with matching rule" do
+      allow( rule ).to receive( :match? ).and_return true
+      allow( rule ).to receive( :result ).and_return :yes
+
+      expect( policy.permit?( :do, :stuff ) ).to be_truthy
+    end
+
+    it "denies if no matching rule" do
+      expect( policy.permit?( :do, :stuff ) ).to be_falsy
+    end
+
+    it "denies if expliclitly denied after permit" do
+      expect( rule ).to receive( :match? ).and_return true
+      expect( rule ).to receive( :result ).and_return false
+
+      allow( second_rule ).to receive( :match? ).and_return true
+      allow( second_rule ).to receive( :result ).and_return :yes
+
+      expect( policy.permit?( :do, :stuff ) ).to be_falsy
+    end
+
+    it "fails when testing an ActiveRecord resource" do
+      expect do
+        policy.permit? :check, Class.new( ActiveRecord::Base )
+      end.to raise_error Shamu::Security::NoActiveRecordPolicyChecksError
+    end
+  end
+
+  describe "#permit" do
+    it "adds a :maybe rule when defined within #when_elevated" do
+      allow( policy ).to receive( :permissions ) do
+        policy.when_elevated do
+          policy.permit :do, :stuff
+        end
+      end
+
+      expect( policy.rules.first.result ).to eq :maybe
+    end
+  end
+
+  describe "#add_rule" do
+    before( :each ) do
+      allow( policy ).to receive( :permissions )
+    end
+
+    it "expands action aliases" do
+      expect( policy ).to receive( :expand_aliases ).and_call_original
+      policy.add_rule [ :do ], :stuff, :yes
+    end
+
+    it "pushes rule to front" do
+
+      policy.add_rule [ :do ], :stuff, :one
+      policy.add_rule [ :do ], :stuff, :two
+
+      expect( policy.rules.first.result ).to eq :two
+    end
+  end
+
+  describe "#expand_aliases" do
+    before( :each ) do
+      policy.alias_action :show, :list, to: :read
+      policy.alias_action :index, to: :list
+    end
+
+    it "includes explicit actions" do
+      expect( policy.expand_aliases( [ :read ] ) ).to include :read
+    end
+
+    it "includes aliases" do
+      expect( policy.expand_aliases( [ :read ] ) ).to include :show
+    end
+
+    it "includes aliases of aliases" do
+      expect( policy.expand_aliases( [ :read ] ) ).to include :index
+    end
+  end
+end

data/spec/lib/shamu/security/roles_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Shamu::Security::Roles do
+
+  describe "#role" do
+    it "adds a role" do
+      klass = Class.new do
+        include Shamu::Security::Roles
+
+        role :admin
+      end
+
+      expect( klass.roles ).to have_key :admin
+      expect( klass.roles[:admin] ).to be_a Hash
+    end
+  end
+
+  describe "#expand_roles" do
+    let( :klass ) do
+      Class.new do
+        include Shamu::Security::Roles
+
+        role :admin, inherits: :manager
+        role :manager, inherits: :user
+        role :user
+      end
+    end
+
+    it "includes base roles" do
+      expect( klass.expand_roles( :user ) ).to include :user
+    end
+
+    it "excludes unknown roles" do
+      expect( klass.expand_roles( :magician ) ).to be_empty
+    end
+
+    it "includes inherited roles" do
+      expect( klass.expand_roles( :manager ) ).to include :user
+    end
+
+    it "includes inherited inherited roles" do
+      expect( klass.expand_roles( :admin ) ).to include :manager
+      expect( klass.expand_roles( :admin ) ).to include :user
+    end
+  end
+end

data/spec/lib/shamu/services/active_record_crud_spec.rb

@@ -0,0 +1,460 @@
+require "spec_helper"
+require "shamu/active_record"
+require_relative "../active_record_support"
+
+module ActiveRecordCrudSpec
+  class FavoriteEntity < Shamu::Entities::Entity
+    model :record
+    attribute :id, on: :record
+    attribute :name, on: :record
+    attribute :label, on: :record
+  end
+
+  module Request
+    class Change < Shamu::Services::Request
+      attribute :name
+      attribute :label
+    end
+
+    class Create < Change
+    end
+
+    class Update < Change
+      attribute :id
+    end
+
+  end
+
+  class Service < Shamu::Services::Service
+    include Shamu::Services::ActiveRecordCrud
+
+    resource FavoriteEntity, ActiveRecordSpec::Favorite
+    create
+    change
+    finders
+    destroy
+  end
+
+  class FavoriteListScope < Shamu::Entities::ListScope
+  end
+
+end
+
+describe Shamu::Services::ActiveRecordCrud do
+  use_active_record
+  before( :all )  { Shamu::ToModelIdExtension.extend! }
+
+  let( :klass )   { ActiveRecordCrudSpec::Service }
+  let( :service ) { scorpion.new klass }
+
+  before( :each ) do
+    # Allow generic args to create the entity
+    allow( service ).to receive( :authorize! ).and_call_original
+  end
+
+  it "includes ActiveRecordService" do
+    expect( ActiveRecordCrudSpec::Service ).to include Shamu::Services::ActiveRecord
+  end
+
+  describe ".resource" do
+    it "defines an entity_class" do
+      expect( klass.entity_class ).to eq ActiveRecordCrudSpec::FavoriteEntity
+    end
+
+    it "defines a model_class" do
+      expect( klass.model_class ).to eq ActiveRecordSpec::Favorite
+    end
+
+    it "defines a build_entity method" do
+      expect( klass.new.respond_to?( :build_entity, true ) ).to be_truthy
+    end
+
+    Shamu::Services::ActiveRecordCrud::DSL_METHODS.each do |method|
+      it "defines standard DSL method `#{ method }` when passed via `:methods`" do
+        expect( klass ).to receive( method )
+        klass.resource( ActiveRecordCrudSpec::FavoriteEntity, ActiveRecordSpec::Favorite, methods: method )
+      end
+    end
+
+    it "takes a block defining #build_entity" do
+      expect do |b|
+        yield_klass = Class.new( klass ) do
+          resource( ActiveRecordCrudSpec::FavoriteEntity, ActiveRecordSpec::Favorite, &b )
+        end
+
+        scorpion.new( yield_klass ).create
+      end.to yield_control
+    end
+
+    context "when not used" do
+      let( :klass ) do
+        Class.new( Shamu::Services::Service ) do
+          include Shamu::Services::ActiveRecordCrud
+        end
+      end
+
+      it "raises helpful error on entity_class" do
+        expect do
+          klass.entity_class
+        end.to raise_error Shamu::Services::IncompleteSetupError
+      end
+
+      it "raises helpful error on model_class" do
+        expect do
+          klass.model_class
+        end.to raise_error Shamu::Services::IncompleteSetupError
+      end
+    end
+  end
+
+  describe ".create" do
+    let( :request ) { ActiveRecordCrudSpec::Request::Create.new( name: "Example", label: "Books" ) }
+
+    it "calls Model.new" do
+      expect( ActiveRecordSpec::Favorite ).to receive( :new ).and_call_original
+
+      service.create request
+    end
+
+    it "calls request.apply_to" do
+      expect( request ).to receive( :apply_to ).and_call_original
+      service.create request
+    end
+
+    it "calls apply_changes if present" do
+      expect( service ).to receive( :apply_changes )
+        .with(
+          request,
+          kind_of( ActiveRecord::Base )
+        )
+      service.create( request )
+    end
+
+    it "returns a Result" do
+      expect( service.create( request ) ).to be_a Shamu::Services::Result
+    end
+
+    it "applies request to entity" do
+      entity = service.create( request ).entity
+
+      expect( entity.name ).to eq "Example"
+      expect( entity.label ).to eq "Books"
+    end
+
+    it "yields if block given" do
+      expect do |b|
+        yield_klass = Class.new( klass ) do
+          create( &b )
+        end
+
+        scorpion.new( yield_klass ).create( request )
+      end.to yield_with_args(
+        request,
+        kind_of( ActiveRecord::Base )
+      )
+    end
+
+    it "does not call apply_changes if block given" do
+      yield_klass = Class.new( klass ) do
+        create { |_, _| }
+      end
+
+      service = scorpion.new( yield_klass )
+      expect( service ).not_to receive :apply_changes
+      service.create
+    end
+
+    it "calls #authorize!" do
+      expect( service ).to receive( :authorize! ).with(
+        :create,
+        ActiveRecordCrudSpec::FavoriteEntity,
+        kind_of( ActiveRecordCrudSpec::Request::Create )
+      )
+
+      service.create
+    end
+  end
+
+  describe ".change" do
+    let( :request ) { ActiveRecordCrudSpec::Request::Update.new( name: "Updated Example" ) }
+    let( :entity )  { service.create( name: "Example", label: "Books" ).entity }
+
+    it "calls Model.find" do
+      expect( ActiveRecordSpec::Favorite ).to receive( :find ).with( entity.id ).and_call_original
+      service.update entity.id, request
+    end
+
+    it "calls request.apply_to" do
+      expect( request ).to receive( :apply_to ).and_call_original
+      service.update entity, request
+    end
+
+    it "calls apply_changes if present" do
+      expect( service ).to receive( :apply_changes )
+        .with(
+          kind_of( Shamu::Services::Request ),
+          kind_of( ::ActiveRecord::Base )
+        )
+      service.create( request )
+    end
+
+    it "yields if block given" do
+      entity = service.create.entity
+
+      expect do |b|
+        yield_klass = Class.new( klass ) do
+          change( :update, &b )
+        end
+
+        scorpion.new( yield_klass ).update entity.id, request
+      end.to yield_with_args( request, kind_of( ::ActiveRecord::Base ) )
+    end
+
+    it "does not call apply_changes if block given" do
+      entity = service.create.entity
+
+      yield_klass = Class.new( klass ) do
+        change( :update ) { |_, _| }
+      end
+
+      service = scorpion.new( yield_klass )
+      expect( service ).not_to receive :apply_changes
+      service.update entity.id
+    end
+
+    it "calls #authorize!" do
+      expect( service ).to receive( :authorize! ).with(
+        :update,
+        kind_of( ActiveRecordCrudSpec::FavoriteEntity ),
+        kind_of( ActiveRecordCrudSpec::Request::Update )
+      )
+
+      service.update entity
+    end
+  end
+
+  describe ".apply_changes" do
+    it "defines an apply_changes method from the block" do
+      klass = Class.new( Shamu::Services::Service ) do
+        include Shamu::Services::ActiveRecordCrud
+
+        apply_changes do |record, request|
+        end
+      end
+
+      expect( klass.new.respond_to?( :apply_changes, true ) ).to be_truthy
+    end
+  end
+
+  describe ".finders" do
+    it "builds #lookup" do
+      expect( service ).to respond_to :lookup
+    end
+
+    it "builds #find" do
+      expect( service ).to respond_to :find
+    end
+
+    it "builds #list" do
+      expect( service ).to respond_to :list
+    end
+
+    context "filtered" do
+      let( :klass ) do
+        Class.new( Shamu::Services::Service ) do
+          include Shamu::Services::ActiveRecordCrud
+          resource ActiveRecordCrudSpec::FavoriteEntity, ActiveRecordSpec::Favorite
+        end
+      end
+
+      it "excludes unwanted methods" do
+        klass.finders except: :list
+
+        expect( klass.new ).to respond_to :find
+        expect( klass.new ).to respond_to :lookup
+        expect( klass.new ).not_to respond_to :list
+      end
+
+      it "includes only specific methods" do
+        klass.finders only: :list
+
+        expect( klass.new ).not_to respond_to :find
+        expect( klass.new ).not_to respond_to :lookup
+        expect( klass.new ).to respond_to :list
+      end
+    end
+  end
+
+  describe ".find" do
+    let( :entity ) { service.create( name: "Example", label: "Books" ).entity }
+
+    it "calls lookup if no block given" do
+      expect( service ).to receive( :lookup ).and_return( [entity] )
+      service.find( 1 )
+    end
+
+    it "yields to block if block given" do
+      find_klass = Class.new( klass )
+      expect do |b|
+        find_klass.find( &b )
+        scorpion.new( find_klass ).find( entity.id )
+      end.to yield_control
+    end
+
+    it "calls #authorize!" do
+      expect( service ).to receive( :authorize! ).with(
+        :read,
+        kind_of( ActiveRecordCrudSpec::FavoriteEntity )
+      )
+
+      service.find entity.id
+    end
+  end
+
+  describe ".lookup" do
+    let( :entity ) { service.create( name: "Example", label: "Books" ).entity }
+
+    it "uses cached_lookup" do
+      expect( service ).to receive( :cached_lookup ).and_call_original
+      service.lookup( entity.id )
+    end
+
+    it "uses entity_lookup_list" do
+      expect( service ).to receive( :entity_lookup_list ).and_call_original
+      service.lookup( entity.id )
+    end
+
+    it "returns a list of entities" do
+      list = service.lookup( entity.id )
+      expect( list ).to be_a Shamu::Entities::List
+      expect( list.size ).to eq 1
+      expect( list.first ).to eq entity
+    end
+
+    it "returns NullEntitys for missing ids" do
+      list = service.lookup( entity.id + 1 )
+      expect( list.first ).to be_a Shamu::Entities::NullEntity
+    end
+
+    it "yields to block if given?" do
+      expect do |b|
+        yield_klass = Class.new( klass ) do
+          lookup( &b )
+        end
+
+        scorpion.new( yield_klass ).lookup entity.id
+      end.to yield_control
+    end
+
+    it "calls #authorize!" do
+      expect( service ).to receive( :authorize! ).with(
+        :read,
+        kind_of( ActiveRecordCrudSpec::FavoriteEntity )
+      )
+
+      service.lookup entity.id
+    end
+
+    it "calls #authorize_relation" do
+      expect( service ).to receive( :authorize_relation ).with(
+        :read,
+        kind_of( ActiveRecord::Relation )
+      )
+
+      service.lookup entity.id
+    end
+  end
+
+  describe ".list" do
+    let!( :entity ) { service.create( name: "Example", label: "Books" ).entity }
+
+    it "returns all the entities" do
+      list = service.list
+      expect( list ).to be_a Shamu::Entities::List
+      expect( list.size ).to eq 1
+      expect( list.first ).to eq entity
+    end
+
+    it "yields if block given" do
+      expect do |b|
+        yield_klass = Class.new( klass ) do
+          list( &b )
+        end
+
+        scorpion.new( yield_klass ).list
+      end
+    end
+
+    it "calls #authorize! for each entity" do
+      expect( service ).to receive( :authorize! ).with(
+        :read,
+        kind_of( ActiveRecordCrudSpec::FavoriteEntity )
+      )
+
+      service.list.to_a
+    end
+
+    it "calls #authorize! to list" do
+      expect( service ).to receive( :authorize! ).with(
+        :list,
+        ActiveRecordCrudSpec::FavoriteEntity,
+        kind_of( ActiveRecordCrudSpec::FavoriteListScope )
+      )
+
+      service.list
+    end
+
+    it "calls #authorize_relation" do
+      expect( service ).to receive( :authorize_relation ).with(
+        :read,
+        kind_of( ActiveRecord::Relation ),
+        kind_of( ActiveRecordCrudSpec::FavoriteListScope )
+      )
+
+      service.list
+    end
+  end
+
+  describe ".destroy" do
+    let!( :entity ) { service.create( name: "Example", label: "Books" ).entity }
+
+    it "destroys the record" do
+      expect do
+        service.destroy entity
+      end.to change( ActiveRecordSpec::Favorite, :count ).by( -1 )
+    end
+
+    it "calls #authorize!" do
+      expect( service ).to receive( :authorize! ).with(
+        :destroy,
+        kind_of( ActiveRecordCrudSpec::FavoriteEntity )
+      )
+
+      service.destroy entity.id
+    end
+  end
+
+  describe ".build_entity" do
+    let!( :entity ) { service.create( name: "Example", label: "Books" ).entity }
+    let( :entity_class ) do
+      Class.new( Shamu::Entities::Entity ) do
+        attribute :id
+      end
+    end
+    let( :klass ) do
+      ec = entity_class
+      Class.new( super() ) do
+        build_entity do |record, _ = nil|
+          scorpion.fetch ec, { record: record }, {}
+        end
+        public :build_entity
+      end
+    end
+
+    it "builds an entity from the model record defined by .resource" do
+      entity = service.build_entity( ActiveRecordSpec::Favorite.first )
+      expect( entity ).to be_a entity_class
+    end
+
+  end
+end