plutus 0.5.2 → 0.7.0

data/spec/models/expense_spec.rb

@@ -1,46 +1,54 @@
 require 'spec_helper'
 
-describe Expense do
-  
-  it "should allow creating an expense account" do
-    expense = Factory(:expense)
-  end
-  
-  it "should report a balance for the expense account" do
-    expense = Factory(:expense)
-    expense.balance.should be_kind_of(BigDecimal)
-  end
-  
-  it "should report a balance for the class of accounts" do
-    Expense.should respond_to(:balance)
-    Expense.balance.should be_kind_of(BigDecimal)
-  end
-  
-  it "should not report a trial balance" do
-    lambda{Expense.trial_balance}.should raise_error(NoMethodError)
-  end
-  
-  it "should not be valid without a name" do
-    expense = Factory.build(:expense, :name => nil)
-    expense.should_not be_valid
-  end
-  
-  it "should have many credit transactions" do
-    expense = Factory(:expense)
-    expense.should respond_to(:credit_transactions)
-  end
+module Plutus
+  describe Expense do
+
+    it "should allow creating an expense account" do
+      expense = FactoryGirl.create(:expense)
+    end
 
-  it "should have many debit transactions" do
-    expense = Factory(:expense)
-    expense.should respond_to(:debit_transactions)
-  end  
+    it "should report a balance for the expense account" do
+      expense = FactoryGirl.create(:expense)
+      FactoryGirl.create(:debit_amount, :account => expense)
+      expense.balance.should > 0
+      expense.balance.should be_kind_of(BigDecimal)
+    end
 
-  it "a contra account should reverse the normal balance" do
-    expense = Factory(:expense)
-    contra_expense = Factory(:expense, :contra => true)
-    transaction = Factory(:transaction, :credit_account => contra_expense, :debit_account => expense, :amount => 1000)
-    contra_expense.balance.should > 0
-    Expense.balance.should == 0
-  end  
+    it "should report a balance for the class of accounts" do
+      expense = FactoryGirl.create(:expense)
+      FactoryGirl.create(:debit_amount, :account => expense)
+      Expense.should respond_to(:balance)
+      Expense.balance.should > 0
+      Expense.balance.should be_kind_of(BigDecimal)
+    end
 
-end
+    it "should not report a trial balance" do
+      lambda{Expense.trial_balance}.should raise_error(NoMethodError)
+    end
+
+    it "should not be valid without a name" do
+      expense = FactoryGirl.build(:expense, :name => nil)
+      expense.should_not be_valid
+    end
+
+    it "should have many credit transactions" do
+      expense = Factory(:expense)
+      expense.should respond_to(:credit_transactions)
+    end
+
+    it "should have many debit transactions" do
+      expense = Factory(:expense)
+      expense.should respond_to(:debit_transactions)
+    end
+
+    it "a contra account should reverse the normal balance" do
+      expense = FactoryGirl.create(:expense)
+      contra_expense = Factory(:expense, :contra => true)
+      FactoryGirl.create(:debit_amount, :account => expense)
+      FactoryGirl.create(:credit_amount, :account => contra_expense)
+      contra_expense.balance.should > 0
+      Expense.balance.should == 0
+    end
+
+  end
+end

data/spec/models/liability_spec.rb

@@ -1,46 +1,54 @@
 require 'spec_helper'
 
-describe Liability do
-  
-  it "should allow creating a liability account" do
-    liability = Factory(:liability)
-  end
-  
-  it "should report a balance for the liability account" do
-    liability = Factory(:liability)
-    liability.balance.should be_kind_of(BigDecimal)
-  end
-  
-  it "should report a balance for the class of accounts" do
-    Liability.should respond_to(:balance)
-    Liability.balance.should be_kind_of(BigDecimal)
-  end
-  
-  it "should not report a trial balance" do
-    lambda{Liability.trial_balance}.should raise_error(NoMethodError)
-  end
-  
-  it "should not be valid without a name" do
-    liability = Factory.build(:liability, :name => nil)
-    liability.should_not be_valid
-  end  
-  
-  it "should have many credit transactions" do
-    liability = Factory(:liability)
-    liability.should respond_to(:credit_transactions)
-  end
+module Plutus
+  describe Liability do
+
+    it "should allow creating an liability account" do
+      liability = FactoryGirl.create(:liability)
+    end
 
-  it "should have many debit transactions" do
-    liability = Factory(:liability)
-    liability.should respond_to(:debit_transactions)
-  end  
+    it "should report a balance for the liability account" do
+      liability = FactoryGirl.create(:liability)
+      FactoryGirl.create(:credit_amount, :account => liability)
+      liability.balance.should > 0
+      liability.balance.should be_kind_of(BigDecimal)
+    end
 
-  it "a contra account should reverse the normal balance" do
-    liability = Factory(:liability)
-    contra_liability = Factory(:liability, :contra => true)
-    transaction = Factory(:transaction, :credit_account => liability, :debit_account => contra_liability, :amount => 1000)
-    contra_liability.balance.should > 0
-    Liability.balance.should == 0
-  end  
+    it "should report a balance for the class of accounts" do
+      liability = FactoryGirl.create(:liability)
+      FactoryGirl.create(:credit_amount, :account => liability)
+      Liability.should respond_to(:balance)
+      Liability.balance.should > 0
+      Liability.balance.should be_kind_of(BigDecimal)
+    end
 
+    it "should not report a trial balance" do
+      lambda{Liability.trial_balance}.should raise_error(NoMethodError)
+    end
+
+    it "should not be valid without a name" do
+      liability = FactoryGirl.build(:liability, :name => nil)
+      liability.should_not be_valid
+    end
+
+    it "should have many credit transactions" do
+      liability = Factory(:liability)
+      liability.should respond_to(:credit_transactions)
+    end
+
+    it "should have many debit transactions" do
+      liability = Factory(:liability)
+      liability.should respond_to(:debit_transactions)
+    end
+
+    it "a contra account should reverse the normal balance" do
+      liability = FactoryGirl.create(:liability)
+      contra_liability = Factory(:liability, :contra => true)
+      FactoryGirl.create(:credit_amount, :account => liability)
+      FactoryGirl.create(:debit_amount, :account => contra_liability)
+      contra_liability.balance.should > 0
+      Liability.balance.should == 0
+    end
+
+  end
 end

data/spec/models/revenue_spec.rb

@@ -1,46 +1,53 @@
 require 'spec_helper'
 
-describe Revenue do
-  
-  it "should allow creating a revenue account" do
-    revenue = Factory(:revenue)
-  end
-  
-  it "should report a balance for the revenue account" do
-    revenue = Factory(:revenue)
-    revenue.balance.should be_kind_of(BigDecimal)
-  end
-  
-  it "should report a balance for the class of accounts" do
-    Revenue.should respond_to(:balance)
-    Revenue.balance.should be_kind_of(BigDecimal)
-  end
-  
-  it "should not report a trial balance" do
-    lambda{Revenue.trial_balance}.should raise_error(NoMethodError)
-  end
-  
-  it "should not be valid without a name" do
-    revenue = Factory.build(:revenue, :name => nil)
-    revenue.should_not be_valid
-  end  
-  
-  it "should have many credit transactions" do
-    revenue = Factory(:revenue)
-    revenue.should respond_to(:credit_transactions)
-  end
+module Plutus
+  describe Revenue do
+
+    it "should allow creating an revenue account" do
+      revenue = FactoryGirl.create(:revenue)
+    end
+
+    it "should report a balance for the revenue account" do
+      revenue = FactoryGirl.create(:revenue)
+      FactoryGirl.create(:credit_amount, :account => revenue)
+      revenue.balance.should > 0
+      revenue.balance.should be_kind_of(BigDecimal)
+    end
 
-  it "should have many debit transactions" do
-    revenue = Factory(:revenue)
-    revenue.should respond_to(:debit_transactions)
-  end  
-  
-  it "a contra account should reverse the normal balance" do
-    revenue = Factory(:revenue)
-    contra_revenue = Factory(:revenue, :contra => true)
-    transaction = Factory(:transaction, :credit_account => revenue, :debit_account => contra_revenue, :amount => 1000)
-    contra_revenue.balance.should > 0
-    Revenue.balance.should == 0
-  end  
+    it "should report a balance for the class of accounts" do
+      revenue = FactoryGirl.create(:revenue)
+      FactoryGirl.create(:credit_amount, :account => revenue)
+      Revenue.should respond_to(:balance)
+      Revenue.balance.should > 0
+      Revenue.balance.should be_kind_of(BigDecimal)
+    end
 
+    it "should not report a trial balance" do
+      lambda{Revenue.trial_balance}.should raise_error(NoMethodError)
+    end
+
+    it "should not be valid without a name" do
+      revenue = FactoryGirl.build(:revenue, :name => nil)
+      revenue.should_not be_valid
+    end
+
+    it "should have many credit transactions" do
+      revenue = Factory(:revenue)
+      revenue.should respond_to(:credit_transactions)
+    end
+
+    it "should have many debit transactions" do
+      revenue = Factory(:revenue)
+      revenue.should respond_to(:debit_transactions)
+    end
+
+    it "a contra account should reverse the normal balance" do
+      contra_revenue = Factory(:revenue, :contra => true)
+      # the odd amount below is because factories create an revenue debit_amount
+      FactoryGirl.create(:debit_amount, :account => contra_revenue, :amount => 473) 
+      contra_revenue.balance.should > 0
+      Revenue.balance.should == 0 
+    end
+
+  end
 end

data/spec/models/transaction_spec.rb

@@ -1,48 +1,83 @@
 require 'spec_helper'
 
-describe Transaction do
+module Plutus
+  describe Transaction do
 
-  it "should create a transaction" do
-    transaction = Factory(:transaction)
-  end
-  
-  it "should not be valid without a credit account" do
-    transaction = Factory.build(:transaction, :credit_account => nil)
-    transaction.should_not be_valid
-  end
-  
-  it "should not be valid without a valid credit account" do
-    bad_account = Factory.build(:asset, :name => nil)
-    transaction = Factory.build(:transaction, :credit_account => bad_account)
-    transaction.should_not be_valid
-  end  
-
-  it "should not be valid without a debit account" do
-    transaction = Factory.build(:transaction, :debit_account => nil)
-    transaction.should_not be_valid
-  end
-  
-  it "should not be valid without a valid credit account" do
-    bad_account = Factory.build(:asset, :name => nil)
-    transaction = Factory.build(:transaction, :debit_account => bad_account)
-    transaction.should_not be_valid
-  end  
-  
-  it "should not be valid without an amount" do
-    transaction = Factory.build(:transaction, :amount => nil)
-    transaction.should_not be_valid
-  end
+    it "should create a transaction" do
+      transaction = FactoryGirl.build(:transaction_with_credit_and_debit)
+      transaction.save!
+    end
+
+    it "should not be valid without a credit amount" do
+      transaction = FactoryGirl.build(:transaction)
+      transaction.debit_amounts << FactoryGirl.build(:debit_amount, :transaction => transaction)
+      transaction.should_not be_valid
+      transaction.errors['base'].should include("Transaction must have at least one credit amount")
+    end
+
+    it "should not be valid with an invalid credit amount" do
+      transaction = FactoryGirl.build(:transaction)
+      transaction.debit_amounts << FactoryGirl.build(:debit_amount, :transaction => transaction)
+      transaction.credit_amounts << FactoryGirl.build(:credit_amount, :transaction => transaction, :amount => nil)
+      transaction.should_not be_valid
+      transaction.errors[:credit_amounts].should == ["is invalid"]
+    end
+
+    it "should not be valid without a debit amount" do
+      transaction = FactoryGirl.build(:transaction)
+      transaction.credit_amounts << FactoryGirl.build(:credit_amount, :transaction => transaction)
+      transaction.should_not be_valid
+      transaction.errors['base'].should include("Transaction must have at least one debit amount")
+    end
+
+    it "should not be valid with an invalid debit amount" do
+      transaction = FactoryGirl.build(:transaction)
+      transaction.credit_amounts << FactoryGirl.build(:credit_amount, :transaction => transaction)
+      transaction.debit_amounts << FactoryGirl.build(:debit_amount, :transaction => transaction, :amount => nil)
+      transaction.should_not be_valid
+      transaction.errors[:debit_amounts].should == ["is invalid"]
+    end
+
+    it "should not be valid without a description" do
+      transaction = FactoryGirl.build(:transaction_with_credit_and_debit, :description => nil)
+      transaction.should_not be_valid
+      transaction.errors[:description].should == ["can't be blank"]
+    end
+
+    it "should require the debit and credit amounts to cancel" do
+      transaction = FactoryGirl.build(:transaction)
+      transaction.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100, :transaction => transaction)
+      transaction.debit_amounts << FactoryGirl.build(:debit_amount, :amount => 200, :transaction => transaction)
+      transaction.should_not be_valid
+      transaction.errors['base'].should == ["The credit and debit amounts are not equal"]
+    end
+
+    it "should have a polymorphic commercial document associations" do
+      mock_document = FactoryGirl.create(:asset) # one would never do this, but it allows us to not require a migration for the test
+      transaction = FactoryGirl.build(:transaction_with_credit_and_debit, :commercial_document => mock_document)
+      transaction.save
+      saved_transaction = Transaction.find(transaction.id)
+      saved_transaction.commercial_document.should == mock_document
+    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")
+      mock_document = FactoryGirl.create(:asset)
+      transaction = Transaction.build(
+        description: "Sold some widgets",
+        commercial_document: mock_document,
+        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 = Transaction.find(transaction.id)
+      saved_transaction.commercial_document.should == mock_document
+    end
 
-  it "should not be valid without a description" do
-    transaction = Factory.build(:transaction, :description => nil)
-    transaction.should_not be_valid
-  end
-  
-  it "should have a polymorphic commercial document associations" do
-    mock_document = Factory(:transaction) # one would never do this, but it allows us to not require a migration for the test
-    transaction = Factory(:transaction, :commercial_document => mock_document)
-    saved_transaction = Transaction.find(transaction.id)
-    saved_transaction.commercial_document.should == mock_document
   end
- 
 end

data/spec/routing/accounts_routing_spec.rb

@@ -1,29 +1,32 @@
 require 'spec_helper'
 
-describe AccountsController do
-  describe "routing" do
-    it "recognizes and generates #index" do
-      { :get => "/accounts" }.should route_to(:controller => "accounts", :action => "index")
-    end
+module Plutus
+  describe AccountsController do
+    # Run these tests if you enable routing in your rails app. See README 
+    #describe "routing" do
+      #it "recognizes and generates #index" do
+        #{ :get => "/accounts" }.should route_to(:controller => "accounts", :action => "index")
+      #end
 
-    it "recognizes and generates #show" do
-      { :get => "/accounts/1" }.should route_to(:controller => "accounts", :action => "show", :id => "1")
-    end
+      #it "recognizes and generates #show" do
+        #{ :get => "/accounts/1" }.should route_to(:controller => "accounts", :action => "show", :id => "1")
+      #end
 
-    it "recognizes and generates #edit" do
-      { :get => "/accounts/1/edit" }.should_not be_routable
-    end
+      #it "recognizes and generates #edit" do
+        #{ :get => "/accounts/1/edit" }.should_not be_routable
+      #end
 
-    it "recognizes and generates #create" do
-      { :post => "/accounts" }.should_not be_routable
-    end
+      #it "recognizes and generates #create" do
+        #{ :post => "/accounts" }.should_not be_routable
+      #end
 
-    it "recognizes and generates #update" do
-      { :put => "/accounts/1" }.should_not be_routable
-    end
+      #it "recognizes and generates #update" do
+        #{ :put => "/accounts/1" }.should_not be_routable
+      #end
 
-    it "recognizes and generates #destroy" do
-      { :delete => "/accounts/1" }.should_not be_routable
-    end
+      #it "recognizes and generates #destroy" do
+        #{ :delete => "/accounts/1" }.should_not be_routable
+      #end
+    #end
   end
 end