jro_apps/redmine Commit - r8357:131f258f5fba

Test cleanup....

Jean-Philippe Lang -

r8357:131f258f5fba

parent child

Context file:

r8357:131f258f5fba

Collapse all files

test/integration/api_test/attachments_test.rb +2 -3

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::AttachmentsTest < ActionController::IntegrationTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :attachments
               def setup
                 Setting.rest_api_enabled = '1'
                 set_fixtures_attachments_directory
               end
               def teardown
                 set_tmp_attachments_directory
               end
               context "/attachments/:id" do
                 context "GET" do
                   should "return the attachment" do
-                    get '/attachments/7.xml', {}, :authorization => credentials('jsmith')
+                    get '/attachments/7.xml', {}, credentials('jsmith')
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag :tag => 'attachment',
                       :child => {
                         :tag => 'id',
                         :content => '7',
                         :sibling => {
                           :tag => 'filename',
                           :content => 'archive.zip',
                           :sibling => {
                             :tag => 'content_url',
                             :content => 'http://www.example.com/attachments/download/7/archive.zip'
                           }
                         }
                       }
                   end
                   should "deny access without credentials" do
                     get '/attachments/7.xml'
                     assert_response 401
                     set_tmp_attachments_directory
                   end
                 end
               end
               context "/attachments/download/:id/:filename" do
                 context "GET" do
                   should "return the attachment content" do
-                    get '/attachments/download/7/archive.zip',
+                    get '/attachments/download/7/archive.zip', {}, credentials('jsmith')
-                        {}, :authorization => credentials('jsmith')
                     assert_response :success
                     assert_equal 'application/octet-stream', @response.content_type
                     set_tmp_attachments_directory
                   end
                   should "deny access without credentials" do
                     get '/attachments/download/7/archive.zip'
                     assert_response 302
                     set_tmp_attachments_directory
                   end
                 end
               end
             end

test/integration/api_test/disabled_rest_api_test.rb +4 -4

             require File.expand_path('../../../test_helper', __FILE__)
             class ApiTest::DisabledRestApiTest < ActionController::IntegrationTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows
               def setup
                 Setting.rest_api_enabled = '0'
                 Setting.login_required = '1'
               end
               def teardown
                 Setting.rest_api_enabled = '1'
                 Setting.login_required = '0'
               end
               # Using the NewsController because it's a simple API.
               context "get /news with the API disabled" do
                 context "in :xml format" do
                   context "with a valid api token" do
                     setup do
                       @user = User.generate_with_protected!
                       @token = Token.generate!(:user => @user, :action => 'api')
                       get "/news.xml?key=#{@token.value}"
                     end
                     should_respond_with :unauthorized
                     should_respond_with_content_type :xml
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                   context "with a valid HTTP authentication" do
                     setup do
                       @user = User.generate_with_protected!(:password => 'my_password', :password_confirmation => 'my_password')
-                      get "/news.xml", nil, :authorization => credentials(@user.login, 'my_password')
+                      get "/news.xml", nil, credentials(@user.login, 'my_password')
                     end
                     should_respond_with :unauthorized
                     should_respond_with_content_type :xml
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                   context "with a valid HTTP authentication using the API token" do
                     setup do
                       @user = User.generate_with_protected!
                       @token = Token.generate!(:user => @user, :action => 'api')
-                      get "/news.xml", nil, :authorization => credentials(@token.value, 'X')
+                      get "/news.xml", nil, credentials(@token.value, 'X')
                     end
                     should_respond_with :unauthorized
                     should_respond_with_content_type :xml
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                 end
                 context "in :json format" do
                   context "with a valid api token" do
                     setup do
                       @user = User.generate_with_protected!
                       @token = Token.generate!(:user => @user, :action => 'api')
                       get "/news.json?key=#{@token.value}"
                     end
                     should_respond_with :unauthorized
                     should_respond_with_content_type :json
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                   context "with a valid HTTP authentication" do
                     setup do
                       @user = User.generate_with_protected!(:password => 'my_password', :password_confirmation => 'my_password')
-                      get "/news.json", nil, :authorization => credentials(@user.login, 'my_password')
+                      get "/news.json", nil, credentials(@user.login, 'my_password')
                     end
                     should_respond_with :unauthorized
                     should_respond_with_content_type :json
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                   context "with a valid HTTP authentication using the API token" do
                     setup do
                       @user = User.generate_with_protected!
                       @token = Token.generate!(:user => @user, :action => 'api')
-                      get "/news.json", nil, :authorization => credentials(@token.value, 'DoesNotMatter')
+                      get "/news.json", nil, credentials(@token.value, 'DoesNotMatter')
                     end
                     should_respond_with :unauthorized
                     should_respond_with_content_type :json
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                 end
               end
             end

test/integration/api_test/issue_categories_test.rb +8 -8

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::IssueCategoriesTest < ActionController::IntegrationTest
               fixtures :projects, :users, :issue_categories, :issues,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules
               def setup
                 Setting.rest_api_enabled = '1'
               end
               context "GET /projects/:project_id/issue_categories.xml" do
                 should "return issue categories" do
-                  get '/projects/1/issue_categories.xml', {}, :authorization => credentials('jsmith')
+                  get '/projects/1/issue_categories.xml', {}, credentials('jsmith')
                   assert_response :success
                   assert_equal 'application/xml', @response.content_type
                   assert_tag :tag => 'issue_categories',
                     :child => {:tag => 'issue_category', :child => {:tag => 'id', :content => '2'}}
                 end
               end
               context "GET /issue_categories/2.xml" do
                 should "return requested issue category" do
-                  get '/issue_categories/2.xml', {}, :authorization => credentials('jsmith')
+                  get '/issue_categories/2.xml', {}, credentials('jsmith')
                   assert_response :success
                   assert_equal 'application/xml', @response.content_type
                   assert_tag :tag => 'issue_category',
                     :child => {:tag => 'id', :content => '2'}
                 end
               end
               context "POST /projects/:project_id/issue_categories.xml" do
                 should "return create issue category" do
                   assert_difference 'IssueCategory.count' do
-                    post '/projects/1/issue_categories.xml', {:issue_category => {:name => 'API'}}, :authorization => credentials('jsmith')
+                    post '/projects/1/issue_categories.xml', {:issue_category => {:name => 'API'}}, credentials('jsmith')
                   end
                   assert_response :created
                   assert_equal 'application/xml', @response.content_type
                   category = IssueCategory.first(:order => 'id DESC')
                   assert_equal 'API', category.name
                   assert_equal 1, category.project_id
                 end
                 context "with invalid parameters" do
                   should "return errors" do
                     assert_no_difference 'IssueCategory.count' do
-                      post '/projects/1/issue_categories.xml', {:issue_category => {:name => ''}}, :authorization => credentials('jsmith')
+                      post '/projects/1/issue_categories.xml', {:issue_category => {:name => ''}}, credentials('jsmith')
                     end
                     assert_response :unprocessable_entity
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'errors', :child => {:tag => 'error', :content => "Name can't be blank"}
                   end
                 end
               end
               context "PUT /issue_categories/2.xml" do
                 context "with valid parameters" do
                   should "update issue category" do
                     assert_no_difference 'IssueCategory.count' do
-                      put '/issue_categories/2.xml', {:issue_category => {:name => 'API Update'}}, :authorization => credentials('jsmith')
+                      put '/issue_categories/2.xml', {:issue_category => {:name => 'API Update'}}, credentials('jsmith')
                     end
                     assert_response :ok
                     assert_equal 'API Update', IssueCategory.find(2).name
                   end
                 end
                 context "with invalid parameters" do
                   should "return errors" do
                     assert_no_difference 'IssueCategory.count' do
-                      put '/issue_categories/2.xml', {:issue_category => {:name => ''}}, :authorization => credentials('jsmith')
+                      put '/issue_categories/2.xml', {:issue_category => {:name => ''}}, credentials('jsmith')
                     end
                     assert_response :unprocessable_entity
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'errors', :child => {:tag => 'error', :content => "Name can't be blank"}
                   end
                 end
               end
               context "DELETE /issue_categories/1.xml" do
                 should "destroy issue categories" do
                   assert_difference 'IssueCategory.count', -1 do
-                    delete '/issue_categories/1.xml', {}, :authorization => credentials('jsmith')
+                    delete '/issue_categories/1.xml', {}, credentials('jsmith')
                   end
                   assert_response :ok
                   assert_nil IssueCategory.find_by_id(1)
                 end
                 should "reassign issues with :reassign_to_id param" do
                   issue_count = Issue.count(:conditions => {:category_id => 1})
                   assert issue_count > 0
                   assert_difference 'IssueCategory.count', -1 do
                     assert_difference 'Issue.count(:conditions => {:category_id => 2})', 3 do
-                      delete '/issue_categories/1.xml', {:reassign_to_id => 2}, :authorization => credentials('jsmith')
+                      delete '/issue_categories/1.xml', {:reassign_to_id => 2}, credentials('jsmith')
                     end
                   end
                   assert_response :ok
                   assert_nil IssueCategory.find_by_id(1)
                 end
               end
             end

test/integration/api_test/issue_relations_test.rb +5 -5

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::IssueRelationsTest < ActionController::IntegrationTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :issue_relations
               def setup
                 Setting.rest_api_enabled = '1'
               end
               context "/issues/:issue_id/relations" do
                 context "GET" do
                   should "return issue relations" do
-                    get '/issues/9/relations.xml', {}, :authorization => credentials('jsmith')
+                    get '/issues/9/relations.xml', {}, credentials('jsmith')
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag :tag => 'relations',
                       :attributes => { :type => 'array' },
                       :child => {
                         :tag => 'relation',
                         :child => {
                           :tag => 'id',
                           :content => '1'
                         }
                       }
                   end
                 end
                 context "POST" do
                   should "create a relation" do
                     assert_difference('IssueRelation.count') do
-                      post '/issues/2/relations.xml', {:relation => {:issue_to_id => 7, :relation_type => 'relates'}}, :authorization => credentials('jsmith')
+                      post '/issues/2/relations.xml', {:relation => {:issue_to_id => 7, :relation_type => 'relates'}}, credentials('jsmith')
                     end
                     relation = IssueRelation.first(:order => 'id DESC')
                     assert_equal 2, relation.issue_from_id
                     assert_equal 7, relation.issue_to_id
                     assert_equal 'relates', relation.relation_type
                     assert_response :created
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'relation', :child => {:tag => 'id', :content => relation.id.to_s}
                   end
                   context "with failure" do
                     should "return the errors" do
                       assert_no_difference('IssueRelation.count') do
-                        post '/issues/2/relations.xml', {:relation => {:issue_to_id => 7, :relation_type => 'foo'}}, :authorization => credentials('jsmith')
+                        post '/issues/2/relations.xml', {:relation => {:issue_to_id => 7, :relation_type => 'foo'}}, credentials('jsmith')
                       end
                       assert_response :unprocessable_entity
                       assert_tag :errors, :child => {:tag => 'error', :content => 'relation_type is not included in the list'}
                     end
                   end
                 end
               end
               context "/relations/:id" do
                 context "GET" do
                   should "return the relation" do
-                    get '/relations/2.xml', {}, :authorization => credentials('jsmith')
+                    get '/relations/2.xml', {}, credentials('jsmith')
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'relation', :child => {:tag => 'id', :content => '2'}
                   end
                 end
                 context "DELETE" do
                   should "delete the relation" do
                     assert_difference('IssueRelation.count', -1) do
-                      delete '/relations/2.xml', {}, :authorization => credentials('jsmith')
+                      delete '/relations/2.xml', {}, credentials('jsmith')
                     end
                     assert_response :ok
                     assert_nil IssueRelation.find_by_id(2)
                   end
                 end
               end
             end

test/integration/api_test/issues_test.rb +21 -26

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::IssuesTest < ActionController::IntegrationTest
               fixtures :projects,
                 :users,
                 :roles,
                 :members,
                 :member_roles,
                 :issues,
                 :issue_statuses,
                 :versions,
                 :trackers,
                 :projects_trackers,
                 :issue_categories,
                 :enabled_modules,
                 :enumerations,
                 :attachments,
                 :workflows,
                 :custom_fields,
                 :custom_values,
                 :custom_fields_projects,
                 :custom_fields_trackers,
                 :time_entries,
                 :journals,
                 :journal_details,
                 :queries,
                 :attachments
               def setup
                 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 "contain metadata" do
                   get '/issues.xml'
                   assert_tag :tag => 'issues',
                     :attributes => {
                       :type => 'array',
                       :total_count => assigns(:issue_count),
                       :limit => 25,
                       :offset => 0
                     }
                 end
                 context "with offset and limit" do
                   should "use the params" do
                     get '/issues.xml?offset=2&limit=3'
                     assert_equal 3, assigns(:limit)
                     assert_equal 2, assigns(:offset)
                     assert_tag :tag => 'issues', :children => {:count => 3, :only => {:tag => 'issue'}}
                   end
                 end
                 context "with nometa param" do
                   should "not contain metadata" do
                     get '/issues.xml?nometa=1'
                     assert_tag :tag => 'issues',
                       :attributes => {
                         :type => 'array',
                         :total_count => nil,
                         :limit => nil,
                         :offset => nil
                       }
                   end
                 end
                 context "with nometa header" do
                   should "not contain metadata" do
                     get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
                     assert_tag :tag => 'issues',
                       :attributes => {
                         :type => 'array',
                         :total_count => nil,
                         :limit => nil,
                         :offset => nil
                       }
                   end
                 end
                 context "with relations" do
                   should "display relations" do
                     get '/issues.xml?include=relations'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'relations',
                       :parent => {:tag => 'issue', :child => {:tag => 'id', :content => '3'}},
                       :children => {:count => 1},
                       :child => {
                         :tag => 'relation',
                         :attributes => {:id => '2', :issue_id => '2', :issue_to_id => '3', :relation_type => 'relates'}
                       }
                     assert_tag 'relations',
                       :parent => {:tag => 'issue', :child => {:tag => 'id', :content => '1'}},
                       :children => {:count => 0}
                   end
                 end
                 context "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_tag 'errors', :child => {:tag => 'error', :content => "Start date can't be blank"}
                   end
                 end
                 context "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 => '='}, :v => {:cf_1 => ['MySQL']}}
                     expected_ids = Issue.visible.all(
                         :include => :custom_values,
                         :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)
                     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
                   should "show only issues with the custom field value" do
                     get '/issues.xml', { :cf_1 => 'MySQL' }
                     expected_ids = Issue.visible.all(
                         :include => :custom_values,
                         :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)
                     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
               context "/index.json" 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.all(:conditions => {:status_id => 5}).map(&:id)
                   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
                 should "show only issues with the status_id" do
                   get '/issues.json?status_id=5'
                   json = ActiveSupport::JSON.decode(response.body)
                   status_ids_used = json['issues'].collect {|j| j['status']['id'] }
                   assert_equal 3, status_ids_used.length
                   assert status_ids_used.all? {|id| id == 5 }
                 end
               end
               # 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_tag :tag => 'issue',
                         :child => {
                           :tag => 'journals',
                           :attributes => { :type => 'array' },
                           :child => {
                             :tag => 'journal',
                             :attributes => { :id => '1'},
                             :child => {
                               :tag => 'details',
                               :attributes => { :type => 'array' },
                               :child => {
                                 :tag => 'detail',
                                 :attributes => { :name => 'status_id' },
                                 :child => {
                                   :tag => 'old_value',
                                   :content => '1',
                                   :sibling => {
                                     :tag => 'new_value',
                                     :content => '2'
                                   }
                                 }
                               }
                             }
                           }
                         }
                     end
                   end
                 end
                 context "with custom fields" do
                   context ".xml" do
                     should "display custom fields" do
                       get '/issues/3.xml'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'custom_fields',
                           :attributes => { :type => 'array' },
                           :child => {
                             :tag => 'custom_field',
                             :attributes => { :id => '1'},
                             :child => {
                               :tag => 'value',
                               :content => 'MySQL'
                             }
                           }
                         }
                       assert_nothing_raised do
                         Hash.from_xml(response.body).to_xml
                       end
                     end
                   end
                 end
                 context "with attachments" do
                   context ".xml" do
                     should "display attachments" do
                       get '/issues/3.xml?include=attachments'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'attachments',
                           :children => {:count => 5},
                           :child => {
                             :tag => 'attachment',
                             :child => {
                               :tag => 'filename',
                               :content => 'source.rb',
                               :sibling => {
                                 :tag => 'content_url',
                                 :content => 'http://www.example.com/attachments/download/4/source.rb'
                               }
                             }
                           }
                         }
                     end
                   end
                 end
                 context "with subtasks" do
                   setup do
                     @c1 = Issue.generate!(:status_id => 1, :subject => "child c1", :tracker_id => 1, :project_id => 1, :parent_issue_id => 1)
                     @c2 = Issue.generate!(:status_id => 1, :subject => "child c2", :tracker_id => 1, :project_id => 1, :parent_issue_id => 1)
                     @c3 = Issue.generate!(:status_id => 1, :subject => "child c3", :tracker_id => 1, :project_id => 1, :parent_issue_id => @c1.id)
                   end
                   context ".xml" do
                     should "display children" do
                       get '/issues/1.xml?include=children'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'children',
                           :children => {:count => 2},
                           :child => {
                             :tag => 'issue',
                             :attributes => {:id => @c1.id.to_s},
                             :child => {
                               :tag => 'subject',
                               :content => 'child c1',
                               :sibling => {
                                 :tag => 'children',
                                 :children => {:count => 1},
                                 :child => {
                                   :tag => 'issue',
                                   :attributes => {:id => @c3.id.to_s}
                                 }
                               }
                             }
                           }
                         }
                     end
                     context ".json" do
                       should "display children" do
                         get '/issues/1.json?include=children'
                         json = ActiveSupport::JSON.decode(response.body)
                         assert_equal([
                           {
                             '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
               context "POST /issues.xml" 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', :tracker_id => 2, :status_id => 3}}, :authorization => credentials('jsmith')
+                    post '/issues.xml', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, credentials('jsmith')
                   end
                   issue = Issue.first(:order => 'id DESC')
                   assert_equal 1, issue.project_id
                   assert_equal 2, issue.tracker_id
                   assert_equal 3, issue.status_id
                   assert_equal 'API test', issue.subject
                   assert_response :created
                   assert_equal 'application/xml', @response.content_type
                   assert_tag 'issue', :child => {:tag => 'id', :content => issue.id.to_s}
                 end
               end
               context "POST /issues.xml with failure" do
                 should "have an errors tag" do
                   assert_no_difference('Issue.count') do
-                    post '/issues.xml', {:issue => {:project_id => 1}}, :authorization => credentials('jsmith')
+                    post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
                   end
                   assert_tag :errors, :child => {:tag => 'error', :content => "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
                   assert_difference('Issue.count') do
-                    post '/issues.json', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, :authorization => credentials('jsmith')
+                    post '/issues.json', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, credentials('jsmith')
                   end
                   issue = Issue.first(:order => 'id DESC')
                   assert_equal 1, issue.project_id
                   assert_equal 2, issue.tracker_id
                   assert_equal 3, issue.status_id
                   assert_equal 'API test', issue.subject
                 end
               end
               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}}, :authorization => credentials('jsmith')
+                    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'}}
-                  @headers = { :authorization => credentials('jsmith') }
                 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, @headers
+                    put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "create a new journal" do
                   assert_difference('Journal.count') do
-                    put '/issues/6.xml', @parameters, @headers
+                    put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "add the note to the journal" do
-                  put '/issues/6.xml', @parameters, @headers
+                  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, @headers
+                  put '/issues/6.xml', @parameters, credentials('jsmith')
                   issue = Issue.find(6)
                   assert_equal "API update", issue.subject
                 end
               end
               context "PUT /issues/3.xml with custom fields" do
                 setup do
                   @parameters = {:issue => {:custom_fields => [{'id' => '1', 'value' => 'PostgreSQL' }, {'id' => '2', 'value' => '150'}]}}
-                  @headers = { :authorization => credentials('jsmith') }
                 end
                 should "update custom fields" do
                   assert_no_difference('Issue.count') do
-                    put '/issues/3.xml', @parameters, @headers
+                    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/6.xml with failed update" do
                 setup do
                   @parameters = {:issue => {:subject => ''}}
-                  @headers = { :authorization => credentials('jsmith') }
                 end
                 should "not create a new issue" do
                   assert_no_difference('Issue.count') do
-                    put '/issues/6.xml', @parameters, @headers
+                    put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "not create a new journal" do
                   assert_no_difference('Journal.count') do
-                    put '/issues/6.xml', @parameters, @headers
+                    put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "have an errors tag" do
-                  put '/issues/6.xml', @parameters, @headers
+                  put '/issues/6.xml', @parameters, credentials('jsmith')
                   assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
                 end
               end
               context "PUT /issues/6.json" do
                 setup do
                   @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
-                  @headers = { :authorization => credentials('jsmith') }
                 end
                 should_allow_api_authentication(:put,
                                                 '/issues/6.json',
                                                 {: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.json', @parameters, @headers
+                    put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "create a new journal" do
                   assert_difference('Journal.count') do
-                    put '/issues/6.json', @parameters, @headers
+                    put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "add the note to the journal" do
-                  put '/issues/6.json', @parameters, @headers
+                  put '/issues/6.json', @parameters, credentials('jsmith')
                   journal = Journal.last
                   assert_equal "A new note", journal.notes
                 end
                 should "update the issue" do
-                  put '/issues/6.json', @parameters, @headers
+                  put '/issues/6.json', @parameters, credentials('jsmith')
                   issue = Issue.find(6)
                   assert_equal "API update", issue.subject
                 end
               end
               context "PUT /issues/6.json with failed update" do
                 setup do
                   @parameters = {:issue => {:subject => ''}}
-                  @headers = { :authorization => credentials('jsmith') }
                 end
                 should "not create a new issue" do
                   assert_no_difference('Issue.count') do
-                    put '/issues/6.json', @parameters, @headers
+                    put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "not create a new journal" do
                   assert_no_difference('Journal.count') do
-                    put '/issues/6.json', @parameters, @headers
+                    put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "have an errors attribute" do
-                  put '/issues/6.json', @parameters, @headers
+                  put '/issues/6.json', @parameters, credentials('jsmith')
                   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
                   assert_difference('Issue.count',-1) do
-                    delete '/issues/6.xml', {}, :authorization => credentials('jsmith')
+                    delete '/issues/6.xml', {}, credentials('jsmith')
                   end
                   assert_nil Issue.find_by_id(6)
                 end
               end
               context "DELETE /issues/1.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', {}, :authorization => credentials('jsmith')
+                    delete '/issues/6.json', {}, credentials('jsmith')
                   end
                   assert_nil Issue.find_by_id(6)
                 end
               end
             end

test/integration/api_test/projects_test.rb +9 -9

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::ProjectsTest < ActionController::IntegrationTest
               fixtures :projects, :versions, :users, :roles, :members, :member_roles, :issues, :journals, :journal_details,
                        :trackers, :projects_trackers, :issue_statuses, :enabled_modules, :enumerations, :boards, :messages,
                        :attachments, :custom_fields, :custom_values, :time_entries, :issue_categories
               def setup
                 Setting.rest_api_enabled = '1'
                 set_tmp_attachments_directory
               end
               context "GET /projects" do
                 context ".xml" do
                   should "return projects" do
                     get '/projects.xml'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag :tag => 'projects',
                       :child => {:tag => 'project', :child => {:tag => 'id', :content => '1'}}
                   end
                 end
                 context ".json" do
                   should "return projects" do
                     get '/projects.json'
                     assert_response :success
                     assert_equal 'application/json', @response.content_type
                     json = ActiveSupport::JSON.decode(response.body)
                     assert_kind_of Hash, json
                     assert_kind_of Array, json['projects']
                     assert_kind_of Hash, json['projects'].first
                     assert json['projects'].first.has_key?('id')
                   end
                 end
               end
               context "GET /projects/:id" do
                 context ".xml" do
                   # TODO: A private project is needed because should_allow_api_authentication
                   # actually tests that authentication is *required*, not just allowed
                   should_allow_api_authentication(:get, "/projects/2.xml")
                   should "return requested project" do
                     get '/projects/1.xml'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag :tag => 'project',
                       :child => {:tag => 'id', :content => '1'}
                     assert_tag :tag => 'custom_field',
                       :attributes => {:name => 'Development status'}, :content => 'Stable'
                     assert_no_tag 'trackers'
                     assert_no_tag 'issue_categories'
                   end
                   context "with hidden custom fields" do
                     setup do
                       ProjectCustomField.find_by_name('Development status').update_attribute :visible, false
                     end
                     should "not display hidden custom fields" do
                       get '/projects/1.xml'
                       assert_response :success
                       assert_equal 'application/xml', @response.content_type
                       assert_no_tag 'custom_field',
                         :attributes => {:name => 'Development status'}
                     end
                   end
                   should "return categories with include=issue_categories" do
                     get '/projects/1.xml?include=issue_categories'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'issue_categories',
                       :attributes => {:type => 'array'},
                       :child => {
                         :tag => 'issue_category',
                         :attributes => {
                           :id => '2',
                           :name => 'Recipes'
                         }
                       }
                   end
                   should "return trackers with include=trackers" do
                     get '/projects/1.xml?include=trackers'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'trackers',
                       :attributes => {:type => 'array'},
                       :child => {
                         :tag => 'tracker',
                         :attributes => {
                           :id => '2',
                           :name => 'Feature request'
                         }
                       }
                   end
                 end
                 context ".json" do
                   should_allow_api_authentication(:get, "/projects/2.json")
                   should "return requested project" do
                     get '/projects/1.json'
                     json = ActiveSupport::JSON.decode(response.body)
                     assert_kind_of Hash, json
                     assert_kind_of Hash, json['project']
                     assert_equal 1, json['project']['id']
                   end
                 end
               end
               context "POST /projects" do
                 context "with valid parameters" do
                   setup do
                     Setting.default_projects_modules = ['issue_tracking', 'repository']
                     @parameters = {:project => {:name => 'API test', :identifier => 'api-test'}}
                   end
                   context ".xml" do
                     should_allow_api_authentication(:post,
                                                     '/projects.xml',
                                                     {:project => {:name => 'API test', :identifier => 'api-test'}},
                                                     {:success_code => :created})
                     should "create a project with the attributes" do
                       assert_difference('Project.count') do
-                        post '/projects.xml', @parameters, :authorization => credentials('admin')
+                        post '/projects.xml', @parameters, credentials('admin')
                       end
                       project = Project.first(:order => 'id DESC')
                       assert_equal 'API test', project.name
                       assert_equal 'api-test', project.identifier
                       assert_equal ['issue_tracking', 'repository'], project.enabled_module_names.sort
                       assert_equal Tracker.all.size, project.trackers.size
                       assert_response :created
                       assert_equal 'application/xml', @response.content_type
                       assert_tag 'project', :child => {:tag => 'id', :content => project.id.to_s}
                     end
                     should "accept enabled_module_names attribute" do
                       @parameters[:project].merge!({:enabled_module_names => ['issue_tracking', 'news', 'time_tracking']})
                       assert_difference('Project.count') do
-                        post '/projects.xml', @parameters, :authorization => credentials('admin')
+                        post '/projects.xml', @parameters, credentials('admin')
                       end
                       project = Project.first(:order => 'id DESC')
                       assert_equal ['issue_tracking', 'news', 'time_tracking'], project.enabled_module_names.sort
                     end
                     should "accept tracker_ids attribute" do
                       @parameters[:project].merge!({:tracker_ids => [1, 3]})
                       assert_difference('Project.count') do
-                        post '/projects.xml', @parameters, :authorization => credentials('admin')
+                        post '/projects.xml', @parameters, credentials('admin')
                       end
                       project = Project.first(:order => 'id DESC')
                       assert_equal [1, 3], project.trackers.map(&:id).sort
                     end
                   end
                 end
                 context "with invalid parameters" do
                   setup do
                     @parameters = {:project => {:name => 'API test'}}
                   end
                   context ".xml" do
                     should "return errors" do
                       assert_no_difference('Project.count') do
-                        post '/projects.xml', @parameters, :authorization => credentials('admin')
+                        post '/projects.xml', @parameters, credentials('admin')
                       end
                       assert_response :unprocessable_entity
                       assert_equal 'application/xml', @response.content_type
                       assert_tag 'errors', :child => {:tag => 'error', :content => "Identifier can't be blank"}
                     end
                   end
                 end
               end
               context "PUT /projects/:id" do
                 context "with valid parameters" do
                   setup do
                     @parameters = {:project => {:name => 'API update'}}
                   end
                   context ".xml" do
                     should_allow_api_authentication(:put,
                                                     '/projects/2.xml',
                                                     {:project => {:name => 'API update'}},
                                                     {:success_code => :ok})
                     should "update the project" do
                       assert_no_difference 'Project.count' do
-                        put '/projects/2.xml', @parameters, :authorization => credentials('jsmith')
+                        put '/projects/2.xml', @parameters, credentials('jsmith')
                       end
                       assert_response :ok
                       assert_equal 'application/xml', @response.content_type
                       project = Project.find(2)
                       assert_equal 'API update', project.name
                     end
                     should "accept enabled_module_names attribute" do
                       @parameters[:project].merge!({:enabled_module_names => ['issue_tracking', 'news', 'time_tracking']})
                       assert_no_difference 'Project.count' do
-                        put '/projects/2.xml', @parameters, :authorization => credentials('admin')
+                        put '/projects/2.xml', @parameters, credentials('admin')
                       end
                       assert_response :ok
                       project = Project.find(2)
                       assert_equal ['issue_tracking', 'news', 'time_tracking'], project.enabled_module_names.sort
                     end
                     should "accept tracker_ids attribute" do
                       @parameters[:project].merge!({:tracker_ids => [1, 3]})
                       assert_no_difference 'Project.count' do
-                        put '/projects/2.xml', @parameters, :authorization => credentials('admin')
+                        put '/projects/2.xml', @parameters, credentials('admin')
                       end
                       assert_response :ok
                       project = Project.find(2)
                       assert_equal [1, 3], project.trackers.map(&:id).sort
                     end
                   end
                 end
                 context "with invalid parameters" do
                   setup do
                     @parameters = {:project => {:name => ''}}
                   end
                   context ".xml" do
                     should "return errors" do
                       assert_no_difference('Project.count') do
-                        put '/projects/2.xml', @parameters, :authorization => credentials('admin')
+                        put '/projects/2.xml', @parameters, credentials('admin')
                       end
                       assert_response :unprocessable_entity
                       assert_equal 'application/xml', @response.content_type
                       assert_tag 'errors', :child => {:tag => 'error', :content => "Name can't be blank"}
                     end
                   end
                 end
               end
               context "DELETE /projects/:id" do
                 context ".xml" do
                   should_allow_api_authentication(:delete,
                                                   '/projects/2.xml',
                                                   {},
                                                   {:success_code => :ok})
                   should "delete the project" do
                     assert_difference('Project.count',-1) do
-                      delete '/projects/2.xml', {}, :authorization => credentials('admin')
+                      delete '/projects/2.xml', {}, credentials('admin')
                     end
                     assert_response :ok
                     assert_nil Project.find_by_id(2)
                   end
                 end
               end
             end

test/integration/api_test/time_entries_test.rb +9 -9

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::TimeEntriesTest < ActionController::IntegrationTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :time_entries
               def setup
                 Setting.rest_api_enabled = '1'
               end
               context "GET /time_entries.xml" do
                 should "return time entries" do
-                  get '/time_entries.xml', {}, :authorization => credentials('jsmith')
+                  get '/time_entries.xml', {}, credentials('jsmith')
                   assert_response :success
                   assert_equal 'application/xml', @response.content_type
                   assert_tag :tag => 'time_entries',
                     :child => {:tag => 'time_entry', :child => {:tag => 'id', :content => '2'}}
                 end
                 context "with limit" do
                   should "return limited results" do
-                    get '/time_entries.xml?limit=2', {}, :authorization => credentials('jsmith')
+                    get '/time_entries.xml?limit=2', {}, credentials('jsmith')
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag :tag => 'time_entries',
                       :children => {:count => 2}
                   end
                 end
               end
               context "GET /time_entries/2.xml" do
                 should "return requested time entry" do
-                  get '/time_entries/2.xml', {}, :authorization => credentials('jsmith')
+                  get '/time_entries/2.xml', {}, credentials('jsmith')
                   assert_response :success
                   assert_equal 'application/xml', @response.content_type
                   assert_tag :tag => 'time_entry',
                     :child => {:tag => 'id', :content => '2'}
                 end
               end
               context "POST /time_entries.xml" do
                 context "with issue_id" do
                   should "return create time entry" do
                     assert_difference 'TimeEntry.count' do
-                      post '/time_entries.xml', {:time_entry => {:issue_id => '1', :spent_on => '2010-12-02', :hours => '3.5', :activity_id => '11'}}, :authorization => credentials('jsmith')
+                      post '/time_entries.xml', {:time_entry => {:issue_id => '1', :spent_on => '2010-12-02', :hours => '3.5', :activity_id => '11'}}, credentials('jsmith')
                     end
                     assert_response :created
                     assert_equal 'application/xml', @response.content_type
                     entry = TimeEntry.first(:order => 'id DESC')
                     assert_equal 'jsmith', entry.user.login
                     assert_equal Issue.find(1), entry.issue
                     assert_equal Project.find(1), entry.project
                     assert_equal Date.parse('2010-12-02'), entry.spent_on
                     assert_equal 3.5, entry.hours
                     assert_equal TimeEntryActivity.find(11), entry.activity
                   end
                 end
                 context "with project_id" do
                   should "return create time entry" do
                     assert_difference 'TimeEntry.count' do
-                      post '/time_entries.xml', {:time_entry => {:project_id => '1', :spent_on => '2010-12-02', :hours => '3.5', :activity_id => '11'}}, :authorization => credentials('jsmith')
+                      post '/time_entries.xml', {:time_entry => {:project_id => '1', :spent_on => '2010-12-02', :hours => '3.5', :activity_id => '11'}}, credentials('jsmith')
                     end
                     assert_response :created
                     assert_equal 'application/xml', @response.content_type
                     entry = TimeEntry.first(:order => 'id DESC')
                     assert_equal 'jsmith', entry.user.login
                     assert_nil entry.issue
                     assert_equal Project.find(1), entry.project
                     assert_equal Date.parse('2010-12-02'), entry.spent_on
                     assert_equal 3.5, entry.hours
                     assert_equal TimeEntryActivity.find(11), entry.activity
                   end
                 end
                 context "with invalid parameters" do
                   should "return errors" do
                     assert_no_difference 'TimeEntry.count' do
-                      post '/time_entries.xml', {:time_entry => {:project_id => '1', :spent_on => '2010-12-02', :activity_id => '11'}}, :authorization => credentials('jsmith')
+                      post '/time_entries.xml', {:time_entry => {:project_id => '1', :spent_on => '2010-12-02', :activity_id => '11'}}, credentials('jsmith')
                     end
                     assert_response :unprocessable_entity
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'errors', :child => {:tag => 'error', :content => "Hours can't be blank"}
                   end
                 end
               end
               context "PUT /time_entries/2.xml" do
                 context "with valid parameters" do
                   should "update time entry" do
                     assert_no_difference 'TimeEntry.count' do
-                      put '/time_entries/2.xml', {:time_entry => {:comments => 'API Update'}}, :authorization => credentials('jsmith')
+                      put '/time_entries/2.xml', {:time_entry => {:comments => 'API Update'}}, credentials('jsmith')
                     end
                     assert_response :ok
                     assert_equal 'API Update', TimeEntry.find(2).comments
                   end
                 end
                 context "with invalid parameters" do
                   should "return errors" do
                     assert_no_difference 'TimeEntry.count' do
-                      put '/time_entries/2.xml', {:time_entry => {:hours => '', :comments => 'API Update'}}, :authorization => credentials('jsmith')
+                      put '/time_entries/2.xml', {:time_entry => {:hours => '', :comments => 'API Update'}}, credentials('jsmith')
                     end
                     assert_response :unprocessable_entity
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'errors', :child => {:tag => 'error', :content => "Hours can't be blank"}
                   end
                 end
               end
               context "DELETE /time_entries/2.xml" do
                 should "destroy time entry" do
                   assert_difference 'TimeEntry.count', -1 do
-                    delete '/time_entries/2.xml', {}, :authorization => credentials('jsmith')
+                    delete '/time_entries/2.xml', {}, credentials('jsmith')
                   end
                   assert_response :ok
                   assert_nil TimeEntry.find_by_id(2)
                 end
               end
             end

test/integration/api_test/users_test.rb +11 -11

             # Redmine - project management software
             # Copyright (C) 2006-2011  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__)
             require 'pp'
             class ApiTest::UsersTest < ActionController::IntegrationTest
               fixtures :users
               def setup
                 Setting.rest_api_enabled = '1'
               end
               context "GET /users" do
                 should_allow_api_authentication(:get, "/users.xml")
                 should_allow_api_authentication(:get, "/users.json")
               end
               context "GET /users/2" do
                 context ".xml" do
                   should "return requested user" do
                     get '/users/2.xml'
                     assert_tag :tag => 'user',
                       :child => {:tag => 'id', :content => '2'}
                   end
                 end
                 context ".json" do
                   should "return requested user" do
                     get '/users/2.json'
                     json = ActiveSupport::JSON.decode(response.body)
                     assert_kind_of Hash, json
                     assert_kind_of Hash, json['user']
                     assert_equal 2, json['user']['id']
                   end
                 end
               end
               context "GET /users/current" do
                 context ".xml" do
                   should "require authentication" do
                     get '/users/current.xml'
                     assert_response 401
                   end
                   should "return current user" do
-                    get '/users/current.xml', {}, :authorization => credentials('jsmith')
+                    get '/users/current.xml', {}, credentials('jsmith')
                     assert_tag :tag => 'user',
                       :child => {:tag => 'id', :content => '2'}
                   end
                 end
               end
               context "POST /users" do
                 context "with valid parameters" do
                   setup do
                     @parameters = {
                       :user => {
                          :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                          :mail => 'foo@example.net', :password => 'secret',
                          :mail_notification => 'only_assigned'
                       }
                     }
                   end
                   context ".xml" do
                     should_allow_api_authentication(:post,
                       '/users.xml',
                        {:user => {
                           :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                           :mail => 'foo@example.net', :password => 'secret'
                         }},
                       {:success_code => :created})
                     should "create a user with the attributes" do
                       assert_difference('User.count') do
-                        post '/users.xml', @parameters, :authorization => credentials('admin')
+                        post '/users.xml', @parameters, credentials('admin')
                       end
                       user = User.first(:order => 'id DESC')
                       assert_equal 'foo', user.login
                       assert_equal 'Firstname', user.firstname
                       assert_equal 'Lastname', user.lastname
                       assert_equal 'foo@example.net', user.mail
                       assert_equal 'only_assigned', user.mail_notification
                       assert !user.admin?
                       assert user.check_password?('secret')
                       assert_response :created
                       assert_equal 'application/xml', @response.content_type
                       assert_tag 'user', :child => {:tag => 'id', :content => user.id.to_s}
                     end
                   end
                   context ".json" do
                     should_allow_api_authentication(:post,
                       '/users.json',
                       {:user => {
                          :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                          :mail => 'foo@example.net'
                       }},
                       {:success_code => :created})
                     should "create a user with the attributes" do
                       assert_difference('User.count') do
-                        post '/users.json', @parameters, :authorization => credentials('admin')
+                        post '/users.json', @parameters, credentials('admin')
                       end
                       user = User.first(:order => 'id DESC')
                       assert_equal 'foo', user.login
                       assert_equal 'Firstname', user.firstname
                       assert_equal 'Lastname', user.lastname
                       assert_equal 'foo@example.net', user.mail
                       assert !user.admin?
                       assert_response :created
                       assert_equal 'application/json', @response.content_type
                       json = ActiveSupport::JSON.decode(response.body)
                       assert_kind_of Hash, json
                       assert_kind_of Hash, json['user']
                       assert_equal user.id, json['user']['id']
                     end
                   end
                 end
                 context "with invalid parameters" do
                   setup do
                     @parameters = {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}
                   end
                   context ".xml" do
                     should "return errors" do
                       assert_no_difference('User.count') do
-                        post '/users.xml', @parameters, :authorization => credentials('admin')
+                        post '/users.xml', @parameters, credentials('admin')
                       end
                       assert_response :unprocessable_entity
                       assert_equal 'application/xml', @response.content_type
                       assert_tag 'errors', :child => {
                                              :tag => 'error',
                                              :content => "First name can't be blank"
                                            }
                     end
                   end
                   context ".json" do
                     should "return errors" do
                       assert_no_difference('User.count') do
-                        post '/users.json', @parameters, :authorization => credentials('admin')
+                        post '/users.json', @parameters, credentials('admin')
                       end
                       assert_response :unprocessable_entity
                       assert_equal 'application/json', @response.content_type
                       json = ActiveSupport::JSON.decode(response.body)
                       assert_kind_of Hash, json
                       assert json.has_key?('errors')
                       assert_kind_of Array, json['errors']
                     end
                   end
                 end
               end
               context "PUT /users/2" do
                 context "with valid parameters" do
                   setup do
                     @parameters = {
                       :user => {
                         :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                         :mail => 'jsmith@somenet.foo'
                       }
                     }
                   end
                   context ".xml" do
                     should_allow_api_authentication(:put,
                       '/users/2.xml',
                       {:user => {
                           :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                           :mail => 'jsmith@somenet.foo'
                       }},
                       {:success_code => :ok})
                     should "update user with the attributes" do
                       assert_no_difference('User.count') do
-                        put '/users/2.xml', @parameters, :authorization => credentials('admin')
+                        put '/users/2.xml', @parameters, credentials('admin')
                       end
                       user = User.find(2)
                       assert_equal 'jsmith', user.login
                       assert_equal 'John', user.firstname
                       assert_equal 'Renamed', user.lastname
                       assert_equal 'jsmith@somenet.foo', user.mail
                       assert !user.admin?
                       assert_response :ok
                     end
                   end
                   context ".json" do
                     should_allow_api_authentication(:put,
                       '/users/2.json',
                       {:user => {
                           :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                           :mail => 'jsmith@somenet.foo'
                       }},
                       {:success_code => :ok})
                     should "update user with the attributes" do
                       assert_no_difference('User.count') do
-                        put '/users/2.json', @parameters, :authorization => credentials('admin')
+                        put '/users/2.json', @parameters, credentials('admin')
                       end
                       user = User.find(2)
                       assert_equal 'jsmith', user.login
                       assert_equal 'John', user.firstname
                       assert_equal 'Renamed', user.lastname
                       assert_equal 'jsmith@somenet.foo', user.mail
                       assert !user.admin?
                       assert_response :ok
                     end
                   end
                 end
                 context "with invalid parameters" do
                   setup do
                     @parameters = {
                       :user => {
                         :login => 'jsmith', :firstname => '', :lastname => 'Lastname',
                         :mail => 'foo'
                       }
                     }
                   end
                   context ".xml" do
                     should "return errors" do
                       assert_no_difference('User.count') do
-                        put '/users/2.xml', @parameters, :authorization => credentials('admin')
+                        put '/users/2.xml', @parameters, credentials('admin')
                       end
                       assert_response :unprocessable_entity
                       assert_equal 'application/xml', @response.content_type
                       assert_tag 'errors', :child => {
                                              :tag => 'error',
                                              :content => "First name can't be blank"
                                             }
                     end
                   end
                   context ".json" do
                     should "return errors" do
                       assert_no_difference('User.count') do
-                        put '/users/2.json', @parameters, :authorization => credentials('admin')
+                        put '/users/2.json', @parameters, credentials('admin')
                       end
                       assert_response :unprocessable_entity
                       assert_equal 'application/json', @response.content_type
                       json = ActiveSupport::JSON.decode(response.body)
                       assert_kind_of Hash, json
                       assert json.has_key?('errors')
                       assert_kind_of Array, json['errors']
                     end
                   end
                 end
               end
               context "DELETE /users/2" do
                 context ".xml" do
                   should_allow_api_authentication(:delete,
                     '/users/2.xml',
                     {},
                     {:success_code => :ok})
                   should "delete user" do
                     assert_difference('User.count', -1) do
-                      delete '/users/2.xml', {}, :authorization => credentials('admin')
+                      delete '/users/2.xml', {}, credentials('admin')
                     end
                     assert_response :ok
                   end
                 end
                 context ".json" do
                   should_allow_api_authentication(:delete,
                     '/users/2.xml',
                     {},
                     {:success_code => :ok})
                   should "delete user" do
                     assert_difference('User.count', -1) do
-                      delete '/users/2.json', {}, :authorization => credentials('admin')
+                      delete '/users/2.json', {}, credentials('admin')
                     end
                     assert_response :ok
                   end
                 end
               end
             end

test/integration/api_test/versions_test.rb +4 -4

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 ApiTest::VersionsTest < ActionController::IntegrationTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :versions
               def setup
                 Setting.rest_api_enabled = '1'
               end
               context "/projects/:project_id/versions" do
                 context "GET" do
                   should "return project versions" do
                     get '/projects/1/versions.xml'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag :tag => 'versions',
                       :attributes => {:type => 'array'},
                       :child => {
                         :tag => 'version',
                         :child => {
                           :tag => 'id',
                           :content => '2',
                           :sibling => {
                             :tag => 'name',
                             :content => '1.0'
                           }
                         }
                       }
                   end
                 end
                 context "POST" do
                   should "create the version" do
                     assert_difference 'Version.count' do
-                      post '/projects/1/versions.xml', {:version => {:name => 'API test'}}, :authorization => credentials('jsmith')
+                      post '/projects/1/versions.xml', {:version => {:name => 'API test'}}, credentials('jsmith')
                     end
                     version = Version.first(:order => 'id DESC')
                     assert_equal 'API test', version.name
                     assert_response :created
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'version', :child => {:tag => 'id', :content => version.id.to_s}
                   end
                   context "with failure" do
                     should "return the errors" do
                       assert_no_difference('Version.count') do
-                        post '/projects/1/versions.xml', {:version => {:name => ''}}, :authorization => credentials('jsmith')
+                        post '/projects/1/versions.xml', {:version => {:name => ''}}, credentials('jsmith')
                       end
                       assert_response :unprocessable_entity
                       assert_tag :errors, :child => {:tag => 'error', :content => "Name can't be blank"}
                     end
                   end
                 end
               end
               context "/versions/:id" do
                 context "GET" do
                   should "return the version" do
                     get '/versions/2.xml'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'version',
                       :child => {
                         :tag => 'id',
                         :content => '2',
                         :sibling => {
                           :tag => 'name',
                           :content => '1.0'
                         }
                       }
                   end
                 end
                 context "PUT" do
                   should "update the version" do
-                    put '/versions/2.xml', {:version => {:name => 'API update'}}, :authorization => credentials('jsmith')
+                    put '/versions/2.xml', {:version => {:name => 'API update'}}, credentials('jsmith')
                     assert_response :ok
                     assert_equal 'API update', Version.find(2).name
                   end
                 end
                 context "DELETE" do
                   should "destroy the version" do
                     assert_difference 'Version.count', -1 do
-                      delete '/versions/3.xml', {}, :authorization => credentials('jsmith')
+                      delete '/versions/3.xml', {}, credentials('jsmith')
                     end
                     assert_response :ok
                     assert_nil Version.find_by_id(3)
                   end
                 end
               end
             end

test/test_helper.rb +6 -6

             # Redmine - project management software
             # Copyright (C) 2006-2011  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.
             ENV["RAILS_ENV"] = "test"
             require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
             require 'test_help'
             require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
             require File.expand_path(File.dirname(__FILE__) + '/object_daddy_helpers')
             include ObjectDaddyHelpers
             class ActiveSupport::TestCase
               # Transactional fixtures accelerate your tests by wrapping each test method
               # in a transaction that's rolled back on completion.  This ensures that the
               # test database remains unchanged so your fixtures don't have to be reloaded
               # between every test method.  Fewer database queries means faster tests.
               #
               # Read Mike Clark's excellent walkthrough at
               #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
               #
               # Every Active Record database supports transactions except MyISAM tables
               # in MySQL.  Turn off transactional fixtures in this case; however, if you
               # don't care one way or the other, switching from MyISAM to InnoDB tables
               # is recommended.
               self.use_transactional_fixtures = true
               # Instantiated fixtures are slow, but give you @david where otherwise you
               # would need people(:david).  If you don't want to migrate your existing
               # test cases which use the @david style and don't mind the speed hit (each
               # instantiated fixtures translates to a database query per test method),
               # then set this back to true.
               self.use_instantiated_fixtures  = false
               # Add more helper methods to be used by all tests here...
               def log_user(login, password)
                 User.anonymous
                 get "/login"
                 assert_equal nil, session[:user_id]
                 assert_response :success
                 assert_template "account/login"
                 post "/login", :username => login, :password => password
                 assert_equal login, User.find(session[:user_id]).login
               end
               def uploaded_test_file(name, mime)
                 ActionController::TestUploadedFile.new(
                   ActiveSupport::TestCase.fixture_path + "/files/#{name}", mime, true)
               end
               def credentials(user, password=nil)
-                ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)
+                {:authorization => ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)}
               end
               # Mock out a file
               def self.mock_file
                 file = 'a_file.png'
                 file.stubs(:size).returns(32)
                 file.stubs(:original_filename).returns('a_file.png')
                 file.stubs(:content_type).returns('image/png')
                 file.stubs(:read).returns(false)
                 file
               end
               def mock_file
                 self.class.mock_file
               end
               def mock_file_with_options(options={})
                 file = ''
                 file.stubs(:size).returns(32)
                 original_filename = options[:original_filename] || nil
                 file.stubs(:original_filename).returns(original_filename)
                 content_type = options[:content_type] || nil
                 file.stubs(:content_type).returns(content_type)
                 file.stubs(:read).returns(false)
                 file
               end
               # Use a temporary directory for attachment related tests
               def set_tmp_attachments_directory
                 Dir.mkdir "#{Rails.root}/tmp/test" unless File.directory?("#{Rails.root}/tmp/test")
                 unless File.directory?("#{Rails.root}/tmp/test/attachments")
                   Dir.mkdir "#{Rails.root}/tmp/test/attachments"
                 end
                 Attachment.storage_path = "#{Rails.root}/tmp/test/attachments"
               end
               def set_fixtures_attachments_directory
                 Attachment.storage_path = "#{Rails.root}/test/fixtures/files"
               end
               def with_settings(options, &block)
                 saved_settings = options.keys.inject({}) {|h, k| h[k] = Setting[k].is_a?(Symbol) ? Setting[k] : Setting[k].dup; h}
                 options.each {|k, v| Setting[k] = v}
                 yield
               ensure
                 saved_settings.each {|k, v| Setting[k] = v} if saved_settings
               end
               def change_user_password(login, new_password)
                 user = User.first(:conditions => {:login => login})
                 user.password, user.password_confirmation = new_password, new_password
                 user.save!
               end
               def self.ldap_configured?
                 @test_ldap = Net::LDAP.new(:host => '127.0.0.1', :port => 389)
                 return @test_ldap.bind
               rescue Exception => e
                 # LDAP is not listening
                 return nil
               end
               # Returns the path to the test +vendor+ repository
               def self.repository_path(vendor)
                 Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
               end
               # Returns the url of the subversion test repository
               def self.subversion_repository_url
                 path = repository_path('subversion')
                 path = '/' + path unless path.starts_with?('/')
                 "file://#{path}"
               end
               # Returns true if the +vendor+ test repository is configured
               def self.repository_configured?(vendor)
                 File.directory?(repository_path(vendor))
               end
               def assert_error_tag(options={})
                 assert_tag({:attributes => { :id => 'errorExplanation' }}.merge(options))
               end
               def assert_include(expected, s)
                 assert s.include?(expected), "\"#{expected}\" not found in \"#{s}\""
               end
               # Shoulda macros
               def self.should_render_404
                 should_respond_with :not_found
                 should_render_template 'common/error'
               end
               def self.should_have_before_filter(expected_method, options = {})
                 should_have_filter('before', expected_method, options)
               end
               def self.should_have_after_filter(expected_method, options = {})
                 should_have_filter('after', expected_method, options)
               end
               def self.should_have_filter(filter_type, expected_method, options)
                 description = "have #{filter_type}_filter :#{expected_method}"
                 description << " with #{options.inspect}" unless options.empty?
                 should description do
                   klass = "action_controller/filters/#{filter_type}_filter".classify.constantize
                   expected = klass.new(:filter, expected_method.to_sym, options)
                   assert_equal 1, @controller.class.filter_chain.select { |filter|
                     filter.method == expected.method && filter.kind == expected.kind &&
                     filter.options == expected.options && filter.class == expected.class
                   }.size
                 end
               end
               def self.should_show_the_old_and_new_values_for(prop_key, model, &block)
                 context "" do
                   setup do
                     if block_given?
                       instance_eval &block
                     else
                       @old_value = model.generate!
                       @new_value = model.generate!
                     end
                   end
                   should "use the new value's name" do
                     @detail = JournalDetail.generate!(:property => 'attr',
                                                       :old_value => @old_value.id,
                                                       :value => @new_value.id,
                                                       :prop_key => prop_key)
                     assert_match @new_value.name, show_detail(@detail, true)
                   end
                   should "use the old value's name" do
                     @detail = JournalDetail.generate!(:property => 'attr',
                                                       :old_value => @old_value.id,
                                                       :value => @new_value.id,
                                                       :prop_key => prop_key)
                     assert_match @old_value.name, show_detail(@detail, true)
                   end
                 end
               end
               # Test that a request allows the three types of API authentication
               #
               # * HTTP Basic with username and password
               # * HTTP Basic with an api key for the username
               # * Key based with the key=X parameter
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_api_authentication(http_method, url, parameters={}, options={})
                 should_allow_http_basic_auth_with_username_and_password(http_method, url, parameters, options)
                 should_allow_http_basic_auth_with_key(http_method, url, parameters, options)
                 should_allow_key_based_auth(http_method, url, parameters, options)
               end
               # Test that a request allows the username and password for HTTP BASIC
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_http_basic_auth_with_username_and_password(http_method, url, parameters={}, options={})
                 success_code = options[:success_code] || :success
                 failure_code = options[:failure_code] || :unauthorized
                 context "should allow http basic auth using a username and password for #{http_method} #{url}" do
                   context "with a valid HTTP authentication" do
                     setup do
                       @user = User.generate_with_protected!(:password => 'my_password', :password_confirmation => 'my_password', :admin => true) # Admin so they can access the project
-                      send(http_method, url, parameters, {:authorization => credentials(@user.login, 'my_password')})
+                      send(http_method, url, parameters, credentials(@user.login, 'my_password'))
                     end
                     should_respond_with success_code
                     should_respond_with_content_type_based_on_url(url)
                     should "login as the user" do
                       assert_equal @user, User.current
                     end
                   end
                   context "with an invalid HTTP authentication" do
                     setup do
                       @user = User.generate_with_protected!
-                      send(http_method, url, parameters, {:authorization => credentials(@user.login, 'wrong_password')})
+                      send(http_method, url, parameters, credentials(@user.login, 'wrong_password'))
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                   context "without credentials" do
                     setup do
-                      send(http_method, url, parameters, {:authorization => ''})
+                      send(http_method, url, parameters)
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "include_www_authenticate_header" do
                       assert @controller.response.headers.has_key?('WWW-Authenticate')
                     end
                   end
                 end
               end
               # Test that a request allows the API key with HTTP BASIC
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_http_basic_auth_with_key(http_method, url, parameters={}, options={})
                 success_code = options[:success_code] || :success
                 failure_code = options[:failure_code] || :unauthorized
                 context "should allow http basic auth with a key for #{http_method} #{url}" do
                   context "with a valid HTTP authentication using the API token" do
                     setup do
                       @user = User.generate_with_protected!(:admin => true)
                       @token = Token.generate!(:user => @user, :action => 'api')
-                      send(http_method, url, parameters, {:authorization => credentials(@token.value, 'X')})
+                      send(http_method, url, parameters, credentials(@token.value, 'X'))
                     end
                     should_respond_with success_code
                     should_respond_with_content_type_based_on_url(url)
                     should_be_a_valid_response_string_based_on_url(url)
                     should "login as the user" do
                       assert_equal @user, User.current
                     end
                   end
                   context "with an invalid HTTP authentication" do
                     setup do
                       @user = User.generate_with_protected!
                       @token = Token.generate!(:user => @user, :action => 'feeds')
-                      send(http_method, url, parameters, {:authorization => credentials(@token.value, 'X')})
+                      send(http_method, url, parameters, credentials(@token.value, 'X'))
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                 end
               end
               # Test that a request allows full key authentication
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url, without the key=ZXY parameter
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_key_based_auth(http_method, url, parameters={}, options={})
                 success_code = options[:success_code] || :success
                 failure_code = options[:failure_code] || :unauthorized
                 context "should allow key based auth using key=X for #{http_method} #{url}" do
                   context "with a valid api token" do
                     setup do
                       @user = User.generate_with_protected!(:admin => true)
                       @token = Token.generate!(:user => @user, :action => 'api')
                       # Simple url parse to add on ?key= or &key=
                       request_url = if url.match(/\?/)
                                       url + "&key=#{@token.value}"
                                     else
                                       url + "?key=#{@token.value}"
                                     end
                       send(http_method, request_url, parameters)
                     end
                     should_respond_with success_code
                     should_respond_with_content_type_based_on_url(url)
                     should_be_a_valid_response_string_based_on_url(url)
                     should "login as the user" do
                       assert_equal @user, User.current
                     end
                   end
                   context "with an invalid api token" do
                     setup do
                       @user = User.generate_with_protected!
                       @token = Token.generate!(:user => @user, :action => 'feeds')
                       # Simple url parse to add on ?key= or &key=
                       request_url = if url.match(/\?/)
                                       url + "&key=#{@token.value}"
                                     else
                                       url + "?key=#{@token.value}"
                                     end
                       send(http_method, request_url, parameters)
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                 end
                 context "should allow key based auth using X-Redmine-API-Key header for #{http_method} #{url}" do
                   setup do
                     @user = User.generate_with_protected!(:admin => true)
                     @token = Token.generate!(:user => @user, :action => 'api')
                     send(http_method, url, parameters, {'X-Redmine-API-Key' => @token.value.to_s})
                   end
                   should_respond_with success_code
                   should_respond_with_content_type_based_on_url(url)
                   should_be_a_valid_response_string_based_on_url(url)
                   should "login as the user" do
                     assert_equal @user, User.current
                   end
                 end
               end
               # Uses should_respond_with_content_type based on what's in the url:
               #
               # '/project/issues.xml' => should_respond_with_content_type :xml
               # '/project/issues.json' => should_respond_with_content_type :json
               #
               # @param [String] url Request
               def self.should_respond_with_content_type_based_on_url(url)
                 case
                 when url.match(/xml/i)
                   should_respond_with_content_type :xml
                 when url.match(/json/i)
                   should_respond_with_content_type :json
                 else
                   raise "Unknown content type for should_respond_with_content_type_based_on_url: #{url}"
                 end
               end
               # Uses the url to assert which format the response should be in
               #
               # '/project/issues.xml' => should_be_a_valid_xml_string
               # '/project/issues.json' => should_be_a_valid_json_string
               #
               # @param [String] url Request
               def self.should_be_a_valid_response_string_based_on_url(url)
                 case
                 when url.match(/xml/i)
                   should_be_a_valid_xml_string
                 when url.match(/json/i)
                   should_be_a_valid_json_string
                 else
                   raise "Unknown content type for should_be_a_valid_response_based_on_url: #{url}"
                 end
               end
               # Checks that the response is a valid JSON string
               def self.should_be_a_valid_json_string
                 should "be a valid JSON string (or empty)" do
                   assert(response.body.blank? || ActiveSupport::JSON.decode(response.body))
                 end
               end
               # Checks that the response is a valid XML string
               def self.should_be_a_valid_xml_string
                 should "be a valid XML string" do
                   assert REXML::Document.new(response.body)
                 end
               end
             end
             # Simple module to "namespace" all of the API tests
             module ApiTest
             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