require File.dirname(__FILE__) + '/../test_helper'
require 'tasks_controller'

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

class TasksControllerTest < Test::Unit::TestCase
  fixtures :parties, :users, :groups, :groups_users, :backlogs, :periods, :tasks, :task_files, :works, :estimates
  
  def setup
    @controller = TasksController.new
    @request    = ActionController::TestRequest.new
    @response   = ActionController::TestResponse.new
    @request.session[:user_id] = 1000001
    assert_sequences
  end
  
  def teardown
    assert_sequences
  end
  
  def test_index
    get :index
    assert_redirected_to :controller => 'backlogs'
  end
  
  def test_list
    get :list
    assert_redirected_to :controller => 'backlogs'
  end
  
  def test_list_started
    get :list_started, :id => '1'
    assert_response :success
    assert_template 'list_started'
    
    assert_not_nil assigns(:tasks)
    assert_not_nil assigns(:selected_task)
  end
  
  def test_list_started_no_selected_task
    get :list_started
    assert_response :success
    assert_template 'list_started'
    
    assert_not_nil assigns(:tasks)
    assert_nil assigns(:selected_task)
  end
  
  def test_new
    get :new
    
    assert_response :success
    assert_template 'new'
    
    assert_not_nil assigns(:task)
  end
  
  def test_create
    num_tasks = Task.count
    
    post :create, :task => {:description => 'an important task', :backlog_id => '2',
      :period_id => periods(:active).id.to_s}
    
    task = assigns(:task)
    assert_equal [], task.errors.full_messages
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => 'show', :id => periods(:active)
    
    assert_equal num_tasks + 1, Task.count
  end
  
  def test_create_without_period
    num_tasks = Task.count
    
    post :create, :task => {:description => 'an important task', :backlog_id => '2'}
    
    task = assigns(:task)
    assert_equal [], task.errors.full_messages
    
    assert_response :redirect
    assert_redirected_to :controller => 'backlogs', :action => :edit, :id => 2
    
    assert_equal num_tasks + 1, Task.count
  end
  
  def test_edit
    get :edit, :id => 1
    
    assert_response :success
    assert_template 'edit'
    
    assert_not_nil assigns(:task)
    assert assigns(:task).valid?
  end
  
  def test_set_task_description
    post :set_task_description, "id"=>"2", :value => 'New value'
    
    after = Task.find(2)
    assert_equal 'New value', after.description
  end
  
  def test_set_task_description_on_subtask
    post :set_task_description, "id"=>"8", :value => 'New value'
    
    after = Task.find(8)
    assert_equal 'New value', after.description
  end
  
  def test_specify
    post :specify, "id" => tasks(:another).id.to_s
    
    after = Task.find(tasks(:another))
    assert_equal 1, after.children.size
  end
  
  def test_specify_passed_period
    assert_raise RuntimeError do
      post :specify, "id"=>"1"
    end
  end
  
  def test_update
    post :update, :id => 2, :task => {:description => 'Two'}
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => 'show', :id => periods(:active)
    
    after = Task.find(2)
    assert_equal 'Two', after.description
  end
  
  def test_update_make_unplanned
    before = Task.find(2)
    
    post :update, :id => 2, :task => {:period_id => ''}
    
    assert_response :redirect
    assert_redirected_to :controller => 'backlogs', :action => 'show', :id => before.backlog
    
    after = Task.find(2)
    assert_equal nil, after.period_id
    assert_equal nil, after.period
    assert_equal 2, after.position
  end
  
  def test_update_make_unplanned_with_detour
    before = Task.find(2)
    add_stored_detour
    
    post :update, :id => 2, :task => {:period_id => ''}
    
    assert_response :redirect
    assert_redirected_to :controller => 'bogus', :action => :location
    
    after = Task.find(2)
    assert_equal nil, after.period_id
    assert_equal nil, after.period
    assert_equal 2, after.position
  end
  
  def test_destroy
    assert_not_nil Task.find(1)
    
    post :destroy, :id => 1
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => 'show', :id => periods(:past)
    
    assert_raise(ActiveRecord::RecordNotFound) {
      Task.find(1)
    }
  end
  
  def test_end_work
    before = Task.find(1)
    assert_equal 80, before.total_done
    
    post :end_work, :id => 1, :work => {:work_started_at_time => (Time.now - 3600).strftime('%H:%M')}
    assert_response :redirect
    assert_redirected_to :controller => 'works', :action => :new, 
                          'work[hours]' => "0.25",
                          'work[task_id]' => 1,
                          'work[completed_at]' => Time.next_quarter.iso8601,
                          'work[started_at]' => Time.previous_quarter.iso8601,
                          'estimate[todo]' => 1
    
    after = Task.find(1)
    assert_equal 80, after.total_done
  end
  
  def test_move_to__subtask_to_top
    subtask = tasks(:subtask)
    subtask_before = Task.find(subtask.id)
    supertask = tasks(:supertask)
    supertask_before = Task.find(supertask.id)
    
    post :move_to, :id => subtask.id.to_s, :target_id => supertask.id.to_s
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => :show_no_layout, :id => subtask_before.root_task.period_id
    
    subtask_after = Task.find(subtask.id)
    assert_equal subtask.root_task.period_id, subtask_after.period_id
    assert_equal 3, subtask_after.position
  end
  
  def test_move_to_next_period
    before = Task.find(tasks(:another).id)
    
    post :move_to_next_period, :id => tasks(:another).id
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => :show, :id => periods(:active)
    
    after = Task.find(tasks(:another).id)
    assert_equal tasks(:another).period_id, after.period_id
    
    new_task = Task.find_by_period_id_and_previous_task_id(periods(:future).id, before.id)
    assert_nil new_task.finished_at
    assert_nil new_task.resolution
    assert_equal 1, new_task.position
  end
  
  def test_move_to_next_period_from_past
    task = tasks(:first)
    before = Task.find(task.id)
    
    post :move_to_next_period, :id => task.id
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => :show, :id => periods(:past)
    
    after = Task.find(task.id)
    assert_equal task.period_id, after.period_id
    
    new_task = Task.find_by_period_id_and_previous_task_id(periods(:active).id, task.id)
    assert_nil new_task.finished_at
    assert_nil new_task.resolution
    assert_equal 1, new_task.position
  end
  
  def test_move_to_next_period_at_end
    before = Task.find(tasks(:in_last_period).id)
    assert_equal tasks(:in_last_period).period_id, before.period_id
    
    post :move_to_next_period, :id => tasks(:in_last_period).id
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => :new, :period => {:party_id => 1}
    
    before.reload
    assert_equal tasks(:in_last_period).period_id, before.period_id
    
    after = Task.find(tasks(:in_last_period).id)
    assert_equal before.period_id, after.period_id
  end
  
  def test_move_to_next_period_from_ancient
    before = tasks(:in_ancient)
    previous_last_id = Task.find(:first, :order => 'id DESC').id
    
    post :move_to_next_period, :id => before.id
    
    assert_response :redirect
    assert_redirected_to :controller => 'periods', :action => :show, :id => periods(:ancient).id
    
    after = Task.find(before.id)
    assert_equal before.period_id, after.period_id
    assert_equal Task::POSTPONED, after.resolution
    assert_not_nil after.finished_at
    
    new = Task.find(:first, :order => 'id DESC', :conditions => "id > #{previous_last_id}")
    assert_not_nil new
    assert_equal before.id, new.previous_task_id
    assert_equal 1, new.position
  end
  
  def test_move_to_period
    highest = Task.find(:first, :order => 'id DESC')
    
    post :move_to_period, :id => "task_#{tasks(:another).id}",
        :detour => {:action => 'show_no_layout', :id => periods(:active).id, :controller => 'periods'}, 
        :period_id => periods(:future).id
    
    new_task = Task.find(:first, :order => 'id DESC')
    assert new_task.id != highest.id
    assert_equal periods(:future).id, new_task.period_id
  end
  
  def test_move_to_period_past
    post :move_to_period, :id => "task_#{tasks(:another).id}",
        :detour => {:action => 'show_no_layout', :id => periods(:active).id, :controller => 'periods'}, 
        :period_id => periods(:past).id
    assert_equal periods(:active).id, tasks(:another).period_id
  end
  
  def test_move_to_period_back_to_earlier_period
    task_to_move = tasks(:in_last_period)
    target_task = tasks(:postponed)
    target_period = periods(:active)
    
    post :move_to_period, {"id"=> task_to_move.id,
                          "detour"=>{"action"=>"edit_no_layout", "id"=>"39", "controller"=>"backlogs"}, 
                          "period_id"=> target_period.id
    }
    
    old_task = Task.find(task_to_move.id)
    assert_not_nil old_task.finished_at
    assert_equal Task::POSTPONED, old_task.resolution
    assert_nil old_task.position
    
    new_task = Task.find(target_task.id)
    new_task.reload
    assert_nil new_task.finished_at
    assert_nil new_task.resolution
    assert_equal 1, new_task.position
  end

  def test_abort
    post :abort, :id => tasks(:first).id
    
    after = Task.find(tasks(:first).id)
    assert_not_nil after.finished_at
    assert_equal Task::ABORTED, after.resolution
  end
  
  def test_start_work
    task_id = tasks(:first).id
    
    post :start_work, :id => task_id
    
    after = Task.find(task_id)
    assert after.work_started?
  end
  
end