deckshuffler 0.0.2

data/spec/lib/cards_csv_exporter_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'cards_csv_exporter'
+
+describe CardsCSVExporter do
+  before(:each) do
+    @exporter = CardsCSVExporter.new()
+  end
+  
+  it "should write csv format of cards to the file without headers." do
+    cards = Array.new()
+    card_mock = mock("card")
+    cards<<(card_mock)
+    file_mock = mock("file")
+    
+    set_data_write_expectations(file_mock,card_mock)
+    
+    @exporter.export(cards, file_mock, false)
+  end
+  
+  it "should write csv format of cards to the file with headers." do
+    cards = Array.new()
+    card_mock = mock("card")
+    cards<<(card_mock)
+    file_mock = mock("file")
+    
+    titles = ["id","type","title","description","status","size","priority","functional sets","milestone","owner"]
+    
+    set_data_write_expectations(file_mock,card_mock,titles)
+    
+    @exporter.export(cards, file_mock, true)
+  end
+  
+  it "should leave file empty when there are no cards." do
+    file_mock = mock("file")
+    file_mock.should_not_receive("<<")
+    @exporter.export(Array.new(), file_mock, true)
+  end
+  
+  it "should raise an ArgumentError when file is nil." do
+    cards = Array.new()
+    card_mock = mock("card")
+    cards<<(card_mock)
+    lambda {@exporter.export(cards, nil, true)}.should(raise_error(ArgumentError))
+  end
+  
+  def set_data_write_expectations(file_mock,card_mock, titles = nil)
+    card_status = mock("status")
+    card_size = mock("size")
+    card_priority = mock("priority")
+    card_functional_set1 = mock("functional_set1")
+    card_functional_set2 = mock("functional_set2")
+    card_milestone = mock("milestone")
+    card_functional_sets = [card_functional_set1,card_functional_set2]
+    card_type = mock("type")
+    
+    values = ["17","test_type","test_title","test_description","test_status","13","51","test_functional_set1|test_functional_set2","test_milestone","test_user"]
+    
+    # Card Expectations
+    card_status.should_receive(:name).once().and_return(values[4])
+    card_mock.should_receive(:status).once().ordered().and_return(card_status)
+    
+    card_size.should_receive(:human_day_approximate).once().and_return(values[5])
+    card_mock.should_receive(:estimated_size).once().ordered().and_return(card_size)
+    
+    card_priority.should_receive(:rank).once().and_return(values[6])
+    card_mock.should_receive(:priority).once().ordered().and_return(card_priority)
+    
+    card_milestone.should_receive(:name).once().and_return(values[8])
+    card_mock.should_receive(:target_milestone).once().ordered().and_return(card_milestone)
+    
+    card_mock.should_receive(:id).once().ordered().and_return(values[0])
+    card_type.should_receive(:name).once().and_return(values[1])
+    card_mock.should_receive(:card_type).ordered().once().and_return(card_type)
+    card_mock.should_receive(:title).once().ordered().and_return(values[2])
+    card_mock.should_receive(:description).once().ordered().and_return(values[3])
+    card_functional_set1.should_receive(:name).once().and_return("test_functional_set1")
+    card_functional_set2.should_receive(:name).once().and_return("test_functional_set2")
+    card_mock.should_receive(:functional_sets).once().ordered().and_return(card_functional_sets)
+    card_mock.should_receive(:owner_name).once().ordered().and_return(values[9])
+    
+    writer_mock = mock("writer")
+    CSV::Writer.should_receive(:generate).once().with(file_mock).and_yield(writer_mock)
+    writer_mock.should_receive("<<").once().ordered.with(titles) unless titles.nil?()
+    writer_mock.should_receive("<<").once().ordered.with(values.collect {|value| value.to_s()})
+  end
+end

data/spec/lib/cards_csv_importer_spec.rb

@@ -0,0 +1,184 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'cards_csv_importer'
+
+describe CardsCSVImporter do
+  before(:each) do
+    @importer = CardsCSVImporter.new()
+  end
+  
+  it "should parse csv and create cards when the file does not have headers." do
+    card_mock = mock("card")
+    card_type_mock = mock("card_type")
+    card_size_mock = mock("card_size")
+    priority_mock = mock("priority")
+    functional_set_mock1 = mock("functional_set1")
+    functional_set_mock2 = mock("functional_set2")
+    milestone_mock = mock("milestone")
+    file_mock = mock("file")
+    
+    Card.should_receive(:new).once().and_return(card_mock)
+    
+    functional_set_mock1.should_receive(:name).and_return("test_functional_set1")
+    functional_set_mock2.should_receive(:name).and_return("test_functional_set2")
+    
+    values = ["test_type","test_title","test_description","13","51","test_functional_set1|test_functional_set2","test_milestone"]
+    CSV::Reader.should_receive(:parse).once().with(file_mock).and_yield(values)
+    
+    CardType.should_receive("find").once().with(:first, :conditions => "name = \"#{values[0]}\"").and_return(card_type_mock)
+    CardSize.should_receive("find").once().with(:first, :conditions => "human_day_approximate = #{values[3]}").and_return(card_size_mock)
+    Priority.should_receive("find").once().with(:first, :conditions => "rank = #{values[4]}").and_return(priority_mock)
+    FunctionalSet.should_receive("find").once().with(:all, :conditions => "name IN (\"test_functional_set1\",\"test_functional_set2\")").and_return([functional_set_mock1,functional_set_mock2])
+    Milestone.should_receive("find").once().with(:first, :conditions => "name = \"#{values[6]}\"").and_return(milestone_mock)
+    
+    card_mock.should_receive("card_type=").once().with(card_type_mock)
+    card_mock.should_receive("title=").once().with(values[1])
+    card_mock.should_receive("description=").once().with(values[2])
+    card_mock.should_receive("estimated_size=").once().with(card_size_mock)
+    card_mock.should_receive("priority=").once().with(priority_mock)
+    card_mock.should_receive("functional_sets=").once().with([functional_set_mock1,functional_set_mock2])
+    card_mock.should_receive("target_milestone=").once().with(milestone_mock)
+    
+    cards = @importer.import(file_mock)
+    
+    cards.size().should == 1
+    cards[0].should === card_mock
+  end
+  
+  it "should parse csv and create cards, sizes, priorities, functional_sets and milestone when they do not exist." do
+    card_mock = mock("card")
+    card_type_mock = mock("card_type")
+    card_size_mock = mock("card_size")
+    priority_mock = mock("priority")
+    functional_set_mock1 = mock("functional_set1")
+    functional_set_mock2 = mock("functional_set2")
+    milestone_mock = mock("milestone")
+    file_mock = mock("file")
+    
+    functional_set_mock1.should_receive(:name).and_return("test_functional_set1")
+    
+    Card.should_receive(:new).once().and_return(card_mock)
+    
+    values = ["test_type","test_title","test_description","13","51","test_functional_set1|test_functional_set2","test_milestone"]
+    CSV::Reader.should_receive(:parse).once().with(file_mock).and_yield(values)
+    
+    CardType.should_receive("find").once().with(:first, :conditions => "name = \"#{values[0]}\"").and_return(nil)
+    CardSize.should_receive("find").once().with(:first, :conditions => "human_day_approximate = #{values[3]}").and_return(nil)
+    Priority.should_receive("find").once().with(:first, :conditions => "rank = #{values[4]}").and_return(nil)
+    FunctionalSet.should_receive("find").once().with(:all, :conditions => "name IN (\"test_functional_set1\",\"test_functional_set2\")").and_return([functional_set_mock1])
+    Milestone.should_receive("find").once().with(:first, :conditions => "name = \"#{values[6]}\"").and_return(nil)
+    
+    CardType.should_receive(:new).once().with({:name => values[0]}).and_return(card_type_mock)
+    CardSize.should_receive(:new).once().with({:human_day_approximate => values[3], :name => "Imported Size"}).and_return(card_size_mock)
+    Priority.should_receive(:new).once().with({:name => values[4]}).and_return(priority_mock)
+    FunctionalSet.should_receive(:new).once().with({:name => "test_functional_set2"}).and_return(functional_set_mock2)
+    Milestone.should_receive(:new).once().with({:description => "Imported Milestone", :name => values[6]}).and_return(milestone_mock)
+    
+    priority_mock.should_receive("[]=").once().with(:rank,values[4])
+    
+    card_mock.should_receive("card_type=").once().with(card_type_mock)
+    card_mock.should_receive("title=").once().with(values[1])
+    card_mock.should_receive("description=").once().with(values[2])
+    card_mock.should_receive("estimated_size=").once().with(card_size_mock)
+    card_mock.should_receive("priority=").once().with(priority_mock)
+    card_mock.should_receive("functional_sets=").once().with([functional_set_mock1,functional_set_mock2])
+    card_mock.should_receive("target_milestone=").once().with(milestone_mock)
+    
+    cards = @importer.import(file_mock)
+    
+    cards.size().should == 6
+    cards[0].should === card_type_mock
+    cards[1].should === card_size_mock
+    cards[2].should === priority_mock
+    cards[3].should === functional_set_mock2
+    cards[4].should === milestone_mock
+    cards[5].should === card_mock
+  end
+  
+  it "should parse csv and create cards when optional parameters are empty." do
+    card_mock = mock("card")
+    card_type_mock = mock("card_type")
+    file_mock = mock("file")
+    
+    Card.should_receive(:new).once().and_return(card_mock)
+    
+    values = ["test_type","test_title","test_description",nil,nil,nil,nil]
+    CSV::Reader.should_receive(:parse).once().with(file_mock).and_yield(values)
+    
+    CardType.should_receive("find").once().with(:first, :conditions => "name = \"#{values[0]}\"").and_return(card_type_mock)
+    
+    card_mock.should_receive("card_type=").once().with(card_type_mock)
+    card_mock.should_receive("title=").once().with(values[1])
+    card_mock.should_receive("description=").once().with(values[2])
+    
+    cards = @importer.import(file_mock)
+    
+    cards.size().should == 1
+    cards[0].should === card_mock
+  end
+  
+  it "should parse csv and create cards when the file has headers." do
+    card_mock = mock("card")
+    card_type_mock = mock("card_type")
+    card_size_mock = mock("card_size")
+    priority_mock = mock("priority")
+    functional_set_mock1 = mock("functional_set1")
+    functional_set_mock2 = mock("functional_set2")
+    milestone_mock = mock("milestone")
+    file_mock = mock("file")
+    
+    Card.should_receive(:new).once().and_return(card_mock)
+    
+    functional_set_mock1.should_receive(:name).and_return("test_functional_set1")
+    functional_set_mock2.should_receive(:name).and_return("test_functional_set2")
+    
+    titles = ["type","title","description","size","priority","functional sets","milestone"]
+    values = ["test_type","test_title","test_description","13","51","test_functional_set1|test_functional_set2","test_milestone"]
+    CSV::Reader.should_receive(:parse).once().with(file_mock).and_yield(titles).and_yield(values)
+    
+    CardType.should_receive("find").once().with(:first, :conditions => "name = \"#{values[0]}\"").and_return(card_type_mock)
+    CardSize.should_receive("find").once().with(:first, :conditions => "human_day_approximate = #{values[3]}").and_return(card_size_mock)
+    Priority.should_receive("find").once().with(:first, :conditions => "rank = #{values[4]}").and_return(priority_mock)
+    FunctionalSet.should_receive("find").once().with(:all, :conditions => "name IN (\"test_functional_set1\",\"test_functional_set2\")").and_return([functional_set_mock1,functional_set_mock2])
+    Milestone.should_receive("find").once().with(:first, :conditions => "name = \"#{values[6]}\"").and_return(milestone_mock)
+    
+    card_mock.should_receive("card_type=").once().with(card_type_mock)
+    card_mock.should_receive("title=").once().with(values[1])
+    card_mock.should_receive("description=").once().with(values[2])
+    card_mock.should_receive("estimated_size=").once().with(card_size_mock)
+    card_mock.should_receive("priority=").once().with(priority_mock)
+    card_mock.should_receive("functional_sets=").once().with([functional_set_mock1,functional_set_mock2])
+    card_mock.should_receive("target_milestone=").once().with(milestone_mock)
+    
+    cards = @importer.import(file_mock)
+    
+    cards.size().should == 1
+    cards[0].should === card_mock
+  end
+  
+  it "should raise an ArgumentError when card type is missing." do
+    card_mock = mock("card")
+    file_mock = mock("file")
+    
+    Card.should_receive(:new).once().and_return(card_mock)
+    
+    values = [nil,"test_title","test_description",nil,nil,nil,nil]
+    CSV::Reader.should_receive(:parse).once().with(file_mock).and_yield(values)
+    
+    card_mock.should_receive("title=").once().with(values[1])
+    card_mock.should_receive("description=").once().with(values[2])
+    
+    lambda {@importer.import(file_mock)}.should(raise_error(ArgumentError))
+  end
+  
+  it "should raise an ArgumentError when file cannot be parsed." do
+    file_mock = mock("file")
+    values = [17,"test_type"]
+    CSV::Reader.should_receive(:parse).once().with(file_mock).and_yield(values)
+    
+    lambda {@importer.import(file_mock)}.should(raise_error(ArgumentError))
+  end
+  
+  it "should raise an ArgumentError when file is nil." do
+    lambda {@importer.import(nil)}.should(raise_error(ArgumentError))
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# This file is copied to ~/spec when you run 'ruby script/generate rspec'
+# from the project root directory.
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'spec/rails'
+
+Spec::Runner.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures  = false
+  config.fixture_path = RAILS_ROOT + '/spec/fixtures'
+
+  # You can declare fixtures for each behaviour like this:
+  #   describe "...." do
+  #     fixtures :table_a, :table_b
+  #
+  # Alternatively, if you prefer to declare them only once, you can
+  # do so here, like so ...
+  #
+  #   config.global_fixtures = :table_a, :table_b
+  #
+  # If you declare global fixtures, be aware that they will be declared
+  # for all of your examples, even those that don't use them.
+end

data/test/fixtures/capacities.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+another:
+  id: 2

data/test/fixtures/card_sizes.yml

@@ -0,0 +1,6 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+  name: test_size
+another:
+  id: 2

data/test/fixtures/card_types.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+another:
+  id: 2

data/test/fixtures/cards.yml

@@ -0,0 +1,17 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+  card_type_id: 1
+  title: number one
+  description: number one description
+  status_name: New
+  owner_name: quentin
+  priority_rank: 10
+another:
+  id: 2
+  card_type_id: 1
+  title: number one
+  description: number one description
+  status_name: Complete
+  owner_name: aaron
+  priority_rank: 20

data/test/fixtures/functional_sets.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+another:
+  id: 2

data/test/fixtures/milestones.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+one:
+  id: 1
+two:
+  id: 2

data/test/fixtures/priorities.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+one:
+  rank: 10
+  name: High
+two:
+  rank: 20
+  name: Low

data/test/fixtures/project_infos.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+  name: test
+  current_iteration: 2

data/test/fixtures/users.yml

@@ -0,0 +1,17 @@
+quentin:
+  id: 1
+  login: quentin
+  email: quentin@example.com
+  salt: 7e3041ebc2fc05a40c60028e2c4901a81035d3cd
+  crypted_password: 00742970dc9e6319f8019fd54864d3ea740f04b1 # test
+  #crypted_password: "ce2/iFrNtQ8=\n" # quentin, use only if you're using 2-way encryption
+  created_at: <%= 5.days.ago.to_s :db %>
+  # activated_at: <%= 5.days.ago.to_s :db %> # only if you're activating new signups
+aaron:
+  id: 2
+  login: aaron
+  email: aaron@example.com
+  salt: 7e3041ebc2fc05a40c60028e2c4901a81035d3cd
+  crypted_password: 00742970dc9e6319f8019fd54864d3ea740f04b1 # test
+  # activation_code: aaronscode # only if you're activating new signups
+  created_at: <%= 1.days.ago.to_s :db %>

data/test/functional/account_controller_test.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'account_controller'
+
+# Re-raise errors caught by the controller.
+class AccountController; def rescue_action(e) raise e end; end
+
+class AccountControllerTest < Test::Unit::TestCase
+  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead
+  # Then, you can remove it from this and the units test.
+  include AuthenticatedTestHelper
+
+  fixtures :users, :project_infos
+
+  def setup
+    @controller = AccountController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_should_login_and_redirect
+    post :login_post, :login => 'quentin', :password => 'test'
+    assert session[:user]
+    assert_response :redirect
+  end
+
+  def test_should_fail_login_and_not_redirect
+    post :login_post, :login => 'quentin', :password => 'bad password'
+    assert_nil session[:user]
+    assert_response :redirect
+  end
+
+  def test_should_allow_signup
+    assert_difference User, :count do
+      create_user
+      assert_response :redirect
+    end
+  end
+
+  def test_should_require_login_on_signup
+    assert_no_difference User, :count do
+      create_user(:login => nil)
+      assert assigns(:user).errors.on(:login)
+      assert_response :redirect
+    end
+  end
+
+  def test_should_require_password_on_signup
+    assert_no_difference User, :count do
+      create_user(:password => nil)
+      assert assigns(:user).errors.on(:password)
+      assert_response :redirect
+    end
+  end
+
+  def test_should_require_password_confirmation_on_signup
+    assert_no_difference User, :count do
+      create_user(:password_confirmation => nil)
+      assert assigns(:user).errors.on(:password_confirmation)
+      assert_response :redirect
+    end
+  end
+
+  def test_should_require_email_on_signup
+    assert_no_difference User, :count do
+      create_user(:email => nil)
+      assert assigns(:user).errors.on(:email)
+      assert_response :redirect
+    end
+  end
+
+  def test_should_logout
+    login_as :quentin
+    get :logout
+    assert_nil session[:user]
+    assert_response :redirect
+  end
+
+  def test_should_remember_me
+    post :login_post, :login => 'quentin', :password => 'test', :remember_me => "1"
+    assert_not_nil @response.cookies["auth_token"]
+  end
+
+  def test_should_not_remember_me
+    post :login_post, :login => 'quentin', :password => 'test', :remember_me => "0"
+    assert_nil @response.cookies["auth_token"]
+  end
+  
+  def test_should_delete_token_on_logout
+    login_as :quentin
+    get :logout
+    assert_equal @response.cookies["auth_token"], []
+  end
+
+  def test_should_login_with_cookie
+    users(:quentin).remember_me
+    @request.cookies["auth_token"] = cookie_for(:quentin)
+    get :index
+    assert @controller.send(:logged_in?)
+  end
+
+  def test_should_fail_cookie_login
+    users(:quentin).remember_me
+    users(:quentin).update_attribute :remember_token_expires_at, 5.minutes.ago.utc
+    @request.cookies["auth_token"] = cookie_for(:quentin)
+    get :index
+    assert !@controller.send(:logged_in?)
+  end
+
+  def test_should_fail_cookie_login
+    users(:quentin).remember_me
+    @request.cookies["auth_token"] = auth_token('invalid_auth_token')
+    get :index
+    assert !@controller.send(:logged_in?)
+  end
+
+  protected
+    def create_user(options = {})
+      post :signup_post, :user => { :login => 'quire', :email => 'quire@example.com', 
+        :password => 'quire2', :password_confirmation => 'quire2' }.merge(options)
+    end
+    
+    def auth_token(token)
+      CGI::Cookie.new('name' => 'auth_token', 'value' => token)
+    end
+    
+    def cookie_for(user)
+      auth_token users(user).remember_token
+    end
+end