double_double 0.1.0 → 0.2.0

data/spec/models/credit_amount_spec.rb

@@ -1,46 +1,68 @@
 module DoubleDouble
   describe CreditAmount do
 
+    before(:each) do
+      @cash = DoubleDouble::Asset.create!(name:'Cash', number: 11)
+      @loan = DoubleDouble::Liability.create!(name:'Loan', number: 12)
+      @dummy_transaction = DoubleDouble::Transaction.new
+      @job = DoubleDouble::Expense.create!(name: 'stand-in job', number: 999)
+      @po  = DoubleDouble::Expense.create!(name: 'stand-in purchase order', number: 333)
+    end
+
     it "should not be valid without an amount" do
       expect {
-        FactoryGirl.build(:credit_amt, amount: nil, transaction: FactoryGirl.build(:transaction))
+        c = DoubleDouble::CreditAmount.new
+        c.amount = nil
+        c.account = @cash
+        c.transaction = @dummy_transaction
+        c.save!
       }.to raise_error(ArgumentError)
     end
 
+    it "should not be valid with an amount of 0" do
+      c = DoubleDouble::CreditAmount.new
+      c.amount = 0
+      c.account = @cash
+      c.transaction = @dummy_transaction
+      c.should_not be_valid
+    end
+
     it "should not be valid without a transaction" do
-      acct = FactoryGirl.create(:asset)
-      credit_amount = FactoryGirl.build(:credit_amt, transaction: nil, account: acct, amount: Money.new(20))
-      credit_amount.should_not be_valid
+      c = DoubleDouble::CreditAmount.new
+      c.amount = 9
+      c.account = @cash
+      c.transaction = nil
+      c.should_not be_valid
     end
 
     it "should not be valid without an account" do
-      t = FactoryGirl.build(:transaction)
-      credit_amount = FactoryGirl.build(:credit_amt, account: nil, transaction: t, amount: Money.new(20))
-      credit_amount.should_not be_valid
+      c = DoubleDouble::CreditAmount.new
+      c.amount = 9
+      c.account = nil
+      c.transaction = @dummy_transaction
+      c.should_not be_valid
     end
     
     it "should be sensitive to 'context' when calculating balances, if supplied" do
-      acct_1     = FactoryGirl.create(:asset)
-      other_acct = FactoryGirl.create(:not_asset)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: acct_1, context_id: 77, context_type: 'Job')
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: other_acct)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(321), account: acct_1, context_id: 77, context_type: 'Job')
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(321), account: other_acct)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(275), account: acct_1, context_id: 82, context_type: 'Job')
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(275), account: other_acct)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(999), account: acct_1)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(999), account: other_acct)
-      t.save
-      acct_1.credits_balance({context_id: 77, context_type: 'Job'}).should == Money.new(123 + 321)
-      acct_1.credits_balance({context_id: 82, context_type: 'Job'}).should == Money.new(275)
-      acct_1.credits_balance.should == Money.new(123 + 321 + 275 + 999)
+      Transaction.create!(
+          description: 'Foobar1',
+          debits:  [{account: 'Cash', amount: Money.new(123)}], 
+          credits: [{account: 'Loan', amount: Money.new(123), context: @job}])
+      Transaction.create!(
+          description: 'Foobar2',
+          debits:  [{account: 'Cash', amount: Money.new(321)}], 
+          credits: [{account: 'Loan', amount: Money.new(321), context: @job}])
+      Transaction.create!(
+          description: 'Foobar3',
+          debits:  [{account: 'Cash', amount: Money.new(275)}], 
+          credits: [{account: 'Loan', amount: Money.new(275), context: @po}])
+      Transaction.create!(
+          description: 'Foobar4',
+          debits:  [{account: 'Cash', amount: Money.new(999)}], 
+          credits: [{account: 'Loan', amount: Money.new(999)}])
+      @loan.credits_balance({context: @job}).should == Money.new(123 + 321)
+      @loan.credits_balance({context: @po}).should == Money.new(275)
+      @loan.credits_balance.should == Money.new(123 + 321 + 275 + 999)
     end
   end
 end

data/spec/models/debit_amount_spec.rb

@@ -1,46 +1,68 @@
 module DoubleDouble
   describe DebitAmount do
 
+    before(:each) do
+      @cash = DoubleDouble::Asset.create!(name:'Cash', number: 11)
+      @loan = DoubleDouble::Liability.create!(name:'Loan', number: 12)
+      @dummy_transaction = DoubleDouble::Transaction.new
+      @job = DoubleDouble::Expense.create!(name: 'stand-in job', number: 999)
+      @po  = DoubleDouble::Expense.create!(name: 'stand-in purchase order', number: 333)
+    end
+
     it "should not be valid without an amount" do
       expect {
-        FactoryGirl.build(:debit_amt, amount: nil, transaction: FactoryGirl.build(:transaction))
+        c = DoubleDouble::DebitAmount.new
+        c.amount = nil
+        c.account = @cash
+        c.transaction = @dummy_transaction
+        c.save!
       }.to raise_error(ArgumentError)
     end
 
+    it "should not be valid with an amount of 0" do
+      c = DoubleDouble::DebitAmount.new
+      c.amount = 0
+      c.account = @cash
+      c.transaction = @dummy_transaction
+      c.should_not be_valid
+    end
+
     it "should not be valid without a transaction" do
-      acct = FactoryGirl.create(:asset)
-      debit_amount = FactoryGirl.build(:debit_amt, transaction: nil, account: acct, amount: Money.new(20))
-      debit_amount.should_not be_valid
+      c = DoubleDouble::DebitAmount.new
+      c.amount = 9
+      c.account = @cash
+      c.transaction = nil
+      c.should_not be_valid
     end
 
     it "should not be valid without an account" do
-      t = FactoryGirl.build(:transaction)
-      debit_amount = FactoryGirl.build(:debit_amt, account: nil, transaction: t, amount: Money.new(20))
-      debit_amount.should_not be_valid
+      c = DoubleDouble::DebitAmount.new
+      c.amount = 9
+      c.account = nil
+      c.transaction = @dummy_transaction
+      c.should_not be_valid
     end
     
-    it "should be sensitive to context_id when calculating balances, if supplied" do
-      acct_1     = FactoryGirl.create(:asset)
-      other_acct = FactoryGirl.create(:not_asset)
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: acct_1, context_id: 77, context_type: 'Job')
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: other_acct)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(321), account: acct_1, context_id: 77, context_type: 'Job')
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(321), account: other_acct)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(275), account: acct_1, context_id: 82, context_type: 'Job')
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(275), account: other_acct)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(999), account: acct_1)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(999), account: other_acct)
-      t.save
-      acct_1.debits_balance({context_id: 77, context_type: 'Job'}).should == Money.new(123 + 321)
-      acct_1.debits_balance({context_id: 82, context_type: 'Job'}).should == Money.new(275)
-      acct_1.debits_balance.should == Money.new(123 + 321 + 275 + 999)
+    it "should be sensitive to 'context' when calculating balances, if supplied" do
+      Transaction.create!(
+          description: 'Foobar1',
+          debits:  [{account: 'Cash', amount: Money.new(123), context: @job}], 
+          credits: [{account: 'Loan', amount: Money.new(123)}])
+      Transaction.create!(
+          description: 'Foobar2',
+          debits:  [{account: 'Cash', amount: Money.new(321), context: @job}], 
+          credits: [{account: 'Loan', amount: Money.new(321)}])
+      Transaction.create!(
+          description: 'Foobar3',
+          debits:  [{account: 'Cash', amount: Money.new(275), context: @po}], 
+          credits: [{account: 'Loan', amount: Money.new(275)}])
+      Transaction.create!(
+          description: 'Foobar4',
+          debits:  [{account: 'Cash', amount: Money.new(999)}], 
+          credits: [{account: 'Loan', amount: Money.new(999)}])
+      @cash.debits_balance({context: @job}).should == Money.new(123 + 321)
+      @cash.debits_balance({context: @po}).should == Money.new(275)
+      @cash.debits_balance.should == Money.new(123 + 321 + 275 + 999)
     end
   end
 end

data/spec/models/equity_spec.rb

@@ -5,8 +5,13 @@ module DoubleDouble
       let(:account_type) {:equity}
     end
 
-    it_behaves_like "a right side account type" do
-      let(:right_side_account_type) {:equity}
+    it_behaves_like "a normal credit account type" do
+      let(:normal_credit_account_type) {:equity}
+    end
+
+    it "should create a proper equity account" do
+      -> { DoubleDouble::Equity.create! name: 'Equity acct', number: 20
+      }.should change(DoubleDouble::Equity, :count).by(1)
     end
   end
 end

data/spec/models/expense_spec.rb

@@ -5,8 +5,13 @@ module DoubleDouble
       let(:account_type) {:expense}
     end
 
-    it_behaves_like "a left side account type" do
-      let(:left_side_account_type) {:expense}
+    it_behaves_like "a normal debit account type" do
+      let(:normal_debit_account_type) {:expense}
+    end
+
+    it "should create a proper Expense account" do
+      -> { DoubleDouble::Expense.create! name: 'Expense acct', number: 20
+      }.should change(DoubleDouble::Expense, :count).by(1)
     end
   end
 end

data/spec/models/liability_spec.rb

@@ -5,8 +5,13 @@ module DoubleDouble
       let(:account_type) {:liability}
     end
 
-    it_behaves_like "a right side account type" do
-      let(:right_side_account_type) {:liability}
+    it_behaves_like "a normal credit account type" do
+      let(:normal_credit_account_type) {:liability}
+    end
+
+    it "should create a proper Liability account" do
+      -> { DoubleDouble::Liability.create! name: 'Liability acct', number: 20
+      }.should change(DoubleDouble::Liability, :count).by(1)
     end
   end
 end

data/spec/models/revenue_spec.rb

@@ -5,8 +5,13 @@ module DoubleDouble
       let(:account_type) {:revenue}
     end
 
-    it_behaves_like "a right side account type" do
-      let(:right_side_account_type) {:revenue}
+    it_behaves_like "a normal credit account type" do
+      let(:normal_credit_account_type) {:revenue}
+    end
+
+    it "should create a proper Revenue account" do
+      -> { DoubleDouble::Revenue.create! name: 'Revenue acct', number: 20
+      }.should change(DoubleDouble::Revenue, :count).by(1)
     end
   end
 end

data/spec/models/transaction_spec.rb

@@ -2,85 +2,154 @@ module DoubleDouble
   describe Transaction do
 
     before(:each) do
-      @acct       = FactoryGirl.create(:asset)
-      @other_acct = FactoryGirl.create(:not_asset)
+      @cash = DoubleDouble::Asset.create!(name:'Cash_11', number: 1011)
+      @loan = DoubleDouble::Liability.create!(name:'Loan_12', number: 1012)
+
+      # dummy objects to stand-in for a context
+      @campaign1 = DoubleDouble::Asset.create!(name:'campaign_test1', number: 9991)
+      @campaign2 = DoubleDouble::Asset.create!(name:'campaign_test2', number: 9992)
     end
 
-    it "should create a transaction" do
+    it 'should create a transaction using the create! method' do
       -> {
-        t = FactoryGirl.build(:transaction)
-        t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
-        t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
-        t.save!
+        Transaction.create!(
+          description: 'spec transaction 01',
+          debits:  [{account: 'Cash_11', amount: 10}],
+          credits: [{account: 'Loan_12', amount:  9},
+                    {account: 'Loan_12', amount:  1}])
+
       }.should change(DoubleDouble::Transaction, :count).by(1)
     end
 
-    it "should not be valid without a credit amount" do
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
-      t.should_not be_valid
-      t.errors['base'].should include("Transaction must have at least one credit amount")
+    it 'should not create a transaction using the build method' do
+      -> {
+        Transaction.build(
+          description: 'spec transaction 01',
+          debits:  [{account: 'Cash_11', amount: 100_000}],
+          credits: [{account: 'Loan_12', amount: 100_000}])
+      }.should change(DoubleDouble::Transaction, :count).by(0)
+    end
+
+    it 'should not be valid without a credit amount' do
+      # No credit_amount element
+      t1 = Transaction.build(
+        description: 'spec transaction 01',
+        debits:  [{account: 'Cash_11', amount: 100_000}])
+      t1.should_not be_valid
+      t1.errors['base'].should include('Transaction must have at least one credit amount')
+      t1.errors['base'].should include('The credit and debit amounts are not equal')
+      # An empty credit_amount element
+      t2 = Transaction.build(
+        description: 'spec transaction 01',
+        debits:  [{account: 'Cash_11', amount: 100_000}],
+        credits: [])
+      t2.should_not be_valid
+      t2.errors['base'].should include('Transaction must have at least one credit amount') 
+      t2.errors['base'].should include('The credit and debit amounts are not equal')
     end
 
-    it "should not be valid with an invalid credit amount" do
+    it 'should raise a RecordInvalid without a credit amount' do
       -> {
-        t = FactoryGirl.build(:transaction)
-        t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: nil,            account: @acct)
-        t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
-        t.save
+      Transaction.create!(
+        description: 'spec transaction 01',
+        debits:  [{account: 'Cash_11', amount: 100_000}],
+        credits: [])
+      }.should raise_error(ActiveRecord::RecordInvalid)
+    end
+
+    it 'should not be valid with an invalid credit amount' do
+      -> {
+        Transaction.create!(
+          description: 'spec transaction 01',
+          credits: [{account: 'Loan_12', amount: nil}],
+          debits:  [{account: 'Cash_11', amount: 100_000}])
       }.should raise_error(ArgumentError)
     end
 
-    it "should not be valid without a debit amount" do
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
-      t.should_not be_valid
-      t.errors['base'].should include("Transaction must have at least one debit amount")
+    it 'should not be valid without a debit amount' do
+      # No credit_amount element
+      t1 = Transaction.build(
+        description: 'spec transaction 01',
+        credits:  [{account: 'Loan_12', amount: 100_000}])
+      t1.should_not be_valid
+      t1.errors['base'].should include('Transaction must have at least one debit amount')
+      t1.errors['base'].should include('The credit and debit amounts are not equal')
+      # An empty credit_amount element
+      t2 = Transaction.build(
+        description: 'spec transaction 01',
+        credits: [{account: 'Loan_12', amount: 100_000}],
+        debits:  [])
+      t2.should_not be_valid
+      t2.errors['base'].should include('Transaction must have at least one debit amount')
+      t2.errors['base'].should include('The credit and debit amounts are not equal')
     end
 
-    it "should not be valid with an invalid debit amount" do
+    it 'should not be valid with an invalid debit amount' do
       -> {
-        t = FactoryGirl.build(:transaction)
-        t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
-        t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: nil,            account: @other_acct)
-        t.save
+        Transaction.create!(
+          description: 'spec transaction 01',
+          credits: [{account: 'Cash_11', amount: 100_000}],
+          debits:  [{account: 'Loan_12', amount: nil}])
       }.should raise_error(ArgumentError)
     end
 
-    it "should not be valid without a description" do
-      t = FactoryGirl.build(:transaction, description: nil)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
-      t.save
+    it 'should not be valid without a description' do
+      t = Transaction.build(
+          description: '',
+          debits:  [{account: 'Cash_11', amount: 100_000}],
+          credits: [{account: 'Loan_12', amount: 100_000}])
       t.should_not be_valid
       t.errors[:description].should == ["can't be blank"]
     end
 
-    it "should require the debit and credit amounts to cancel" do
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(555), account: @acct)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(666), account: @other_acct)
-      t.save
+    it 'should require the debit and credit amounts to cancel' do
+      t = Transaction.build(
+        description: 'spec transaction 01',
+        credits: [{account: 'Cash_11', amount: 100_000}],
+        debits:  [{account: 'Loan_12', amount:  99_999}])
       t.should_not be_valid
-      t.errors['base'].should == ["The credit and debit amounts are not equal"]
+      t.errors['base'].should == ['The credit and debit amounts are not equal']
     end
 
-    it "should allow building a transaction and credit and debits with a hash" do
-      FactoryGirl.create(:asset, :name => "Accounts Receivable")
-      FactoryGirl.create(:revenue, :name => "Sales Revenue")
-      FactoryGirl.create(:liability, :name =>  "Sales Tax Payable")
-      transaction = Transaction.build(
-        description: "Sold some widgets",
-        debits: [
-          {account: "Accounts Receivable", amount: 50}], 
-        credits: [
-          {account: "Sales Revenue", amount: 45},
-          {account: "Sales Tax Payable", amount: 5}])
-
-      transaction.should be_valid
-      transaction.save
-      saved_transaction = DoubleDouble::Transaction.find(transaction.id)
+    describe 'context references' do
+      it 'should allow a transaction to be built describing the context in the hash' do
+        Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'Cash_11', amount: 60, context: @campaign1},
+                    {account: 'Cash_11', amount: 40, context: @campaign2}], 
+          credits: [{account: 'Loan_12', amount: 45},
+                    {account: 'Loan_12', amount:  5},
+                    {account: 'Loan_12', amount: 50, context: @campaign1}])
+        Amount.by_context(@campaign1).count.should eq(2)
+        Amount.by_context(@campaign2).count.should eq(1)
+        @cash.debits_balance(context: @campaign1).should eq(60)
+        @cash.debits_balance(context: @campaign2).should eq(40)
+      end  
     end
 
+    describe 'README.md scenarios' do
+      it 'should perform BASIC SCENARIO A correctly' do
+        DoubleDouble::Asset.create! name:'Cash', number: 11
+        DoubleDouble::Liability.create! name:'Grandpa Loan', number: 12
+        # Grandpa was kind enough to loan us $800 USD in cash for college textbooks.  To enter this we will require a transaction which will affect both 'Cash' and 'Grandpa Loan'
+        DoubleDouble::Transaction.create!(
+          description: 
+            'We received a loan from Grandpa',
+          debits:[
+            {account: 'Cash', amount: '$800'}],
+          credits:[
+            {account: 'Grandpa Loan', amount: '$800'}])
+        # But say that we wanted to return $320 because we were able to purchase a few used books.
+        DoubleDouble::Transaction.create!(
+          description: 
+            'Payed back $320 to Grandpa',
+          debits:[
+            {account: 'Grandpa Loan', amount: '$320'}],
+          credits:[
+            {account: 'Cash', amount: '$320'}])
+        # If we wanted to know how much we still owed Grandpa, we could look at the balance of the account.
+        DoubleDouble::Account.find_by_name('Grandpa Loan').balance.to_s.should eq("480.00")
+      end
+    end
   end
 end

data/spec/support/all_account_types.rb

@@ -14,7 +14,8 @@ shared_examples "all account types" do
     end
 
     it "should allow creating an account" do
-      -> { account = FactoryGirl.create(account_type) }.should change(DoubleDouble::Account, :count).by(1)
+      -> { DoubleDouble.const_get(@capitalized_account_type).create! name: 'test acct', number: 2
+      }.should change(DoubleDouble::Account, :count).by(1)
     end
 
     it "should not report a trial balance" do
@@ -22,28 +23,35 @@ shared_examples "all account types" do
     end
 
     it "should not be valid without a name" do
-      account = FactoryGirl.build(account_type, :name => nil)
+      account = DoubleDouble.const_get(@capitalized_account_type).new(number: 998)
+      account.should_not be_valid
+      account = DoubleDouble.const_get(@capitalized_account_type).new(name: nil, number: 997)
+      account.should_not be_valid
+      account = DoubleDouble.const_get(@capitalized_account_type).new(name: '', number: 996)
       account.should_not be_valid
     end
 
     it "should respond_to credit_transactions" do
-      account = FactoryGirl.build(account_type)
+      account = DoubleDouble.const_get(@capitalized_account_type).create!(name: 'acct', number: 999)
       account.should respond_to(:credit_transactions)
     end
 
     it "should respond_to debit_transactions" do
-      account = FactoryGirl.build(account_type)
+      account = DoubleDouble.const_get(@capitalized_account_type).create!(name: 'acct', number: 999)
       account.should respond_to(:debit_transactions)
     end
 
     it "a contra account should be capable of balancing against a non-contra account" do
-      account        = FactoryGirl.create(account_type)
-      contra_account = FactoryGirl.create(account_type, :contra => true)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 50, account: account)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 25, account: account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 75, account: contra_account)
-      t.save
+      DoubleDouble.const_get(@capitalized_account_type).create!(name: 'acct1', number: 1)
+      DoubleDouble.const_get(@capitalized_account_type).create!(name: 'acct2', number: 2, contra: true)
+      DoubleDouble::Transaction.create!(
+        description: 
+          'testing contra balancing',
+        debits:[
+          {account: 'acct1', amount: '$250'},
+          {account: 'acct1', amount: '$550'}],
+        credits:[
+          {account: 'acct2', amount: '$800'}])
       DoubleDouble.const_get(@capitalized_account_type).balance.should == 0
     end
   end