lockdown_vail 1.6.2.1

data/spec/lockdown/frameworks/rails/view_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+class TestAView
+  def link_to
+    "link_to"
+  end
+
+  def button_to
+    "button_to"
+  end
+
+  include Lockdown::Frameworks::Rails::View
+end
+
+describe Lockdown::Frameworks::Rails::Controller do
+
+  before do
+    @view = TestAView.new
+
+    @view.stub!(:url_for).and_return("posts/new")
+
+    @options = {:controller => "posts", :action => "new"}
+  end
+
+  describe "#link_to_secured" do
+    it "should return the link if authorized" do
+      link = "<a href='http://a.com'>my_link</a>"
+      @view.stub!(:authorized?).and_return(true)
+      @view.stub!(:link_to_open).and_return(link)
+
+      @view.link_to_secured("my link", @options).should == link
+    end
+
+     it "should return an empty string if authorized" do
+      @view.stub!(:authorized?).and_return(false)
+
+      @view.link_to_secured("my link", @options).should == ""
+    end 
+  end
+
+  describe "#button_to_secured" do
+    it "should return the link if authorized" do
+      link = "<a href='http://a.com'>my_link</a>"
+      @view.stub!(:authorized?).and_return(true)
+      @view.stub!(:button_to_open).and_return(link)
+
+      @view.button_to_secured("my link", @options).should == link
+    end
+
+     it "should return an empty string if authorized" do
+      @view.stub!(:authorized?).and_return(false)
+
+      @view.button_to_secured("my link", @options).should == ""
+    end 
+  end
+
+  describe "#link_to_or_show" do
+    it "should return the name if link_to returned an empty string" do
+      @view.stub!(:link_to).and_return('')
+
+      @view.link_to_or_show("my_link", @options).
+        should == "my_link"
+    end
+
+    it "should return the link if access is allowed" do
+      link = "<a href='http://a.com'>my_link</a>"
+      @view.stub!(:link_to).and_return(link)
+
+      @view.link_to_or_show("my_link", @options).
+        should == link
+    end
+  end
+
+  describe "#link_to_or_show" do
+    it "should return links separated by | " do
+      Lockdown::System.stub!(:fetch).with(:link_separator).and_return(' | ')
+      links = ["link_one", "link_two"]
+      @view.links(links).should == links.join(' | ')
+    end
+
+    it "should return links separated by | and handle empty strings" do
+      Lockdown::System.stub!(:fetch).with(:link_separator).and_return(' | ')
+      links = ["link_one", "link_two", ""]
+      @view.links(links).should == links.join(' | ')
+    end
+  end
+end

data/spec/lockdown/frameworks/rails_spec.rb

@@ -0,0 +1,163 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Lockdown::Frameworks::Rails do
+  before do
+    @rails = Lockdown::Frameworks::Rails
+
+    @rails.stub!(:use_me?).and_return(true)
+
+    @lockdown = mock("lockdown")        
+  end
+
+
+  describe "#included" do
+    it "should extend lockdown with rails environment" do
+      @lockdown.should_receive(:extend).
+        with(Lockdown::Frameworks::Rails::Environment)
+
+      @rails.should_receive(:mixin)
+
+      @rails.included(@lockdown)
+    end
+  end
+
+  describe "#mixin" do
+    it "should perform class_eval on controller view and system to inject itself" do
+
+      @view_helper = Mikey
+      @view_helper.should_receive(:include).
+        with( Lockdown::Frameworks::Rails::View )
+
+      Lockdown.should_receive(:view_helper) do 
+        @view_helper
+      end
+
+      @system = Mikey
+      @system.should_receive(:extend).
+        with( Lockdown::Frameworks::Rails::System )
+
+      Lockdown.should_receive(:system) do 
+        @system
+      end
+
+      @rails.should_receive(:mixin_controller)
+
+      @rails.mixin
+    end
+
+  end
+
+  describe "#mixin_controller" do
+
+    it "should inject itself" do
+      klass = Mikey
+
+      klass.should_receive(:include).
+        with(Lockdown::Session)
+
+      klass.should_receive(:include).
+        with(Lockdown::Frameworks::Rails::Controller::Lock)
+
+      klass.should_receive(:helper_method).with(:authorized?)
+
+      klass.should_receive(:hide_action).with(:set_current_user, :configure_lockdown, :check_request_authorization, :check_model_authorization)
+
+      klass.should_receive(:before_filter).and_return do |c|
+        #not working yet. very frustrating trying to test this
+      end
+
+      klass.should_receive(:filter_parameter_logging)
+
+      klass.should_receive(:rescue_from).exactly(:twice)
+
+      @rails.mixin_controller(klass)
+    end
+  end
+
+end
+
+RAILS_ROOT = "/shibby/dibby/do"
+
+module ActionController; class Base; end end
+
+class ApplicationController; end
+
+module ActionView; class Base; end end
+
+describe Lockdown::Frameworks::Rails::Environment do
+
+  before do
+    @env = class Test; extend Lockdown::Frameworks::Rails::Environment; end
+  end
+
+  describe "#project_root" do
+    it "should return rails root" do
+      @env.project_root.should == "/shibby/dibby/do"
+    end
+  end
+
+  describe "#init_file" do
+    it "should return path to init_file" do
+      @env.stub!(:project_root).and_return("/shibby/dibby/do")
+      @env.init_file.should == "/shibby/dibby/do/lib/lockdown/init.rb"
+    end
+  end
+
+  describe "#controller_class_name" do
+    it "should add Controller to name" do
+      @env.controller_class_name("user").should == "UserController"
+    end
+
+    it "should convert two underscores to a namespaced controller" do
+      @env.controller_class_name("admin__user").should == "Admin::UserController"
+    end
+  end
+
+  describe "#controller_parent" do
+    it "should return ActionController::Base if not caching classes" do
+      @env.should_receive(:caching?).and_return(false)
+      @env.controller_parent.should == ActionController::Base
+    end
+
+    it "should return ApplicationController if caching classes" do
+      @env.should_receive(:caching?).and_return(true)
+      @env.controller_parent.should == ApplicationController
+    end
+
+  end
+
+  describe "#view_helper" do
+    it "should return ActionView::Base" do
+      
+      @env.view_helper.should == ActionView::Base
+    end
+  end
+end
+
+describe Lockdown::Frameworks::Rails::System do
+  class Test 
+    extend Lockdown::Frameworks::Rails::System
+  end
+
+  before do
+    @env = Test
+  end
+
+  describe "#skip_sync?" do
+    it "should return true if env == skip sync" do
+      Lockdown::System.stub!(:fetch).with(:skip_db_sync_in).and_return(['test'])
+      @env.should_receive(:framework_environment).and_return("test")
+      
+      @env.skip_sync?.should == true
+    end
+
+    it "should return false if env not in skip_sync" do
+      Lockdown::System.stub!(:fetch).with(:skip_db_sync_in).and_return(['test', 'ci'])
+      @env.should_receive(:framework_environment).and_return("qa")
+      
+      @env.skip_sync?.should == false
+    end
+    
+  end
+
+end

data/spec/lockdown/permission_spec.rb

@@ -0,0 +1,156 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+describe Lockdown::Permission do
+  before do
+    
+    @permission = Lockdown::Permission.new(:user_management)
+    @permission.stub!(:paths_for).and_return([])
+  end
+
+  describe "#with_controller" do
+    before do
+      @permission.with_controller(:users)
+    end
+
+    it "should set current_context to ControllerContext" do
+      @permission.current_context.class.should equal(Lockdown::ControllerContext)
+    end
+  end
+
+  describe "#only_methods" do
+    before do
+      @permission.with_controller(:users).only_methods(:show, :edit)
+    end
+
+    it "should set current_context to RootContext" do
+      @permission.current_context.class.should equal(Lockdown::RootContext)
+    end
+  end
+
+  describe "#except_methods" do
+    before do
+      @permission.with_controller(:users).except_methods(:destroy)
+    end
+
+    it "should set current_context to RootContext" do
+      @permission.current_context.class.should equal(Lockdown::RootContext)
+    end
+  end
+
+  describe "#to_model" do
+    before do
+      @permission.to_model(:user)
+    end
+
+    it "should set current_context to ModelContext" do
+      @permission.current_context.class.should equal(Lockdown::ModelContext)
+    end
+  end
+
+  describe "#where" do
+    before do
+      @permission.to_model(:user).where(:current_user_id)
+    end
+
+    it "should set current_context to ModelWhereContext" do
+      @permission.current_context.class.should equal(Lockdown::ModelWhereContext)
+    end
+  end
+
+  describe "#equals" do
+    before do
+      @permission.to_model(:user).where(:current_user_id).equals(:id)
+    end
+
+    it "should set current_context to RootContext" do
+      @permission.current_context.class.should equal(Lockdown::RootContext)
+    end
+  end
+
+  describe "#is_in" do
+    before do
+      @permission.to_model(:user).where(:current_user_id).is_in(:manager_ids)
+    end
+
+    it "should set current_context to RootContext" do
+      @permission.current_context.class.should equal(Lockdown::RootContext)
+    end
+  end
+
+  describe "#set_as_public_access" do
+    it "should raise an PermissionScopeCollision if already protected" do
+      @permission.set_as_protected_access
+      lambda{@permission.set_as_public_access}.
+        should raise_error(Lockdown::PermissionScopeCollision)
+    end
+  end
+
+
+  describe "#set_as_protected_access" do
+    it "should raise an PermissionScopeCollision if already public" do
+      @permission.set_as_public_access
+      lambda{@permission.set_as_protected_access}.
+        should raise_error(Lockdown::PermissionScopeCollision)
+    end
+  end
+
+  describe "while in RootContext" do
+    before do
+      @permission.with_controller(:users).only_methods(:show, :edit)
+    end
+
+    it "should raise InvalidRuleContext trying to access methods out of context" do
+      methods = [:only_methods, :except_methods, :where, :equals, :is_in, :includes]
+
+        methods.each do |method|
+          lambda{@permission.send(method, :sample_param)}.
+            should raise_error(Lockdown::InvalidRuleContext)
+        end
+    end
+  end
+
+  describe "while in ControllerContext" do
+    before do
+      @permission.with_controller(:users)
+    end
+
+    it "should raise InvalidRuleContext trying to access methods out of context" do
+      methods = [:where, :equals, :is_in, :includes]
+
+        methods.each do |method|
+          lambda{@permission.send(method, :sample_param)}.
+            should raise_error(Lockdown::InvalidRuleContext)
+        end
+    end
+  end
+
+  describe "while in ModelContext" do
+    before do
+      @permission.to_model(:user)
+    end
+
+    it "should raise InvalidRuleContext trying to access methods out of context" do
+      methods = [:with_controller, :and_controller, :only_methods, :except_methods, :to_model, :equals, :is_in, :includes]
+
+        methods.each do |method|
+          lambda{@permission.send(method, :sample_param)}.
+            should raise_error(Lockdown::InvalidRuleContext)
+        end
+    end
+  end
+
+  describe "while in ModelWhereContext" do
+    before do
+      @permission.to_model(:user).where(:current_user_id)
+    end
+
+    it "should raise InvalidRuleContext trying to access methods out of context" do
+      methods = [:with_controller, :and_controller, :only_methods, :except_methods, :to_model, :where]
+
+        methods.each do |method|
+          lambda{@permission.send(method, :sample_param)}.
+            should raise_error(Lockdown::InvalidRuleContext)
+        end
+    end
+  end
+end

data/spec/lockdown/rspec_helper_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+require 'lockdown/rspec_helper'
+
+class TestAController
+  extend Lockdown::Frameworks::Rails::Controller
+  include Lockdown::Frameworks::Rails::Controller::Lock
+end
+
+class RspecEnv
+end
+
+describe Lockdown::RspecHelper do
+  before do
+    @controller = TestAController.new
+    @controller.stub!(:session).and_return({})
+
+    usr = mock  :user, 
+                :first_name => 'John',
+                :last_name  => 'Smith',
+                :password   => 'mysecret',
+                :password_confirmation  => 'mysecret'
+
+    usr_group = mock :usr_group
+
+    Lockdown.should_receive(:maybe_parse_init)
+    RspecEnv.send :include, Lockdown::RspecHelper
+    @rspec_env = RspecEnv.new
+    @rspec_env.stub!(:controller).and_return(@controller)
+    @rspec_env.stub!(:mock_user).and_return(usr)
+    @rspec_env.stub!(:mock_user_group).and_return(usr_group)
+  end
+
+  describe "#login_admin" do
+    it "should set access_rights to :all" do 
+      @rspec_env.login_admin
+      #@rspec_env.controller.session[:access_rights].should == :all
+      @rspec_env.controller.session[:user_groups].should == [Lockdown.administrator_group_symbol]
+    end
+  end
+end