arpa 0.0.2

data/spec/lib/ar/repositories/base_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+class BaseImplementationTest
+  include Arpa::Repositories::Base
+end
+
+describe Arpa::Repositories::Base, type: :repository, fast: true do
+
+  let(:base_implementation) { BaseImplementationTest.new }
+
+  context 'when Implementation class do not override methods from Base' do
+
+    context 'when call :mapper_instance' do
+
+      it 'should raise NotImplementedError' do
+        expect { base_implementation.mapper_instance }.to raise_error do |error|
+          expect(error).to be_a NotImplementedError
+          expect(error.message).to eql 'This BaseImplementationTest cannot respond :mapper_instance'
+        end
+      end
+
+    end
+
+    context 'when call :repository_class' do
+
+      it 'should raise NotImplementedError' do
+        expect { base_implementation.repository_class}.to raise_error do |error|
+          expect(error).to be_a NotImplementedError
+          expect(error.message).to eql 'This BaseImplementationTest cannot respond :repository_class'
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/ar/repositories/profiles/finder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Profiles::Finder, type: :repository, slow: true do
+
+  let(:record_001) { create :repository_profile, name: 'profile_01' }
+  let(:record_002) { create :repository_profile, name: 'profile_02' }
+
+  before do
+    record_001
+    record_002
+  end
+
+  describe '#find' do
+    let(:result) { subject.find(record_001.id) }
+
+    it 'the Profile entity should has name "profile_01"' do
+      expect(result.name).to eql 'profile_01'
+    end
+
+    it 'the result should be an Arpa::Entities::Profile' do
+      expect(result).to be_an Arpa::Entities::Profile
+    end
+
+  end
+
+  describe '#all' do
+    let(:result) { subject.all }
+
+    it 'should return size 2' do
+      expect(result.size).to be == 2
+    end
+
+    it 'the first Profile entity should has name "profile_01"' do
+      expect(result.first.name).to eql 'profile_01'
+    end
+
+    it 'the result should be an Array of Arpa::Entities::Profile' do
+      expect(result.first).to be_an Arpa::Entities::Profile
+    end
+
+  end
+
+end

data/spec/lib/ar/repositories/profiles/remover_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Profiles::Remover, type: :repository, slow: true do
+
+  let(:created_profile) { create :repository_profile }
+
+  before { created_profile }
+
+  describe '#destroy' do
+    let(:destroy_profile) { subject.destroy(created_profile) }
+
+    it 'should destroy the role' do
+      expect { destroy_profile }.to change(Arpa::Repositories::Profiles::RepositoryProfile, :count).by(-1)
+    end
+
+  end
+
+  describe '#disable' do
+    let(:disable_profile) { subject.disable(created_profile) }
+
+    it 'should disable the role' do
+      expect { disable_profile }.to change(Arpa::Repositories::Profiles::RepositoryProfile, :count).by(-1)
+    end
+
+    it 'role should be setted to removed: true' do
+      expect(disable_profile.removed).to be_truthy
+    end
+
+  end
+
+end

data/spec/lib/ar/repositories/resources/finder_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Resources::Finder, type: :repository, slow: true do
+
+  let(:record_001) { create :repository_resource, :user }
+  let(:record_002) { create :repository_resource, :contact }
+
+  describe '#find' do
+    let(:result) { subject.find(record_001.id) }
+
+    it 'the Resource entity should has name "users"' do
+      expect(result.name).to eql 'users'
+    end
+
+    it 'the result should be an Arpa::Entities::Resource' do
+      expect(result).to be_an Arpa::Entities::Resource
+    end
+
+  end
+
+  describe '#all' do
+    let(:result) { subject.all }
+
+    before do
+      record_001
+      record_002
+    end
+
+
+    it 'should return size 2' do
+      expect(result.size).to be == 2
+    end
+
+    it 'the first Resource entity should has full_name "ContactsController"' do
+      expect(result.first.full_name).to eql 'ContactsController'
+    end
+
+    it 'the result should be an Array of Arpa::Entities::Resource' do
+      expect(result.first).to be_an Arpa::Entities::Resource
+    end
+
+  end
+
+  describe '#by_full_name' do
+
+    before do
+      record_001
+      record_002
+    end
+
+    context 'when exist with the full_name' do
+
+      let(:result) { subject.by_full_name('UsersController') }
+
+      it 'should return a resource with name "users"' do
+        expect(result.name).to eql 'users'
+      end
+
+      it 'the result should be an instance of Arpa::Entities::Resource' do
+        expect(result).to be_an Arpa::Entities::Resource
+      end
+    end
+
+    context 'when nonexist with the full_name' do
+
+      let(:result) { subject.by_full_name('NonessController') }
+
+      it 'the result should return nil' do
+        expect(result).to be_nil
+      end
+    end
+
+  end
+
+  describe 'getting permissions from profile_ids' do
+    let(:profile_001) { create :repository_profile, :with_complete_association, name: 'prof_001' }
+    let(:profile_002) { create :repository_profile, :with_complete_association, name: 'prof_002' }
+    let(:profile_ids) { [profile_001.id, profile_002.id] }
+
+    let(:result) { subject.permissions(profile_ids) }
+    let(:first)  { result.first }
+
+    it 'should return an Arpa::Entities::Permissions' do
+      expect(result).to be_an Arpa::Entities::Permissions
+    end
+
+    it 'should has just one permission' do
+      expect(result.permissions.size).to be == 1
+    end
+
+  end
+end

data/spec/lib/ar/repositories/resources/remover_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Resources::Remover, type: :repository, slow: true do
+
+  let(:resource_001)     { create :repository_resource, :user }
+  let(:destroy_resource) { subject.destroy(resource_001) }
+
+  describe '#destroy' do
+
+    context 'when resource has no actions associate' do
+      let(:actions) { [] }
+
+      it 'should destroy the resource' do
+        expect { destroy_resource }.to change(Arpa::Repositories::Resources::RepositoryResource, :count).by(0)
+      end
+    end
+
+    context 'when resource has actions associate' do
+      let(:action_001) { create :repository_action, :index, resource: resource_001 }
+      let(:action_002) { create :repository_action, :show,  resource: resource_001 }
+
+      before do
+        action_001
+        action_002
+      end
+
+      it 'should destroy the resource' do
+        expect { destroy_resource }.to change(Arpa::Repositories::Resources::RepositoryResource, :count).by(-1)
+      end
+
+      it 'should destroy all actions associate with resource' do
+        expect { destroy_resource }.to change(Arpa::Repositories::Actions::RepositoryAction, :count).by(-2)
+      end
+
+    end
+
+  end
+end

data/spec/lib/ar/repositories/roles/finder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Roles::Finder, type: :repository, slow: true do
+
+  let(:record_001) { create :repository_role, name: 'role_01' }
+  let(:record_002) { create :repository_role, name: 'role_02' }
+
+  before do
+    record_001
+    record_002
+  end
+
+  describe '#find' do
+    let(:result) { subject.find(record_001.id) }
+
+    it 'the Role entity should has name "role_01"' do
+      expect(result.name).to eql 'role_01'
+    end
+
+    it 'the result should be an Arpa::Entities::Role' do
+      expect(result).to be_an Arpa::Entities::Role
+    end
+
+  end
+
+  describe '#all' do
+    let(:result) { subject.all }
+
+    it 'should return size 2' do
+      expect(result.size).to be == 2
+    end
+
+    it 'the first Role entity should has name "role_01"' do
+      expect(result.first.name).to eql 'role_01'
+    end
+
+    it 'the result should be an Array of Arpa::Entities::Role' do
+      expect(result.first).to be_an Arpa::Entities::Role
+    end
+
+  end
+
+end

data/spec/lib/ar/repositories/roles/remover_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Roles::Remover, type: :repository, slow: true do
+
+  let(:created_role) { create :repository_role }
+
+  before { created_role }
+
+  describe '#destroy' do
+    let(:destroy_role) { subject.destroy(created_role) }
+
+    it 'should destroy the role' do
+      expect { destroy_role }.to change(Arpa::Repositories::Roles::RepositoryRole, :count).by(-1)
+    end
+
+  end
+
+  describe '#disable' do
+    let(:disable_role) { subject.disable(created_role) }
+
+    it 'should disable the role' do
+      expect { disable_role }.to change(Arpa::Repositories::Roles::RepositoryRole, :count).by(-1)
+    end
+
+    it 'role should be setted to removed: true' do
+      expect(disable_role.removed).to be_truthy
+    end
+
+  end
+
+end

data/spec/lib/ar/requests/profiles/create_request_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe "Create Profile", type: [:request, :profile] do
+  let(:finder_profile_repo)      { Arpa::Repositories::Profiles::Finder.new }
+  let(:finder_resource_repo)     { Arpa::Repositories::Resources::Finder.new }
+  let(:finder_role_repo)         { Arpa::Repositories::Roles::Finder.new }
+  let(:creator_resource_service) { Arpa::Services::Resources::ResourceManagerCreator.new }
+  let(:creator_role_service)     { Arpa::Services::Roles::RoleManagerCreator.new }
+  let(:creator_profile_service)  { Arpa::Services::Profiles::ProfileManagerCreator.new }
+  let(:success_proc)             { ->(r) {} }
+  let(:callback)                 { {success: success_proc, fail: ->(e) {raise e} } }
+
+  context 'when have no created resources or actions' do
+    let(:resourceable_001)  { double to_s: 'UsersController', action_methods: [:index, :show, 'edit'] }
+    let(:resourceable_002)  { double to_s: 'ContactsController', action_methods: [:index, 'edit'] }
+    let(:resourceables)     { [resourceable_001, resourceable_002] }
+    let(:created_resources) { creator_resource_service.create({resourceables: resourceables}, callback) }
+
+    let(:action_ids) { finder_resource_repo.all.first.actions.collect{ |action| action.id} }
+    let(:role_001_params)   { {role: {name: 'role_name_001', description: 'role_description_001', action_ids: action_ids}} }
+    let(:role_002_params)   { {role: {name: 'role_name_002', description: 'role_description_002', action_ids: action_ids}} }
+    let(:created_roles) do
+      creator_role_service.create(role_001_params, callback)
+      creator_role_service.create(role_002_params, callback)
+    end
+
+    let(:role_ids) { finder_role_repo.all.map { |r| r.id } }
+
+    before do
+      created_resources
+      created_roles
+      profile_params = {profile: {name: 'profile_name', description: 'profile_description', role_ids: role_ids}}
+      creator_profile_service.create(profile_params, callback)
+    end
+
+    it 'should be recorded one profile' do
+      expect(finder_profile_repo.all.size).to be == 1
+    end
+
+    it 'should has 2 roles associated' do
+      expect(finder_profile_repo.all.first.roles.size).to be == 2
+    end
+
+    context 'names of associated roles' do
+      it {expect(finder_profile_repo.all.first.roles.first.name).to eql 'role_name_001'}
+      it {expect(finder_profile_repo.all.first.roles.second.name).to eql 'role_name_002'}
+    end
+
+  end
+
+end

data/spec/lib/ar/requests/profiles/remove_request_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe "Remove Profile", type: [:request, :profile] do
+  let(:finder_profile_repo)     { Arpa::Repositories::Profiles::Finder.new }
+  let(:remover_profile_service) { Arpa::Services::Profiles::ProfileManagerRemover.new }
+  let(:success_proc)            { ->(r) {} }
+  let(:callback)                { {success: success_proc, fail: ->(e) {raise e} } }
+
+  describe 'removing a Profile' do
+
+    before do
+      create :repository_profile
+      remover_profile_service.remove(profile_params_to_remove, callback)
+    end
+
+    context 'when need destroy a Profile' do
+      let(:profile_params_to_remove) { {profile: finder_profile_repo.all.first } }
+
+      it 'record should be removed ' do
+        expect(finder_profile_repo.all.size).to be == 0
+      end
+
+    end
+
+    context 'when need disable a Profile' do
+      let(:profile_params_to_remove) { {profile: finder_profile_repo.all.first, disable: true } }
+
+      it 'record should be removed ' do
+        expect(finder_profile_repo.all.size).to be == 0
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/ar/requests/resources/create_request_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec.describe "Create Resource", type: [:request, :resource] do
+  let(:finder_repo)     { Arpa::Repositories::Resources::Finder.new }
+  let(:creator_service) { Arpa::Services::Resources::ResourceManagerCreator.new }
+  let(:success_proc)    { ->(r) {} }
+  let(:callback)        { {success: success_proc, fail: ->(e) {raise e} } }
+
+  context 'when have no created resources or actions' do
+    let(:resourceable_001) { double to_s: 'UsersController', action_methods: [:index, :show, 'edit'] }
+    let(:resourceable_002) { double to_s: 'ContactsController', action_methods: [:index, 'edit'] }
+    let(:resourceables)    { [resourceable_001, resourceable_002] }
+
+    before do
+      creator_service.create({resourceables: resourceables}, callback)
+    end
+
+    it 'should be recorded two resources' do
+      expect(finder_repo.all.size).to be == 2
+    end
+
+    context 'names of resources' do
+      it {expect(finder_repo.all.first.name).to eql('contacts') }
+      it {expect(finder_repo.all.second.name).to eql('users') }
+    end
+
+    context 'Contacts resource' do
+      let(:contacts_resource) { finder_repo.all.first }
+
+      it 'should has two actions' do
+        expect(contacts_resource.actions.size).to be == 2
+      end
+
+      context 'names of actions' do
+        it {expect(contacts_resource.actions.first.name).to eql('edit') }
+        it {expect(contacts_resource.actions.second.name).to eql('index') }
+      end
+    end
+
+    context 'Users resource' do
+      let(:users_resource) { finder_repo.all.second }
+
+      it 'should has three actions' do
+        expect(users_resource.actions.size).to be == 3
+      end
+
+      context 'names of actions' do
+        it {expect(users_resource.actions.first.name).to eql('edit') }
+        it {expect(users_resource.actions.second.name).to eql('index') }
+        it {expect(users_resource.actions.third.name).to eql('show') }
+      end
+
+    end
+  end
+
+  context 'when have created resources or actions' do
+    let(:resourceable_001)      { double to_s: 'UsersController', action_methods: [:index, :show, 'edit'] }
+    let(:resourceable_002)      { double to_s: 'ContactsController', action_methods: [:index, 'edit'] }
+    let(:created_resourceables) { [resourceable_001, resourceable_002] }
+
+    let(:resourceable_003)  { double to_s: 'Arpa::NewUsersController', action_methods: [:show, 'edit'] }
+    let(:resourceable_004)  { double to_s: 'ContactsController', action_methods: [:index, 'new_edit'] }
+    let(:new_resourceables) { [resourceable_003, resourceable_004] }
+
+    before do
+      creator_service.create({resourceables: created_resourceables}, callback)
+      creator_service.create({resourceables: new_resourceables}, callback)
+    end
+
+    it 'should be recorded two resources' do
+      expect(finder_repo.all.size).to be == 2
+    end
+
+    context 'names of resources' do
+      it {expect(finder_repo.all.first.name).to eql('arpa/new_users') }
+      it {expect(finder_repo.all.second.name).to eql('contacts') }
+    end
+
+    context 'Contacts resource' do
+      let(:contacts_resource) { finder_repo.all.second }
+
+      it 'should has two actions' do
+        expect(contacts_resource.actions.size).to be == 2
+      end
+
+      context 'names of actions' do
+        it {expect(contacts_resource.actions.first.name).to eql('index') }
+        it {expect(contacts_resource.actions.second.name).to eql('new_edit') }
+      end
+    end
+
+    context 'Arpa::NewUsers resource' do
+      let(:users_resource) { finder_repo.all.first }
+
+      it 'should has two actions' do
+        expect(users_resource.actions.size).to be == 2
+      end
+
+      context 'names of actions' do
+        it {expect(users_resource.actions.first.name).to eql('edit') }
+        it {expect(users_resource.actions.second.name).to eql('show') }
+      end
+
+    end
+  end
+
+end