strongbolt 0.3.6

data/spec/strongbolt/bolted_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+
+module Strongbolt
+
+  describe Bolted do
+    
+    #
+    # Bolted?
+    #
+    describe "bolted?" do
+
+      context 'when grant is disabled' 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
+        before do
+          expect(Grant::User).to receive(:current_user)
+        end
+
+        it "should return false" do
+          expect(Model.bolted?).to eq false
+        end
+      end
+
+      context "when using rails is on console" do
+        before do
+          rails = class_double 'Rails'#, :console => true
+        end
+
+        it "should return false" do
+          expect(Model.bolted?).to eq false
+        end
+      end
+
+    end
+
+    it "should let create a model" do
+      expect do
+        Model.create! name: "Cool"
+      end.not_to raise_error
+    end
+
+  end
+
+  #
+  # Owned?
+  #
+  describe 'owned?' do
+
+    context "when model is User" do
+      let(:user) { User.create! }
+
+      it "should be true" do
+        expect(User).to be_owned
+      end
+
+      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
+        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"
+
+          belongs_to :user
+        end
+      end
+
+      let(:model) { OwnedModel.create! user: User.create! }
+
+      it "should be true" do
+        expect(OwnedModel).to be_owned
+      end
+
+      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
+        expect(OwnedModel.owner_attribute).to eq :user_id
+      end
+    
+    end
+    
+    context 'when model isnt ownable' do
+      
+      it "should be true" do
+        expect(UnownedModel).not_to be_owned
+      end
+
+      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.name_for_authorization).to eq "Model"
+    end
+  end
+
+  #
+  # Authorize as
+  #
+  describe 'authorize_as' do
+    
+    before { Model.authorize_as "ParentModel" }
+    after { Model.authorize_as nil }
+
+    it "should have changed name for authorization" do
+      expect(Model.name_for_authorization).to eq "ParentModel"
+    end
+
+  end
+
+end

data/spec/strongbolt/capability_spec.rb

@@ -0,0 +1,251 @@
+require "spec_helper"
+
+module Strongbolt
+  
+  describe Capability do
+  
+    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(:roles).through :capabilities_roles }
+    it { is_expected.to have_many(:users).through :roles }
+
+
+    #
+    # VALIDATIONS
+    #
+
+    it { is_expected.to be_valid }
+
+    it { is_expected.to validate_presence_of :model }
+    it { is_expected.to validate_presence_of :action }
+
+    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 "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
+        
+      before do
+        capability.save
+        capability.roles << Role.create!(name: 'role')
+      end
+
+      it "cannot delete" do
+        expect do
+          capability.destroy
+        end.to raise_error ActiveRecord::DeleteRestrictionError
+      end
+
+    end
+
+
+    #
+    # Scopes and table
+    #
+    describe "scope and table" do
+      before(:all) do
+        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")
+        ]
+      end
+      after(:all) { Capability.all.delete_all }
+
+      #
+      # SCOPE ORDERED
+      #
+      describe "ordered" do
+        it "should have the scope" do
+          expect(Capability).to respond_to :ordered
+        end
+
+        describe "results" do
+
+          let(:results) { Capability.ordered }
+
+          subject { results }
+
+          it "should have 5 elements" do
+            expect(results.size).to eq 5
+          end
+
+          it { should == @capabilities }
+        end
+      end
+
+      #
+      # To Table
+      #
+      describe "to_table" do
+        
+        it "should have the to_table" do
+          expect(Capability).to respond_to :to_table
+        end
+
+        describe "results" do
+          let(:results) { Capability.to_table }
+
+          subject { results }
+
+          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
+            results.each do |permission|
+              [: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
+          expect(Capability).to respond_to :to_hash
+        end
+
+        describe "results" do
+          let(:results) { Capability.to_hash }
+
+          subject { results }
+
+          it "should have 4" do
+            expect(results.size).to eq 4
+          end
+
+          it "should have the correct keys" do
+            keys = [
+              {
+                model: "Model",
+                require_ownership: false,
+                require_tenant_access: true
+              },
+              {
+                model: "OtherModel",
+                require_ownership: false,
+                require_tenant_access: true
+              },
+              {
+                model: "OtherModel",
+                require_ownership: true,
+                require_tenant_access: true
+              },
+              {
+                model: "User",
+                require_ownership: false,
+                require_tenant_access: true
+              },
+            ]
+            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|
+                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} }
+
+      let(:capabilities) { Capability.from_hash params }
+
+      subject { capabilities }
+
+      context "when list of actions" do
+        before { params[:actions] = [:find, :update] }
+
+        it "should have 2 element2" do
+          expect(subject.size).to eq 2  
+        end
+
+        it "should have the right model" do
+          capabilities.each do |c|
+            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  }
+        end
+
+        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
+          capabilities.each do |c|
+            expect(["find", "update"]).to include c.action.to_s
+          end
+        end
+      end #/list of actions
+
+      context "when list of actions" do
+        before { params[:actions] = "find" }
+
+        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"
+        end
+      end
+
+      context "when :all" do
+        before { params[:actions] = "all" }
+
+        it "should have 4 elements" do
+          expect(subject.size).to eq 4
+        end
+
+        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

data/spec/strongbolt/configuration_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Strongbolt::Configuration do
+  
+
+  #
+  # User class
+  #
+  describe "user class" do
+    
+    it "should default to User" do
+      expect(Strongbolt::Configuration.user_class).to eq "User"
+    end
+
+    context "when setting it" do
+      before { Strongbolt::Configuration.user_class = "Account" }
+      after { Strongbolt::Configuration.user_class = "User" }
+
+      it "should give it" do
+        expect(Strongbolt::Configuration.user_class).to eq "Account"
+      end
+    end
+
+  end
+
+
+
+  #
+  # Setting up tenants
+  #
+  describe 'tenants=' do
+    
+    before do
+      define_model "Model" do
+        self.table_name = "models"
+      end
+
+      define_model "OtherModel" do
+        self.table_name = "models"
+      end
+
+      expect(Model).to receive(:send).with :tenant
+      expect(OtherModel).to receive(:send).with :tenant
+    end
+    after { Strongbolt::Configuration.tenants = [] }
+
+    it "should tenant the models" do
+      Strongbolt::Configuration.tenants = "Model", OtherModel, Model
+      expect(Strongbolt::Configuration.tenants).to eq [Model, OtherModel]
+    end
+
+  end
+
+  #
+  # Configuring Capability Models
+  #
+  describe "models=" do
+    before do
+      Strongbolt::Configuration.models = "OtherModel", "Model"
+    end
+    after do
+      Capability.models = nil
+    end
+
+    it "should set Capability::Models" do
+      expect(Capability.models).to eq ["Model", "OtherModel", "Strongbolt::Capability", "Strongbolt::Role", "Strongbolt::UserGroup", "Strongbolt::UsersTenant"]
+    end
+
+    context "when adding other models" do
+      before do
+        Strongbolt::Configuration.models = "Model", "LastModel"
+      end
+
+      it "should merge with current models" do
+        expect(Capability.models).to eq ["LastModel", "Model", "OtherModel", "Strongbolt::Capability", "Strongbolt::Role", "Strongbolt::UserGroup", "Strongbolt::UsersTenant"]
+      end
+    end
+
+    context "when adding 1 model" do
+      before do
+        Strongbolt::Configuration.models = "BottomModel"
+      end
+
+      it "should merge with current models" do
+        expect(Capability.models).to eq ["BottomModel", "Model", "OtherModel", "Strongbolt::Capability", "Strongbolt::Role", "Strongbolt::UserGroup", "Strongbolt::UsersTenant"]
+      end
+    end
+  end #/models=
+
+
+
+  #
+  # Setting default permissions
+  #
+  describe "default_capabilities=" do
+    
+    before do
+      Strongbolt::Configuration.default_capabilities = [
+        {:model => "User", :actions => :all},
+        {:model => "Model", :actions => "find"}
+      ]
+    end
+    after do
+      Strongbolt::Configuration.default_capabilities = []
+    end
+
+    it "should return 5 Capabilities" do
+      expect(Strongbolt::Configuration.default_capabilities.size).to eq 5
+    end
+
+    it "should return Capability" do
+      Strongbolt::Configuration.default_capabilities.each do |c|
+        expect(c).to be_a Capability
+      end
+    end
+
+  end
+
+end