jro_apps/redmine Commit - r13264:4989c9f6a845

Removed some test contexts....

Jean-Philippe Lang -

r13264:4989c9f6a845

parent child

Context file:

r13264:4989c9f6a845

Collapse all files

test/integration/api_test/http_basic_login_test.rb +4 -15

             # Redmine - project management software
             # Copyright (C) 2006-2014  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.expand_path('../../../test_helper', __FILE__)
             class Redmine::ApiTest::HttpBasicLoginTest < Redmine::ApiTest::Base
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules
               def setup
                 Setting.rest_api_enabled = '1'
                 Setting.login_required = '1'
+                project = Project.find('onlinestore')
+                EnabledModule.create(:project => project, :name => 'news')
               end
               def teardown
                 Setting.rest_api_enabled = '0'
                 Setting.login_required = '0'
               end
-              # Using the NewsController because it's a simple API.
+              should_allow_http_basic_auth_with_username_and_password(:get, "/projects/onlinestore/news.xml")
-              context "get /news" do
+              should_allow_http_basic_auth_with_username_and_password(:get, "/projects/onlinestore/news.json")
-                setup do
-                  project = Project.find('onlinestore')
-                  EnabledModule.create(:project => project, :name => 'news')
-                end
-                context "in :xml format" do
-                  should_allow_http_basic_auth_with_username_and_password(:get, "/projects/onlinestore/news.xml")
-                end
-                context "in :json format" do
-                  should_allow_http_basic_auth_with_username_and_password(:get, "/projects/onlinestore/news.json")
-                end
-              end
             end

test/integration/api_test/http_basic_login_with_api_token_test.rb +2 -11

             # Redmine - project management software
             # Copyright (C) 2006-2014  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.expand_path('../../../test_helper', __FILE__)
             class Redmine::ApiTest::HttpBasicLoginWithApiTokenTest < Redmine::ApiTest::Base
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules
               def setup
                 Setting.rest_api_enabled = '1'
                 Setting.login_required = '1'
               end
               def teardown
                 Setting.rest_api_enabled = '0'
                 Setting.login_required = '0'
               end
-              # Using the NewsController because it's a simple API.
+              should_allow_http_basic_auth_with_key(:get, "/news.xml")
-              context "get /news" do
+              should_allow_http_basic_auth_with_key(:get, "/news.json")
-                context "in :xml format" do
-                  should_allow_http_basic_auth_with_key(:get, "/news.xml")
-                end
-                context "in :json format" do
-                  should_allow_http_basic_auth_with_key(:get, "/news.json")
-                end
-              end
             end

test/integration/api_test/issues_test.rb +322 -489

This diff has been collapsed as it changes many lines, (811 lines changed) Show them Hide them
	@@ -1,799 +1,632
	1	# Redmine - project management software	1	# Redmine - project management software
	2	# Copyright (C) 2006-2014 Jean-Philippe Lang	2	# Copyright (C) 2006-2014 Jean-Philippe Lang
	3	#	3	#
	4	# This program is free software; you can redistribute it and/or	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.	7	# of the License, or (at your option) any later version.
	8	#	8	#
	9	# This program is distributed in the hope that it will be useful,	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.	12	# GNU General Public License for more details.
	13	#	13	#
	14	# You should have received a copy of the GNU General Public License	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17		17
	18	require File.expand_path('../../../test_helper', __FILE__)	18	require File.expand_path('../../../test_helper', __FILE__)
	19		19
	20	class Redmine::ApiTest::IssuesTest < Redmine::ApiTest::Base	20	class Redmine::ApiTest::IssuesTest < Redmine::ApiTest::Base
	21	fixtures :projects,	21	fixtures :projects,
	22	:users,	22	:users,
	23	:roles,	23	:roles,
	24	:members,	24	:members,
	25	:member_roles,	25	:member_roles,
	26	:issues,	26	:issues,
	27	:issue_statuses,	27	:issue_statuses,
	28	:issue_relations,	28	:issue_relations,
	29	:versions,	29	:versions,
	30	:trackers,	30	:trackers,
	31	:projects_trackers,	31	:projects_trackers,
	32	:issue_categories,	32	:issue_categories,
	33	:enabled_modules,	33	:enabled_modules,
	34	:enumerations,	34	:enumerations,
	35	:attachments,	35	:attachments,
	36	:workflows,	36	:workflows,
	37	:custom_fields,	37	:custom_fields,
	38	:custom_values,	38	:custom_values,
	39	:custom_fields_projects,	39	:custom_fields_projects,
	40	:custom_fields_trackers,	40	:custom_fields_trackers,
	41	:time_entries,	41	:time_entries,
	42	:journals,	42	:journals,
	43	:journal_details,	43	:journal_details,
	44	:queries,	44	:queries,
	45	:attachments	45	:attachments
	46		46
	47	def setup	47	def setup
	48	Setting.rest_api_enabled = '1'	48	Setting.rest_api_enabled = '1'
	49	end	49	end
	50		50
	51	context "/issues" do	51	# Use a private project to make sure auth is really working and not just
	52	# Use a private project to make sure auth is really working and not just	52	# only showing public issues.
	53	# only showing public issues.	53	should_allow_api_authentication(:get, "/projects/private-child/issues.xml")
	54	should_allow_api_authentication(:get, "/projects/private-child/issues.~~xml~~")	54	should_allow_api_authentication(:get, "/projects/private-child/issues.json")
	55		55
	56	should "contain metadata" do	56	should_allow_api_authentication(:get, "/issues/6.xml")
	57	get '/issues.xml'	57	should_allow_api_authentication(:get, "/issues/6.json")
			58
			59	should_allow_api_authentication(
			60	:post,
			61	'/issues.xml',
			62	{:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
			63	{:success_code => :created}
			64	)
			65	should_allow_api_authentication(:post,
			66	'/issues.json',
			67	{:issue => {:project_id => 1, :subject => 'API test',
			68	:tracker_id => 2, :status_id => 3}},
			69	{:success_code => :created})
			70
			71	should_allow_api_authentication(:put,
			72	'/issues/6.xml',
			73	{:issue => {:subject => 'API update', :notes => 'A new note'}},
			74	{:success_code => :ok})
			75	should_allow_api_authentication(:put,
			76	'/issues/6.json',
			77	{:issue => {:subject => 'API update', :notes => 'A new note'}},
			78	{:success_code => :ok})
			79
			80	should_allow_api_authentication(:delete,
			81	'/issues/6.xml',
			82	{},
			83	{:success_code => :ok})
			84	should_allow_api_authentication(:delete,
			85	'/issues/6.json',
			86	{},
			87	{:success_code => :ok})
			88
			89	test "GET /issues.xml should contain metadata" do
			90	get '/issues.xml'
			91	assert_select 'issues[type=array][total_count=?][limit="25"][offset="0"]',
			92	assigns(:issue_count).to_s
			93	end
	58		94
	59	assert_select 'issues[type=array][total_count=?][limit="25"][offset="0"]', assigns(:issue_count).to_s	95	test "GET /issues.xml with nometa param should not contain metadata" do
	60	end	96	get '/issues.xml?nometa=1'
			97	assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
			98	end
	61		99
	62	context "with offset and limit" do	100	test "GET /issues.xml with nometa header should not contain metadata" do
	63	should "use the params" do	101	get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
	64	get '/issues.xml?offset=2&limit=3'	102	assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
			103	end
	65		104
	66	assert_equal 3, assigns(:limit)	105	test "GET /issues.xml with offset and limit" do
	67	assert_equal 2, assigns(:offset)	106	get '/issues.xml?offset=2&limit=3'
	68	assert_select 'issues issue', 3
	69	end
	70	end
	71		107
	72	context "with nometa param" do	108	assert_equal 3, assigns(:limit)
	73	should "not contain metadata" do	109	assert_equal 2, assigns(:offset)
	74	get '/issues.xml?nometa=1'	110	assert_select 'issues issue', 3
			111	end
	75		112
	76	assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'	113	test "GET /issues.xml with relations" do
	77	end	114	get '/issues.xml?include=relations'
	78	end
	79		115
	80	context "with nometa header" do	116	assert_response :success
	81	should "not contain metadata" do	117	assert_equal 'application/xml', @response.content_type
	82	get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
	83		118
	84	assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'	119	assert_select 'issue id:content(3)' do
	85	end	120	assert_select '~ relations relation', 1
			121	assert_select '~ relations relation[id="2"][issue_id="2"][issue_to_id="3"][relation_type=relates]'
	86	end	122	end
	87		123
	88	context "with relations" do	124	assert_select 'issue id:content(1)' do
	89	should "display relations" do	125	assert_select '~ relations'
	90	get '/issues.xml?include=relations'	126	assert_select '~ relations relation', 0
	91		127	end
	92	assert_response :success	128	end
	93	assert_equal 'application/xml', @response.content_type
	94		129
	95	assert_select 'issue id:content(3)' do	130	test "GET /issues.xml with invalid query params" do
	96	assert_select '~ relations relation', 1	131	get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}
	97	assert_select '~ relations relation[id="2"][issue_id="2"][issue_to_id="3"][relation_type=relates]'
	98	end
	99		132
	100	assert_select 'issue id:content(1)' do	133	assert_response :unprocessable_entity
	101	assert_select '~ relations'	134	assert_equal 'application/xml', @response.content_type
	102	assert_select '~ relations relation', 0	135	assert_select 'errors error', :text => "Start date can't be blank"
	103	end	136	end
	104	end
	105	end
	106		137
	107	context "with invalid query params" do	138	test "GET /issues.xml with custom field filter" do
	108	should "return errors" do	139	get '/issues.xml',
	109	get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}	140	{:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='}, :v => {:cf_1 => ['MySQL']}}
	110		141
	111	assert_response :unprocessable_entity	142	expected_ids = Issue.visible.
	112	assert_equal 'application/xml', @response.content_type	143	joins(:custom_values).
	113	assert_select 'errors error', :text => "Start date can't be blank"	144	where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
	114	end	145	assert expected_ids.any?
	115	end
	116		146
	117	context "with custom field filter" do	147	assert_select 'issues > issue > id', :count => expected_ids.count do \|ids\|
	118	should "show only issues with the custom field value" do	148	ids.each { \|id\| assert expected_ids.delete(id.children.first.content.to_i) }
	119	get '/issues.xml',
	120	{:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='},
	121	:v => {:cf_1 => ['MySQL']}}
	122	expected_ids = Issue.visible.
	123	joins(:custom_values).
	124	where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
	125	assert_select 'issues > issue > id', :count => expected_ids.count do \|ids\|
	126	ids.each { \|id\| assert expected_ids.delete(id.children.first.content.to_i) }
	127	end
	128	end
	129	end	149	end
			150	end
	130		151
	131	~~contex~~t "with custom field filter (shorthand method)" do	152	test "GET /issues.xml with custom field filter (shorthand method)" do
	132	should "show only issues with the custom field value" do	153	get '/issues.xml', {:cf_1 => 'MySQL'}
	133	get '/issues.xml', { :cf_1 => 'MySQL' }
	134		154
	135	expected_ids = Issue.visible.	155	expected_ids = Issue.visible.
	136	joins(:custom_values).	156	joins(:custom_values).
	137	where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)	157	where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
			158	assert expected_ids.any?
	138		159
	139	assert_select 'issues > issue > id', :count => expected_ids.count do \|ids\|	160	assert_select 'issues > issue > id', :count => expected_ids.count do \|ids\|
	140	ids.each { \|id\| assert expected_ids.delete(id.children.first.content.to_i) }	161	ids.each { \|id\| assert expected_ids.delete(id.children.first.content.to_i) }
	141	end
	142	end
	143	end	162	end
	144	end	163	end
	145		164
	146	def test_index_should_include_issue_attributes	165	def test_index_should_include_issue_attributes
	147	get '/issues.xml'	166	get '/issues.xml'
	148	assert_select 'issues>issue>is_private', :text => 'false'	167	assert_select 'issues>issue>is_private', :text => 'false'
	149	end	168	end
	150		169
	151	def test_index_should_allow_timestamp_filtering	170	def test_index_should_allow_timestamp_filtering
	152	Issue.delete_all	171	Issue.delete_all
	153	Issue.generate!(:subject => '1').update_column(:updated_on, Time.parse("2014-01-02T10:25:00Z"))	172	Issue.generate!(:subject => '1').update_column(:updated_on, Time.parse("2014-01-02T10:25:00Z"))
	154	Issue.generate!(:subject => '2').update_column(:updated_on, Time.parse("2014-01-02T12:13:00Z"))	173	Issue.generate!(:subject => '2').update_column(:updated_on, Time.parse("2014-01-02T12:13:00Z"))
	155		174
	156	get '/issues.xml',	175	get '/issues.xml',
	157	{:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '<='},	176	{:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '<='},
	158	:v => {:updated_on => ['2014-01-02T12:00:00Z']}}	177	:v => {:updated_on => ['2014-01-02T12:00:00Z']}}
	159	assert_select 'issues>issue', :count => 1	178	assert_select 'issues>issue', :count => 1
	160	assert_select 'issues>issue>subject', :text => '1'	179	assert_select 'issues>issue>subject', :text => '1'
	161		180
	162	get '/issues.xml',	181	get '/issues.xml',
	163	{:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},	182	{:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
	164	:v => {:updated_on => ['2014-01-02T12:00:00Z']}}	183	:v => {:updated_on => ['2014-01-02T12:00:00Z']}}
	165	assert_select 'issues>issue', :count => 1	184	assert_select 'issues>issue', :count => 1
	166	assert_select 'issues>issue>subject', :text => '2'	185	assert_select 'issues>issue>subject', :text => '2'
	167		186
	168	get '/issues.xml',	187	get '/issues.xml',
	169	{:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},	188	{:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
	170	:v => {:updated_on => ['2014-01-02T08:00:00Z']}}	189	:v => {:updated_on => ['2014-01-02T08:00:00Z']}}
	171	assert_select 'issues>issue', :count => 2	190	assert_select 'issues>issue', :count => 2
	172	end	191	end
	173		192
	174	context "/index.json" do	193	test "GET /issues.xml with filter" do
	175	should_allow_api_authentication(:get, "/projects/private-child/issues.json")	194	get '/issues.xml?status_id=5'
	176	end
	177		195
	178	context "/index.xml with filter" do	196	expected_ids = Issue.visible.where(:status_id => 5).map(&:id)
	179	should "show only issues with the status_id" do	197	assert expected_ids.any?
	180	get '/issues.xml?status_id=5'
	181		198
	182	expected_ids = Issue.visible.where(:status_id => 5).map(&:id)	199	assert_select 'issues > issue > id', :count => expected_ids.count do \|ids\|
	183		200	ids.each { \|id\| assert expected_ids.delete(id.children.first.content.to_i) }
	184	assert_select 'issues > issue > id', :count => expected_ids.count do \|ids\|
	185	ids.each { \|id\| assert expected_ids.delete(id.children.first.content.to_i) }
	186	end
	187	end	201	end
	188	end	202	end
	189		203
	190	~~contex~~t "~~/index~~.json with filter" do	204	test "GET /issues.json with filter" do
	191	should "show only issues with the status_id" do	205	get '/issues.json?status_id=5'
	192	get '/issues.json?status_id=5'
	193
	194	json = ActiveSupport::JSON.decode(response.body)
	195	status_ids_used = json['issues'].collect {\|j\| j['status']['id'] }
	196	assert_equal 3, status_ids_used.length
	197	assert status_ids_used.all? {\|id\| id == 5 }
	198	end
	199		206
			207	json = ActiveSupport::JSON.decode(response.body)
			208	status_ids_used = json['issues'].collect {\|j\| j['status']['id'] }
			209	assert_equal 3, status_ids_used.length
			210	assert status_ids_used.all? {\|id\| id == 5 }
	200	end	211	end
	201		212
	202	# Issue 6 is on a private project	213	test "GET /issues/:id.xml with journals" do
	203	context "/issues/6.xml" do	214	get '/issues/1.xml?include=journals'
	204	should_allow_api_authentication(:get, "/issues/6.xml")
	205	end
	206		215
	207	context "/issues/6.json" do	216	assert_select 'issue journals[type=array]' do
	208	should_allow_api_authentication(:get, "/issues/6.json")	217	assert_select 'journal[id="1"]' do
			218	assert_select 'details[type=array]' do
			219	assert_select 'detail[name=status_id]' do
			220	assert_select 'old_value', :text => '1'
			221	assert_select 'new_value', :text => '2'
			222	end
			223	end
			224	end
			225	end
	209	end	226	end
	210		227
	211	~~contex~~t "GET /issues/:id" do	228	test "GET /issues/:id.xml with custom fields" do
	212	context "with journals" do	229	get '/issues/3.xml'
	213	context ".xml" do
	214	should "display journals" do
	215	get '/issues/1.xml?include=journals'
	216		230
	217	assert_select 'issue ~~journal~~s[type=array]' do	231	assert_select 'issue custom_fields[type=array]' do
	218	assert_select '~~journal~~[id="1"]' do	232	assert_select 'custom_field[id="1"]' do
	219	assert_select 'details[type=array]' do	233	assert_select 'value', :text => 'MySQL'
	220	assert_select 'detail[name=status_id]' do
	221	assert_select 'old_value', :text => '1'
	222	assert_select 'new_value', :text => '2'
	223	end
	224	end
	225	end
	226	end
	227	end
	228	end	234	end
	229	end	235	end
			236	assert_nothing_raised do
			237	Hash.from_xml(response.body).to_xml
			238	end
			239	end
	230		240
	231	~~contex~~t "with custom fields" do	241	test "GET /issues/:id.xml with multi custom fields" do
	232	context ".xml" do	242	field = CustomField.find(1)
	233	should "display custom fields" do	243	field.update_attribute :multiple, true
	234	get '/issues/3.xml'	244	issue = Issue.find(3)
			245	issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
			246	issue.save!
	235		247
	236	assert_select 'issue custom_fields[type=array]' do	248	get '/issues/3.xml'
	237	assert_select 'custom_field[id="1"]' do	249	assert_response :success
	238	assert_select 'value', :text => 'MySQL'
	239	end
	240	end
	241		250
	242	assert_nothing_raised do	251	assert_select 'issue custom_fields[type=array]' do
	243	Hash.from_xml(response.body).to_xml	252	assert_select 'custom_field[id="1"]' do
	244	end	253	assert_select 'value[type=array] value', 2
	245	end
	246	end	254	end
	247	end	255	end
			256	xml = Hash.from_xml(response.body)
			257	custom_fields = xml['issue']['custom_fields']
			258	assert_kind_of Array, custom_fields
			259	field = custom_fields.detect {\|f\| f['id'] == '1'}
			260	assert_kind_of Hash, field
			261	assert_equal ['MySQL', 'Oracle'], field['value'].sort
			262	end
	248		263
	249	~~contex~~t "with multi custom fields" do	264	test "GET /issues/:id.json with multi custom fields" do
	250	setup do	265	field = CustomField.find(1)
	251	field = CustomField.find(1)	266	field.update_attribute :multiple, true
	252	field.update_attribute :multiple, true	267	issue = Issue.find(3)
	253	issue = Issue.find(3)	268	issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
	254	issue.custom_field_values = {1 => ['MySQL', 'Oracle']}	269	issue.save!
	255	issue.save!
	256	end
	257		270
	258	context ".xml" do	271	get '/issues/3.json'
	259	should "display custom fields" do	272	assert_response :success
	260	get '/issues/3.xml'
	261	assert_response :success
	262		273
	263	assert_select 'issue custom_fields[type=array]' do	274	json = ActiveSupport::JSON.decode(response.body)
	264	assert_select 'custom_field[id="1"]' do	275	custom_fields = json['issue']['custom_fields']
	265	assert_select 'value[type=array] value', 2	276	assert_kind_of Array, custom_fields
	266	end	277	field = custom_fields.detect {\|f\| f['id'] == 1}
	267	end	278	assert_kind_of Hash, field
			279	assert_equal ['MySQL', 'Oracle'], field['value'].sort
			280	end
	268		281
	269	xml = Hash.from_xml(response.body)	282	test "GET /issues/:id.xml with empty value for multi custom field" do
	270	custom_fields = xml['issue']['custom_fields']	283	field = CustomField.find(1)
	271	assert_kind_of Array, custom_fields	284	field.update_attribute :multiple, true
	272	field = custom_fields.detect {\|f\| f['id'] == '1'}	285	issue = Issue.find(3)
	273	assert_kind_of Hash, field	286	issue.custom_field_values = {1 => ['']}
	274	assert_equal ['MySQL', 'Oracle'], field['value'].sort	287	issue.save!
	275	end
	276	end
	277		288
	278	context ".json" do	289	get '/issues/3.xml'
	279	should "display custom fields" do
	280	get '/issues/3.json'
	281	assert_response :success
	282	json = ActiveSupport::JSON.decode(response.body)
	283	custom_fields = json['issue']['custom_fields']
	284	assert_kind_of Array, custom_fields
	285	field = custom_fields.detect {\|f\| f['id'] == 1}
	286	assert_kind_of Hash, field
	287	assert_equal ['MySQL', 'Oracle'], field['value'].sort
	288	end
	289	end
	290	end
	291		290
	292	context "with empty value for multi custom field" do	291	assert_select 'issue custom_fields[type=array]' do
	293	setup do	292	assert_select 'custom_field[id="1"]' do
	294	field = CustomField.find(1)	293	assert_select 'value[type=array]:empty'
	295	field.update_attribute :multiple, true
	296	issue = Issue.find(3)
	297	issue.custom_field_values = {1 => ['']}
	298	issue.save!
	299	end	294	end
			295	end
			296	xml = Hash.from_xml(response.body)
			297	custom_fields = xml['issue']['custom_fields']
			298	assert_kind_of Array, custom_fields
			299	field = custom_fields.detect {\|f\| f['id'] == '1'}
			300	assert_kind_of Hash, field
			301	assert_equal [], field['value']
			302	end
	300		303
	301	context ".xml" do	304	test "GET /issues/:id.json with empty value for multi custom field" do
	302	should "display custom fields" do	305	field = CustomField.find(1)
	303	get '/issues/3.xml'	306	field.update_attribute :multiple, true
			307	issue = Issue.find(3)
			308	issue.custom_field_values = {1 => ['']}
			309	issue.save!
	304		310
	305	assert_select 'issue custom_fields[type=array]' do	311	get '/issues/3.json'
	306	assert_select 'custom_field[id="1"]' do	312	assert_response :success
	307	assert_select 'value[type=array]:empty'	313	json = ActiveSupport::JSON.decode(response.body)
	308	end	314	custom_fields = json['issue']['custom_fields']
	309	end	315	assert_kind_of Array, custom_fields
			316	field = custom_fields.detect {\|f\| f['id'] == 1}
			317	assert_kind_of Hash, field
			318	assert_equal [], field['value'].sort
			319	end
	310		320
	311	xml = Hash.from_xml(response.body)	321	test "GET /issues/:id.xml with attachments" do
	312	custom_fields = xml['issue']['custom_fields']	322	get '/issues/3.xml?include=attachments'
	313	assert_kind_of Array, custom_fields
	314	field = custom_fields.detect {\|f\| f['id'] == '1'}
	315	assert_kind_of Hash, field
	316	assert_equal [], field['value']
	317	end
	318	end
	319		323
	320	context ".json" do	324	assert_select 'issue attachments[type=array]' do
	321	should "display custom fields" do	325	assert_select 'attachment', 5
	322	get '/issues/3.json'	326	assert_select 'attachment id:content(4)' do
	323	assert_response :success	327	assert_select '~ filename', :text => 'source.rb'
	324	json = ActiveSupport::JSON.decode(response.body)	328	assert_select '~ content_url', :text => 'http://www.example.com/attachments/download/4/source.rb'
	325	custom_fields = json['issue']['custom_fields']
	326	assert_kind_of Array, custom_fields
	327	field = custom_fields.detect {\|f\| f['id'] == 1}
	328	assert_kind_of Hash, field
	329	assert_equal [], field['value'].sort
	330	end
	331	end	329	end
	332	end	330	end
			331	end
	333		332
	334	context "with attachments" do	333	test "GET /issues/:id.xml with subtasks" do
	335	context ".xml" do	334	issue = Issue.generate_with_descendants!(:project_id => 1)
	336	should "display attachments" do	335	get "/issues/#{issue.id}.xml?include=children"
	337	get '/issues/3.xml?include=attachments'
	338
	339	assert_select 'issue attachments[type=array]' do
	340	assert_select 'attachment', 5
	341	assert_select 'attachment id:content(4)' do
	342	assert_select '~ filename', :text => 'source.rb'
	343	assert_select '~ content_url', :text => 'http://www.example.com/attachments/download/4/source.rb'
	344	end
	345	end
	346	end
	347	end
	348	end
	349		336
	350	context "with subtasks" do	337	assert_select 'issue children[type=array]' do
	351	setup do	338	assert_select 'issue', 2
	352	@c1 = Issue.create!(	339	assert_select 'issue children', 1
	353	:status_id => 1, :subject => "child c1",	340	end
	354	:tracker_id => 1, :project_id => 1, :author_id => 1,	341	end
	355	:parent_issue_id => 1
	356	)
	357	@c2 = Issue.create!(
	358	:status_id => 1, :subject => "child c2",
	359	:tracker_id => 1, :project_id => 1, :author_id => 1,
	360	:parent_issue_id => 1
	361	)
	362	@c3 = Issue.create!(
	363	:status_id => 1, :subject => "child c3",
	364	:tracker_id => 1, :project_id => 1, :author_id => 1,
	365	:parent_issue_id => @c1.id
	366	)
	367	end
	368		342
	369	context ".xml" do	343	test "GET /issues/:id.json with subtasks" do
	370	should "display children" do	344	issue = Issue.generate_with_descendants!(:project_id => 1)
	371	get ~~'/issues/1.xml~~?include=children'	345	get "/issues/#{issue.id}.json?include=children"
	372
	373	assert_select 'issue children[type=array]' do
	374	assert_select 'issue', 2
	375	assert_select 'issue[id=?]', @c1.id.to_s do
	376	assert_select 'subject', :text => 'child c1'
	377	assert_select 'children' do
	378	assert_select 'issue[id=?]', @c3.id.to_s
	379	end
	380	end
	381	end
	382	end
	383		346
	384	context ".json" do	347	json = ActiveSupport::JSON.decode(response.body)
	385	should "display children" do	348	assert_equal 2, json['issue']['children'].size
	386	get '/issues/1.json?include=children'	349	assert_equal 1, json['issue']['children'].select {\|child\| child.key?('children')}.size
	387
	388	json = ActiveSupport::JSON.decode(response.body)
	389	assert_equal([
	390	{
	391	'id' => @c1.id, 'subject' => 'child c1', 'tracker' => {'id' => 1, 'name' => 'Bug'},
	392	'children' => [{'id' => @c3.id, 'subject' => 'child c3',
	393	'tracker' => {'id' => 1, 'name' => 'Bug'} }]
	394	},
	395	{ 'id' => @c2.id, 'subject' => 'child c2', 'tracker' => {'id' => 1, 'name' => 'Bug'} }
	396	],
	397	json['issue']['children'])
	398	end
	399	end
	400	end
	401	end
	402	end	350	end
	403		351
	404	def test_show_should_include_issue_attributes	352	def test_show_should_include_issue_attributes
	405	get '/issues/1.xml'	353	get '/issues/1.xml'
	406	assert_select 'issue>is_private', :text => 'false'	354	assert_select 'issue>is_private', :text => 'false'
	407	end	355	end
	408		356
	409	test "GET /issues/:id.xml?include=watchers should include watchers" do	357	test "GET /issues/:id.xml?include=watchers should include watchers" do
	410	Watcher.create!(:user_id => 3, :watchable => Issue.find(1))	358	Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
	411		359
	412	get '/issues/1.xml?include=watchers', {}, credentials('jsmith')	360	get '/issues/1.xml?include=watchers', {}, credentials('jsmith')
	413		361
	414	assert_response :ok	362	assert_response :ok
	415	assert_equal 'application/xml', response.content_type	363	assert_equal 'application/xml', response.content_type
	416	assert_select 'issue' do	364	assert_select 'issue' do
	417	assert_select 'watchers', Issue.find(1).watchers.count	365	assert_select 'watchers', Issue.find(1).watchers.count
	418	assert_select 'watchers' do	366	assert_select 'watchers' do
	419	assert_select 'user[id=3]'	367	assert_select 'user[id=3]'
	420	end	368	end
	421	end	369	end
	422	end	370	end
	423		371
	424	context "POST /issues.xml" do	372	test "POST /issues.xml should create an issue with the attributes" do
	425	should_allow_api_authentication(	373	assert_difference('Issue.count') do
	426	:post,	374	post '/issues.xml',
	427	'/issues.xml',	375	{:issue => {:project_id => 1, :subject => 'API test',
	428	{:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},	376	:tracker_id => 2, :status_id => 3}}, credentials('jsmith')
	429	{:success_code => :created}
	430	)
	431	should "create an issue with the attributes" do
	432	assert_difference('Issue.count') do
	433	post '/issues.xml',
	434	{:issue => {:project_id => 1, :subject => 'API test',
	435	:tracker_id => 2, :status_id => 3}}, credentials('jsmith')
	436	end
	437	issue = Issue.order('id DESC').first
	438	assert_equal 1, issue.project_id
	439	assert_equal 2, issue.tracker_id
	440	assert_equal 3, issue.status_id
	441	assert_equal 'API test', issue.subject
	442
	443	assert_response :created
	444	assert_equal 'application/xml', @response.content_type
	445	assert_select 'issue > id', :text => issue.id.to_s
	446	end	377	end
			378	issue = Issue.order('id DESC').first
			379	assert_equal 1, issue.project_id
			380	assert_equal 2, issue.tracker_id
			381	assert_equal 3, issue.status_id
			382	assert_equal 'API test', issue.subject
			383
			384	assert_response :created
			385	assert_equal 'application/xml', @response.content_type
			386	assert_select 'issue > id', :text => issue.id.to_s
	447	end	387	end
	448		388
	449	test "POST /issues.xml with watcher_user_ids should create issue with watchers" do	389	test "POST /issues.xml with watcher_user_ids should create issue with watchers" do
	450	assert_difference('Issue.count') do	390	assert_difference('Issue.count') do
	451	post '/issues.xml',	391	post '/issues.xml',
	452	{:issue => {:project_id => 1, :subject => 'Watchers',	392	{:issue => {:project_id => 1, :subject => 'Watchers',
	453	:tracker_id => 2, :status_id => 3, :watcher_user_ids => [3, 1]}}, credentials('jsmith')	393	:tracker_id => 2, :status_id => 3, :watcher_user_ids => [3, 1]}}, credentials('jsmith')
	454	assert_response :created	394	assert_response :created
	455	end	395	end
	456	issue = Issue.order('id desc').first	396	issue = Issue.order('id desc').first
	457	assert_equal 2, issue.watchers.size	397	assert_equal 2, issue.watchers.size
	458	assert_equal [1, 3], issue.watcher_user_ids.sort	398	assert_equal [1, 3], issue.watcher_user_ids.sort
	459	end	399	end
	460		400
	461	~~contex~~t "POST /issues.xml with failure" do	401	test "POST /issues.xml with failure should return errors" do
	462	should "have an errors tag" do	402	assert_no_difference('Issue.count') do
	463	assert_no_difference('Issue.count') do	403	post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
	464	post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
	465	end
	466
	467	assert_select 'errors error', :text => "Subject can't be blank"
	468	end
	469	end
	470
	471	context "POST /issues.json" do
	472	should_allow_api_authentication(:post,
	473	'/issues.json',
	474	{:issue => {:project_id => 1, :subject => 'API test',
	475	:tracker_id => 2, :status_id => 3}},
	476	{:success_code => :created})
	477
	478	should "create an issue with the attributes" do
	479	assert_difference('Issue.count') do
	480	post '/issues.json',
	481	{:issue => {:project_id => 1, :subject => 'API test',
	482	:tracker_id => 2, :status_id => 3}},
	483	credentials('jsmith')
	484	end
	485
	486	issue = Issue.order('id DESC').first
	487	assert_equal 1, issue.project_id
	488	assert_equal 2, issue.tracker_id
	489	assert_equal 3, issue.status_id
	490	assert_equal 'API test', issue.subject
	491	end	404	end
	492		405
			406	assert_select 'errors error', :text => "Subject can't be blank"
	493	end	407	end
	494		408
	495	~~contex~~t "POST /issues.json ~~with failure~~" do	409	test "POST /issues.json should create an issue with the attributes" do
	496	should "have an errors element" do	410	assert_difference('Issue.count') do
	497	assert_no_difference('Issue.count') do	411	post '/issues.json',
	498	~~post~~ ~~'/issues.json'~~, {:issue => {:project_id => 1}}, ~~credentials~~(~~'jsmith'~~)	412	{:issue => {:project_id => 1, :subject => 'API test',
	499	end	413	:tracker_id => 2, :status_id => 3}},
	500		414	credentials('jsmith')
	501	json = ActiveSupport::JSON.decode(response.body)
	502	assert json['errors'].include?("Subject can't be blank")
	503	end
	504	end
	505
	506	# Issue 6 is on a private project
	507	context "PUT /issues/6.xml" do
	508	setup do
	509	@parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
	510	end
	511
	512	should_allow_api_authentication(:put,
	513	'/issues/6.xml',
	514	{:issue => {:subject => 'API update', :notes => 'A new note'}},
	515	{:success_code => :ok})
	516
	517	should "not create a new issue" do
	518	assert_no_difference('Issue.count') do
	519	put '/issues/6.xml', @parameters, credentials('jsmith')
	520	end
	521	end
	522
	523	should "create a new journal" do
	524	assert_difference('Journal.count') do
	525	put '/issues/6.xml', @parameters, credentials('jsmith')
	526	end
	527	end
	528
	529	should "add the note to the journal" do
	530	put '/issues/6.xml', @parameters, credentials('jsmith')
	531
	532	journal = Journal.last
	533	assert_equal "A new note", journal.notes
	534	end
	535
	536	should "update the issue" do
	537	put '/issues/6.xml', @parameters, credentials('jsmith')
	538
	539	issue = Issue.find(6)
	540	assert_equal "API update", issue.subject
	541	end	415	end
	542		416
			417	issue = Issue.order('id DESC').first
			418	assert_equal 1, issue.project_id
			419	assert_equal 2, issue.tracker_id
			420	assert_equal 3, issue.status_id
			421	assert_equal 'API test', issue.subject
	543	end	422	end
	544		423
	545	context "PUT /issues/3.xml with custom fields" do	424	test "POST /issues.json with failure should return errors" do
	546	setup do	425	assert_no_difference('Issue.count') do
	547	@parameters = {	426	post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')
	548	:issue => {:custom_fields => [{'id' => '1', 'value' => 'PostgreSQL' },
	549	{'id' => '2', 'value' => '150'}]}
	550	}
	551	end	427	end
	552		428
	553	should "update custom fields" do	429	json = ActiveSupport::JSON.decode(response.body)
	554	assert_no_difference('Issue.count') do	430	assert json['errors'].include?("Subject can't be blank")
	555	put '/issues/3.xml', @parameters, credentials('jsmith')
	556	end
	557
	558	issue = Issue.find(3)
	559	assert_equal '150', issue.custom_value_for(2).value
	560	assert_equal 'PostgreSQL', issue.custom_value_for(1).value
	561	end
	562	end	431	end
	563		432
	564	~~contex~~t "PUT /issues/~~3.xml with multi custom fields~~" do	433	test "PUT /issues/:id.xml" do
	565	setup do	434	assert_difference('Journal.count') do
	566	field = CustomField.find(1)	435	put '/issues/6.xml',
	567	field.update_attribute :multiple, true	436	{:issue => {:subject => 'API update', :notes => 'A new note'}},
	568	@parameters = {	437	credentials('jsmith')
	569	:issue => {:custom_fields => [{'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
	570	{'id' => '2', 'value' => '150'}]}
	571	}
	572	end	438	end
	573		439
	574	should "update custom fields" do	440	issue = Issue.find(6)
	575	assert_no_difference('Issue.count') do	441	assert_equal "API update", issue.subject
	576	put '/issues/3.xml', @parameters, credentials('jsmith')	442	journal = Journal.last
	577	end	443	assert_equal "A new note", journal.notes
	578
	579	issue = Issue.find(3)
	580	assert_equal '150', issue.custom_value_for(2).value
	581	assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
	582	end
	583	end	444	end
	584		445
	585	~~contex~~t "PUT /issues/~~3.xml with project change~~" do	446	test "PUT /issues/:id.xml with custom fields" do
	586	setup do	447	put '/issues/3.xml',
	587	@parameters = {:issue => {:project_id => 2, :subject => 'Project changed'}}	448	{:issue => {:custom_fields => [
	588	end	449	{'id' => '1', 'value' => 'PostgreSQL' },
	589		450	{'id' => '2', 'value' => '150'}
	590	should "update project" do	451	]}},
	591	assert_no_difference('Issue.count') do	452	credentials('jsmith')
	592	put '/issues/3.xml', @parameters, credentials('jsmith')	453
	593	end	454	issue = Issue.find(3)
	594		455	assert_equal '150', issue.custom_value_for(2).value
	595	issue = Issue.find(3)	456	assert_equal 'PostgreSQL', issue.custom_value_for(1).value
	596	assert_equal 2, issue.project_id
	597	assert_equal 'Project changed', issue.subject
	598	end
	599	end	457	end
	600		458
	601	~~contex~~t "PUT /issues/~~6.xml with failed update~~" do	459	test "PUT /issues/:id.xml with multi custom fields" do
	602	setup do	460	field = CustomField.find(1)
	603	@parameters = {:issue => {:subject => ''}}	461	field.update_attribute :multiple, true
	604	end
	605
	606	should "not create a new issue" do
	607	assert_no_difference('Issue.count') do
	608	put '/issues/6.xml', @parameters, credentials('jsmith')
	609	end
	610	end
	611
	612	should "not create a new journal" do
	613	assert_no_difference('Journal.count') do
	614	put '/issues/6.xml', @parameters, credentials('jsmith')
	615	end
	616	end
	617		462
	618	should "have an errors tag" do	463	put '/issues/3.xml',
	619	put '/issues/6.xml', @parameters, credentials('jsmith')	464	{:issue => {:custom_fields => [
			465	{'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
			466	{'id' => '2', 'value' => '150'}
			467	]}},
			468	credentials('jsmith')
	620		469
	621	assert_select 'errors error', :text => "Subject can't be blank"	470	issue = Issue.find(3)
	622	end	471	assert_equal '150', issue.custom_value_for(2).value
			472	assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
	623	end	473	end
	624		474
	625	~~contex~~t "PUT /issues/~~6.json~~" do	475	test "PUT /issues/:id.xml with project change" do
	626	setup do	476	put '/issues/3.xml',
	627	@parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}	477	{:issue => {:project_id => 2, :subject => 'Project changed'}},
	628	end	478	credentials('jsmith')
	629
	630	should_allow_api_authentication(:put,
	631	'/issues/6.json',
	632	{:issue => {:subject => 'API update', :notes => 'A new note'}},
	633	{:success_code => :ok})
	634		479
	635	should "update the issue" do	480	issue = Issue.find(3)
	636	assert_no_difference('Issue.count') do	481	assert_equal 2, issue.project_id
	637	assert_difference('Journal.count') do	482	assert_equal 'Project changed', issue.subject
	638	put '/issues/6.json', @parameters, credentials('jsmith')	483	end
	639		484
	640	assert_response :ok	485	test "PUT /issues/:id.xml with failed update" do
	641	assert_equal '', response.body	486	put '/issues/6.xml', {:issue => {:subject => ''}}, credentials('jsmith')
	642	end
	643	end
	644		487
	645	issue = Issue.find(6)	488	assert_response :unprocessable_entity
	646	assert_equal "API update", issue.subject	489	assert_select 'errors error', :text => "Subject can't be blank"
	647	journal = Journal.last
	648	assert_equal "A new note", journal.notes
	649	end
	650	end	490	end
	651		491
	652	~~contex~~t "PUT /issues/~~6.json with failed update~~" do	492	test "PUT /issues/:id.json" do
	653	should "return errors" do	493	assert_difference('Journal.count') do
	654	assert_no_difference('Issue.count') do	494	put '/issues/6.json',
	655	assert_no_difference('Journal.count') do	495	{:issue => {:subject => 'API update', :notes => 'A new note'}},
	656	put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')	496	credentials('jsmith')
	657
	658	assert_response :unprocessable_entity
	659	end
	660	end
	661		497
	662	json = ActiveSupport::JSON.decode(response.body)	498	assert_response :ok
	663	assert json['errors'].include?("Subject can't be blank")	499	assert_equal '', response.body
	664	end	500	end
			501
			502	issue = Issue.find(6)
			503	assert_equal "API update", issue.subject
			504	journal = Journal.last
			505	assert_equal "A new note", journal.notes
	665	end	506	end
	666		507
	667	context "DELETE /issues/1.xml" do	508	test "PUT /issues/:id.json with failed update" do
	668	should_allow_api_authentication(:delete,	509	put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')
	669	'/issues/6.xml',
	670	{},
	671	{:success_code => :ok})
	672		510
	673	should "delete the issue" do	511	assert_response :unprocessable_entity
	674	assert_difference('Issue.count', -1) do	512	json = ActiveSupport::JSON.decode(response.body)
	675	delete '/issues/6.xml', {}, credentials('jsmith')	513	assert json['errors'].include?("Subject can't be blank")
			514	end
	676		515
	677	assert_response :ok	516	test "DELETE /issues/:id.xml" do
	678	assert_equal '', response.body	517	assert_difference('Issue.count', -1) do
	679	end	518	delete '/issues/6.xml', {}, credentials('jsmith')
	680		519
	681	assert_nil Issue.find_by_id(6)	520	assert_response :ok
			521	assert_equal '', response.body
	682	end	522	end
			523	assert_nil Issue.find_by_id(6)
	683	end	524	end
	684		525
	685	~~contex~~t "DELETE /issues/1.json" do	526	test "DELETE /issues/:id.json" do
	686	should_allow_api_authentication(:delete,	527	assert_difference('Issue.count', -1) do
	687	'/issues/6.json',	528	delete '/issues/6.json', {}, credentials('jsmith')
	688	{},
	689	{:success_code => :ok})
	690
	691	should "delete the issue" do
	692	assert_difference('Issue.count', -1) do
	693	delete '/issues/6.json', {}, credentials('jsmith')
	694		529
	695	assert_response :ok	530	assert_response :ok
	696	assert_equal '', response.body	531	assert_equal '', response.body
	697	end
	698
	699	assert_nil Issue.find_by_id(6)
	700	end	532	end
			533	assert_nil Issue.find_by_id(6)
	701	end	534	end
	702		535
	703	test "POST /issues/:id/watchers.xml should add watcher" do	536	test "POST /issues/:id/watchers.xml should add watcher" do
	704	assert_difference 'Watcher.count' do	537	assert_difference 'Watcher.count' do
	705	post '/issues/1/watchers.xml', {:user_id => 3}, credentials('jsmith')	538	post '/issues/1/watchers.xml', {:user_id => 3}, credentials('jsmith')
	706		539
	707	assert_response :ok	540	assert_response :ok
	708	assert_equal '', response.body	541	assert_equal '', response.body
	709	end	542	end
	710	watcher = Watcher.order('id desc').first	543	watcher = Watcher.order('id desc').first
	711	assert_equal Issue.find(1), watcher.watchable	544	assert_equal Issue.find(1), watcher.watchable
	712	assert_equal User.find(3), watcher.user	545	assert_equal User.find(3), watcher.user
	713	end	546	end
	714		547
	715	test "DELETE /issues/:id/watchers/:user_id.xml should remove watcher" do	548	test "DELETE /issues/:id/watchers/:user_id.xml should remove watcher" do
	716	Watcher.create!(:user_id => 3, :watchable => Issue.find(1))	549	Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
	717		550
	718	assert_difference 'Watcher.count', -1 do	551	assert_difference 'Watcher.count', -1 do
	719	delete '/issues/1/watchers/3.xml', {}, credentials('jsmith')	552	delete '/issues/1/watchers/3.xml', {}, credentials('jsmith')
	720		553
	721	assert_response :ok	554	assert_response :ok
	722	assert_equal '', response.body	555	assert_equal '', response.body
	723	end	556	end
	724	assert_equal false, Issue.find(1).watched_by?(User.find(3))	557	assert_equal false, Issue.find(1).watched_by?(User.find(3))
	725	end	558	end
	726		559
	727	def test_create_issue_with_uploaded_file	560	def test_create_issue_with_uploaded_file
	728	set_tmp_attachments_directory	561	set_tmp_attachments_directory
	729	# upload the file	562	# upload the file
	730	assert_difference 'Attachment.count' do	563	assert_difference 'Attachment.count' do
	731	post '/uploads.xml', 'test_create_with_upload',	564	post '/uploads.xml', 'test_create_with_upload',
	732	{"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))	565	{"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
	733	assert_response :created	566	assert_response :created
	734	end	567	end
	735	xml = Hash.from_xml(response.body)	568	xml = Hash.from_xml(response.body)
	736	token = xml['upload']['token']	569	token = xml['upload']['token']
	737	attachment = Attachment.order('id DESC').first	570	attachment = Attachment.order('id DESC').first
	738		571
	739	# create the issue with the upload's token	572	# create the issue with the upload's token
	740	assert_difference 'Issue.count' do	573	assert_difference 'Issue.count' do
	741	post '/issues.xml',	574	post '/issues.xml',
	742	{:issue => {:project_id => 1, :subject => 'Uploaded file',	575	{:issue => {:project_id => 1, :subject => 'Uploaded file',
	743	:uploads => [{:token => token, :filename => 'test.txt',	576	:uploads => [{:token => token, :filename => 'test.txt',
	744	:content_type => 'text/plain'}]}},	577	:content_type => 'text/plain'}]}},
	745	credentials('jsmith')	578	credentials('jsmith')
	746	assert_response :created	579	assert_response :created
	747	end	580	end
	748	issue = Issue.order('id DESC').first	581	issue = Issue.order('id DESC').first
	749	assert_equal 1, issue.attachments.count	582	assert_equal 1, issue.attachments.count
	750	assert_equal attachment, issue.attachments.first	583	assert_equal attachment, issue.attachments.first
	751		584
	752	attachment.reload	585	attachment.reload
	753	assert_equal 'test.txt', attachment.filename	586	assert_equal 'test.txt', attachment.filename
	754	assert_equal 'text/plain', attachment.content_type	587	assert_equal 'text/plain', attachment.content_type
	755	assert_equal 'test_create_with_upload'.size, attachment.filesize	588	assert_equal 'test_create_with_upload'.size, attachment.filesize
	756	assert_equal 2, attachment.author_id	589	assert_equal 2, attachment.author_id
	757		590
	758	# get the issue with its attachments	591	# get the issue with its attachments
	759	get "/issues/#{issue.id}.xml", :include => 'attachments'	592	get "/issues/#{issue.id}.xml", :include => 'attachments'
	760	assert_response :success	593	assert_response :success
	761	xml = Hash.from_xml(response.body)	594	xml = Hash.from_xml(response.body)
	762	attachments = xml['issue']['attachments']	595	attachments = xml['issue']['attachments']
	763	assert_kind_of Array, attachments	596	assert_kind_of Array, attachments
	764	assert_equal 1, attachments.size	597	assert_equal 1, attachments.size
	765	url = attachments.first['content_url']	598	url = attachments.first['content_url']
	766	assert_not_nil url	599	assert_not_nil url
	767		600
	768	# download the attachment	601	# download the attachment
	769	get url	602	get url
	770	assert_response :success	603	assert_response :success
	771	end	604	end
	772		605
	773	def test_update_issue_with_uploaded_file	606	def test_update_issue_with_uploaded_file
	774	set_tmp_attachments_directory	607	set_tmp_attachments_directory
	775	# upload the file	608	# upload the file
	776	assert_difference 'Attachment.count' do	609	assert_difference 'Attachment.count' do
	777	post '/uploads.xml', 'test_upload_with_upload',	610	post '/uploads.xml', 'test_upload_with_upload',
	778	{"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))	611	{"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
	779	assert_response :created	612	assert_response :created
	780	end	613	end
	781	xml = Hash.from_xml(response.body)	614	xml = Hash.from_xml(response.body)
	782	token = xml['upload']['token']	615	token = xml['upload']['token']
	783	attachment = Attachment.order('id DESC').first	616	attachment = Attachment.order('id DESC').first
	784		617
	785	# update the issue with the upload's token	618	# update the issue with the upload's token
	786	assert_difference 'Journal.count' do	619	assert_difference 'Journal.count' do
	787	put '/issues/1.xml',	620	put '/issues/1.xml',
	788	{:issue => {:notes => 'Attachment added',	621	{:issue => {:notes => 'Attachment added',
	789	:uploads => [{:token => token, :filename => 'test.txt',	622	:uploads => [{:token => token, :filename => 'test.txt',
	790	:content_type => 'text/plain'}]}},	623	:content_type => 'text/plain'}]}},
	791	credentials('jsmith')	624	credentials('jsmith')
	792	assert_response :ok	625	assert_response :ok
	793	assert_equal '', @response.body	626	assert_equal '', @response.body
	794	end	627	end
	795		628
	796	issue = Issue.find(1)	629	issue = Issue.find(1)
	797	assert_include attachment, issue.attachments	630	assert_include attachment, issue.attachments
	798	end	631	end
	799	end	632	end

test/unit/user_test.rb +45 -80

             # Redmine - project management software
             # Copyright (C) 2006-2014  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.expand_path('../../test_helper', __FILE__)
             class UserTest < ActiveSupport::TestCase
               fixtures :users, :members, :projects, :roles, :member_roles, :auth_sources,
                         :trackers, :issue_statuses,
                         :projects_trackers,
                         :watchers,
                         :issue_categories, :enumerations, :issues,
                         :journals, :journal_details,
                         :groups_users,
                         :enabled_modules
               include Redmine::I18n
               def setup
                 @admin = User.find(1)
                 @jsmith = User.find(2)
                 @dlopper = User.find(3)
               end
               def test_sorted_scope_should_sort_user_by_display_name
                 # Use .active to ignore anonymous with localized display name
                 assert_equal User.active.map(&:name).map(&:downcase).sort,
                              User.active.sorted.map(&:name).map(&:downcase)
               end
               def test_generate
                 User.generate!(:firstname => 'Testing connection')
                 User.generate!(:firstname => 'Testing connection')
                 assert_equal 2, User.where(:firstname => 'Testing connection').count
               end
               def test_truth
                 assert_kind_of User, @jsmith
               end
               def test_mail_should_be_stripped
                 u = User.new
                 u.mail = " foo@bar.com  "
                 assert_equal "foo@bar.com", u.mail
               end
               def test_mail_validation
                 u = User.new
                 u.mail = ''
                 assert !u.valid?
                 assert_include I18n.translate('activerecord.errors.messages.blank'), u.errors[:mail]
               end
               def test_login_length_validation
                 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                 user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
                 assert !user.valid?
                 user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
                 assert user.valid?
                 assert user.save
               end
               def test_generate_password_should_respect_minimum_password_length
                 with_settings :password_min_length => 15 do
                   user = User.generate!(:generate_password => true)
                   assert user.password.length >= 15
                 end
               end
               def test_generate_password_should_not_generate_password_with_less_than_10_characters
                 with_settings :password_min_length => 4 do
                   user = User.generate!(:generate_password => true)
                   assert user.password.length >= 10
                 end
               end
               def test_generate_password_on_create_should_set_password
                 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                 user.login = "newuser"
                 user.generate_password = true
                 assert user.save
                 password = user.password
                 assert user.check_password?(password)
               end
               def test_generate_password_on_update_should_update_password
                 user = User.find(2)
                 hash = user.hashed_password
                 user.generate_password = true
                 assert user.save
                 password = user.password
                 assert user.check_password?(password)
                 assert_not_equal hash, user.reload.hashed_password
               end
               def test_create
                 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                 user.login = "jsmith"
                 user.password, user.password_confirmation = "password", "password"
                 # login uniqueness
                 assert !user.save
                 assert_equal 1, user.errors.count
                 user.login = "newuser"
                 user.password, user.password_confirmation = "password", "pass"
                 # password confirmation
                 assert !user.save
                 assert_equal 1, user.errors.count
                 user.password, user.password_confirmation = "password", "password"
                 assert user.save
               end
               def test_user_before_create_should_set_the_mail_notification_to_the_default_setting
                 @user1 = User.generate!
                 assert_equal 'only_my_events', @user1.mail_notification
                 with_settings :default_notification_option => 'all' do
                   @user2 = User.generate!
                   assert_equal 'all', @user2.mail_notification
                 end
               end
               def test_user_login_should_be_case_insensitive
                 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                 u.login = 'newuser'
                 u.password, u.password_confirmation = "password", "password"
                 assert u.save
                 u = User.new(:firstname => "Similar", :lastname => "User",
                              :mail => "similaruser@somenet.foo")
                 u.login = 'NewUser'
                 u.password, u.password_confirmation = "password", "password"
                 assert !u.save
                 assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:login]
               end
               def test_mail_uniqueness_should_not_be_case_sensitive
                 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                 u.login = 'newuser1'
                 u.password, u.password_confirmation = "password", "password"
                 assert u.save
                 u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
                 u.login = 'newuser2'
                 u.password, u.password_confirmation = "password", "password"
                 assert !u.save
                 assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:mail]
               end
               def test_update
                 assert_equal "admin", @admin.login
                 @admin.login = "john"
                 assert @admin.save, @admin.errors.full_messages.join("; ")
                 @admin.reload
                 assert_equal "john", @admin.login
               end
               def test_update_should_not_fail_for_legacy_user_with_different_case_logins
                 u1 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser1@somenet.foo")
                 u1.login = 'newuser1'
                 assert u1.save
                 u2 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser2@somenet.foo")
                 u2.login = 'newuser1'
                 assert u2.save(:validate => false)
                 user = User.find(u2.id)
                 user.firstname = "firstname"
                 assert user.save, "Save failed"
               end
               def test_destroy_should_delete_members_and_roles
                 members = Member.where(:user_id => 2)
                 ms = members.count
                 rs = members.collect(&:roles).flatten.size
                 assert ms > 0
                 assert rs > 0
                 assert_difference 'Member.count', - ms do
                   assert_difference 'MemberRole.count', - rs do
                     User.find(2).destroy
                   end
                 end
                 assert_nil User.find_by_id(2)
                 assert_equal 0, Member.where(:user_id => 2).count
               end
               def test_destroy_should_update_attachments
                 attachment = Attachment.create!(:container => Project.find(1),
                   :file => uploaded_test_file("testfile.txt", "text/plain"),
                   :author_id => 2)
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, attachment.reload.author
               end
               def test_destroy_should_update_comments
                 comment = Comment.create!(
                   :commented => News.create!(:project_id => 1,
                                              :author_id => 1, :title => 'foo', :description => 'foo'),
                   :author => User.find(2),
                   :comments => 'foo'
                 )
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, comment.reload.author
               end
               def test_destroy_should_update_issues
                 issue = Issue.create!(:project_id => 1, :author_id => 2,
                                       :tracker_id => 1, :subject => 'foo')
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, issue.reload.author
               end
               def test_destroy_should_unassign_issues
                 issue = Issue.create!(:project_id => 1, :author_id => 1,
                                       :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_nil issue.reload.assigned_to
               end
               def test_destroy_should_update_journals
                 issue = Issue.create!(:project_id => 1, :author_id => 2,
                                       :tracker_id => 1, :subject => 'foo')
                 issue.init_journal(User.find(2), "update")
                 issue.save!
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, issue.journals.first.reload.user
               end
               def test_destroy_should_update_journal_details_old_value
                 issue = Issue.create!(:project_id => 1, :author_id => 1,
                                       :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                 issue.init_journal(User.find(1), "update")
                 issue.assigned_to_id = nil
                 assert_difference 'JournalDetail.count' do
                   issue.save!
                 end
                 journal_detail = JournalDetail.order('id DESC').first
                 assert_equal '2', journal_detail.old_value
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
               end
               def test_destroy_should_update_journal_details_value
                 issue = Issue.create!(:project_id => 1, :author_id => 1,
                                       :tracker_id => 1, :subject => 'foo')
                 issue.init_journal(User.find(1), "update")
                 issue.assigned_to_id = 2
                 assert_difference 'JournalDetail.count' do
                   issue.save!
                 end
                 journal_detail = JournalDetail.order('id DESC').first
                 assert_equal '2', journal_detail.value
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous.id.to_s, journal_detail.reload.value
               end
               def test_destroy_should_update_messages
                 board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
                 message = Message.create!(:board_id => board.id, :author_id => 2,
                                           :subject => 'foo', :content => 'foo')
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, message.reload.author
               end
               def test_destroy_should_update_news
                 news = News.create!(:project_id => 1, :author_id => 2,
                                     :title => 'foo', :description => 'foo')
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, news.reload.author
               end
               def test_destroy_should_delete_private_queries
                 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
                 query.project_id = 1
                 query.user_id = 2
                 query.save!
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_nil Query.find_by_id(query.id)
               end
               def test_destroy_should_update_public_queries
                 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
                 query.project_id = 1
                 query.user_id = 2
                 query.save!
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, query.reload.user
               end
               def test_destroy_should_update_time_entries
                 entry = TimeEntry.new(:hours => '2', :spent_on => Date.today,
                                       :activity => TimeEntryActivity.create!(:name => 'foo'))
                 entry.project_id = 1
                 entry.user_id = 2
                 entry.save!
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, entry.reload.user
               end
               def test_destroy_should_delete_tokens
                 token = Token.create!(:user_id => 2, :value => 'foo')
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_nil Token.find_by_id(token.id)
               end
               def test_destroy_should_delete_watchers
                 issue = Issue.create!(:project_id => 1, :author_id => 1,
                                       :tracker_id => 1, :subject => 'foo')
                 watcher = Watcher.create!(:user_id => 2, :watchable => issue)
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_nil Watcher.find_by_id(watcher.id)
               end
               def test_destroy_should_update_wiki_contents
                 wiki_content = WikiContent.create!(
                   :text => 'foo',
                   :author_id => 2,
                   :page => WikiPage.create!(:title => 'Foo',
                                             :wiki => Wiki.create!(:project_id => 3,
                                                                   :start_page => 'Start'))
                 )
                 wiki_content.text = 'bar'
                 assert_difference 'WikiContent::Version.count' do
                   wiki_content.save!
                 end
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_equal User.anonymous, wiki_content.reload.author
                 wiki_content.versions.each do |version|
                   assert_equal User.anonymous, version.reload.author
                 end
               end
               def test_destroy_should_nullify_issue_categories
                 category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_nil category.reload.assigned_to_id
               end
               def test_destroy_should_nullify_changesets
                 changeset = Changeset.create!(
                   :repository => Repository::Subversion.create!(
                     :project_id => 1,
                     :url => 'file:///tmp',
                     :identifier => 'tmp'
                   ),
                   :revision => '12',
                   :committed_on => Time.now,
                   :committer => 'jsmith'
                   )
                 assert_equal 2, changeset.user_id
                 User.find(2).destroy
                 assert_nil User.find_by_id(2)
                 assert_nil changeset.reload.user_id
               end
               def test_anonymous_user_should_not_be_destroyable
                 assert_no_difference 'User.count' do
                   assert_equal false, User.anonymous.destroy
                 end
               end
               def test_password_change_should_destroy_tokens
                 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                 user = User.find(2)
                 user.password, user.password_confirmation = "a new password", "a new password"
                 assert user.save
                 assert_nil Token.find_by_id(recovery_token.id)
                 assert_nil Token.find_by_id(autologin_token.id)
               end
               def test_mail_change_should_destroy_tokens
                 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                 user = User.find(2)
                 user.mail = "user@somwehere.com"
                 assert user.save
                 assert_nil Token.find_by_id(recovery_token.id)
                 assert_equal autologin_token, Token.find_by_id(autologin_token.id)
               end
               def test_change_on_other_fields_should_not_destroy_tokens
                 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                 user = User.find(2)
                 user.firstname = "Bobby"
                 assert user.save
                 assert_equal recovery_token, Token.find_by_id(recovery_token.id)
                 assert_equal autologin_token, Token.find_by_id(autologin_token.id)
               end
               def test_validate_login_presence
                 @admin.login = ""
                 assert !@admin.save
                 assert_equal 1, @admin.errors.count
               end
               def test_validate_mail_notification_inclusion
                 u = User.new
                 u.mail_notification = 'foo'
                 u.save
                 assert_not_equal [], u.errors[:mail_notification]
               end
               def test_password
                 user = User.try_to_login("admin", "admin")
                 assert_kind_of User, user
                 assert_equal "admin", user.login
                 user.password = "hello123"
                 assert user.save
                 user = User.try_to_login("admin", "hello123")
                 assert_kind_of User, user
                 assert_equal "admin", user.login
               end
               def test_validate_password_length
                 with_settings :password_min_length => '100' do
                   user = User.new(:firstname => "new100",
                                   :lastname => "user100", :mail => "newuser100@somenet.foo")
                   user.login = "newuser100"
                   user.password, user.password_confirmation = "password100", "password100"
                   assert !user.save
                   assert_equal 1, user.errors.count
                 end
               end
               def test_name_format
                 assert_equal 'John S.', @jsmith.name(:firstname_lastinitial)
                 assert_equal 'Smith, John', @jsmith.name(:lastname_coma_firstname)
                 assert_equal 'J. Smith', @jsmith.name(:firstinitial_lastname)
                 assert_equal 'J.-P. Lang', User.new(:firstname => 'Jean-Philippe', :lastname => 'Lang').name(:firstinitial_lastname)
               end
               def test_name_should_use_setting_as_default_format
                 with_settings :user_format => :firstname_lastname do
                   assert_equal 'John Smith', @jsmith.reload.name
                 end
                 with_settings :user_format => :username do
                   assert_equal 'jsmith', @jsmith.reload.name
                 end
                 with_settings :user_format => :lastname do
                   assert_equal 'Smith', @jsmith.reload.name
                 end
               end
               def test_today_should_return_the_day_according_to_user_time_zone
                 preference = User.find(1).pref
                 date = Date.new(2012, 05, 15)
                 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
                 Date.stubs(:today).returns(date)
                 Time.stubs(:now).returns(time)
                 preference.update_attribute :time_zone, 'Baku' # UTC+4
                 assert_equal '2012-05-16', User.find(1).today.to_s
                 preference.update_attribute :time_zone, 'La Paz' # UTC-4
                 assert_equal '2012-05-15', User.find(1).today.to_s
                 preference.update_attribute :time_zone, ''
                 assert_equal '2012-05-15', User.find(1).today.to_s
               end
               def test_time_to_date_should_return_the_date_according_to_user_time_zone
                 preference = User.find(1).pref
                 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
                 preference.update_attribute :time_zone, 'Baku' # UTC+4
                 assert_equal '2012-05-16', User.find(1).time_to_date(time).to_s
                 preference.update_attribute :time_zone, 'La Paz' # UTC-4
                 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
                 preference.update_attribute :time_zone, ''
                 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
               end
               def test_fields_for_order_statement_should_return_fields_according_user_format_setting
                 with_settings :user_format => 'lastname_coma_firstname' do
                   assert_equal ['users.lastname', 'users.firstname', 'users.id'],
                                User.fields_for_order_statement
                 end
               end
               def test_fields_for_order_statement_width_table_name_should_prepend_table_name
                 with_settings :user_format => 'lastname_firstname' do
                   assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'],
                                User.fields_for_order_statement('authors')
                 end
               end
               def test_fields_for_order_statement_with_blank_format_should_return_default
                 with_settings :user_format => '' do
                   assert_equal ['users.firstname', 'users.lastname', 'users.id'],
                                User.fields_for_order_statement
                 end
               end
               def test_fields_for_order_statement_with_invalid_format_should_return_default
                 with_settings :user_format => 'foo' do
                   assert_equal ['users.firstname', 'users.lastname', 'users.id'],
                                User.fields_for_order_statement
                 end
               end
               test ".try_to_login with good credentials should return the user" do
                 user = User.try_to_login("admin", "admin")
                 assert_kind_of User, user
                 assert_equal "admin", user.login
               end
               test ".try_to_login with wrong credentials should return nil" do
                 assert_nil User.try_to_login("admin", "foo")
               end
               def test_try_to_login_with_locked_user_should_return_nil
                 @jsmith.status = User::STATUS_LOCKED
                 @jsmith.save!
                 user = User.try_to_login("jsmith", "jsmith")
                 assert_equal nil, user
               end
               def test_try_to_login_with_locked_user_and_not_active_only_should_return_user
                 @jsmith.status = User::STATUS_LOCKED
                 @jsmith.save!
                 user = User.try_to_login("jsmith", "jsmith", false)
                 assert_equal @jsmith, user
               end
               test ".try_to_login should fall-back to case-insensitive if user login is not found as-typed" do
                 user = User.try_to_login("AdMin", "admin")
                 assert_kind_of User, user
                 assert_equal "admin", user.login
               end
               test ".try_to_login should select the exact matching user first" do
                 case_sensitive_user = User.generate! do |user|
                   user.password = "admin123"
                 end
                 # bypass validations to make it appear like existing data
                 case_sensitive_user.update_attribute(:login, 'ADMIN')
                 user = User.try_to_login("ADMIN", "admin123")
                 assert_kind_of User, user
                 assert_equal "ADMIN", user.login
               end
               if ldap_configured?
-                context "#try_to_login using LDAP" do
+                test "#try_to_login using LDAP with failed connection to the LDAP server" do
-                  context "with failed connection to the LDAP server" do
+                  auth_source = AuthSourceLdap.find(1)
-                    should "return nil" do
+                  AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
-                      @auth_source = AuthSourceLdap.find(1)
-                      AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
-                      assert_equal nil, User.try_to_login('edavis', 'wrong')
+                  assert_equal nil, User.try_to_login('edavis', 'wrong')
-                    end
+                end
-                  end
-                  context "with an unsuccessful authentication" do
+                test "#try_to_login using LDAP" do
-                    should "return nil" do
+                  assert_equal nil, User.try_to_login('edavis', 'wrong')
-                      assert_equal nil, User.try_to_login('edavis', 'wrong')
+                end
-                    end
-                  end
-                  context "binding with user's account" do
+                test "#try_to_login using LDAP binding with user's account" do
-                    setup do
+                  auth_source = AuthSourceLdap.find(1)
-                      @auth_source = AuthSourceLdap.find(1)
+                  auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
-                      @auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
+                  auth_source.account_password = ''
-                      @auth_source.account_password = ''
+                  auth_source.save!
-                      @auth_source.save!
-                      @ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
+                  ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
-                      @ldap_user.login = 'example1'
+                  ldap_user.login = 'example1'
-                      @ldap_user.save!
+                  ldap_user.save!
-                    end
-                    context "with a successful authentication" do
+                  assert_equal @ldap_user, User.try_to_login('example1', '123456')
-                      should "return the user" do
+                  assert_nil User.try_to_login('example1', '11111')
-                        assert_equal @ldap_user, User.try_to_login('example1', '123456')
+                end
-                      end
-                    end
-                    context "with an unsuccessful authentication" do
+                test "#try_to_login using LDAP on the fly registration" do
-                      should "return nil" do
+                  AuthSourceLdap.find(1).update_attribute :onthefly_register, true
-                        assert_nil User.try_to_login('example1', '11111')
-                      end
+                  assert_difference('User.count') do
-                    end
+                    assert User.try_to_login('edavis', '123456')
                   end
-                  context "on the fly registration" do
+                  assert_no_difference('User.count') do
-                    setup do
+                    assert User.try_to_login('edavis', '123456')
-                      @auth_source = AuthSourceLdap.find(1)
+                  end
-                      @auth_source.update_attribute :onthefly_register, true
-                    end
-                    context "with a successful authentication" do
+                  assert_nil User.try_to_login('example1', '11111')
-                      should "create a new user account if it doesn't exist" do
+                end
-                        assert_difference('User.count') do
-                          user = User.try_to_login('edavis', '123456')
-                          assert !user.admin?
-                        end
-                      end
-                      should "retrieve existing user" do
-                        user = User.try_to_login('edavis', '123456')
-                        user.admin = true
-                        user.save!
-                        assert_no_difference('User.count') do
-                          user = User.try_to_login('edavis', '123456')
-                          assert user.admin?
-                        end
-                      end
-                    end
-                    context "binding with user's account" do
+                test "#try_to_login using LDAP on the fly registration and binding with user's account" do
-                      setup do
+                  auth_source = AuthSourceLdap.find(1)
-                        @auth_source = AuthSourceLdap.find(1)
+                  auth_source.update_attribute :onthefly_register, true
-                        @auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
+                  auth_source = AuthSourceLdap.find(1)
-                        @auth_source.account_password = ''
+                  auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
-                        @auth_source.save!
+                  auth_source.account_password = ''
-                      end
+                  auth_source.save!
-                      context "with a successful authentication" do
+                  assert_difference('User.count') do
-                        should "create a new user account if it doesn't exist" do
+                    assert User.try_to_login('example1', '123456')
-                          assert_difference('User.count') do
-                            user = User.try_to_login('example1', '123456')
-                            assert_kind_of User, user
-                          end
-                        end
-                      end
-                      context "with an unsuccessful authentication" do
-                        should "return nil" do
-                          assert_nil User.try_to_login('example1', '11111')
-                        end
-                      end
-                    end
                   end
+                  assert_no_difference('User.count') do
+                    assert User.try_to_login('edavis', '123456')
+                  end
+                  assert_nil User.try_to_login('example1', '11111')
                 end
               else
                 puts "Skipping LDAP tests."
               end
               def test_create_anonymous
                 AnonymousUser.delete_all
                 anon = User.anonymous
                 assert !anon.new_record?
                 assert_kind_of AnonymousUser, anon
               end
               def test_ensure_single_anonymous_user
                 AnonymousUser.delete_all
                 anon1 = User.anonymous
                 assert !anon1.new_record?
                 assert_kind_of AnonymousUser, anon1
                 anon2 = AnonymousUser.create(
                             :lastname => 'Anonymous', :firstname => '',
                             :mail => '', :login => '', :status => 0)
                 assert_equal 1, anon2.errors.count
               end
               def test_rss_key
                 assert_nil @jsmith.rss_token
                 key = @jsmith.rss_key
                 assert_equal 40, key.length
                 @jsmith.reload
                 assert_equal key, @jsmith.rss_key
               end
               def test_rss_key_should_not_be_generated_twice
                 assert_difference 'Token.count', 1 do
                   key1 = @jsmith.rss_key
                   key2 = @jsmith.rss_key
                   assert_equal key1, key2
                 end
               end
               def test_api_key_should_not_be_generated_twice
                 assert_difference 'Token.count', 1 do
                   key1 = @jsmith.api_key
                   key2 = @jsmith.api_key
                   assert_equal key1, key2
                 end
               end
               test "#api_key should generate a new one if the user doesn't have one" do
                 user = User.generate!(:api_token => nil)
                 assert_nil user.api_token
                 key = user.api_key
                 assert_equal 40, key.length
                 user.reload
                 assert_equal key, user.api_key
               end
               test "#api_key should return the existing api token value" do
                 user = User.generate!
                 token = Token.create!(:action => 'api')
                 user.api_token = token
                 assert user.save
                 assert_equal token.value, user.api_key
               end
               test "#find_by_api_key should return nil if no matching key is found" do
                 assert_nil User.find_by_api_key('zzzzzzzzz')
               end
               test "#find_by_api_key should return nil if the key is found for an inactive user" do
                 user = User.generate!
                 user.status = User::STATUS_LOCKED
                 token = Token.create!(:action => 'api')
                 user.api_token = token
                 user.save
                 assert_nil User.find_by_api_key(token.value)
               end
               test "#find_by_api_key should return the user if the key is found for an active user" do
                 user = User.generate!
                 token = Token.create!(:action => 'api')
                 user.api_token = token
                 user.save
                 assert_equal user, User.find_by_api_key(token.value)
               end
               def test_default_admin_account_changed_should_return_false_if_account_was_not_changed
                 user = User.find_by_login("admin")
                 user.password = "admin"
                 assert user.save(:validate => false)
                 assert_equal false, User.default_admin_account_changed?
               end
               def test_default_admin_account_changed_should_return_true_if_password_was_changed
                 user = User.find_by_login("admin")
                 user.password = "newpassword"
                 user.save!
                 assert_equal true, User.default_admin_account_changed?
               end
               def test_default_admin_account_changed_should_return_true_if_account_is_disabled
                 user = User.find_by_login("admin")
                 user.password = "admin"
                 user.status = User::STATUS_LOCKED
                 assert user.save(:validate => false)
                 assert_equal true, User.default_admin_account_changed?
               end
               def test_default_admin_account_changed_should_return_true_if_account_does_not_exist
                 user = User.find_by_login("admin")
                 user.destroy
                 assert_equal true, User.default_admin_account_changed?
               end
               def test_membership_with_project_should_return_membership
                 project = Project.find(1)
                 membership = @jsmith.membership(project)
                 assert_kind_of Member, membership
                 assert_equal @jsmith, membership.user
                 assert_equal project, membership.project
               end
               def test_membership_with_project_id_should_return_membership
                 project = Project.find(1)
                 membership = @jsmith.membership(1)
                 assert_kind_of Member, membership
                 assert_equal @jsmith, membership.user
                 assert_equal project, membership.project
               end
               def test_membership_for_non_member_should_return_nil
                 project = Project.find(1)
                 user = User.generate!
                 membership = user.membership(1)
                 assert_nil membership
               end
               def test_roles_for_project_with_member_on_public_project_should_return_roles_and_non_member
                 roles = @jsmith.roles_for_project(Project.find(1))
                 assert_kind_of Role, roles.first
                 assert_equal ["Manager"], roles.map(&:name)
               end
               def test_roles_for_project_with_member_on_private_project_should_return_roles
                 Project.find(1).update_attribute :is_public, false
                 roles = @jsmith.roles_for_project(Project.find(1))
                 assert_kind_of Role, roles.first
                 assert_equal ["Manager"], roles.map(&:name)
               end
               def test_roles_for_project_with_non_member_with_public_project_should_return_non_member
                 set_language_if_valid 'en'
                 roles = User.find(8).roles_for_project(Project.find(1))
                 assert_equal ["Non member"], roles.map(&:name)
               end
               def test_roles_for_project_with_non_member_with_public_project_and_override_should_return_override_roles
                 project = Project.find(1)
                 Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
                 roles = User.find(8).roles_for_project(project)
                 assert_equal ["Developer", "Manager"], roles.map(&:name).sort
               end
               def test_roles_for_project_with_non_member_with_private_project_should_return_no_roles
                 Project.find(1).update_attribute :is_public, false
                 roles = User.find(8).roles_for_project(Project.find(1))
                 assert_equal [], roles.map(&:name)
               end
               def test_roles_for_project_with_non_member_with_private_project_and_override_should_return_no_roles
                 project = Project.find(1)
                 project.update_attribute :is_public, false
                 Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
                 roles = User.find(8).roles_for_project(project)
                 assert_equal [], roles.map(&:name).sort
               end
               def test_roles_for_project_with_anonymous_with_public_project_should_return_anonymous
                 set_language_if_valid 'en'
                 roles = User.anonymous.roles_for_project(Project.find(1))
                 assert_equal ["Anonymous"], roles.map(&:name)
               end
               def test_roles_for_project_with_anonymous_with_public_project_and_override_should_return_override_roles
                 project = Project.find(1)
                 Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
                 roles = User.anonymous.roles_for_project(project)
                 assert_equal ["Developer", "Manager"], roles.map(&:name).sort
               end
               def test_roles_for_project_with_anonymous_with_private_project_should_return_no_roles
                 Project.find(1).update_attribute :is_public, false
                 roles = User.anonymous.roles_for_project(Project.find(1))
                 assert_equal [], roles.map(&:name)
               end
               def test_roles_for_project_with_anonymous_with_private_project_and_override_should_return_no_roles
                 project = Project.find(1)
                 project.update_attribute :is_public, false
                 Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
                 roles = User.anonymous.roles_for_project(project)
                 assert_equal [], roles.map(&:name).sort
               end
               def test_projects_by_role_for_user_with_role
                 user = User.find(2)
                 assert_kind_of Hash, user.projects_by_role
                 assert_equal 2, user.projects_by_role.size
                 assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
                 assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
               end
               def test_accessing_projects_by_role_with_no_projects_should_return_an_empty_array
                 user = User.find(2)
                 assert_equal [], user.projects_by_role[Role.find(3)]
                 # should not update the hash
                 assert_nil user.projects_by_role.values.detect(&:blank?)
               end
               def test_projects_by_role_for_user_with_no_role
                 user = User.generate!
                 assert_equal({}, user.projects_by_role)
               end
               def test_projects_by_role_for_anonymous
                 assert_equal({}, User.anonymous.projects_by_role)
               end
               def test_valid_notification_options
                 # without memberships
                 assert_equal 5, User.find(7).valid_notification_options.size
                 # with memberships
                 assert_equal 6, User.find(2).valid_notification_options.size
               end
               def test_valid_notification_options_class_method
                 assert_equal 5, User.valid_notification_options.size
                 assert_equal 5, User.valid_notification_options(User.find(7)).size
                 assert_equal 6, User.valid_notification_options(User.find(2)).size
               end
               def test_notified_project_ids_setter_should_coerce_to_unique_integer_array
                 @jsmith.notified_project_ids = ["1", "123", "2u", "wrong", "12", 6, 12, -35, ""]
                 assert_equal [1, 123, 2, 12, 6], @jsmith.notified_projects_ids
               end
               def test_mail_notification_all
                 @jsmith.mail_notification = 'all'
                 @jsmith.notified_project_ids = []
                 @jsmith.save
                 @jsmith.reload
                 assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
               end
               def test_mail_notification_selected
                 @jsmith.mail_notification = 'selected'
                 @jsmith.notified_project_ids = [1]
                 @jsmith.save
                 @jsmith.reload
                 assert Project.find(1).recipients.include?(@jsmith.mail)
               end
               def test_mail_notification_only_my_events
                 @jsmith.mail_notification = 'only_my_events'
                 @jsmith.notified_project_ids = []
                 @jsmith.save
                 @jsmith.reload
                 assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
               end
               def test_comments_sorting_preference
                 assert !@jsmith.wants_comments_in_reverse_order?
                 @jsmith.pref.comments_sorting = 'asc'
                 assert !@jsmith.wants_comments_in_reverse_order?
                 @jsmith.pref.comments_sorting = 'desc'
                 assert @jsmith.wants_comments_in_reverse_order?
               end
               def test_find_by_mail_should_be_case_insensitive
                 u = User.find_by_mail('JSmith@somenet.foo')
                 assert_not_nil u
                 assert_equal 'jsmith@somenet.foo', u.mail
               end
               def test_random_password
                 u = User.new
                 u.random_password
                 assert !u.password.blank?
                 assert !u.password_confirmation.blank?
               end
               test "#change_password_allowed? should be allowed if no auth source is set" do
                 user = User.generate!
                 assert user.change_password_allowed?
               end
               test "#change_password_allowed? should delegate to the auth source" do
                 user = User.generate!
                 allowed_auth_source = AuthSource.generate!
                 def allowed_auth_source.allow_password_changes?; true; end
                 denied_auth_source = AuthSource.generate!
                 def denied_auth_source.allow_password_changes?; false; end
                 assert user.change_password_allowed?
                 user.auth_source = allowed_auth_source
                 assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
                 user.auth_source = denied_auth_source
                 assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
               end
               def test_own_account_deletable_should_be_true_with_unsubscrive_enabled
                 with_settings :unsubscribe => '1' do
                   assert_equal true, User.find(2).own_account_deletable?
                 end
               end
               def test_own_account_deletable_should_be_false_with_unsubscrive_disabled
                 with_settings :unsubscribe => '0' do
                   assert_equal false, User.find(2).own_account_deletable?
                 end
               end
               def test_own_account_deletable_should_be_false_for_a_single_admin
                 User.delete_all(["admin = ? AND id <> ?", true, 1])
                 with_settings :unsubscribe => '1' do
                   assert_equal false, User.find(1).own_account_deletable?
                 end
               end
               def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
                 User.generate! do |user|
                   user.admin = true
                 end
                 with_settings :unsubscribe => '1' do
                   assert_equal true, User.find(1).own_account_deletable?
                 end
               end
               context "#allowed_to?" do
                 context "with a unique project" do
                   should "return false if project is archived" do
                     project = Project.find(1)
                     Project.any_instance.stubs(:status).returns(Project::STATUS_ARCHIVED)
                     assert_equal false, @admin.allowed_to?(:view_issues, Project.find(1))
                   end
                   should "return false for write action if project is closed" do
                     project = Project.find(1)
                     Project.any_instance.stubs(:status).returns(Project::STATUS_CLOSED)
                     assert_equal false, @admin.allowed_to?(:edit_project, Project.find(1))
                   end
                   should "return true for read action if project is closed" do
                     project = Project.find(1)
                     Project.any_instance.stubs(:status).returns(Project::STATUS_CLOSED)
                     assert_equal true, @admin.allowed_to?(:view_project, Project.find(1))
                   end
                   should "return false if related module is disabled" do
                     project = Project.find(1)
                     project.enabled_module_names = ["issue_tracking"]
                     assert_equal true, @admin.allowed_to?(:add_issues, project)
                     assert_equal false, @admin.allowed_to?(:view_wiki_pages, project)
                   end
                   should "authorize nearly everything for admin users" do
                     project = Project.find(1)
                     assert ! @admin.member_of?(project)
                     %w(edit_issues delete_issues manage_news add_documents manage_wiki).each do |p|
                       assert_equal true, @admin.allowed_to?(p.to_sym, project)
                     end
                   end
                   should "authorize normal users depending on their roles" do
                     project = Project.find(1)
                     assert_equal true, @jsmith.allowed_to?(:delete_messages, project)    #Manager
                     assert_equal false, @dlopper.allowed_to?(:delete_messages, project) #Developper
                   end
                 end
                 context "with multiple projects" do
                   should "return false if array is empty" do
                     assert_equal false, @admin.allowed_to?(:view_project, [])
                   end
                   should "return true only if user has permission on all these projects" do
                     assert_equal true, @admin.allowed_to?(:view_project, Project.all.to_a)
                     assert_equal false, @dlopper.allowed_to?(:view_project, Project.all.to_a) #cannot see Project(2)
                     assert_equal true, @jsmith.allowed_to?(:edit_issues, @jsmith.projects.to_a) #Manager or Developer everywhere
                     assert_equal false, @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects.to_a) #Dev cannot delete_issue_watchers
                   end
                   should "behave correctly with arrays of 1 project" do
                     assert_equal false, User.anonymous.allowed_to?(:delete_issues, [Project.first])
                   end
                 end
                 context "with options[:global]" do
                   should "authorize if user has at least one role that has this permission" do
                     @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                     @anonymous = User.find(6)
                     assert_equal true, @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
                     assert_equal false, @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
                     assert_equal true, @dlopper2.allowed_to?(:add_issues, nil, :global => true)
                     assert_equal false, @anonymous.allowed_to?(:add_issues, nil, :global => true)
                     assert_equal true, @anonymous.allowed_to?(:view_issues, nil, :global => true)
                   end
                 end
               end
               # this is just a proxy method, the test only calls it to ensure it doesn't break trivially
               context "#allowed_to_globally?" do
                 should "proxy to #allowed_to? and reflect global permissions" do
                   @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                   @anonymous = User.find(6)
                   assert_equal true, @jsmith.allowed_to_globally?(:delete_issue_watchers)
                   assert_equal false, @dlopper2.allowed_to_globally?(:delete_issue_watchers)
                   assert_equal true, @dlopper2.allowed_to_globally?(:add_issues)
                   assert_equal false, @anonymous.allowed_to_globally?(:add_issues)
                   assert_equal true, @anonymous.allowed_to_globally?(:view_issues)
                 end
               end
               context "User#notify_about?" do
                 context "Issues" do
                   setup do
                     @project = Project.find(1)
                     @author = User.generate!
                     @assignee = User.generate!
                     @issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)
                   end
                   should "be true for a user with :all" do
                     @author.update_attribute(:mail_notification, 'all')
                     assert @author.notify_about?(@issue)
                   end
                   should "be false for a user with :none" do
                     @author.update_attribute(:mail_notification, 'none')
                     assert ! @author.notify_about?(@issue)
                   end
                   should "be false for a user with :only_my_events and isn't an author, creator, or assignee" do
                     @user = User.generate!(:mail_notification => 'only_my_events')
                     Member.create!(:user => @user, :project => @project, :role_ids => [1])
                     assert ! @user.notify_about?(@issue)
                   end
                   should "be true for a user with :only_my_events and is the author" do
                     @author.update_attribute(:mail_notification, 'only_my_events')
                     assert @author.notify_about?(@issue)
                   end
                   should "be true for a user with :only_my_events and is the assignee" do
                     @assignee.update_attribute(:mail_notification, 'only_my_events')
                     assert @assignee.notify_about?(@issue)
                   end
                   should "be true for a user with :only_assigned and is the assignee" do
                     @assignee.update_attribute(:mail_notification, 'only_assigned')
                     assert @assignee.notify_about?(@issue)
                   end
                   should "be false for a user with :only_assigned and is not the assignee" do
                     @author.update_attribute(:mail_notification, 'only_assigned')
                     assert ! @author.notify_about?(@issue)
                   end
                   should "be true for a user with :only_owner and is the author" do
                     @author.update_attribute(:mail_notification, 'only_owner')
                     assert @author.notify_about?(@issue)
                   end
                   should "be false for a user with :only_owner and is not the author" do
                     @assignee.update_attribute(:mail_notification, 'only_owner')
                     assert ! @assignee.notify_about?(@issue)
                   end
                   should "be true for a user with :selected and is the author" do
                     @author.update_attribute(:mail_notification, 'selected')
                     assert @author.notify_about?(@issue)
                   end
                   should "be true for a user with :selected and is the assignee" do
                     @assignee.update_attribute(:mail_notification, 'selected')
                     assert @assignee.notify_about?(@issue)
                   end
                   should "be false for a user with :selected and is not the author or assignee" do
                     @user = User.generate!(:mail_notification => 'selected')
                     Member.create!(:user => @user, :project => @project, :role_ids => [1])
                     assert ! @user.notify_about?(@issue)
                   end
                 end
               end
               def test_notify_about_news
                 user = User.generate!
                 news = News.new
                 User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
                   user.mail_notification = option
                   assert_equal (option != 'none'), user.notify_about?(news)
                 end
               end
               def test_salt_unsalted_passwords
                 # Restore a user with an unsalted password
                 user = User.find(1)
                 user.salt = nil
                 user.hashed_password = User.hash_password("unsalted")
                 user.save!
                 User.salt_unsalted_passwords!
                 user.reload
                 # Salt added
                 assert !user.salt.blank?
                 # Password still valid
                 assert user.check_password?("unsalted")
                 assert_equal user, User.try_to_login(user.login, "unsalted")
               end
               if Object.const_defined?(:OpenID)
                 def test_setting_identity_url
                   normalized_open_id_url = 'http://example.com/'
                   u = User.new( :identity_url => 'http://example.com/' )
                   assert_equal normalized_open_id_url, u.identity_url
                 end
                 def test_setting_identity_url_without_trailing_slash
                   normalized_open_id_url = 'http://example.com/'
                   u = User.new( :identity_url => 'http://example.com' )
                   assert_equal normalized_open_id_url, u.identity_url
                 end
                 def test_setting_identity_url_without_protocol
                   normalized_open_id_url = 'http://example.com/'
                   u = User.new( :identity_url => 'example.com' )
                   assert_equal normalized_open_id_url, u.identity_url
                 end
                 def test_setting_blank_identity_url
                   u = User.new( :identity_url => 'example.com' )
                   u.identity_url = ''
                   assert u.identity_url.blank?
                 end
                 def test_setting_invalid_identity_url
                   u = User.new( :identity_url => 'this is not an openid url' )
                   assert u.identity_url.blank?
                 end
               else
                 puts "Skipping openid tests."
               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