parlement 0.14 → 0.17

data/vendor/plugins/login_engine/lib/login_engine/authenticated_user.rb

@@ -1,155 +0,0 @@
-require 'digest/sha1'
-
-# this model expects a certain database layout and its based on the name/login pattern. 
-
-module LoginEngine
-  module AuthenticatedUser
-
-    def self.included(base)
-      base.class_eval do
-
-        # use the table name given
-        set_table_name LoginEngine.config(:user_table)
-
-        attr_accessor :new_password
-      
-        validates_presence_of :login
-        validates_length_of :login, :within => 3..40
-        validates_uniqueness_of :login
-        validates_uniqueness_of :email
-        validates_format_of :email, :with => /^[^@]+@.+$/
-
-        validates_presence_of :password, :if => :validate_password?
-        validates_confirmation_of :password, :if => :validate_password?
-        validates_length_of :password, { :minimum => 5, :if => :validate_password? }
-        validates_length_of :password, { :maximum => 40, :if => :validate_password? }
-  
-        protected 
-      
-        attr_accessor :password, :password_confirmation
-      
-        after_save :falsify_new_password
-        after_validation :crypt_password
-
-      end
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-    
-      def authenticate(login, pass)
-        u = find(:first, :conditions => ["login = ? AND verified = 1 AND deleted = 0", login])
-        return nil if u.nil?
-        find(:first, :conditions => ["login = ? AND salted_password = ? AND verified = 1", login, AuthenticatedUser.salted_password(u.salt, AuthenticatedUser.hashed(pass))])
-      end
-
-      def authenticate_by_token(id, token)
-        # Allow logins for deleted accounts, but only via this method (and
-        # not the regular authenticate call)
-        u = find(:first, :conditions => ["#{User.primary_key} = ? AND security_token = ?", id, token])
-        return nil if u.nil? or u.token_expired?
-        return nil if false == u.update_expiry
-        u
-      end
-      
-    end
-  
-
-    protected
-    
-      def self.hashed(str)
-        # check if a salt has been set...
-        if LoginEngine.config(:salt) == nil
-          raise "You must define a :salt value in the configuration for the LoginEngine module."
-        end
-  
-        return Digest::SHA1.hexdigest("#{LoginEngine.config(:salt)}--#{str}--}")[0..39]
-      end
-    
-      def self.salted_password(salt, hashed_password)
-        hashed(salt + hashed_password)
-      end
-    
-    public
-  
-    # hmmm, how does this interact with the developer's own User model initialize?
-    # We would have to *insist* that the User.initialize method called 'super'
-    #
-    def initialize(attributes = nil)
-      super
-      @new_password = false
-    end
-
-    def token_expired?
-      self.security_token and self.token_expiry and (Time.now > self.token_expiry)
-    end
-
-    def update_expiry
-      write_attribute('token_expiry', [self.token_expiry, Time.at(Time.now.to_i + 600 * 1000)].min)
-      write_attribute('authenticated_by_token', true)
-      write_attribute("verified", 1)
-      update_without_callbacks
-    end
-
-    def generate_security_token(hours = nil)
-      if not hours.nil? or self.security_token.nil? or self.token_expiry.nil? or 
-          (Time.now.to_i + token_lifetime / 2) >= self.token_expiry.to_i
-        return new_security_token(hours)
-      else
-        return self.security_token
-      end
-    end
-
-    def set_delete_after
-      hours = LoginEngine.config(:delayed_delete_days) * 24
-      write_attribute('deleted', 1)
-      write_attribute('delete_after', Time.at(Time.now.to_i + hours * 60 * 60))
-
-      # Generate and return a token here, so that it expires at
-      # the same time that the account deletion takes effect.
-      return generate_security_token(hours)
-    end
-
-    def change_password(pass, confirm = nil)
-      self.password = pass
-      self.password_confirmation = confirm.nil? ? pass : confirm
-      @new_password = true
-    end
-    
-    protected
-
-    def validate_password?
-      @new_password
-    end
-
-
-    def crypt_password
-      if @new_password
-        write_attribute("salt", AuthenticatedUser.hashed("salt-#{Time.now}"))
-        write_attribute("salted_password", AuthenticatedUser.salted_password(salt, AuthenticatedUser.hashed(@password)))
-      end
-    end
-
-    def falsify_new_password
-      @new_password = false
-      true
-    end
-
-    def new_security_token(hours = nil)
-      write_attribute('security_token', AuthenticatedUser.hashed(self.salted_password + Time.now.to_i.to_s + rand.to_s))
-      write_attribute('token_expiry', Time.at(Time.now.to_i + token_lifetime(hours)))
-      update_without_callbacks
-      return self.security_token
-    end
-
-    def token_lifetime(hours = nil)
-      if hours.nil?
-        LoginEngine.config(:security_token_life_hours) * 60 * 60
-      else
-        hours * 60 * 60
-      end
-    end
-
-  end
-end
-  

data/vendor/plugins/login_engine/public/stylesheets/login_engine.css

@@ -1,81 +0,0 @@
-/*
-
-  This CSS file is basically the scaffold.css file, and is only
-  included here to demonstrate using CSS files with Engines.
-
-*/
-
-body { background-color: #fff; color: #333; }
-
-body, p, ol, ul, td {
-  font-family: verdana, arial, helvetica, sans-serif;
-  font-size:   13px;
-  line-height: 18px;
-}
-
-pre {
-  background-color: #eee;
-  padding: 10px;
-  font-size: 11px;
-}
-
-a { color: #000; }
-a:visited { color: #666; }
-a:hover { color: #fff; background-color:#000; }
-
-.fieldWithErrors {
-  padding: 2px;
-  background-color: red;
-  display: table;
-}
-
-#ErrorExplanation {
-  width: 400px;
-  border: 2px solid red;
-  padding: 7px;
-  padding-bottom: 12px;
-  margin-bottom: 20px;
-  background-color: #f0f0f0;
-}
-
-#ErrorExplanation h2 {
-  text-align: left;
-  font-weight: bold;
-  padding: 5px 5px 5px 15px;
-  font-size: 12px;
-  margin: -7px;
-  background-color: #c00;
-  color: #fff;
-}
-
-#ErrorExplanation p {
-  color: #333;
-  margin-bottom: 0;
-  padding: 5px;
-}
-
-#ErrorExplanation ul li {
-  font-size: 12px;
-  list-style: square;
-}
-
-div.uploadStatus {
-  margin: 5px;
-}
-
-div.progressBar {
-  margin: 5px;
-}
-
-div.progressBar div.border {
-  background-color: #fff;
-  border: 1px solid grey;
-  width: 100%;
-}
-
-div.progressBar div.background {
-  background-color: #333;
-  height: 18px;
-  width: 0%;
-}
-

data/vendor/plugins/login_engine/test/fixtures/users.yml

@@ -1,41 +0,0 @@
-# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
-
-bob:
-  id: 1000001
-  login: bob
-  salted_password: b1de1d1d2aec05df2be6f02995537c1783f08490 # atest
-  salt: bf3c47e71c0bfeb6288c9b6b5e24e15256a0e407
-  email: bob@test.com
-  verified: 1
-  
-existingbob:
-  id: 1000002
-  login: existingbob
-  salted_password: b1de1d1d2aec05df2be6f02995537c1783f08490 # atest
-  salt: bf3c47e71c0bfeb6288c9b6b5e24e15256a0e407
-  email: existingbob@test.com
-  verified: 1  
-
-longbob:
-  id: 1000003
-  login: longbob
-  salted_password: 53427dca242488e885216a579e362ee888c3ebc1 # alongtest
-  salt: d35a9cc89af83799d9a938a74cb06a11d295aa9c
-  email: longbob@test.com
-  verified: 1
-
-deletebob1:
-  id: 1000004
-  login: deletebob1
-  salted_password: 53427dca242488e885216a579e362ee888c3ebc1 # alongtest
-  salt: d35a9cc89af83799d9a938a74cb06a11d295aa9c
-  email: deletebob1@test.com
-  verified: 1
-
-deletebob2:
-  id: 1000005
-  login: deletebob2
-  salted_password: 53427dca242488e885216a579e362ee888c3ebc1 # alongtest
-  salt: d35a9cc89af83799d9a938a74cb06a11d295aa9c
-  email: deletebob2@test.com
-  verified: 1

data/vendor/plugins/login_engine/test/functional/user_controller_test.rb

@@ -1,536 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require_dependency 'user_controller'
-
-
-# Raise errors beyond the default web-based presentation
-class UserController; def rescue_action(e) raise e end; end
-
-class UserControllerTest < Test::Unit::TestCase
-  
-  # load the fixture into the developer-specified table using the custom
-  # 'fixture' method.
-  fixture :users, :table_name => LoginEngine.config(:user_table), :class_name => "User"
-  
-  def setup
-    
-    LoginEngine::CONFIG[:salt] = "test-salt"
-    
-    @controller = UserController.new
-    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
-    @request.host = "localhost"
-  end
-
-
-  
-  #==========================================================================
-  #
-  # Login/Logout
-  #
-  #==========================================================================
-
-  def test_home_without_login
-    get :home
-    assert_redirected_to :action => "login"
-  end
-
-  def test_invalid_login
-    post :login, :user => { :login => "bob", :password => "wrong_password" }
-    assert_response :success
-
-    assert_session_has_no :user
-    assert_template "login"
-  end
- 
-  def test_login
-    @request.session['return-to'] = "/bogus/location"
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    
-    assert_response 302  # redirect
-    assert_session_has :user
-    assert_equal users(:bob), session[:user]
-    
-    assert_redirect_url "http://#{@request.host}/bogus/location"
-  end
-
-  def test_login_logoff
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    get :logout
-    assert_session_has_no :user
-
-  end
-
-
-  #==========================================================================
-  #
-  # Signup
-  #
-  #==========================================================================
-
-  def test_signup
-    LoginEngine::CONFIG[:use_email_notification] = true
-
-    ActionMailer::Base.deliveries = []
-
-    @request.session['return-to'] = "/bogus/location"
-
-    assert_equal 5, User.count
-    post :signup, :user => { :login => "newbob", :password => "newpassword", :password_confirmation => "newpassword", :email => "newbob@test.com" }
-    assert_session_has_no :user
-
-    assert_redirect_url(@controller.url_for(:action => "login"))
-    assert_equal 1, ActionMailer::Base.deliveries.size
-    mail = ActionMailer::Base.deliveries[0]
-    assert_equal "newbob@test.com", mail.to_addrs[0].to_s
-    assert_match /login:\s+\w+\n/, mail.encoded
-    assert_match /password:\s+\w+\n/, mail.encoded
-    #mail.encoded =~ /user_id=(.*?)&key=(.*?)"/
-    user_id = /user_id=(\d+)/.match(mail.encoded)[1]
-    key = /key=([a-z0-9]+)/.match(mail.encoded)[1]
-
-    assert_not_nil user_id
-    assert_not_nil key
-
-    user = User.find_by_email("newbob@test.com")
-    assert_not_nil user
-    assert_equal 0, user.verified
-
-    # First past the expiration.
-    Time.advance_by_days = 1
-    get :home, :user_id => "#{user_id}", :key => "#{key}"
-    Time.advance_by_days = 0
-    user = User.find_by_email("newbob@test.com")
-    assert_equal 0, user.verified
-
-    # Then a bogus key.
-    get :home, :user_id => "#{user_id}", :key => "boguskey"
-    user = User.find_by_email("newbob@test.com")
-    assert_equal 0, user.verified
-
-    # Now the real one.
-    get :home, :user_id => "#{user_id}", :key => "#{key}"
-    user = User.find_by_email("newbob@test.com")
-    assert_equal 1, user.verified
-
-    post :login, :user => { :login => "newbob", :password => "newpassword" }
-    assert_session_has :user
-    get :logout
-
-  end
-  
-  def test_signup_bad_password
-    LoginEngine::CONFIG[:use_email_notification] = true
-    ActionMailer::Base.deliveries = []
-
-    @request.session['return-to'] = "/bogus/location"
-    post :signup, :user => { :login => "newbob", :password => "bad", :password_confirmation => "bad", :email => "newbob@test.com" }
-    assert_session_has_no :user
-    assert_invalid_column_on_record "user", "password"
-    assert_success
-    assert_equal 0, ActionMailer::Base.deliveries.size
-  end
-  
-  def test_signup_bad_email
-    LoginEngine::CONFIG[:use_email_notification] = true
-    ActionMailer::Base.deliveries = []
-
-    @request.session['return-to'] = "/bogus/location"
-
-    ActionMailer::Base.inject_one_error = true
-    post :signup, :user => { :login => "newbob", :password => "newpassword", :password_confirmation => "newpassword", :email => "newbob@test.com" }
-    assert_session_has_no :user
-    assert_equal 0, ActionMailer::Base.deliveries.size
-  end
-
-  def test_signup_without_email
-    LoginEngine::CONFIG[:use_email_notification] = false
-    
-    @request.session['return-to'] = "/bogus/location"
-
-    post :signup, :user => { :login => "newbob", :password => "newpassword", :password_confirmation => "newpassword", :email => "newbob@test.com" }
-
-    assert_redirect_url(@controller.url_for(:action => "login"))    
-    assert_session_has_no :user
-    assert_match /Signup successful/, flash[:notice]
-    
-    assert_not_nil User.find_by_login("newbob")
-    
-    user = User.find_by_email("newbob@test.com")
-    assert_not_nil user
-    
-    post :login, :user => { :login => "newbob", :password => "newpassword" }
-    assert_session_has :user
-    get :logout    
-  end
-
-  def test_signup_bad_details
-    @request.session['return-to'] = "/bogus/location"
-
-    # mismatched password
-    post :signup, :user => { :login => "newbob", :password => "newpassword", :password_confirmation => "wrong" }
-    assert_invalid_column_on_record "user", "password"
-    assert_success
-    
-    # login not long enough
-    post :signup, :user => { :login => "yo", :password => "newpassword", :password_confirmation => "newpassword" }
-    assert_invalid_column_on_record "user", "login"
-    assert_success
-
-    # both
-    post :signup, :user => { :login => "yo", :password => "newpassword", :password_confirmation => "wrong" }
-    assert_invalid_column_on_record "user", ["login", "password"]
-    assert_success
-    
-    # existing user
-    post :signup, :user => { :login => "bob", :password => "doesnt_matter", :password_confirmation => "doesnt_matter" }
-    assert_invalid_column_on_record "user", "login"
-    assert_success
-
-    # existing email
-    post :signup, :user => { :login => "newbob", :email => "longbob@test.com", :password => "doesnt_matter", :password_confirmation => "doesnt_matter" }
-    assert_invalid_column_on_record "user", "email"
-    assert_success
-
-  end
-  
-
-  #==========================================================================
-  #
-  # Edit
-  #
-  #==========================================================================
-  
-  def test_edit
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    post :edit, :user => { "firstname" => "Bob", "form" => "edit" }
-    assert_equal @response.session[:user].firstname, "Bob"
-
-    post :edit, :user => { "firstname" => "", "form" => "edit" }
-    assert_equal @response.session[:user].firstname, ""
-
-    get :logout
-  end
-
-
-
-  #==========================================================================
-  #
-  # Delete
-  #
-  #==========================================================================
-
-  def test_delete
-    LoginEngine::CONFIG[:use_email_notification] = true
-    # Immediate delete
-    post :login, :user => { :login => "deletebob1", :password => "alongtest" }
-    assert_session_has :user
-
-    LoginEngine.config :delayed_delete, false, :force
-    post :delete
-    assert_equal 1, ActionMailer::Base.deliveries.size
-    assert_session_has_no :user
-    
-    # try and login in again, we should fail.
-    post :login, :user => { :login => "deletebob1", :password => "alongtest" }
-    assert_session_has_no :user
-    assert_template_has "login"
-    
-
-    # Now try delayed delete
-    ActionMailer::Base.deliveries = []
-
-    post :login, :user => { :login => "deletebob2", :password => "alongtest" }
-    assert_session_has :user
-
-    LoginEngine.config :delayed_delete, true, :force
-    post :delete
-    assert_equal 1, ActionMailer::Base.deliveries.size
-    mail = ActionMailer::Base.deliveries[0]
-    user_id = /user_id=(\d+)/.match(mail.encoded)[1]
-    key = /key=([a-z0-9]+)/.match(mail.encoded)[1]
-    
-    post :restore_deleted, :user_id => "#{user_id}", "key" => "badkey"
-    assert_session_has_no :user
-
-    # Advance the time past the delete date
-    Time.advance_by_days = LoginEngine.config :delayed_delete_days
-    post :restore_deleted, :user_id => "#{user_id}", "key" => "#{key}"
-    assert_session_has_no :user
-    Time.advance_by_days = 0
-
-    post :restore_deleted, :user_id => "#{user_id}", "key" => "#{key}"
-    assert_session_has :user      
-  end
-  
-  def test_delete_without_email
-    LoginEngine::CONFIG[:use_email_notification] = false
-    ActionMailer::Base.deliveries = []
-
-    # Immediate delete
-    post :login, :user => { :login => "deletebob1", :password => "alongtest" }
-    assert_session_has :user
-
-    LoginEngine.config :delayed_delete, false, :force
-    post :delete
-    assert_session_has_no :user
-    assert_nil User.find_by_login("deletebob1")
-    
-    # try and login in again, we should fail.
-    post :login, :user => { :login => "deletebob1", :password => "alongtest" }
-    assert_session_has_no :user
-    assert_template_has "login"
-    
-
-    # Now try delayed delete
-    ActionMailer::Base.deliveries = []
-
-    post :login, :user => { :login => "deletebob2", :password => "alongtest" }
-    assert_session_has :user
-
-    # delayed delete is not really relevant currently without email.
-    LoginEngine.config :delayed_delete, true, :force
-    post :delete
-    assert_equal 1, User.find_by_login("deletebob2").deleted
-  end
-
-
-
-  #==========================================================================
-  #
-  # Change Password
-  #
-  #==========================================================================
-
-  def test_change_valid_password
-    
-    LoginEngine::CONFIG[:use_email_notification] = true
-    
-    ActionMailer::Base.deliveries = []
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    post :change_password, :user => { :password => "changed_password", :password_confirmation => "changed_password" }
-    
-    assert_equal 1, ActionMailer::Base.deliveries.size
-    mail = ActionMailer::Base.deliveries[0]
-    assert_equal "bob@test.com", mail.to_addrs[0].to_s
-    assert_match /login:\s+\w+\n/, mail.encoded
-    assert_match /password:\s+\w+\n/, mail.encoded
-
-    post :login, :user => { :login => "bob", :password => "changed_password" }
-    assert_session_has :user
-    post :change_password, :user => { :password => "atest", :password_confirmation => "atest" }
-    get :logout
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    get :logout
-  end
-
-  def test_change_valid_password_without_email
-    
-    LoginEngine::CONFIG[:use_email_notification] = false
-    
-    ActionMailer::Base.deliveries = []
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    post :change_password, :user => { :password => "changed_password", :password_confirmation => "changed_password" }
-    
-    assert_redirected_to :action => "change_password"
-
-    post :login, :user => { :login => "bob", :password => "changed_password" }
-    assert_session_has :user
-    post :change_password, :user => { :password => "atest", :password_confirmation => "atest" }
-    get :logout
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    get :logout
-  end
-
-  def test_change_short_password
-    LoginEngine::CONFIG[:use_email_notification] = true
-    ActionMailer::Base.deliveries = []
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    post :change_password, :user => { :password => "bad", :password_confirmation => "bad" }
-    assert_invalid_column_on_record "user", "password"
-    assert_success
-    assert_equal 0, ActionMailer::Base.deliveries.size    
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    get :logout
-  end
-  
-  def test_change_short_password_without_email
-    LoginEngine::CONFIG[:use_email_notification] = false
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    post :change_password, :user => { :password => "bad", :password_confirmation => "bad" }
-    assert_invalid_column_on_record "user", "password"
-    assert_success
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    get :logout
-  end
-
-
-  def test_change_password_with_bad_email
-    LoginEngine::CONFIG[:use_email_notification] = true
-    ActionMailer::Base.deliveries = []
-    
-    # log in
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    # change the password, but the email delivery will fail
-    ActionMailer::Base.inject_one_error = true
-    post :change_password, :user => { :password => "changed_password", :password_confirmation => "changed_password" }
-    assert_equal 0, ActionMailer::Base.deliveries.size
-    assert_match /Password could not be changed/, flash[:warning]
-    
-    # logout
-    get :logout
-    assert_session_has_no :user
-
-    # ensure we can log in with our original password
-    # TODO: WHY DOES THIS FAIL!! It looks like the transaction stuff in UserController#change_password isn't actually rolling back changes.
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    get :logout
-  end
-
-
-
-
-  #==========================================================================
-  #
-  # Forgot Password
-  #
-  #==========================================================================
-
-  def test_forgot_password
-    LoginEngine::CONFIG[:use_email_notification] = true
-
-    do_forgot_password(false, false, false)
-    do_forgot_password(false, false, true)
-    do_forgot_password(true, false, false)
-    do_forgot_password(false, true, false)
-  end
-  
-  def do_forgot_password(bad_address, bad_email, logged_in)
-    ActionMailer::Base.deliveries = []
-
-    if logged_in
-      post :login, :user => { :login => "bob", :password => "atest" }
-      assert_session_has :user
-    end
-
-    @request.session['return-to'] = "/bogus/location"
-    if not bad_address and not bad_email
-      post :forgot_password, :user => { :email => "bob@test.com" }
-      password = "anewpassword"
-      if logged_in
-        assert_equal 0, ActionMailer::Base.deliveries.size
-        assert_redirect_url(@controller.url_for(:action => "change_password"))
-        post :change_password, :user => { :password => "#{password}", :password_confirmation => "#{password}" }
-      else
-        assert_equal 1, ActionMailer::Base.deliveries.size
-        mail = ActionMailer::Base.deliveries[0]
-        assert_equal "bob@test.com", mail.to_addrs[0].to_s
-        user_id = /user_id=(\d+)/.match(mail.encoded)[1]
-        key = /key=([a-z0-9]+)/.match(mail.encoded)[1]
-        post :change_password, :user => { :password => "#{password}", :password_confirmation => "#{password}"}, :user_id => "#{user_id}", :key => "#{key}"
-        assert_session_has :user
-        get :logout
-      end
-    elsif bad_address
-      post :forgot_password, :user => { :email => "bademail@test.com" }
-      assert_equal 0, ActionMailer::Base.deliveries.size
-    elsif bad_email
-      ActionMailer::Base.inject_one_error = true
-      post :forgot_password, :user => { :email => "bob@test.com" }
-      assert_equal 0, ActionMailer::Base.deliveries.size
-    else
-      # Invalid test case
-      assert false
-    end
-
-    if not bad_address and not bad_email
-      if logged_in
-        get :logout
-      else
-        assert_redirect_url(@controller.url_for(:action => "login"))
-      end
-      post :login, :user => { :login => "bob", :password => "#{password}" }
-    else
-      # Okay, make sure the database did not get changed
-      if logged_in
-        get :logout
-      end
-      post :login, :user => { :login => "bob", :password => "atest" }
-    end
-
-    assert_session_has :user
-
-    # Put the old settings back
-    if not bad_address and not bad_email
-      post :change_password, :user => { :password => "atest", :password_confirmation => "atest" }
-    end
-    
-    get :logout
-  end
-
-  def test_forgot_password_without_email_and_logged_in
-    LoginEngine::CONFIG[:use_email_notification] = false
-
-    post :login, :user => { :login => "bob", :password => "atest" }
-    assert_session_has :user
-
-    @request.session['return-to'] = "/bogus/location"
-    post :forgot_password, :user => { :email => "bob@test.com" }
-    password = "anewpassword"
-    assert_redirect_url(@controller.url_for(:action => "change_password"))
-    post :change_password, :user => { :password => "#{password}", :password_confirmation => "#{password}" }
-
-    get :logout
-
-    post :login, :user => { :login => "bob", :password => "#{password}" }
-
-    assert_session_has :user
-    
-    get :logout
-  end
-
-  def forgot_password_without_email_and_not_logged_in
-    LoginEngine::CONFIG[:use_email_notification] = false
-
-    @request.session['return-to'] = "/bogus/location"
-    post :forgot_password, :user => { :email => "bob@test.com" }
-    password = "anewpassword"
-
-    # wothout email, you can't retrieve your forgotten password...
-    assert_match /Please contact the system admin/, flash[:message]
-    assert_session_has_no :user
-
-    assert_redirect_url "http://#{@request.host}/bogus/location"
-  end  
-end