SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2012  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::UnifiedDiffTest < ActiveSupport::TestCase

  def test_subversion_diff

    diff = Redmine::UnifiedDiff.new(read_diff_fixture('subversion.diff'))

    # number of files

    assert_equal 4, diff.size

    assert diff.detect {|file| file.file_name =~ %r{^config/settings.yml}}

  end

  def test_truncate_diff

    diff = Redmine::UnifiedDiff.new(read_diff_fixture('subversion.diff'), :max_lines => 20)

    assert_equal 2, diff.size

  end

  def test_inline_partials

    diff = Redmine::UnifiedDiff.new(read_diff_fixture('partials.diff'))

    assert_equal 1, diff.size

    diff = diff.first

    assert_equal 43, diff.size

    assert_equal [51, -1], diff[0].offsets

    assert_equal [51, -1], diff[1].offsets

    assert_equal 'Lorem ipsum dolor sit amet, consectetur adipiscing <span>elit</span>', diff[0].html_line

    assert_equal 'Lorem ipsum dolor sit amet, consectetur adipiscing <span>xx</span>', diff[1].html_line

    assert_nil diff[2].offsets

    assert_equal 'Praesent et sagittis dui. Vivamus ac diam diam', diff[2].html_line

    assert_equal [0, -14], diff[3].offsets

    assert_equal [0, -14], diff[4].offsets

    assert_equal '<span>Ut sed</span> auctor justo', diff[3].html_line

    assert_equal '<span>xxx</span> auctor justo', diff[4].html_line

    assert_equal [13, -19], diff[6].offsets

    assert_equal [13, -19], diff[7].offsets

    assert_equal [24, -8], diff[9].offsets

    assert_equal [24, -8], diff[10].offsets

    assert_equal [37, -1], diff[12].offsets

    assert_equal [37, -1], diff[13].offsets

    assert_equal [0, -38], diff[15].offsets

    assert_equal [0, -38], diff[16].offsets

  end

  def test_side_by_side_partials

    diff = Redmine::UnifiedDiff.new(read_diff_fixture('partials.diff'), :type => 'sbs')

    assert_equal 1, diff.size

    diff = diff.first

    assert_equal 32, diff.size

    assert_equal [51, -1], diff[0].offsets

    assert_equal 'Lorem ipsum dolor sit amet, consectetur adipiscing <span>elit</span>', diff[0].html_line_left

    assert_equal 'Lorem ipsum dolor sit amet, consectetur adipiscing <span>xx</span>', diff[0].html_line_right

    assert_nil diff[1].offsets

    assert_equal 'Praesent et sagittis dui. Vivamus ac diam diam', diff[1].html_line_left

    assert_equal 'Praesent et sagittis dui. Vivamus ac diam diam', diff[1].html_line_right

    assert_equal [0, -14], diff[2].offsets

    assert_equal '<span>Ut sed</span> auctor justo', diff[2].html_line_left

    assert_equal '<span>xxx</span> auctor justo', diff[2].html_line_right

    assert_equal [13, -19], diff[4].offsets

    assert_equal [24, -8], diff[6].offsets

    assert_equal [37, -1], diff[8].offsets

    assert_equal [0, -38], diff[10].offsets

  end

  def test_partials_with_html_entities

    raw = <<-DIFF

--- test.orig.txt Wed Feb 15 16:10:39 2012

+++ test.new.txt  Wed Feb 15 16:11:25 2012

@@ -1,5 +1,5 @@

 Semicolons were mysteriously appearing in code diffs in the repository

-void DoSomething(std::auto_ptr<MyClass> myObj)

+void DoSomething(const MyClass& myObj)

DIFF

    diff = Redmine::UnifiedDiff.new(raw, :type => 'sbs')

    assert_equal 1, diff.size

    assert_equal 'void DoSomething(<span>std::auto_ptr&lt;MyClass&gt;</span> myObj)', diff.first[2].html_line_left

    assert_equal 'void DoSomething(<span>const MyClass&amp;</span> myObj)', diff.first[2].html_line_right

    diff = Redmine::UnifiedDiff.new(raw, :type => 'inline')

    assert_equal 1, diff.size

    assert_equal 'void DoSomething(<span>std::auto_ptr&lt;MyClass&gt;</span> myObj)', diff.first[2].html_line

    assert_equal 'void DoSomething(<span>const MyClass&amp;</span> myObj)', diff.first[3].html_line

  end

  def test_line_starting_with_dashes

    diff = Redmine::UnifiedDiff.new(<<-DIFF

--- old.txt Wed Nov 11 14:24:58 2009

+++ new.txt Wed Nov 11 14:25:02 2009

@@ -1,8 +1,4 @@

-Lines that starts with dashes:

-

-------------------------

--- file.c

-------------------------

+A line that starts with dashes:

 and removed.

@@ -23,4 +19,4 @@

-Another chunk of change

+Another chunk of changes

DIFF

    )

    assert_equal 1, diff.size

  end

  def test_one_line_new_files

    diff = Redmine::UnifiedDiff.new(<<-DIFF

diff -r 000000000000 -r ea98b14f75f0 README1

--- /dev/null

+++ b/README1

@@ -0,0 +1,1 @@

+test1

diff -r 000000000000 -r ea98b14f75f0 README2

--- /dev/null

+++ b/README2

@@ -0,0 +1,1 @@

+test2

diff -r 000000000000 -r ea98b14f75f0 README3

--- /dev/null

+++ b/README3

@@ -0,0 +1,3 @@

+test4

+test5

+test6

diff -r 000000000000 -r ea98b14f75f0 README4

--- /dev/null

+++ b/README4

@@ -0,0 +1,3 @@

+test4

+test5

+test6

DIFF

    )

    assert_equal 4, diff.size

    assert_equal "README1", diff[0].file_name

  end

  def test_both_git_diff

    diff = Redmine::UnifiedDiff.new(<<-DIFF

# HG changeset patch

# User test

# Date 1348014182 -32400

# Node ID d1c871b8ef113df7f1c56d41e6e3bfbaff976e1f

# Parent  180b6605936cdc7909c5f08b59746ec1a7c99b3e

modify test1.txt

diff -r 180b6605936c -r d1c871b8ef11 test1.txt

--- a/test1.txt

+++ b/test1.txt

@@ -1,1 +1,1 @@

-test1

+modify test1

DIFF

    )

    assert_equal 1, diff.size

    assert_equal "test1.txt", diff[0].file_name

  end

  def test_include_a_b_slash

    diff = Redmine::UnifiedDiff.new(<<-DIFF

--- test1.txt

+++ b/test02.txt

@@ -1 +0,0 @@

-modify test1

DIFF

    )

    assert_equal 1, diff.size

    assert_equal "b/test02.txt", diff[0].file_name

    diff = Redmine::UnifiedDiff.new(<<-DIFF

--- a/test1.txt

+++ a/test02.txt

@@ -1 +0,0 @@

-modify test1

DIFF

    )

    assert_equal 1, diff.size

    assert_equal "a/test02.txt", diff[0].file_name

    diff = Redmine::UnifiedDiff.new(<<-DIFF

--- a/test1.txt

+++ test02.txt

@@ -1 +0,0 @@

-modify test1

DIFF

    )

    assert_equal 1, diff.size

    assert_equal "test02.txt", diff[0].file_name

  end

  private

  def read_diff_fixture(filename)

    File.new(File.join(File.dirname(__FILE__), '/../../../fixtures/diffs', filename)).read

  end

end

# Redmine - project management software

# Copyright (C) 2006-2012  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class VersionCustomField < CustomField

  def type_name

    :label_version_plural

  end

end

require File.expand_path('../../../test_helper', __FILE__)

class ApiTest::DisabledRestApiTest < ActionController::IntegrationTest

  fixtures :projects, :trackers, :issue_statuses, :issues,

           :enumerations, :users, :issue_categories,

           :projects_trackers,

           :roles,

           :member_roles,

           :members,

           :enabled_modules,

           :workflows

  def setup

    Setting.rest_api_enabled = '0'

    Setting.login_required = '1'

  end

  def teardown

    Setting.rest_api_enabled = '1'

    Setting.login_required = '0'

  end

  def test_with_a_valid_api_token

    @user = User.generate!

    @token = Token.create!(:user => @user, :action => 'api')

    get "/news.xml?key=#{@token.value}"

    assert_response :unauthorized

    assert_equal User.anonymous, User.current

    get "/news.json?key=#{@token.value}"

    assert_response :unauthorized

    assert_equal User.anonymous, User.current

  end

  def test_with_valid_username_password_http_authentication

    @user = User.generate! do |user|

      user.password = 'my_password'

    end

    get "/news.xml", nil, credentials(@user.login, 'my_password')

    assert_response :unauthorized

    assert_equal User.anonymous, User.current

    get "/news.json", nil, credentials(@user.login, 'my_password')

    assert_response :unauthorized

    assert_equal User.anonymous, User.current

  end

  def test_with_valid_token_http_authentication

    @user = User.generate!

    @token = Token.create!(:user => @user, :action => 'api')

    get "/news.xml", nil, credentials(@token.value, 'X')

    assert_response :unauthorized

    assert_equal User.anonymous, User.current

    get "/news.json", nil, credentials(@token.value, 'X')

    assert_response :unauthorized

    assert_equal User.anonymous, User.current

  end

end

# Redmine - project management software

# Copyright (C) 2006-2012  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require File.expand_path('../../../test_helper', __FILE__)

class ApiTest::IssuesTest < ActionController::IntegrationTest

  fixtures :projects,

    :users,

    :roles,

    :members,

    :member_roles,

    :issues,

    :issue_statuses,

    :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

  context "/issues" do

    # Use a private project to make sure auth is really working and not just

    # only showing public issues.

    should_allow_api_authentication(:get, "/projects/private-child/issues.xml")

    should "contain metadata" do

      get '/issues.xml'

      assert_tag :tag => 'issues',

        :attributes => {

          :type => 'array',

          :total_count => assigns(:issue_count),

          :limit => 25,

          :offset => 0

        }

    end

    context "with offset and limit" do

      should "use the params" do

        get '/issues.xml?offset=2&limit=3'

        assert_equal 3, assigns(:limit)

        assert_equal 2, assigns(:offset)

        assert_tag :tag => 'issues', :children => {:count => 3, :only => {:tag => 'issue'}}

      end

    end

    context "with nometa param" do

      should "not contain metadata" do

        get '/issues.xml?nometa=1'

        assert_tag :tag => 'issues',

          :attributes => {

            :type => 'array',

            :total_count => nil,

            :limit => nil,

            :offset => nil

          }

      end

    end

    context "with nometa header" do

      should "not contain metadata" do

        get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}

        assert_tag :tag => 'issues',

          :attributes => {

            :type => 'array',

            :total_count => nil,

            :limit => nil,

            :offset => nil

          }

      end

    end

    context "with relations" do

      should "display relations" do

        get '/issues.xml?include=relations'

        assert_response :success

        assert_equal 'application/xml', @response.content_type

        assert_tag 'relations',

          :parent => {:tag => 'issue', :child => {:tag => 'id', :content => '3'}},

          :children => {:count => 1},

          :child => {

            :tag => 'relation',

            :attributes => {:id => '2', :issue_id => '2', :issue_to_id => '3',

                            :relation_type => 'relates'}

          }

        assert_tag 'relations',

          :parent => {:tag => 'issue', :child => {:tag => 'id', :content => '1'}},

          :children => {:count => 0}

      end

    end

    context "with invalid query params" do

      should "return errors" do

        get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}

        assert_response :unprocessable_entity

        assert_equal 'application/xml', @response.content_type

        assert_tag 'errors', :child => {:tag => 'error', :content => "Start date can't be blank"}

      end

    end

    context "with custom field filter" do

      should "show only issues with the custom field value" do

        get '/issues.xml',

            {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='},

             :v => {:cf_1 => ['MySQL']}}

        expected_ids = Issue.visible.all(

            :include => :custom_values,

            :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)

        assert_select 'issues > issue > id', :count => expected_ids.count do |ids|

           ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }

        end

      end

    end

    context "with custom field filter (shorthand method)" do

      should "show only issues with the custom field value" do

        get '/issues.xml', { :cf_1 => 'MySQL' }

        expected_ids = Issue.visible.all(

            :include => :custom_values,

            :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)

        assert_select 'issues > issue > id', :count => expected_ids.count do |ids|

          ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }

        end

      end

    end

  end

  context "/index.json" do

    should_allow_api_authentication(:get, "/projects/private-child/issues.json")

  end

  context "/index.xml with filter" do

    should "show only issues with the status_id" do

      get '/issues.xml?status_id=5'

      expected_ids = Issue.visible.all(:conditions => {:status_id => 5}).map(&:id)

      assert_select 'issues > issue > id', :count => expected_ids.count do |ids|

         ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }

      end

    end

  end

  context "/index.json with filter" do

    should "show only issues with the status_id" do

      get '/issues.json?status_id=5'

      json = ActiveSupport::JSON.decode(response.body)

      status_ids_used = json['issues'].collect {|j| j['status']['id'] }

      assert_equal 3, status_ids_used.length

      assert status_ids_used.all? {|id| id == 5 }

    end

  end

  # Issue 6 is on a private project

  context "/issues/6.xml" do

    should_allow_api_authentication(:get, "/issues/6.xml")

  end

  context "/issues/6.json" do

    should_allow_api_authentication(:get, "/issues/6.json")

  end

  context "GET /issues/:id" do

    context "with journals" do

      context ".xml" do

        should "display journals" do

          get '/issues/1.xml?include=journals'

          assert_tag :tag => 'issue',

            :child => {

              :tag => 'journals',

              :attributes => { :type => 'array' },

              :child => {

                :tag => 'journal',

                :attributes => { :id => '1'},

                :child => {

                  :tag => 'details',

                  :attributes => { :type => 'array' },

                  :child => {

                    :tag => 'detail',

                    :attributes => { :name => 'status_id' },

                    :child => {

                      :tag => 'old_value',

                      :content => '1',

                      :sibling => {

                        :tag => 'new_value',

                        :content => '2'

                      }

                    }

                  }

                }

              }

            }

        end

      end

    end

    context "with custom fields" do

      context ".xml" do

        should "display custom fields" do

          get '/issues/3.xml'

          assert_tag :tag => 'issue',

            :child => {

              :tag => 'custom_fields',

              :attributes => { :type => 'array' },

              :child => {

                :tag => 'custom_field',

                :attributes => { :id => '1'},

                :child => {

                  :tag => 'value',

                  :content => 'MySQL'

                }

              }

            }

          assert_nothing_raised do

            Hash.from_xml(response.body).to_xml

          end

        end

      end

    end

    context "with multi custom fields" do

      setup do

        field = CustomField.find(1)

        field.update_attribute :multiple, true

        issue = Issue.find(3)

        issue.custom_field_values = {1 => ['MySQL', 'Oracle']}

        issue.save!

      end

      context ".xml" do

        should "display custom fields" do

          get '/issues/3.xml'

          assert_response :success

          assert_tag :tag => 'issue',

            :child => {

              :tag => 'custom_fields',

              :attributes => { :type => 'array' },

              :child => {

                :tag => 'custom_field',

                :attributes => { :id => '1'},

                :child => {

                  :tag => 'value',

                  :attributes => { :type => 'array' },

                  :children => { :count => 2 }

                }

              }

            }

          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

      end

      context ".json" do

        should "display custom fields" do

          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

      end

    end

    context "with empty value for multi custom field" do

      setup do

        field = CustomField.find(1)

        field.update_attribute :multiple, true

        issue = Issue.find(3)

        issue.custom_field_values = {1 => ['']}

        issue.save!

      end

      context ".xml" do

        should "display custom fields" do

          get '/issues/3.xml'

          assert_response :success

          assert_tag :tag => 'issue',

            :child => {

              :tag => 'custom_fields',

              :attributes => { :type => 'array' },

              :child => {

                :tag => 'custom_field',

                :attributes => { :id => '1'},

                :child => {

                  :tag => 'value',

                  :attributes => { :type => 'array' },

                  :children => { :count => 0 }

                }

              }

            }

          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

      end

      context ".json" do

        should "display custom fields" do

          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

      end

    end

    context "with attachments" do

      context ".xml" do

        should "display attachments" do

          get '/issues/3.xml?include=attachments'

          assert_tag :tag => 'issue',

            :child => {

              :tag => 'attachments',

              :children => {:count => 5},

              :child => {

                :tag => 'attachment',

                :child => {

                  :tag => 'filename',

                  :content => 'source.rb',

                  :sibling => {

                    :tag => 'content_url',

                    :content => 'http://www.example.com/attachments/download/4/source.rb'

                  }

                }

              }

            }

        end

      end

    end

    context "with subtasks" do

      setup do

        @c1 = Issue.create!(

                :status_id => 1, :subject => "child c1",

                :tracker_id => 1, :project_id => 1, :author_id => 1,

                :parent_issue_id => 1

              )

        @c2 = Issue.create!(

                :status_id => 1, :subject => "child c2",

                :tracker_id => 1, :project_id => 1, :author_id => 1,

                :parent_issue_id => 1

              )

        @c3 = Issue.create!(

                :status_id => 1, :subject => "child c3",

                :tracker_id => 1, :project_id => 1, :author_id => 1,

                :parent_issue_id => @c1.id

              )

      end

      context ".xml" do

        should "display children" do

          get '/issues/1.xml?include=children'

          assert_tag :tag => 'issue',

            :child => {

              :tag => 'children',

              :children => {:count => 2},

              :child => {

                :tag => 'issue',

                :attributes => {:id => @c1.id.to_s},

                :child => {

                  :tag => 'subject',

                  :content => 'child c1',

                  :sibling => {

                    :tag => 'children',

                    :children => {:count => 1},

                    :child => {

                      :tag => 'issue',

                      :attributes => {:id => @c3.id.to_s}

                    }

                  }

                }

              }

            }

        end

        context ".json" do

          should "display children" do

            get '/issues/1.json?include=children'

            json = ActiveSupport::JSON.decode(response.body)

            assert_equal([

              {

                'id' => @c1.id, 'subject' => 'child c1', 'tracker' => {'id' => 1, 'name' => 'Bug'},

                'children' => [{'id' => @c3.id, 'subject' => 'child c3',

                                'tracker' => {'id' => 1, 'name' => 'Bug'} }]

              },

              { 'id' => @c2.id, 'subject' => 'child c2', 'tracker' => {'id' => 1, 'name' => 'Bug'} }

              ],

              json['issue']['children'])

          end

        end

      end

    end

  end

  context "POST /issues.xml" do

    should_allow_api_authentication(

      :post,

      '/issues.xml',

      {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},

      {:success_code => :created}

    )

    should "create an issue with the attributes" do

      assert_difference('Issue.count') do

        post '/issues.xml',

             {:issue => {:project_id => 1, :subject => 'API test',

              :tracker_id => 2, :status_id => 3}}, credentials('jsmith')

      end

      issue = Issue.first(:order => 'id DESC')

      assert_equal 1, issue.project_id

      assert_equal 2, issue.tracker_id

      assert_equal 3, issue.status_id

      assert_equal 'API test', issue.subject

      assert_response :created

      assert_equal 'application/xml', @response.content_type

      assert_tag 'issue', :child => {:tag => 'id', :content => issue.id.to_s}

    end

  end

  context "POST /issues.xml with failure" do

    should "have an errors tag" do

      assert_no_difference('Issue.count') do

        post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')

      end

      assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}

    end

  end

  context "POST /issues.json" do

    should_allow_api_authentication(:post,

                                    '/issues.json',

                                    {:issue => {:project_id => 1, :subject => 'API test',

                                     :tracker_id => 2, :status_id => 3}},

                                    {:success_code => :created})

    should "create an issue with the attributes" do

      assert_difference('Issue.count') do

        post '/issues.json',

             {:issue => {:project_id => 1, :subject => 'API test',

                         :tracker_id => 2, :status_id => 3}},

             credentials('jsmith')

      end

      issue = Issue.first(:order => 'id DESC')

      assert_equal 1, issue.project_id

      assert_equal 2, issue.tracker_id

      assert_equal 3, issue.status_id

      assert_equal 'API test', issue.subject

    end

  end

  context "POST /issues.json with failure" do

    should "have an errors element" do

      assert_no_difference('Issue.count') do

        post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')

      end

      json = ActiveSupport::JSON.decode(response.body)

      assert json['errors'].include?("Subject can't be blank")

    end

  end

  # Issue 6 is on a private project

  context "PUT /issues/6.xml" do

    setup do

      @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}

    end

    should_allow_api_authentication(:put,

                                    '/issues/6.xml',

                                    {:issue => {:subject => 'API update', :notes => 'A new note'}},

                                    {:success_code => :ok})

    should "not create a new issue" do

      assert_no_difference('Issue.count') do

        put '/issues/6.xml', @parameters, credentials('jsmith')

      end

    end

    should "create a new journal" do

      assert_difference('Journal.count') do

        put '/issues/6.xml', @parameters, credentials('jsmith')

      end

    end

    should "add the note to the journal" do

      put '/issues/6.xml', @parameters, credentials('jsmith')

      journal = Journal.last

      assert_equal "A new note", journal.notes

    end

    should "update the issue" do

      put '/issues/6.xml', @parameters, credentials('jsmith')

      issue = Issue.find(6)

      assert_equal "API update", issue.subject

    end

  end

  context "PUT /issues/3.xml with custom fields" do

    setup do

      @parameters = {

        :issue => {:custom_fields => [{'id' => '1', 'value' => 'PostgreSQL' },

        {'id' => '2', 'value' => '150'}]}

      }

    end

    should "update custom fields" do

      assert_no_difference('Issue.count') do

        put '/issues/3.xml', @parameters, credentials('jsmith')

      end

      issue = Issue.find(3)

      assert_equal '150', issue.custom_value_for(2).value

      assert_equal 'PostgreSQL', issue.custom_value_for(1).value

    end

  end

  context "PUT /issues/3.xml with multi custom fields" do

    setup do

      field = CustomField.find(1)

      field.update_attribute :multiple, true

      @parameters = {

        :issue => {:custom_fields => [{'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },

        {'id' => '2', 'value' => '150'}]}

      }

    end

    should "update custom fields" do

      assert_no_difference('Issue.count') do

        put '/issues/3.xml', @parameters, credentials('jsmith')

      end

      issue = Issue.find(3)

      assert_equal '150', issue.custom_value_for(2).value

      assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort

    end

  end

  context "PUT /issues/3.xml with project change" do

    setup do

      @parameters = {:issue => {:project_id => 2, :subject => 'Project changed'}}

    end

    should "update project" do

      assert_no_difference('Issue.count') do

        put '/issues/3.xml', @parameters, credentials('jsmith')

      end

      issue = Issue.find(3)

      assert_equal 2, issue.project_id

      assert_equal 'Project changed', issue.subject

    end

  end

  context "PUT /issues/6.xml with failed update" do

    setup do

      @parameters = {:issue => {:subject => ''}}

    end

    should "not create a new issue" do

      assert_no_difference('Issue.count') do

        put '/issues/6.xml', @parameters, credentials('jsmith')

      end

    end

    should "not create a new journal" do

      assert_no_difference('Journal.count') do

        put '/issues/6.xml', @parameters, credentials('jsmith')

      end

    end

    should "have an errors tag" do

      put '/issues/6.xml', @parameters, credentials('jsmith')

      assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}

    end

  end

  context "PUT /issues/6.json" do

    setup do

      @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}

    end

    should_allow_api_authentication(:put,

                                    '/issues/6.json',

                                    {:issue => {:subject => 'API update', :notes => 'A new note'}},

                                    {:success_code => :ok})

    should "update the issue" do

      assert_no_difference('Issue.count') do

        assert_difference('Journal.count') do

          put '/issues/6.json', @parameters, credentials('jsmith')

          assert_response :ok

          assert_equal '', response.body

        end

      end

      issue = Issue.find(6)

      assert_equal "API update", issue.subject

      journal = Journal.last

      assert_equal "A new note", journal.notes

    end

  end

  context "PUT /issues/6.json with failed update" do

    should "return errors" do

      assert_no_difference('Issue.count') do

        assert_no_difference('Journal.count') do

          put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')

          assert_response :unprocessable_entity

        end

      end

      json = ActiveSupport::JSON.decode(response.body)

      assert json['errors'].include?("Subject can't be blank")

    end

  end

  context "DELETE /issues/1.xml" do

    should_allow_api_authentication(:delete,

                                    '/issues/6.xml',

                                    {},

                                    {:success_code => :ok})

    should "delete the issue" do

      assert_difference('Issue.count', -1) do

        delete '/issues/6.xml', {}, credentials('jsmith')

        assert_response :ok

        assert_equal '', response.body

      end

      assert_nil Issue.find_by_id(6)

    end

  end

  context "DELETE /issues/1.json" do

    should_allow_api_authentication(:delete,

                                    '/issues/6.json',

                                    {},

                                    {:success_code => :ok})

    should "delete the issue" do

      assert_difference('Issue.count', -1) do

        delete '/issues/6.json', {}, credentials('jsmith')

        assert_response :ok

        assert_equal '', response.body

      end

      assert_nil Issue.find_by_id(6)

    end

  end

  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.first(:order => 'id DESC')

    # 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.first(:order => 'id DESC')

    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.first(:order => 'id DESC')

    # 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

# encoding: utf-8

#

# Redmine - project management software

# Copyright (C) 2006-2012  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 'forwardable'

require 'cgi'

module ApplicationHelper

  include Redmine::WikiFormatting::Macros::Definitions

  include Redmine::I18n

  include GravatarHelper::PublicMethods

  extend Forwardable

  def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter

  # Return true if user is authorized for controller/action, otherwise false

  def authorize_for(controller, action)

    User.current.allowed_to?({:controller => controller, :action => action}, @project)

  end

  # Display a link if user is authorized

  #

  # @param [String] name Anchor text (passed to link_to)

  # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized

  # @param [optional, Hash] html_options Options passed to link_to

  # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to

  def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)

    link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])

  end

  # Displays a link to user's account page if active

  def link_to_user(user, options={})

    if user.is_a?(User)

      name = h(user.name(options[:format]))

      if user.active? || (User.current.admin? && user.logged?)

        link_to name, user_path(user), :class => user.css_classes

      else

        name

      end

    else

      h(user.to_s)

    end

  end

  # Displays a link to +issue+ with its subject.

  # Examples:

  #

  #   link_to_issue(issue)                        # => Defect #6: This is the subject

  #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...

  #   link_to_issue(issue, :subject => false)     # => Defect #6

  #   link_to_issue(issue, :project => true)      # => Foo - Defect #6

  #   link_to_issue(issue, :subject => false, :tracker => false)     # => #6

  #

  def link_to_issue(issue, options={})

    title = nil

    subject = nil

    text = options[:tracker] == false ? "##{issue.id}" : "#{issue.tracker} ##{issue.id}"

    if options[:subject] == false

      title = truncate(issue.subject, :length => 60)

    else

      subject = issue.subject

      if options[:truncate]

        subject = truncate(subject, :length => options[:truncate])

      end

    end

    s = link_to text, issue_path(issue), :class => issue.css_classes, :title => title

    s << h(": #{subject}") if subject

    s = h("#{issue.project} - ") + s if options[:project]

    s

  end

  # Generates a link to an attachment.

  # Options:

  # * :text - Link text (default to attachment filename)

  # * :download - Force download (default: false)

  def link_to_attachment(attachment, options={})

    text = options.delete(:text) || attachment.filename

    action = options.delete(:download) ? 'download' : 'show'

    opt_only_path = {}

    opt_only_path[:only_path] = (options[:only_path] == false ? false : true)

    options.delete(:only_path)

    link_to(h(text),

           {:controller => 'attachments', :action => action,

            :id => attachment, :filename => attachment.filename}.merge(opt_only_path),

           options)

  end

  # Generates a link to a SCM revision

  # Options:

  # * :text - Link text (default to the formatted revision)

  def link_to_revision(revision, repository, options={})

    if repository.is_a?(Project)

      repository = repository.repository

    end

    text = options.delete(:text) || format_revision(revision)

    rev = revision.respond_to?(:identifier) ? revision.identifier : revision

    link_to(

        h(text),

        {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},

        :title => l(:label_revision_id, format_revision(revision))

      )

  end

  # Generates a link to a message

  def link_to_message(message, options={}, html_options = nil)

    link_to(

      h(truncate(message.subject, :length => 60)),

      { :controller => 'messages', :action => 'show',

        :board_id => message.board_id,

        :id => (message.parent_id || message.id),

        :r => (message.parent_id && message.id),

        :anchor => (message.parent_id ? "message-#{message.id}" : nil)

      }.merge(options),

      html_options

    )

  end

  # Generates a link to a project if active

  # Examples:

  #

  #   link_to_project(project)                          # => link to the specified project overview

  #   link_to_project(project, :action=>'settings')     # => link to project settings

  #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options

  #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)

  #

  def link_to_project(project, options={}, html_options = nil)

    if project.archived?

      h(project)

    else

      url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)

      link_to(h(project), url, html_options)

    end

  end

  def wiki_page_path(page, options={})

    url_for({:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title}.merge(options))

  end

  def thumbnail_tag(attachment)

    link_to image_tag(url_for(:controller => 'attachments', :action => 'thumbnail', :id => attachment)),

      {:controller => 'attachments', :action => 'show', :id => attachment, :filename => attachment.filename},

      :title => attachment.filename

  end

  def toggle_link(name, id, options={})

    onclick = "$('##{id}').toggle(); "

    onclick << (options[:focus] ? "$('##{options[:focus]}').focus(); " : "this.blur(); ")

    onclick << "return false;"

    link_to(name, "#", :onclick => onclick)

  end

  def image_to_function(name, function, html_options = {})

    html_options.symbolize_keys!

    tag(:input, html_options.merge({

        :type => "image", :src => image_path(name),

        :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};"

        }))

  end

  def format_activity_title(text)

    h(truncate_single_line(text, :length => 100))

  end

  def format_activity_day(date)

    date == User.current.today ? l(:label_today).titleize : format_date(date)

  end

  def format_activity_description(text)

    h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')

       ).gsub(/[\r\n]+/, "<br />").html_safe

  end

  def format_version_name(version)

    if version.project == @project

    	h(version)

    else

      h("#{version.project} - #{version}")

    end

  end

  def due_date_distance_in_words(date)

    if date

      l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))

    end

  end

  # Renders a tree of projects as a nested set of unordered lists

  # The given collection may be a subset of the whole project tree

  # (eg. some intermediate nodes are private and can not be seen)

  def render_project_nested_lists(projects)

    s = ''

    if projects.any?

      ancestors = []

      original_project = @project

      projects.sort_by(&:lft).each do |project|

        # set the project environment to please macros.

        @project = project

        if (ancestors.empty? || project.is_descendant_of?(ancestors.last))

          s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"

        else

          ancestors.pop

          s << "</li>"

          while (ancestors.any? && !project.is_descendant_of?(ancestors.last))

            ancestors.pop

            s << "</ul></li>\n"

          end

        end

        classes = (ancestors.empty? ? 'root' : 'child')

        s << "<li class='#{classes}'><div class='#{classes}'>"

        s << h(block_given? ? yield(project) : project.name)

        s << "</div>\n"

        ancestors << project

      end

      s << ("</li></ul>\n" * ancestors.size)

      @project = original_project

    end

    s.html_safe

  end

  def render_page_hierarchy(pages, node=nil, options={})

    content = ''

    if pages[node]

      content << "<ul class=\"pages-hierarchy\">\n"

      pages[node].each do |page|

        content << "<li>"

        content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title, :version => nil},

                           :title => (options[:timestamp] && page.updated_on ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))

        content << "\n" + render_page_hierarchy(pages, page.id, options) if pages[page.id]

        content << "</li>\n"

      end

      content << "</ul>\n"

    end

    content.html_safe

  end

  # Renders flash messages

  def render_flash_messages

    s = ''

    flash.each do |k,v|

      s << content_tag('div', v.html_safe, :class => "flash #{k}", :id => "flash_#{k}")

    end

    s.html_safe

  end

  # Renders tabs and their content

  def render_tabs(tabs)

    if tabs.any?

      render :partial => 'common/tabs', :locals => {:tabs => tabs}

    else

      content_tag 'p', l(:label_no_data), :class => "nodata"

    end

  end

  # Renders the project quick-jump box

  def render_project_jump_box

    return unless User.current.logged?

    projects = User.current.memberships.collect(&:project).compact.select(&:active?).uniq

    if projects.any?

      options =

        ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +

         '<option value="" disabled="disabled">---</option>').html_safe

      options << project_tree_options_for_select(projects, :selected => @project) do |p|

        { :value => project_path(:id => p, :jump => current_menu_item) }

      end

      select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')

    end

  end

  def project_tree_options_for_select(projects, options = {})

    s = ''

    project_tree(projects) do |project, level|

      name_prefix = (level > 0 ? ' ' * 2 * level + '» ' : '').html_safe

      tag_options = {:value => project.id}

      if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))

        tag_options[:selected] = 'selected'

      else

        tag_options[:selected] = nil

      end

      tag_options.merge!(yield(project)) if block_given?

      s << content_tag('option', name_prefix + h(project), tag_options)

    end

    s.html_safe

  end

  # Yields the given block for each project with its level in the tree

  #

  # Wrapper for Project#project_tree

  def project_tree(projects, &block)

    Project.project_tree(projects, &block)

  end

  def principals_check_box_tags(name, principals)

    s = ''

    principals.sort.each do |principal|

      s << "<label>#{ check_box_tag name, principal.id, false } #{h principal}</label>\n"

    end

    s.html_safe

  end

  # Returns a string for users/groups option tags

  def principals_options_for_select(collection, selected=nil)

    s = ''

    if collection.include?(User.current)

      s << content_tag('option', "<< #{l(:label_me)} >>", :value => User.current.id)

    end

    groups = ''

    collection.sort.each do |element|

      selected_attribute = ' selected="selected"' if option_value_selected?(element, selected)

      (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)

    end

    unless groups.empty?

      s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)

    end

    s.html_safe

  end

  # Options for the new membership projects combo-box

  def options_for_membership_project_select(principal, projects)

    options = content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---")

    options << project_tree_options_for_select(projects) do |p|

      {:disabled => principal.projects.include?(p)}

    end

    options

  end

  # Truncates and returns the string as a single line

  def truncate_single_line(string, *args)

    truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')

  end

  # Truncates at line break after 250 characters or options[:length]

  def truncate_lines(string, options={})

    length = options[:length] || 250

    if string.to_s =~ /\A(.{#{length}}.*?)$/m

      "#{$1}..."

    else

      string

    end

  end

  def anchor(text)

    text.to_s.gsub(' ', '_')

  end

  def html_hours(text)

    text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe

  end

  def authoring(created, author, options={})

    l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe

  end

  def time_tag(time)

    text = distance_of_time_in_words(Time.now, time)

    if @project

      link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => User.current.time_to_date(time)}, :title => format_time(time))