deckshuffler 0.0.2

data/test/functional/board_controller_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'board_controller'
+
+# Re-raise errors caught by the controller.
+class BoardController; def rescue_action(e) raise e end; end
+
+class BoardControllerTest < Test::Unit::TestCase
+  fixtures :users, :project_infos, :cards, :priorities
+
+  def setup
+    @controller = BoardController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_page_title_should_return_board_info_when_action_is_index
+    login_as(:quentin)
+    get :index
+    assert_equal("In Play, iteration #{ProjectInfo.find(:first).current_iteration().to_s()}", @controller.page_title)
+  end
+  
+  def test_footer_menu_should_contain_import_as_last_element
+    menu = @controller.footer_menu()
+    import_menu_element = menu.pop()
+    assert_equal('Import', import_menu_element[0])
+    assert_equal({:action => 'import', :controller => 'cards'}, import_menu_element[1])
+  end
+end

data/test/functional/capacities_controller_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'capacities_controller'
+
+# Re-raise errors caught by the controller.
+class CapacitiesController; def rescue_action(e) raise e end; end
+
+class CapacitiesControllerTest < Test::Unit::TestCase
+  fixtures :capacities, :project_infos, :users
+
+  def setup
+    @controller = CapacitiesController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_create_redirected_when_not_logged_in
+    post :create, :capacity => {:developer_name => 'quentin', :planned_capacity => 10}
+    
+    assert_response :redirect
+    assert_redirected_to :controller => 'account', :action => 'login'
+  end
+  
+  def test_create_saves_capacity_with_current_iteration
+    login_as(:quentin)
+    
+    assert_difference Capacity, :count do
+      post :create, :capacity => {:developer_name => 'quentin', :planned_capacity => 10}
+      assert_response :redirect
+      assert_redirected_to :action => 'list'
+    end
+    new_capacity = Capacity.find(:first, :conditions => "developer_name = 'quentin'")
+    assert_equal(ProjectInfo.find(:first).current_iteration(), new_capacity.iteration())
+    assert_equal(10, new_capacity.planned_capacity())
+    assert_nil(new_capacity.actual_capacity())
+  end
+  
+end

data/test/functional/cards_controller_test.rb

@@ -0,0 +1,268 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'cards_controller'
+
+# Re-raise errors caught by the controller.
+class CardsController; def rescue_action(e) raise e end; end
+
+class CardsControllerTest < Test::Unit::TestCase
+  fixtures :cards, :project_infos, :users, :card_types, :priorities, :functional_sets
+  
+  def setup
+    @controller = CardsController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+  
+  def test_raise_card_is_marked_as_snap_back
+    login_as(:quentin)
+    
+    @request.env["HTTP_REFERER"]=("test/test_referer")
+    get :raise_card
+    assert_response :success
+    assert_template 'raise_card'
+    assert_equal("test/test_referer", session[:return_to])
+    assert_not_nil(assigns(:card))
+  end
+  
+  def test_create_uses_marked_snap_back_to_redirect
+    post :create, {:card => {:title => 'Test', :description => 'Test Description', :card_type => CardType.find(1)}}, {:return_to => "/test/test_referer", :user => 1}
+    
+    assert_response :redirect
+    assert_redirected_to "/test/test_referer"
+  end
+  
+  def test_edit_is_marked_as_snap_back
+    login_as(:quentin)
+    
+    @request.env["HTTP_REFERER"]=("test/test_referer")
+    card = Card.find(1)
+    get :edit, :id => card.id()
+    assert_response :success
+    assert_template 'edit'
+    assert_equal("test/test_referer", session[:return_to])
+    assert_equal(card, assigns(:card))
+  end
+  
+  def test_update_uses_marked_snap_back_to_redirect
+    post :update, {:id => 1, :card => {:description => 'Other Test Description'}}, {:return_to => "/test/test_referer", :user => 1}
+    
+    assert_response :redirect
+    assert_redirected_to "/test/test_referer"
+  end
+  
+  def test_list_per_status_loads_cards_in_status
+    login_as(:quentin)
+    status = Status::NEW
+    
+    get :list_per_status, :status_name => status.name()
+    
+    assert_response :success
+    assert_template "list_per_status"
+    assert_equal(Card.find(:all, :conditions => " status_name = '#{status.name()}'"), assigns(:cards))
+    assert_equal(status, assigns(:status))
+    assert_not_nil(assigns(:card_pages))
+  end
+  
+  def test_list_per_user_loads_cards_owned_by_user
+    login_as(:quentin)
+    
+    get :list_per_user, :owner_name => 'quentin'
+    
+    assert_response :success
+    assert_template "list_per_user"
+    assert_equal(Card.find(:all, :conditions => " owner_name = 'quentin'", :order => 'status_name, priority_rank, title'), assigns(:cards))
+    assert_equal('quentin', assigns(:owner))
+    assert_not_nil(assigns(:card_pages))
+  end
+  
+  def test_page_title_should_return_cards_in_functional_set_name_when_action_is_list_per_functional_set
+    login_as(:quentin)
+    functional_set = FunctionalSet.find(:first)
+    get :list_per_functional_set, :id => functional_set.id()
+    assert_equal("Cards in #{functional_set.name()} Set", @controller.page_title)
+  end
+  
+  def test_page_title_should_return_status_name_when_action_is_list_per_status
+    login_as(:quentin)
+    get :list_per_status, :status_name => Status::NEW.name()
+    assert_equal("#{Status::NEW.name()} Cards", @controller.page_title)
+  end
+  
+  def test_page_title_should_return_user_name_when_action_is_list_per_user
+    login_as(:quentin)
+    get :list_per_user, :owner_name => 'aaron'
+    assert_equal("Cards for aaron", @controller.page_title)
+  end
+  
+  def test_page_title_should_return_splitting_card_title_when_action_is_split
+    login_as(:quentin)
+    card = Card.find(:first)
+    get :split, :id => card.id()
+    assert_equal("Splitting #{card.title()} Card", @controller.page_title)
+  end
+  
+  def test_change_status_updates_status_and_redirects_to_list_per_status_when_referred_from_list_per_status
+    login_as(:quentin)
+    
+    @request.env["HTTP_REFERER"]=("/cards/list_per_status?name=""Estimated""")
+    
+    get :change_status, :id => 1, :status_name => Status::NEW.name()
+    
+    assert_response :redirect
+    assert_redirected_to "/cards/list_per_status?name=""Estimated"""
+  end
+  
+  def test_change_status_updates_status_and_redirects_to_index_when_referred_from_index
+    login_as(:quentin)
+    
+    @request.env["HTTP_REFERER"]=("/board/index")
+    
+    get :change_status, :id => 1, :status_name => Status::NEW.name()
+    
+    assert_response :redirect
+    assert_redirected_to "/board/index"
+  end
+  
+  def test_split_is_marked_as_snap_back
+    login_as(:quentin)
+    
+    @request.env["HTTP_REFERER"]=("test/test_referer")
+    get :split, :id => 1
+    assert_response :success
+    assert_template 'split'
+    assert_equal("test/test_referer", session[:return_to])
+    assert_not_nil(assigns(:card))
+  end
+  
+  def test_splitable_true_only_when_card_estimated_or_new_or_in_play
+    card = Card.new()
+    for status in Status.values()
+      card.status=(status)
+      assert_equal([Status::NEW, Status::ESTIMATED, Status::IN_PLAY].include?(status), @controller.splitable?(card))
+    end
+  end
+  
+  def test_split_redirects_to_referer_when_card_not_splitable
+    login_as(:quentin)
+    
+    @request.env["HTTP_REFERER"]=("test/test_referer")
+    get :split, :id => 2
+    assert_response :redirect
+    assert_redirected_to "test_referer"
+  end
+  
+  def test_update_split_uses_marked_snap_back_to_redirect
+    login_as(:quentin)
+    
+    post :update_split, {:id => 1, :slice => {:slices => 3}}, {:return_to => "/test/test_referer", :user => 1}
+    
+    assert_response :redirect
+    assert_redirected_to "/test/test_referer"
+  end
+  
+  def test_update_split_drops_original_card_and_creates_new_cards
+    login_as(:quentin)
+    
+    original_card = Card.find(1)
+    original_status = original_card.status()
+    
+    assert_difference(Card, :count, 3) do
+      post :update_split, :id => 1, :slice => {:slices => 3}
+      assert_response :redirect
+      assert_redirected_to :action => 'index', :controller => 'board'
+      original_card = Card.find(1)
+      assert_same(Status::DROPPED, original_card.status())
+      
+      new_cards = Card.find(:all, :conditions => "title like '#{original_card.title()} (_)'")
+      for card in new_cards do
+        assert_equal(original_card.description(),card.description())
+        assert_same(original_status, card.status())
+        assert_equal(original_card.priority(), card.priority())
+        assert_equal(original_card.estimated_size(), card.estimated_size())
+        assert_equal(original_card.owner_name(), card.owner_name())
+        assert_equal(original_card.target_milestone(), card.target_milestone())
+        assert_equal(original_card.card_type(), card.card_type())
+        assert_equal(original_card.functional_sets(), card.functional_sets())
+        assert_equal(original_card.parent_cards(), card.parent_cards())
+        assert_equal(original_card.child_cards(), card.child_cards())
+      end
+      assert_equal(3, new_cards.size())
+    end
+  end
+  
+  def test_merge_loads_only_mergeable_cards
+    login_as(:quentin)
+    
+    get :merge
+    assert_response :success
+    assert_template 'merge'
+    cards = assigns(:cards)
+    assert_not_nil(cards)
+    assert_equal(cards,Card.find(:all, :conditions => "status_name in ('#{Status::NEW.name()}','#{Status::ESTIMATED.name()}','#{Status::IN_PLAY.name()}')"))
+  end
+  
+  def test_update_merge_redirects_to_edit
+    login_as(:quentin)
+    
+    post :merge_update, :merge_cards => {1 => "true", 2 => "true"}
+    
+    new_card = Card.find(:first, :conditions => 'title like "merged from %"')
+    
+    assert_response :redirect
+    assert_redirected_to :action => 'edit', :id => new_card.id()
+  end
+  
+  def test_update_merge_drops_original_cards_and_creates_new_card
+    login_as(:quentin)
+    
+    original_cards = Card.find(1,2)
+    new_status = original_cards.collect {|card| card.status()}.min()
+    new_size = original_cards.collect {|card| card.estimated_size()}.compact().max()
+    new_priority = original_cards.collect {|card| card.priority()}.min()
+    new_card_type = original_cards.collect {|card| card.card_type()}.min()
+    new_milestone = original_cards.collect {|card| card.target_milestone()}.compact().min()
+    new_child_cards = original_cards.collect {|card| card.child_cards()}.flatten()
+    new_parent_cards = original_cards.collect {|card| card.parent_cards()}.flatten()
+    new_functional_sets = original_cards.collect {|card| card.functional_sets()}.flatten()
+    new_description = original_cards.collect {|card| card.description()}.join("\n")
+    
+    assert_difference(Card, :count) do
+      post :merge_update, :merge_cards => {1 => "true",2 => "true"}
+      original_cards = Card.find(1,2)
+      for original_card in original_cards
+        assert_same(Status::DROPPED, original_card.status())
+      end
+      
+      new_card = Card.find(:first, :conditions => 'title like "merged from %"')
+      assert_equal(new_description,new_card.description())
+      assert_same(new_status, new_card.status())
+      assert_equal(new_priority, new_card.priority())
+      assert_equal(new_size, new_card.estimated_size())
+      assert_equal(new_card_type, new_card.card_type())
+      assert_equal(new_milestone, new_card.target_milestone())
+      assert_equal(new_parent_cards, new_card.parent_cards())
+      assert_equal(new_child_cards, new_card.child_cards())
+      assert_equal(new_functional_sets, new_card.functional_sets())
+    end
+  end
+  
+  def test_merge_cards_should_conserve_owner_when_owned_by_unique_user
+    card1 = Card.new()
+    card2 = Card.new()
+    cards = [card1,card2]
+    card1.owner_name=('aaron')
+    card2.owner_name=('aaron')
+    new_card = @controller.merge_cards(cards)
+    assert_equal('aaron', new_card.owner_name())
+  end
+  
+  def test_merge_cards_should_use_parameter_user_when_owned_by_different_users
+    card1 = Card.new()
+    card2 = Card.new()
+    cards = [card1,card2]
+    card1.owner_name=('aaron')
+    card2.owner_name=('quentin')
+    new_card = @controller.merge_cards(cards,'quentin')
+    assert_equal('quentin', new_card.owner_name())
+  end
+end

data/test/functional/functional_sets_controller_test.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'functional_sets_controller'
+
+# Re-raise errors caught by the controller.
+class FunctionalSetsController; def rescue_action(e) raise e end; end
+
+class FunctionalSetsControllerTest < Test::Unit::TestCase
+  fixtures :users, :functional_sets, :cards
+  
+  def setup
+    @controller = FunctionalSetsController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+  
+  def test_page_title_should_return_functional_sets_when_action_is_list
+    login_as(:quentin)
+    get :list
+    assert_equal("Functional Sets", @controller.page_title)
+  end
+  
+  def test_page_title_should_return_action_name_by_default
+    login_as(:quentin)
+    get 'new'
+    assert_equal('new Functional Set', @controller.page_title)
+  end
+end

data/test/functional/project_infos_controller_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'project_infos_controller'
+
+# Re-raise errors caught by the controller.
+class ProjectInfosController; def rescue_action(e) raise e end; end
+
+class ProjectInfosControllerTest < Test::Unit::TestCase
+  fixtures :project_infos, :users
+
+  def setup
+    @controller = ProjectInfosController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_create_redirected_to_index_when_project_info_exists
+    login_as(:quentin)
+    post :create, :project_info => {:name => 'other_project'}
+    
+    assert_response :redirect
+    assert_redirected_to :controller => 'board', :action => 'index'
+    
+    assert_nil assigns['project_info']
+  end
+  
+  def test_new_redirected_to_index_when_project_info_exists
+    login_as(:quentin)
+    
+    assert ProjectInfo.exists?(1)
+    
+    get :new
+    
+    assert_response :redirect
+    assert_redirected_to :controller => 'board', :action => 'index'
+    
+    assert_nil assigns['project_info']
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/authentication/authenticated_test_helper")
+
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+  include AuthenticatedTestHelper
+end

data/test/unit/capacity_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CapacityTest < Test::Unit::TestCase
+  # Capacity does not contain any code aside from the database link.
+  def test_save
+	capacity = Capacity.new
+	assert(! capacity.save())
+	capacity.developer_name= 'Test'
+	assert_equal(0, capacity.iteration)
+	assert capacity.save
+	capacity.iteration= 'Test'
+	assert(! capacity.save())
+  end
+end