brisk-bills 0.6.0

data/test/unit/activity/material_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class Activity::MaterialTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/activity/proposal_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class Activity::ProposalTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/activity_test.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ActivityTest < ActiveSupport::TestCase
+  fixtures :activities, :clients
+  
+  def test_activity_constraints
+    
+    assert_raise( ActiveRecord::RecordInvalid ) do
+      Activity.create(
+      :is_published => false,
+      :occurred_on => Time.new,
+      :cost => 0
+      ).save!
+    end
+    
+    assert_raise( ActiveRecord::RecordInvalid ) do
+      Activity.create(
+      :is_published => false,
+      :occurred_on => Time.new,
+      :activity_type => '',
+      :cost => 0
+      ).save!
+    end
+    
+    # NOTE: I used to test the costs in here, but, since we've switched to acts_as money, this is no longer needed...
+    
+    assert_nothing_raised do
+      Activity.create(
+      :is_published => false,
+      :occurred_on => Time.new,
+      :activity_type => 'n/a',
+      :cost => 6.66
+      ).save!
+    end
+    
+    assert_nothing_raised do
+      Activity.create(
+      :is_published => false,
+      :occurred_on => Time.new,
+      :activity_type => 'n/a',
+      :cost => 0
+      ).save!
+    end
+    
+     assert_nothing_raised do
+      Activity.create(
+      :is_published => false,
+      :occurred_on => Time.new,
+      :activity_type => 'n/a',
+      :client_id => 1,
+      :cost => nil
+      ).save!
+    end
+    
+    assert_nothing_raised do
+      ddc = Client.find :first, :conditions => [ "company_name = ?","DeRose Design Consultants, Inc."]
+      
+      a1 = Activity.create(
+        :is_published => false,
+        :occurred_on => Time.new,
+        :activity_type => 'n/a',
+        :cost => nil
+      )
+      
+      a1.client = ddc
+      a1.save!
+      
+      a2 = Activity.find a1.id, :include => [:client]
+      
+      assert_equal a2.client_id, ddc.id
+    end
+    
+  end
+  
+  def test_validations
+    a1 = Activity.new :activity_type => nil
+    
+    assert_nothing_raised { a1.valid? }
+    
+    assert_equal 1, a1.errors.length
+    assert_equal true, a1.errors.invalid?(:activity_type)
+  end
+end

data/test/unit/activity_type_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ActivityTypeTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/client_eventlog_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ClientEventlogTest < ActiveSupport::TestCase
+  fixtures :client_eventlogs
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/client_financial_transaction_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ClientFinancialTransactionTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/client_representative_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ClientRepresentativesTest < ActiveSupport::TestCase
+  fixtures :client_representatives
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/client_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ClientTest < ActiveSupport::TestCase
+  fixtures :clients
+
+  def test_is_active
+    acme = Client.create! :company_name => 'ACME Inc.'
+
+    base_clients = ["DeRose Design Consultants, Inc.", "Ashbritt Environmental, Inc.", "CC1 Companies, Inc.", "Academy Roofing", "Affordable Air", "B'nai Congregation", "CC1 Companies, Inc.", "Worldwide Super Abrasives", "Chase Entertainment", "Flying Chimp Media", "GSA", "Lighting Dynamics, Inc.", "Noble Residence", "Garcia Architect", "Scott Rovenger PA", "SarSam", "Gary Slopey", "Thompkins Residence", "United Steel Building"]
+
+    assert_equal base_clients+["ACME Inc."], Client.find_active(:all).collect{|e| e.company_name}
+
+    acme.is_active = false
+    acme.save!
+
+    assert_equal base_clients, Client.find_active(:all).collect{|e| e.company_name}
+
+    assert_equal base_clients, Client.find_active(:all, :conditions => ['id > ?', 0]).collect{|e| e.company_name}
+
+    assert_equal base_clients, Client.find_active(:all, :conditions => 'id > 0').collect{|e| e.company_name}
+
+    assert_equal base_clients, Client.find_active(:all, :conditions => ['id > 0']).collect{|e| e.company_name}
+  end
+end

data/test/unit/credential_test.rb

@@ -0,0 +1,217 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CredentialTest < ActiveSupport::TestCase
+
+  def setup
+    if Setting.exists? :account_lockout_threshold
+      Setting.set! :account_lockout_threshold, 3
+    else  
+      Setting.create!(
+      :keyname     => 'account_lockout_threshold',
+      :label       => 'Account Lockout Threshold',
+      :description => 'Number of incorrect logins before an account is locked out',
+      :keyval      => '3'
+      )
+    end
+
+    if Setting.exists? :account_lockout_duration
+      Setting.set! :account_lockout_duration, 54000
+    else
+      Setting.create!(
+      :keyname     => 'account_lockout_duration',
+      :label       => 'Account Lockout Duration',
+      :description => 'Number of seconds for an account to be locked out, after the lockout threshold has been reached',
+      :keyval      => '54000'
+      ) 
+    end
+
+  end
+
+  # Replace this with your real tests.
+  def test_has_credential_helpers
+    [Employee, ClientRepresentative].each do |user_klass|
+      jsmith = user_klass.create!(
+        :first_name    => 'John', 
+        :last_name     => 'Smith', 
+        :email_address => 'jsmith@test.com', 
+        :password      => 'password'
+      )
+
+      assert_equal 'jsmith@test.com', jsmith.credential.email_address
+      assert_equal 'jsmith@test.com', jsmith.email_address
+      
+      assert_not_equal 'password', jsmith.credential.password_hash
+      assert_not_equal 'password', jsmith.password_hash
+  
+      assert_not_equal 0, jsmith.credential.password_hash.length
+      assert_not_equal 0, jsmith.password_hash.length
+        
+      assert_equal false, jsmith.credential.login_enabled
+      
+      jsmith_cred = Credential.find :first, :conditions => ['email_address = ? ','jsmith@test.com']
+  
+      assert_equal user_klass.to_s, jsmith_cred.user.class.to_s
+      assert_equal jsmith.id, jsmith_cred.user.id
+      
+      jsmith.destroy
+    end
+
+  end
+
+  def test_logins
+    Employee.create!(
+      :first_name    => 'George', 
+      :last_name     => 'Washington', 
+      :email_address => 'gwashington@whitehouse.gov',
+      :password      => 'cherrytree',
+      :login_enabled => false
+    )
+
+    Employee.create!(
+      :first_name    => 'John', 
+      :last_name     => 'Adams', 
+      :email_address => 'jadams@whitehouse.gov',
+      :password      => 'sedition',
+      :login_enabled => true
+    )
+    
+    Employee.create!(
+      :first_name    => 'Thomas', 
+      :last_name     => 'Jefferson', 
+      :email_address => 'tjefferson@whitehouse.gov',
+      :password      => 'monticello',
+      :login_enabled => true
+    )
+    
+    Employee.create!(
+      :first_name    => 'James', 
+      :last_name     => 'Madison', 
+      :email_address => 'jmadison@whitehouse.gov',
+      :password      => '$5000',
+      :login_enabled => true
+    )
+    
+    # Make sure find_user_using_auth works
+    assert_nothing_raised do
+      assert_not_nil Credential.find_using_auth( 'tjefferson@whitehouse.gov', 'monticello' )
+    end
+
+    # Make sure wrong password doesn't work
+    assert_nothing_raised do
+      assert_nil Credential.find_using_auth( 'tjefferson@whitehouse.gov', 'crackattack!' )
+    end
+
+    # Make sure we can't login if the login is disabled...
+    assert_raise CredentialDisabled do
+      Credential.find_using_auth 'gwashington@whitehouse.gov', 'cherrytree'
+    end
+  end
+    
+  def test_humanize_duration_in_seconds
+    # Probably this is silly - but whatever
+    [
+      [1,    '1 second'],
+      [45,   '45 seconds'],
+      [60,   '1 minute'],
+      [3600, '1 hour'],
+      [3601, '1 hour 1 second'],
+      [777,  '12 minutes 57 seconds'],
+      [3661, '1 hour 1 minute 1 second'],
+      [7200, '2 hours'],
+      [7260, '2 hours 1 minute'],
+      [7325, '2 hours 2 minutes 5 seconds'],
+      [100000, '27 hours 46 minutes 40 seconds']
+    ].each do |t|
+      assert_equal t[1], Credential.humanize_duration_from_seconds(t[0])
+    end
+  end
+    
+  def test_lockout
+    Employee.create!(
+      :first_name    => 'James', 
+      :last_name     => 'Monroe', 
+      :email_address => 'jmonroe@whitehouse.gov',
+      :password      => 'florida',
+      :login_enabled => true
+    )
+
+    # We'll use this to simulate the advancement of the clock:
+    time_now = Time.now
+    time_now = Time.local time_now.year, time_now.month, time_now.day, time_now.hour, time_now.min, time_now.sec # Removes usec's
+
+    args_crack = %w(jmonroe@whitehouse.gov crackattack!)
+    args_valid = %w(jmonroe@whitehouse.gov florida)
+
+    2.times do 
+      assert_nothing_raised{ Credential.find_using_auth(*args_crack+[time_now]) } 
+    end
+
+    # Ensure we throw a lockout error
+    assert_raise(CredentialLockedOut) { Credential.find_using_auth(*args_crack+[time_now]) }
+
+    # Ensure we throw a lockout error despite this pass being right
+    assert_raise(CredentialLockedOut) { Credential.find_using_auth(*args_valid+[time_now]) }
+    
+    # Do a success round to clear out the failures from above
+    time_now += 54000 # sleep
+    assert_nothing_raised{ Credential.find_using_auth(*args_valid+[time_now]) } 
+    
+    # Cause a lock-out
+    2.times { Credential.find_using_auth(*args_crack+[time_now]) }
+    
+    assert_raise(CredentialLockedOut) { Credential.find_using_auth(*args_crack+[time_now]) }
+    
+    # Now we sleep out the multiplier
+    time_now += 54000 # sleep
+    
+    # Cause another lockout
+    2.times { Credential.find_using_auth(*args_crack+[time_now]) }
+    assert_raise(CredentialLockedOut) { Credential.find_using_auth(*args_crack+[time_now]) }
+    
+    time_now += 54000 # sleep
+    
+    # Despite being past the duration, this should nonetheless fail b/c of the multiplier
+    assert_raise(CredentialLockedOut) { Credential.find_using_auth(*args_valid+[time_now]) }
+  end
+  
+  def test_password_reset
+    dvader = Employee.create!(
+      :first_name    => 'Darth', 
+      :last_name     => 'Vader', 
+      :email_address => 'dvader@deathstar.com',
+      :password      => 'iamyourfather',
+      :login_enabled => true
+    )
+    
+    valid_reset_token = nil
+    
+    # Test Generation:
+    assert_nothing_raised{ valid_reset_token = dvader.credential.generate_reset_token! }
+    
+    assert_not_nil valid_reset_token
+    
+    assert_match /^[a-z0-9]{32}$/i, valid_reset_token
+    
+    # Test use:
+    assert_equal false, dvader.credential.reset_password_by_token!( '????', 'badnewpassword')
+    
+    assert_equal true, dvader.credential.reset_password_by_token!(valid_reset_token, 'darkside')
+    
+    assert_not_nil Credential.find_using_auth('dvader@deathstar.com', 'darkside')
+
+    # Test Lockout:
+    assert_nothing_raised do
+      valid_reset_token = dvader.credential.generate_reset_token!
+
+      2.times{ assert_equal false, dvader.credential.reset_password_by_token!('????', 'badnewpassword') } 
+    end
+
+    # Ensure we throw a lockout error on next attempt:
+    assert_raise(CredentialLockedOut) { dvader.credential.reset_password_by_token!( '????', 'badnewpassword') }
+
+    # And make sure we continue to fail, now that they're locked out, even if we use a good token:
+    assert_raise(CredentialLockedOut) { dvader.credential.reset_password_by_token! valid_reset_token, 'badnewpassword' }
+
+  end
+  
+end

data/test/unit/employee/slimtimer_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class Employee::SlimTimerTest < ActiveSupport::TestCase
+#  fixtures :employee_slim_timers
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/employee_client_labor_rate_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EmployeeClientLaborRateTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/employee_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EmployeeTest < ActiveSupport::TestCase
+  fixtures :employees,:credentials
+
+  def test_is_active  
+    jsmith = Employee.create! :first_name => 'John', :last_name => 'Smith', :email_address => 'jsmith@test.com'
+    
+    base_employees = ["Chris DeRose", "Arian Amador", "Michael Bogle"]
+    
+    assert_equal base_employees+["John Smith"], Employee.find_active(:all).collect{|e| e.name}
+    
+    jsmith.is_active = false
+    jsmith.save!
+    
+    assert_equal base_employees, Employee.find_active(:all).collect{|e| e.name}
+    
+    assert_equal base_employees, Employee.find_active(:all, :conditions => ['id > ?', 0]).collect{|e| e.name}
+    
+    assert_equal base_employees, Employee.find_active(:all, :conditions => 'id > 0').collect{|e| e.name}
+    
+    assert_equal base_employees, Employee.find_active(:all, :conditions => ['id > 0']).collect{|e| e.name}
+    
+  end
+end

data/test/unit/invoice_payment_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class InvoicePaymentTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/invoice_test.rb

@@ -0,0 +1,459 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../test_unit_factory_helper.rb'
+
+require 'date'
+
+class InvoiceTest < ActiveSupport::TestCase
+
+  fixtures :activity_types
+
+  def setup
+    @activity_types = ActivityType.find :all
+  end
+
+  def test_only_newest_invoice_can_be_unpublished
+    client = Factory.create_client
+    
+    # Once they're published they cant be unpublished unless they're the newest invoice...
+    invoices = [
+      Factory.generate_invoice(100.00, :issued_on => (DateTime.now << 4), :is_published => true ),
+      Factory.generate_invoice(200.00, :issued_on => (DateTime.now << 3), :is_published => true ),
+      Factory.generate_invoice(300.00, :issued_on => (DateTime.now << 2), :is_published => true ),
+      Factory.generate_invoice(400.00, :issued_on => (DateTime.now << 1), :is_published => true )
+    ]
+
+    invoices[0...2].each do |inv|
+      assert_raise(ActiveRecord::RecordInvalid) {set_published inv, false}
+    end
+
+    assert_nothing_raised { set_published invoices[3], false }
+    
+  end
+
+  def test_ensure_client_cant_be_changed
+    client = Factory.create_client
+    client2 = Factory.create_client :company_name => 'Client 2, Inc.'
+    
+    invoice = Factory.generate_invoice 100.00, :client => client
+    
+    assert_raise(ActiveRecord::RecordInvalid) do 
+      invoice.client = client2
+      invoice.save!
+    end
+  end
+
+  def test_is_published_behavior
+    client = Factory.create_client
+
+    Payment.create!(
+      :client => client,
+      :payment_method_id => 1,
+      :amount => 2000.00,
+      :paid_on => (DateTime.now << 1)
+    ) 
+
+    inv = Factory.generate_invoice 1000.00, :issued_on => (DateTime.now >> 12)
+    
+    # Change payment, save:
+    assert_nothing_raised do
+      inv.comments = 'This should be editable'
+      inv.save!
+    end
+    
+    # Now we Mark it published
+    assert_nothing_raised do
+      inv.is_published = true
+      inv.save!
+    end
+    
+    # Now make sure we raise something on edit
+    assert_raise( ActiveRecord::RecordInvalid ) do
+      inv.comments = 'This shouldnt actually work'
+      inv.save!
+    end
+
+    # Now we Mark it unpublished
+    assert_nothing_raised do
+      inv.is_published = false
+      inv.save!
+    end
+
+    # Change payment again, save:
+    assert_nothing_raised do
+      inv.comments = 'This time it should work'
+      inv.save!
+    end
+
+  end
+
+  def test_invoice_create_defaults
+    inv = Invoice.create
+
+    assert_equal Time.utc(*Time.now.to_a).last_month.end_of_month, inv.issued_on
+    assert_equal false, inv.is_published
+  end
+
+  def test_errors
+    client = Factory.create_client
+    
+    # Make sure we cant create an invoice with no client :
+    assert_raise(ActiveRecord::RecordInvalid) { Invoice.create! :client => nil, :issued_on => DateTime.now }
+
+    # Make sure we can't edit the client once an invoice is created (for now ... that might change)
+    invoice = nil
+    assert_nothing_raised { invoice = Invoice.create! :client => client, :issued_on => DateTime.now }
+    
+    invoice.client = Factory.create_client :company_name => 'PBR Inc.'
+    
+    assert_raise(ActiveRecord::RecordInvalid) { invoice.save! }
+  end
+  
+  def test_activity_assignment_on_create_delete
+    invoice = nil
+  
+    client = Factory.create_client
+        
+    # These are a ruse.. make sure these dont get added:
+    Factory.create_labor( {}, {:occurred_on => (DateTime.now >> 1)} ) # This is newer then issued_on
+    Factory.create_labor( {}, {:client_id => 6969} )                  # This is a different client
+    Factory.create_labor( {}, {:is_published => false} )              # This isnt published yet
+    
+    # These will be legit:
+    valid_activities = [
+      Factory.create_labor.activity.id,
+      Factory.create_material.activity.id,
+      Factory.create_proposal.activity.id,
+      Factory.create_adjustment.activity.id
+    ]
+
+    assert_nothing_raised { invoice = Invoice.create! :client => client, :issued_on => (DateTime.now+1), :activity_types => @activity_types }
+    
+    # Make sure the right activities were included:
+    assert_equal 4, invoice.activities.length
+    invoice.activities.each { |a| assert_equal true, valid_activities.include?(a.id) }
+    
+    # Make sure the cost adds up:
+    assert_equal 2421.0, invoice.amount
+    
+    assert_equal 2421.0, (invoice.sub_total+invoice.taxes_total)
+    
+    # Now Make sure we unassign on a delete:
+    assert_nothing_raised { invoice.destroy }
+    
+    valid_activities.each { |a_id| assert_equal nil, Activity.find(a_id).invoice_id }
+  end
+
+  def test_uneditable_upon_is_published
+
+    client = Factory.create_client
+
+    labor = Factory.create_labor
+    material = Factory.create_material
+    proposal = Factory.create_proposal
+    adjustment = Factory.create_adjustment
+    
+    invoice = nil
+    
+    assert_nothing_raised do
+      invoice = Invoice.create!(
+        :client => client, 
+        :issued_on => DateTime.now,
+        :activity_types => @activity_types 
+      )
+
+      invoice.is_published = true
+      invoice.save!
+    end    
+    
+    # Make sure they can't destroy:
+    assert_equal false, invoice.destroy
+    
+    # Make sure they can't update:
+    invoice.comments = "This shouldn't be retained!"
+    assert_raise(ActiveRecord::RecordInvalid) { invoice.save! }
+
+    # Make sure the right activities were included:
+    assert_equal 4, invoice.activities(true).size
+    
+    # Now make sure we can't adjust any of them:
+    invoice.activities.each do |a|
+      # Make sure they can't destroy:
+      assert_equal false, a.destroy
+
+      # Make sure they can't update:
+      a.cost = 69.0
+      assert_raise(ActiveRecord::RecordInvalid) { a.save! }
+
+      # Make sure we can't adjust/destroy the subtype either
+      a_st = a.send(a.activity_type)
+      
+      # Make sure they can't destroy:
+      assert_equal false, a_st.destroy
+      
+      # Make sure they can't update:
+      a_st.comments = "THis Shouldn't get committed...."
+      assert_raise(ActiveRecord::RecordInvalid) { a_st.save! }
+    end
+        
+  end
+  
+  def test_issued_date_updates
+    # This make sure the activity adjustments are working the way they should be
+
+    client = Factory.create_client # This needs to get done here so the factory attaches the activities to it...
+
+    present_date = DateTime.now
+    past_date    = (present_date << 1)
+    future_date  = (present_date >> 1)
+    
+    past_activities = [
+      Factory.create_labor({}, {:occurred_on => past_date}).activity.id,
+      Factory.create_material({}, {:occurred_on => past_date}).activity.id,
+      Factory.create_proposal({}, {:occurred_on => past_date}).activity.id,
+      Factory.create_adjustment({}, {:occurred_on => past_date}).activity.id
+    ]
+    
+    future_activities = [
+      Factory.create_labor({}, {:occurred_on => future_date}).activity.id,
+      Factory.create_material({}, {:occurred_on => future_date}).activity.id,
+      Factory.create_proposal({}, {:occurred_on => future_date}).activity.id,
+      Factory.create_adjustment({}, {:occurred_on => future_date}).activity.id
+    ]
+    
+    invoice = nil
+    assert_nothing_raised { invoice = Invoice.create! :client => client, :issued_on => present_date, :activity_types => @activity_types  }
+    
+    # Make sure the right activities were included:
+    assert_equal 4, invoice.activities(true).size
+    
+    invoice.activities.each do |a| 
+      assert_equal true,  past_activities.include?(a.id) 
+      assert_equal false, future_activities.include?(a.id)
+    end
+    
+    # Now let's set to the way future:
+    assert_nothing_raised do
+      invoice.issued_on = present_date >> 2
+      invoice.save!
+    end
+    
+    # Make sure everything ends up in there:
+    assert_equal 8, invoice.activities(true).size
+    
+    invoice.activities(true).each do |a| 
+      assert_equal true, (past_activities.include?(a.id) or future_activities.include?(a.id) )
+    end
+    
+    # Now let's set back to present:
+    assert_nothing_raised do
+      invoice.issued_on = present_date
+      invoice.save!
+    end
+    
+    # Make sure we're where we should be:
+    assert_equal 4, invoice.activities(true).size
+    
+    invoice.activities.each do |a| 
+      assert_equal true,  past_activities.include?(a.id) 
+      assert_equal false, future_activities.include?(a.id)
+    end
+    
+  end
+
+  def test_invoice_deletes_only_if_recent    
+    invoice_time = Time.new
+    
+    invoices = [20,40,80,160,320,640,1280].collect do |amt| 
+      invoice_time += 1.weeks
+      Factory.generate_invoice amt, :issued_on => invoice_time
+    end
+
+    while invoices.length > 0
+      0.upto(invoices.length-2)  { |i| assert_equal false, invoices[i].destroy }
+    
+      assert_not_equal false, invoices.delete_at(invoices.length-1).destroy
+    end
+    
+  end
+  
+  def test_activity_type_inclusions
+    client = Factory.create_client
+    
+    @activity_types = ActivityType.find :all
+    
+    a_type_map = HashWithIndifferentAccess.new
+    @activity_types.each{|at| a_type_map[at.label.downcase] = at }
+    
+    # First, let's Make sure this includion feature actually works during a create
+    present_date = DateTime.now
+    past_date    = (present_date << 1)
+    
+    activities = [
+      Factory.create_labor({}, {:occurred_on => past_date, :cost => 1.99 }),
+      Factory.create_labor({}, {:occurred_on => past_date, :cost => 1.99 }),
+      Factory.create_material({}, {:occurred_on => past_date}),
+      Factory.create_material({}, {:occurred_on => past_date}),
+      Factory.create_proposal({}, {:occurred_on => past_date}),
+      Factory.create_proposal({}, {:occurred_on => past_date}),
+      Factory.create_adjustment({}, {:occurred_on => past_date}),
+      Factory.create_adjustment({}, {:occurred_on => past_date})
+    ]
+    
+    invoice = nil
+    
+    assert_nothing_raised do 
+      invoice = Invoice.create!(
+        :client => client, 
+        :issued_on => present_date, 
+        :activity_types => [ a_type_map[:material], a_type_map[:labor] ]
+      )
+    end
+
+    assert_equal 1805.96, invoice.amount
+
+    assert_equal 1805.96, (invoice.sub_total+invoice.taxes_total)
+
+    assert_equal(
+      invoice.activity_ids, 
+      activities.select{|a| /^Activity::(Material|Labor)$/.match a.class.to_s}.collect{|a| a.activity.id}
+    )
+    
+    # Let's remove a type and see if this works the way it should:
+    assert_nothing_raised do
+      invoice.activity_types.delete a_type_map[:material]
+      invoice.save!
+      
+      # We have to expire the cache here....
+      invoice.activities(true)
+    end
+
+    assert_equal 3.98, invoice.amount
+    
+    assert_equal 3.98, (invoice.sub_total+invoice.taxes_total)
+    
+    assert_equal(
+      activities.select{|a| /^Activity::Labor$/.match a.class.to_s}.collect{|a| a.activity.id},
+      invoice.activity_ids
+    )
+
+    # Now let's add the rest of the types, and see if it works the way it should:
+    assert_nothing_raised do
+      invoice.activity_types.push a_type_map[:material], a_type_map[:proposal]
+      invoice.save!
+      
+      # We have to expire the cache here....
+      invoice.activities(true)
+    end
+
+    assert_equal 4245.98, invoice.amount
+    
+    assert_equal 4245.98, (invoice.sub_total+invoice.taxes_total)
+    
+    assert_equal(
+      activities.select{|a| /^Activity::(Material|Labor|Proposal)$/.match a.class.to_s}.collect{|a| a.activity.id},
+      invoice.activity_ids
+    )
+        
+    # Make sure we can't add/remove activity types for a published invoice
+    assert_nothing_raised{ set_published invoice, true }
+    
+    assert_raise(RuntimeError) { invoice.activity_types.push a_type_map[:adjustment]}
+
+    assert_raise(RuntimeError) { invoice.activity_types.delete a_type_map[:material]}
+  end
+  
+  def test_empty_invoice
+    # Create an invoice with no activities - even though it should have a balance of zero, also make sure things dont puke
+    
+    inv = nil
+    assert_nothing_raised { inv = Invoice.create! :client => Factory.create_client }
+    
+    assert_equal 0.0, inv.amount
+    
+    assert_equal 0.0, (inv.sub_total+inv.taxes_total)
+    
+  end
+  
+  def test_activity_move
+
+    client_src = Factory.create_client
+    client_dest = Factory.create_client
+
+    create_act_args = {:occurred_on => (DateTime.now << 1), :client => client_src}
+    
+    labor = Factory.create_labor( {}, create_act_args.merge({:cost => 1.99}) )
+    material = Factory.create_material( {}, create_act_args)
+    proposal = Factory.create_proposal( {}, create_act_args)
+    adjustment = Factory.create_adjustment( {}, create_act_args.merge({:tax => 26.00}))
+
+    subactivities = [labor, material, proposal, adjustment]
+    
+    invoice_src = Invoice.create!(
+      :client => client_src, 
+      :issued_on => DateTime.now,
+      :activity_types => @activity_types 
+    )
+
+    invoice_dest = Invoice.create!(
+      :client => client_dest, 
+      :issued_on => DateTime.now
+    )
+    
+    subactivities.each do |activity_type|
+      activity_type.reload
+
+      assert_equal invoice_src.id, activity_type.activity.invoice_id
+      assert_equal client_src.id, activity_type.activity.client_id
+    end
+
+    assert_equal 2448.99, invoice_src.amount
+    
+    assert_equal 2448.99, (invoice_src.sub_total+invoice_src.taxes_total)
+
+    assert_nothing_raised do 
+      subactivities.each do |activity_type|
+        activity_type.activity.move_to_invoice invoice_dest
+      end
+    end
+
+    assert_equal 2448.99, invoice_dest.amount
+    
+    assert_equal 2448.99, (invoice_dest.sub_total+invoice_dest.taxes_total)
+
+    subactivities.each do |at|
+      assert_equal invoice_dest.id, at.activity.invoice_id
+      assert_equal client_src.id, at.activity.client_id
+    end
+  
+    assert_nothing_raised do 
+      labor.activity.move_to_invoice invoice_src
+    end
+
+    assert_equal invoice_src.id, labor.activity.invoice_id
+    assert_equal client_src.id, labor.activity.client_id
+
+    assert_equal 2447.0, invoice_dest.amount
+    
+    assert_equal 2447.0, (invoice_dest.sub_total+invoice_dest.taxes_total)
+
+    invoice_src.is_published = true
+    invoice_src.save!
+
+    # Assert fail!
+    labor.activity.reload
+    assert_raise(StandardError) { labor.activity.move_to_invoice invoice_dest }
+    
+    # Assert fail!
+    material.activity.reload
+    assert_raise(StandardError) { material.activity.move_to_invoice invoice_src }
+    
+  end
+  
+  private
+  
+  def set_published(inv, published_state)
+    inv.is_published = published_state
+    inv.save!
+  end
+
+end