strongbolt 0.3.12 → 0.3.13

data/spec/strongbolt/bolted_spec.rb

@@ -1,78 +1,71 @@
-require "spec_helper"
+require 'spec_helper'
 
 module Strongbolt
-
   describe Bolted do
-
     #
     # Bolted?
     #
-    describe "bolted?" do
-
+    describe 'bolted?' do
       context 'when grant is disabled' do
-        it "should return false" do
+        it 'should return false' do
           without_grant do
             expect(Model.bolted?).to eq false
           end
         end
       end # End Grant disabled
 
-      context "when no user but enabled" do
+      context 'when no user but enabled' do
         before do
           expect(Grant::User).to receive(:current_user)
         end
 
-        it "should return false" do
+        it 'should return false' do
           expect(Model.bolted?).to eq false
         end
       end
 
-      context "when using rails is on console" do
+      context 'when using rails is on console' do
         before do
-          rails = class_double 'Rails'#, :console => true
+          class_double 'Rails' # , :console => true
         end
 
-        it "should return false" do
+        it 'should return false' do
           expect(Model.bolted?).to eq false
         end
       end
-
     end
 
-    it "should let create a model" do
+    it 'should let create a model' do
       expect do
-        Model.create! name: "Cool"
+        Model.create! name: 'Cool'
       end.not_to raise_error
     end
-
   end
 
   #
   # Owned?
   #
   describe 'owned?' do
-
-    context "when model is User" do
+    context 'when model is User' do
       let(:user) { User.create! }
 
-      it "should be true" do
+      it 'should be true' do
         expect(User).to be_owned
       end
 
-      it "should return the user id" do
+      it 'should return the user id' do
         expect(user.strongbolt_owner_id).to eq user.id
       end
 
-      it "should have the right owner attribute" do
+      it 'should have the right owner attribute' do
         expect(User.owner_attribute).to eq :id
       end
     end
 
     context 'when model is ownable' do
-
       before do
-        define_model "OwnedModel" do
-          self.table_name = "models"
+        define_model 'OwnedModel' do
+          self.table_name = 'models'
 
           belongs_to :user
         end
@@ -80,42 +73,38 @@ module Strongbolt
 
       let(:model) { OwnedModel.create! user: User.create! }
 
-      it "should be true" do
+      it 'should be true' do
         expect(OwnedModel).to be_owned
       end
 
-      it "should return the model user id" do
+      it 'should return the model user id' do
         expect(model.strongbolt_owner_id).to eq model.user_id
       end
 
-      it "should have the right owner attribute" do
+      it 'should have the right owner attribute' do
         expect(OwnedModel.owner_attribute).to eq :user_id
       end
-
     end
 
     context 'when model isnt ownable' do
-
-      it "should be true" do
+      it 'should be true' do
         expect(UnownedModel).not_to be_owned
       end
 
-      it "should raise error" do
+      it 'should raise error' do
         expect do
           UnownedModel.new.strongbolt_owner_id
         end.to raise_error ModelNotOwned
       end
-
     end
-
   end
 
   #
   # Name for authorization
   #
   describe 'name_for_authorization' do
-    it "should default to model name" do
-      expect(Model.send(:name_for_authorization)).to eq "Model"
+    it 'should default to model name' do
+      expect(Model.send(:name_for_authorization)).to eq 'Model'
     end
   end
 
@@ -123,14 +112,11 @@ module Strongbolt
   # Authorize as
   #
   describe 'authorize_as' do
-
-    before { Model.authorize_as "ParentModel" }
+    before { Model.authorize_as 'ParentModel' }
     after { Model.authorize_as nil }
 
-    it "should have changed name for authorization" do
-      expect(Model.send(:name_for_authorization)).to eq "ParentModel"
+    it 'should have changed name for authorization' do
+      expect(Model.send(:name_for_authorization)).to eq 'ParentModel'
     end
-
   end
-
 end

data/spec/strongbolt/capability_spec.rb

@@ -1,22 +1,21 @@
-require "spec_helper"
+require 'spec_helper'
 
 module Strongbolt
-  
   describe Capability do
-  
-    let(:capability) { Capability.new model: "User", action: "find" }
+    let(:capability) { Capability.new model: 'User', action: 'find' }
 
     subject { capability }
 
     #
     # Associations
     #
-    it { is_expected.to have_many(:capabilities_roles).class_name("Strongbolt::CapabilitiesRole")
-      .dependent :restrict_with_exception }
+    it {
+      is_expected.to have_many(:capabilities_roles).class_name('Strongbolt::CapabilitiesRole')
+                                                   .dependent :restrict_with_exception
+    }
     it { is_expected.to have_many(:roles).through :capabilities_roles }
     it { is_expected.to have_many(:users).through :roles }
 
-
     #
     # VALIDATIONS
     #
@@ -28,42 +27,39 @@ module Strongbolt
 
     it { is_expected.to validate_uniqueness_of(:action).scoped_to :model, :require_ownership, :require_tenant_access }
 
-    it { is_expected.to validate_inclusion_of(:action).in_array %w{find create update destroy} }
+    it { is_expected.to validate_inclusion_of(:action).in_array %w[find create update destroy] }
 
-    it "should ensure the model exists" do
-      capability.model = "UserFake"
+    it 'should ensure the model exists' do
+      capability.model = 'UserFake'
       expect(capability).not_to be_valid
     end
 
-    context "when there are roles linked to it" do
-        
+    context 'when there are roles linked to it' do
       before do
         capability.save
         capability.roles << Role.create!(name: 'role')
       end
 
-      it "cannot delete" do
+      it 'cannot delete' do
         expect do
           capability.destroy
         end.to raise_error ActiveRecord::DeleteRestrictionError
       end
-
     end
 
-
     #
     # Scopes and table
     #
-    describe "scope and table" do
+    describe 'scope and table' do
       before(:all) do
-        define_model "OtherModel"
+        define_model 'OtherModel'
 
         @capabilities = [
-          Capability.create!(model: "Model", action: "find"),
-          Capability.create!(model: "Model", action: "create"),
-          Capability.create!(model: "OtherModel", action: "find"),
-          Capability.create!(model: "OtherModel", action: "find", require_ownership: true),
-          Capability.create!(model: "User", action: "find")
+          Capability.create!(model: 'Model', action: 'find'),
+          Capability.create!(model: 'Model', action: 'create'),
+          Capability.create!(model: 'OtherModel', action: 'find'),
+          Capability.create!(model: 'OtherModel', action: 'find', require_ownership: true),
+          Capability.create!(model: 'User', action: 'find')
         ]
       end
       after(:all) { Capability.all.delete_all }
@@ -71,18 +67,17 @@ module Strongbolt
       #
       # SCOPE ORDERED
       #
-      describe "ordered" do
-        it "should have the scope" do
+      describe 'ordered' do
+        it 'should have the scope' do
           expect(Capability).to respond_to :ordered
         end
 
-        describe "results" do
-
+        describe 'results' do
           let(:results) { Capability.ordered }
 
           subject { results }
 
-          it "should have 5 elements" do
+          it 'should have 5 elements' do
             expect(results.size).to eq 5
           end
 
@@ -93,159 +88,150 @@ module Strongbolt
       #
       # To Table
       #
-      describe "to_table" do
-        
-        it "should have the to_table" do
+      describe 'to_table' do
+        it 'should have the to_table' do
           expect(Capability).to respond_to :to_table
         end
 
-        describe "results" do
+        describe 'results' do
           let(:results) { Capability.to_table }
 
           subject { results }
 
-          it "should have 4" do
+          it 'should have 4' do
             expect(results.size).to eq 4
           end
 
-          it "should have each one as a hash with the right keys" do
+          it 'should have each one as a hash with the right keys' do
             results.each do |permission|
-              [:model, :require_ownership, :require_tenant_access,
-                :find, :create, :update, :destroy].each do |attr|
-                  expect(permission).to include attr
-                end
+              %i[model require_ownership require_tenant_access
+                 find create update destroy].each do |attr|
+                expect(permission).to include attr
+              end
             end
           end
         end
-
       end # End to_table
 
       #
       # To Hash
       #
-      describe "to_hash" do
-        
-        it "should have the to_hash" do
+      describe 'to_hash' do
+        it 'should have the to_hash' do
           expect(Capability).to respond_to :to_hash
         end
 
-        describe "results" do
+        describe 'results' do
           let(:results) { Capability.to_hash }
 
           subject { results }
 
-          it "should have 4" do
+          it 'should have 4' do
             expect(results.size).to eq 4
           end
 
-          it "should have the correct keys" do
+          it 'should have the correct keys' do
             keys = [
               {
-                model: "Model",
+                model: 'Model',
                 require_ownership: false,
                 require_tenant_access: true
               },
               {
-                model: "OtherModel",
+                model: 'OtherModel',
                 require_ownership: false,
                 require_tenant_access: true
               },
               {
-                model: "OtherModel",
+                model: 'OtherModel',
                 require_ownership: true,
                 require_tenant_access: true
               },
               {
-                model: "User",
+                model: 'User',
                 require_ownership: false,
                 require_tenant_access: true
-              },
+              }
             ]
-            results.each do |key, permission|
+            results.each do |key, _permission|
               expect(keys).to include key
             end
           end
 
-          it "should have each one as a hash with the right keys" do
-            results.each do |key, permission|
-              [:find, :create, :update, :destroy].each do |attr|
+          it 'should have each one as a hash with the right keys' do
+            results.each do |_key, permission|
+              %i[find create update destroy].each do |attr|
                 expect(permission).to include attr
               end
             end
           end
         end
-
       end # End to_hash
-
     end # End Scope and Table
 
-
-
     #
     # Create capability from hash
     #
-    describe "from_hash" do
-      let(:params) { {model: "User", require_ownership: true, require_tenant_access: false} }
+    describe 'from_hash' do
+      let(:params) { { model: 'User', require_ownership: true, require_tenant_access: false } }
 
       let(:capabilities) { Capability.from_hash params }
 
       subject { capabilities }
 
-      context "when list of actions" do
-        before { params[:actions] = [:find, :update] }
+      context 'when list of actions' do
+        before { params[:actions] = %i[find update] }
 
-        it "should have 2 element2" do
-          expect(subject.size).to eq 2  
+        it 'should have 2 element2' do
+          expect(subject.size).to eq 2
         end
 
-        it "should have the right model" do
+        it 'should have the right model' do
           capabilities.each do |c|
-            expect(c.model).to eq "User"
+            expect(c.model).to eq 'User'
           end
         end
 
-        it "should have the right require_ownership" do
-          capabilities.each { |c| expect(c.require_ownership).to eq true  }
+        it 'should have the right require_ownership' do
+          capabilities.each { |c| expect(c.require_ownership).to eq true }
         end
 
-        it "should have the right require_tenant_access" do
-          capabilities.each { |c| expect(c.require_tenant_access).to eq false  }
+        it 'should have the right require_tenant_access' do
+          capabilities.each { |c| expect(c.require_tenant_access).to eq false }
         end
 
-        it "should have the right actions" do
+        it 'should have the right actions' do
           capabilities.each do |c|
-            expect(["find", "update"]).to include c.action.to_s
+            expect(%w[find update]).to include c.action.to_s
           end
         end
-      end #/list of actions
+      end # /list of actions
 
-      context "when list of actions" do
-        before { params[:actions] = "find" }
+      context 'when list of actions' do
+        before { params[:actions] = 'find' }
 
-        it "should have 1 element" do
-          expect(subject.size).to eq 1  
+        it 'should have 1 element' do
+          expect(subject.size).to eq 1
         end
-        
-        it "should have the right action" do
-          expect(capabilities[0].action).to eq "find"
+
+        it 'should have the right action' do
+          expect(capabilities[0].action).to eq 'find'
         end
       end
 
-      context "when :all" do
-        before { params[:actions] = "all" }
+      context 'when :all' do
+        before { params[:actions] = 'all' }
 
-        it "should have 4 elements" do
+        it 'should have 4 elements' do
           expect(subject.size).to eq 4
         end
 
-        it "should have the right actions" do
+        it 'should have the right actions' do
           capabilities.each do |c|
             expect(Capability::Actions).to include c.action.to_s
           end
         end
       end
     end
-
   end
-
-end
+end