jro_apps/redmine Commit - r2419:9525e5f147a8

Fixes Setting.openid? (#2764)....

Jean-Philippe Lang -

r2419:9525e5f147a8

parent child

Context file:

r2419:9525e5f147a8

Collapse all files

app/models/setting.rb +1 -1

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Setting < ActiveRecord::Base
               DATE_FORMATS = [
             	'%Y-%m-%d',
             	'%d/%m/%Y',
             	'%d.%m.%Y',
             	'%d-%m-%Y',
             	'%m/%d/%Y',
             	'%d %b %Y',
             	'%d %B %Y',
             	'%b %d, %Y',
             	'%B %d, %Y'
                 ]
               TIME_FORMATS = [
                 '%H:%M',
                 '%I:%M %p'
                 ]
               ENCODINGS = %w(US-ASCII
                               windows-1250
                               windows-1251
                               windows-1252
                               windows-1253
                               windows-1254
                               windows-1255
                               windows-1256
                               windows-1257
                               windows-1258
                               windows-31j
                               ISO-2022-JP
                               ISO-2022-KR
                               ISO-8859-1
                               ISO-8859-2
                               ISO-8859-3
                               ISO-8859-4
                               ISO-8859-5
                               ISO-8859-6
                               ISO-8859-7
                               ISO-8859-8
                               ISO-8859-9
                               ISO-8859-13
                               ISO-8859-15
                               KOI8-R
                               UTF-8
                               UTF-16
                               UTF-16BE
                               UTF-16LE
                               EUC-JP
                               Shift_JIS
                               GB18030
                               GBK
                               ISCII91
                               EUC-KR
                               Big5
                               Big5-HKSCS
                               TIS-620)
               cattr_accessor :available_settings
               @@available_settings = YAML::load(File.open("#{RAILS_ROOT}/config/settings.yml"))
               Redmine::Plugin.all.each do |plugin|
                 next unless plugin.settings
                 @@available_settings["plugin_#{plugin.id}"] = {'default' => plugin.settings[:default], 'serialized' => true}
               end
               validates_uniqueness_of :name
               validates_inclusion_of :name, :in => @@available_settings.keys
               validates_numericality_of :value, :only_integer => true, :if => Proc.new { |setting| @@available_settings[setting.name]['format'] == 'int' }
               # Hash used to cache setting values
               @cached_settings = {}
               @cached_cleared_on = Time.now
               def value
                 v = read_attribute(:value)
                 # Unserialize serialized settings
                 v = YAML::load(v) if @@available_settings[name]['serialized'] && v.is_a?(String)
                 v = v.to_sym if @@available_settings[name]['format'] == 'symbol' && !v.blank?
                 v
               end
               def value=(v)
                 v = v.to_yaml if v && @@available_settings[name]['serialized']
                 write_attribute(:value, v.to_s)
               end
               # Returns the value of the setting named name
               def self.[](name)
                 v = @cached_settings[name]
                 v ? v : (@cached_settings[name] = find_or_default(name).value)
               end
               def self.[]=(name, v)
                 setting = find_or_default(name)
                 setting.value = (v ? v : "")
                 @cached_settings[name] = nil
                 setting.save
                 setting.value
               end
               # Defines getter and setter for each setting
               # Then setting values can be read using: Setting.some_setting_name
               # or set using Setting.some_setting_name = "some value"
               @@available_settings.each do |name, params|
                 src = <<-END_SRC
                 def self.#{name}
                   self[:#{name}]
                 end
                 def self.#{name}?
                   self[:#{name}].to_i > 0
                 end
                 def self.#{name}=(value)
                   self[:#{name}] = value
                 end
                 END_SRC
                 class_eval src, __FILE__, __LINE__
               end
               # Helper that returns an array based on per_page_options setting
               def self.per_page_options_array
                 per_page_options.split(%r{[\s,]}).collect(&:to_i).select {|n| n > 0}.sort
               end
               def self.openid?
-                Object.const_defined?(:OpenID) && self['openid'].to_s == '1'
+                Object.const_defined?(:OpenID) && self[:openid].to_i > 0
               end
               # Checks if settings have changed since the values were read
               # and clears the cache hash if it's the case
               # Called once per request
               def self.check_cache
                 settings_updated_on = Setting.maximum(:updated_on)
                 if settings_updated_on && @cached_cleared_on <= settings_updated_on
                   @cached_settings.clear
                   @cached_cleared_on = Time.now
                   logger.info "Settings cache cleared." if logger
                 end
               end
             private
               # Returns the Setting instance for the setting named name
               # (record found in database or new record with default value)
               def self.find_or_default(name)
                 name = name.to_s
                 raise "There's no setting named #{name}" unless @@available_settings.has_key?(name)
                 setting = find_by_name(name)
                 setting ||= new(:name => name, :value => @@available_settings[name]['default']) if @@available_settings.has_key? name
               end
             end

test/functional/account_controller_test.rb +5 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             require 'account_controller'
             # Re-raise errors caught by the controller.
             class AccountController; def rescue_action(e) raise e end; end
             class AccountControllerTest < Test::Unit::TestCase
               fixtures :users, :roles
               def setup
                 @controller = AccountController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_show
                 get :show, :id => 2
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:user)
               end
               def test_show_inactive
                 get :show, :id => 5
                 assert_response 404
                 assert_nil assigns(:user)
               end
               def test_login_should_redirect_to_back_url_param
                 # request.uri is "test.host" in test environment
                 post :login, :username => 'jsmith', :password => 'jsmith', :back_url => 'http%3A%2F%2Ftest.host%2Fissues%2Fshow%2F1'
                 assert_redirected_to '/issues/show/1'
               end
               def test_login_should_not_redirect_to_another_host
                 post :login, :username => 'jsmith', :password => 'jsmith', :back_url => 'http%3A%2F%2Ftest.foo%2Ffake'
                 assert_redirected_to '/my/page'
               end
               def test_login_with_wrong_password
                 post :login, :username => 'admin', :password => 'bad'
                 assert_response :success
                 assert_template 'login'
                 assert_tag 'div',
                            :attributes => { :class => "flash error" },
                            :content => /Invalid user or password/
               end
               if Object.const_defined?(:OpenID)
               def test_login_with_openid_for_existing_user
                 Setting.self_registration = '3'
                 Setting.openid = '1'
                 existing_user = User.new(:firstname => 'Cool',
                                          :lastname => 'User',
                                          :mail => 'user@somedomain.com',
                                          :identity_url => 'http://openid.example.com/good_user')
                 existing_user.login = 'cool_user'
                 assert existing_user.save!
                 post :login, :openid_url => existing_user.identity_url
                 assert_redirected_to 'my/page'
               end
               def test_login_with_openid_with_new_user_created
                 Setting.self_registration = '3'
                 Setting.openid = '1'
                 post :login, :openid_url => 'http://openid.example.com/good_user'
                 assert_redirected_to 'my/account'
                 user = User.find_by_login('cool_user')
                 assert user
                 assert_equal 'Cool', user.firstname
                 assert_equal 'User', user.lastname
               end
               def test_login_with_openid_with_new_user_and_self_registration_off
                 Setting.self_registration = '0'
                 Setting.openid = '1'
                 post :login, :openid_url => 'http://openid.example.com/good_user'
                 assert_redirected_to home_url
                 user = User.find_by_login('cool_user')
                 assert ! user
               end
               def test_login_with_openid_with_new_user_created_with_email_activation_should_have_a_token
                 Setting.self_registration = '1'
                 Setting.openid = '1'
                 post :login, :openid_url => 'http://openid.example.com/good_user'
                 assert_redirected_to 'login'
                 user = User.find_by_login('cool_user')
                 assert user
                 token = Token.find_by_user_id_and_action(user.id, 'register')
                 assert token
               end
               def test_login_with_openid_with_new_user_created_with_manual_activation
                 Setting.self_registration = '2'
                 Setting.openid = '1'
                 post :login, :openid_url => 'http://openid.example.com/good_user'
                 assert_redirected_to 'login'
                 user = User.find_by_login('cool_user')
                 assert user
                 assert_equal User::STATUS_REGISTERED, user.status
               end
               def test_login_with_openid_with_new_user_with_conflict_should_register
                 Setting.self_registration = '3'
                 Setting.openid = '1'
                 existing_user = User.new(:firstname => 'Cool', :lastname => 'User', :mail => 'user@somedomain.com')
                 existing_user.login = 'cool_user'
                 assert existing_user.save!
                 post :login, :openid_url => 'http://openid.example.com/good_user'
                 assert_response :success
                 assert_template 'register'
                 assert assigns(:user)
                 assert_equal 'http://openid.example.com/good_user', assigns(:user)[:identity_url]
               end
+              def test_setting_openid_should_return_true_when_set_to_true
+                Setting.openid = '1'
+                assert_equal true, Setting.openid?
+              end
               else
                 puts "Skipping openid tests."
               end
               def test_autologin
                 Setting.autologin = "7"
                 Token.delete_all
                 post :login, :username => 'admin', :password => 'admin', :autologin => 1
                 assert_redirected_to 'my/page'
                 token = Token.find :first
                 assert_not_nil token
                 assert_equal User.find_by_login('admin'), token.user
                 assert_equal 'autologin', token.action
               end
               def test_logout
                 @request.session[:user_id] = 2
                 get :logout
                 assert_redirected_to ''
                 assert_nil @request.session[:user_id]
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages