odania_plutus 0.13

data/spec/factories/amount_factory.rb

@@ -0,0 +1,19 @@
+FactoryGirl.define do
+  factory :amount, :class => Plutus::Amount do |amount|
+    amount.amount BigDecimal.new('473')
+    amount.association :entry, :factory => :entry_with_credit_and_debit
+    amount.association :account, :factory => :asset
+  end
+
+  factory :credit_amount, :class => Plutus::CreditAmount do |credit_amount|
+    credit_amount.amount BigDecimal.new('473')
+    credit_amount.association :entry, :factory => :entry_with_credit_and_debit
+    credit_amount.association :account, :factory => :revenue
+  end
+
+  factory :debit_amount, :class => Plutus::DebitAmount do |debit_amount|
+    debit_amount.amount BigDecimal.new('473')
+    debit_amount.association :entry, :factory => :entry_with_credit_and_debit
+    debit_amount.association :account, :factory => :asset
+  end
+end

data/spec/factories/entry_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :entry, :class => Plutus::Entry do |entry|
+    entry.description 'factory description'
+    factory :entry_with_credit_and_debit, :class => Plutus::Entry do |entry_cd|
+      entry_cd.after_build do |t|
+        t.credit_amounts << FactoryGirl.build(:credit_amount, :entry => t)
+        t.debit_amounts << FactoryGirl.build(:debit_amount, :entry => t)
+      end
+    end
+  end
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+module Plutus
+  describe Account do
+    let(:account) { FactoryGirl.build(:account) }
+    subject { account }
+
+    it { is_expected.not_to be_valid }  # must construct a child type instead
+
+    describe "when using a child type" do
+      let(:account) { FactoryGirl.create(:account, type: "Finance::Asset") }
+      it { is_expected.to be_valid }
+
+      it "should be unique per name" do
+        conflict = FactoryGirl.build(:account, name: account.name, type: account.type)
+        expect(conflict).not_to be_valid
+        expect(conflict.errors[:name]).to eq(["has already been taken"])
+      end
+    end
+
+    it "calling the instance method #balance should raise a NoMethodError" do
+      expect { subject.balance }.to raise_error NoMethodError, "undefined method 'balance'"
+    end
+
+    it "calling the class method ::balance should raise a NoMethodError" do
+      expect { subject.class.balance }.to raise_error NoMethodError, "undefined method 'balance'"
+    end
+
+    describe ".trial_balance" do
+      subject { Account.trial_balance }
+      it { is_expected.to be_kind_of BigDecimal }
+
+      context "when given no entries" do
+        it { is_expected.to eq(0) }
+      end
+
+      context "when given correct entries" do
+        before {
+          # credit accounts
+          liability = FactoryGirl.create(:liability)
+          equity = FactoryGirl.create(:equity)
+          revenue = FactoryGirl.create(:revenue)
+          contra_asset = FactoryGirl.create(:asset, :contra => true)
+          contra_expense = FactoryGirl.create(:expense, :contra => true)
+          # credit amounts
+          ca1 = FactoryGirl.build(:credit_amount, :account => liability, :amount => 100000)
+          ca2 = FactoryGirl.build(:credit_amount, :account => equity, :amount => 1000)
+          ca3 = FactoryGirl.build(:credit_amount, :account => revenue, :amount => 40404)
+          ca4 = FactoryGirl.build(:credit_amount, :account => contra_asset, :amount => 2)
+          ca5 = FactoryGirl.build(:credit_amount, :account => contra_expense, :amount => 333)
+
+          # debit accounts
+          asset = FactoryGirl.create(:asset)
+          expense = FactoryGirl.create(:expense)
+          contra_liability = FactoryGirl.create(:liability, :contra => true)
+          contra_equity = FactoryGirl.create(:equity, :contra => true)
+          contra_revenue = FactoryGirl.create(:revenue, :contra => true)
+          # debit amounts
+          da1 = FactoryGirl.build(:debit_amount, :account => asset, :amount => 100000)
+          da2 = FactoryGirl.build(:debit_amount, :account => expense, :amount => 1000)
+          da3 = FactoryGirl.build(:debit_amount, :account => contra_liability, :amount => 40404)
+          da4 = FactoryGirl.build(:debit_amount, :account => contra_equity, :amount => 2)
+          da5 = FactoryGirl.build(:debit_amount, :account => contra_revenue, :amount => 333)
+
+          FactoryGirl.create(:entry, :credit_amounts => [ca1], :debit_amounts => [da1])
+          FactoryGirl.create(:entry, :credit_amounts => [ca2], :debit_amounts => [da2])
+          FactoryGirl.create(:entry, :credit_amounts => [ca3], :debit_amounts => [da3])
+          FactoryGirl.create(:entry, :credit_amounts => [ca4], :debit_amounts => [da4])
+          FactoryGirl.create(:entry, :credit_amounts => [ca5], :debit_amounts => [da5])
+        }
+
+        it { is_expected.to eq(0) }
+      end
+    end
+
+    describe "#amounts" do
+      it "returns all credit and debit amounts" do
+        equity = FactoryGirl.create(:equity)
+        asset = FactoryGirl.create(:asset)
+        expense = FactoryGirl.create(:expense)
+
+        investment = Entry.new(
+          description: "Initial investment",
+          date: Date.today,
+          debits: [{ account_name: equity.name, amount: 1000 }],
+          credits: [{ account_name: asset.name, amount: 1000 }],
+        )
+        investment.save
+
+        purchase = Entry.new(
+          description: "First computer",
+          date: Date.today,
+          debits: [{ account_name: asset.name, amount: 900 }],
+          credits: [{ account_name: expense.name, amount: 900 }],
+        )
+        purchase.save
+
+        expect(equity.amounts.size).to eq 1
+        expect(asset.amounts.size).to eq 2
+        expect(expense.amounts.size).to eq 1
+      end
+    end
+
+    describe "#entries" do
+      it "returns all credit and debit entries" do
+        equity = FactoryGirl.create(:equity)
+        asset = FactoryGirl.create(:asset)
+        expense = FactoryGirl.create(:expense)
+
+        investment = Entry.new(
+          description: "Initial investment",
+          date: Date.today,
+          debits: [{ account_name: equity.name, amount: 1000 }],
+          credits: [{ account_name: asset.name, amount: 1000 }],
+        )
+        investment.save
+
+        purchase = Entry.new(
+          description: "First computer",
+          date: Date.today,
+          debits: [{ account_name: asset.name, amount: 900 }],
+          credits: [{ account_name: expense.name, amount: 900 }],
+        )
+        purchase.save
+
+        expect(equity.entries.size).to eq 1
+        expect(asset.entries.size).to eq 2
+        expect(expense.entries.size).to eq 1
+      end
+    end
+
+  end
+end

data/spec/models/amount_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Plutus
+  describe Amount do
+    subject { FactoryGirl.build(:amount) }
+    it { is_expected.not_to be_valid }  # construct a child class instead
+  end
+end

data/spec/models/asset_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe Asset do
+    it_behaves_like 'a Plutus::Account subtype', kind: :asset, normal_balance: :debit
+  end
+end

data/spec/models/credit_amount_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe CreditAmount do
+    it_behaves_like 'a Plutus::Amount subtype', kind: :credit_amount
+  end
+end

data/spec/models/debit_amount_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe DebitAmount do
+    it_behaves_like 'a Plutus::Amount subtype', kind: :debit_amount
+  end
+end

data/spec/models/entry_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+module Plutus
+  describe Entry do
+    let(:entry) { FactoryGirl.build(:entry) }
+    subject { entry }
+
+    it { is_expected.not_to be_valid }
+
+    context "with credit and debit" do
+      let(:entry) { FactoryGirl.build(:entry_with_credit_and_debit) }
+      it { is_expected.to be_valid }
+
+      it "should require a description" do
+        entry.description = nil
+        expect(entry).not_to be_valid
+      end
+    end
+
+    context "with a debit" do
+      before {
+        entry.debit_amounts << FactoryGirl.build(:debit_amount, entry: entry)
+      }
+      it { is_expected.not_to be_valid }
+
+      context "with an invalid credit" do
+        before {
+          entry.credit_amounts << FactoryGirl.build(:credit_amount, entry: entry, amount: nil)
+        }
+        it { is_expected.not_to be_valid }
+      end
+    end
+
+    context "with a credit" do
+      before {
+        entry.credit_amounts << FactoryGirl.build(:credit_amount, entry: entry)
+      }
+      it { is_expected.not_to be_valid }
+
+      context "with an invalid debit" do
+        before {
+          entry.debit_amounts << FactoryGirl.build(:debit_amount, entry: entry, amount: nil)
+        }
+        it { is_expected.not_to be_valid }
+      end
+    end
+
+    context "without a date" do
+      let(:entry) { FactoryGirl.build(:entry_with_credit_and_debit, date: nil) }
+
+      context "should assign a default date before being saved" do
+        before { entry.save! }
+        its(:date) { is_expected.to eq(Time.now.to_date) }
+      end
+    end
+
+    it "should require the debit and credit amounts to cancel" do
+      entry.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100, :entry => entry)
+      entry.debit_amounts << FactoryGirl.build(:debit_amount, :amount => 200, :entry => entry)
+      expect(entry).not_to be_valid
+      expect(entry.errors['base']).to eq(["The credit and debit amounts are not equal"])
+    end
+
+    it "should require the debit and credit amounts to cancel even with fractions" do
+      entry = FactoryGirl.build(:entry)
+      entry.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100.1, :entry => entry)
+      entry.debit_amounts << FactoryGirl.build(:debit_amount, :amount => 100.2, :entry => entry)
+      expect(entry).not_to be_valid
+      expect(entry.errors['base']).to eq(["The credit and debit amounts are not equal"])
+    end
+
+    it "should ignore debit and credit amounts marked for destruction to cancel" do
+      entry.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100, :entry => entry)
+      debit_amount = FactoryGirl.build(:debit_amount, :amount => 100, :entry => entry)
+      debit_amount.mark_for_destruction
+      entry.debit_amounts << debit_amount
+      expect(entry).not_to be_valid
+      expect(entry.errors['base']).to eq(["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
+      entry = FactoryGirl.build(:entry_with_credit_and_debit, commercial_document: mock_document)
+      entry.save!
+      saved_entry = Entry.find(entry.id)
+      expect(saved_entry.commercial_document).to eq(mock_document)
+    end
+
+    context "given a set of accounts" do
+      let(:mock_document) { FactoryGirl.create(:asset) }
+      let!(:accounts_receivable) { FactoryGirl.create(:asset, name: "Accounts Receivable") }
+      let!(:sales_revenue) { FactoryGirl.create(:revenue, name: "Sales Revenue") }
+      let!(:sales_tax_payable) { FactoryGirl.create(:liability, name: "Sales Tax Payable") }
+
+      shared_examples_for 'a built-from-hash Plutus::Entry' do
+        its(:credit_amounts) { is_expected.not_to be_empty }
+        its(:debit_amounts) { is_expected.not_to be_empty }
+        it { is_expected.to be_valid }
+
+        context "when saved" do
+          before { entry.save! }
+          its(:id) { is_expected.not_to be_nil }
+
+          context "when reloaded" do
+            let(:saved_transaction) { Entry.find(entry.id) }
+            subject { saved_transaction }
+            it("should have the correct commercial document") {
+              saved_transaction.commercial_document == mock_document
+            }
+          end
+        end
+      end
+
+      describe ".new" do
+        let(:entry) { Entry.new(hash) }
+        subject { entry }
+
+        context "when given a credit/debits hash with :account => Account" do
+          let(:hash) {
+            {
+                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}
+                ]
+            }
+          }
+          include_examples 'a built-from-hash Plutus::Entry'
+        end
+
+        context "when given a credit/debits hash with :account_name => String" do
+          let(:hash) {
+            {
+                description: "Sold some widgets",
+                commercial_document: mock_document,
+                debits: [{account_name: accounts_receivable.name, amount: 50}],
+                credits: [
+                    {account_name: sales_revenue.name, amount: 45},
+                    {account_name: sales_tax_payable.name, amount: 5}
+                ]
+            }
+          }
+          include_examples 'a built-from-hash Plutus::Entry'
+        end
+      end
+
+      describe ".build" do
+        let(:entry) { Entry.build(hash) }
+        subject { entry }
+
+        before { ::ActiveSupport::Deprecation.silenced = true }
+        after { ::ActiveSupport::Deprecation.silenced = false }
+
+        context "when used at all" do
+          let(:hash) { Hash.new }
+
+          it("should be deprecated") {
+            # .build is the only thing deprecated
+            expect(::ActiveSupport::Deprecation).to receive(:warn).once
+            entry
+          }
+        end
+
+      end
+    end
+
+  end
+end

data/spec/models/equity_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe Equity do
+    it_behaves_like 'a Plutus::Account subtype', kind: :equity, normal_balance: :credit
+  end
+end

data/spec/models/expense_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe Expense do
+    it_behaves_like 'a Plutus::Account subtype', kind: :expense, normal_balance: :debit
+  end
+end

data/spec/models/liability_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe Liability do
+    it_behaves_like 'a Plutus::Account subtype', kind: :liability, normal_balance: :credit
+  end
+end

data/spec/models/revenue_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plutus
+  describe Revenue do
+    it_behaves_like 'a Plutus::Account subtype', kind: :revenue, normal_balance: :credit
+  end
+end

data/spec/models/tenancy_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Plutus
+  describe Account do
+    describe 'tenancy support' do
+      before(:each) do
+        ActiveSupportHelpers.clear_model('Account')
+        ActiveSupportHelpers.clear_model('Asset')
+
+        Plutus.enable_tenancy = true
+        Plutus.tenant_class = 'Plutus::Entry'
+
+        FactoryGirlHelpers.reload()
+        Plutus::Asset.new
+      end
+
+      after(:each) do
+        if Plutus.const_defined?(:Asset)
+          ActiveSupportHelpers.clear_model('Account')
+          ActiveSupportHelpers.clear_model('Asset')
+        end
+
+        Plutus.enable_tenancy = false
+        Plutus.tenant_class = nil
+
+        FactoryGirlHelpers.reload()
+      end
+
+      it 'validate uniqueness of name scoped to tenant' do
+        account = FactoryGirl.create(:asset, tenant_id: 10)
+
+        record = FactoryGirl.build(:asset, name: account.name, tenant_id: 10)
+        expect(record).not_to be_valid
+        expect(record.errors[:name]).to eq(['has already been taken'])
+      end
+
+      it 'allows same name scoped under a different tenant' do
+        account = FactoryGirl.create(:asset, tenant_id: 10)
+
+        record = FactoryGirl.build(:asset, name: account.name, tenant_id: 11)
+        expect(record).to be_valid
+      end
+    end
+  end
+end