aloe 0.1.0

data/spec/aloe/account_spec.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aloe::Account do
+  describe "#configuration" do
+    it "returns AccountConfiguration instance by default" do
+      subject.configuration.should be_kind_of Aloe::AccountConfiguration
+    end
+  end
+
+  describe "#allow_negative_balance" do
+    it "delegates request to configuration" do
+      configuration = double "account configuration"
+      subject.stub(:configuration).and_return configuration
+      configuration.should_receive(:allow_negative_balance).and_return true
+      subject.allow_negative_balance.should be_true
+    end
+  end
+
+  describe "#balance" do
+    it "returns instance of Money value" do
+      subject.currency = "CZK"
+      subject.balance = 1234
+      subject.balance.should eq Money.new(1234, "CZK")
+    end
+  end
+
+  describe "#balance_of?" do
+    before(:each) do
+      subject.balance = 500
+    end
+
+    context "given fixnum cents" do
+      it "returns true when available balance is more than or equals to given number" do
+        subject.balance_of?(500).should be_true
+        subject.balance_of?(35).should be_true
+      end
+
+      it "returns false when available balance is less than given number" do
+        subject.balance_of?(501).should be_false
+        subject.balance_of?(990).should be_false
+      end
+    end
+
+    context "given Money instance" do
+      it "returns true when available balance is more than or equals to given number" do
+        subject.balance_of?(Money.new(500)).should be_true
+        subject.balance_of?(Money.new(35)).should be_true
+      end
+
+      it "returns false when available balance is less than given number" do
+        subject.balance_of?(Money.new(501)).should be_false
+        subject.balance_of?(Money.new(990)).should be_false
+      end
+
+    end
+  end
+
+  describe "#closeable?" do
+    context "given the balance is zero" do
+      it "returns true" do
+        subject.should be_closeable
+      end
+    end
+
+    context "given the balance is non-zero" do
+      it "returns false" do
+        subject.stub(:balance).and_return Money.new 100
+        subject.should_not be_closeable
+      end
+    end
+  end
+
+  describe "#create_entry" do
+    before do
+      subject.currency = "GBP"
+      subject.save!
+    end
+
+    it "creates entry" do
+      subject.create_entry 500
+      subject.entries.size.should eq 1
+    end
+
+    it "modifies the balance" do
+      subject.create_entry 500
+      subject.balance.should eq Money.new(500, "GBP")
+    end
+
+    it "returns created entry" do
+      entry = subject.create_entry(500)
+      entry.should be_kind_of(Aloe::Entry)
+      entry.amount.should eq Money.new(500, :GBP)
+    end
+  end
+
+  describe "#currency?" do
+    it "checks whether account is of asked currency" do
+      subject.currency = "GBP"
+      subject.currency?(:GBP).should be_true
+      subject.currency?("GBP").should be_true
+      subject.currency?("USD").should be_false
+    end
+  end
+
+  describe "#rollback_all" do
+    it "calls rollback on all transactions" do
+      t1 = double("t1")
+      t2 = double("t2")
+      entries = [double("e1", transaction: t1), double("e2", transaction: t2)]
+      subject.stub(:entries).and_return entries
+      t1.should_receive(:rollback)
+      t2.should_receive(:rollback)
+      subject.rollback_all
+    end
+  end
+
+  describe "#balance_at" do
+    before do
+      subject.stub(:currency).and_return 'GBP'
+      subject.stub_chain(:entries, :where).and_return entries
+    end
+
+    context 'given date before the account was created' do
+      let(:entries) { [] }
+
+      before do
+        subject.stub(:created_at).and_return Time.now
+      end
+
+      it "should have nil balance before it was created" do
+        subject.balance_at(1.year.ago).should be_nil
+      end
+    end
+
+    context 'given there are entries and correct date given' do
+      let(:balance) { 84920123 }
+      let(:amounts) { [4858, -75785, 5951, -9958, 99485, 885496, 9983] }
+      let(:entries) do
+        amounts.map do |amount|
+          double "Entry", amount: amount
+        end
+      end
+
+      before do
+        subject.stub(:balance).and_return balance
+        subject.stub(:created_at).and_return 30.days.ago
+      end
+
+      it "should give the correct past balance" do
+        subject.balance_at(29.days.ago).should eq(balance - amounts.sum)
+      end
+    end
+  end
+
+  describe "#turnover" do
+    before do
+      subject.stub_chain(:entries, :where).and_return entries
+      subject.stub(:currency).and_return 'GBP'
+    end
+
+    context "given there are any entries" do
+      let(:amounts) { [1234, 500, -1234, 600, -100] }
+      let(:entries) do
+        amounts.map do |amount|
+          double "Entry", amount: amount
+        end
+      end
+
+      it "returns turnover over given period of time" do
+        subject.turnover(1.month.ago..Time.now).should eq 1000
+      end
+    end
+
+    context "given there are no entries" do
+      let(:entries) { [] }
+
+      before do
+        subject.stub_chain(:entries, :where).and_return entries
+      end
+
+      it "returns Money instance with 0" do
+        zero = Money.new(0, 'GBP')
+        subject.turnover(1.month.ago..Time.now).should eq zero
+      end
+    end
+  end
+end

data/spec/aloe/accounting_integration_spec.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe "Aloe integration spec", integration: true do
+  describe "Aloe::Account" do
+    it "does not allow duplicate names" do
+      create_account 'Test', :GBP
+      account = Aloe::Account.new name: "Test", currency: "GBP"
+      account.should_not be_valid
+    end
+
+    it "does not allow duplicate owners" do
+      user = User.create!
+      previous_account = create_account user, :GBP
+      account = Aloe::Account.new owner: user, currency: "GBP"
+      account.should_not be_valid
+    end
+  end
+
+  describe "Aloe::Ledger.find_account" do
+    context "given an account exists" do
+      let(:user) { User.create! }
+
+      it "returns given account" do
+        create_account user, :GBP
+        account = Aloe::Ledger.find_account(user, "GBP")
+        account.should be_kind_of Aloe::Account
+        account.owner.should eq user
+      end
+    end
+  end
+
+  describe "posting to a ledger" do
+    let(:from_account) { create_account 'Debit', :GBP }
+    let(:to_account)   { create_account 'Credit', :GBP }
+    let(:money)        { Money.new 5000, "GBP" }
+
+    it "manipulates balances" do
+      Aloe::Ledger.create_entry money, from: from_account, to: to_account,
+        type: 'deposit'
+      to_account.balance.should eq money
+      from_account.balance.should eq -money
+    end
+
+    context "given different currency" do
+      it "raises exception when given amount is of different currency" do
+        money = Money.new 5000, "USD"
+        lambda do
+          Aloe::Ledger.create_entry money, from: from_account,
+            to: to_account,
+            type: 'deposit'
+        end.should raise_error Aloe::InvalidCurrencyError
+      end
+    end
+
+    context "given that accounts are of different currency" do
+      let(:to_account) { create_account 'Credit', :USD }
+
+      it "raises exception when given amount is of different currency" do
+        lambda do
+          Aloe::Ledger.create_entry money, from: from_account, to: to_account,
+            type: 'deposit'
+        end.should raise_error Aloe::InvalidCurrencyError
+      end
+    end
+
+    context "given debit account cannot have negative balance" do
+      let(:configuration) { Aloe::AccountConfiguration.new allow_negative_balance: false }
+      let(:from_account)  { create_account 'Debit', :GBP, configuration: configuration }
+
+      it "raises exception" do
+        lambda do
+          Aloe::Ledger.create_entry money, from: from_account, to: to_account,
+            type: 'deposit'
+        end.should raise_error Aloe::InsufficientBalanceError
+        to_account.balance.should be_zero
+        from_account.balance.should be_zero
+      end
+    end
+
+    context "given debit account is closed" do
+      let(:from_account)  { create_account 'Debit', :GBP }
+
+      before do
+        from_account.close!
+      end
+
+      it "manipulates balances" do
+        lambda do
+          Aloe::Ledger.create_entry money, from: from_account,
+            to: to_account,
+            type: 'deposit'
+        end.should raise_error Aloe::InoperableAccountError
+        to_account.balance.should be_zero
+        from_account.balance.should be_zero
+      end
+    end
+
+    context "given debit account is suspended" do
+      let(:from_account)  { create_account 'Debit', :GBP }
+
+      before do
+        from_account.suspend!
+      end
+
+      it "manipulates balances" do
+        lambda do
+          Aloe::Ledger.create_entry money, from: from_account,
+            to: to_account,
+            type: 'deposit'
+        end.should raise_error Aloe::InoperableAccountError
+        to_account.balance.should be_zero
+        from_account.balance.should be_zero
+      end
+    end
+  end
+
+  describe "rolling back transactions" do
+    let(:from_account) { create_account 'Debit', :GBP }
+    let(:to_account)   { create_account 'Credit', :GBP }
+    let(:money)        { Money.new 5000, "GBP" }
+
+    before do
+      @transaction = Aloe::Ledger.create_entry money,
+        from: from_account, to: to_account,
+        type: 'deposit'
+    end
+
+    it "creates balancing transaction" do
+      @transaction.rollback
+      from_account.entries.size.should eq 2
+      to_account.entries.size.should eq 2
+      Aloe::Transaction.last.type.should eq Aloe::ROLLBACK_TRANSACTION
+      Aloe::Transaction.last.type.should eq Aloe::ROLLBACK_TRANSACTION
+    end
+
+    it "balances accounts" do
+      @transaction.rollback
+      from_account.reload.balance.should be_zero
+      to_account.reload.balance.should be_zero
+    end
+  end
+
+  describe "handling concurent transactions" do
+    let(:configuration) { Aloe::AccountConfiguration.new allow_negative_balance: false }
+    let(:from_account) { create_account 'Debit', :GBP, configuration: configuration }
+    let(:to_account)   { create_account 'Credit', :GBP, configuration: configuration }
+    let(:source)       { create_account 'Source', :GBP }
+    let(:money)        { Money.new 5000, "GBP" }
+
+    before do
+      Aloe::Ledger.create_entry money, from: source,
+        to: from_account,
+        type: 'deposit'
+    end
+
+    it "shouldn't allow concurent transactions" do
+      from_account_copy = Aloe::Account.find(from_account.id)
+      Aloe::Ledger.create_entry money, from: from_account,
+        to: to_account,
+        type: 'deposit'
+      expect do
+        Aloe::Ledger.create_entry money, from: from_account_copy,
+          to: to_account,
+          type: 'deposit'
+      end.to raise_error(Aloe::InsufficientBalanceError)
+      to_account.balance.should eq money
+    end
+  end
+end
+

data/spec/aloe/entry_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aloe::Entry do
+  it "takes amount in fixnum" do
+    subject.amount = 1234
+    subject.read_attribute(:amount).should eq 1234
+  end
+
+  it "delegates #currency to #account" do
+    subject.stub(:account).and_return(double "Account", currency: "GBP")
+    subject.currency.should eq "GBP"
+  end
+
+  describe '#amount' do
+    it 'returns Money instance' do
+      subject.send :write_attribute, :amount, 1234
+      subject.stub(:account).and_return(double 'Account', currency: 'GBP')
+      subject.amount.should eq Money.new(1234, 'GBP')
+    end
+  end
+
+  describe '#withdrawal?' do
+    before do
+      subject.stub(:account).and_return(double 'Account', currency: 'GBP')
+    end
+
+    context 'given the amount is negative' do
+      it 'returns true' do
+        subject.send :write_attribute, :amount, -1234
+        subject.should be_withdrawal
+      end
+    end
+
+    context 'given the amount is positive' do
+      it 'returns false' do
+        subject.send :write_attribute, :amount, 1234
+        subject.should_not be_withdrawal
+      end
+    end
+  end
+end

data/spec/aloe/ledger_entry_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aloe::LedgerEntry do
+  describe ".create_entry" do
+    let(:debit_account) { double 'DebitAccount', currency?: true,
+      create_entry: debit_entry, open?: true }
+    let(:credit_account) { double 'CreditAccount', currency?: true,
+      create_entry: credit_entry, open?: true }
+    let(:credit_entry) { double 'CreditEntry' }
+    let(:debit_entry) { double 'DebitEntry' }
+    let(:transaction) { double 'Transaction' }
+    let(:amount) { Money.new 5000, :GBP }
+    let(:options) { { from: debit_account, to: credit_account, type: 123 } }
+    subject { Aloe::LedgerEntry.new amount, options }
+
+    before do
+      Aloe::Transaction.stub(:create!)
+    end
+
+    it "checks if credit and debit accounts are of given currency" do
+      debit_account.should_receive(:currency?).with(amount.currency).and_return true
+      credit_account.should_receive(:currency?).with(amount.currency).and_return true
+      subject.create!
+    end
+
+    it "creates entry on debit and credit account" do
+      debit_account.should_receive(:create_entry).with(-5000)
+      credit_account.should_receive(:create_entry).with(5000)
+      subject.create!
+    end
+
+    it "creates transaction" do
+      Aloe::Transaction
+        .should_receive(:create!)
+        .with(credit_entry: credit_entry, debit_entry: debit_entry, category: 123)
+        .and_return transaction
+      subject.create!.should eq transaction
+    end
+
+    context "account owners given instead of accounts" do
+      let(:debit_owner) { double "debit owner" }
+      let(:credit_owner) { double "credit owner" }
+
+      it "finds accounts" do
+        Aloe::Ledger
+          .should_receive(:find_account)
+          .with(credit_owner, amount.currency)
+          .and_return credit_account
+        Aloe::Ledger
+          .should_receive(:find_account)
+          .with(debit_owner, amount.currency)
+          .and_return debit_account
+        Aloe::LedgerEntry.new(amount, from: debit_owner, to: credit_owner,
+                                       type: 123).create!
+      end
+    end
+
+    context "given different currency" do
+      let(:amount) { Money.new 5000, :CZK }
+
+      it "raises InvalidCurrencyError if given different currency" do
+        lambda do
+          debit_account.stub(:currency?).and_return false
+          subject.create!
+        end.should raise_error(Aloe::InvalidCurrencyError)
+      end
+    end
+
+    context "given 0 amount" do
+      let(:amount) { 0 }
+
+      it "raises InvalidAmountError" do
+        lambda do
+          subject.create!
+        end.should raise_error(Aloe::InvalidAmountError)
+      end
+    end
+
+    context "given closed or freezed debit amount" do
+      before do
+        debit_account.stub(:open?).and_return false
+      end
+
+      it "raises InoperableAccountError" do
+        lambda do
+          subject.create!
+        end.should raise_error(Aloe::InoperableAccountError)
+      end
+    end
+
+    context "given closed or freezed credit amount" do
+      before do
+        credit_account.stub(:open?).and_return false
+      end
+
+      it "raises InoperableAccountError" do
+        lambda do
+          subject.create!
+        end.should raise_error(Aloe::InoperableAccountError)
+      end
+    end
+  end
+end