deckshuffler 0.0.2

data/test/unit/card_size_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CardSizeTest < Test::Unit::TestCase
+  
+  def test_comparator_compares_on_human_day_approximate
+    card_size1 = CardSize.new()
+    card_size2 = CardSize.new()
+    card_size1.human_day_approximate=(1)
+    card_size2.human_day_approximate=(2)
+    
+    assert_equal(card_size1.human_day_approximate() <=> card_size2.human_day_approximate(), card_size1 <=> card_size2 )
+    assert_equal(card_size2.human_day_approximate() <=> card_size1.human_day_approximate(), card_size2 <=> card_size1 )
+  end
+  
+  def test_comparator_returns_nil_when_comparing_non_status
+    card_size = CardSize.new()
+    card_size.human_day_approximate=(1)
+    assert_nil card_size <=> 1
+    assert_nil card_size <=> nil
+  end
+end

data/test/unit/card_test.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CardTest < Test::Unit::TestCase
+  fixtures :card_sizes, :card_types, :priorities, :project_infos
+
+  def test_save_with_estimate_in_status_new_transitions_to_estimated
+    card = Card.new(:title => "Test", :description => "Test Description", :card_type => CardType.find(1))
+    assert(card.save())
+    
+    assert_equal(Status::NEW, card.status())
+    
+    card.estimated_size=(CardSize.find(1))
+    assert(card.save())
+    
+    assert_equal(Status::ESTIMATED, card.status())
+  end
+  
+  def test_update_with_estimate_in_status_new_transitions_to_estimated
+    card = Card.new(:title => "Test", :description => "Test Description", :card_type => CardType.find(1))
+    assert(card.save())
+    
+    assert_equal(Status::NEW, card.status())
+    
+    assert(card.update_attributes({:estimated_size_id => 1}))
+    
+    assert_equal(Status::ESTIMATED, card.status())
+  end
+  
+  def test_save_to_status_in_play_changes_priority_to_high
+    card = Card.new(:title => "Test", :description => "Test Description", :card_type => CardType.find(1))
+    assert(card.save())
+    
+    assert_equal(Status::NEW, card.status())
+    
+    card.status=(Status::IN_PLAY)
+    assert(card.save())
+    
+    assert_equal(Priority.find(:first, :conditions => "name = 'High'"), card.priority())
+  end
+  
+  def test_update_to_status_in_play_changes_priority_to_high
+    card = Card.new(:title => "Test", :description => "Test Description", :card_type => CardType.find(1))
+    assert(card.save())
+    
+    assert_equal(Status::NEW, card.status())
+    
+    assert(card.update_attributes({:status_name => "InPlay"}))
+    
+    assert_equal(Priority.find(:first, :conditions => "name = 'High'"), card.priority())
+  end
+end

data/test/unit/card_type_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CardTypeTest < Test::Unit::TestCase
+  def test_comparator_compares_on_id
+    card_type1 = CardType.new()
+    card_type2 = CardType.new()
+    card_type1[:id]=(1)
+    card_type2[:id]=(2)
+    
+    assert_equal(card_type1.id() <=> card_type2.id(), card_type1 <=> card_type2 )
+    assert_equal(card_type2.id() <=> card_type1.id(), card_type2 <=> card_type1 )
+  end
+  
+  def test_comparator_returns_nil_when_comparing_non_card_type
+    card_type = CardType.new()
+    card_type[:id]=(1)
+    assert_nil card_type <=> 1
+    assert_nil card_type <=> nil
+  end
+end

data/test/unit/milestone_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MilestoneTest < Test::Unit::TestCase
+  def test_comparator_compares_on_id
+    milestone1 = Milestone.new()
+    milestone2 = Milestone.new()
+    milestone1[:id]=(1)
+    milestone2[:id]=(2)
+    
+    assert_equal(milestone1.id() <=> milestone2.id(), milestone1 <=> milestone2 )
+    assert_equal(milestone2.id() <=> milestone1.id(), milestone2 <=> milestone1 )
+  end
+  
+  def test_comparator_returns_nil_when_comparing_non_milestones
+    milestone = Milestone.new()
+    milestone[:id]=(1)
+    assert_nil milestone <=> 1
+    assert_nil milestone <=> nil
+  end
+end

data/test/unit/priority_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PriorityTest < Test::Unit::TestCase
+  def test_comparator_compares_on_rank
+    priority1 = Priority.new()
+    priority2 = Priority.new()
+    priority1[:rank]=(1)
+    priority2[:rank]=(2)
+    
+    assert_equal(priority1.rank() <=> priority2.rank(), priority2 <=> priority1 )
+    assert_equal(priority2.rank() <=> priority1.rank(), priority1 <=> priority2 )
+  end
+  
+  def test_comparator_returns_nil_when_comparing_non_priority
+    priority = Priority.new()
+    priority[:rank]=(1)
+    assert_nil priority <=> 1
+    assert_nil priority <=> nil
+  end
+end

data/test/unit/status_test.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class StatusTest < Test::Unit::TestCase
+  def test_comparator_compares_on_precedence
+    for status1 in Status.values()
+      for status2 in Status.values()
+        assert_equal(status1.precedence() <=> status2.precedence(), status1 <=> status2)
+      end
+    end
+  end
+  
+  def test_comparator_returns_nil_when_comparing_non_status
+      for status in Status.values()
+        assert_nil status <=> 1
+        assert_nil status <=> nil
+      end
+  end
+
+  def test_NEW_has_DROPPED_as_successors_and_is_inactive
+    assert_equal("New", Status::NEW.name())
+    assert_equal([Status::DROPPED],Status::NEW.successors())
+    assert(! Status::NEW.active?())
+  end
+  
+  def test_ESTIMATED_has_IN_PLAY_DROPPED_as_successors_and_is_inactive
+    assert_equal("Estimated", Status::ESTIMATED.name())
+    assert_equal([Status::IN_PLAY,Status::DROPPED],Status::ESTIMATED.successors())
+    assert(! Status::ESTIMATED.active?())
+  end
+  
+  def test_IN_PLAY_has_ESTIMATED_IN_DEV_DROPPED_as_successors_and_is_active
+    assert_equal("In Play", Status::IN_PLAY.name())
+    assert_equal([Status::ESTIMATED,Status::IN_DEV,Status::DROPPED],Status::IN_PLAY.successors())
+    assert(Status::IN_PLAY.active?())
+  end
+  
+  def test_IN_DEV_has_IN_PLAY_COMPLETE_DROPPED_as_successors_and_is_active
+    assert_equal("In Development", Status::IN_DEV.name())
+    assert_equal([Status::IN_PLAY,Status::COMPLETE,Status::DROPPED],Status::IN_DEV.successors())
+    assert(Status::IN_DEV.active?())
+  end
+  
+  def test_COMPLETE_has_IN_DEV_IN_ACCEPTANCE_DROPPED_as_successors_and_is_active
+    assert_equal("Complete", Status::COMPLETE.name())
+    assert_equal([Status::IN_ACCEPTANCE,Status::DROPPED],Status::COMPLETE.successors())
+    assert(Status::COMPLETE.active?())
+  end
+  
+  def test_IN_ACCEPTANCE_has_ACCEPTED_REJECTED_DROPPED_as_successors_and_is_active
+    assert_equal("In Acceptance", Status::IN_ACCEPTANCE.name())
+    assert_equal([Status::ACCEPTED,Status::REJECTED,Status::DROPPED],Status::IN_ACCEPTANCE.successors())
+    assert(Status::IN_ACCEPTANCE.active?())
+  end
+  
+  def test_ACCEPTED_has_DELIVERED_DROPPED_as_successors_and_is_active
+    assert_equal("Accepted", Status::ACCEPTED.name())
+    assert_equal([Status::REJECTED,Status::DROPPED],Status::ACCEPTED.successors())
+    assert(Status::ACCEPTED.active?())
+  end
+  
+  def test_REJECTED_has_IN_DEV_IN_ACCEPTANCE_DROPPED_as_successors_and_is_active
+    assert_equal("Rejected", Status::REJECTED.name())
+    assert_equal([Status::IN_DEV,Status::IN_ACCEPTANCE,Status::DROPPED],Status::REJECTED.successors())
+    assert(Status::REJECTED.active?())
+  end
+  
+  def test_DROPPED_has_no_successors_and_is_not_active
+    assert_equal("Dropped", Status::DROPPED.name())
+    assert(Status::DROPPED.successors().empty?())
+    assert(! Status::DROPPED.active?())
+  end
+  
+  def test_DELIVERED_has_no_successors_and_is_not_active
+    assert_equal("Delivered", Status::DELIVERED.name())
+    assert(Status::DELIVERED.successors().empty?())
+    assert(! Status::DELIVERED.active?())
+  end
+  
+  def test_get_returns_the_value_from_its_name
+    for status in Status.values()
+      assert_same(status, Status.get(status.name()))
+    end
+  end
+  
+  def test_values_contains_all_statuses
+    expectedStatuses = [Status::NEW,Status::ESTIMATED,Status::IN_PLAY,Status::IN_DEV,Status::COMPLETE,Status::IN_ACCEPTANCE,Status::ACCEPTED,Status::REJECTED,Status::DROPPED,Status::DELIVERED]
+    statuses = Status.values()
+    assert_equal(expectedStatuses.size(),statuses.size())
+    for status in expectedStatuses
+      assert(statuses.include?(status))
+    end
+  end
+end

data/test/unit/transition_manager_test.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TransitionManagerTest < Test::Unit::TestCase
+  include TransitionManager
+  
+  def test_successor_statuses_returns_all_successors_when_card_is_independent
+    card = Card.create()
+    for status in Status.values()
+      card.status=(status)
+      assert_equal(status.successors(), successor_statuses(card))
+    end
+  end
+  
+  def test_successor_statuses_does_not_contain_DROPPED_when_card_has_children
+    assert_status_absent_when_child_in_status(Status::DROPPED, Status::NEW)
+  end
+  
+  def test_successor_statuses_does_not_contain_IN_PLAY_when_card_has_IN_DEV_children
+    assert_status_absent_when_child_in_status(Status::IN_PLAY, Status::IN_DEV)
+  end
+  
+  def test_successor_statuses_does_not_contain_ESTIMATED_when_card_has_IN_PLAY_children
+    assert_status_absent_when_child_in_status(Status::ESTIMATED, Status::IN_PLAY)
+  end
+  
+  def test_successor_statuses_contains_IN_DEV_when_card_IN_PLAY_and_has_IN_PLAY_children
+    card = Card.create()
+    card.status=(Status::IN_PLAY)
+    child_card = Card.create()
+    child_card.status=(Status::IN_PLAY)
+    card.child_cards=([child_card])
+    assert(successor_statuses(card).include?(Status::IN_DEV))
+    assert(transition_allowed?(card,Status::IN_DEV))
+  end
+  
+  def test_successor_statuses_contains_all_successors_when_card_has_COMPLETE_parents
+    assert_no_status_absent_when_parent_in_status(Status::COMPLETE)
+  end
+  
+  def test_successor_statuses_contains_all_successors_when_card_has_IN_ACCEPTANCE_parents
+    assert_no_status_absent_when_parent_in_status(Status::IN_ACCEPTANCE)
+  end
+  
+  def test_successor_statuses_contains_all_successors_when_card_has_ACCEPTED_parents
+    assert_no_status_absent_when_parent_in_status(Status::ACCEPTED)
+  end
+  
+  def test_successor_statuses_contains_all_successors_when_card_has_DELIVERED_parents
+    assert_no_status_absent_when_parent_in_status(Status::DELIVERED)
+  end
+  
+  def test_successor_statuses_contains_all_successors_when_card_has_REJECTED_parents
+    assert_no_status_absent_when_parent_in_status(Status::REJECTED)
+  end
+  
+  def test_successor_statuses_does_not_contain_IN_DEV_when_card_has_IN_PLAY_parents
+    assert_status_absent_when_parent_in_status(Status::IN_DEV,Status::IN_PLAY)
+  end
+  
+  def test_successor_statuses_does_not_contain_IN_PLAY_when_card_has_NEW_parents
+    assert_status_absent_when_parent_in_status(Status::IN_PLAY,Status::NEW)
+  end
+  
+  def test_apply_transition_to_IN_PLAY_moves_ESTIMATED_parents_to_IN_PLAY
+    card = Card.create()
+    parent_card = Card.create()
+    parent_card.status=(Status::ESTIMATED)
+    other_parent_card = Card.create()
+    card.parent_cards<<([parent_card,other_parent_card])
+    
+    apply_transition(card, Status::IN_PLAY)
+    
+    assert_same(Status::IN_PLAY, card.status())
+    assert_same(Status::IN_PLAY, parent_card.status())
+    assert(other_parent_card.status().nil?())
+  end
+  
+  def test_apply_transition_to other_than_IN_PLAY_does_not_change_parent_cards
+    card = Card.create()
+    parent_card = Card.create()
+    parent_card.status=(Status::ESTIMATED)
+    other_parent_card = Card.create()
+    card.parent_cards<<([parent_card,other_parent_card])
+    for status in Status.values().select {|s| Status::ESTIMATED != s}
+      apply_transition(card, status)
+    
+      assert_same(status, card.status())
+      assert_same(Status::ESTIMATED, parent_card.status())
+      assert(other_parent_card.status().nil?())
+    end
+  end
+  
+  private
+  def assert_status_absent_when_child_in_status(absent_status, child_status)
+    card = Card.create()
+    child_card = Card.create()
+    child_card.status=(child_status)
+    other_child_card = Card.create()
+    other_child_card.status=(Status::NEW)
+    card.child_cards=([child_card, other_child_card])
+    for status in Status.values()
+      original_successors = status.successors().clone()
+      card.status=(status)
+      assert(! successor_statuses(card).include?(absent_status))
+      assert(! transition_allowed?(card,absent_status))
+      # verify that that the original successors list was not modified.
+      assert_equal(original_successors, status.successors)
+    end
+  end
+  
+  def assert_status_absent_when_parent_in_status(absent_status, parent_status)
+    card = Card.create()
+    parent_card = Card.create()
+    parent_card.status=(parent_status)
+    card.parent_cards<<([parent_card,Card.create()])
+    for status in Status.values()
+      original_successors = status.successors().clone()
+      card.status=(status)
+      assert(! successor_statuses(card).include?(absent_status))
+      assert(! transition_allowed?(card,absent_status))
+      # verify that that the original successors list was not modified.
+      assert_equal(original_successors, status.successors)
+    end
+  end
+  
+  def assert_no_status_absent_when_parent_in_status(parent_status)
+    card = Card.create()
+    parent_card = Card.create()
+    parent_card.status=(parent_status)
+    card.parent_cards<<([parent_card,Card.create()])
+    for status in Status.values()
+      original_successors = status.successors().clone()
+      card.status=(status)
+      assert_equal(status.successors(), successor_statuses(card))
+      for succeding_status in status.successors()
+        assert(transition_allowed?(card,succeding_status))
+      end
+      # verify that that the original successors list was not modified.
+      assert_equal(original_successors, status.successors)
+    end
+  end
+end

data/test/unit/user_notifier_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'user_notifier'
+
+class UserNotifierTest < Test::Unit::TestCase
+  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
+  CHARSET = "utf-8"
+
+  include ActionMailer::Quoting
+
+  def setup
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    ActionMailer::Base.deliveries = []
+
+    @expected = TMail::Mail.new
+    @expected.set_content_type "text", "plain", { "charset" => CHARSET }
+  end
+  
+  # Code was generated, no tests at this point.
+  def test_true
+	assert true
+  end
+
+  private
+    def read_fixture(action)
+      IO.readlines("#{FIXTURES_PATH}/user_notifier/#{action}")
+    end
+
+    def encode(subject)
+      quoted_printable(subject, CHARSET)
+    end
+end

data/test/unit/user_test.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UserTest < Test::Unit::TestCase
+  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead.
+  # Then, you can remove it from this and the functional test.
+  include AuthenticatedTestHelper
+  fixtures :users
+
+  def test_should_create_user
+    assert_difference User, :count do
+      user = create_user
+      assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+    end
+  end
+
+  def test_should_require_login
+    assert_no_difference User, :count do
+      u = create_user(:login => nil)
+      assert u.errors.on(:login)
+    end
+  end
+
+  def test_should_require_password
+    assert_no_difference User, :count do
+      u = create_user(:password => nil)
+      assert u.errors.on(:password)
+    end
+  end
+
+  def test_should_require_password_confirmation
+    assert_no_difference User, :count do
+      u = create_user(:password_confirmation => nil)
+      assert u.errors.on(:password_confirmation)
+    end
+  end
+
+  def test_should_require_email
+    assert_no_difference User, :count do
+      u = create_user(:email => nil)
+      assert u.errors.on(:email)
+    end
+  end
+
+  def test_should_reset_password
+    users(:quentin).update_attributes(:password => 'new password', :password_confirmation => 'new password')
+    assert_equal users(:quentin), User.authenticate('quentin', 'new password')
+  end
+
+  def test_should_not_rehash_password
+    users(:quentin).update_attributes(:login => 'quentin2')
+    assert_equal users(:quentin), User.authenticate('quentin2', 'test')
+  end
+
+  def test_should_authenticate_user
+    assert_equal users(:quentin), User.authenticate('quentin', 'test')
+  end
+
+  def test_should_set_remember_token
+    users(:quentin).remember_me
+    assert_not_nil users(:quentin).remember_token
+    assert_not_nil users(:quentin).remember_token_expires_at
+  end
+
+  def test_should_unset_remember_token
+    users(:quentin).remember_me
+    assert_not_nil users(:quentin).remember_token
+    users(:quentin).forget_me
+    assert_nil users(:quentin).remember_token
+  end
+
+  protected
+    def create_user(options = {})
+      User.create({ :login => 'quire', :email => 'quire@example.com', :password => 'quire2', :password_confirmation => 'quire2' }.merge(options))
+    end
+end