arpa 0.0.2

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe "Create Role", type: [:request, :role] do
+  let(:finder_role_repo)         { Arpa::Repositories::Roles::Finder.new }
+  let(:finder_resource_repo)     { Arpa::Repositories::Resources::Finder.new }
+  let(:creator_resource_service) { Arpa::Services::Resources::ResourceManagerCreator.new }
+  let(:creator_role_service)     { Arpa::Services::Roles::RoleManagerCreator.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} }
+
+    before do
+      created_resources
+      role_params = {role: {name: 'role_name', description: 'role_description', action_ids: action_ids}}
+      creator_role_service.create(role_params, callback)
+    end
+
+    it 'should be recorded one role' do
+      expect(finder_role_repo.all.size).to be == 1
+    end
+
+    it 'should has 2 actions associated' do
+      expect(finder_role_repo.all.first.actions.size).to be == 2
+    end
+
+    context 'names of associated actions' do
+      it {expect(finder_role_repo.all.first.actions.first.name).to eql 'edit'}
+      it {expect(finder_role_repo.all.first.actions.second.name).to eql 'index'}
+    end
+
+  end
+
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe "Remove Role", type: [:request, :role] do
+  let(:finder_role_repo)     { Arpa::Repositories::Roles::Finder.new }
+  let(:remover_role_service) { Arpa::Services::Roles::RoleManagerRemover.new }
+  let(:success_proc)         { ->(r) {} }
+  let(:callback)             { {success: success_proc, fail: ->(e) {raise e} } }
+
+  describe 'removing a Role' do
+
+    before do
+      create :repository_role
+      role_params_to_remove = {role: finder_role_repo.all.first }
+      remover_role_service.remove(role_params_to_remove, callback)
+    end
+
+    it 'record should be removed ' do
+      expect(finder_role_repo.all.size).to be == 0
+    end
+
+  end
+
+end

data/spec/lib/ar/requests/roles/update_request_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe "Update Role", type: [:request, :role] do
+  let(:finder_role_repo)         { Arpa::Repositories::Roles::Finder.new }
+  let(:finder_resource_repo)     { Arpa::Repositories::Resources::Finder.new }
+  let(:creator_resource_service) { Arpa::Services::Resources::ResourceManagerCreator.new }
+  let(:creator_role_service)     { Arpa::Services::Roles::RoleManagerCreator.new }
+  let(:updater_role_service)     { Arpa::Services::Roles::RoleManagerUpdater.new }
+  let(:success_proc)             { ->(r) {} }
+  let(:callback)                 { {success: success_proc, fail: ->(e) {raise e} } }
+
+  context 'updating a Role' 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(:create_resources_and_role) do
+      created_resources
+      role_params = {role: {name: 'role_name', description: 'role_description', action_ids: action_ids}}
+      creator_role_service.create(role_params, callback)
+    end
+
+    before do
+      create_resources_and_role
+      found_role = finder_role_repo.all.first
+      role_params_to_update = {role: {id: found_role.id, name: 'updated_role_name', description: 'role_description', action_ids: [action_ids[0]] }}
+      updater_role_service.update(role_params_to_update, callback)
+    end
+
+    it 'should be recorded one role' do
+      expect(finder_role_repo.all.size).to be == 1
+    end
+
+    it 'should has 1 actions associated' do
+      expect(finder_role_repo.all.first.actions.size).to be == 1
+    end
+
+    it 'name should be "updated_role_name"' do
+      expect(finder_role_repo.all.first.name).to eql 'updated_role_name'
+    end
+
+    context 'names of associated actions' do
+      it {expect(finder_role_repo.all.first.actions.first.name).to eql 'edit'}
+    end
+
+  end
+
+end

data/spec/lib/ar/services/actions/create/action_creator_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Arpa::Services::Actions::Create::ActionCreator, type: :service, fast: true do
+
+  let(:action_entity_class) { Arpa::Entities::Action }
+  let(:action)              { double }
+  let(:resource)            { double id: 1 }
+  let(:actions_names)       { ['index', 'new'] }
+  let(:params)              { {resource: resource, actions_names: actions_names} }
+  let(:action_found)        { nil }
+
+  let(:actions_created) { subject.create_many(params) }
+  let(:validator_class) { Arpa::Validators::ActionValidator }
+  let(:validator)       { instance_double validator_class }
+
+  let(:finder_repo_class) { Arpa::Repositories::Actions::Finder}
+  let(:finder_repo)       { instance_double finder_repo_class }
+
+  before do
+    allow(finder_repo_class).to receive(:new).and_return(finder_repo)
+    allow(finder_repo).to receive(:by_name_and_resource).and_return(action_found)
+
+    allow(validator_class).to receive(:new).with(action).and_return(validator)
+    allow(action_entity_class).to receive(:new).and_return(action)
+  end
+
+  describe 'creating a new action' do
+
+    context 'when resource is invalid' do
+      let(:errors) { instance_double('ActiveModel::Errors') }
+
+      before do
+        allow(validator).to receive(:valid?).and_return false
+        allow(validator).to receive(:errors).and_return(errors)
+        allow(errors).to receive(:messages)
+      end
+
+      it 'should raise a Arpa::Exceptions::RecordInvalid with :errors of ActiveModel::Errors' do
+        expect { actions_created }.to raise_error { |error|
+          expect(error).to be_a Arpa::Exceptions::RecordInvalid
+          expect(error.errors).not_to be_nil
+        }
+      end
+
+    end
+
+    context 'when actino already exists' do
+      let(:action_found) { double }
+
+      it 'should return the action found' do
+        expect(actions_created).to eq [action_found, action_found]
+      end
+
+    end
+
+    context 'when resource is valid' do
+      let(:creator_repo_class) { Arpa::Repositories::Actions::Creator }
+      let(:creator_repo)       { instance_double creator_repo_class }
+
+      before do
+        allow(validator).to receive(:valid?).and_return true
+        allow(creator_repo_class).to receive(:new).and_return(creator_repo)
+        allow(creator_repo).to receive(:create).with(action)
+        actions_created
+      end
+
+      it 'creator repository should call :new' do
+        expect(creator_repo_class).to have_received(:new).once
+      end
+
+      it 'creator_repo should call create method with action as parameter' do
+        expect(creator_repo).to have_received(:create).with(action).twice
+      end
+
+      context 'when build an instance of action' do
+
+        it 'entity action should call new method' do
+          expect(action_entity_class).to have_received(:new).with({resource_id: resource.id, name: 'index'}).once
+          expect(action_entity_class).to have_received(:new).with({resource_id: resource.id, name: 'new'}).once
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/ar/services/actions/remove/action_remover_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Arpa::Services::Actions::Remove::ActionRemover, type: :service, fast: true do
+
+  let(:action_001) { double name: 'index' }
+  let(:action_002) { double name: 'old_index' }
+  let(:actions)    { [action_001, action_002]}
+  let(:resource)   { double actions: actions }
+
+  let(:actions_names) { ['index', 'show'] }
+
+  let(:params) { {resource: resource, actions_names: actions_names} }
+
+  describe 'removing nonexistent actions' do
+    let(:remover_repo_class) { Arpa::Repositories::Actions::Remover }
+    let(:remover_repo)       { instance_double remover_repo_class }
+
+    before do
+      allow(remover_repo_class).to receive(:new).and_return(remover_repo)
+      allow(remover_repo).to receive(:destroy)
+
+      subject.remove_nonexistent_actions(params)
+    end
+
+    it 'remover repository should call :new once' do
+      expect(remover_repo_class).to have_received(:new).once
+    end
+
+    it 'remover repository should call :destroy once' do
+      expect(remover_repo).to have_received(:destroy).once
+      expect(remover_repo).to have_received(:destroy).with(action_002).once
+    end
+
+  end
+
+end

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

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+class CustomTransactionClass
+  def self.transaction
+    yield
+  end
+end
+
+class ManagerImplementationTest
+  include Arpa::Services::Base
+
+  def create_raise callback
+    manager_action callback do
+      raise Exceptions::RecordInvalid.new 'some error'
+    end
+  end
+
+  def create callback
+    manager_action callback do
+      'success'
+    end
+  end
+
+end
+
+describe Arpa::Services::Base, type: :service, fast: true do
+
+  let(:manager_implementation) { ManagerImplementationTest.new }
+  let(:callback) {
+    {
+      success: -> (result) {},
+      fail: -> (exception){}
+    }
+  }
+
+  describe 'calling .transaction' do
+    before do
+      set_custom_transaction_class
+      allow(transaction_class).to receive(:transaction)
+      manager_implementation.create callback
+    end
+
+    context 'when use the default transaction_class from Services::ManagerBase' do
+      let(:set_custom_transaction_class) { manager_implementation.class.repository_transaction nil }
+      let(:transaction_class)            { ActiveRecord::Base }
+
+      it 'transaction_class should call .transaction' do
+        expect(transaction_class).to have_received(:transaction)
+      end
+
+    end
+
+    context 'when use a custom transaction_class' do
+      let(:set_custom_transaction_class) { manager_implementation.class.repository_transaction 'CustomTransactionClass' }
+      let(:transaction_class)            { CustomTransactionClass }
+
+      it 'transaction_class should call .transaction' do
+        expect(transaction_class).to have_received(:transaction)
+      end
+
+    end
+  end
+
+  describe 'calling correct callback' do
+    before do
+      manager_implementation.class.repository_transaction 'CustomTransactionClass'
+    end
+
+    context 'when success transaction' do
+      before do
+        allow(callback[:success]).to receive(:call)
+        manager_implementation.create callback
+      end
+
+      it 'should call the callback[:success]' do
+        expect(callback[:success]).to have_received(:call).once
+      end
+    end
+
+    context 'when fail transaction' do
+      before do
+        allow(callback[:fail]).to receive(:call).with kind_of StandardError
+        manager_implementation.create_raise callback
+      end
+
+
+      it 'should call the callback[:fail] with Exceptions::RecordInvalid' do
+        expect(callback[:fail]).to have_received(:call).with(kind_of StandardError)
+      end
+
+    end
+  end
+
+end

data/spec/lib/ar/services/profiles/create/profile_creator_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Arpa::Services::Profiles::Create::ProfileCreator, type: :service, fast: true do
+
+  let(:profile_entity_class) { Arpa::Entities::Profile }
+  let(:profile)              { double }
+  let(:params)               { double }
+
+  let(:profile_created)  { subject.create(params) }
+  let(:validator_class)  { Arpa::Validators::ProfileValidator }
+  let(:validator)        { instance_double validator_class }
+
+  before do
+    allow(validator_class).to receive(:new).and_return(validator)
+    allow(profile_entity_class).to receive(:new).and_return(profile)
+  end
+
+  describe 'creating a new profile' do
+
+    context 'when profile is invalid' do
+      let(:errors) { instance_double('ActiveModel::Errors') }
+
+      before do
+        allow(validator).to receive(:valid?).and_return false
+        allow(validator).to receive(:errors).and_return(errors)
+        allow(errors).to receive(:messages)
+      end
+
+      it 'should raise a Arpa::Exceptions::RecordInvalid with :errors of ActiveModel::Errors' do
+        expect { profile_created }.to raise_error { |error|
+          expect(error).to be_a Arpa::Exceptions::RecordInvalid
+          expect(error.errors).not_to be_nil
+        }
+      end
+
+    end
+
+    context 'when profile is valid' do
+      let(:creator_repo_class) { Arpa::Repositories::Profiles::Creator }
+      let(:creator_repo)       { instance_double creator_repo_class }
+
+      before do
+        allow(validator).to receive(:valid?).and_return true
+        allow(creator_repo_class).to receive(:new).and_return(creator_repo)
+        allow(creator_repo).to receive(:create).with(profile)
+        profile_created
+      end
+
+      it 'creator repository should call :new' do
+        expect(creator_repo_class).to have_received(:new)
+      end
+
+      it 'creator_repo should call create method with profile as parameter' do
+        expect(creator_repo).to have_received(:create).with(profile).once
+      end
+
+      context 'when build the profile' do
+
+        it 'entity profile should call new method' do
+          expect(profile_entity_class).to have_received(:new).once
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/ar/services/profiles/profile_manager_creator_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Arpa::Services::Profiles::ProfileManagerCreator, type: :service, fast: true do
+
+  let(:profile_creator) { double }
+  let(:params)          { {profile: {name: 'profile_name', description: 'profile_description', role_ids: [1, 2]}} }
+  let(:success_proc)    { ->(r) {} }
+  let(:callback)        { {success: success_proc, fail: ->(e) {raise e} } }
+
+  let(:setup_creators) do
+    allow(Arpa::Services::Profiles::Create::ProfileCreator).to receive(:new).and_return(profile_creator)
+  end
+
+  let(:setup_creators_methods) do
+    allow(profile_creator).to receive(:create)
+  end
+
+  let(:result) { subject.create params, callback }
+
+  before do
+    setup_creators
+    setup_creators_methods
+    allow(success_proc).to receive(:call)
+    result
+  end
+
+  it 'profile_creator should call :create with parameters' do
+    expect(profile_creator).to have_received(:create).with(params[:profile]).once
+  end
+
+end

data/spec/lib/ar/services/profiles/profile_manager_remover_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Arpa::Services::Profiles::ProfileManagerRemover, type: :service, fast: true do
+
+  let(:profile_remover) { double }
+  let(:profile)         { double }
+  let(:success_proc)    { ->(r) {} }
+  let(:callback)        { {success: success_proc, fail: ->(e) {raise e} } }
+
+  let(:setup_updaters) do
+    allow(Arpa::Services::Profiles::Remove::ProfileRemover).to receive(:new).and_return(profile_remover)
+  end
+
+  let(:setup_updaters_methods) do
+    allow(profile_remover).to receive(:remove)
+  end
+
+  let(:result) { subject.remove params, callback }
+
+  before do
+    setup_updaters
+    setup_updaters_methods
+    allow(success_proc).to receive(:call)
+    result
+  end
+
+  context 'when is to destroy' do
+    let(:params) { {profile: profile} }
+
+    it 'profile_remover should call :remove with profile as parameter' do
+      expect(profile_remover).to have_received(:remove).with(profile, nil).once
+    end
+  end
+
+  context 'when is to disable' do
+    let(:params) { {profile: profile, disable: true} }
+
+    it 'profile_remover should call :remove with profile and disable: true as parameter' do
+      expect(profile_remover).to have_received(:remove).with(profile, true).once
+    end
+
+  end
+
+end