slow_your_roles 2.0.2

data/spec/methods/serialize_spec.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SlowYourRoles do
+  describe 'serialize method' do
+    it 'should allow me to set a users role' do
+      user = SerializeUser.new
+      user.add_role 'admin'
+      expect(user.roles).to include('admin')
+    end
+
+    it 'should allow me to set multiple roles at one time' do
+      user = SerializeUser.new
+      user.add_roles 'admin', 'manager'
+      expect(user.roles).to include 'admin'
+      expect(user.roles).to include 'manager'
+      expect(user.roles.length).to eq 2
+      user.add_roles 'admin', 'manager','user'
+      expect(user.roles).to include 'user'
+      expect(user.roles.length).to eq 3
+    end
+
+    it 'should return true for is_admin? if the admin role is added to the user' do
+      user = SerializeUser.new
+      user.add_role 'admin'
+      expect(user.is_admin?).to eq true
+    end
+
+    it "should return true for has_role? 'admin' if the admin role is added to the user" do
+      user = SerializeUser.new
+      user.add_role 'admin'
+      expect(user.has_role?('admin')).to eq true
+    end
+
+    it "should turn false for has_role? 'manager' if manager role is not added to the user" do
+      user = SerializeUser.new
+      expect(user.has_role?('manager')).to eq false
+    end
+
+    it 'should turn false for is_manager? if manager role is not added to the user' do
+      user = SerializeUser.new
+      expect(user.is_manager?).to eq false
+    end
+
+    it 'should return the users role through association' do
+      user = BitmaskUser.create(name: 'Bob')
+      user.add_role! 'admin'
+
+      Membership.create(name: 'Test Membership', bitmask_user: user)
+
+      expect(Membership.last.bitmask_user.is_admin?).to eq true
+    end
+
+    it 'should get no method error if no roles on model' do
+      b = Beggar.create(name: 'Ivor')
+
+      b.is_admin?
+    rescue StandardError => e
+      expect(e.class).to eq(NoMethodError)
+    end
+
+    it 'should get no method error if no roles on model even through association' do
+      b = Beggar.create(name: 'Ivor')
+      Membership.create(name: 'Beggars club', beggar: b)
+      Membership.last.beggar.is_admin?
+
+    rescue StandardError => e
+      expect(e.class).to eq(NoMethodError)
+    end
+
+    describe 'normal methods' do
+      it 'should not save to the database if not implicitly saved' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.reload
+
+        expect(user.is_admin?).to eq false
+      end
+
+      it 'should save to the database if implicity saved' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.save
+        user.reload
+
+        expect(user.is_admin?).to eq true
+      end
+
+      it 'should clear all roles and not save if not implicitly saved' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.save
+        user.reload
+        expect(user.is_admin?).to eq true
+
+        user.clear_roles
+        expect(user.is_admin?).to eq false
+        user.reload
+
+        expect(user.is_admin?).to eq true
+      end
+
+      it 'should clear all roles and save if implicitly saved' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.save
+        user.reload
+        expect(user.is_admin?).to eq true
+
+        user.clear_roles
+        expect(user.is_admin?).to eq false
+        user.save
+        user.reload
+
+        expect(user.is_admin?).to eq false
+      end
+
+      it 'should remove a role and not save unless implicitly saved' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.save
+        user.reload
+
+        expect(user.is_admin?).to eq true
+        user.remove_role 'admin'
+        expect(user.is_admin?).to eq false
+        user.reload
+
+        expect(user.is_admin?).to eq true
+      end
+
+      it 'should remove a role and save if implicitly saved' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.save
+        user.reload
+
+        expect(user.is_admin?).to eq true
+        user.remove_role 'admin'
+        expect(user.is_admin?).to eq false
+        user.save
+        user.reload
+
+        expect(user.is_admin?).to eq false
+      end
+    end
+
+    describe 'bang method' do
+      it 'should save to the database if the bang method is used' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role! 'admin'
+        expect(user.is_admin?).to eq true
+        user.reload
+
+        expect(user.is_admin?).to eq true
+      end
+
+      it 'should allow me to set multiple roles at one time' do
+        user = SerializeUser.new
+        user.add_roles! 'admin', 'manager'
+        expect(user.roles).to include 'admin'
+        expect(user.roles).to include 'manager'
+        expect(user.roles.length).to eq 2
+        user.add_roles! 'admin', 'manager','user'
+        expect(user.roles).to include 'user'
+        expect(user.roles.length).to eq 3
+      end
+
+      it 'should remove a role and save' do
+        user = SerializeUser.create(name: 'Ryan')
+        user.add_role 'admin'
+        expect(user.is_admin?).to eq true
+        user.save
+        user.reload
+
+        expect(user.is_admin?).to eq true
+        user.remove_role! 'admin'
+        expect(user.is_admin?).to eq false
+        user.reload
+
+        expect(user.is_admin?).to eq false
+      end
+    end
+
+    describe 'scopes' do
+      describe 'with_role' do
+        describe 'with markers' do
+          before do
+            @marker_cache = SerializeUser.roles_marker
+          end
+
+          after do
+            SerializeUser.roles_marker = @marker_cache
+          end
+
+          it 'should prove that wrapper markers are a necessary strategy by failing without them' do
+            SerializeUser.roles_marker = ''
+            (morgan = SerializeUser.create(name: 'Mr. Freeman')).add_role!('onrecursionrecursi')
+            expect(SerializeUser.with_role('recursion')).to include morgan
+          end
+
+          it 'should not allow roles to be added if they include the roles_marker character' do
+            SerializeUser.roles_marker = '!'
+            user = SerializeUser.create(name: 'Towelie')
+            expect(user.add_role!('funkytown!')).to eq false
+          end
+        end
+
+        it 'should implement the `with_role` scope' do
+          expect(SerializeUser).to respond_to :without_role
+        end
+
+        it 'should return an ActiveRecord::Relation' do
+          expect(SerializeUser.with_role('admin').class).to eq(
+            "SerializeUser::ActiveRecord_Relation".constantize
+          )
+        end
+
+        it 'should match records for a given role' do
+          user = SerializeUser.create(name: 'Daniel')
+          expect(SerializeUser.with_role('admin')).not_to include user
+
+          user.add_role! 'admin'
+          expect(SerializeUser.with_role('admin')).to include user
+        end
+
+        it 'should be chainable' do
+          (daniel = SerializeUser.create(name: 'Daniel')).add_role! 'user'
+          (ryan = SerializeUser.create(name: 'Ryan')).add_role! 'user'
+          ryan.add_role! 'admin'
+          admin_users = SerializeUser.with_role('user').with_role('admin')
+          expect(admin_users).to include ryan
+          expect(admin_users).not_to include daniel
+        end
+
+        it "should avoid incorrectly matching roles where the name is a subset of another role's name" do
+          (chuck = SerializeUser.create(name: 'Mr. Norris')).add_role!('recursion')
+          (morgan = SerializeUser.create(name: 'Mr. Freeman')).add_role!('onrecursionrecursi')
+          expect(SerializeUser.with_role('recursion')).to include chuck
+          expect(SerializeUser.with_role('recursion')).not_to include morgan
+        end
+
+        it 'should correctly handle markers on failed saves' do
+          UniqueSerializeUser.create(name: 'Elvis')
+          (imposter = UniqueSerializeUser.create(name: 'Elvisbot')).add_role!('sings-like-a-robot')
+          imposter.name = 'Elvis'
+          expect(imposter.save).to eq false
+          expect(imposter.roles.any? { |r| r.include?(SerializeUser.roles_marker) }).to eq false
+        end
+      end
+
+      describe 'without_role' do
+        describe 'with markers' do
+          before do
+            @marker_cache = SerializeUser.roles_marker
+          end
+
+          after do
+            SerializeUser.roles_marker = @marker_cache
+          end
+
+          it 'should prove that wrapper markers are a necessary strategy by failing without them' do
+            SerializeUser.roles_marker = ''
+            (morgan = SerializeUser.create(name: 'Mr. Freeman')).add_role!('onrecursionrecursi')
+            expect(SerializeUser.without_role('onrecursionrecursi')).not_to include morgan
+            expect(SerializeUser.without_role('recursion')).not_to include morgan
+          end
+
+          it 'should not allow roles to be added if they include the roles_marker character' do
+            SerializeUser.roles_marker = '!'
+            user = SerializeUser.create(name: 'Towelie')
+            expect(user.add_role!('funkytown!')).to eq false
+          end
+        end
+
+        it 'should implement the `without_role` scope' do
+          expect(SerializeUser).to respond_to :without_role 
+        end
+
+        it 'should return an ActiveRecord::Relation' do
+          expect(SerializeUser.without_role('admin').class).to eq(
+            "SerializeUser::ActiveRecord_Relation".constantize
+          )
+        end
+
+        it 'should match records for a given role' do
+          user = SerializeUser.create(name: 'Daniel')
+          expect(SerializeUser.without_role('admin')).to include user 
+          user.add_role! 'admin'
+          expect(SerializeUser.without_role('admin')).not_to include user
+        end
+
+        it 'should be chainable' do
+          (daniel = SerializeUser.create(name: 'Daniel')).add_role! 'user'
+          (ryan = SerializeUser.create(name: 'Ryan')).add_role! 'user'
+          ryan.add_role! 'admin'
+          non_admin_users = SerializeUser.with_role('user').without_role('admin')
+          expect(non_admin_users).not_to include ryan
+          expect(non_admin_users).to include daniel
+        end
+
+        it "should avoid incorrectly matching roles where the name is a subset of another role's name" do
+          (chuck = SerializeUser.create(name: 'Mr. Norris')).add_role!('recursion')
+          (morgan = SerializeUser.create(name: 'Mr. Freeman')).add_role!('onrecursionrecursi')
+
+          expect(SerializeUser.without_role('onrecursionrecursi')).to include chuck
+          expect(SerializeUser.without_role('onrecursionrecursi')).not_to include morgan
+          expect(SerializeUser.without_role('recursion')).not_to include chuck
+          expect(SerializeUser.without_role('recursion')).to include morgan
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'active_record'
+require 'slow_your_roles'
+
+RSpec.configure do |config|
+end
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+def setup_db
+  ActiveRecord::Schema.define(version: 1) do
+    create_table :serialize_users do |t|
+      t.string :name
+      t.string :roles, default: '--- []'
+    end
+    create_table :bitmask_users do |t|
+      t.string :name
+      t.integer :roles_mask, default: 0
+    end
+
+    create_table :memberships do |t|
+      t.string :name
+      t.integer :bitmask_user_id
+      t.integer :beggar_id
+    end
+
+    create_table :beggars do |t|
+      t.string :name
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+setup_db
+
+class SerializeUser < ActiveRecord::Base
+  slow_your_roles :roles, method: :serialize
+end
+
+class UniqueSerializeUser < SerializeUser
+  validates :name, uniqueness: true
+end
+
+class BitmaskUser < ActiveRecord::Base
+  has_many :memberships
+  slow_your_roles :roles_mask, method: :bitmask
+
+  ROLES_MASK = %w[admin manager user].freeze
+end
+
+class Membership < ActiveRecord::Base
+  belongs_to :bitmask_user
+  belongs_to :beggar
+end
+
+class Beggar < ActiveRecord::Base
+  has_many :memberships
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: slow_your_roles
+version: !ruby/object:Gem::Version
+  version: 2.0.2
+platform: ruby
+authors:
+- Aaron A
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy role authorization in Rails ported from an unmaintained library
+email: _aaron@tutanota.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- README.md
+- lib/generators/active_record/slow_your_roles_generator.rb
+- lib/generators/active_record/templates/migration_bitmask.rb.erb
+- lib/generators/active_record/templates/migration_serialize.rb.erb
+- lib/generators/active_record/templates/model.rb.erb
+- lib/generators/slow_your_roles/slow_your_roles_generator.rb
+- lib/generators/templates/README
+- lib/generators/install_generator_helpers.rb
+- lib/slow_your_roles.rb
+- lib/methods/bitmask.rb
+- lib/methods/serialize.rb
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- init.rb
+- lib/generators/active_record/slow_your_roles_generator.rb
+- lib/generators/active_record/templates/migration_bitmask.rb.erb
+- lib/generators/active_record/templates/migration_serialize.rb.erb
+- lib/generators/active_record/templates/model.rb.erb
+- lib/generators/install_generator_helpers.rb
+- lib/generators/slow_your_roles/slow_your_roles_generator.rb
+- lib/generators/templates/README
+- lib/methods/bitmask.rb
+- lib/methods/serialize.rb
+- lib/slow_your_roles.rb
+- slow_your_roles.gemspec
+- spec/methods/bitmask_spec.rb
+- spec/methods/serialize_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/aarona/slow_your_roles
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- Slow_your_roles
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Easy role authorization in Rails
+test_files:
+- spec/spec_helper.rb
+- spec/methods/serialize_spec.rb
+- spec/methods/bitmask_spec.rb