rules_engine_users 0.0.1

data/spec/railsenv/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/spec/railsenv/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/spec/railsenv/config/initializers/new_rails_defaults.rb

@@ -0,0 +1,19 @@
+# Be sure to restart your server when you modify this file.
+
+# These settings change the behavior of Rails 2 apps and will be defaults
+# for Rails 3. You can remove this initializer when Rails 3 is released.
+
+if defined?(ActiveRecord)
+  # Include Active Record class name as root for JSON serialized output.
+  ActiveRecord::Base.include_root_in_json = true
+
+  # Store the full class name (including module namespace) in STI type column.
+  ActiveRecord::Base.store_full_sti_class = true
+end
+
+# Use ISO 8601 format for JSON serialized times and dates.
+ActiveSupport.use_standard_json_time_format = true
+
+# Don't escape HTML entities in JSON, leave that for the #json_escape helper.
+# if you're including raw json in an HTML page.
+ActiveSupport.escape_html_entities_in_json = false

data/spec/railsenv/config/initializers/session_store.rb

@@ -0,0 +1,15 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying cookie session data integrity.
+# If you change this key, all old sessions will become invalid!
+# Make sure the secret is at least 30 characters and all random, 
+# no regular words or you'll be exposed to dictionary attacks.
+ActionController::Base.session = {
+  :key         => '_railsenv_session',
+  :secret      => '5b6ce90fd6469cb00f7486f06c61280817a3fde17955abe87a4ae1f02547c6f65d54a1a04e843e0bf4f1694935aa95bddf2f57ce886ffb395a89a3af01d07b4a'
+}
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rake db:sessions:create")
+# ActionController::Base.session_store = :active_record_store

data/spec/railsenv/config/locales/en.yml

@@ -0,0 +1,5 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See http://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  hello: "Hello world"

data/spec/railsenv/config/routes.rb

@@ -0,0 +1,43 @@
+ActionController::Routing::Routes.draw do |map|
+  # The priority is based upon order of creation: first created -> highest priority.
+
+  # Sample of regular route:
+  #   map.connect 'products/:id', :controller => 'catalog', :action => 'view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  #   map.purchase 'products/:id/purchase', :controller => 'catalog', :action => 'purchase'
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # Sample resource route (maps HTTP verbs to controller actions automatically):
+  #   map.resources :products
+
+  # Sample resource route with options:
+  #   map.resources :products, :member => { :short => :get, :toggle => :post }, :collection => { :sold => :get }
+
+  # Sample resource route with sub-resources:
+  #   map.resources :products, :has_many => [ :comments, :sales ], :has_one => :seller
+  
+  # Sample resource route with more complex sub-resources
+  #   map.resources :products do |products|
+  #     products.resources :comments
+  #     products.resources :sales, :collection => { :recent => :get }
+  #   end
+
+  # Sample resource route within a namespace:
+  #   map.namespace :admin do |admin|
+  #     # Directs /admin/products/* to Admin::ProductsController (app/controllers/admin/products_controller.rb)
+  #     admin.resources :products
+  #   end
+
+  # You can have the root of your site routed with map.root -- just remember to delete public/index.html.
+  # map.root :controller => "welcome"
+
+  # See how all your routes lay out with "rake routes"
+
+  # Install the default routes as the lowest priority.
+  # Note: These default routes make all actions in every controller accessible via GET requests. You should
+  # consider removing the them or commenting them out if you're using named routes and resources.
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/spec/railsenv/db/test.sqlite3

@@ -0,0 +1 @@
+S

data/spec/railsenv/log/debug.log

@@ -0,0 +1 @@
+# Logfile created on Tue Mar 09 23:35:57 +1100 2010

data/spec/railsenv/log/test.log

@@ -0,0 +1 @@
+# Logfile created on Tue Feb 23 14:37:00 +1100 2010

data/spec/rcov.opts

@@ -0,0 +1,3 @@
+--exclude "spec/*,gems/*,tmp/,features/*" 
+--rails
+--aggregate coverage.data

data/spec/rules_engine/controller_user_mail_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# class MockControllerUsersController < ActionController::Base
+# 
+# end
+# 
+describe "ControllerUserMail", :type => :helper  do
+  # controller_name 'MockControllerUsers'
+  
+  describe "host name" do
+    it "should set the host name to localhost:3000" do
+      RulesEngine::ControllerUserMail.host.should == "localhost:3000"
+    end
+
+    it "should set the host name to the host defined" do
+      RulesEngine::ControllerUserMail.host = "mock host"
+      RulesEngine::ControllerUserMail.host.should == "mock host"
+    end
+  end    
+  
+  describe "from" do
+    it "should set the from to Do Not Reply <do_not_reply@localhost:3000>" do
+      RulesEngine::ControllerUserMail.from.should == "Do Not Reply <do_not_reply@localhost:3000>"
+    end
+
+    it "should set the host name to the host defined" do
+      RulesEngine::ControllerUserMail.from = "mock from"
+      RulesEngine::ControllerUserMail.from.should == "mock from"
+    end
+  end    
+
+  describe "prefix" do
+    it "should be blank by default" do
+      RulesEngine::ControllerUserMail.prefix.should be_blank
+    end
+
+    it "should set the host name to the host defined" do
+      RulesEngine::ControllerUserMail.prefix = "mock from"
+      RulesEngine::ControllerUserMail.prefix.should == "mock from"
+    end
+  end    
+  
+end  

data/spec/rules_engine/controller_users_spec.rb

@@ -0,0 +1,337 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class MockControllerUsersController < ActionController::Base
+
+end
+
+describe "ControllerUsers", :type => :controller  do
+  controller_name 'MockControllerUsers'
+  
+  before(:each) do    
+    @current_user = mock_model(User)
+    @current_user.stub!(:remember_token).and_return('mock_token')
+    @current_user.stub!(:remember_token_expires_at).and_return(30.days.from_now)
+    
+    User.stub!(:find_by_id).and_return(nil)
+    User.stub!(:authenticate_by_email).and_return(nil)
+    User.stub!(:authenticate_by_login).and_return(nil)
+    User.stub!(:authenticate_by_remember_token).and_return(nil)
+    
+    controller.stub!(:cookies).and_return(:auth_token => 'mock_token')
+    controller.stub!(:session).and_return(:user_id => 'mock_session_id')
+    @credentials = ActionController::HttpAuthentication::Basic.encode_credentials("mock_name", "mock_password")
+    request.env['HTTP_AUTHORIZATION'] = @credentials    
+    
+    @format = mock("format") 
+    @format.stub!(:js).and_yield(controller)
+    @format.stub!(:html).and_yield(controller)
+    controller.stub!(:respond_to).and_yield(@format)  
+    @js = ""  
+    controller.stub!(:render).with(:update).and_yield(@js)    
+    
+    controller.stub!(:user_login_path).and_return('/login')
+    controller.stub!(:root_path).and_return('/root')
+  end
+      
+  describe "getting the current user" do    
+    it "should try the session" do
+      User.should_receive(:find_by_id).with('mock_session_id').and_return(@current_user)
+      controller.current_user.should == @current_user
+    end
+  
+    it "should try basic authentication by email" do
+      User.should_receive(:authenticate_by_email).with("mock_name", "mock_password").and_return(@current_user)      
+      controller.current_user.should == @current_user
+    end
+
+    it "should try basic authentication by login" do
+      User.should_receive(:authenticate_by_login).with("mock_name", "mock_password").and_return(@current_user)      
+      controller.current_user.should == @current_user
+    end
+  
+  
+    it "should get the cookie" do
+      User.stub!(:authenticate_by_remember_token).with('mock_token').and_return(@current_user)
+      controller.current_user.should == @current_user
+    end
+        
+    it "should return nil if previous calls to the current user have failed" do
+      controller.current_user.should be_nil
+      controller.current_user.should be_nil
+    end
+    
+    it "should return the current user if previous calls to current user have passed" do
+      User.stub!(:find_by_id).once.and_return(@current_user)
+      controller.current_user.should == @current_user
+      controller.current_user.should == @current_user
+    end
+  end    
+  
+  describe "checking the login" do
+    it "should tell us if the user is logged in" do
+      controller.should_receive(:current_user).and_return(@current_user)
+      controller.should be_logged_in
+    end
+  
+    it "should tell us if the user is logged in" do
+      controller.should_receive(:current_user).and_return(nil)
+      controller.should_not be_logged_in
+    end
+  end
+  
+  describe "checking for an administrator" do
+    before(:each) do
+      controller.stub!(:current_user).and_return(@current_user)
+    end
+  
+    it "should tell us if the current user is an administrator" do
+      @current_user.should_receive(:access_level).and_return(User::ACCESS_LEVEL_ADMIN)
+      controller.should be_logged_in
+      controller.should be_logged_in_as_admin
+    end
+  
+    it "should tell us if the current user is not an administrator" do
+      @current_user.should_receive(:access_level).and_return(101)
+      controller.should be_logged_in
+      controller.should_not be_logged_in_as_admin
+    end
+  end
+  
+  describe "checking for a disabled account" do
+    before(:each) do
+      controller.stub!(:current_user).and_return(@current_user)
+    end
+  
+    it "should tell us if the current user's account is disabled" do
+      @current_user.should_receive(:access_level).and_return(User::ACCESS_LEVEL_DISABLED)
+      controller.should be_logged_in
+      controller.should be_logged_in_disabled
+    end
+  end
+    
+  describe "login required" do
+    before(:each) do
+      controller.stub!(:logged_in?).and_return(false)
+      controller.stub!(:redirect_to)
+    end
+    
+    it "should pass if the user is logged in" do
+      controller.should_receive(:logged_in?).and_return(true)
+      controller.login_required
+      flash[:error].should be_blank
+    end
+    
+    it "should set an error message if the user is not logged in" do
+      controller.should_receive(:access_denied)
+      controller.login_required
+      flash[:error].should_not be_blank
+    end
+    
+    it "should redirect to login page if the user is not logged in" do
+      controller.should_receive(:redirect_to).with('/login')
+      controller.login_required
+    end
+
+    it "should set the js window location to the login page if the user is not logged in" do
+      @format.stub!(:html)
+      controller.should_receive(:render).with(:update).and_yield(@js)    
+      controller.login_required
+      @js.should == "window.location.href = '/login';"
+    end
+  end    
+  
+  describe "admin access required" do
+    before(:each) do
+      controller.stub!(:logged_in?).and_return(true)
+      controller.stub!(:logged_in_as_admin?).and_return(false)
+      controller.stub!(:redirect_to)
+      controller.stub!(:current_user).and_return(@current_user)
+    end
+    
+    it "should pass if the user is logged in and is an administrator" do
+      controller.stub!(:logged_in_as_admin?).and_return(true)
+      @current_user.stub!(:access_level).and_return(User::ACCESS_LEVEL_ADMIN)
+      controller.admin_access_required
+      
+      flash[:error].should be_blank
+    end
+    
+    it "should set an error message if the user is not logged in" do
+      controller.stub!(:logged_in?).and_return(false)
+      controller.admin_access_required
+      flash[:error].should_not be_blank
+    end
+  
+    it "should redirect to the login page if the user is not logged in" do
+      controller.stub!(:logged_in?).and_return(false)
+      controller.should_receive(:redirect_to).with('/login')
+      controller.admin_access_required
+    end
+    
+    it "should set the js window location to the login page if the user is not logged in" do
+      controller.stub!(:logged_in?).and_return(false)
+      @format.stub!(:html)
+      controller.should_receive(:render).with(:update).and_yield(@js)    
+      controller.admin_access_required
+      @js.should == "window.location.href = '/login';"
+    end
+    
+    it "should set an error message if the user is not an administrator" do
+      @current_user.stub!(:access_level).and_return(101)
+      controller.admin_access_required
+      flash[:error].should_not be_blank
+    end    
+    
+    it "should redirect to root path if the user is not an administrator" do
+      @current_user.stub!(:access_level).and_return(101)
+      controller.should_receive(:redirect_to).with('/root')
+      controller.admin_access_required
+    end
+
+    it "should set the js window location to the login page if the user is not an administrator" do
+      @current_user.stub!(:access_level).and_return(101)
+      @format.stub!(:html)
+      controller.should_receive(:render).with(:update).and_yield(@js)    
+      controller.admin_access_required
+      @js.should == "window.location.href = '/root';"
+    end
+    
+  end
+  
+  describe "user access level" do
+    it "should return the admin access level" do
+      @current_user.stub!(:access_level).and_return(User::ACCESS_LEVEL_ADMIN)
+      controller.user_access_level(@current_user).should == "Administrator"
+    end
+
+    it "should return the account disabled access level" do
+      @current_user.stub!(:access_level).and_return(User::ACCESS_LEVEL_DISABLED)
+      controller.user_access_level(@current_user).should == "Account Disabled"
+    end    
+  end
+
+  describe "user access levels" do
+    it "should return the access levels" do
+      controller.user_access_levels.should include ["Administrator", User::ACCESS_LEVEL_ADMIN]
+      controller.user_access_levels.should include ["Account Disabled", User::ACCESS_LEVEL_DISABLED]
+    end
+  end
+  
+  describe "defining new access levels" do
+    before(:each) do
+      MockControllerUsersController.define_access_level(:reporter, 200)
+    end
+    
+    describe "_access_level" do
+      it "should return the access level" do
+        ActionController::Base.reporter_access_level.should == 200
+      end
+    end    
+    
+    describe "logged_in_as_? method" do
+      before(:each) do
+        controller.stub!(:current_user).and_return(@current_user)
+      end
+      
+      it "should pass if the current user has the access level" do
+        @current_user.stub!(:access_level).and_return(200)
+        controller.should be_logged_in
+        controller.should be_logged_in_as_reporter
+      end
+
+      it "should pass if the current user has an access level greater than that required" do
+        @current_user.stub!(:access_level).and_return(201)
+        controller.should be_logged_in
+        controller.should be_logged_in_as_reporter
+      end
+  
+      it "should fail if the current user has an access level less than that required" do
+        @current_user.stub!(:access_level).and_return(199)
+        controller.should be_logged_in
+        controller.should_not be_logged_in_as_reporter
+      end      
+    end
+
+    describe "_access_required method" do
+      before(:each) do
+        controller.stub!(:logged_in?).and_return(true)
+        controller.stub!(:redirect_to)
+        controller.stub!(:current_user).and_return(@current_user)
+      end
+    
+      it "should pass if the user is logged in and has the access level" do
+        controller.stub!(:logged_in_as_admin?).and_return(true)
+        @current_user.stub!(:access_level).and_return(200)
+        controller.reporter_access_required
+      
+        flash[:error].should be_blank
+      end
+    
+      it "should pass if the user is logged in and has an access level greater than that required" do
+        controller.stub!(:logged_in_as_admin?).and_return(true)
+        @current_user.stub!(:access_level).and_return(201)
+        controller.reporter_access_required
+      
+        flash[:error].should be_blank
+      end
+    
+      it "should set an error message if the user is not logged in" do
+        controller.stub!(:logged_in?).and_return(false)
+        controller.admin_access_required
+        flash[:error].should_not be_blank
+      end
+  
+      it "should redirect to the login page if the user is not logged in" do
+        controller.stub!(:logged_in?).and_return(false)
+        controller.should_receive(:access_denied)
+        controller.reporter_access_required
+      end
+  
+      it "should set an error message if the user is does not have the access level required" do
+        controller.stub!(:logged_in_as_admin?).and_return(false)
+        @current_user.stub!(:access_level).and_return(199)
+        controller.should_receive(:user_access_denied)
+        controller.reporter_access_required
+        flash[:error].should_not be_blank
+      end    
+    
+      it "should redirect to root path if the user is does not have the access level required" do
+        controller.stub!(:logged_in_as_admin?).and_return(false)
+        @current_user.stub!(:access_level).and_return(199)
+        controller.should_receive(:user_access_denied)
+        controller.reporter_access_required
+      end
+    end
+
+    describe "user access level" do
+      it "should return the admin access level" do
+        @current_user.stub!(:access_level).and_return(200)
+        controller.user_access_level(@current_user).should == "Reporter"
+      end
+    end
+
+    describe "user access levels" do
+      it "should return the access levels" do
+        controller.user_access_levels.should include ["Reporter", 200]
+      end
+    end
+    
+    describe "user time zone" do
+      it "Set the time zone to the user's timezone" do
+        controller.stub!(:current_user).and_return(@current_user)
+        @current_user.stub!(:time_zone).and_return('mock time zone')
+        Time.should_receive(:zone=).with('mock time zone')
+        
+        controller.set_timezone
+      end
+
+      it "Set the time zone to the default timezone when not set" do
+        controller.stub!(:current_user).and_return(nil)
+        # @current_user.stub!(:time_zone).and_return('mock time zone')
+        Time.should_receive(:zone=).with('Eastern Time (US & Canada)')
+        
+        controller.set_timezone
+      end
+    end    
+  end
+end  

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# The minimal Rails project was created to run specs against using:
+# rails -m http://github.com/robinsp/rails_templates/raw/master/minimal.rb railsenv
+
+
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/railsenv/config/environment")
+require 'spec'
+require 'spec/rails'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures  = false
+  # config.mock_with :mocha
+end
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/railsenv/log/debug.log")
+
+# require File.expand_path(File.dirname(__FILE__) + "/../rails_generators/templates/app/models/user.rb")
+class User < ActiveRecord::Base
+  ACCESS_LEVEL_ADMIN      = 999   # administrator access 
+  ACCESS_LEVEL_DISABLED   = 0     # disabled access 
+  def self.columns() @columns ||= []; end
+  # def self.column(name, sql_type = nil, default = nil, null = true)
+  #   columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+  # end
+  
+end
+
+Dir["#{File.dirname(__FILE__)}/../lib/*.rb"].each {|f| require f}

data/tasks/rspec.rake

@@ -0,0 +1,18 @@
+require 'spec/rake/spectask'
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs in spec directory with RCov (excluding plugin specs)"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/../spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = lambda do
+      IO.readlines("#{File.dirname(__FILE__)}/../spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+    end
+  end
+end