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 +2 -13

               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.login_required = '0'
               end
-              # Using the NewsController because it's a simple API.
-              context "get /news" do
-                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 0 -9

@@ -36,15 +36,6 class Redmine::ApiTest::HttpBasicLoginWithApiTokenTest < Redmine::ApiTest::Base
36	Setting.login_required = '0'	36	Setting.login_required = '0'
37	end	37	end
38		38
39	# Using the NewsController because it's a simple API.
40	context "get /news" do
41
42	context "in :xml format" do
43	should_allow_http_basic_auth_with_key(:get, "/news.xml")	39	should_allow_http_basic_auth_with_key(:get, "/news.xml")
44	end
45
46	context "in :json format" do
47	should_allow_http_basic_auth_with_key(:get, "/news.json")	40	should_allow_http_basic_auth_with_key(:get, "/news.json")
48	end	41	end
49	end
50	end

test/integration/api_test/issues_test.rb +123 -290

                 Setting.rest_api_enabled = '1'
               end
-              context "/issues" do
               # Use a private project to make sure auth is really working and not just
               # only showing public issues.
               should_allow_api_authentication(:get, "/projects/private-child/issues.xml")
+              should_allow_api_authentication(:get, "/projects/private-child/issues.json")
-                should "contain metadata" do
+              should_allow_api_authentication(:get, "/issues/6.xml")
-                  get '/issues.xml'
+              should_allow_api_authentication(:get, "/issues/6.json")
-                  assert_select 'issues[type=array][total_count=?][limit="25"][offset="0"]', assigns(:issue_count).to_s
+              should_allow_api_authentication(
-                end
+                :post,
+                '/issues.xml',
+                {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
+                {:success_code => :created}
+              )
+              should_allow_api_authentication(:post,
+                                              '/issues.json',
+                                              {:issue => {:project_id => 1, :subject => 'API test',
+                                               :tracker_id => 2, :status_id => 3}},
+                                              {:success_code => :created})
-                context "with offset and limit" do
+              should_allow_api_authentication(:put,
-                  should "use the params" do
+                                              '/issues/6.xml',
-                    get '/issues.xml?offset=2&limit=3'
+                                              {:issue => {:subject => 'API update', :notes => 'A new note'}},
+                                              {:success_code => :ok})
+              should_allow_api_authentication(:put,
+                                              '/issues/6.json',
+                                              {:issue => {:subject => 'API update', :notes => 'A new note'}},
+                                              {:success_code => :ok})
-                    assert_equal 3, assigns(:limit)
+              should_allow_api_authentication(:delete,
-                    assert_equal 2, assigns(:offset)
+                                              '/issues/6.xml',
-                    assert_select 'issues issue', 3
+                                              {},
-                  end
+                                              {:success_code => :ok})
+              should_allow_api_authentication(:delete,
+                                              '/issues/6.json',
+                                              {},
+                                              {:success_code => :ok})
+              test "GET /issues.xml should contain metadata" do
+                get '/issues.xml'
+                assert_select 'issues[type=array][total_count=?][limit="25"][offset="0"]',
+                  assigns(:issue_count).to_s
               end
-                context "with nometa param" do
+              test "GET /issues.xml with nometa param should not contain metadata" do
-                  should "not contain metadata" do
                 get '/issues.xml?nometa=1'
                 assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
               end
-                end
-                context "with nometa header" do
+              test "GET /issues.xml with nometa header should not contain metadata" do
-                  should "not contain metadata" do
                 get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
                 assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
               end
+              test "GET /issues.xml with offset and limit" do
+                get '/issues.xml?offset=2&limit=3'
+                assert_equal 3, assigns(:limit)
+                assert_equal 2, assigns(:offset)
+                assert_select 'issues issue', 3
               end
-                context "with relations" do
+              test "GET /issues.xml with relations" do
-                  should "display relations" do
                 get '/issues.xml?include=relations'
                 assert_response :success
                   assert_select '~ relations relation', 0
                 end
               end
-                end
-                context "with invalid query params" do
+              test "GET /issues.xml with invalid query params" do
-                  should "return errors" do
                 get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'errors error', :text => "Start date can't be blank"
               end
-                end
-                context "with custom field filter" do
+              test "GET /issues.xml with custom field filter" do
-                  should "show only issues with the custom field value" do
                 get '/issues.xml',
-                        {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='},
+                  {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='}, :v => {:cf_1 => ['MySQL']}}
-                         :v => {:cf_1 => ['MySQL']}}
                 expected_ids = Issue.visible.
                     joins(:custom_values).
                     where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
+                assert expected_ids.any?
                 assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                    ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                 end
               end
-                end
-                context "with custom field filter (shorthand method)" do
+              test "GET /issues.xml with custom field filter (shorthand method)" do
-                  should "show only issues with the custom field value" do
                 get '/issues.xml', {:cf_1 => 'MySQL'}
                 expected_ids = Issue.visible.
                     joins(:custom_values).
                     where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
+                assert expected_ids.any?
                 assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                   ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                 end
               end
-                end
-              end
               def test_index_should_include_issue_attributes
                 get '/issues.xml'
                 assert_select 'issues>issue', :count => 2
               end
-              context "/index.json" do
+              test "GET /issues.xml with filter" do
-                should_allow_api_authentication(:get, "/projects/private-child/issues.json")
-              end
-              context "/index.xml with filter" do
-                should "show only issues with the status_id" do
                 get '/issues.xml?status_id=5'
                 expected_ids = Issue.visible.where(:status_id => 5).map(&:id)
+                assert expected_ids.any?
                 assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                    ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                 end
               end
-              end
-              context "/index.json with filter" do
+              test "GET /issues.json with filter" do
-                should "show only issues with the status_id" do
                 get '/issues.json?status_id=5'
                 json = ActiveSupport::JSON.decode(response.body)
                 assert status_ids_used.all? {|id| id == 5 }
               end
-              end
+              test "GET /issues/:id.xml with journals" do
-              # Issue 6 is on a private project
-              context "/issues/6.xml" do
-                should_allow_api_authentication(:get, "/issues/6.xml")
-              end
-              context "/issues/6.json" do
-                should_allow_api_authentication(:get, "/issues/6.json")
-              end
-              context "GET /issues/:id" do
-                context "with journals" do
-                  context ".xml" do
-                    should "display journals" do
                 get '/issues/1.xml?include=journals'
                 assert_select 'issue journals[type=array]' do
                   end
                 end
               end
-                  end
-                end
-                context "with custom fields" do
+              test "GET /issues/:id.xml with custom fields" do
-                  context ".xml" do
-                    should "display custom fields" do
                 get '/issues/3.xml'
                 assert_select 'issue custom_fields[type=array]' do
                     assert_select 'value', :text => 'MySQL'
                   end
                 end
                 assert_nothing_raised do
                   Hash.from_xml(response.body).to_xml
                 end
               end
-                  end
-                end
-                context "with multi custom fields" do
+              test "GET /issues/:id.xml with multi custom fields" do
-                  setup do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(3)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
-                  end
-                  context ".xml" do
-                    should "display custom fields" do
                 get '/issues/3.xml'
                 assert_response :success
                     assert_select 'value[type=array] value', 2
                   end
                 end
                 xml = Hash.from_xml(response.body)
                 custom_fields = xml['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 assert_kind_of Hash, field
                 assert_equal ['MySQL', 'Oracle'], field['value'].sort
               end
-                  end
-                  context ".json" do
+              test "GET /issues/:id.json with multi custom fields" do
-                    should "display custom fields" do
+                field = CustomField.find(1)
+                field.update_attribute :multiple, true
+                issue = Issue.find(3)
+                issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
+                issue.save!
                 get '/issues/3.json'
                 assert_response :success
                 json = ActiveSupport::JSON.decode(response.body)
                 custom_fields = json['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 assert_kind_of Hash, field
                 assert_equal ['MySQL', 'Oracle'], field['value'].sort
               end
-                  end
-                end
-                context "with empty value for multi custom field" do
+              test "GET /issues/:id.xml with empty value for multi custom field" do
-                  setup do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(3)
                 issue.custom_field_values = {1 => ['']}
                 issue.save!
-                  end
-                  context ".xml" do
-                    should "display custom fields" do
                 get '/issues/3.xml'
                 assert_select 'issue custom_fields[type=array]' do
                     assert_select 'value[type=array]:empty'
                   end
                 end
                 xml = Hash.from_xml(response.body)
                 custom_fields = xml['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 assert_kind_of Hash, field
                 assert_equal [], field['value']
               end
-                  end
-                  context ".json" do
+              test "GET /issues/:id.json with empty value for multi custom field" do
-                    should "display custom fields" do
+                field = CustomField.find(1)
+                field.update_attribute :multiple, true
+                issue = Issue.find(3)
+                issue.custom_field_values = {1 => ['']}
+                issue.save!
                 get '/issues/3.json'
                 assert_response :success
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, field
                 assert_equal [], field['value'].sort
               end
-                  end
-                end
-                context "with attachments" do
+              test "GET /issues/:id.xml with attachments" do
-                  context ".xml" do
-                    should "display attachments" do
                 get '/issues/3.xml?include=attachments'
                 assert_select 'issue attachments[type=array]' do
                   end
                 end
               end
-                  end
-                end
-                context "with subtasks" do
+              test "GET /issues/:id.xml with subtasks" do
-                  setup do
+                issue = Issue.generate_with_descendants!(:project_id => 1)
-                    @c1 = Issue.create!(
+                get "/issues/#{issue.id}.xml?include=children"
-                            :status_id => 1, :subject => "child c1",
-                            :tracker_id => 1, :project_id => 1, :author_id => 1,
-                            :parent_issue_id => 1
-                    @c2 = Issue.create!(
-                            :status_id => 1, :subject => "child c2",
-                            :tracker_id => 1, :project_id => 1, :author_id => 1,
-                            :parent_issue_id => 1
-                    @c3 = Issue.create!(
-                            :status_id => 1, :subject => "child c3",
-                            :tracker_id => 1, :project_id => 1, :author_id => 1,
-                            :parent_issue_id => @c1.id
-                  end
-                  context ".xml" do
-                    should "display children" do
-                      get '/issues/1.xml?include=children'
                 assert_select 'issue children[type=array]' do
                   assert_select 'issue', 2
-                        assert_select 'issue[id=?]', @c1.id.to_s do
+                  assert_select 'issue children', 1
-                          assert_select 'subject', :text => 'child c1'
-                          assert_select 'children' do
-                            assert_select 'issue[id=?]', @c3.id.to_s
-                          end
-                        end
                 end
               end
-                    context ".json" do
+              test "GET /issues/:id.json with subtasks" do
-                      should "display children" do
+                issue = Issue.generate_with_descendants!(:project_id => 1)
-                        get '/issues/1.json?include=children'
+                get "/issues/#{issue.id}.json?include=children"
                 json = ActiveSupport::JSON.decode(response.body)
-                        assert_equal([
+                assert_equal 2, json['issue']['children'].size
+                assert_equal 1, json['issue']['children'].select {|child| child.key?('children')}.size
-                            'id' => @c1.id, 'subject' => 'child c1', 'tracker' => {'id' => 1, 'name' => 'Bug'},
-                            'children' => [{'id' => @c3.id, 'subject' => 'child c3',
-                                            'tracker' => {'id' => 1, 'name' => 'Bug'} }]
-                          },
-                          { 'id' => @c2.id, 'subject' => 'child c2', 'tracker' => {'id' => 1, 'name' => 'Bug'} }
-                          ],
-                          json['issue']['children'])
-                      end
-                    end
-                  end
-                end
               end
               def test_show_should_include_issue_attributes
                 end
               end
-              context "POST /issues.xml" do
+              test "POST /issues.xml should create an issue with the attributes" do
-                should_allow_api_authentication(
-                  :post,
-                  '/issues.xml',
-                  {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
-                  {:success_code => :created}
-                should "create an issue with the attributes" do
                 assert_difference('Issue.count') do
                   post '/issues.xml',
                        {:issue => {:project_id => 1, :subject => 'API test',
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'issue > id', :text => issue.id.to_s
               end
-              end
               test "POST /issues.xml with watcher_user_ids should create issue with watchers" do
                 assert_difference('Issue.count') do
                 assert_equal [1, 3], issue.watcher_user_ids.sort
               end
-              context "POST /issues.xml with failure" do
+              test "POST /issues.xml with failure should return errors" do
-                should "have an errors tag" do
                 assert_no_difference('Issue.count') do
                   post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
                 end
                 assert_select 'errors error', :text => "Subject can't be blank"
               end
-              end
-              context "POST /issues.json" do
-                should_allow_api_authentication(:post,
-                                                '/issues.json',
-                                                {:issue => {:project_id => 1, :subject => 'API test',
-                                                 :tracker_id => 2, :status_id => 3}},
-                                                {:success_code => :created})
-                should "create an issue with the attributes" do
+              test "POST /issues.json should create an issue with the attributes" do
                 assert_difference('Issue.count') do
                   post '/issues.json',
                        {:issue => {:project_id => 1, :subject => 'API test',
                 assert_equal 'API test', issue.subject
               end
-              end
+              test "POST /issues.json with failure should return errors" do
-              context "POST /issues.json with failure" do
-                should "have an errors element" do
                 assert_no_difference('Issue.count') do
                   post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')
                 end
                 json = ActiveSupport::JSON.decode(response.body)
                 assert json['errors'].include?("Subject can't be blank")
               end
-              end
-              # Issue 6 is on a private project
-              context "PUT /issues/6.xml" do
-                setup do
-                  @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
-                end
-                should_allow_api_authentication(:put,
-                                                '/issues/6.xml',
-                                                {:issue => {:subject => 'API update', :notes => 'A new note'}},
-                                                {:success_code => :ok})
-                should "not create a new issue" do
-                  assert_no_difference('Issue.count') do
-                    put '/issues/6.xml', @parameters, credentials('jsmith')
-                  end
-                end
-                should "create a new journal" do
+              test "PUT /issues/:id.xml" do
                 assert_difference('Journal.count') do
-                    put '/issues/6.xml', @parameters, credentials('jsmith')
+                  put '/issues/6.xml',
-                  end
+                    {:issue => {:subject => 'API update', :notes => 'A new note'}},
-                end
+                    credentials('jsmith')
-                should "add the note to the journal" do
-                  put '/issues/6.xml', @parameters, credentials('jsmith')
-                  journal = Journal.last
-                  assert_equal "A new note", journal.notes
                 end
-                should "update the issue" do
-                  put '/issues/6.xml', @parameters, credentials('jsmith')
                 issue = Issue.find(6)
                 assert_equal "API update", issue.subject
+                journal = Journal.last
+                assert_equal "A new note", journal.notes
               end
-              end
+              test "PUT /issues/:id.xml with custom fields" do
+                put '/issues/3.xml',
-              context "PUT /issues/3.xml with custom fields" do
+                  {:issue => {:custom_fields => [
-                setup do
+                    {'id' => '1', 'value' => 'PostgreSQL' },
-                  @parameters = {
+                    {'id' => '2', 'value' => '150'}
-                    :issue => {:custom_fields => [{'id' => '1', 'value' => 'PostgreSQL' },
+                    ]}},
-                    {'id' => '2', 'value' => '150'}]}
+                  credentials('jsmith')
-                end
-                should "update custom fields" do
-                  assert_no_difference('Issue.count') do
-                    put '/issues/3.xml', @parameters, credentials('jsmith')
-                  end
                 issue = Issue.find(3)
                 assert_equal '150', issue.custom_value_for(2).value
                 assert_equal 'PostgreSQL', issue.custom_value_for(1).value
               end
-              end
-              context "PUT /issues/3.xml with multi custom fields" do
+              test "PUT /issues/:id.xml with multi custom fields" do
-                setup do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
-                  @parameters = {
-                    :issue => {:custom_fields => [{'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
-                    {'id' => '2', 'value' => '150'}]}
-                end
-                should "update custom fields" do
+                put '/issues/3.xml',
-                  assert_no_difference('Issue.count') do
+                  {:issue => {:custom_fields => [
-                    put '/issues/3.xml', @parameters, credentials('jsmith')
+                    {'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
-                  end
+                    {'id' => '2', 'value' => '150'}
+                    ]}},
+                  credentials('jsmith')
                 issue = Issue.find(3)
                 assert_equal '150', issue.custom_value_for(2).value
                 assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
               end
-              end
-              context "PUT /issues/3.xml with project change" do
+              test "PUT /issues/:id.xml with project change" do
-                setup do
+                put '/issues/3.xml',
-                  @parameters = {:issue => {:project_id => 2, :subject => 'Project changed'}}
+                  {:issue => {:project_id => 2, :subject => 'Project changed'}},
-                end
+                  credentials('jsmith')
-                should "update project" do
-                  assert_no_difference('Issue.count') do
-                    put '/issues/3.xml', @parameters, credentials('jsmith')
-                  end
                 issue = Issue.find(3)
                 assert_equal 2, issue.project_id
                 assert_equal 'Project changed', issue.subject
               end
-              end
-              context "PUT /issues/6.xml with failed update" do
-                setup do
-                  @parameters = {:issue => {:subject => ''}}
-                end
-                should "not create a new issue" do
-                  assert_no_difference('Issue.count') do
-                    put '/issues/6.xml', @parameters, credentials('jsmith')
-                  end
-                end
-                should "not create a new journal" do
+              test "PUT /issues/:id.xml with failed update" do
-                  assert_no_difference('Journal.count') do
+                put '/issues/6.xml', {:issue => {:subject => ''}}, credentials('jsmith')
-                    put '/issues/6.xml', @parameters, credentials('jsmith')
-                  end
-                end
-                should "have an errors tag" do
-                  put '/issues/6.xml', @parameters, credentials('jsmith')
+                assert_response :unprocessable_entity
                 assert_select 'errors error', :text => "Subject can't be blank"
               end
-              end
-              context "PUT /issues/6.json" do
-                setup do
-                  @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
-                end
-                should_allow_api_authentication(:put,
-                                                '/issues/6.json',
-                                                {:issue => {:subject => 'API update', :notes => 'A new note'}},
-                                                {:success_code => :ok})
-                should "update the issue" do
+              test "PUT /issues/:id.json" do
-                  assert_no_difference('Issue.count') do
                 assert_difference('Journal.count') do
-                      put '/issues/6.json', @parameters, credentials('jsmith')
+                  put '/issues/6.json',
+                    {:issue => {:subject => 'API update', :notes => 'A new note'}},
+                    credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
-                  end
                 issue = Issue.find(6)
                 assert_equal "API update", issue.subject
                 journal = Journal.last
                 assert_equal "A new note", journal.notes
               end
-              end
-              context "PUT /issues/6.json with failed update" do
+              test "PUT /issues/:id.json with failed update" do
-                should "return errors" do
-                  assert_no_difference('Issue.count') do
-                    assert_no_difference('Journal.count') do
                 put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')
                 assert_response :unprocessable_entity
-                    end
-                  end
                 json = ActiveSupport::JSON.decode(response.body)
                 assert json['errors'].include?("Subject can't be blank")
               end
-              end
-              context "DELETE /issues/1.xml" do
-                should_allow_api_authentication(:delete,
-                                                '/issues/6.xml',
-                                                {},
-                                                {:success_code => :ok})
-                should "delete the issue" do
+              test "DELETE /issues/:id.xml" do
                 assert_difference('Issue.count', -1) do
                   delete '/issues/6.xml', {}, credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 assert_nil Issue.find_by_id(6)
               end
-              end
-              context "DELETE /issues/1.json" do
+              test "DELETE /issues/:id.json" do
-                should_allow_api_authentication(:delete,
-                                                '/issues/6.json',
-                                                {},
-                                                {:success_code => :ok})
-                should "delete the issue" do
                 assert_difference('Issue.count', -1) do
                   delete '/issues/6.json', {}, credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 assert_nil Issue.find_by_id(6)
               end
-              end
               test "POST /issues/:id/watchers.xml should add watcher" do
                 assert_difference 'Watcher.count' do

test/unit/user_test.rb +28 -63

@@ -601,98 +601,63 class UserTest < ActiveSupport::TestCase
601	end	601	end
602		602
603	if ldap_configured?	603	if ldap_configured?
604	~~contex~~t "#try_to_login using LDAP" do	604	test "#try_to_login using LDAP with failed connection to the LDAP server" do
605	context "with failed connection to the LDAP server" do	605	auth_source = AuthSourceLdap.find(1)
606	should "return nil" do
607	@auth_source = AuthSourceLdap.find(1)
608	AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')	606	AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
609		607
610	assert_equal nil, User.try_to_login('edavis', 'wrong')	608	assert_equal nil, User.try_to_login('edavis', 'wrong')
611	end	609	end
612	end
613		610
614	context "with an unsuccessful authentication" do	611	test "#try_to_login using LDAP" do
615	should "return nil" do
616	assert_equal nil, User.try_to_login('edavis', 'wrong')	612	assert_equal nil, User.try_to_login('edavis', 'wrong')
617	end	613	end
618	end
619		614
620	~~contex~~t "binding with user's account" do	615	test "#try_to_login using LDAP binding with user's account" do
621	setup do	616	auth_source = AuthSourceLdap.find(1)
622	@auth_source = AuthSourceLdap.find(1)	617	auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
623	@auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"	618	auth_source.account_password = ''
624	@auth_source.account_password = ''	619	auth_source.save!
625	@auth_source.save!
626		620
627	@ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)	621	ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
628	@ldap_user.login = 'example1'	622	ldap_user.login = 'example1'
629	@ldap_user.save!	623	ldap_user.save!
630	end
631		624
632	context "with a successful authentication" do
633	should "return the user" do
634	assert_equal @ldap_user, User.try_to_login('example1', '123456')	625	assert_equal @ldap_user, User.try_to_login('example1', '123456')
635	end
636	end
637
638	context "with an unsuccessful authentication" do
639	should "return nil" do
640	assert_nil User.try_to_login('example1', '11111')	626	assert_nil User.try_to_login('example1', '11111')
641	end	627	end
642	end
643	end
644		628
645	~~contex~~t "on the fly registration" do	629	test "#try_to_login using LDAP on the fly registration" do
646	setup do	630	AuthSourceLdap.find(1).update_attribute :onthefly_register, true
647	@auth_source = AuthSourceLdap.find(1)
648	@auth_source.update_attribute :onthefly_register, true
649	end
650		631
651	context "with a successful authentication" do
652	should "create a new user account if it doesn't exist" do
653	assert_difference('User.count') do	632	assert_difference('User.count') do
654	~~user~~ = User.try_to_login('edavis', '123456')	633	assert User.try_to_login('edavis', '123456')
655	assert !user.admin?
656	end	634	end
657	end
658
659	should "retrieve existing user" do
660	user = User.try_to_login('edavis', '123456')
661	user.admin = true
662	user.save!
663		635
664	assert_no_difference('User.count') do	636	assert_no_difference('User.count') do
665	~~user~~ = User.try_to_login('edavis', '123456')	637	assert User.try_to_login('edavis', '123456')
666	assert user.admin?
667	end
668	end
669	end	638	end
670		639
671	context "binding with user's account" do	640	assert_nil User.try_to_login('example1', '11111')
672	setup do
673	@auth_source = AuthSourceLdap.find(1)
674	@auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
675	@auth_source.account_password = ''
676	@auth_source.save!
677	end	641	end
678		642
679	context "with a successful authentication" do	643	test "#try_to_login using LDAP on the fly registration and binding with user's account" do
680	should "create a new user account if it doesn't exist" do	644	auth_source = AuthSourceLdap.find(1)
		645	auth_source.update_attribute :onthefly_register, true
		646	auth_source = AuthSourceLdap.find(1)
		647	auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
		648	auth_source.account_password = ''
		649	auth_source.save!
		650
681	assert_difference('User.count') do	651	assert_difference('User.count') do
682	~~user~~ = User.try_to_login('example1', '123456')	652	assert User.try_to_login('example1', '123456')
683	assert_kind_of User, user
684	end
685	end	653	end
		654
		655	assert_no_difference('User.count') do
		656	assert User.try_to_login('edavis', '123456')
686	end	657	end
687		658
688	context "with an unsuccessful authentication" do
689	should "return nil" do
690	assert_nil User.try_to_login('example1', '11111')	659	assert_nil User.try_to_login('example1', '11111')
691	end	660	end
692	end
693	end
694	end
695	end
696		661
697	else	662	else
698	puts "Skipping LDAP tests."	663	puts "Skipping LDAP tests."

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