activity_permission_engine 0.0.1

data/lib/activity_permission_engine/check_authorization.rb

@@ -0,0 +1,47 @@
+module ActivityPermissionEngine
+  class CheckAuthorization
+    def initialize(request, activities_registry = ActivityPermissionEngine.configuration.activity_permissions_registry)
+      @request = request
+      @activities_registry = activities_registry
+    end
+
+    def call
+      Response.new(authorized?)
+    end
+
+    private
+    attr_reader(:request, :activities_registry)
+
+    def activity
+      @activity ||= activities_registry.find_by_activity_ref(request.activity_ref)
+    end
+
+    def authorized?
+      activity && (activity.role_refs & request.role_refs).length > 0
+    end
+
+    class Request
+      include Framework::Request
+
+      def initialize(activity_ref, role_refs)
+        @activity_ref = activity_ref
+        @role_refs = role_refs
+      end
+
+      attr_reader(:activity_ref, :role_refs)
+    end
+
+    class Response
+      def initialize(authorized)
+        @authorized = authorized
+      end
+
+      def authorized?
+        authorized
+      end
+
+      attr_reader(:authorized)
+    end
+
+  end
+end

data/lib/activity_permission_engine/disallow_activity.rb

@@ -0,0 +1,38 @@
+module ActivityPermissionEngine
+  class DisallowActivity
+    def initialize(request, activities_registry = ActivityPermissionEngine.configuration.activity_permissions_registry)
+      @request = request
+      @activities_registry = activities_registry
+    end
+
+    def call
+      Response.new(activities_registry.remove_role(request.activity_ref, request.role_ref))
+    end
+
+    private
+    attr_reader(:request, :activities_registry)
+
+    class Request
+      include Framework::Request
+
+      def initialize(activity_ref, role_ref)
+        @activity_ref = activity_ref
+        @role_ref = role_ref
+      end
+
+      attr_reader(:activity_ref, :role_ref)
+    end
+
+    class Response
+      def initialize(success)
+        @success = success
+      end
+
+      def success?
+        success
+      end
+      private
+      attr_reader(:success)
+    end
+  end
+end

data/lib/activity_permission_engine/framework/request.rb

@@ -0,0 +1,16 @@
+module ActivityPermissionEngine
+  module Framework
+    module Request
+      def response
+        perform
+      end
+
+      private
+      def perform
+        self.class.name.split('::').reverse.drop(1).reverse.inject(Object) do |nesting, name|
+          nesting.const_get(name)
+        end.new(self).call
+      end
+    end
+  end
+end

data/lib/activity_permission_engine/interface_helpers.rb

@@ -0,0 +1,31 @@
+module ActivityPermissionEngine
+  module InterfaceHelpers
+    def register_activity(activity_ref)
+      RegisterActivity::Request.new(activity_ref).response
+    end
+
+    def list_activities
+      ListActivities::Request.new.response
+    end
+
+    def unregister_activity(activity_ref)
+      UnregisterActivity::Request.new(activity_ref).response
+    end
+
+    def allow_activity(activity_ref, role_ref)
+      AllowActivity::Request.new(activity_ref, role_ref).response
+    end
+
+    def disallow_activity(activity_ref, role_ref)
+      DisallowActivity::Request.new(activity_ref, role_ref).response
+    end
+
+    def check_authorization(activity_ref, role_refs)
+      CheckAuthorization::Request.new(activity_ref, role_refs).response
+    end
+
+    def list_activities_permissions
+      ListActivitiesPermissions::Request.new.response
+    end
+  end
+end

data/lib/activity_permission_engine/list_activities.rb

@@ -0,0 +1,27 @@
+module ActivityPermissionEngine
+  class ListActivities
+    def initialize(request, activities_registry = ActivityPermissionEngine.configuration.activities_registry)
+      @request = request
+      @activities_registry = activities_registry
+    end
+
+    def call
+      Response.new(activities_registry.all)
+    end
+
+    private
+    attr_reader(:activities_registry)
+
+    class Request
+      include Framework::Request
+    end
+
+    class Response
+      def initialize(activity_refs)
+        @activity_refs = activity_refs
+      end
+
+      attr_reader(:activity_refs)
+    end
+  end
+end

data/lib/activity_permission_engine/list_activities_permissions.rb

@@ -0,0 +1,28 @@
+module ActivityPermissionEngine
+  class ListActivitiesPermissions
+    def initialize(request, activity_permissions_registry = ActivityPermissionEngine.configuration.activity_permissions_registry)
+      @activity_permissions_registry = activity_permissions_registry
+      @request = request
+    end
+
+
+    def call
+      Response.new(activity_permissions_registry.all)
+    end
+
+    private
+    attr_reader(:activity_permissions_registry)
+
+    class Request
+      include Framework::Request
+    end
+
+    class Response
+      def initialize(activities_permissions)
+        @activities_permissions = activities_permissions
+      end
+
+      attr_reader :activities_permissions
+    end
+  end
+end

data/lib/activity_permission_engine/register_activity.rb

@@ -0,0 +1,38 @@
+module ActivityPermissionEngine
+  class RegisterActivity
+    def initialize(request, activity_registry = ActivityPermissionEngine.configuration.activities_registry)
+      @request = request
+      @activity_registry = activity_registry
+    end
+
+    def call
+      Response.new(activity_registry.add(request.activity_ref))
+    end
+
+    private
+    attr_reader(:request, :activity_registry)
+
+    class Request
+      include Framework::Request
+
+      def initialize(activity_ref)
+        @activity_ref = activity_ref
+      end
+
+      attr_reader(:activity_ref)
+    end
+
+    class Response
+      def initialize(success)
+        @success = success
+      end
+
+      def success?
+        success
+      end
+
+      private
+      attr_reader :success
+    end
+  end
+end

data/lib/activity_permission_engine/test_helpers/activity_permissions_registry_test.rb

@@ -0,0 +1,31 @@
+module ActivityPermissionEngine
+  module TestHelpers
+    # Include this module in your adapter's test
+    # it will ensure that it quacks like a duck
+    module ActivityPermissionsRegistryTest
+      def self.included(base)
+        base.class_eval do
+          it 'respond_to add' do
+            subject.must_respond_to(:add)
+          end
+
+          it 'respond_to all' do
+            subject.must_respond_to(:all)
+          end
+
+          it 'respond_to del' do
+            subject.must_respond_to(:del)
+          end
+
+          it 'respond_to add_role' do
+            subject.must_respond_to(:add_role)
+          end
+
+          it 'respond_to find_by_activity_ref' do
+            subject.must_respond_to(:find_by_activity_ref)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activity_permission_engine/unregister_activity.rb

@@ -0,0 +1,38 @@
+module ActivityPermissionEngine
+  class UnregisterActivity
+    def initialize(request, activities_registry = ActivityPermissionEngine.configuration.activity_permissions_registry)
+      @request = request
+      @activities_registry = activities_registry
+    end
+
+    def call
+      Response.new(activities_registry.del(request.activity_ref))
+    end
+
+    private
+    attr_reader(:request, :activities_registry)
+
+    class Request
+      include Framework::Request
+
+      def initialize(activity_ref)
+        @activity_ref = activity_ref
+      end
+
+      attr_reader(:activity_ref)
+    end
+
+    class Response
+      def initialize(success)
+        @success = success
+      end
+
+      def success?
+        success
+      end
+
+      private
+      attr_reader(:success)
+    end
+  end
+end

data/lib/activity_permission_engine/version.rb

@@ -0,0 +1,3 @@
+module ActivityPermissionEngine
+  VERSION = "0.0.1"
+end

data/test/adapters/activities_registry/memory_test.rb

@@ -0,0 +1,68 @@
+require_relative '../../test_helper'
+require_relative '../../../lib/activity_permission_engine/adapters/activity_permissions_registry/memory'
+require_relative '../../../lib/activity_permission_engine/test_helpers/activity_permissions_registry_test'
+
+module ActivityPermissionEngine
+  describe Adapters::ActivityPermissionsRegistry::Memory do
+
+    let(:activity_ref) { 'example:activity_ref' }
+    let(:role_refs) { %w(foo bar) }
+    let(:store) { { activity_ref => role_refs} }
+    let(:registry) { Adapters::ActivityPermissionsRegistry::Memory.new(store) }
+
+    describe 'implement the activity permission registry interface' do
+      subject { registry }
+      include ActivityPermissionEngine::TestHelpers::ActivityPermissionsRegistryTest
+    end
+
+    describe '#all' do
+      subject{ registry.all }
+
+      it 'returns a list of activities' do
+        subject.must_be_kind_of Array
+        subject.first.must_be_kind_of ActivityPermissionsRegistry::ActivityPermission
+      end
+    end
+
+    describe '#find_by_activity_ref' do
+      subject { registry.find_by_activity_ref(activity_ref) }
+      describe 'using an existing activity_ref' do
+        it 'return an Activity' do
+          subject.must_be_kind_of ActivityPermissionsRegistry::ActivityPermission
+        end
+
+        it 'returns the corresponding Activity' do
+          subject.activity_ref.must_equal activity_ref
+        end
+      end
+
+      describe 'when activity_ref does not exists' do
+        let(:store) { {'foo' => []} }
+
+        it 'returns false' do
+          subject.must_equal false
+        end
+      end
+    end
+
+    describe '#del' do
+      let(:existing_activity) { 'activity' }
+      subject { registry.del(activity_ref) }
+
+      it 'remove the activity from registry' do
+        subject
+        registry.find_by_activity_ref(activity_ref).must_equal false
+      end
+    end
+
+    describe '#add_role' do
+      let(:new_role_ref) { 'new_role_ref' }
+      subject { registry.add_role(activity_ref, new_role_ref) }
+
+      it 'add role to the role_refs' do
+        subject
+        registry.find_by_activity_ref(activity_ref).role_refs.must_include new_role_ref
+      end
+    end
+  end
+end

data/test/functionnals/activity_permission_engine_test.rb

@@ -0,0 +1,74 @@
+require_relative '../test_helper'
+
+describe 'configured with a registry and a list of activities' do
+  let(:provided_activities) { %w(allow_role disallow_role) }
+
+  before(:each) do
+    ActivityPermissionEngine.configuration = ActivityPermissionEngine::Configuration.new(activities: provided_activities)
+  end
+
+  describe 'I can list activities' do
+    subject { ActivityPermissionEngine.list_activities }
+
+    it 'return activity references list' do
+      subject.activity_refs.must_equal provided_activities
+    end
+
+    describe 'when i add activity at runtime' do
+      let(:new_activity) { 'new_activity' }
+
+      before(:each) do
+        ActivityPermissionEngine.register_activity(new_activity)
+      end
+      it 'return the added activity' do
+        subject.activity_refs.must_include new_activity
+      end
+    end
+  end
+
+  describe 'When I allow an entity ( like role ) to perform an activity' do
+    let(:my_role) { 'roles manager' }
+    let(:activity) { 'allow_role' }
+    let(:allow_activity_request) { ActivityPermissionEngine::AllowActivity::Request.new(activity, my_role) }
+
+    before(:each) { ActivityPermissionEngine.allow_activity(activity, my_role) }
+
+    describe 'checking for authorization' do
+      it 'allows the role to perform activity' do
+        ActivityPermissionEngine.check_authorization(activity, [my_role]).authorized?.must_equal true
+      end
+
+      describe 'the permission list' do
+        subject { ActivityPermissionEngine.list_activities_permissions.activities_permissions }
+        it 'includes the new permission' do
+          subject.select do
+          |ap|
+            ap.activity_ref == activity
+          end.first.role_refs.must_include my_role
+        end
+      end
+
+
+      describe 'I can disallow an entity to perform activity' do
+        let(:my_role) { 'roles manager' }
+        let(:activity) { 'allow_role' }
+        let(:disallow_activity_request) { ActivityPermissionEngine::DisallowActivity::Request.new(activity, [my_role]) }
+        let(:check_authorization_request) { ActivityPermissionEngine::CheckAuthorization::Request.new(activity, [my_role]) }
+
+        before(:each) do
+          ActivityPermissionEngine.configuration = ActivityPermissionEngine::Configuration.new(
+              activity_permission_registry: ActivityPermissionEngine::Adapters::ActivityPermissionsRegistry::Memory.new(
+                  {activity => [my_role]}
+              )
+          )
+        end
+
+        it 'disallow the role to perform activity' do
+          ActivityPermissionEngine.disallow_activity(my_role, activity)
+          ActivityPermissionEngine.check_authorization(activity, [my_role]).authorized?.must_equal false
+        end
+      end
+    end
+  end
+end
+