brisk-bills 0.6.0 → 0.7.0

data/test/test_unit_factory_helper.rb

@@ -1,4 +1,3 @@
-
 module Factory
   def self.create_labor(attributes = {}, activity_attributes = {})
     employee = Employee.find(
@@ -111,9 +110,9 @@ module Factory
   end
 
 
-  def self.generate_invoice(total, attributes = {})
-    attributes[:client] ||= Factory.create_client
+  def self.generate_invoice(client, total, attributes = {})
     attributes[:issued_on] ||= Time.now
+    attributes[:is_published] = true if !attributes.has_key?(:is_published) or attributes[:is_published].nil?
 
     activity_increments = (total.floor).to_f/10
     1.upto(10) do |i|
@@ -127,7 +126,7 @@ module Factory
       a = Activity::Adjustment.new :label => 'test invoice'
       a.activity.cost = activity_cost.to_money
       a.activity.tax = activity_tax
-      a.activity.client = attributes[:client]
+      a.activity.client = client
       a.activity.occurred_on = (attributes[:issued_on] - 1.months)
       a.activity.is_published = true
       a.save! 
@@ -137,16 +136,24 @@ module Factory
     
     puts "\nWARNING: No activity types found in db... sure you're using the right fixtures?\n" unless activity_types.length >0
 
-    Invoice.create!( { :activity_types =>  activity_types }.merge(attributes) )
+    Invoice.create!( 
+      { 
+      :activity_types => activity_types, 
+      :client => client,
+      :payment_assignments => (attributes[:is_published]) ? client.recommend_payment_assignments_for(total) : [],
+      :activities => Invoice.recommended_activities_for(client, attributes[:issued_on], activity_types)
+      }.merge(attributes)
+    )
+    
   end
   
-  def self.generate_payment(amount, attributes = {})
-    attributes[:client] ||= Factory.create_client
-    
+  def self.generate_payment(client, amount, attributes = {})
     Payment.create!(
       {
+      :client => client,
       :amount => amount,
-      :payment_method_id => 1
+      :payment_method_id => 1,
+      :invoice_assignments => client.recommend_invoice_assignments_for(amount),
       }.merge(attributes)
     )
   end

data/test/unit/client_test.rb

@@ -1,8 +1,10 @@
 require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../test_unit_factory_helper.rb'
 
 class ClientTest < ActiveSupport::TestCase
   fixtures :clients
-
+  fixtures :activity_types
+  
   def test_is_active
     acme = Client.create! :company_name => 'ACME Inc.'
 
@@ -21,4 +23,298 @@ class ClientTest < ActiveSupport::TestCase
 
     assert_equal base_clients, Client.find_active(:all, :conditions => ['id > 0']).collect{|e| e.company_name}
   end
-end
+
+  def test_basic_unpaid_invoices
+    client = Factory.create_client
+    
+    payments = []
+    
+    paid_invoices = []
+    unpaid_invoices = []
+    unpaid_invoices << Factory.generate_invoice( client, 100.00, :issued_on => (DateTime.now << 4), :is_published => true )
+    paid_invoices   << Factory.generate_invoice( client, 202.00, :issued_on => (DateTime.now << 3), :is_published => true )
+    unpaid_invoices << Factory.generate_invoice( client, 300.00, :issued_on => (DateTime.now << 2), :is_published => true )
+    unpaid_invoices << Factory.generate_invoice( client, 400.00, :issued_on => (DateTime.now << 1), :is_published => true )
+    
+    # This is a basic test in an obvious and typical scenario. Note that we should be matching payments up when they equal invoices..
+    payments << Factory.generate_payment( client, 202.00 )
+
+    client_unpaid_invoices = client.unpaid_invoices
+    
+    assert_equal client_unpaid_invoices.length, unpaid_invoices.length
+    client_unpaid_invoices.each{ |inv| assert unpaid_invoices.collect{|un_inv| un_inv.id}.include?(inv.id) }
+    
+    # Now we test a half payment, which shouldn't make a difference in what's marked as fully-paid:
+    payments << Factory.generate_payment( client, 99.00 )
+
+    client_unpaid_invoices = client.unpaid_invoices
+    
+    assert_equal client_unpaid_invoices.length, unpaid_invoices.length
+    client_unpaid_invoices.each{ |inv| assert unpaid_invoices.collect{|un_inv| un_inv.id}.include?(inv.id) }
+    
+    # Delete all the invoices we just created:
+    (paid_invoices+unpaid_invoices+payments).reject!{|o| o.delete }
+    paid_invoices, unpaid_invoices, payments = [], [], []
+    
+    # Now try this for the case of a payment created before the invoices...
+    payments << Factory.generate_payment(client, 23.00)
+
+    paid_invoices   << Factory.generate_invoice( client, 8.00,  :issued_on => (DateTime.now << 4) )
+    paid_invoices   << Factory.generate_invoice( client, 14.00, :issued_on => (DateTime.now << 4) )
+    unpaid_invoices << Factory.generate_invoice( client, 30.00, :issued_on => (DateTime.now << 1) )
+    unpaid_invoices << Factory.generate_invoice( client, 2.00,  :issued_on => (DateTime.now << 1) )
+
+    client_unpaid_invoices = client.unpaid_invoices
+
+    assert_equal client_unpaid_invoices.uniq.length, client_unpaid_invoices.length
+    client_unpaid_invoices.each{ |inv| assert unpaid_invoices.collect{|un_inv| un_inv.id}.include?(inv.id) }
+  end
+  
+  def test_basic_unassigned_payments
+    client = Factory.create_client
+    
+    invoices = []
+    
+    unassigned_payments = []
+    assigned_payments   = []
+    unassigned_payments << Factory.generate_payment( client,  230.00 )
+    unassigned_payments << Factory.generate_payment( client,  132.00 )
+    assigned_payments   << Factory.generate_payment( client,  23.00 )
+    unassigned_payments << Factory.generate_payment( client,  993.00 )
+    
+    # This is a basic test in an obvious and typical scenario. Note that we should be matching payments up when they equal invoices..
+    invoices << Factory.generate_invoice( client, 23.00, :issued_on => (DateTime.now << 1) )
+
+    client_unassigned_payments = client.unassigned_payments
+    
+    assert_equal unassigned_payments.length, client_unassigned_payments.length
+    client_unassigned_payments.each{ |pymt| assert unassigned_payments.collect{|un_pymnt| un_pymnt.id}.include?(pymt.id) }
+
+    # Now we test a partial invoice, which shouldn't make a difference in what's marked as unassigned:
+    invoices << Factory.generate_invoice( client, 100.00 )
+
+    client_unassigned_payments = client.unassigned_payments
+    
+    assert_equal unassigned_payments.length, client_unassigned_payments.length
+    client_unassigned_payments.each{ |pymt| assert unassigned_payments.collect{|un_pymnt| un_pymnt.id}.include?(pymt.id) }
+
+    # Delete all the payments we just created:
+    (unassigned_payments+assigned_payments+invoices).reject!{|o| o.delete }
+    assigned_payments, unassigned_payments, invoices = [], [], []
+    
+    # Now try this for the case of an invoice created before the payments...
+    invoices << Factory.generate_invoice(client, 23.00, :issued_on => (DateTime.now << 1) )
+
+    assigned_payments   << Factory.generate_payment( client, 8.00 )
+    assigned_payments   << Factory.generate_payment( client, 14.00 )
+    unassigned_payments << Factory.generate_payment( client, 30.00 )
+    unassigned_payments << Factory.generate_payment( client, 2.00 )
+    
+    client_unassigned_payments = client.unassigned_payments
+    
+    assert_equal unassigned_payments.length, client_unassigned_payments.length
+    client_unassigned_payments.each{ |pymt| assert unassigned_payments.collect{|un_pymnt| un_pymnt.id}.include?(pymt.id) }
+  end
+
+  def test_recommend_payment_assignments_for
+    # Make sure the assignments make sense (equal value outstanding returned before any-outstanding)
+    client = Factory.create_client
+    
+    payments = [
+      Factory.generate_payment( client,  23.45,  :paid_on => (DateTime.now << 5) ),
+      Factory.generate_payment( client,  202.02, :paid_on => (DateTime.now << 4) ),
+      Factory.generate_payment( client,  2.40,   :paid_on => (DateTime.now << 3) ),
+      Factory.generate_payment( client,  94.00,  :paid_on => (DateTime.now << 2) ),
+      Factory.generate_payment( client,  2.40,   :paid_on => (DateTime.now << 1) )
+    ]
+    
+    # First test that exact-matches are properly assigned:
+    reccomended = client.recommend_payment_assignments_for(2.40)
+    assert_equal 1, reccomended.length
+    assert_equal payments[2].id, reccomended.first.payment_id
+    
+    reccomended = client.recommend_payment_assignments_for(94)
+    assert_equal 1, reccomended.length
+    assert_equal payments[3].id, reccomended.first.payment_id
+    
+    reccomended = client.recommend_payment_assignments_for(23.45)
+    assert_equal 1, reccomended.length
+    assert_equal payments[0].id, reccomended.first.payment_id
+
+    # Now test partials:
+    reccomended = client.recommend_payment_assignments_for(5.40)
+    assert_equal 1, reccomended.length
+    assert_equal payments[0].id, reccomended.first.payment_id
+    
+    reccomended = client.recommend_payment_assignments_for(225.47)
+    assert_equal 2, reccomended.length
+    assert_equal payments[0].id, reccomended[0].payment_id
+    assert_equal payments[1].id, reccomended[1].payment_id
+
+    reccomended = client.recommend_payment_assignments_for(229)
+    assert_equal 4, reccomended.length
+    assert_equal payments[0].id, reccomended[0].payment_id
+    assert_equal payments[1].id, reccomended[1].payment_id
+    assert_equal payments[2].id, reccomended[2].payment_id
+    assert_equal payments[3].id, reccomended[3].payment_id
+
+    reccomended = client.recommend_payment_assignments_for(25)
+    assert_equal 2, reccomended.length
+    assert_equal payments[0].id, reccomended[0].payment_id
+    assert_equal payments[1].id, reccomended[1].payment_id
+
+  end
+  
+  def test_recommend_invoice_assignments_for 
+    # Make sure the assignments make sense (equal value outstanding returned before any-outstanding)  
+    client = Factory.create_client
+    
+    invoices = [
+      Factory.generate_invoice( client,  23.45,  :issued_on => (DateTime.now << 5) ),
+      Factory.generate_invoice( client,  202.02, :issued_on => (DateTime.now << 4) ),
+      Factory.generate_invoice( client,  2.40,   :issued_on => (DateTime.now << 3) ),
+      Factory.generate_invoice( client,  94.00,  :issued_on => (DateTime.now << 2) ),
+      Factory.generate_invoice( client,  2.40,   :issued_on => (DateTime.now << 1) )
+    ]
+    
+    # First test that exact-matches are properly assigned:
+    reccomended = client.recommend_invoice_assignments_for(2.40)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[2].id, reccomended.first.invoice_id
+    
+    reccomended = client.recommend_invoice_assignments_for(94)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[3].id, reccomended.first.invoice_id
+    
+    reccomended = client.recommend_invoice_assignments_for(23.45)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[0].id, reccomended.first.invoice_id
+
+    # Now test partials:
+    reccomended = client.recommend_invoice_assignments_for(5.40)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[0].id, reccomended.first.invoice_id
+    
+    reccomended = client.recommend_invoice_assignments_for(225.47)
+    assert_equal 2, reccomended.length
+    assert_equal invoices[0].id, reccomended[0].invoice_id
+    assert_equal invoices[1].id, reccomended[1].invoice_id
+
+    reccomended = client.recommend_invoice_assignments_for(229)
+    assert_equal 4, reccomended.length
+    assert_equal invoices[0].id, reccomended[0].invoice_id
+    assert_equal invoices[1].id, reccomended[1].invoice_id
+    assert_equal invoices[2].id, reccomended[2].invoice_id
+    assert_equal invoices[3].id, reccomended[3].invoice_id
+
+    reccomended = client.recommend_invoice_assignments_for(25)
+    assert_equal 2, reccomended.length
+    assert_equal invoices[0].id, reccomended[0].invoice_id
+    assert_equal invoices[1].id, reccomended[1].invoice_id
+  end
+  
+  def test_negative_recommend_invoice_payment_assignments_for
+    # Make sure the assignments make sense (equal value outstanding returned before any-outstanding)  
+    client = Factory.create_client
+    
+    invoices = [
+      Factory.generate_invoice( client,  20.00, :issued_on => (DateTime.now << 5) ),
+      Factory.generate_invoice( client,  -40.0, :issued_on => (DateTime.now << 4) ),
+      Factory.generate_invoice( client,  8.00,  :is_published => true, :issued_on => (DateTime.now << 3) ),
+      Factory.generate_invoice( client,  -2.00, :issued_on => (DateTime.now << 2) ),
+      Factory.generate_invoice( client,  16.00, :issued_on => (DateTime.now << 1) )
+    ]
+    
+    # First test that exact-matches are properly assigned:
+    reccomended = client.recommend_invoice_assignments_for(20.00)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[0].id, reccomended.first.invoice_id
+    
+    reccomended = client.recommend_invoice_assignments_for(8.00)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[2].id, reccomended.first.invoice_id
+    
+    reccomended = client.recommend_invoice_assignments_for(16.00)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[4].id, reccomended.first.invoice_id
+
+    reccomended = client.recommend_invoice_assignments_for(16.00)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[4].id, reccomended.first.invoice_id
+
+    # And check what happens if we have a negative amount?
+    reccomended = client.recommend_invoice_assignments_for(-40.00)
+    assert_equal 0, reccomended.length
+
+    # Now test partials:
+    reccomended = client.recommend_invoice_assignments_for(5.00)
+    assert_equal 1, reccomended.length
+    assert_equal invoices[0].id, reccomended.first.invoice_id
+    
+    reccomended = client.recommend_invoice_assignments_for(25.00)
+    assert_equal 2, reccomended.length
+    assert_equal invoices[0].id, reccomended[0].invoice_id
+    assert_equal invoices[2].id, reccomended[1].invoice_id
+
+    reccomended = client.recommend_invoice_assignments_for(48)
+    assert_equal 3, reccomended.length
+    assert_equal invoices[0].id, reccomended[0].invoice_id
+    assert_equal invoices[2].id, reccomended[1].invoice_id
+    assert_equal invoices[4].id, reccomended[2].invoice_id
+
+    reccomended = client.recommend_invoice_assignments_for(28)
+    assert_equal 2, reccomended.length
+    assert_equal invoices[0].id, reccomended[0].invoice_id
+    assert_equal invoices[2].id, reccomended[1].invoice_id
+  end
+
+  # Now that we support multiple unpublished invoices - let's make sure that our payment recomendations aren't improperly
+  # assigning payments to unpublished invoices
+  def test_unpublished_invoice_payment_assignments
+    client = Factory.create_client
+    
+    # First create three published invoices:
+    invoices = [
+      Factory.generate_invoice( client,  400.0,  :issued_on => (DateTime.now << 5) ),
+      Factory.generate_invoice( client,  50.00,  :issued_on => (DateTime.now << 4) ),
+      Factory.generate_invoice( client,  800.00, :issued_on => (DateTime.now << 3) )
+    ]
+    payments = []
+      
+    assert_equal 1250.00, client.balance
+
+    # Unpublish invoices 1 & 2
+    [invoices[0], invoices[1]].each do |inv|
+      inv.is_published = false
+      inv.save!
+    end
+
+    # Create a payment for the first
+    payments << Factory.generate_payment( client, 800.00 )
+
+    # Publish invoice 2:
+    invoices[1].is_published = true
+    invoices[1].save!
+    
+    # Create payments for the third
+    payments << Factory.generate_payment( client, 26.00 )
+    payments << Factory.generate_payment( client, 24.00 )
+
+    # Set the 1st published
+    invoices[0].is_published = true
+    invoices[0].save!
+    
+    # Create a payment for the second
+    payments << Factory.generate_payment( client, 500.00 )
+    
+    # Now we test all the invoice_payment mappings to be sure they make sense ..
+    assert_equal true, invoices[0].is_paid?
+    assert_equal [payments[3].id], invoices[0].payment_assignments(true).collect(&:payment_id)
+
+    assert_equal true, invoices[1].is_paid?
+    assert_equal [payments[1].id, payments[2].id], invoices[1].payment_assignments(true).collect(&:payment_id)
+    
+    assert_equal true, invoices[2].is_paid?
+    assert_equal [payments[0].id], invoices[2].payment_assignments(true).collect(&:payment_id)
+  end
+end

data/test/unit/invoice_payment_test.rb

@@ -1,8 +1,318 @@
 require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../test_unit_factory_helper'
+
 
 class InvoicePaymentTest < ActiveSupport::TestCase
-  # Replace this with your real tests.
-  def test_truth
-    assert true
+
+  def test_invoice_payment_marking
+    client = Factory.create_client
+    
+    invoices = [
+      Factory.generate_invoice( client, 10.00,  :issued_on => (DateTime.now << 4), :payment_assignments => [] ),
+      Factory.generate_invoice( client, 15.00,  :issued_on => (DateTime.now << 3), :payment_assignments => [] ),
+      Factory.generate_invoice( client, 5.00,   :issued_on => (DateTime.now << 2), :payment_assignments => [] ),
+    ]
+
+    assert_equal 30.00, client.balance
+    
+    payments = [
+      Factory.generate_payment( client, 2.00,  :invoice_assignments => [] ),
+      Factory.generate_payment( client, 3.00,  :invoice_assignments => [] ),
+      Factory.generate_payment( client, 11.00, :invoice_assignments => [] ),
+      Factory.generate_payment( client, 4.00,  :invoice_assignments => [] ),
+      Factory.generate_payment( client, 10.00, :invoice_assignments => [] )
+    ]
+
+    assert_equal 0.00, client.balance
+    
+    # Ensure that invoices aren't marked as 'paid' until the invoice_payments have been applied.  Even though the balance is 0
+    assert_equal false, invoices[0].is_paid?
+    assert_equal false, invoices[1].is_paid?
+    assert_equal false, invoices[2].is_paid?
+
+    # Ensure that payments aren't marked as 'paid' until the invoice_payments have been applied.  Even though the balance is 0
+    assert_equal false, payments[0].is_allocated?
+    assert_equal false, payments[1].is_allocated?
+    assert_equal false, payments[2].is_allocated?
+    assert_equal false, payments[3].is_allocated?
+    assert_equal false, payments[4].is_allocated?
+    
+    # Now start marking payments/invocies, and testing the corresponding is_ methods :
+    InvoicePayment.quick_create! invoices[0], payments[2], 10.00
+
+    assert_equal true, invoices[0].is_paid?
+    assert_equal false, invoices[1].is_paid?
+    assert_equal false, invoices[2].is_paid?
+    assert_equal false, payments[0].is_allocated?
+    assert_equal false, payments[1].is_allocated?
+    assert_equal false, payments[2].is_allocated?
+    assert_equal false, payments[3].is_allocated?
+    assert_equal false, payments[4].is_allocated?
+
+    InvoicePayment.quick_create! invoices[1], payments[2], 1.00
+    InvoicePayment.quick_create! invoices[1], payments[3], 4.00    
+    InvoicePayment.quick_create! invoices[1], payments[4], 10.00
+
+    assert_equal true, invoices[0].is_paid?
+    assert_equal true, invoices[1].is_paid?
+    assert_equal false, invoices[2].is_paid?
+    assert_equal false, payments[0].is_allocated?
+    assert_equal false, payments[1].is_allocated?
+    assert_equal true, payments[2].is_allocated?
+    assert_equal true, payments[3].is_allocated?
+    assert_equal true, payments[4].is_allocated?
+
+    InvoicePayment.quick_create! invoices[2], payments[0], 2.00
+    InvoicePayment.quick_create! invoices[2], payments[1], 3.00    
+    
+    # Everything should be allocated now - retest is_paid/allocated code
+    assert_equal true, invoices[0].is_paid?
+    assert_equal true, invoices[1].is_paid?
+    assert_equal true, invoices[2].is_paid?
+
+    assert_equal true, payments[0].is_allocated?
+    assert_equal true, payments[1].is_allocated?
+    assert_equal true, payments[2].is_allocated?
+    assert_equal true, payments[3].is_allocated?
+    assert_equal true, payments[4].is_allocated?
+  end
+
+  # How well does find_recomended_invoices work for a negative invoice with a credit/negative amount -payment? Write a test:
+  def test_negative_invoice_payment_marking
+    client = Factory.create_client
+    
+    invoices = [
+      Factory.generate_invoice( client, 10.00,  :issued_on => (DateTime.now << 4), :payment_assignments => [] ),
+      Factory.generate_invoice( client, -15.00, :issued_on => (DateTime.now << 3), :payment_assignments => [] ),
+      Factory.generate_invoice( client, -5.00,  :issued_on => (DateTime.now << 2), :payment_assignments => [] ),
+    ]
+
+    assert_equal -10.00, client.balance
+
+    # Negative invoices are always marked paid
+    assert_equal false, invoices[0].is_paid?
+    assert_equal true,  invoices[1].is_paid?
+    assert_equal true,  invoices[2].is_paid?
+    
+    payments = [
+      Factory.generate_payment( client, 5.00,   :invoice_assignments => 
+        [InvoicePayment.new(:invoice => invoices[0], :amount => 5.00 )]
+      ),
+      Factory.generate_payment( client, 5.00,   :invoice_assignments => 
+        [InvoicePayment.new(:invoice => invoices[0], :amount => 5.00 )]
+      )
+    ]
+
+    assert_equal -20.00, client.balance
+
+    # Everything should be paid now:
+    assert_equal true, invoices[0].is_paid?
+    assert_equal true, invoices[1].is_paid?
+    assert_equal true, invoices[2].is_paid?
+    
+    # Now what if the invoice they have an invoice for -$20, and an invoice for +$12. Their outstanding balance is -$8,
+    # but if they try to make a payment for $5, will we freak on them?
+    
+    # Just for goo measure let's generate a new invoice:
+    invoices << Factory.generate_invoice( client, 12.00,  :issued_on => (DateTime.now << 1), :payment_assignments => [] )
+
+    assert_equal -8.00, client.balance
+    
+    assert_equal true, invoices[0].is_paid?
+    assert_equal true, invoices[1].is_paid?
+    assert_equal true, invoices[2].is_paid?
+    assert_equal false, invoices[3].is_paid?
+    
+    payments << Factory.generate_payment( client, 12.00,   :invoice_assignments => 
+        [InvoicePayment.new(:invoice => invoices[3], :amount => 12.00 )]
+    )
+    
+    # and make sure we're cool:
+    assert_equal true, invoices[0].is_paid?
+    assert_equal true, invoices[1].is_paid?
+    assert_equal true, invoices[2].is_paid?
+    assert_equal true, invoices[3].is_paid?
+    
+    assert_equal -20.00, client.balance
+  end
+
+  def test_invoice_dependent_delete
+    client = Factory.create_client
+    
+    invoice = Factory.generate_invoice client, 99.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    Factory.generate_payment client, 40.00,  :invoice_assignments => [InvoicePayment.new(:invoice => invoice, :amount => 40.00 )]
+    Factory.generate_payment client, 40.00,  :invoice_assignments => [InvoicePayment.new(:invoice => invoice, :amount => 40.00 )]
+    Factory.generate_payment client, 20.00,  :invoice_assignments => [InvoicePayment.new(:invoice => invoice, :amount => 19.00 )]
+    
+    assert_equal 3, InvoicePayment.find(:all).length
+
+    invoice.is_published = false
+    assert_not_equal false, invoice.destroy # False would indicate that the invoice didnt delete successfully
+    
+    # Now make sure all our InvoicePayments were also destroyed:
+    assert_equal 0, InvoicePayment.find(:all).length
+  end
+  
+  def test_invoice_payments_dependent_delete
+    client = Factory.create_client
+    
+    payment = Factory.generate_payment client, 13.00,  :invoice_assignments => []
+    
+    Factory.generate_invoice client, 4.00,  :issued_on => (DateTime.now << 1), :payment_assignments => [
+      InvoicePayment.new(:payment => payment, :amount => 4.00 )
+    ]
+    Factory.generate_invoice client, 4.00,  :issued_on => (DateTime.now << 1), :payment_assignments => [
+      InvoicePayment.new(:payment => payment, :amount => 4.00 )
+    ]
+    Factory.generate_invoice client, 3.00,  :issued_on => (DateTime.now << 1), :payment_assignments => [
+      InvoicePayment.new(:payment => payment, :amount => 3.00 )
+    ]
+    
+    assert_equal 3, InvoicePayment.find(:all).length
+
+    payment.destroy
+    
+    # Now make sure all our InvoicePayments were also destroyed:
+    assert_equal 0, InvoicePayment.find(:all).length
+  end
+
+  def test_bogus_invoice_payment_amounts
+    client = Factory.create_client
+    
+    ip = nil
+    
+    invoice = Factory.generate_invoice client,  100.00,  :issued_on => (DateTime.now << 1),  :payment_assignments => []
+    paymentA = Factory.generate_payment client,  20.00, :invoice_assignments => []
+    paymentB = Factory.generate_payment client, 110.00, :invoice_assignments => []
+    
+    #  Test: People can't specifify more allocations than the total payment's amount
+    ip = InvoicePayment.new :payment => paymentA, :invoice => invoice, :amount => 21.00
+    assert_equal false, ip.valid?
+    assert_equal "exceeds the payment's remainder amount", ip.errors.on('amount')
+
+    #  Test: People can't specifify more allocations than the total invoice's amount
+    ip = InvoicePayment.create :payment => paymentB, :invoice => invoice, :amount => 101.00
+    assert_equal false, ip.valid?
+    assert_equal "exceeds the invoice's remainder balance", ip.errors.on('amount')
+        
+    #  Test: Trying the case of a second/multiple payments which exceed the invoice balance..
+    invoice = Factory.generate_invoice client,  20.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    paymentA = Factory.generate_payment client,  12.00, :invoice_assignments => [
+      InvoicePayment.new( :invoice => invoice, :amount => 12.00)
+    ]
+    paymentB = Factory.generate_payment client,  12.00, :invoice_assignments => []
+
+    ip = InvoicePayment.create :payment => paymentB, :invoice => invoice, :amount => 12.00
+    assert_equal false, ip.valid?
+    assert_equal "exceeds the invoice's remainder balance", ip.errors.on('amount')
+
+    # Now try the case of multiple invoices which exceed the payment balance..
+    invoiceA = Factory.generate_invoice client,  40.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    invoiceB = Factory.generate_invoice client,  35.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    
+    payment = Factory.generate_payment client,  70.00, :invoice_assignments => [
+      InvoicePayment.new( :invoice => invoiceA, :amount => 40.00)
+    ]
+
+    ip = InvoicePayment.create :payment => payment, :invoice => invoiceB, :amount => 35.00
+    assert_equal false, ip.valid?
+    assert_equal "exceeds the payment's remainder amount", ip.errors.on('amount')
+  end
+
+  def test_bogus_invoice_allocations
+    client = Factory.create_client
+    
+    # This is a repeat of some of the above tests, but we're ensuring that we fail during the invoice model's creation
+    paymentA = Factory.generate_payment client,  4.00, :invoice_assignments => []
+    paymentB = Factory.generate_payment client,  8.00, :invoice_assignments => []
+    paymentC = Factory.generate_payment client,  8.00, :invoice_assignments => []
+    
+    assert_raise ActiveRecord::RecordInvalid do
+      Factory.generate_invoice client,  16.00,  :issued_on => (DateTime.now << 1), :payment_assignments => [
+        InvoicePayment.new( :payment => paymentA, :amount => 4.00 ),
+        InvoicePayment.new( :payment => paymentB, :amount => 8.00 ),
+        InvoicePayment.new( :payment => paymentC, :amount => 5.00 ) # <-- this one's invalid, b/c its greater than the invoice price
+      ]
+    end
+    
+    assert_raise ActiveRecord::RecordInvalid do
+      Factory.generate_invoice client,  16.00,  :issued_on => (DateTime.now << 1), :payment_assignments => [
+        InvoicePayment.new( :payment => paymentA, :amount => 8.00 ), # <-- this one's invalid, b/c its greater than the payment total
+        InvoicePayment.new( :payment => paymentB, :amount => 4.00 ),
+        InvoicePayment.new( :payment => paymentC, :amount => 4.00 )
+      ]
+    end
+  end
+
+  def test_bogus_payment_allocations
+    client = Factory.create_client
+    
+    # This is a repeat of some of the above tests, but we're ensuring that we fail during the payment model's creation
+    invoiceA = Factory.generate_invoice client,  3.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    invoiceB = Factory.generate_invoice client,  6.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    invoiceC = Factory.generate_invoice client,  6.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    
+    assert_raise ActiveRecord::RecordInvalid do
+      Factory.generate_payment client,  12.00, :invoice_assignments => [
+        InvoicePayment.new( :invoice => invoiceA, :amount => 3.00 ),
+        InvoicePayment.new( :invoice => invoiceB, :amount => 6.00 ),
+        InvoicePayment.new( :invoice => invoiceC, :amount => 4.00 ) # <-- this one's invalid, b/c its greater than the payment price
+      ]
+    end
+
+    assert_raise ActiveRecord::RecordInvalid do
+      Factory.generate_payment client,  12.00, :invoice_assignments => [
+        InvoicePayment.new( :invoice => invoiceA, :amount => 6.00 ),# <-- this one's invalid, b/c its greater than the invoice total
+        InvoicePayment.new( :invoice => invoiceB, :amount => 3.00 ),
+        InvoicePayment.new( :invoice => invoiceC, :amount => 3.00 ) 
+      ]
+    end
+  end
+
+  def test_invoice_payment_amount_not_negative
+    client = Factory.create_client
+    
+    # People can't specifify negative payment_allocations
+    invoice = Factory.generate_invoice client,  5.00,  :issued_on => (DateTime.now << 1), :payment_assignments => []
+    payment = Factory.generate_payment client,  5.00, :invoice_assignments => []
+    
+    ip = InvoicePayment.create :payment => payment, :invoice => invoice, :amount => -5.00
+    
+    assert_equal false, ip.valid?
+    assert_equal "must be greater than or equal to 0", ip.errors.on('amount')
+  end
+  
+  def test_payments_unapplyable_to_unpublished_invoices
+    client = Factory.create_client
+    
+    invoice = nil
+    payment = nil
+    
+    # Ensure Invoice :payment_assignments create fails with unpublished unvoice
+    payment = Factory.generate_payment( client,  40.00 , :invoice_assignments => [] )
+    
+    assert_raise(ActiveRecord::RecordInvalid) do
+      invoice = Factory.generate_invoice( client, 40.00, :is_published => false, :payment_assignments => [
+        InvoicePayment.new( :payment => payment, :amount => 40.00 ) 
+      ] )
+    end
+
+    # Ensure Payment :invoice_assignments create fails with unpublished unvoice
+    invoice = Factory.generate_invoice( client, 50.00, :is_published => false, :payment_assignments => [])
+
+    assert_raise(ActiveRecord::RecordInvalid) do
+      payment = Factory.generate_payment( client,  50.00 , :invoice_assignments => [
+        InvoicePayment.new( :invoice => invoice, :amount => 50.00 ) 
+      ] )
+    end
+
+    # Test InvoicePayment create fails with unpublished unvoice
+    invoice = Factory.generate_invoice( client, 60.00, :is_published => false, :payment_assignments => [])
+    payment = Factory.generate_payment( client, 60.00, :invoice_assignments => [] )
+    
+    ip = InvoicePayment.new :invoice => invoice, :payment => payment, :amount => 60.00
+    
+    assert_raise(ActiveRecord::RecordInvalid) { ip.save! }
+    assert ip.errors.invalid?(:invoice)
   end
 end