double_entry 1.0.1 → 2.0.0.beta1

data/spec/double_entry/balance_calculator_spec.rb

@@ -1,88 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe DoubleEntry::BalanceCalculator do
-  describe '#calculate' do
-    let(:account) { DoubleEntry.account(:test, :scope => scope) }
-    let(:scope) { User.make! }
-    let(:from) { nil }
-    let(:to) { nil }
-    let(:at) { nil }
-    let(:code) { nil }
-    let(:codes) { nil }
-    let(:relation) { double.as_null_object }
-
-    before do
-      allow(DoubleEntry::Line).to receive(:where).and_return(relation)
-      DoubleEntry::BalanceCalculator.calculate(
-        account,
-        :scope => scope,
-        :from => from,
-        :to => to,
-        :at => at,
-        :code => code,
-        :codes => codes,
-      )
-    end
-
-    describe 'what happens with different times' do
-      context 'when we want to sum the lines before a given created_at date' do
-        let(:at) { Time.parse('2014-06-19 15:09:18 +1000') }
-
-        it 'scopes the lines summed to times before (or at) the given time' do
-          expect(relation).to have_received(:where).with(
-            'created_at <= ?', Time.parse('2014-06-19 15:09:18 +1000')
-          )
-        end
-
-        context 'when a time range is also specified' do
-          let(:from) { Time.parse('2014-06-19 10:09:18 +1000') }
-          let(:to) { Time.parse('2014-06-19 20:09:18 +1000') }
-
-          it 'ignores the time range when summing the lines' do
-            expect(relation).to_not have_received(:where).with(
-              :created_at => Time.parse('2014-06-19 10:09:18 +1000')..Time.parse('2014-06-19 20:09:18 +1000'),
-            )
-            expect(relation).to_not have_received(:sum)
-          end
-        end
-      end
-
-      context 'when we want to sum the lines between a given range' do
-        let(:from) { Time.parse('2014-06-19 10:09:18 +1000') }
-        let(:to) { Time.parse('2014-06-19 20:09:18 +1000') }
-
-        it 'scopes the lines summed to times within the given range' do
-          expect(relation).to have_received(:where).with(
-            :created_at => Time.parse('2014-06-19 10:09:18 +1000')..Time.parse('2014-06-19 20:09:18 +1000'),
-          )
-          expect(relation).to have_received(:sum).with(:amount)
-        end
-      end
-    end
-
-    context 'when a single code is provided' do
-      let(:code) { 'code1' }
-
-      it 'scopes the lines summed by the given code' do
-        expect(relation).to have_received(:where).with(:code => ['code1'])
-        expect(relation).to have_received(:sum).with(:amount)
-      end
-    end
-
-    context 'when a list of codes is provided' do
-      let(:codes) { %w(code1 code2) }
-
-      it 'scopes the lines summed by the given codes' do
-        expect(relation).to have_received(:where).with(:code => %w(code1 code2))
-        expect(relation).to have_received(:sum).with(:amount)
-      end
-    end
-
-    context 'when no codes are provided' do
-      it 'does not scope the lines summed by any code' do
-        expect(relation).to_not have_received(:where).with(:code => anything)
-        expect(relation).to_not have_received(:sum).with(:amount)
-      end
-    end
-  end
-end

data/spec/double_entry/configuration_spec.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-RSpec.describe DoubleEntry::Configuration do
-  its(:accounts) { should be_a DoubleEntry::Account::Set }
-  its(:transfers) { should be_a DoubleEntry::Transfer::Set }
-
-  describe 'max lengths' do
-    context 'given a max length has not been set' do
-      its(:code_max_length) { should be 47 }
-      its(:scope_identifier_max_length) { should be 23 }
-      its(:account_identifier_max_length) { should be 31 }
-    end
-
-    context 'given a code max length of 10 has been set' do
-      before { subject.code_max_length = 10 }
-      its(:code_max_length) { should be 10 }
-    end
-
-    context 'given a scope identifier max length of 11 has been set' do
-      before { subject.scope_identifier_max_length = 11 }
-      its(:scope_identifier_max_length) { should be 11 }
-    end
-
-    context 'given an account identifier max length of 9 has been set' do
-      before { subject.account_identifier_max_length = 9 }
-      its(:account_identifier_max_length) { should be 9 }
-    end
-
-    after do
-      subject.code_max_length = nil
-      subject.scope_identifier_max_length = nil
-      subject.account_identifier_max_length = nil
-    end
-  end
-
-  describe '#define_accounts' do
-    it 'yields the accounts set' do
-      expect do |block|
-        subject.define_accounts(&block)
-      end.to yield_with_args(be_a DoubleEntry::Account::Set)
-    end
-  end
-
-  describe '#define_transfers' do
-    it 'yields the transfers set' do
-      expect do |block|
-        subject.define_transfers(&block)
-      end.to yield_with_args(be_a DoubleEntry::Transfer::Set)
-    end
-  end
-end

data/spec/double_entry/line_spec.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-RSpec.describe DoubleEntry::Line do
-  it 'has a table name prefixed with double_entry_' do
-    expect(DoubleEntry::Line.table_name).to eq 'double_entry_lines'
-  end
-
-  describe 'persistance' do
-    let(:line_to_persist) do
-      DoubleEntry::Line.new(
-        :amount => Money.new(10_00),
-        :balance => Money.zero,
-        :account => account,
-        :partner_account => partner_account,
-        :code => code,
-      )
-    end
-    let(:account) { DoubleEntry.account(:test, :scope => '17') }
-    let(:partner_account) { DoubleEntry.account(:test, :scope => '72') }
-    let(:code) { :test_code }
-
-    subject(:persisted_line) do
-      line_to_persist.save!
-      line_to_persist.reload
-    end
-
-    describe 'attributes' do
-      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 }
-        specify { expect { line_to_persist.save! }.to raise_error }
-      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 'currency' do
-        let(:account) { DoubleEntry.account(:btc_test, :scope => '17') }
-        let(:partner_account) { DoubleEntry.account(:btc_test, :scope => '72') }
-        its(:currency) { should eq 'BTC' }
-      end
-    end
-
-    context 'when balance is sent negative' do
-      before { DoubleEntry::Account.accounts.define(:identifier => :a_positive_only_acc, :positive_only => true) }
-      let(:account) { DoubleEntry.account(:a_positive_only_acc) }
-      let(:line) { DoubleEntry::Line.new(:balance => Money.new(-1), :account => account) }
-
-      it 'raises AccountWouldBeSentNegative error' do
-        expect { line.save }.to raise_error DoubleEntry::AccountWouldBeSentNegative
-      end
-    end
-
-    context 'when balance is sent positive' do
-      before { DoubleEntry::Account.accounts.define(:identifier => :a_negative_only_acc, :negative_only => true) }
-      let(:account) { DoubleEntry.account(:a_negative_only_acc) }
-      let(:line) { DoubleEntry::Line.new(:balance => Money.new(1), :account => account) }
-
-      it 'raises AccountWouldBeSentPositiveError' do
-        expect { line.save }.to raise_error DoubleEntry::AccountWouldBeSentPositiveError
-      end
-    end
-
-    it 'has a table name prefixed with double_entry_' do
-      expect(DoubleEntry::Line.table_name).to eq 'double_entry_lines'
-    end
-  end
-end

data/spec/double_entry/locking_spec.rb

@@ -1,214 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe DoubleEntry::Locking do
-  before do
-    @config_accounts = DoubleEntry.configuration.accounts
-    @config_transfers = DoubleEntry.configuration.transfers
-    DoubleEntry.configuration.accounts = DoubleEntry::Account::Set.new
-    DoubleEntry.configuration.transfers = DoubleEntry::Transfer::Set.new
-  end
-
-  after do
-    DoubleEntry.configuration.accounts = @config_accounts
-    DoubleEntry.configuration.transfers = @config_transfers
-  end
-
-  before do
-    scope = ->(x) { x }
-
-    DoubleEntry.configure do |config|
-      config.define_accounts do |accounts|
-        accounts.define(:identifier => :account_a, :scope_identifier => scope)
-        accounts.define(:identifier => :account_b, :scope_identifier => scope)
-        accounts.define(:identifier => :account_c, :scope_identifier => scope)
-        accounts.define(:identifier => :account_d, :scope_identifier => scope)
-        accounts.define(:identifier => :account_e)
-      end
-
-      config.define_transfers do |transfers|
-        transfers.define(:from => :account_a, :to => :account_b, :code => :test)
-        transfers.define(:from => :account_c, :to => :account_d, :code => :test)
-      end
-    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')
-    @account_e = DoubleEntry.account(:account_e)
-  end
-
-  it 'creates 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 'takes the balance for new account balance records from the lines table' do
-    DoubleEntry::Line.create!(
-      :account => @account_a,
-      :partner_account => @account_b,
-      :amount => Money.new(3_00),
-      :balance => Money.new(3_00),
-      :code => :test,
-    )
-    DoubleEntry::Line.create!(
-      :account => @account_a,
-      :partner_account => @account_b,
-      :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 'prohibits locking inside a regular transaction' do
-    expect do
-      DoubleEntry::AccountBalance.transaction do
-        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
-        end
-      end
-    end.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
-  end
-
-  it 'prohibits a transfer inside a regular transaction' do
-    expect do
-      DoubleEntry::AccountBalance.transaction do
-        DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
-      end
-    end.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
-  end
-
-  it "allows a transfer inside a lock if we've locked the transaction accounts" 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)
-      end
-    end.to_not raise_error
-  end
-
-  it "does not allow a transfer inside a lock if the right locks aren't held" do
-    expect do
-      DoubleEntry::Locking.lock_accounts(@account_a, @account_c) do
-        DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
-      end
-    end.to raise_error(DoubleEntry::Locking::LockNotHeld, 'No lock held for account: account_b, scope 2')
-  end
-
-  it 'allows 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 "prohibits 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 'rolls 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)
-      fail 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 "rolls 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)
-        fail '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 'allows locking a scoped account and a non scoped account' do
-    expect do
-      DoubleEntry::Locking.lock_accounts(@account_d, @account_e) {}
-    end.to_not raise_error
-  end
-
-  context 'handling ActiveRecord::StatementInvalid errors' do
-    context 'non lock wait timeout errors' do
-      let(:error) { ActiveRecord::StatementInvalid.new('some other error') }
-      before do
-        allow(DoubleEntry::AccountBalance).to receive(:with_restart_on_deadlock).
-          and_raise(error)
-      end
-
-      it 're-raises the ActiveRecord::StatementInvalid error' do
-        expect do
-          DoubleEntry::Locking.lock_accounts(@account_d, @account_e) {}
-        end.to raise_error(error)
-      end
-    end
-
-    context 'lock wait timeout errors' do
-      before do
-        allow(DoubleEntry::AccountBalance).to receive(:with_restart_on_deadlock).
-          and_raise(ActiveRecord::StatementInvalid, 'lock wait timeout')
-      end
-
-      it 'raises a LockWaitTimeout error' do
-        expect do
-          DoubleEntry::Locking.lock_accounts(@account_d, @account_e) {}
-        end.to raise_error(DoubleEntry::Locking::LockWaitTimeout)
-      end
-    end
-  end
-
-  # sqlite cannot handle these cases so they don't run when DB=sqlite
-  describe 'concurrent locking', :unless => ENV['DB'] == 'sqlite' do
-    it 'allows multiple threads to lock at the same time' do
-      expect do
-        threads = []
-
-        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 'allows multiple threads to lock accounts without balances at the same time' do
-      threads = []
-      expect do
-        threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { sleep 0.1 } }
-        threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_c, @account_d) { sleep 0.1 } }
-
-        threads.each(&:join)
-      end.to_not raise_error
-    end
-  end
-end

data/spec/double_entry/performance/double_entry_performance_spec.rb

@@ -1,32 +0,0 @@
-module DoubleEntry
-  RSpec.describe DoubleEntry do
-    describe 'transfer performance' do
-      include PerformanceHelper
-      let(:user) { User.make! }
-      let(:amount) { Money.new(10_00) }
-      let(:test) { DoubleEntry.account(:test, :scope => user) }
-      let(:savings) { DoubleEntry.account(:savings, :scope => user) }
-
-      it 'creates a lot of transfers quickly without metadata' do
-        profile_transfers_with_metadata(nil)
-        # local results: 6.44, 5.93, 5.94
-      end
-
-      it 'creates a lot of transfers quickly with metadata' do
-        big_metadata = {}
-        8.times { |i| big_metadata["key#{i}".to_sym] = "value#{i}" }
-        profile_transfers_with_metadata(big_metadata)
-        # local results: 21.2, 21.6, 20.9
-      end
-    end
-
-    def profile_transfers_with_metadata(metadata)
-      start_profiling
-      options = { :from => test, :to => savings, :code => :bonus }
-      options[:metadata] = metadata if metadata
-      100.times { Transfer.transfer(amount, options) }
-      profile_name = metadata ? 'transfer-with-metadata' : 'transfer'
-      stop_profiling(profile_name)
-    end
-  end
-end