require File.dirname(__FILE__) + '/../test_helper'
require File.dirname(__FILE__) + '/test_case'
require 'tickets_controller'

# Re-raise errors caught by the controller.
class TicketsController; def rescue_action(e) raise e end; end

class TicketsControllerTest < Functional::TestCase
  fixtures :groups, :projects, :groups_projects, :groups_users, 
            :tickets, :ticket_changes, :ticket_reports, :ticket_subscribers,
            :statuses, :priorities, :milestones, :ticket_property_types, :ticket_properties, :ticket_properties_tickets
            

  def setup
    RetroCM.reload
    RetroCM[:content][:markup][:default] = 'retro'
    @controller = TicketsController.new
    @request    = ActionController::TestRequest.new
    @response   = ActionController::TestResponse.new
    Project.current = Project.find(1)
    logout
  end

  def test_index
    get :index
    assert_response :success
    assert_template 'tickets/index'    
    assert_valid_markup
    assert_select 'tbody>tr.record', 3
    @controller = TicketsController.new

    get :index, :status => ['2']
    assert_response :success
    assert_template 'tickets/index'    
    assert_valid_markup
    assert_select 'tbody>tr.record', 1
    @controller = TicketsController.new

    get :index, :status => ['1','2']
    assert_response :success
    assert_template 'tickets/index'    
    assert_valid_markup
    assert_select 'tbody>tr.record', 4
    @controller = TicketsController.new

    get :index, :status => ['1','2'], :search => 'expected behaviour'
    assert_response :success
    assert_template 'tickets/index'    
    assert_valid_markup
    assert_select 'tbody>tr.record', 1
    @controller = TicketsController.new
    
    get :index, :status => ['10','20','invalid'] # status filter is not applied
    assert_response :success
    assert_template 'tickets/index'
    assert_valid_markup
    assert_select 'tbody>tr.record', 3
    @controller = TicketsController.new

    get :index, :status => ['1','2','invalid']  # 'invalid' is not applied
    assert_response :success
    assert_template 'tickets/index'
    assert_valid_markup
    assert_select 'tbody>tr.record', 4
    @controller = TicketsController.new
    
    get :index, :report => '1'
    assert_response :success
    assert_template 'tickets/index'    
    assert_valid_markup
    assert_select 'tbody>tr.record', 1
    @controller = TicketsController.new

    get :index, :report => '2'
    assert_response :success
    assert_template 'tickets/index'    
    assert_valid_markup
    assert_select 'tbody>tr.record', 3
    @controller = TicketsController.new        
  end

  def test_index_update
    xhr :get, :index, :page => 2
    assert_response :success
  end

  def test_redirect_to_ticket
    ticket = Ticket.find :first
    get :index, :id => ticket.id
    assert_response :success
    assert_template 'tickets/index'    

    post :index, :id => ticket.id
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
  end
  
  def test_show
    get :show
    assert_response :redirect
    assert_redirected_to :action => 'index'    

    get :show, :id => '999'
    assert_response :redirect
    assert_redirected_to :action => 'index'    
  
    get :show, :id => '1'
    assert_response :success
    assert_template 'tickets/show'
    assert_valid_markup

    post :show, :id => '1'
    assert_response :success
    assert_template 'tickets/show'    
    assert_valid_markup

    # Now do the same as admit, verify additional handles
    login(:admin)
    project_name = Ticket.find(1).project.short_name
    get :show, :id => '1'
    assert_response :redirect
    assert_redirected_to :action => "show", :id => '1', :project_name => project_name

    get :show, :id => '1', :project_name => project_name
    assert_response :success
    assert_template 'tickets/show'    
    assert_valid_markup
    assert_select 'a#ticket-summary-externalControl', 1
    assert_select 'a#ticket-content-externalControl', 1
    assert_select 'a#ticket-change-content-1-externalControl', 1
  end

  def test_show_markup
    get :show, :id => '4'
    assert_response :success
    assert_template 'tickets/show'
    content_links = css_select("div#ticket-content a")
    assert_equal ["http://example.com/?a=b&#38;c=d;e=f"],
                 content_links.collect {|a| a["href"]}
  end

  def test_update
    ticket = Ticket.find(1)
    content = 'Some comment'
    assert_equal(1, ticket.status_id)
    assert_equal(1, ticket.priority_id)
    assert_equal(0, ticket.subscribers.count)
    assert_equal(3, ticket.milestone_id)
    
    post :update, :id => ticket.id, :ticket => { :priority_id => '3', :status_id => '2', :milestone_id => '' }, :change => { :author => 'Me', :content => content }, :subscribe => '1'
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal(2, ticket.status_id)
    assert_equal(3, ticket.priority_id)
    assert_equal(0, ticket.subscribers.count)
    assert_equal(nil, ticket.milestone_id)
    assert_equal(['Milestone', 'Priority', 'Status'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(3, ticket.ticket_changes.count)
    
    get :update, :id => ticket.id
    assert_response :redirect
    assert_redirected_to :action => 'index'

    post :update, :id => ticket.id, :ticket => { :priority_id => '2', :status => '999', :property_ids => [3] }, :change => { :author => 'Me' }
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal('Me', ticket.ticket_changes.last.author)
    assert_equal(2, ticket.status_id)
    assert_equal(2, ticket.priority_id)
    assert_equal([3], ticket.property_ids)
    assert_equal(0, ticket.subscribers.count)
    assert_equal(nil, ticket.milestone_id)
    assert_equal(['Component', 'Priority'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(4, ticket.ticket_changes.count)

    post :update, :id => ticket.id, :ticket => {}, :change => { :author => 'Me' }
    assert_response :success
    ticket.reload
    assert_equal(2, ticket.status_id)
    assert_equal(2, ticket.priority_id)
    assert_equal(0, ticket.subscribers.count)
    assert_equal(nil, ticket.milestone_id)
    assert_equal(4, ticket.ticket_changes.count)

    login(:agent)

    post :update, :id => ticket.id, :ticket => ticket.attributes, :change => {}, :subscribe => '1'
    assert_response :success
    ticket.reload
    assert_equal(0, ticket.subscribers.count)
    assert_equal(4, ticket.ticket_changes.count)
    
    post :update, :id => ticket.id, :ticket => { :priority_id => '3' }, :change => { :author => 'Me' }, :subscribe => '1'
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal(User.current.name, ticket.ticket_changes.last.author)
    assert_equal(2, ticket.status_id)
    assert_equal(3, ticket.priority_id)
    assert_equal(1, ticket.subscribers.count)
    assert_equal(['Priority'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(5, ticket.ticket_changes.count)

    RetroCM[:ticketing][:subscription][:subscribe_on_assignement] = false

    user_login = users(:admin).login
    post :update, :id => ticket.id, :ticket => { :priority_id => '1', :assigned_user_login => user_login }, :change => {}  
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal(2, ticket.status_id)
    assert_equal(1, ticket.priority_id)
    assert_equal(1, ticket.subscribers.count)
    assert_equal(nil, ticket.milestone)
    assert_equal(['Assigned user', 'Priority'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(6, ticket.ticket_changes.count)

    RetroCM[:ticketing][:subscription][:subscribe_on_assignement] = true
    post :update, :id => ticket.id, :ticket => { :milestone_id => '2', :assigned_user_login => nil }, :change => {}  
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal(2, ticket.status_id)
    assert_equal(1, ticket.priority_id)
    assert_equal(1, ticket.subscribers.count)
    assert_equal(2, ticket.milestone_id)
    assert_equal(nil, ticket.assigned_user_id)
    assert_equal(['Assigned user', 'Milestone'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(7, ticket.ticket_changes.count)

    post :update, :id => ticket.id, :ticket => { :priority_id => '2', :assigned_user_login => user_login }, :change => {}  
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal(user_login, ticket.assigned_user_login)
    assert_equal(2, ticket.status_id)
    assert_equal(2, ticket.priority_id)
    assert_equal(2, ticket.subscribers.count)
    assert_equal(2, ticket.milestone_id)
    assert_equal(['Assigned user', 'Priority'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(8, ticket.ticket_changes.count)

    post :update, :id => ticket.id, :ticket => { :priority_id => '1', :assigned_user_login => 'nonexistinguser' }, :change => {}  
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => ticket.id
    ticket.reload
    assert_equal(nil, ticket.assigned_user_login)
    assert_equal(1, ticket.priority_id)
    assert_equal(2, ticket.subscribers.count)
    assert_equal(['Assigned user', 'Priority'], ticket.ticket_changes.last.changes.keys.sort)
    assert_equal(9, ticket.ticket_changes.count)
  end


  def test_toggle_subscription
    ticket = Ticket.find(1)
    
    assert_raises(Retrospectiva::AccessManager::NoAuthorizationError) do
      post :toggle_subscription, :id => '1'
    end
    
    assert_equal(0, ticket.subscribers.count)    

    login(:agent)
    user = User.current

    get :toggle_subscription
    assert_response :redirect
    assert_redirected_to(:action => 'index')

    get :toggle_subscription, :id => '1'
    assert_response :redirect
    assert_redirected_to(:action => 'index')

    assert_equal(0, ticket.subscribers.count)    
    assert_equal(0, users(:agent).ticket_subscriptions.count)    

    post :toggle_subscription, :id => '1'
    assert_response :redirect
    assert_redirected_to(:action => 'show', :id => '1')
    assert_equal(1, ticket.subscribers.count)    
    assert_equal(1, user.ticket_subscriptions.count)    

    post :toggle_subscription, :id => '1'
    assert_response :redirect
    assert_redirected_to(:action => 'show', :id => '1')
    assert_equal(0, ticket.subscribers.count)    
    assert_equal(0, user.ticket_subscriptions.count)    

    user = User.find(@request.session[:user_id])
    user.groups.each do |group|
      group.permissions -= ['subscribe_to_tickets']
      assert(group.save)
    end

    logout
    assert_raises(Retrospectiva::AccessManager::NoAuthorizationError) do
      post :toggle_subscription, :id => '1'
    end
  end


  def test_new
    get :new
    assert_response :success
    assert_template 'tickets/new'
    assert_valid_markup
     
    post :new
    assert_response :success
    assert_template 'tickets/new'
  end

  def test_create
    get :create
    assert_response :redirect
    assert_redirected_to :action => 'new'

    ticket_options = {:content => 'Some content', :author => 'Me'}
    post :create, :ticket => ticket_options    
    assert_response :success
    assert_template 'tickets/new'

    ticket_options[:summary] = 'Some summary'
    post :create, :ticket => ticket_options    
    assert_response :redirect
    last_ticket = Ticket.find(:first, :order => 'id DESC')
    assert_redirected_to :action => 'show', :id => last_ticket.id

    post :create, :ticket => ticket_options.merge(:status_id => 2, :priority_id => 3, :assigned_user_login => 'agent')
    last_ticket = Ticket.find(:first, :order => 'id DESC')
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => last_ticket.id
    assert_equal(2, last_ticket.status_id)
    assert_equal(3, last_ticket.priority_id)
    assert_equal(3, last_ticket.assigned_user_id)

    logout
    post :create, :ticket => ticket_options.merge(:status_id => 99, :priority_id => 'abc', :assigned_user_login => 'Default'), :subscribe => '1'
    last_ticket = Ticket.find(:first, :order => 'id DESC')
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => last_ticket.id
    assert_equal(1, last_ticket.status_id)
    assert_equal(1, last_ticket.priority_id)
    assert_nil(last_ticket.assigned_user_id)
    assert_equal(0, last_ticket.subscribers.count)

    login(:agent)
    post :create, :ticket => ticket_options.merge(:status_id => 2), :subscribe => '1'
    last_ticket = Ticket.find(:first, :order => 'id DESC')
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => last_ticket.id
    assert_equal(2, last_ticket.status_id)
    assert_equal(1, last_ticket.subscribers.count)

    RetroCM[:ticketing][:subscription][:subscribe_on_assignement] = false

    user_login = users(:admin).login
    post :create, :ticket => ticket_options.merge(:assigned_user_login => user_login)
    last_ticket = Ticket.find(:first, :order => 'id DESC')
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => last_ticket.id
    assert_equal(0, last_ticket.subscribers.count)

    RetroCM[:ticketing][:subscription][:subscribe_on_assignement] = true

    user_login = users(:admin).login
    post :create, :ticket => ticket_options.merge(:assigned_user_login => user_login)
    last_ticket = Ticket.find(:first, :order => 'id DESC')
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => last_ticket.id
    assert_equal(1, last_ticket.subscribers.count)
  end

  def test_preview_ticket_content
    get :preview_ticket_content
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new
    
    xhr :get, :preview_ticket_content
    assert_response :success
    assert_equal('Element.update("ticket_content_viewer", "");', @response.body)
    @response = ActionController::TestResponse.new
    
    xhr :get, :preview_ticket_content, :ticket => {:content => 'h1. Test'}
    assert_response :success
    assert_equal("Element.update(\"ticket_content_viewer\", #{'<h1>Test</h1>'.to_json});", @response.body)
    @response = ActionController::TestResponse.new
  end

  def test_preview_change_content
    get :preview_change_content
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new
    
    xhr :get, :preview_change_content
    assert_response :success
    assert_equal('Element.update("change_content_viewer", "");', @response.body)
    @response = ActionController::TestResponse.new
    
    xhr :get, :preview_change_content, :change => {:content => 'h1. Test'}
    assert_response :success
    assert_equal("Element.update(\"change_content_viewer\", #{'<h1>Test</h1>'.to_json});", @response.body)
    @response = ActionController::TestResponse.new
  end
  
  def test_modify_summary
    login(:admin)

    get :modify_summary
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new

    assert_redirect_to_projects_index do
      xhr :get, :modify_summary, :id => 1, :value => 'New summary'
    end

    project_name = Ticket.find(1).project.short_name
    xhr :get, :modify_summary, :id => 1, :value => 'New summary', :project_name => project_name
    assert_response :success
    assert_equal('New summary', @response.body)
  end
  
  def test_modify_content
    login(:admin)

    get :modify_content
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new

    ticket = Ticket.find(:first)
    assert_redirect_to_projects_index do
      xhr :get, :modify_content, :id => ticket.id, :value => 'New *content*'
    end

    project_name = ticket.project.short_name
    xhr :get, :modify_content, :id => ticket.id, :value => 'New *content*', :project_name => project_name
    assert_response :success
    assert_equal('<p>New <strong>content</strong></p>', @response.body)
  end

  def test_modify_content_as_author
    login(:agent)

    RetroCM[:ticketing][:author_modifiable][:tickets] = true
    
    assert_raises(Retrospectiva::AccessManager::NoAuthorizationError) do
      xhr :get, :modify_content, :id => 1, :value => 'New *content*'
    end
    assert_nothing_raised do # Ticket 2 was filed by User 4
      xhr :get, :modify_content, :id => 2, :value => 'New *content*'
    end
    assert_equal('<p>New <strong>content</strong></p>', @response.body)    
  end

  def test_show_content
    login(:admin)

    get :show_content
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new

    ticket = Ticket.find(:first)
    assert_redirect_to_projects_index do
      xhr :get, :show_content, :id => ticket.id
    end

    project_name = ticket.project.short_name
    xhr :get, :show_content, :id => ticket.id, :project_name => project_name
    assert_response :success
    assert_equal(ticket.content, @response.body)  
  end

  def test_edit_change_content
    login(:admin)

    get :modify_change_content
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new

    change = TicketChange.find(:first)
    assert_redirect_to_projects_index do
      xhr :get, :modify_change_content, :id => change.id, :value => 'New *comment*'
    end

    project_name = change.ticket.project.short_name
    xhr :get, :modify_change_content, :id => change.id, :value => 'New *comment*', :project_name => project_name
    assert_response :success
    assert_equal('<p>New <strong>comment</strong></p>', @response.body)
  end

  def test_edit_change_content_as_author
    login(:agent)

    RetroCM[:ticketing][:author_modifiable][:ticket_changes] = true
    
    assert_raises(Retrospectiva::AccessManager::NoAuthorizationError) do
      xhr :get, :modify_change_content, :id => 1, :value => 'New *comment*'
    end
    assert_nothing_raised do # TicketChange 3 was filed by User 4
      xhr :get, :modify_change_content, :id => 3, :value => 'New *comment*'
    end
    assert_equal('<p>New <strong>comment</strong></p>', @response.body)    
  end

  def test_delete_ticket_change
    login(:admin)

    get :delete_ticket_change
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new

    change = TicketChange.find :first, :include => [:ticket]
    assert_redirect_to_projects_index do
      post :delete_ticket_change, :id => change.id
    end

    change = TicketChange.find :first, :include => [:ticket]
    project_name = change.ticket.project.short_name
    post :delete_ticket_change, :id => change.id, :project_name => project_name
    assert_response :redirect
    assert_redirected_to :action => 'show', :id => change.ticket.id
    assert_not_nil flash[:notice]
    assert_equal false, TicketChange.exists?(change.id)
  end


  def test_show_change_content
    login(:admin)

    get :show_change_content
    assert_response :redirect
    assert_redirected_to :action => 'index'
    @response = ActionController::TestResponse.new

    change = TicketChange.find(:first)
    assert_redirect_to_projects_index do
      xhr :get, :show_change_content, :id => change.id
    end

    project_name = change.ticket.project.short_name
    xhr :get, :show_change_content, :id => change.id, :project_name => project_name
    assert_response :success
    assert_equal(change.content.to_s, @response.body)  
  end

  def test_should_support_extended_sql_in_order_clauses
    assert_nothing_raised do
      get :index, :per_page => 1, :order => 'assigned_user.1'
    end
    assert_response :success
    assert_template 'tickets/index'
  end
  
end