strongbolt 0.3.6

data/lib/strongbolt/user_group.rb

@@ -0,0 +1,24 @@
+module Strongbolt
+  class UserGroup < Base
+
+    has_many :user_groups_users,
+      :class_name => "Strongbolt::UserGroupsUser",
+      :dependent => :restrict_with_exception,
+      :inverse_of => :user_group
+    has_many :users, :through => :user_groups_users
+    
+    has_many :roles_user_groups,
+      :class_name => "Strongbolt::RolesUserGroup",
+      :dependent => :delete_all,
+      :inverse_of => :user_group
+
+    has_many :roles, :through => :roles_user_groups
+
+    has_many :capabilities, through: :roles
+
+    validates_presence_of :name
+
+  end
+end
+
+UserGroup = Strongbolt::UserGroup unless defined? UserGroup

data/lib/strongbolt/user_groups_user.rb

@@ -0,0 +1,16 @@
+module Strongbolt
+  class UserGroupsUser < Base
+    authorize_as "Strongbolt::UserGroup"
+
+    belongs_to :user_group,
+      :class_name => "Strongbolt::UserGroup",
+      :inverse_of => :user_groups_users
+    
+    belongs_to :user,
+      :class_name => Configuration.user_class,
+      :foreign_key => :user_id,
+      :inverse_of => :user_groups_users
+
+    validates_presence_of :user_group, :user
+  end
+end

data/lib/strongbolt/users_tenant.rb

@@ -0,0 +1,12 @@
+module Strongbolt
+  #
+  # This is a STI model that will have subclasses making links
+  # from users to tenants (if one or more tenants are defined)
+  #
+  class UsersTenant < Base
+    # Required validation for every subclass
+    validates :user, presence: true
+  end
+end
+
+UsersTenant = Strongbolt::UsersTenant unless defined? UsersTenant

data/lib/strongbolt/version.rb

@@ -0,0 +1,3 @@
+module Strongbolt
+  VERSION = "0.3.6"
+end

data/lib/tasks/strongbolt_tasks.rake

@@ -0,0 +1,29 @@
+namespace :strongbolt do
+  #
+  # Create full authorization roles that allows to get started using StrongBolt
+  #
+  task :seed => :environment do
+    ActiveRecord::Base.transaction do
+      #
+      # Creates capabilities for all models/actions
+      #
+      Capability.models.each do |model|
+        Capability::Actions.each do |action|
+          Capability.where(model: model, action: action,
+            require_tenant_access: false).first_or_create
+        end
+      end
+
+      # The role
+      role = Role.create! name: "FULL ACCESS (TEMPORARY)"
+      role.capabilities = Capability.all
+
+      # The user group
+      ug = UserGroup.create! name: "FULL ACCESS USERS (TEMPORARY)"
+      ug.roles << role
+
+      # Assign to all users
+      User.all.each { |user| user.user_groups << ug }
+    end
+  end
+end

data/spec/controllers/strongbolt/capabilities_controller_spec.rb

@@ -0,0 +1,254 @@
+require "spec_helper"
+
+module Strongbolt
+
+  describe CapabilitiesController do
+
+    subject { response }
+
+    # #
+    # # GET #index
+    # #
+    # describe "GET #index" do
+      
+    #   before do
+    #     Fabricate :capability
+    #     get :index
+    #   end
+
+    #   it { should be_success }
+
+    #   it { should render_template :index }
+
+    #   it "should assign capabilities" do
+    #     expect(assigns :capabilities).to be_present
+    #     expect(assigns(:capabilities).size).to be > 0
+    #   end
+
+    # end # End GET #index
+
+
+    # #
+    # # GET #show
+    # #
+    # describe "GET #show" do
+    #   let(:capability) { Fabricate :capability }
+
+    #   before { get :show, id: capability.id }
+
+    #   it { should be_success }
+
+    #   it { should render_template :show }
+
+    #   it "should assign capability" do
+    #     expect(assigns :capability).to be_present
+    #   end
+    # end
+
+    #
+    # POST #create
+    #
+    describe "POST #create" do
+
+      let(:create) { post :create, capability: attributes }
+      
+      # context "when valid attributes" do
+      #   let(:attributes) { Fabricate.attributes_for :capability }
+
+      #   it "should redirect to capabilities list" do
+      #     create
+      #     expect(response).to redirect_to capabilities_path
+      #   end
+
+      #   it "should create a capability" do
+      #     expect do
+      #       create
+      #     end.to change(Capability, :count).by 1
+      #   end
+      # end
+
+      context "when valid attributes and role id present" do
+
+        let(:role) { Fabricate :role }
+        let(:attributes) { Fabricate.attributes_for :capability }
+
+        context "html" do
+          let(:create) { post :create, capability: attributes, role_id: role.id }
+
+          it "should redirect to role" do
+            create
+            expect(response).to redirect_to role_path(role)
+          end
+
+          it "should add a capability to the role" do
+            expect do
+              create
+            end.to change(role.capabilities, :count).by 1
+          end
+        end
+
+        context "json" do |variable|
+          let(:create) { post :create, capability: attributes, role_id: role.id, format: :json }
+
+          it "should redirect to role" do
+            create
+            expect(response.code).to eq "200"
+          end
+
+          it "should add a capability to the role" do
+            expect do
+              create
+            end.to change(role.capabilities, :count).by 1
+          end
+        end
+      end
+
+      # context "when same capability already exist" do
+      #   let(:attributes) { Fabricate.attributes_for :capability }
+
+      #   before do
+      #     Fabricate :capability, attributes
+      #   end
+
+      #   it "should redirect to index" do
+      #     create
+      #     expect(response).to redirect_to capabilities_path
+      #   end
+      # end
+
+      # context "when invalid attributes" do
+      #   let(:attributes) { {} }
+
+      #   it "should set flash danger" do
+      #     create
+      #     expect(flash[:danger]).to be_present
+      #   end
+
+      #   it "should redirect to index" do
+      #     create
+      #     expect(response).to redirect_to capabilities_path
+      #   end
+      # end
+
+    end # END POST #create
+
+
+
+    #
+    # DELETE #destroy
+    #
+    describe "DELETE #destroy" do
+
+      before do
+        @capability = Fabricate :capability
+      end
+
+      let(:capability) { @capability }
+
+      let(:destroy) { delete :destroy, id: capability.id }
+
+      # context "when no roles" do
+
+      #   it "should redirect to capabilities list" do
+      #     destroy
+      #     expect(response).to redirect_to capabilities_path
+      #   end
+
+      #   it "should delete a capability" do
+      #     expect do
+      #       destroy
+      #     end.to change(Capability, :count).by -1
+      #   end
+
+      # end
+
+      # context "when roles linked" do
+
+      #   before do
+      #     capability.roles << Fabricate(:role)
+      #   end
+        
+      #   it "should redirect to capabilities list" do
+      #     destroy
+      #     expect(response).to redirect_to capability_path(capability)
+      #   end
+
+      #   it "should not delete a capability" do
+      #     expect do
+      #       destroy
+      #     end.not_to change(Capability, :count)
+      #   end
+
+      #   it "should set flash danger" do
+      #     destroy
+      #     expect(flash[:danger]).to be_present
+      #   end
+
+      # end
+
+      context "when role_id given" do
+        let(:role) { Fabricate :role }
+        
+        before do
+          role.capabilities << capability
+        end
+
+        context "when capability id given" do
+
+          let(:destroy) { delete :destroy, id: capability.id, role_id: role.id }
+
+
+          it "should not delete a capability" do
+            expect do
+              destroy
+            end.not_to change(Capability, :count)
+          end
+
+          it "should remove the capability from role" do
+            destroy
+            role.reload
+            expect(role.capabilities).not_to include capability
+          end
+
+          it "should redirect to role" do
+            destroy
+            expect(response).to redirect_to role_path(role)
+          end
+
+        end
+
+        context "when capability data given and format json" do
+          let(:attributes) do
+            {model: capability.model, require_ownership: capability.require_ownership,
+              require_tenant_access: capability.require_tenant_access,
+              action: capability.action}
+          end
+
+          let(:destroy) { delete :destroy, role_id: role.id, capability: capability.attributes, format: :json }
+
+          it "should not delete a capability" do
+            expect do
+              destroy
+            end.not_to change(Capability, :count)
+          end
+
+          it "should remove the capability from role" do
+            destroy
+            role.reload
+            expect(role.capabilities).not_to include capability
+          end
+
+          it "should render 200" do
+            destroy
+            expect(response.code).to eq "200"
+          end
+        end
+      end
+
+
+    end
+
+
+  end
+
+end

data/spec/controllers/strongbolt/roles_controller_spec.rb

@@ -0,0 +1,228 @@
+require "spec_helper"
+
+module Strongbolt
+  
+  describe RolesController do
+    
+    let!(:role) { Fabricate :role }
+
+    let(:valid_attributes) { Fabricate.attributes_for :role }
+
+    # login_user
+
+    subject { response }
+
+    #
+    # GET #index
+    #
+    describe "GET #index" do
+      
+      before { get :index }
+
+      it { should be_success }
+
+      it { should render_template :index }
+
+      it "should assign roles" do
+        expect(assigns :roles).to eq [role]
+      end
+
+    end
+
+    #
+    # GET #new
+    #
+    describe "GET #new" do
+      
+      before { get :new }
+
+      it { should be_success }
+
+      it { should render_template :new }
+
+    end
+
+
+    #
+    # GET #show
+    #
+    describe "GET #show" do
+      
+      # Some children
+      let(:role2) { Fabricate :role, parent: role }
+      let!(:role3) { Fabricate :role, parent: role2 } 
+      
+      before { get :show, id: role.id }
+
+      it { should be_success }
+
+      it "should assign role" do
+        expect(assigns :role).to eq role
+      end
+
+      it "should assign children" do
+        expect(assigns :descendants).to eq [role2, role3]
+      end
+
+      it { should render_template :show }
+
+    end
+
+    #
+    # GET #edit
+    #
+    describe "GET #edit" do
+      
+      before { get :edit, id: role.id }
+
+      it { should be_success }
+
+      it "should assign role" do
+        expect(assigns :role).to eq role
+      end
+
+      it { should render_template :edit }
+
+    end
+
+    #
+    # POST #create
+    #
+    describe "POST #create" do
+
+      let(:create) { post :create, role: attributes }
+
+      context 'when valid attributes' do
+      
+        let(:attributes) { valid_attributes }
+
+        it "should redirect to show" do
+          create
+          expect(response).to redirect_to role_path(Role.last)
+        end
+
+        it "should create an role" do
+          expect do
+            create
+          end.to change(Role, :count).by 1
+        end
+
+      end
+
+      context "when invalid attributes" do
+        
+        let(:attributes) { {} }
+
+        it "should redirect_to new" do
+          create
+          expect(response).to redirect_to new_role_path
+        end
+
+        it "should not create a role" do
+          expect do
+            create
+          end.not_to change(Role, :count)
+        end
+
+        it "should set flash danger" do
+          create
+          expect(flash[:danger]).to be_present
+        end
+
+      end
+
+    end
+
+
+    #
+    # PUT #update
+    #
+    describe "PUT #update" do
+      
+      before { put :update, id: role.id, role: attributes }
+
+      context 'when valid attributes' do
+        
+        let(:attributes) { valid_attributes }
+
+        it { should redirect_to role_path(role) }
+
+        it "should update attributes" do
+          expect(role.reload.name).to eq valid_attributes[:name]
+        end
+
+      end
+
+      context 'when invalid attributes' do
+        
+        let(:attributes) { {name: ""} }
+
+        it { should redirect_to edit_role_path(role) }
+
+        it "should not update attributes" do
+          expect(role.reload.name).not_to eq ""
+        end
+
+        it "should set flash danger" do
+          expect(flash[:danger]).to be_present
+        end
+
+      end
+
+    end
+
+
+    #
+    # DELETE #destroy
+    #
+    describe "DELETE #destroy" do
+      
+      let(:destroy) { delete :destroy, id: role.id }
+
+      context "when no user" do
+
+        it "should redirect to index" do
+          destroy
+          expect(response).to redirect_to roles_path
+        end
+
+        it "should set flash success" do
+          destroy
+          expect(flash[:success]).to be_present
+        end
+
+        it "should delete a role" do
+          expect do
+            destroy
+          end.to change(Role, :count).by -1
+        end
+
+      end
+
+      context "when has user groups" do
+        
+        let(:role) { Fabricate :role_with_user_groups }
+
+        it "should redirect to show" do
+          destroy
+          expect(response).to redirect_to role_path(role)
+        end
+
+        it "should set flash danger" do
+          destroy
+          expect(flash[:danger]).to be_present
+        end
+
+        it "should not delete a role" do
+          expect do
+            destroy
+          end.not_to change(Role, :count)
+        end
+
+      end
+
+    end
+
+  end
+
+end