double_entry 0.0.1.pre → 0.1.0.pre.pre.alpha

data/spec/double_entry/line_aggregate_spec.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require 'spec_helper'
+describe DoubleEntry::LineAggregate do
+
+  it "has a table name prefixed with double_entry_" do
+    expect(DoubleEntry::LineAggregate.table_name).to eq "double_entry_line_aggregates"
+  end
+end

data/spec/double_entry/line_check_spec.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe DoubleEntry::LineCheck do
+
+  describe '#last' do
+
+    context 'Given some checks have been created' do
+      before do
+        Timecop.freeze 3.minutes.ago do
+          DoubleEntry::LineCheck.create! :last_line_id => 100, :errors_found => false, :log => ''
+        end
+        Timecop.freeze 1.minute.ago do
+          DoubleEntry::LineCheck.create! :last_line_id => 300, :errors_found => false, :log => ''
+        end
+        Timecop.freeze 2.minutes.ago do
+          DoubleEntry::LineCheck.create! :last_line_id => 200, :errors_found => false, :log => ''
+        end
+      end
+
+      it 'should find the newest LineCheck created (by creation_date)' do
+        expect(DoubleEntry::LineCheck.last.last_line_id).to eq 300
+      end
+    end
+
+  end
+
+  describe '#perform!' do
+    subject(:performed_line_check) { DoubleEntry::LineCheck.perform! }
+
+    context 'Given a user with 100 dollars' do
+      before { User.make!(:savings_balance => Money.new(100_00)) }
+
+      context 'And all is consistent' do
+
+        context 'And all lines have been checked' do
+          before { DoubleEntry::LineCheck.perform!  }
+
+          it { should be_nil }
+
+          it 'should not persist a new LineCheck' do
+            expect {
+              DoubleEntry::LineCheck.perform!
+            }.to_not change { DoubleEntry::LineCheck.count }
+          end
+        end
+
+        it { should be_instance_of DoubleEntry::LineCheck }
+        its(:errors_found) { should eq false }
+
+        it 'should persist the LineCheck' do
+          line_check = DoubleEntry::LineCheck.perform!
+          expect(DoubleEntry::LineCheck.last).to eq line_check
+        end
+      end
+
+      context 'And there is a consistency error in lines' do
+        before { DoubleEntry::Line.order(:id).limit(1).update_all('balance = balance + 1') }
+
+        its(:errors_found) { should be true }
+        its(:log) { should match /Error on line/ }
+
+        it 'should correct the running balance' do
+          expect {
+            DoubleEntry::LineCheck.perform!
+          }.to change { DoubleEntry::Line.order(:id).first.balance }.by Money.new(-1)
+        end
+      end
+
+      context 'And there is a consistency error in account balance' do
+        before { DoubleEntry::AccountBalance.order(:id).limit(1).update_all('balance = balance + 1') }
+
+        its(:errors_found) { should be true }
+
+        it 'should correct the account balance' do
+          expect {
+            DoubleEntry::LineCheck.perform!
+          }.to change { DoubleEntry::AccountBalance.order(:id).first.balance }.by Money.new(-1)
+        end
+      end
+    end
+
+    it "has a table name prefixed with double_entry_" do
+      expect(DoubleEntry::LineCheck.table_name).to eq "double_entry_line_checks"
+    end
+
+  end
+end

data/spec/double_entry/line_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+require "spec_helper"
+describe DoubleEntry::Line do
+
+  describe "persistent attributes" do
+    let(:persisted_line) {
+      DoubleEntry::Line.new(
+        :amount => Money.new(10_00),
+        :balance => Money.empty,
+        :account => account,
+        :partner_account => partner_account,
+        :code => code,
+        :meta => meta,
+      )
+    }
+    let(:account) { DoubleEntry.account(:test, :scope => "17") }
+    let(:partner_account) { DoubleEntry.account(:test, :scope => "72") }
+    let(:code) { :test_code }
+    let(:meta) { "test meta" }
+    before { persisted_line.save! }
+    subject { DoubleEntry::Line.last }
+
+    context "given code = :the_code" do
+      let(:code) { :the_code }
+      its(:code) { should eq :the_code }
+    end
+
+    context "given code = nil" do
+      let(:code) { nil }
+      its(:code) { should eq nil }
+    end
+
+    context "given account = :test, 54 " do
+      let(:account) { DoubleEntry.account(:test, :scope => "54") }
+      its("account.account.identifier") { should eq :test }
+      its("account.scope") { should eq "54" }
+    end
+
+    context "given partner_account = :test, 91 " do
+      let(:partner_account) { DoubleEntry.account(:test, :scope => "91") }
+      its("partner_account.account.identifier") { should eq :test }
+      its("partner_account.scope") { should eq "91" }
+    end
+
+    context "given meta = 'the meta'" do
+      let(:meta) { "the meta" }
+      its(:meta) { should eq "the meta" }
+    end
+
+    context "given meta = nil" do
+      let(:meta) { nil }
+      its(:meta) { should eq nil }
+    end
+
+    context "given meta has not been persisted (NULL)" do
+      let(:persisted_line) {
+        DoubleEntry::Line.new(
+          :amount => Money.new(10_00),
+          :balance => Money.empty,
+          :account => DoubleEntry.account(:savings, :scope => User.make!),
+          :code => code,
+        )
+      }
+      its(:meta) { should eq Hash.new }
+    end
+  end
+
+  it "has a table name prefixed with double_entry_" do
+    expect(DoubleEntry::Line.table_name).to eq "double_entry_lines"
+  end
+
+end

data/spec/double_entry/locking_spec.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe DoubleEntry::Locking do
+
+  before(:all) { @saved_accounts,   @saved_transfers   = DoubleEntry.accounts, DoubleEntry.transfers }
+  after(:all)  { DoubleEntry.accounts, DoubleEntry.transfers = @saved_accounts,   @saved_transfers   }
+
+  before do
+    scope = lambda {|x| x }
+
+    DoubleEntry.accounts = DoubleEntry::Account::Set.new.tap do |accounts|
+      accounts << DoubleEntry::Account.new(:identifier => :account_a, :scope_identifier => scope)
+      accounts << DoubleEntry::Account.new(:identifier => :account_b, :scope_identifier => scope)
+      accounts << DoubleEntry::Account.new(:identifier => :account_c, :scope_identifier => scope)
+      accounts << DoubleEntry::Account.new(:identifier => :account_d, :scope_identifier => scope)
+    end
+
+    DoubleEntry.transfers = DoubleEntry::Transfer::Set.new.tap do |transfers|
+      transfers << DoubleEntry::Transfer.new(:from => :account_a, :to => :account_b, :code => :test)
+      transfers << DoubleEntry::Transfer.new(:from => :account_c, :to => :account_d, :code => :test)
+    end
+
+    @account_a = DoubleEntry.account(:account_a, :scope => "1")
+    @account_b = DoubleEntry.account(:account_b, :scope => "2")
+    @account_c = DoubleEntry.account(:account_c, :scope => "3")
+    @account_d = DoubleEntry.account(:account_d, :scope => "4")
+  end
+
+  it "should create missing account balance records" do
+    expect do
+      DoubleEntry::Locking.lock_accounts(@account_a) { }
+    end.to change(DoubleEntry::AccountBalance, :count).by(1)
+
+    account_balance = DoubleEntry::AccountBalance.find_by_account(@account_a)
+    expect(account_balance).to_not be_nil
+    expect(account_balance.balance).to eq Money.new(0)
+  end
+
+  it "should take the balance for new account balance records from the lines table" do
+    DoubleEntry::Line.create!(:account => @account_a, :amount => Money.new(3_00), :balance => Money.new( 3_00), :code => :test)
+    DoubleEntry::Line.create!(:account => @account_a, :amount => Money.new(7_00), :balance => Money.new(10_00), :code => :test)
+
+    expect do
+      DoubleEntry::Locking.lock_accounts(@account_a) { }
+    end.to change(DoubleEntry::AccountBalance, :count).by(1)
+
+    account_balance = DoubleEntry::AccountBalance.find_by_account(@account_a)
+    expect(account_balance).to_not be_nil
+    expect(account_balance.balance).to eq Money.new(10_00)
+  end
+
+  it "should not allow locking inside a regular transaction" do
+    expect {
+      DoubleEntry::AccountBalance.transaction do
+        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+        end
+      end
+    }.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
+  end
+
+  it "should not allow a transfer inside a regular transaction" do
+    expect {
+      DoubleEntry::AccountBalance.transaction do
+        DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+      end
+    }.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
+  end
+
+  it "should allow a transfer inside a lock if we've locked the transaction accounts" do
+    expect {
+      DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+        DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+      end
+    }.to_not raise_error
+  end
+
+  it "should not allow a transfer inside a lock if the right locks aren't held" do
+    expect {
+      DoubleEntry::Locking.lock_accounts(@account_a, @account_c) do
+        DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+      end
+    }.to raise_error(DoubleEntry::Locking::LockNotHeld, "No lock held for account: account_b, scope 2")
+  end
+
+  it "should allow nested locks if the outer lock locks all the accounts" do
+    expect do
+      DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { }
+      end
+    end.to_not raise_error
+  end
+
+  it "should not allow nested locks if the out lock doesn't lock all the accounts" do
+    expect do
+      DoubleEntry::Locking.lock_accounts(@account_a) do
+        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { }
+      end
+    end.to raise_error(DoubleEntry::Locking::LockNotHeld, "No lock held for account: account_b, scope 2")
+  end
+
+  it "should roll back a locking transaction" do
+    DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+      DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+      raise ActiveRecord::Rollback
+    end
+    expect(DoubleEntry.balance(@account_a)).to eq Money.new(0)
+    expect(DoubleEntry.balance(@account_b)).to eq Money.new(0)
+  end
+
+  it "should roll back a locking transaction if there's an exception" do
+    expect do
+      DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+        DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+        raise "Yeah, right"
+      end
+    end.to raise_error("Yeah, right")
+    expect(DoubleEntry.balance(@account_a)).to eq Money.new(0)
+    expect(DoubleEntry.balance(@account_b)).to eq Money.new(0)
+  end
+
+  it "should allow multiple threads to lock at the same time" do
+    threads = Array.new
+
+    expect do
+      threads << Thread.new do
+        sleep 0.05
+        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+          DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+        end
+      end
+
+      threads << Thread.new do
+        DoubleEntry::Locking.lock_accounts(@account_c, @account_d) do
+          sleep 0.1
+          DoubleEntry.transfer(Money.new(10_00), :from => @account_c, :to => @account_d, :code => :test)
+        end
+      end
+
+      threads.each(&:join)
+    end.to_not raise_error
+  end
+
+  it "should allow multiple threads to lock accounts without balances at the same time" do
+    threads         = Array.new
+
+    expect do
+      threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { } }
+      threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_c, @account_d) { } }
+
+      threads.each(&:join)
+    end.to_not raise_error
+  end
+end

data/spec/double_entry/month_range_spec.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+require "spec_helper"
+describe DoubleEntry::MonthRange do
+
+  describe "::from_time" do
+    subject(:from_time) { DoubleEntry::MonthRange.from_time(given_time) }
+
+    context "given the Time 31st March 2012" do
+      let(:given_time) { Time.new(2012, 3, 31) }
+      its(:year) { should eq 2012 }
+      its(:month) { should eq 3 }
+    end
+
+    context "given the Date 31st March 2012" do
+      let(:given_time) { Date.parse("2012-03-31") }
+      its(:year) { should eq 2012 }
+      its(:month) { should eq 3 }
+    end
+  end
+
+  describe "::reportable_months" do
+    subject(:reportable_months) { DoubleEntry::MonthRange.reportable_months }
+
+    context "The date is 1st March 1970" do
+      before { Timecop.freeze(Time.new(1970, 3, 1)) }
+
+      it { should eq [
+        DoubleEntry::MonthRange.new(year: 1970, month: 1),
+        DoubleEntry::MonthRange.new(year: 1970, month: 2),
+        DoubleEntry::MonthRange.new(year: 1970, month: 3),
+      ] }
+
+      context "My business started on 5th Feb 1970" do
+        before do
+          DoubleEntry::Reporting.configure do |config|
+            config.start_of_business = Time.new(1970, 2, 5)
+          end
+        end
+
+        it { should eq [
+          DoubleEntry::MonthRange.new(year: 1970, month: 2),
+          DoubleEntry::MonthRange.new(year: 1970, month: 3),
+        ] }
+      end
+    end
+
+    context "The date is 1st Jan 1970" do
+      before { Timecop.freeze(Time.new(1970, 1, 1)) }
+
+      it { should eq [ DoubleEntry::MonthRange.new(year: 1970, month: 1) ] }
+    end
+  end
+
+  describe "::beginning_of_financial_year" do
+    let(:month_range) { DoubleEntry::MonthRange.new(:year => year, :month => month) }
+    let(:year) { 2014 }
+
+    context "the first month of the financial year is July" do
+      subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
+      context "returns the current year if the month is after July" do
+        let(:month) { 10 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 7)) }
+      end
+
+      context "returns the previous year if the month is before July" do
+        let(:month) { 3 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2013, :month => 7)) }
+      end
+    end
+
+    context "the first month of the financial year is January" do
+      subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
+
+      before do
+        DoubleEntry::Reporting.configure do |config|
+          config.first_month_of_financial_year = 1
+        end
+      end
+
+      context "returns the current year if the month is after January" do
+        let(:month) { 10 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 1)) }
+      end
+
+      context "returns the current year if the month is January" do
+        let(:month) { 1 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 1)) }
+      end
+    end
+
+    context "the first month of the financial year is December" do
+      subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
+
+      before do
+        DoubleEntry::Reporting.configure do |config|
+          config.first_month_of_financial_year = 12
+        end
+      end
+
+      context "returns the previous year if the month is before December (in the same year)" do
+        let(:month) { 11 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2013, :month => 12)) }
+      end
+
+      context "returns the previous year if the month is after December (in the next year)" do
+        let(:year) { 2015 }
+        let(:month) { 1 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 12)) }
+      end
+
+      context "returns the current year if the month is December" do
+        let(:month) { 12 }
+        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 12)) }
+      end
+    end
+
+    context "Given a start time of 3rd Dec 1982" do
+      subject(:reportable_months) { DoubleEntry::MonthRange.reportable_months(from: Time.new(1982, 12, 3)) }
+
+      context "The date is 2nd Feb 1983" do
+        before { Timecop.freeze(Time.new(1983, 2, 2)) }
+
+        it { should eq [
+          DoubleEntry::MonthRange.new(year: 1982, month: 12),
+          DoubleEntry::MonthRange.new(year: 1983, month: 1),
+          DoubleEntry::MonthRange.new(year: 1983, month: 2),
+        ] }
+      end
+    end
+  end
+end