skill_tree 0.0.1

data/spec/skill_tree/models/acl_ownership_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe SkillTree::Models::AclOwnership, type: :model do
+  it 'belongs to an acl' do
+    expect(subject).to be_respond_to(:acl)
+  end
+
+  it 'validates presence of acl' do
+    expect(subject).to have(1).error_on(:acl)
+    subject.acl = build(:acl)
+    expect(subject).to have(0).error_on(:acl)
+  end
+
+  it 'belongs to a resource' do
+    expect(subject).to be_respond_to(:resource)
+  end
+
+  it 'resource is polymorphic' do
+    subject.resource = User.new
+    subject.resource = Post.new
+  end
+
+  it 'resource is unique' do
+    resource = Post.create!
+    acl = create(:acl, name: 'some_name', version: 0)
+    described_class.create!(resource: resource, acl: acl)
+    subject.resource = User.new
+    subject.resource = Post.new
+  end
+end

data/spec/skill_tree/models/acl_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe SkillTree::Models::Acl, type: :model do
+  it 'validates name presence' do
+    expect(subject).to have(1).error_on(:name)
+    subject.name = 'my_name'
+    expect(subject).to have(0).error_on(:name)
+  end
+
+  it 'validates name uniqueness' do
+    create(:acl, name: 'my_name', version: 0)
+    subject.name = 'my_name'
+    expect(subject).to have(1).error_on(:name)
+  end
+
+  it 'has many roles' do
+    expect(subject).to be_respond_to(:roles)
+    expect(subject.roles.model.name).to eq('SkillTree::Models::Role')
+  end
+
+  it 'has many acl_mappings' do
+    expect(subject).to be_respond_to(:acl_mappings)
+    expect(subject.acl_mappings.model.name).to eq(
+      'SkillTree::Models::AclMapping')
+  end
+
+  it 'has many acl_ownerships' do
+    expect(subject).to be_respond_to(:acl_ownerships)
+    expect(subject.acl_ownerships.model.name).to eq(
+      'SkillTree::Models::AclOwnership')
+  end
+end

data/spec/skill_tree/models/permission_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe SkillTree::Models::Permission, type: :model do
+  it 'validates name presence' do
+    expect(subject).to have(1).error_on(:name)
+    subject.name = 'my_name'
+    expect(subject).to have(0).error_on(:name)
+  end
+
+  it 'validates name uniqueness' do
+    subject.name = 'my_name'
+    expect(subject).to have(0).error_on(:name)
+    create(:permission, name: 'my_name')
+    expect(subject).to have(1).error_on(:name)
+  end
+end

data/spec/skill_tree/models/role_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe SkillTree::Models::Role, type: :model do
+  it 'validates name presence' do
+    expect(subject).to have(1).error_on(:name)
+    subject.name = 'my_name'
+    expect(subject).to have(0).error_on(:name)
+  end
+
+  it 'validates name uniqueness' do
+    create(:role, name: 'my_name')
+    subject.name = 'my_name'
+    expect(subject).to have(1).error_on(:name)
+  end
+
+  describe '#find_for' do
+    before(:each) do
+      stub_const('Rails', double(root: double))
+      allow(Rails.root).to receive(:join)
+        .and_return('spec/support/acls/subject_acl.rb')
+
+      SkillTree::Parser::Initializer.parse!
+    end
+    let(:user) { User.create! }
+    let(:resource) { Post.create! }
+    it 'finds the current role of an user given a resource' do
+      expect(role_for(nil, resource)).to eq('guest')
+      expect(role_for(user, resource)).to eq('user')
+      user.role! :editor, resource
+      expect(role_for(user, resource)).to eq('editor')
+      user.role! :admin, resource
+      expect(role_for(user, resource)).to eq('admin')
+      user.unrole! :admin, resource
+      expect(role_for(user, resource)).to eq('user')
+    end
+
+    def role_for(user, resource)
+      described_class.find_for(user, resource).name
+    end
+  end
+end

data/spec/skill_tree/models/user_role_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe SkillTree::Models::UserRole, type: :model do
+  it 'users can\'t have duplicate roles for the same resource' do
+    user = User.create!
+    resource = Post.create!
+    role = create(:role, name: 'name')
+
+    create(:user_role, role: role, user: user, resource: resource)
+
+    subject.assign_attributes(role: role, user: user, resource: resource)
+    expect(subject).to have(1).error_on(:user_id)
+    subject.user = nil
+    expect(subject).to have(0).error_on(:user_id)
+  end
+end

data/spec/skill_tree/parser_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe SkillTree::Parser::Initializer do
+  before(:each) do
+    stub_const('Rails', double(root: double))
+    allow(Rails.root).to receive(:join) { |param| param }
+  end
+
+  describe '#parse!' do
+    it 'calls setup' do
+      expect_any_instance_of(described_class).to receive(:setup)
+      described_class.parse!
+    end
+  end
+
+  describe '#setup' do
+    let(:roles) { %w(guest user editor admin) }
+    let(:more_roles) { %w(guest user editor admin master) }
+    let(:permissions) { %w(read create write update delete) }
+
+    it 'parses the acl file updating the model' do
+      subject.setup 'spec/support/acls/acl_example.rb'
+      acl = SkillTree::Models::Acl.find_by(name: 'desks')
+      expect(acl.roles.count).to eq(4)
+      expect(SkillTree::Models::Role.where(name: roles).count).to eq(roles.count)
+      expect(acl.roles.count).to eq(4)
+      expect(permission(acl, 'guest', 'read')).to be_any
+      expect(permission(acl, 'guest', 'write')).not_to be_any
+      expect(permission(acl, 'admin', 'destroy')).to be_any
+    end
+
+    it 'parses files additively' do
+      subject.setup 'spec/support/acls/acl_example.rb'
+      subject.setup 'spec/support/acls/acl_example2.rb'
+      acl = SkillTree::Models::Acl.find_by(name: 'desks')
+      model_roles = SkillTree::Models::Role.where(name: roles)
+      expect(model_roles.count).to eq(roles.count)
+      expect(acl.roles.count).to eq(5)
+
+      expect(permission(acl, 'admin', 'read')).to be_any
+      expect(permission(acl, 'master', 'destroy')).to be_any
+      expect(permission(acl, 'admin', 'destroy')).not_to be_any
+    end
+
+    describe 'versioning:' do
+      before { subject.setup 'spec/support/acls/acl_example3.rb' }
+      it 'when the version is identical, changes nothing' do
+        expect_any_instance_of(SkillTree::Models::Acl).not_to receive(:save!)
+        subject.setup 'spec/support/acls/acl_example3.rb'
+      end
+      it 'when the version changes, recomputes everything' do
+        expect_any_instance_of(SkillTree::Models::Acl).to receive(:save!)
+          .and_call_original
+        subject.setup 'spec/support/acls/acl_example4.rb'
+        expect(SkillTree::Models::Acl.first.version).to eq(2)
+      end
+    end
+  end
+
+  def permission(acl, role, permission)
+    acl = SkillTree::Models::Acl.find_by(name: acl) if acl.is_a? String
+    role = SkillTree::Models::Role.find_by(name: role) if role.is_a? String
+    permission = SkillTree::Models::Permission
+                 .find_by(name: permission) if permission.is_a? String
+    SkillTree::Models::AclMapping.where(
+      role: role,
+      acl: acl,
+      permission: permission
+    )
+  end
+end

data/spec/skill_tree/resource_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe SkillTree::Resource do
+  before(:each) do
+    stub_const('Rails', double(root: double))
+    allow(Rails.root).to receive(:join)
+      .and_return('spec/support/acls/subject_acl.rb')
+
+    SkillTree::Parser::Initializer.parse!
+  end
+
+  let(:private_acl) { SkillTree::Models::Acl.find_by(name: 'private_post') }
+  let(:user) { User.create! }
+  let(:any_user) { User.create! }
+
+  subject { Post.create! }
+
+  it 'has a default acl' do
+    expect(subject.acl).not_to be_nil
+    expect(subject.acls.first).to eq(subject.acl)
+  end
+
+  it 'assigns no acl if there\'s none' do
+    allow(SkillTree::Parser::Initializer).to receive(:default_acl_for)
+      .and_return(nil)
+    expect(subject.acl).to be_nil
+    expect(subject.acl_ownerships).to be_empty
+  end
+
+  it 'sets up admin automatically if defined' do
+    expect do
+      subject = PostWithAuthor.create!(user: user)
+      expect(user).to have_role :admin, subject
+    end.to change(SkillTree::Models::UserRole, :count).by(1)
+  end
+
+  it 'can\'t assign a new acl' do
+    expect do
+      subject.update(acl: private_acl)
+    end.to raise_error SkillTree::AclAlreadySet
+  end
+
+  it '#default_permission?' do
+    expect(subject).to have_default_permission(:read)
+    expect(subject).to have_default_permission(:create)
+    expect(subject).not_to have_default_permission(:write)
+    expect(subject).to have_default_permission(:read, :guest)
+    expect(subject).not_to have_default_permission(:create, :guest)
+  end
+
+  describe '#acl!' do
+    it 'can change his acl, keeping all roles' do
+      user.role! :editor, subject
+      expect(user).to be_allowed_to :write, subject
+      expect(user).not_to be_allowed_to :update, subject
+      subject.acl! private_acl
+      expect(user).to have_role :editor, subject
+      expect(user).to be_allowed_to :update, subject
+      expect(user).not_to be_allowed_to :destroy, subject
+    end
+
+    it 'accepts both symbols and strings' do
+      subject.acl! :private_post
+      subject.acl! 'private_post'
+    end
+  end
+
+  describe '#where_user_can' do
+    it 'selector for guest' do
+      expect(Post.where_user_can(nil, :read)).to include(subject)
+      expect(Post.where_user_can(nil, :create)).not_to include(subject)
+      expect(Post.where_user_can(nil, :write)).not_to include(subject)
+      expect(Post.where_user_can(nil, :destroy)).not_to include(subject)
+    end
+
+    it 'selector for logged user' do
+      expect(Post.where_user_can(user, :read)).to include(subject)
+
+      expect(Post.where_user_can(any_user, :read)).to include(subject)
+      expect(Post.where_user_can(any_user, :read)).to include(subject)
+      expect(Post.where_user_can(any_user, :create)).to include(subject)
+      expect(Post.where_user_can(any_user, :write)).not_to include(subject)
+      expect(Post.where_user_can(any_user, :destroy)).not_to include(subject)
+    end
+
+    it 'selector for editor' do
+      user.role!(:editor, subject)
+
+      # Bug fix
+      expect(Post.where_user_can(any_user, :read)).to include(subject)
+      expect(Post.where_user_can(any_user, :destroy)).not_to include(subject)
+
+      expect(Post.where_user_can(user, :read)).to include(subject)
+      expect(Post.where_user_can(user, :create)).to include(subject)
+      expect(Post.where_user_can(user, :write)).to include(subject)
+      expect(Post.where_user_can(user, :destroy)).not_to include(subject)
+    end
+
+    it 'selector for admin' do
+      user.role!(:admin, subject)
+      # Bug fix
+      expect(Post.where_user_can(any_user, :read)).to include(subject)
+      expect(Post.where_user_can(any_user, :destroy)).not_to include(subject)
+
+      expect(Post.where_user_can(user, :read)).to include(subject)
+      expect(Post.where_user_can(user, :create)).to include(subject)
+      expect(Post.where_user_can(user, :write)).to include(subject)
+      expect(Post.where_user_can(user, :destroy)).to include(subject)
+      expect(Post.where_user_can(user, :foo)).not_to include(subject)
+    end
+  end
+
+  describe '#permissions_for' do
+    it 'lists all permissions for guests when user is nil' do
+      expect(permissions_for(nil)).to contain_exactly(:read)
+    end
+
+    it 'lists all permissions for an user' do
+      expect(permissions_for(user)).to contain_exactly(:create, :read)
+    end
+
+    it 'lists all permissions for an editor' do
+      user.role! :editor, subject
+      expect(permissions_for(user)).to contain_exactly(:create, :read, :write)
+    end
+
+    it 'lists all permissions for an admin' do
+      user.role! :admin, subject
+      expect(permissions_for(user)).to contain_exactly(
+        :read, :create, :write, :update, :destroy)
+    end
+
+    def permissions_for(user)
+      subject.permissions_for(user).names
+    end
+  end
+end

data/spec/skill_tree/subject_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe SkillTree::Subject do
+  before(:each) do
+    stub_const('Rails', double(root: double))
+    allow(Rails.root).to receive(:join)
+      .and_return('spec/support/acls/subject_acl.rb')
+    SkillTree::Parser::Initializer.parse!
+  end
+
+  let(:current_acl) { SkillTree::Models::Acl.find_by(name: 'posts') }
+
+  let(:resource) do
+    Post.create!(acl: current_acl)
+  end
+
+  subject { User.create! }
+
+  it '#can?' do
+    expect(subject).to be_allowed_to(:read, resource)
+    expect(subject).not_to be_allowed_to(:write, resource)
+  end
+
+  describe '#role!' do
+    it 'sets a only one role per resource' do
+      subject.role! :editor, resource
+      expect(subject).to have_role(:editor, resource)
+      subject.role! :admin, resource
+      expect(subject).not_to have_role(:editor, resource)
+      expect(subject).to have_role(:admin, resource)
+    end
+
+    it 'can\'t set a role that does not exist' do
+      expect do
+        subject.role! :foo, resource
+      end.to raise_error ActiveRecord::RecordNotFound
+    end
+  end
+
+  describe '#unrole!' do
+    it 'unsets a role' do
+      subject.role! :editor, resource
+      expect(subject).to have_role(:editor, resource)
+      subject.unrole! :editor, resource
+      expect(subject).not_to have_role(:editor, resource)
+    end
+
+    it 'unsets also a role you don\'t have' do
+      expect(subject).not_to have_role(:editor, resource)
+      subject.unrole! :editor, resource
+    end
+
+    it 'can\'t unset a role that does not exist' do
+      expect do
+        subject.unrole! :foo, resource
+      end.to raise_error ActiveRecord::RecordNotFound
+    end
+  end
+
+  it '#role?' do
+    expect(subject).not_to have_role(:admin, resource)
+    subject.role! :admin, resource
+    expect(subject).to have_role(:admin, resource)
+  end
+end

data/spec/skill_tree_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe SkillTree do
+  it '#init! calls Parser' do
+    expect(SkillTree::Parser::Initializer).to receive(:parse!)
+    described_class.init!
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+require 'active_support'
+require 'active_record'
+require 'action_controller'
+require 'skill_tree'
+require 'generators/skill_tree/install_generator'
+require 'rspec'
+require 'rspec/collection_matchers'
+require 'generator_spec'
+
+I18n.enforce_available_locales = false
+
+Dir[File.join(File.dirname(__FILE__), '..', 'spec/support/*.rb')].each { |f| require f }
+
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+    capture_stdout { load 'db/schema.rb' }
+  end
+
+  config.before(:each) do
+    load 'support/models.rb'
+  end
+
+  config.include MockControllerTestHelpers, type: :controller
+  config.include ModelBuilder, type: :model
+
+  config.around(:each) do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end