arpa 0.0.2

data/spec/factories/repository_actions.rb

@@ -0,0 +1,19 @@
+FactoryGirl.define do
+  factory :repository_action, class: Arpa::Repositories::Actions::RepositoryAction do
+
+    trait :index do
+      name 'index'
+      resource { FactoryGirl.create(:repository_resource, :user) }
+    end
+
+    trait :show do
+      name 'show'
+      resource { FactoryGirl.create(:repository_resource, :user) }
+    end
+
+    trait :with_complete_association do
+      name 'index_new'
+      resource { FactoryGirl.create(:repository_resource, :user) }
+    end
+  end
+end

data/spec/factories/repository_profiles.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :repository_profile, class: Arpa::Repositories::Profiles::RepositoryProfile do
+
+    name        'some_profile'
+    description 'description_profile'
+
+    trait :with_complete_association do
+      roles { [FactoryGirl.create(:repository_role, :with_complete_association)] }
+    end
+  end
+end

data/spec/factories/repository_resources.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+  factory :repository_resource, class: Arpa::Repositories::Resources::RepositoryResource do
+
+    trait :user do
+      full_name 'UsersController'
+      name      'users'
+    end
+
+    trait :contact do
+      full_name 'ContactsController'
+      name      'contacts'
+    end
+
+  end
+end

data/spec/factories/repository_roles.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :repository_role, class: Arpa::Repositories::Roles::RepositoryRole do
+
+    name        'some_role'
+    description 'description_role'
+
+    trait :with_complete_association do
+      actions {[FactoryGirl.create(:repository_action, :with_complete_association)] }
+    end
+  end
+end

data/spec/lib/ar/additions/resource_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class ResourceImplementation
+  def self.helper_method(args);end
+  include Arpa::Additions::Resource
+  def session;'';end
+  def current_user;'';end
+end
+
+describe Arpa::Additions::Resource, type: :addition, fast: true do
+
+  let(:resource_implementation) { ResourceImplementation.new }
+
+  describe '#has_access?' do
+    let(:verifier) { double }
+    let(:resource) { double }
+    let(:action)   { double }
+
+    before do
+      allow(Arpa::Services::Verifier).to receive(:new).and_return(verifier)
+      allow(verifier).to receive(:has_access?)
+      resource_implementation.has_access?(resource, action)
+    end
+
+    it 'should call :new from Arpa::Services::Verifier' do
+      expect(Arpa::Services::Verifier).to have_received(:new).once
+    end
+
+    it 'verifier should call :has_access? with resource and action as parameter' do
+      expect(verifier).to have_received(:has_access?).with(resource, action).once
+    end
+  end
+
+end

data/spec/lib/ar/data_mappers/action_mapper_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Arpa::DataMappers::ActionMapper, type: :mapper, fast: true do
+  let(:mapper) { Arpa::DataMappers::ActionMapper.instance }
+
+  describe 'mapping to record instance' do
+    let(:entity)          { Arpa::Entities::Action.new(name: 'index', resource_id: 1)}
+    let(:record_instance) { mapper.map_to_record(entity) }
+
+    it 'record_instance should be an instance of ActiveRecord::Base' do
+      expect(record_instance).to be_a ActiveRecord::Base
+    end
+
+    it 'record_instance should fill the property :name from entity property' do
+      expect(record_instance.name).to eql 'index'
+    end
+
+    it 'record_instance should fill the property :resource_id and :repository_resource_id from entity property' do
+      expect(record_instance.resource_id).to be == 1
+      expect(record_instance.repository_resource_id).to be == 1
+    end
+
+  end
+
+  describe 'mapping to entity instance' do
+    let(:record)          { create :repository_action, :index }
+    let(:entity_instance) { mapper.map_to_entity(record) }
+
+    it 'entity_instance should fill the property :name from record property' do
+      expect(entity_instance.name).to eql 'index'
+    end
+
+    it 'entity_instance should fill the property :id from record property' do
+      expect(entity_instance.id).to be == record.id
+    end
+
+    it 'entity_instance should fill the property :resource_id from record property' do
+      expect(entity_instance.resource_id).to be == record.resource_id
+    end
+
+    it 'entity_instance should fill the property :resource from record property' do
+      expect(entity_instance.resource).to be_an Arpa::Entities::Resource
+    end
+  end
+
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class TestMapper < Arpa::DataMappers::Base
+  entity_class 'TestRepository'
+  repository_class 'TestRepository'
+  attributes_to_map :id, :name
+end
+
+describe Arpa::DataMappers::Base, type: :mapper, fast: true do
+  let(:mapper) { TestMapper.instance }
+
+  context 'when initialize more than one Mapper' do
+
+    let(:mapper_002) { TestMapper.instance }
+
+    it 'the instances should use singleton pattern' do
+      expect(mapper).to eq mapper_002
+    end
+  end
+
+  describe 'mapping to record instance' do
+    let(:entity)           { double id: nil, name: 'Some Name' }
+    let(:record_instance)  { mapper.map_to_record(entity) }
+
+    it 'record_instance should be an instance of ActiveRecord::Base' do
+      expect(record_instance).to be_a ActiveRecord::Base
+    end
+
+    it 'record_instance should fill the property :name from entity property' do
+      expect(record_instance.name).to eql 'Some Name'
+    end
+  end
+
+  describe 'mapping to entity instance' do
+    let(:record)          { TestRepository.create(name: 'Name One') }
+    let(:entity_instance) { mapper.map_to_entity(record) }
+
+    it 'entity_instance should fill the property :name from record property' do
+      expect(entity_instance.name).to eql 'Name One'
+    end
+
+    it 'entity_instance should fill the property :id from record property' do
+      expect(entity_instance.id).to be == record.id
+    end
+  end
+
+end

data/spec/lib/ar/data_mappers/profile_mapper_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Arpa::DataMappers::ProfileMapper, type: :mapper, fast: true do
+  let(:mapper) { Arpa::DataMappers::ProfileMapper.instance }
+
+  describe 'mapping to record instance' do
+    let(:entity)          { Arpa::Entities::Profile.new(name: 'some_profile')}
+    let(:record_instance) { mapper.map_to_record(entity) }
+
+    it 'record_instance should be an instance of Arpa::Repositories::Profiles::RepositoryProfile' do
+      expect(record_instance).to be_a Arpa::Repositories::Profiles::RepositoryProfile
+    end
+
+    it 'record_instance should fill the property :name from entity property' do
+      expect(record_instance.name).to eql 'some_profile'
+    end
+  end
+
+  describe 'mapping to entity instance' do
+    let(:action_record)   { create :repository_action, :index }
+    let(:role_record)     { create :repository_role, action_ids: [action_record.id] }
+    let(:record)          { create :repository_profile, role_ids: [role_record.id] }
+    let(:entity_instance) { mapper.map_to_entity(record) }
+
+    it 'entity_instance should fill the property :name from record property' do
+      expect(entity_instance.name).to eql 'some_profile'
+    end
+
+    it 'entity_instance should fill the property :id from record property' do
+      expect(entity_instance.id).to be == record.id
+    end
+
+    it 'entity_instance should fill the property :roles from record property' do
+      expect(entity_instance.roles.first).to be_an Arpa::Entities::Role
+    end
+
+    it 'entity_instance should fill the property :role_ids from record property' do
+      expect(entity_instance.role_ids).to eq [role_record.id]
+    end
+
+  end
+
+end

data/spec/lib/ar/data_mappers/resource_mapper_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Arpa::DataMappers::ResourceMapper, type: :mapper, fast: true do
+  let(:mapper) { Arpa::DataMappers::ResourceMapper.instance }
+
+  describe 'mapping to record instance' do
+    let(:entity)          { Arpa::Entities::Resource.new(full_name: 'UsersController')}
+    let(:record_instance) { mapper.map_to_record(entity) }
+
+    it 'record_instance should be an instance of ActiveRecord::Base' do
+      expect(record_instance).to be_a ActiveRecord::Base
+    end
+
+    it 'record_instance should fill the property :name from entity property' do
+      expect(record_instance.full_name).to eql 'UsersController'
+    end
+  end
+
+  describe 'mapping to entity instance' do
+    let(:action_record)   { create :repository_action, :index }
+    let(:record)          { create :repository_resource, :user, actions: [action_record] }
+    let(:entity_instance) { mapper.map_to_entity(record.reload) }
+
+    it 'entity_instance should fill the property :name from record property' do
+      expect(entity_instance.full_name).to eql 'UsersController'
+    end
+
+    it 'entity_instance should fill the property :id from record property' do
+      expect(entity_instance.id).to be == record.id
+    end
+
+    it 'entity_instance should fill the property :actions from record property' do
+      expect(entity_instance.actions.first).to be_an Arpa::Entities::Action
+    end
+
+  end
+
+end

data/spec/lib/ar/data_mappers/role_mapper_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Arpa::DataMappers::RoleMapper, type: :mapper, fast: true do
+  let(:mapper) { Arpa::DataMappers::RoleMapper.instance }
+
+  describe 'mapping to record instance' do
+    let(:entity)          { Arpa::Entities::Role.new(name: 'some_role')}
+    let(:record_instance) { mapper.map_to_record(entity) }
+
+    it 'record_instance should be an instance of Arpa::Repositories::Roles::RepositoryRole' do
+      expect(record_instance).to be_a Arpa::Repositories::Roles::RepositoryRole
+    end
+
+    it 'record_instance should fill the property :name from entity property' do
+      expect(record_instance.name).to eql 'some_role'
+    end
+  end
+
+  describe 'mapping to entity instance' do
+    let(:action_record)   { create :repository_action, :index }
+    let(:profile_record)  { create :repository_profile }
+    let(:record)          { create :repository_role, profile_ids: [profile_record.id], action_ids: [action_record.id] }
+    let(:entity_instance) { mapper.map_to_entity(record) }
+
+    it 'entity_instance should fill the property :name from record property' do
+      expect(entity_instance.name).to eql 'some_role'
+    end
+
+    it 'entity_instance should fill the property :id from record property' do
+      expect(entity_instance.id).to be == record.id
+    end
+
+    it 'entity_instance should fill the property :actions from record property' do
+      expect(entity_instance.actions.first).to be_an Arpa::Entities::Action
+    end
+
+    it 'entity_instance should fill the property :action_ids from record property' do
+      expect(entity_instance.action_ids).to eq [action_record.id]
+    end
+
+    it 'entity_instance should fill the property :profiles from record property' do
+      expect(entity_instance.profiles.first).to be_an Arpa::Entities::Profile
+    end
+
+  end
+
+end

data/spec/lib/ar/entities/action_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Arpa::Entities::Action, type: :entity, fast: true do
+  let(:resource) { double(name: 'users') }
+
+  subject { Arpa::Entities::Action.new resource: resource, name: 'index'}
+
+  describe 'getting description by action name and resource name' do
+
+    context 'when resource.name is "users" and action.name is "index"' do
+
+      it 'description should be "List of Users"' do
+        expect(subject.description).to eql "List of Users"
+      end
+    end
+
+  end
+
+end

data/spec/lib/ar/entities/permissions_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Arpa::Entities::Permissions, type: :presenter, fast: true do
+  let(:index_action) { double name: 'index_new' }
+  let(:resource_001) { double name: 'users', actions: [index_action] }
+  let(:resource_002) { double name: 'users', actions: [index_action] }
+  let(:resources)    { [resource_001, resource_002] }
+
+  subject { Arpa::Entities::Permissions.new(resources)}
+
+  describe 'intializing' do
+    let(:result) { subject.permissions }
+
+    it 'attr :permissions should be an Array' do
+      expect(result).to be_an Array
+    end
+
+    it 'should fill attr :permissions as an Array of Hash with keys :resource and :action' do
+      first = result.first
+
+      expect(first).to be_a Hash
+      expect(first.has_key?('resource')).to be_truthy
+      expect(first.has_key?('action')).to be_truthy
+    end
+
+    context 'when try fill permissions with duplicate resource and action' do
+      let(:hash_permission) { {'resource' => 'users', 'action' => 'index_new' } }
+
+      it 'should has only one Hash with that duplicated resource and action' do
+        duplicated_hash_permission = result.detect{ |e| result.count(e) > 1 }
+        expect(duplicated_hash_permission).to be_nil
+      end
+    end
+
+  end
+
+  describe '#has_permission?' do
+    let(:resource_name) { 'users' }
+    let(:result) { subject.has_permission?(resource_name, action_name) }
+
+    context 'when has' do
+      let(:action_name) { 'index_new' }
+
+      it 'should return true' do
+        expect(result).to be_truthy
+      end
+
+    end
+
+    context 'when has not' do
+      let(:action_name) { 'index' }
+
+      it 'should return false' do
+        expect(result).to be_falsey
+      end
+
+    end
+  end
+
+end
+

data/spec/lib/ar/entities/resource_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Arpa::Entities::Resource, type: :entity, fast: true do
+
+  describe '#build_correct_name' do
+
+    before { subject.build_correct_name }
+
+    context 'when pass :full_name as "UsersController"' do
+      subject { Arpa::Entities::Resource.new full_name: 'UsersController' }
+
+      it 'full_name should be "UsersController"' do
+        expect(subject.full_name).to eql 'UsersController'
+      end
+
+      it 'name should be builded as "users"' do
+        expect(subject.name).to eql 'users'
+      end
+    end
+
+    context 'when pass :full_name as "Authentication::Someone::UsersController"' do
+      subject { Arpa::Entities::Resource.new full_name: 'Authentication::Someone::UsersController' }
+
+      it 'full_name should be "Authentication::Someone::UsersController"' do
+        expect(subject.full_name).to eql 'Authentication::Someone::UsersController'
+      end
+
+      it 'name should be builded as "authentication/someone/users"' do
+        expect(subject.name).to eql 'authentication/someone/users'
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Arpa::Repositories::Actions::Finder, type: :repository, slow: true do
+
+  let(:resource_record)   { create :repository_resource, :user }
+  let(:action_record_001) { create :repository_action, :index, resource: resource_record }
+  let(:action_record_002) { create :repository_action, :show, resource: resource_record}
+
+  before do
+    action_record_001
+    action_record_002
+  end
+
+  describe '#by_name_and_resource' do
+
+    context 'when exist with the params' do
+
+      let(:result) { subject.by_name_and_resource('index', resource_record) }
+
+      it 'should return a resource with name "index"' do
+        expect(result.name).to eql 'index'
+      end
+
+      it 'the result should be an instance of Arpa::Entities::Action' do
+        expect(result).to be_an Arpa::Entities::Action
+      end
+    end
+
+    context 'when nonexist with the params' do
+
+      let(:result) { subject.by_name_and_resource('nonexist_action', resource_record) }
+
+      it 'the result should return nil' do
+        expect(result).to be_nil
+      end
+    end
+
+  end
+
+end