arpa 0.0.2

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Arpa::Services::Profiles::ProfileManagerUpdater, type: :service, fast: true do
+
+  let(:profile_updater) { 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_updaters) do
+    allow(Arpa::Services::Profiles::Update::ProfileUpdater).to receive(:new).and_return(profile_updater)
+  end
+
+  let(:setup_updaters_methods) do
+    allow(profile_updater).to receive(:update)
+  end
+
+  let(:result) { subject.update params, callback }
+
+  before do
+    setup_updaters
+    setup_updaters_methods
+    allow(success_proc).to receive(:call)
+    result
+  end
+
+  it 'profile_updater should call :update with parameters' do
+    expect(profile_updater).to have_received(:update).with(params[:profile]).once
+  end
+
+end

data/spec/lib/ar/services/profiles/remove/profile_remover_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Arpa::Services::Profiles::Remove::ProfileRemover, type: :service, fast: true do
+
+  let(:profile) { double }
+
+  describe 'removing profile' do
+    let(:remover_repo_class) { Arpa::Repositories::Profiles::Remover }
+    let(:remover_repo)       { instance_double remover_repo_class }
+
+    before do
+      allow(remover_repo_class).to receive(:new).and_return(remover_repo)
+      setup
+      subject.remove(profile, disable)
+    end
+
+    context 'when pass nil as disable param' do
+      let(:disable) { nil }
+
+      let(:setup) { allow(remover_repo).to receive(:destroy) }
+
+      it 'remover repository should call :destroy once' do
+        expect(remover_repo).to have_received(:destroy).once
+      end
+
+      it 'remover repository should call :new once' do
+        expect(remover_repo_class).to have_received(:new).once
+      end
+
+    end
+
+    context 'when pass true as disable param' do
+      let(:disable) { true }
+
+      let(:setup) { allow(remover_repo).to receive(:disable) }
+
+      it 'remover repository should call :disable once' do
+        expect(remover_repo).to have_received(:disable).once
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/ar/services/profiles/update/profile_updater_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Arpa::Services::Profiles::Update::ProfileUpdater, type: :service, fast: true do
+
+  let(:role_entity_class) { Arpa::Entities::Profile }
+  let(:profile)           { double }
+  let(:params)            { double }
+
+  let(:profile_updated) { subject.update(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(role_entity_class).to receive(:new).and_return(profile)
+  end
+
+  describe 'updating a 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_updated }.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(:updater_repo_class) { Arpa::Repositories::Profiles::Updater }
+      let(:updater_repo)       { instance_double updater_repo_class }
+
+      before do
+        allow(validator).to receive(:valid?).and_return true
+        allow(updater_repo_class).to receive(:new).and_return(updater_repo)
+        allow(updater_repo).to receive(:update).with(profile)
+        profile_updated
+      end
+
+      it 'updater repository should call :new' do
+        expect(updater_repo_class).to have_received(:new)
+      end
+
+      it 'updater_repo should call update method with profile as parameter' do
+        expect(updater_repo).to have_received(:update).with(profile).once
+      end
+
+      context 'when build the profile' do
+
+        it 'entity profile should call new method' do
+          expect(role_entity_class).to have_received(:new).once
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/ar/services/resources/create/resource_creator_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Arpa::Services::Resources::Create::ResourceCreator, type: :service, fast: true do
+
+  let(:resource_entity_class) { Arpa::Entities::Resource }
+  let(:resource)              { double full_name: 'UsersController' }
+  let(:resourceable)          { double }
+  let(:resource_found)        { nil }
+
+  let(:resource_created) { subject.create(resourceable) }
+  let(:validator_class)  { Arpa::Validators::ResourceValidator }
+  let(:validator)        { instance_double validator_class }
+
+  let(:finder_repo_class) { Arpa::Repositories::Resources::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_full_name).with(kind_of(String)).and_return(resource_found)
+
+    allow(validator_class).to receive(:new).with(resource).and_return(validator)
+    allow(resource_entity_class).to receive(:new).and_return(resource)
+    allow(resource).to receive(:build_correct_name)
+  end
+
+  describe 'creating a new resource' 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 { resource_created }.to raise_error { |error|
+          expect(error).to be_a Arpa::Exceptions::RecordInvalid
+          expect(error.errors).not_to be_nil
+        }
+      end
+
+    end
+
+    context 'when resouce already exists' do
+      let(:resource_found) { double }
+
+      it 'should return the resource found' do
+        expect(resource_created).to eq resource_found
+      end
+    end
+
+    context 'when resource is valid' do
+      let(:creator_repo_class) { Arpa::Repositories::Resources::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(resource)
+        resource_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 resource as parameter' do
+        expect(creator_repo).to have_received(:create).with(resource).once
+      end
+
+      context 'when build the resource with resourceable' do
+
+        it 'entity resource should call new method' do
+          expect(resource_entity_class).to have_received(:new).once
+        end
+
+        it 'resource instance should call build_correct_name method' do
+          expect(resource).to have_received(:build_correct_name).once
+        end
+      end
+
+    end
+
+  end
+end

data/spec/lib/ar/services/resources/remove/resource_remover_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Arpa::Services::Resources::Remove::ResourceRemover, type: :service, fast: true do
+
+  let(:resource_001) { double full_name: 'UsersController' }
+  let(:resource_002) { double full_name: 'OldContactsController' }
+  let(:resources)    { [resource_001, resource_002]}
+
+  let(:resourceable_001) { double to_s: 'UsersController' }
+  let(:resourceable_002) { double to_s: 'ContactsController' }
+  let(:resourceables)    { [resourceable_001, resourceable_002]}
+
+  describe 'removing nonexistent resources' do
+
+    let(:finder_repo_class) { Arpa::Repositories::Resources::Finder }
+    let(:finder_repo)       { instance_double finder_repo_class }
+
+    let(:remover_repo_class) { Arpa::Repositories::Resources::Remover }
+    let(:remover_repo)       { instance_double remover_repo_class }
+
+    before do
+      allow(finder_repo_class).to receive(:new).and_return(finder_repo)
+      allow(finder_repo).to receive(:all).and_return(resources)
+
+      allow(remover_repo_class).to receive(:new).and_return(remover_repo)
+      allow(remover_repo).to receive(:destroy).with(resource_002)
+
+      subject.remove_nonexistent_resources(resourceables)
+    end
+
+    it 'finder repository should call :new once' do
+      expect(finder_repo_class).to have_received(:new).once
+    end
+
+    it 'remover repository should call :new once' do
+      expect(remover_repo_class).to have_received(:new).once
+    end
+
+    it 'finder repository should call :all once' do
+      expect(finder_repo).to have_received(:all).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(resource_002).once
+    end
+
+  end
+
+end

data/spec/lib/ar/services/resources/resource_manager_creator_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Arpa::Services::Resources::ResourceManagerCreator, type: :service, fast: true do
+
+  let(:action_remover)   { double }
+  let(:resource_remover) { double }
+  let(:resource_creator) { double }
+  let(:action_creator)   { double }
+  let(:element)          { double }
+  let(:resourceables)    { [resourceable_001, resourceable_002] }
+  let(:params)           { {resourceables: resourceables} }
+  let(:success_proc)     { ->(r) {} }
+  let(:callback)         { {success: success_proc, fail: ->(e) {raise e} } }
+
+  let(:resourceable_001) { double action_methods: [] }
+  let(:resourceable_002) { double action_methods: []}
+  let(:resource_created) { double }
+
+  let(:setup_creators) do
+    allow(Arpa::Services::Resources::Create::ResourceCreator).to receive(:new).and_return(resource_creator)
+    allow(Arpa::Services::Actions::Create::ActionCreator).to receive(:new).and_return(action_creator)
+  end
+
+  let(:setup_removers) do
+    allow(Arpa::Services::Resources::Remove::ResourceRemover).to receive(:new).and_return(resource_remover)
+    allow(Arpa::Services::Actions::Remove::ActionRemover).to receive(:new).and_return(action_remover)
+  end
+
+  let(:setup_creators_methods) do
+    allow(resource_creator).to receive(:create).and_return(resource_created)
+    allow(action_creator).to receive(:create_many)
+  end
+
+  let(:setup_removers_methods) do
+    allow(resource_remover).to receive(:remove_nonexistent_resources)
+    allow(action_remover).to receive(:remove_nonexistent_actions)
+  end
+
+  let(:result) { subject.create params, callback }
+
+  before do
+    setup_creators
+    setup_creators_methods
+    setup_removers
+    setup_removers_methods
+    allow(success_proc).to receive(:call)
+    result
+  end
+
+  it 'resource_remover should call :remove_nonexistent_resources with :resourceables as parameter' do
+    expect(resource_remover).to have_received(:remove_nonexistent_resources).with(resourceables).once
+  end
+
+  it 'action_remover should call :remove_nonexistent_actions with :action_params as parameter' do
+    expect(action_remover).to have_received(:remove_nonexistent_actions).with({resource: resource_created, actions_names: []}).twice
+  end
+
+  it 'resource_creator should call :create with :resourceable as parameter' do
+    expect(resource_creator).to have_received(:create).with(resourceable_001).once
+    expect(resource_creator).to have_received(:create).with(resourceable_002).once
+  end
+
+  it 'action_creator should call :create_many with :action_params as parameter' do
+    expect(action_creator).to have_received(:create_many).with({resource: resource_created, actions_names: []}).twice
+  end
+
+  it 'success callback should be called with Array of resources as parameter' do
+    expect(success_proc).to have_received(:call).with([resource_created, resource_created])
+  end
+
+end

data/spec/lib/ar/services/roles/create/role_creator_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Arpa::Services::Roles::Create::RoleCreator, type: :service, fast: true do
+
+  let(:role_entity_class) { Arpa::Entities::Role }
+  let(:role)              { double }
+  let(:params)            { double }
+
+  let(:role_created) { subject.create(params) }
+  let(:validator_class)  { Arpa::Validators::RoleValidator }
+  let(:validator)        { instance_double validator_class }
+
+  before do
+    allow(validator_class).to receive(:new).and_return(validator)
+    allow(role_entity_class).to receive(:new).and_return(role)
+  end
+
+  describe 'creating a new role' do
+
+    context 'when role 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 { role_created }.to raise_error { |error|
+          expect(error).to be_a Arpa::Exceptions::RecordInvalid
+          expect(error.errors).not_to be_nil
+        }
+      end
+
+    end
+
+    context 'when role is valid' do
+      let(:creator_repo_class) { Arpa::Repositories::Roles::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(role)
+        role_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 role as parameter' do
+        expect(creator_repo).to have_received(:create).with(role).once
+      end
+
+      context 'when build the role' do
+
+        it 'entity role should call new method' do
+          expect(role_entity_class).to have_received(:new).once
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/ar/services/roles/remove/role_remover_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Arpa::Services::Roles::Remove::RoleRemover, type: :service, fast: true do
+
+  let(:role) { double }
+
+  describe 'removing role' do
+    let(:remover_repo_class) { Arpa::Repositories::Roles::Remover }
+    let(:remover_repo)       { instance_double remover_repo_class }
+    let(:setup)              {  }
+
+    before do
+      allow(remover_repo_class).to receive(:new).and_return(remover_repo)
+      setup
+      subject.remove(role)
+    end
+
+    context 'when role has no profiles' do
+
+      let(:setup) do
+        allow(role).to receive(:has_profile?).and_return(false)
+        allow(remover_repo).to receive(:destroy)
+      end
+
+      it 'remover repository should call :destroy once' do
+        expect(remover_repo).to have_received(:destroy).once
+      end
+
+      it 'remover repository should call :new once' do
+        expect(remover_repo_class).to have_received(:new).once
+      end
+
+    end
+
+    context 'when role has profiles' do
+
+      let(:setup) do
+        allow(role).to receive(:has_profile?).and_return(true)
+        allow(remover_repo).to receive(:disable)
+      end
+
+      it 'remover repository should call :disable once' do
+        expect(remover_repo).to have_received(:disable).once
+      end
+
+    end
+
+  end
+
+end