jro_apps/redmine Commit - r13297:d22029083c48

Pull up #setup and #teardown in API tests....

Jean-Philippe Lang -

r13297:d22029083c48

parent child

Context file:

r13297:d22029083c48

Expand all files

test/integration/api_test/api_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::ApiTest < Redmine::ApiTest::Base
                fixtures :users
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                def test_api_should_work_with_protect_from_forgery
                  ActionController::Base.allow_forgery_protection = true
                  assert_difference('User.count') do
                    post '/users.xml', {
                      :user => {
                        :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                        :mail => 'foo@example.net', :password => 'secret123'}
                      },
                      credentials('admin')
                    assert_response 201
                  end
                ensure
                  ActionController::Base.allow_forgery_protection = false
                end
              end
  No newline at end of file

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

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::AttachmentsTest < Redmine::ApiTest::Base
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :attachments
                def setup
-                 Setting.rest_api_enabled = '1'
+                 super
                  set_fixtures_attachments_directory
                end
                def teardown
+                 super
                  set_tmp_attachments_directory
                end
                test "GET /attachments/:id.xml should return the attachment" do
                  get '/attachments/7.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'attachment id:content(7)' do
                    assert_select '~ filename', :text => 'archive.zip'
                    assert_select '~ content_url', :text => 'http://www.example.com/attachments/download/7/archive.zip'
                  end
                end
                test "GET /attachments/:id.xml should deny access without credentials" do
                  get '/attachments/7.xml'
                  assert_response 401
                  set_tmp_attachments_directory
                end
                test "GET /attachments/download/:id/:filename should return the attachment content" do
                  get '/attachments/download/7/archive.zip', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/octet-stream', @response.content_type
                  set_tmp_attachments_directory
                end
                test "GET /attachments/download/:id/:filename should deny access without credentials" do
                  get '/attachments/download/7/archive.zip'
                  assert_response 302
                  set_tmp_attachments_directory
                end
                test "POST /uploads.xml should return the token" do
                  set_tmp_attachments_directory
                  assert_difference 'Attachment.count' do
                    post '/uploads.xml', 'File content', {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                    assert_response :created
                    assert_equal 'application/xml', response.content_type
                  end
                  xml = Hash.from_xml(response.body)
                  assert_kind_of Hash, xml['upload']
                  token = xml['upload']['token']
                  assert_not_nil token
                  attachment = Attachment.order('id DESC').first
                  assert_equal token, attachment.token
                  assert_nil attachment.container
                  assert_equal 2, attachment.author_id
                  assert_equal 'File content'.size, attachment.filesize
                  assert attachment.content_type.blank?
                  assert attachment.filename.present?
                  assert_match /\d+_[0-9a-z]+/, attachment.diskfile
                  assert File.exist?(attachment.diskfile)
                  assert_equal 'File content', File.read(attachment.diskfile)
                end
                test "POST /uploads.json should return the token" do
                  set_tmp_attachments_directory
                  assert_difference 'Attachment.count' do
                    post '/uploads.json', 'File content', {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                    assert_response :created
                    assert_equal 'application/json', response.content_type
                  end
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Hash, json['upload']
                  token = json['upload']['token']
                  assert_not_nil token
                  attachment = Attachment.order('id DESC').first
                  assert_equal token, attachment.token
                end
                test "POST /uploads.xml should accept :filename param as the attachment filename" do
                  set_tmp_attachments_directory
                  assert_difference 'Attachment.count' do
                    post '/uploads.xml?filename=test.txt', 'File content', {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                    assert_response :created
                  end
                  attachment = Attachment.order('id DESC').first
                  assert_equal 'test.txt', attachment.filename
                  assert_match /_test\.txt$/, attachment.diskfile
                end
                test "POST /uploads.xml should not accept other content types" do
                  set_tmp_attachments_directory
                  assert_no_difference 'Attachment.count' do
                    post '/uploads.xml', 'PNG DATA', {"CONTENT_TYPE" => 'image/png'}.merge(credentials('jsmith'))
                    assert_response 406
                  end
                end
                test "POST /uploads.xml should return errors if file is too big" do
                  set_tmp_attachments_directory
                  with_settings :attachment_max_size => 1 do
                    assert_no_difference 'Attachment.count' do
                      post '/uploads.xml', ('x' * 2048), {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                      assert_response 422
                      assert_select 'error', :text => /exceeds the maximum allowed file size/
                    end
                  end
                end
              end

test/integration/api_test/authentication_test.rb 0 -8

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::AuthenticationTest < Redmine::ApiTest::Base
                fixtures :users
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
-               def teardown
-                 Setting.rest_api_enabled = '0'
-               end
                def test_api_should_deny_without_credentials
                  get '/users/current.xml', {}
                  assert_response 401
                  assert_equal User.anonymous, User.current
                  assert response.headers.has_key?('WWW-Authenticate')
                end
                def test_api_should_accept_http_basic_auth_using_username_and_password
                  user = User.generate! do |user|
                    user.password = 'my_password'
                  end
                  get '/users/current.xml', {}, credentials(user.login, 'my_password')
                  assert_response 200
                  assert_equal user, User.current
                end
                def test_api_should_deny_http_basic_auth_using_username_and_wrong_password
                  user = User.generate! do |user|
                    user.password = 'my_password'
                  end
                  get '/users/current.xml', {}, credentials(user.login, 'wrong_password')
                  assert_response 401
                  assert_equal User.anonymous, User.current
                end
                def test_api_should_accept_http_basic_auth_using_api_key
                  user = User.generate!
                  token = Token.create!(:user => user, :action => 'api')
                  get '/users/current.xml', {}, credentials(token.value, 'X')
                  assert_response 200
                  assert_equal user, User.current
                end
                def test_api_should_deny_http_basic_auth_using_wrong_api_key
                  user = User.generate!
                  token = Token.create!(:user => user, :action => 'feeds') # not the API key
                  get '/users/current.xml', {}, credentials(token.value, 'X')
                  assert_response 401
                  assert_equal User.anonymous, User.current
                end
                def test_api_should_accept_auth_using_api_key_as_parameter
                  user = User.generate!
                  token = Token.create!(:user => user, :action => 'api')
                  get "/users/current.xml?key=#{token.value}", {}
                  assert_response 200
                  assert_equal user, User.current
                end
                def test_api_should_deny_auth_using_wrong_api_key_as_parameter
                  user = User.generate!
                  token = Token.create!(:user => user, :action => 'feeds') # not the API key
                  get "/users/current.xml?key=#{token.value}", {}
                  assert_response 401
                  assert_equal User.anonymous, User.current
                end
                def test_api_should_accept_auth_using_api_key_as_request_header
                  user = User.generate!
                  token = Token.create!(:user => user, :action => 'api')
                  get "/users/current.xml", {}, {'X-Redmine-API-Key' => token.value.to_s}
                  assert_response 200
                  assert_equal user, User.current
                end
                def test_api_should_deny_auth_using_wrong_api_key_as_request_header
                  user = User.generate!
                  token = Token.create!(:user => user, :action => 'feeds') # not the API key
                  get "/users/current.xml", {}, {'X-Redmine-API-Key' => token.value.to_s}
                  assert_response 401
                  assert_equal User.anonymous, User.current
                end
                def test_api_should_trigger_basic_http_auth_with_basic_authorization_header
                  ApplicationController.any_instance.expects(:authenticate_with_http_basic).once
                  get '/users/current.xml', {}, credentials('jsmith')
                  assert_response 401
                end
                def test_api_should_not_trigger_basic_http_auth_with_non_basic_authorization_header
                  ApplicationController.any_instance.expects(:authenticate_with_http_basic).never
                  get '/users/current.xml', {}, 'HTTP_AUTHORIZATION' => 'Digest foo bar'
                  assert_response 401
                end
                def test_invalid_utf8_credentials_should_not_trigger_an_error
                  invalid_utf8 = "\x82".force_encoding('UTF-8')
                  assert !invalid_utf8.valid_encoding?
                  assert_nothing_raised do
                    get '/users/current.xml', {}, credentials(invalid_utf8, "foo")
                  end
                end
                def test_api_request_should_not_use_user_session
                  log_user('jsmith', 'jsmith')
                  get '/users/current'
                  assert_response :success
                  get '/users/current.json'
                  assert_response 401
                end
                def test_api_should_accept_switch_user_header_for_admin_user
                  user = User.find(1)
                  su = User.find(4)
                  get '/users/current', {}, {'X-Redmine-API-Key' => user.api_key, 'X-Redmine-Switch-User' => su.login}
                  assert_response :success
                  assert_equal su, assigns(:user)
                  assert_equal su, User.current
                end
                def test_api_should_respond_with_412_when_trying_to_switch_to_a_invalid_user
                  get '/users/current', {}, {'X-Redmine-API-Key' => User.find(1).api_key, 'X-Redmine-Switch-User' => 'foobar'}
                  assert_response 412
                end
                def test_api_should_respond_with_412_when_trying_to_switch_to_a_locked_user
                  user = User.find(5)
                  assert user.locked?
                  get '/users/current', {}, {'X-Redmine-API-Key' => User.find(1).api_key, 'X-Redmine-Switch-User' => user.login}
                  assert_response 412
                end
                def test_api_should_not_accept_switch_user_header_for_non_admin_user
                  user = User.find(2)
                  su = User.find(4)
                  get '/users/current', {}, {'X-Redmine-API-Key' => user.api_key, 'X-Redmine-Switch-User' => su.login}
                  assert_response :success
                  assert_equal user, assigns(:user)
                  assert_equal user, User.current
                end
              end

test/integration/api_test/custom_fields_attribute_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::CustomFieldsAttributeTest < Redmine::ApiTest::Base
                fixtures :users
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                def test_integer_custom_fields_should_accept_strings
                  field = GroupCustomField.generate!(:field_format => 'int')
                  post '/groups.json', %({"group":{"name":"Foo","custom_field_values":{"#{field.id}":"52"}}}),
                    {'CONTENT_TYPE' => 'application/json'}.merge(credentials('admin'))
                  assert_response :created
                  group = Group.order('id DESC').first
                  assert_equal "52", group.custom_field_value(field)
                end
                def test_integer_custom_fields_should_accept_integers
                  field = GroupCustomField.generate!(:field_format => 'int')
                  post '/groups.json', %({"group":{"name":"Foo","custom_field_values":{"#{field.id}":52}}}),
                    {'CONTENT_TYPE' => 'application/json'}.merge(credentials('admin'))
                  assert_response :created
                  group = Group.order('id DESC').first
                  assert_equal "52", group.custom_field_value(field)
                end
              end

test/integration/api_test/custom_fields_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::CustomFieldsTest < Redmine::ApiTest::Base
                fixtures :users, :custom_fields
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /custom_fields.xml should return custom fields" do
                  get '/custom_fields.xml', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'custom_fields' do
                    assert_select 'custom_field' do
                      assert_select 'name', :text => 'Database'
                      assert_select 'id', :text => '2'
                      assert_select 'customized_type', :text => 'issue'
                      assert_select 'possible_values[type=array]' do
                        assert_select 'possible_value>value', :text => 'PostgreSQL'
                      end
                      assert_select 'trackers[type=array]'
                      assert_select 'roles[type=array]'
                    end
                  end
                end
              end

test/integration/api_test/enumerations_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::EnumerationsTest < Redmine::ApiTest::Base
                fixtures :enumerations
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /enumerations/issue_priorities.xml should return priorities" do
                  get '/enumerations/issue_priorities.xml'
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'issue_priorities[type=array]' do
                    assert_select 'issue_priority' do
                      assert_select 'id', :text => '6'
                      assert_select 'name', :text => 'High'
                    end
                  end
                end
              end

test/integration/api_test/groups_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::GroupsTest < Redmine::ApiTest::Base
                fixtures :users, :groups_users
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /groups.xml should require authentication" do
                  get '/groups.xml'
                  assert_response 401
                end
                test "GET /groups.xml should return givable groups" do
                  get '/groups.xml', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'groups' do
                    assert_select 'group', Group.givable.count
                    assert_select 'group' do
                      assert_select 'name', :text => 'A Team'
                      assert_select 'id', :text => '10'
                    end
                  end
                end
                test "GET /groups.xml?builtin=1 should return all groups" do
                  get '/groups.xml?builtin=1', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'groups' do
                    assert_select 'group', Group.givable.count + 2
                    assert_select 'group' do
                      assert_select 'builtin', :text => 'non_member'
                      assert_select 'id', :text => '12'
                    end
                    assert_select 'group' do
                      assert_select 'builtin', :text => 'anonymous'
                      assert_select 'id', :text => '13'
                    end
                  end
                end
                test "GET /groups.json should require authentication" do
                  get '/groups.json'
                  assert_response 401
                end
                test "GET /groups.json should return groups" do
                  get '/groups.json', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/json', response.content_type
                  json = MultiJson.load(response.body)
                  groups = json['groups']
                  assert_kind_of Array, groups
                  group = groups.detect {|g| g['name'] == 'A Team'}
                  assert_not_nil group
                  assert_equal({'id' => 10, 'name' => 'A Team'}, group)
                end
                test "GET /groups/:id.xml should return the group" do
                  get '/groups/10.xml', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'group' do
                    assert_select 'name', :text => 'A Team'
                    assert_select 'id', :text => '10'
                  end
                end
                test "GET /groups/:id.xml should return the builtin group" do
                  get '/groups/12.xml', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'group' do
                    assert_select 'builtin', :text => 'non_member'
                    assert_select 'id', :text => '12'
                  end
                end
                test "GET /groups/:id.xml should include users if requested" do
                  get '/groups/10.xml?include=users', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'group' do
                    assert_select 'users' do
                      assert_select 'user', Group.find(10).users.count
                      assert_select 'user[id=8]'
                    end
                  end
                end
                test "GET /groups/:id.xml include memberships if requested" do
                  get '/groups/10.xml?include=memberships', {}, credentials('admin')
                  assert_response :success
                  assert_equal 'application/xml', response.content_type
                  assert_select 'group' do
                    assert_select 'memberships'
                  end
                end
                test "POST /groups.xml with valid parameters should create the group" do
                  assert_difference('Group.count') do
                    post '/groups.xml', {:group => {:name => 'Test', :user_ids => [2, 3]}}, credentials('admin')
                    assert_response :created
                    assert_equal 'application/xml', response.content_type
                  end
                  group = Group.order('id DESC').first
                  assert_equal 'Test', group.name
                  assert_equal [2, 3], group.users.map(&:id).sort
                  assert_select 'group' do
                    assert_select 'name', :text => 'Test'
                  end
                end
                test "POST /groups.xml with invalid parameters should return errors" do
                  assert_no_difference('Group.count') do
                    post '/groups.xml', {:group => {:name => ''}}, credentials('admin')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', response.content_type
                  assert_select 'errors' do
                    assert_select 'error', :text => /Name can't be blank/
                  end
                end
                test "PUT /groups/:id.xml with valid parameters should update the group" do
                  put '/groups/10.xml', {:group => {:name => 'New name', :user_ids => [2, 3]}}, credentials('admin')
                  assert_response :ok
                  assert_equal '', @response.body
                  group = Group.find(10)
                  assert_equal 'New name', group.name
                  assert_equal [2, 3], group.users.map(&:id).sort
                end
                test "PUT /groups/:id.xml with invalid parameters should return errors" do
                  put '/groups/10.xml', {:group => {:name => ''}}, credentials('admin')
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', response.content_type
                  assert_select 'errors' do
                    assert_select 'error', :text => /Name can't be blank/
                  end
                end
                test "DELETE /groups/:id.xml should delete the group" do
                  assert_difference 'Group.count', -1 do
                    delete '/groups/10.xml', {}, credentials('admin')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                end
                test "POST /groups/:id/users.xml should add user to the group" do
                  assert_difference 'Group.find(10).users.count' do
                    post '/groups/10/users.xml', {:user_id => 5}, credentials('admin')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                  assert_include User.find(5), Group.find(10).users
                end
                test "DELETE /groups/:id/users/:user_id.xml should remove user from the group" do
                  assert_difference 'Group.find(10).users.count', -1 do
                    delete '/groups/10/users/8.xml', {}, credentials('admin')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                  assert_not_include User.find(8), Group.find(10).users
                end
              end

test/integration/api_test/issue_categories_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::IssueCategoriesTest < Redmine::ApiTest::Base
                fixtures :projects, :users, :issue_categories, :issues,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /projects/:project_id/issue_categories.xml should return the issue categories" do
                  get '/projects/1/issue_categories.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue_categories issue_category id', :text => '2'
                end
                test "GET /issue_categories/:id.xml should return the issue category" do
                  get '/issue_categories/2.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue_category id', :text => '2'
                end
                test "POST /projects/:project_id/issue_categories.xml should return create issue category" do
                  assert_difference 'IssueCategory.count' do
                    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.order('id DESC').first
                  assert_equal 'API', category.name
                  assert_equal 1, category.project_id
                end
                test "POST /projects/:project_id/issue_categories.xml with invalid parameters should return errors" do
                  assert_no_difference 'IssueCategory.count' do
                    post '/projects/1/issue_categories.xml', {:issue_category => {:name => ''}}, credentials('jsmith')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Name can't be blank"
                end
                test "PUT /issue_categories/:id.xml with valid parameters should update the issue category" do
                  assert_no_difference 'IssueCategory.count' do
                    put '/issue_categories/2.xml', {:issue_category => {:name => 'API Update'}}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_equal 'API Update', IssueCategory.find(2).name
                end
                test "PUT /issue_categories/:id.xml with invalid parameters should return errors" do
                  assert_no_difference 'IssueCategory.count' do
                    put '/issue_categories/2.xml', {:issue_category => {:name => ''}}, credentials('jsmith')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Name can't be blank"
                end
                test "DELETE /issue_categories/:id.xml should destroy the issue category" do
                  assert_difference 'IssueCategory.count', -1 do
                    delete '/issue_categories/1.xml', {}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_nil IssueCategory.find_by_id(1)
                end
                test "DELETE /issue_categories/:id.xml should reassign issues with :reassign_to_id param" do
                  issue_count = Issue.where(:category_id => 1).count
                  assert issue_count > 0
                  assert_difference 'IssueCategory.count', -1 do
                    assert_difference 'Issue.where(:category_id => 2).count', 3 do
                      delete '/issue_categories/1.xml', {:reassign_to_id => 2}, credentials('jsmith')
                    end
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_nil IssueCategory.find_by_id(1)
                end
              end

test/integration/api_test/issue_relations_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::IssueRelationsTest < Redmine::ApiTest::Base
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :issue_relations
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /issues/:issue_id/relations.xml should return issue relations" do
                  get '/issues/9/relations.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'relations[type=array] relation id', :text => '1'
                end
                test "POST /issues/:issue_id/relations.xml should create the relation" do
                  assert_difference('IssueRelation.count') do
                    post '/issues/2/relations.xml', {:relation => {:issue_to_id => 7, :relation_type => 'relates'}}, credentials('jsmith')
                  end
                  relation = IssueRelation.order('id DESC').first
                  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_select 'relation id', :text => relation.id.to_s
                end
                test "POST /issues/:issue_id/relations.xml with failure should return errors" do
                  assert_no_difference('IssueRelation.count') do
                    post '/issues/2/relations.xml', {:relation => {:issue_to_id => 7, :relation_type => 'foo'}}, credentials('jsmith')
                  end
                  assert_response :unprocessable_entity
                  assert_select 'errors error', :text => /relation_type is not included in the list/
                end
                test "GET /relations/:id.xml should return the relation" do
                  get '/relations/2.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'relation id', :text => '2'
                end
                test "DELETE /relations/:id.xml should delete the relation" do
                  assert_difference('IssueRelation.count', -1) do
                    delete '/relations/2.xml', {}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_nil IssueRelation.find_by_id(2)
                end
              end

test/integration/api_test/issue_statuses_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::IssueStatusesTest < Redmine::ApiTest::Base
                fixtures :issue_statuses
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /issue_statuses.xml should return issue statuses" do
                  get '/issue_statuses.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue_statuses[type=array] issue_status id:content(2)' do
                    assert_select '~ name', :text => 'Assigned'
                  end
                end
              end

test/integration/api_test/issues_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::IssuesTest < Redmine::ApiTest::Base
                fixtures :projects,
                  :users,
                  :roles,
                  :members,
                  :member_roles,
                  :issues,
                  :issue_statuses,
                  :issue_relations,
                  :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
                test "GET /issues.xml should contain metadata" do
                  get '/issues.xml'
                  assert_select 'issues[type=array][total_count=?][limit="25"][offset="0"]',
                    assigns(:issue_count).to_s
                end
                test "GET /issues.xml with nometa param should not contain metadata" do
                  get '/issues.xml?nometa=1'
                  assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
                end
                test "GET /issues.xml with nometa header should not contain metadata" do
                  get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
                  assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
                end
                test "GET /issues.xml with offset and limit" do
                  get '/issues.xml?offset=2&limit=3'
                  assert_equal 3, assigns(:limit)
                  assert_equal 2, assigns(:offset)
                  assert_select 'issues issue', 3
                end
                test "GET /issues.xml with relations" do
                  get '/issues.xml?include=relations'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue id:content(3)' do
                    assert_select '~ relations relation', 1
                    assert_select '~ relations relation[id="2"][issue_id="2"][issue_to_id="3"][relation_type=relates]'
                  end
                  assert_select 'issue id:content(1)' do
                    assert_select '~ relations'
                    assert_select '~ relations relation', 0
                  end
                end
                test "GET /issues.xml with invalid query params" do
                  get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Start date can't be blank"
                end
                test "GET /issues.xml with custom field filter" do
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='}, :v => {:cf_1 => ['MySQL']}}
                  expected_ids = Issue.visible.
                      joins(:custom_values).
                      where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                  assert expected_ids.any?
                  assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                     ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  end
                end
                test "GET /issues.xml with custom field filter (shorthand method)" do
                  get '/issues.xml', {:cf_1 => 'MySQL'}
                  expected_ids = Issue.visible.
                      joins(:custom_values).
                      where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                  assert expected_ids.any?
                  assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                    ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  end
                end
                def test_index_should_include_issue_attributes
                  get '/issues.xml'
                  assert_select 'issues>issue>is_private', :text => 'false'
                end
                def test_index_should_allow_timestamp_filtering
                  Issue.delete_all
                  Issue.generate!(:subject => '1').update_column(:updated_on, Time.parse("2014-01-02T10:25:00Z"))
                  Issue.generate!(:subject => '2').update_column(:updated_on, Time.parse("2014-01-02T12:13:00Z"))
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '<='},
                     :v => {:updated_on => ['2014-01-02T12:00:00Z']}}
                  assert_select 'issues>issue', :count => 1
                  assert_select 'issues>issue>subject', :text => '1'
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
                     :v => {:updated_on => ['2014-01-02T12:00:00Z']}}
                  assert_select 'issues>issue', :count => 1
                  assert_select 'issues>issue>subject', :text => '2'
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
                     :v => {:updated_on => ['2014-01-02T08:00:00Z']}}
                  assert_select 'issues>issue', :count => 2
                end
                test "GET /issues.xml with filter" do
                  get '/issues.xml?status_id=5'
                  expected_ids = Issue.visible.where(:status_id => 5).map(&:id)
                  assert expected_ids.any?
                  assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                     ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  end
                end
                test "GET /issues.json with filter" 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
                test "GET /issues/:id.xml with journals" do
                  get '/issues/1.xml?include=journals'
                  assert_select 'issue journals[type=array]' do
                    assert_select 'journal[id="1"]' do
                      assert_select 'details[type=array]' do
                        assert_select 'detail[name=status_id]' do
                          assert_select 'old_value', :text => '1'
                          assert_select 'new_value', :text => '2'
                        end
                      end
                    end
                  end
                end
                test "GET /issues/:id.xml with custom fields" do
                  get '/issues/3.xml'
                  assert_select 'issue custom_fields[type=array]' do
                    assert_select 'custom_field[id="1"]' do
                      assert_select 'value', :text => 'MySQL'
                    end
                  end
                  assert_nothing_raised do
                    Hash.from_xml(response.body).to_xml
                  end
                end
                test "GET /issues/:id.xml with multi custom fields" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                  issue.save!
                  get '/issues/3.xml'
                  assert_response :success
                  assert_select 'issue custom_fields[type=array]' do
                    assert_select 'custom_field[id="1"]' do
                      assert_select 'value[type=array] value', 2
                    end
                  end
                  xml = Hash.from_xml(response.body)
                  custom_fields = xml['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == '1'}
                  assert_kind_of Hash, field
                  assert_equal ['MySQL', 'Oracle'], field['value'].sort
                end
                test "GET /issues/:id.json with multi custom fields" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                  issue.save!
                  get '/issues/3.json'
                  assert_response :success
                  json = ActiveSupport::JSON.decode(response.body)
                  custom_fields = json['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == 1}
                  assert_kind_of Hash, field
                  assert_equal ['MySQL', 'Oracle'], field['value'].sort
                end
                test "GET /issues/:id.xml with empty value for multi custom field" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['']}
                  issue.save!
                  get '/issues/3.xml'
                  assert_select 'issue custom_fields[type=array]' do
                    assert_select 'custom_field[id="1"]' do
                      assert_select 'value[type=array]:empty'
                    end
                  end
                  xml = Hash.from_xml(response.body)
                  custom_fields = xml['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == '1'}
                  assert_kind_of Hash, field
                  assert_equal [], field['value']
                end
                test "GET /issues/:id.json with empty value for multi custom field" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['']}
                  issue.save!
                  get '/issues/3.json'
                  assert_response :success
                  json = ActiveSupport::JSON.decode(response.body)
                  custom_fields = json['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == 1}
                  assert_kind_of Hash, field
                  assert_equal [], field['value'].sort
                end
                test "GET /issues/:id.xml with attachments" do
                  get '/issues/3.xml?include=attachments'
                  assert_select 'issue attachments[type=array]' do
                    assert_select 'attachment', 5
                    assert_select 'attachment id:content(4)' do
                      assert_select '~ filename', :text => 'source.rb'
                      assert_select '~ content_url', :text => 'http://www.example.com/attachments/download/4/source.rb'
                    end
                  end
                end
                test "GET /issues/:id.xml with subtasks" do
                  issue = Issue.generate_with_descendants!(:project_id => 1)
                  get "/issues/#{issue.id}.xml?include=children"
                  assert_select 'issue children[type=array]' do
                    assert_select 'issue', 2
                    assert_select 'issue children', 1
                  end
                end
                test "GET /issues/:id.json with subtasks" do
                  issue = Issue.generate_with_descendants!(:project_id => 1)
                  get "/issues/#{issue.id}.json?include=children"
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_equal 2, json['issue']['children'].size
                  assert_equal 1, json['issue']['children'].select {|child| child.key?('children')}.size
                end
                def test_show_should_include_issue_attributes
                  get '/issues/1.xml'
                  assert_select 'issue>is_private', :text => 'false'
                end
                test "GET /issues/:id.xml?include=watchers should include watchers" do
                  Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                  get '/issues/1.xml?include=watchers', {}, credentials('jsmith')
                  assert_response :ok
                  assert_equal 'application/xml', response.content_type
                  assert_select 'issue' do
                    assert_select 'watchers', Issue.find(1).watchers.count
                    assert_select 'watchers' do
                      assert_select 'user[id=3]'
                    end
                  end
                end
                test "POST /issues.xml 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}}, credentials('jsmith')
                  end
                  issue = Issue.order('id DESC').first
                  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_select 'issue > id', :text => issue.id.to_s
                end
                test "POST /issues.xml with watcher_user_ids should create issue with watchers" do
                  assert_difference('Issue.count') do
                    post '/issues.xml',
                         {:issue => {:project_id => 1, :subject => 'Watchers',
                          :tracker_id => 2, :status_id => 3, :watcher_user_ids => [3, 1]}}, credentials('jsmith')
                    assert_response :created
                  end
                  issue = Issue.order('id desc').first
                  assert_equal 2, issue.watchers.size
                  assert_equal [1, 3], issue.watcher_user_ids.sort
                end
                test "POST /issues.xml with failure should return errors" do
                  assert_no_difference('Issue.count') do
                    post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
                  end
                  assert_select 'errors error', :text => "Subject can't be blank"
                end
                test "POST /issues.json should create an issue with the attributes" do
                  assert_difference('Issue.count') do
                    post '/issues.json',
                         {:issue => {:project_id => 1, :subject => 'API test',
                                     :tracker_id => 2, :status_id => 3}},
                         credentials('jsmith')
                  end
                  issue = Issue.order('id DESC').first
                  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
                test "POST /issues.json with failure should return errors" do
                  assert_no_difference('Issue.count') do
                    post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')
                  end
                  json = ActiveSupport::JSON.decode(response.body)
                  assert json['errors'].include?("Subject can't be blank")
                end
                test "PUT /issues/:id.xml" do
                  assert_difference('Journal.count') do
                    put '/issues/6.xml',
                      {:issue => {:subject => 'API update', :notes => 'A new note'}},
                      credentials('jsmith')
                  end
                  issue = Issue.find(6)
                  assert_equal "API update", issue.subject
                  journal = Journal.last
                  assert_equal "A new note", journal.notes
                end
                test "PUT /issues/:id.xml with custom fields" do
                  put '/issues/3.xml',
                    {:issue => {:custom_fields => [
                      {'id' => '1', 'value' => 'PostgreSQL' },
                      {'id' => '2', 'value' => '150'}
                      ]}},
                    credentials('jsmith')
                  issue = Issue.find(3)
                  assert_equal '150', issue.custom_value_for(2).value
                  assert_equal 'PostgreSQL', issue.custom_value_for(1).value
                end
                test "PUT /issues/:id.xml with multi custom fields" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  put '/issues/3.xml',
                    {:issue => {:custom_fields => [
                      {'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
                      {'id' => '2', 'value' => '150'}
                      ]}},
                    credentials('jsmith')
                  issue = Issue.find(3)
                  assert_equal '150', issue.custom_value_for(2).value
                  assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
                end
                test "PUT /issues/:id.xml with project change" do
                  put '/issues/3.xml',
                    {:issue => {:project_id => 2, :subject => 'Project changed'}},
                    credentials('jsmith')
                  issue = Issue.find(3)
                  assert_equal 2, issue.project_id
                  assert_equal 'Project changed', issue.subject
                end
                test "PUT /issues/:id.xml with failed update" do
                  put '/issues/6.xml', {:issue => {:subject => ''}}, credentials('jsmith')
                  assert_response :unprocessable_entity
                  assert_select 'errors error', :text => "Subject can't be blank"
                end
                test "PUT /issues/:id.json" do
                  assert_difference('Journal.count') do
                    put '/issues/6.json',
                      {:issue => {:subject => 'API update', :notes => 'A new note'}},
                      credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  issue = Issue.find(6)
                  assert_equal "API update", issue.subject
                  journal = Journal.last
                  assert_equal "A new note", journal.notes
                end
                test "PUT /issues/:id.json with failed update" do
                  put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')
                  assert_response :unprocessable_entity
                  json = ActiveSupport::JSON.decode(response.body)
                  assert json['errors'].include?("Subject can't be blank")
                end
                test "DELETE /issues/:id.xml" do
                  assert_difference('Issue.count', -1) do
                    delete '/issues/6.xml', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  assert_nil Issue.find_by_id(6)
                end
                test "DELETE /issues/:id.json" do
                  assert_difference('Issue.count', -1) do
                    delete '/issues/6.json', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  assert_nil Issue.find_by_id(6)
                end
                test "POST /issues/:id/watchers.xml should add watcher" do
                  assert_difference 'Watcher.count' do
                    post '/issues/1/watchers.xml', {:user_id => 3}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  watcher = Watcher.order('id desc').first
                  assert_equal Issue.find(1), watcher.watchable
                  assert_equal User.find(3), watcher.user
                end
                test "DELETE /issues/:id/watchers/:user_id.xml should remove watcher" do
                  Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                  assert_difference 'Watcher.count', -1 do
                    delete '/issues/1/watchers/3.xml', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  assert_equal false, Issue.find(1).watched_by?(User.find(3))
                end
                def test_create_issue_with_uploaded_file
                  set_tmp_attachments_directory
                  # upload the file
                  assert_difference 'Attachment.count' do
                    post '/uploads.xml', 'test_create_with_upload',
                         {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                    assert_response :created
                  end
                  xml = Hash.from_xml(response.body)
                  token = xml['upload']['token']
                  attachment = Attachment.order('id DESC').first
                  # create the issue with the upload's token
                  assert_difference 'Issue.count' do
                    post '/issues.xml',
                         {:issue => {:project_id => 1, :subject => 'Uploaded file',
                                     :uploads => [{:token => token, :filename => 'test.txt',
                                                   :content_type => 'text/plain'}]}},
                         credentials('jsmith')
                    assert_response :created
                  end
                  issue = Issue.order('id DESC').first
                  assert_equal 1, issue.attachments.count
                  assert_equal attachment, issue.attachments.first
                  attachment.reload
                  assert_equal 'test.txt', attachment.filename
                  assert_equal 'text/plain', attachment.content_type
                  assert_equal 'test_create_with_upload'.size, attachment.filesize
                  assert_equal 2, attachment.author_id
                  # get the issue with its attachments
                  get "/issues/#{issue.id}.xml", :include => 'attachments'
                  assert_response :success
                  xml = Hash.from_xml(response.body)
                  attachments = xml['issue']['attachments']
                  assert_kind_of Array, attachments
                  assert_equal 1, attachments.size
                  url = attachments.first['content_url']
                  assert_not_nil url
                  # download the attachment
                  get url
                  assert_response :success
                end
                def test_update_issue_with_uploaded_file
                  set_tmp_attachments_directory
                  # upload the file
                  assert_difference 'Attachment.count' do
                    post '/uploads.xml', 'test_upload_with_upload',
                         {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                    assert_response :created
                  end
                  xml = Hash.from_xml(response.body)
                  token = xml['upload']['token']
                  attachment = Attachment.order('id DESC').first
                  # update the issue with the upload's token
                  assert_difference 'Journal.count' do
                    put '/issues/1.xml',
                        {:issue => {:notes => 'Attachment added',
                                    :uploads => [{:token => token, :filename => 'test.txt',
                                                  :content_type => 'text/plain'}]}},
                        credentials('jsmith')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                  issue = Issue.find(1)
                  assert_include attachment, issue.attachments
                end
              end

test/integration/api_test/memberships_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::MembershipsTest < Redmine::ApiTest::Base
                fixtures :projects, :users, :roles, :members, :member_roles
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /projects/:project_id/memberships.xml should return memberships" do
                  get '/projects/1/memberships.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'memberships[type=array] membership id:content(2)' do
                    assert_select '~ user[id=3][name=Dave Lopper]'
                    assert_select '~ roles role[id=2][name=Developer]'
                  end
                end
                test "GET /projects/:project_id/memberships.json should return memberships" do
                  get '/projects/1/memberships.json', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/json', @response.content_type
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_equal({
                    "memberships" =>
                      [{"id"=>1,
                        "project" => {"name"=>"eCookbook", "id"=>1},
                        "roles" => [{"name"=>"Manager", "id"=>1}],
                        "user" => {"name"=>"John Smith", "id"=>2}},
                       {"id"=>2,
                        "project" => {"name"=>"eCookbook", "id"=>1},
                        "roles" => [{"name"=>"Developer", "id"=>2}],
                        "user" => {"name"=>"Dave Lopper", "id"=>3}}],
                   "limit" => 25,
                   "total_count" => 2,
                   "offset" => 0},
                   json)
                end
                test "GET /projects/:project_id/memberships.xml should succeed for closed project" do
                  project = Project.find(1)
                  project.close
                  assert !project.reload.active?
                  get '/projects/1/memberships.json', {}, credentials('jsmith')
                  assert_response :success
                end
                test "POST /projects/:project_id/memberships.xml should create the membership" do
                  assert_difference 'Member.count' do
                    post '/projects/1/memberships.xml', {:membership => {:user_id => 7, :role_ids => [2,3]}}, credentials('jsmith')
                    assert_response :created
                  end
                end
                test "POST /projects/:project_id/memberships.xml should create the group membership" do
                  group = Group.find(11)
                  assert_difference 'Member.count', 1 + group.users.count do
                    post '/projects/1/memberships.xml', {:membership => {:user_id => 11, :role_ids => [2,3]}}, credentials('jsmith')
                    assert_response :created
                  end
                end
                test "POST /projects/:project_id/memberships.xml with invalid parameters should return errors" do
                  assert_no_difference 'Member.count' do
                    post '/projects/1/memberships.xml', {:membership => {:role_ids => [2,3]}}, credentials('jsmith')
                    assert_response :unprocessable_entity
                    assert_equal 'application/xml', @response.content_type
                    assert_select 'errors error', :text => "Principal can't be blank"
                  end
                end
                test "GET /memberships/:id.xml should return the membership" do
                  get '/memberships/2.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'membership id:content(2)' do
                    assert_select '~ user[id=3][name=Dave Lopper]'
                    assert_select '~ roles role[id=2][name=Developer]'
                  end
                end
                test "GET /memberships/:id.json should return the membership" do
                  get '/memberships/2.json', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/json', @response.content_type
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_equal(
                    {"membership" => {
                      "id" => 2,
                      "project" => {"name"=>"eCookbook", "id"=>1},
                      "roles" => [{"name"=>"Developer", "id"=>2}],
                      "user" => {"name"=>"Dave Lopper", "id"=>3}}
                    },
                    json)
                end
                test "PUT /memberships/:id.xml should update the membership" do
                  assert_not_equal [1,2], Member.find(2).role_ids.sort
                  assert_no_difference 'Member.count' do
                    put '/memberships/2.xml', {:membership => {:user_id => 3, :role_ids => [1,2]}}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                  member = Member.find(2)
                  assert_equal [1,2], member.role_ids.sort
                end
                test "PUT /memberships/:id.xml with invalid parameters should return errors" do
                  put '/memberships/2.xml', {:membership => {:user_id => 3, :role_ids => [99]}}, credentials('jsmith')
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Role can't be empty"
                end
                test "DELETE /memberships/:id.xml should destroy the membership" do
                  assert_difference 'Member.count', -1 do
                    delete '/memberships/2.xml', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                  assert_nil Member.find_by_id(2)
                end
                test "DELETE /memberships/:id.xml should respond with 422 on failure" do
                  assert_no_difference 'Member.count' do
                    # A membership with an inherited role can't be deleted
                    Member.find(2).member_roles.first.update_attribute :inherited_from, 99
                    delete '/memberships/2.xml', {}, credentials('jsmith')
                    assert_response :unprocessable_entity
                  end
                end
              end

test/integration/api_test/news_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::NewsTest < Redmine::ApiTest::Base
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :news
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /news.xml should return news" do
                  get '/news.xml'
                  assert_select 'news[type=array] news id', :text => '2'
                end
                test "GET /news.json should return news" do
                  get '/news.json'
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Hash, json
                  assert_kind_of Array, json['news']
                  assert_kind_of Hash, json['news'].first
                  assert_equal 2, json['news'].first['id']
                end
                test "GET /projects/:project_id/news.xml should return news" do
                  get '/projects/ecookbook/news.xml'
                  assert_select 'news[type=array] news id', :text => '2'
                end
                test "GET /projects/:project_id/news.json should return news" do
                  get '/projects/ecookbook/news.json'
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Hash, json
                  assert_kind_of Array, json['news']
                  assert_kind_of Hash, json['news'].first
                  assert_equal 2, json['news'].first['id']
                end
              end

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

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::ProjectsTest < Redmine::ApiTest::Base
                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'
+                 super
                  set_tmp_attachments_directory
                end
                test "GET /projects.xml should return projects" do
                  get '/projects.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'projects>project>id', :text => '1'
                  assert_select 'projects>project>status', :text => '1'
                  assert_select 'projects>project>is_public', :text => 'true'
                end
                test "GET /projects.json 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
                test "GET /projects.xml with include=issue_categories should return categories" do
                  get '/projects.xml?include=issue_categories'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue_categories[type=array] issue_category[id=2][name=Recipes]'
                end
                test "GET /projects.xml with include=trackers should return trackers" do
                  get '/projects.xml?include=trackers'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'trackers[type=array] tracker[id=2][name=Feature request]'
                end
                test "GET /projects.xml with include=enabled_modules should return enabled modules" do
                  get '/projects.xml?include=enabled_modules'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'enabled_modules[type=array] enabled_module[name=issue_tracking]'
                end
                test "GET /projects/:id.xml should return the project" do
                  get '/projects/1.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'project>id', :text => '1'
                  assert_select 'project>status', :text => '1'
                  assert_select 'project>is_public', :text => 'true'
                  assert_select 'custom_field[name=Development status]', :text => 'Stable'
                  assert_select 'trackers', 0
                  assert_select 'issue_categories', 0
                end
                test "GET /projects/:id.json should return the 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
                test "GET /projects/:id.xml with hidden custom fields should not display hidden custom fields" do
                  ProjectCustomField.find_by_name('Development status').update_attribute :visible, false
                  get '/projects/1.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'custom_field[name=?]', 'Development status', 0
                end
                test "GET /projects/:id.xml with include=issue_categories should return categories" do
                  get '/projects/1.xml?include=issue_categories'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue_categories[type=array] issue_category[id=2][name=Recipes]'
                end
                test "GET /projects/:id.xml with include=trackers should return trackers" do
                  get '/projects/1.xml?include=trackers'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'trackers[type=array] tracker[id=2][name=Feature request]'
                end
                test "GET /projects/:id.xml with include=enabled_modules should return enabled modules" do
                  get '/projects/1.xml?include=enabled_modules'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'enabled_modules[type=array] enabled_module[name=issue_tracking]'
                end
                test "POST /projects.xml with valid parameters should create the project" do
                  with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                    assert_difference('Project.count') do
                      post '/projects.xml',
                        {:project => {:name => 'API test', :identifier => 'api-test'}},
                        credentials('admin')
                    end
                  end
                  project = Project.order('id DESC').first
                  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_select 'project id', :text => project.id.to_s
                end
                test "POST /projects.xml should accept enabled_module_names attribute" do
                  assert_difference('Project.count') do
                    post '/projects.xml',
                      {:project => {:name => 'API test', :identifier => 'api-test', :enabled_module_names => ['issue_tracking', 'news', 'time_tracking']}},
                      credentials('admin')
                  end
                  project = Project.order('id DESC').first
                  assert_equal ['issue_tracking', 'news', 'time_tracking'], project.enabled_module_names.sort
                end
                test "POST /projects.xml should accept tracker_ids attribute" do
                  assert_difference('Project.count') do
                    post '/projects.xml',
                      {:project => {:name => 'API test', :identifier => 'api-test', :tracker_ids => [1, 3]}},
                      credentials('admin')
                  end
                  project = Project.order('id DESC').first
                  assert_equal [1, 3], project.trackers.map(&:id).sort
                end
                test "POST /projects.xml with invalid parameters should return errors" do
                  assert_no_difference('Project.count') do
                    post '/projects.xml', {:project => {:name => 'API test'}}, credentials('admin')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Identifier can't be blank"
                end
                test "PUT /projects/:id.xml with valid parameters should update the project" do
                  assert_no_difference 'Project.count' do
                    put '/projects/2.xml', {:project => {:name => 'API update'}}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_equal 'application/xml', @response.content_type
                  project = Project.find(2)
                  assert_equal 'API update', project.name
                end
                test "PUT /projects/:id.xml should accept enabled_module_names attribute" do
                  assert_no_difference 'Project.count' do
                    put '/projects/2.xml', {:project => {:name => 'API update', :enabled_module_names => ['issue_tracking', 'news', 'time_tracking']}}, credentials('admin')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  project = Project.find(2)
                  assert_equal ['issue_tracking', 'news', 'time_tracking'], project.enabled_module_names.sort
                end
                test "PUT /projects/:id.xml should accept tracker_ids attribute" do
                  assert_no_difference 'Project.count' do
                    put '/projects/2.xml', {:project => {:name => 'API update', :tracker_ids => [1, 3]}}, credentials('admin')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  project = Project.find(2)
                  assert_equal [1, 3], project.trackers.map(&:id).sort
                end
                test "PUT /projects/:id.xml with invalid parameters should return errors" do
                  assert_no_difference('Project.count') do
                    put '/projects/2.xml', {:project => {:name => ''}}, credentials('admin')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Name can't be blank"
                end
                test "DELETE /projects/:id.xml should delete the project" do
                  assert_difference('Project.count',-1) do
                    delete '/projects/2.xml', {}, credentials('admin')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_nil Project.find_by_id(2)
                end
              end

test/integration/api_test/queries_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::QueriesTest < Redmine::ApiTest::Base
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :queries
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /queries.xml should return queries" do
                  get '/queries.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'queries[type=array] query id:content(4)' do
                    assert_select '~ name', :text => 'Public query for all projects'
                  end
                end
              end

test/integration/api_test/roles_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::RolesTest < Redmine::ApiTest::Base
                fixtures :roles
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /roles.xml should return the roles" do
                  get '/roles.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_equal 3, assigns(:roles).size
                  assert_select 'roles[type=array] role id:content(2)' do
                    assert_select '~ name', :text => 'Developer'
                  end
                end
                test "GET /roles.json should return the roles" do
                  get '/roles.json'
                  assert_response :success
                  assert_equal 'application/json', @response.content_type
                  assert_equal 3, assigns(:roles).size
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Hash, json
                  assert_kind_of Array, json['roles']
                  assert_include({'id' => 2, 'name' => 'Developer'}, json['roles'])
                end
                test "GET /roles/:id.xml should return the role" do
                  get '/roles/1.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'role' do
                    assert_select 'name', :text => 'Manager'
                    assert_select 'role permissions[type=array]' do
                      assert_select 'permission', Role.find(1).permissions.size
                      assert_select 'permission', :text => 'view_issues'
                    end
                  end
                end
              end

test/integration/api_test/time_entries_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::TimeEntriesTest < Redmine::ApiTest::Base
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :time_entries
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /time_entries.xml should return time entries" do
                  get '/time_entries.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'time_entries[type=array] time_entry id', :text => '2'
                end
                test "GET /time_entries.xml with limit should return limited results" do
                  get '/time_entries.xml?limit=2', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'time_entries[type=array] time_entry', 2
                end
                test "GET /time_entries/:id.xml should return the time entry" do
                  get '/time_entries/2.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'time_entry id', :text => '2'
                end
                test "POST /time_entries.xml with issue_id should 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'}}, credentials('jsmith')
                  end
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  entry = TimeEntry.order('id DESC').first
                  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
                test "POST /time_entries.xml with issue_id should accept custom fields" do
                  field = TimeEntryCustomField.create!(:name => 'Test', :field_format => 'string')
                  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', :custom_fields => [{:id => field.id.to_s, :value => 'accepted'}]
                    }}, credentials('jsmith')
                  end
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  entry = TimeEntry.order('id DESC').first
                  assert_equal 'accepted', entry.custom_field_value(field)
                end
                test "POST /time_entries.xml with project_id should 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'}}, credentials('jsmith')
                  end
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  entry = TimeEntry.order('id DESC').first
                  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
                test "POST /time_entries.xml with invalid parameters 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'}}, credentials('jsmith')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Hours can't be blank"
                end
                test "PUT /time_entries/:id.xml with valid parameters should update time entry" do
                  assert_no_difference 'TimeEntry.count' do
                    put '/time_entries/2.xml', {:time_entry => {:comments => 'API Update'}}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_equal 'API Update', TimeEntry.find(2).comments
                end
                test "PUT /time_entries/:id.xml with invalid parameters should return errors" do
                  assert_no_difference 'TimeEntry.count' do
                    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_select 'errors error', :text => "Hours can't be blank"
                end
                test "DELETE /time_entries/:id.xml should destroy time entry" do
                  assert_difference 'TimeEntry.count', -1 do
                    delete '/time_entries/2.xml', {}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_nil TimeEntry.find_by_id(2)
                end
              end

test/integration/api_test/trackers_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::TrackersTest < Redmine::ApiTest::Base
                fixtures :trackers
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /trackers.xml should return trackers" do
                  get '/trackers.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'trackers[type=array] tracker id:content(2)' do
                    assert_select '~ name', :text => 'Feature request'
                  end
                end
              end

test/integration/api_test/users_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
                fixtures :users, :members, :member_roles, :roles, :projects
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /users/:id.xml should return the user" do
                  get '/users/2.xml'
                  assert_response :success
                  assert_select 'user id', :text => '2'
                end
                test "GET /users/:id.json should return the user" do
                  get '/users/2.json'
                  assert_response :success
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Hash, json
                  assert_kind_of Hash, json['user']
                  assert_equal 2, json['user']['id']
                end
                test "GET /users/:id.xml with include=memberships should include memberships" do
                  get '/users/2.xml?include=memberships'
                  assert_response :success
                  assert_select 'user memberships', 1
                end
                test "GET /users/:id.json with include=memberships should include memberships" do
                  get '/users/2.json?include=memberships'
                  assert_response :success
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Array, json['user']['memberships']
                  assert_equal [{
                    "id"=>1,
                    "project"=>{"name"=>"eCookbook", "id"=>1},
                    "roles"=>[{"name"=>"Manager", "id"=>1}]
                  }], json['user']['memberships']
                end
                test "GET /users/current.xml should require authentication" do
                  get '/users/current.xml'
                  assert_response 401
                end
                test "GET /users/current.xml should return current user" do
                  get '/users/current.xml', {}, credentials('jsmith')
                  assert_select 'user id', :text => '2'
                end
                test "GET /users/:id should not return login for other user" do
                  get '/users/3.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_select 'user login', 0
                end
                test "GET /users/:id should return login for current user" do
                  get '/users/2.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_select 'user login', :text => 'jsmith'
                end
                test "GET /users/:id should not return api_key for other user" do
                  get '/users/3.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_select 'user api_key', 0
                end
                test "GET /users/:id should return api_key for current user" do
                  get '/users/2.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_select 'user api_key', :text => User.find(2).api_key
                end
                test "GET /users/:id should not return status for standard user" do
                  get '/users/3.xml', {}, credentials('jsmith')
                  assert_response :success
                  assert_select 'user status', 0
                end
                test "GET /users/:id should return status for administrators" do
                  get '/users/2.xml', {}, credentials('admin')
                  assert_response :success
                  assert_select 'user status', :text => User.find(1).status.to_s
                end
                test "POST /users.xml with valid parameters should create the user" do
                  assert_difference('User.count') do
                    post '/users.xml', {
                      :user => {
                        :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                        :mail => 'foo@example.net', :password => 'secret123',
                        :mail_notification => 'only_assigned'}
                      },
                      credentials('admin')
                  end
                  user = User.order('id DESC').first
                  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?('secret123')
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'user id', :text => user.id.to_s
                end
                test "POST /users.json with valid parameters should create the user" do
                  assert_difference('User.count') do
                    post '/users.json', {
                      :user => {
                        :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                        :mail => 'foo@example.net', :password => 'secret123',
                        :mail_notification => 'only_assigned'}
                      },
                      credentials('admin')
                  end
                  user = User.order('id DESC').first
                  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
                test "POST /users.xml with with invalid parameters should return errors" do
                  assert_no_difference('User.count') do
                    post '/users.xml', {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}, credentials('admin')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "First name can't be blank"
                end
                test "POST /users.json with with invalid parameters should return errors" do
                  assert_no_difference('User.count') do
                    post '/users.json', {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}, 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
                test "PUT /users/:id.xml with valid parameters should update the user" do
                  assert_no_difference('User.count') do
                    put '/users/2.xml', {
                      :user => {
                        :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                        :mail => 'jsmith@somenet.foo'}
                      },
                      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
                  assert_equal '', @response.body
                end
                test "PUT /users/:id.json with valid parameters should update the user" do
                  assert_no_difference('User.count') do
                    put '/users/2.json', {
                      :user => {
                        :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                        :mail => 'jsmith@somenet.foo'}
                      },
                      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
                  assert_equal '', @response.body
                end
                test "PUT /users/:id.xml with invalid parameters" do
                  assert_no_difference('User.count') do
                    put '/users/2.xml', {
                      :user => {
                        :login => 'jsmith', :firstname => '', :lastname => 'Lastname',
                        :mail => 'foo'}
                      },
                      credentials('admin')
                  end
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "First name can't be blank"
                end
                test "PUT /users/:id.json with invalid parameters" do
                  assert_no_difference('User.count') do
                    put '/users/2.json', {
                      :user => {
                        :login => 'jsmith', :firstname => '', :lastname => 'Lastname',
                        :mail => 'foo'}
                      },
                      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
                test "DELETE /users/:id.xml should delete the user" do
                  assert_difference('User.count', -1) do
                    delete '/users/2.xml', {}, credentials('admin')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                end
                test "DELETE /users/:id.json should delete the user" do
                  assert_difference('User.count', -1) do
                    delete '/users/2.json', {}, credentials('admin')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                end
              end

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

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::VersionsTest < Redmine::ApiTest::Base
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :versions
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /projects/:project_id/versions.xml should return project versions" do
                  get '/projects/1/versions.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'versions[type=array] version id:content(2)' do
                    assert_select '~ name', :text => '1.0'
                  end
                end
                test "POST /projects/:project_id/versions.xml should create the version" do
                  assert_difference 'Version.count' do
                    post '/projects/1/versions.xml', {:version => {:name => 'API test'}}, credentials('jsmith')
                  end
                  version = Version.order('id DESC').first
                  assert_equal 'API test', version.name
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'version id', :text => version.id.to_s
                end
                test "POST /projects/:project_id/versions.xml should create the version with due date" do
                  assert_difference 'Version.count' do
                    post '/projects/1/versions.xml', {:version => {:name => 'API test', :due_date => '2012-01-24'}}, credentials('jsmith')
                  end
                  version = Version.order('id DESC').first
                  assert_equal 'API test', version.name
                  assert_equal Date.parse('2012-01-24'), version.due_date
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'version id', :text => version.id.to_s
                end
                test "POST /projects/:project_id/versions.xml should create the version with custom fields" do
                  field = VersionCustomField.generate!
                  assert_difference 'Version.count' do
                    post '/projects/1/versions.xml', {
                        :version => {
                          :name => 'API test',
                          :custom_fields => [
                            {'id' => field.id.to_s, 'value' => 'Some value'}
                          ]
                        }
                      }, credentials('jsmith')
                  end
                  version = Version.order('id DESC').first
                  assert_equal 'API test', version.name
                  assert_equal 'Some value', version.custom_field_value(field)
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'version>custom_fields>custom_field[id=?]>value', field.id.to_s, 'Some value'
                end
                test "POST /projects/:project_id/versions.xml with failure should return the errors" do
                  assert_no_difference('Version.count') do
                    post '/projects/1/versions.xml', {:version => {:name => ''}}, credentials('jsmith')
                  end
                  assert_response :unprocessable_entity
                  assert_select 'errors error', :text => "Name can't be blank"
                end
                test "GET /versions/:id.xml should return the version" do
                  get '/versions/2.xml'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'version' do
                    assert_select 'id', :text => '2'
                    assert_select 'name', :text => '1.0'
                    assert_select 'sharing', :text => 'none'
                  end
                end
                test "PUT /versions/:id.xml should update the version" do
                  put '/versions/2.xml', {:version => {:name => 'API update'}}, credentials('jsmith')
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_equal 'API update', Version.find(2).name
                end
                test "DELETE /versions/:id.xml should destroy the version" do
                  assert_difference 'Version.count', -1 do
                    delete '/versions/3.xml', {}, credentials('jsmith')
                  end
                  assert_response :ok
                  assert_equal '', @response.body
                  assert_nil Version.find_by_id(3)
                end
              end

test/integration/api_test/wiki_pages_test.rb 0 -4

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../../test_helper', __FILE__)
              class Redmine::ApiTest::WikiPagesTest < Redmine::ApiTest::Base
                fixtures :projects, :users, :roles, :members, :member_roles,
                         :enabled_modules, :wikis, :wiki_pages, :wiki_contents,
                         :wiki_content_versions, :attachments
-               def setup
-                 Setting.rest_api_enabled = '1'
-               end
                test "GET /projects/:project_id/wiki/index.xml should return wiki pages" do
                  get '/projects/ecookbook/wiki/index.xml'
                  assert_response 200
                  assert_equal 'application/xml', response.content_type
                  assert_select 'wiki_pages[type=array]' do
                    assert_select 'wiki_page', :count => Wiki.find(1).pages.count
                    assert_select 'wiki_page' do
                      assert_select 'title', :text => 'CookBook_documentation'
                      assert_select 'version', :text => '3'
                      assert_select 'created_on'
                      assert_select 'updated_on'
                    end
                    assert_select 'wiki_page' do
                      assert_select 'title', :text => 'Page_with_an_inline_image'
                      assert_select 'parent[title=?]', 'CookBook_documentation'
                    end
                  end
                end
                test "GET /projects/:project_id/wiki/:title.xml should return wiki page" do
                  get '/projects/ecookbook/wiki/CookBook_documentation.xml'
                  assert_response 200
                  assert_equal 'application/xml', response.content_type
                  assert_select 'wiki_page' do
                    assert_select 'title', :text => 'CookBook_documentation'
                    assert_select 'version', :text => '3'
                    assert_select 'text'
                    assert_select 'author'
                    assert_select 'comments'
                    assert_select 'created_on'
                    assert_select 'updated_on'
                  end
                end
                test "GET /projects/:project_id/wiki/:title.xml?include=attachments should include attachments" do
                  get '/projects/ecookbook/wiki/Page_with_an_inline_image.xml?include=attachments'
                  assert_response 200
                  assert_equal 'application/xml', response.content_type
                  assert_select 'wiki_page' do
                    assert_select 'title', :text => 'Page_with_an_inline_image'
                    assert_select 'attachments[type=array]' do
                      assert_select 'attachment' do
                        assert_select 'id', :text => '3'
                        assert_select 'filename', :text => 'logo.gif'
                      end
                    end
                  end
                end
                test "GET /projects/:project_id/wiki/:title.xml with unknown title and edit permission should respond with 404" do
                  get '/projects/ecookbook/wiki/Invalid_Page.xml', {}, credentials('jsmith')
                  assert_response 404
                  assert_equal 'application/xml', response.content_type
                end
                test "GET /projects/:project_id/wiki/:title/:version.xml should return wiki page version" do
                  get '/projects/ecookbook/wiki/CookBook_documentation/2.xml'
                  assert_response 200
                  assert_equal 'application/xml', response.content_type
                  assert_select 'wiki_page' do
                    assert_select 'title', :text => 'CookBook_documentation'
                    assert_select 'version', :text => '2'
                    assert_select 'text'
                    assert_select 'author'
                    assert_select 'comments', :text => 'Small update'
                    assert_select 'created_on'
                    assert_select 'updated_on'
                  end
                end
                test "GET /projects/:project_id/wiki/:title/:version.xml without permission should be denied" do
                  Role.anonymous.remove_permission! :view_wiki_edits
                  get '/projects/ecookbook/wiki/CookBook_documentation/2.xml'
                  assert_response 401
                  assert_equal 'application/xml', response.content_type
                end
                test "PUT /projects/:project_id/wiki/:title.xml should update wiki page" do
                  assert_no_difference 'WikiPage.count' do
                    assert_difference 'WikiContent::Version.count' do
                      put '/projects/ecookbook/wiki/CookBook_documentation.xml',
                        {:wiki_page => {:text => 'New content from API', :comments => 'API update'}},
                        credentials('jsmith')
                      assert_response 200
                    end
                  end
                  page = WikiPage.find(1)
                  assert_equal 'New content from API', page.content.text
                  assert_equal 4, page.content.version
                  assert_equal 'API update', page.content.comments
                  assert_equal 'jsmith', page.content.author.login
                end
                test "PUT /projects/:project_id/wiki/:title.xml with current versino should update wiki page" do
                  assert_no_difference 'WikiPage.count' do
                    assert_difference 'WikiContent::Version.count' do
                      put '/projects/ecookbook/wiki/CookBook_documentation.xml',
                        {:wiki_page => {:text => 'New content from API', :comments => 'API update', :version => '3'}},
                        credentials('jsmith')
                      assert_response 200
                    end
                  end
                  page = WikiPage.find(1)
                  assert_equal 'New content from API', page.content.text
                  assert_equal 4, page.content.version
                  assert_equal 'API update', page.content.comments
                  assert_equal 'jsmith', page.content.author.login
                end
                test "PUT /projects/:project_id/wiki/:title.xml with stale version should respond with 409" do
                  assert_no_difference 'WikiPage.count' do
                    assert_no_difference 'WikiContent::Version.count' do
                      put '/projects/ecookbook/wiki/CookBook_documentation.xml',
                        {:wiki_page => {:text => 'New content from API', :comments => 'API update', :version => '2'}},
                        credentials('jsmith')
                      assert_response 409
                    end
                  end
                end
                test "PUT /projects/:project_id/wiki/:title.xml should create the page if it does not exist" do
                  assert_difference 'WikiPage.count' do
                    assert_difference 'WikiContent::Version.count' do
                      put '/projects/ecookbook/wiki/New_page_from_API.xml',
                        {:wiki_page => {:text => 'New content from API', :comments => 'API create'}},
                        credentials('jsmith')
                      assert_response 201
                    end
                  end
                  page = WikiPage.order('id DESC').first
                  assert_equal 'New_page_from_API', page.title
                  assert_equal 'New content from API', page.content.text
                  assert_equal 1, page.content.version
                  assert_equal 'API create', page.content.comments
                  assert_equal 'jsmith', page.content.author.login
                  assert_nil page.parent
                end
                test "PUT /projects/:project_id/wiki/:title.xml with parent" do
                  assert_difference 'WikiPage.count' do
                    assert_difference 'WikiContent::Version.count' do
                      put '/projects/ecookbook/wiki/New_subpage_from_API.xml',
                        {:wiki_page => {:parent_title => 'CookBook_documentation', :text => 'New content from API', :comments => 'API create'}},
                        credentials('jsmith')
                      assert_response 201
                    end
                  end
                  page = WikiPage.order('id DESC').first
                  assert_equal 'New_subpage_from_API', page.title
                  assert_equal WikiPage.find(1), page.parent
                end
                test "DELETE /projects/:project_id/wiki/:title.xml should destroy the page" do
                  assert_difference 'WikiPage.count', -1 do
                    delete '/projects/ecookbook/wiki/CookBook_documentation.xml', {}, credentials('jsmith')
                    assert_response 200
                  end
                  assert_nil WikiPage.find_by_id(1)
                end
              end

test/test_helper.rb +7 0

              # Redmine - project management software
              # Copyright (C) 2006-2014  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              ENV["RAILS_ENV"] = "test"
              require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
              require 'rails/test_help'
              require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
              require File.expand_path(File.dirname(__FILE__) + '/object_helpers')
              include ObjectHelpers
              require 'awesome_nested_set/version'
              require 'net/ldap'
              class ActionView::TestCase
                helper :application
                include ApplicationHelper
              end
              class ActiveSupport::TestCase
                include ActionDispatch::TestProcess
                self.use_transactional_fixtures = true
                self.use_instantiated_fixtures  = false
                #ESCAPED_CANT  = 'can&#x27;t'
                #ESCAPED_UCANT = 'Can&#x27;t'
                # Rails 4.0.2
                ESCAPED_CANT  = 'can&#39;t'
                ESCAPED_UCANT = 'Can&#39;t'
                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)
                  fixture_file_upload("files/#{name}", mime, true)
                end
                def credentials(user, password=nil)
                  {'HTTP_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({}) do |h, k|
                    h[k] = case Setting[k]
                      when Symbol, false, true, nil
                        Setting[k]
                      else
                        Setting[k].dup
                      end
                    h
                  end
                  options.each {|k, v| Setting[k] = v}
                  yield
                ensure
                  saved_settings.each {|k, v| Setting[k] = v} if saved_settings
                end
                # Yields the block with user as the current user
                def with_current_user(user, &block)
                  saved_user = User.current
                  User.current = user
                  yield
                ensure
                  User.current = saved_user
                end
                def with_locale(locale, &block)
                  saved_localed = ::I18n.locale
                  ::I18n.locale = locale
                  yield
                ensure
                  ::I18n.locale = saved_localed
                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
                def self.convert_installed?
                  Redmine::Thumbnail.convert_available?
                end
                # Returns the path to the test +vendor+ repository
                def self.repository_path(vendor)
                  path = Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
                  # Unlike ruby, JRuby returns Rails.root with backslashes under Windows
                  path.tr("\\", "/")
                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 repository_path_hash(arr)
                  hs = {}
                  hs[:path]  = arr.join("/")
                  hs[:param] = arr.join("/")
                  hs
                end
                def assert_save(object)
                  saved = object.save
                  message = "#{object.class} could not be saved"
                  errors = object.errors.full_messages.map {|m| "- #{m}"}
                  message << ":\n#{errors.join("\n")}" if errors.any?
                  assert_equal true, saved, message
                end
                def assert_select_error(arg)
                  assert_select '#errorExplanation', :text => arg
                end
                def assert_include(expected, s, message=nil)
                  assert s.include?(expected), (message || "\"#{expected}\" not found in \"#{s}\"")
                end
                def assert_not_include(expected, s, message=nil)
                  assert !s.include?(expected), (message || "\"#{expected}\" found in \"#{s}\"")
                end
                def assert_select_in(text, *args, &block)
                  d = HTML::Document.new(CGI::unescapeHTML(String.new(text))).root
                  assert_select(d, *args, &block)
                end
                def assert_mail_body_match(expected, mail, message=nil)
                  if expected.is_a?(String)
                    assert_include expected, mail_body(mail), message
                  else
                    assert_match expected, mail_body(mail), message
                  end
                end
                def assert_mail_body_no_match(expected, mail, message=nil)
                  if expected.is_a?(String)
                    assert_not_include expected, mail_body(mail), message
                  else
                    assert_no_match expected, mail_body(mail), message
                  end
                end
                def mail_body(mail)
                  mail.parts.first.body.encoded
                end
                # awesome_nested_set new node lft and rgt value changed this refactor revision.
                #   https://github.com/collectiveidea/awesome_nested_set/commit/199fca9bb938e40200cd90714dc69247ef017c61
                # The reason of behavior change is that "self.class.base_class.unscoped" was added to this line.
                #   https://github.com/collectiveidea/awesome_nested_set/commit/199fca9bb9#diff-f61b59a5e6319024e211b0ffdd0e4ef1R273
                # It seems correct behavior because of this line comment.
                #   https://github.com/collectiveidea/awesome_nested_set/blame/199fca9bb9/lib/awesome_nested_set/model.rb#L278
                def new_issue_lft
                  # ::AwesomeNestedSet::VERSION > "2.1.6" ? Issue.maximum(:rgt) + 1 : 1
                  Issue.maximum(:rgt) + 1
                end
              end
              module Redmine
                class RoutingTest < ActionDispatch::IntegrationTest
                  def should_route(arg)
                    arg = arg.dup
                    request = arg.keys.detect {|key| key.is_a?(String)}
                    raise ArgumentError unless request
                    options = arg.slice!(request)
                    raise ArgumentError unless request =~ /\A(GET|POST|PUT|PATCH|DELETE)\s+(.+)\z/
                    method, path = $1.downcase.to_sym, $2
                    raise ArgumentError unless arg.values.first =~ /\A(.+)#(.+)\z/
                    controller, action = $1, $2
                    assert_routing(
                      {:method => method, :path => path},
                      options.merge(:controller => controller, :action => action)
                    )
                  end
                end
                module ApiTest
                  API_FORMATS = %w(json xml).freeze
                  # Base class for API tests
                  class Base < ActionDispatch::IntegrationTest
+                   def setup
+                     Setting.rest_api_enabled = '1'
+                   end
+                   def teardown
+                     Setting.rest_api_enabled = '0'
+                   end
                  end
                  class Routing < Redmine::RoutingTest
                    def should_route(arg)
                      arg = arg.dup
                      request = arg.keys.detect {|key| key.is_a?(String)}
                      raise ArgumentError unless request
                      options = arg.slice!(request)
                      API_FORMATS.each do |format|
                        format_request = request.sub /$/, ".#{format}"
                        super options.merge(format_request => arg[request], :format => format)
                      end
                    end
                  end
                end
              end
              # URL helpers do not work with config.threadsafe!
              # https://github.com/rspec/rspec-rails/issues/476#issuecomment-4705454
              ActionView::TestCase::TestController.instance_eval do
                helper Rails.application.routes.url_helpers
              end
              ActionView::TestCase::TestController.class_eval do
                def _routes
                  Rails.application.routes
                end
              end

General Comments 0

Write
Preview

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

No TODOs yet

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

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