double_entry 0.10.3 → 1.0.0

data/lib/double_entry/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DoubleEntry
-  VERSION = '0.10.3'
+  VERSION = '1.0.0'
 end

data/lib/generators/double_entry/install/templates/migration.rb

@@ -54,9 +54,19 @@ class CreateDoubleEntryTables < ActiveRecord::Migration
       t.text       "log"
       t.timestamps                             :null => false
     end
+
+    create_table "double_entry_line_metadata", :force => true do |t|
+      t.integer    "line_id",               :null => false
+      t.string     "key",     :limit => 48, :null => false
+      t.string     "value",   :limit => 64, :null => false
+      t.timestamps                          :null => false
+    end
+
+    add_index "double_entry_line_metadata", ["line_id", "key", "value"], :name => "lines_meta_line_id_key_value_idx"
   end
 
   def self.down
+    drop_table "double_entry_line_metadata"
     drop_table "double_entry_line_checks"
     drop_table "double_entry_line_aggregates"
     drop_table "double_entry_lines"

data/spec/double_entry/locking_spec.rb

@@ -148,6 +148,35 @@ RSpec.describe DoubleEntry::Locking do
     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

data/spec/double_entry/performance/double_entry_performance_spec.rb

@@ -0,0 +1,32 @@
+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

data/spec/double_entry/performance/reporting/aggregate_performance_spec.rb

@@ -0,0 +1,50 @@
+module DoubleEntry
+  module Reporting
+    RSpec.describe Aggregate 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) }
+
+      subject(:transfer) { Transfer.transfer(amount, options) }
+
+      context '200 transfers in a single day, half with metadata' do
+        # Surprisingly, the number of transfers makes no difference to the time taken to aggregate them. Some sample results:
+        # 20,000 => 524ms
+        # 10,000 => 573ms
+        # 1,000  => 486ms
+        # 100    => 608ms
+        # 10     => 509ms
+        # 1      => 473ms
+        before do
+          Timecop.freeze Time.local(2015, 06, 30) do
+            100.times { Transfer.transfer(amount, :from => test, :to => savings, :code => :bonus) }
+            100.times { Transfer.transfer(amount, :from => test, :to => savings, :code => :bonus, :metadata => { :country => 'AU', :tax => 'GST' }) }
+          end
+        end
+
+        it 'calculates monthly all_time ranges quickly without a filter' do
+          profile_aggregation_with_filter(nil)
+          # local results: 517ms, 484ms, 505ms, 482ms, 525ms
+        end
+
+        it 'calculates monthly all_time ranges quickly with a filter' do
+          profile_aggregation_with_filter([:metadata => { :country => 'AU' }])
+          # local results when run independently (caching improves performance when run consecutively):
+          # 655ms, 613ms, 597ms, 607ms, 627ms
+        end
+      end
+
+      def profile_aggregation_with_filter(filter)
+        start_profiling
+        range = TimeRange.make(:year   => 2015, :month => 06, :range_type => :all_time)
+        options = {}
+        options[:filter] = filter if filter
+        Reporting.aggregate(:sum, :savings, :bonus, range, options)
+        profile_name = filter ? 'aggregate-with-metadata' : 'aggregate'
+        stop_profiling(profile_name)
+      end
+    end
+  end
+end

data/spec/double_entry/reporting/aggregate_array_spec.rb

@@ -5,11 +5,11 @@ module DoubleEntry
       let(:start) { nil }
       let(:finish) { nil }
       let(:range_type) { 'year' }
-      let(:function) { :sum }
+      let(:function) { 'sum' }
       let(:account) { :savings }
       let(:transfer_code) { :bonus }
       subject(:aggregate_array) do
-        Reporting.aggregate_array(
+        AggregateArray.new(
           function,
           account,
           transfer_code,
@@ -42,17 +42,17 @@ module DoubleEntry
 
               context 'and some aggregates were created previously' do
                 before do
-                  Reporting.aggregate(function.to_s, account, transfer_code, :filter => nil, :range => years[0])
-                  Reporting.aggregate(function.to_s, account, transfer_code, :filter => nil, :range => years[1])
-                  allow(Reporting).to receive(:aggregate)
+                  Aggregate.formatted_amount(function, account, transfer_code, years[0])
+                  Aggregate.formatted_amount(function, account, transfer_code, years[1])
+                  allow(Aggregate).to receive(:formatted_amount)
                 end
 
-                it 'only asks Reporting for the non-existent ones' do
-                  expect(Reporting).not_to receive(:aggregate).with(function.to_s, account, transfer_code, :filter => nil, :range => years[0])
-                  expect(Reporting).not_to receive(:aggregate).with(function.to_s, account, transfer_code, :filter => nil, :range => years[1])
+                it 'only asks Aggregate for the non-existent ones' do
+                  expect(Aggregate).not_to receive(:formatted_amount).with(function, account, transfer_code, years[0], :filter => nil)
+                  expect(Aggregate).not_to receive(:formatted_amount).with(function, account, transfer_code, years[1], :filter => nil)
 
-                  expect(Reporting).to receive(:aggregate).with(function.to_s, account, transfer_code, :filter => nil, :range => years[2])
-                  expect(Reporting).to receive(:aggregate).with(function.to_s, account, transfer_code, :filter => nil, :range => years[3])
+                  expect(Aggregate).to receive(:formatted_amount).with(function, account, transfer_code, years[2], :filter => nil)
+                  expect(Aggregate).to receive(:formatted_amount).with(function, account, transfer_code, years[3], :filter => nil)
                   aggregate_array
                 end
               end

data/spec/double_entry/reporting/aggregate_spec.rb

@@ -33,166 +33,113 @@ module DoubleEntry
       end
 
       it 'should store the aggregate for quick retrieval' do
-        Aggregate.new(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 10)).amount
+        Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 10)).amount
         expect(LineAggregate.count).to eq 1
       end
 
       it 'should only store the aggregate once if it is requested more than once' do
-        Aggregate.new(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 9)).amount
-        Aggregate.new(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 9)).amount
-        Aggregate.new(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 10)).amount
+        Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 9)).amount
+        Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 9)).amount
+        Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 10)).amount
         expect(LineAggregate.count).to eq 2
       end
 
       it 'should calculate the complete year correctly' do
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009)
-          ).formatted_amount,
-        ).to eq Money.new(200_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009)).formatted_amount
+        expect(amount).to eq Money.new(200_00)
       end
 
       it 'should calculate seperate months correctly' do
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :month => 10)
-          ).formatted_amount,
-        ).to eq Money.new(110_00)
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :month => 11)
-          ).formatted_amount,
-        ).to eq Money.new(90_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 10)).formatted_amount
+        expect(amount).to eq Money.new(110_00)
+
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 11)).formatted_amount
+        expect(amount).to eq Money.new(90_00)
       end
 
       it 'should calculate seperate weeks correctly' do
         # Week 40 - Mon Sep 28, 2009 to Sun Oct 4 2009
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 40)
-          ).formatted_amount,
-        ).to eq Money.new(60_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :week => 40)).formatted_amount
+        expect(amount).to eq Money.new(60_00)
       end
 
       it 'should calculate seperate days correctly' do
         # 1 Nov 2009
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 44, :day => 7)
-          ).formatted_amount,
-        ).to eq Money.new(90_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :week => 44, :day => 7)).formatted_amount
+        expect(amount).to eq Money.new(90_00)
       end
 
       it 'should calculate seperate hours correctly' do
         # 1 Nov 2009
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 0)
-          ).formatted_amount,
-        ).to eq Money.new(40_00)
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 1)
-          ).formatted_amount,
-        ).to eq Money.new(50_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 0)).formatted_amount
+        expect(amount).to eq Money.new(40_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 1)).formatted_amount
+        expect(amount).to eq Money.new(50_00)
       end
 
       it 'should calculate, but not store aggregates when the time range is still current' do
         Timecop.freeze Time.local(2009, 11, 21) do
-          expect(
-            Aggregate.new(
-              :sum, :savings, :bonus,
-              :range => TimeRange.make(:year => 2009, :month => 11)
-            ).formatted_amount,
-          ).to eq Money.new(90_00)
+          amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 11)).formatted_amount
+          expect(amount).to eq Money.new(90_00)
           expect(LineAggregate.count).to eq 0
         end
       end
 
       it 'should calculate, but not store aggregates when the time range is in the future' do
         Timecop.freeze Time.local(2009, 11, 21) do
-          expect(
-            Aggregate.new(
-              :sum, :savings, :bonus,
-              :range => TimeRange.make(:year => 2009, :month => 12)
-            ).formatted_amount,
-          ).to eq Money.new(0)
+          amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 12)).formatted_amount
+          expect(amount).to eq Money.new(0)
           expect(LineAggregate.count).to eq 0
         end
       end
 
       it 'should calculate monthly all_time ranges correctly' do
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)
-          ).formatted_amount,
-        ).to eq Money.new(200_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)).formatted_amount
+        expect(amount).to eq Money.new(200_00)
       end
 
       it 'calculates the average monthly all_time ranges correctly' do
-        expect(
-          Aggregate.new(
-            :average, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)
-          ).formatted_amount,
-        ).to eq expected_monthly_average
+        amount = Aggregate.new(:average, :savings, :bonus, TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)).formatted_amount
+        expect(amount).to eq expected_monthly_average
       end
 
       it 'returns the correct count for weekly all_time ranges correctly' do
-        expect(
-          Aggregate.new(
-            :count, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)
-          ).formatted_amount,
-        ).to eq 5
+        amount = Aggregate.new(:count, :savings, :bonus, TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)).formatted_amount
+        expect(amount).to eq 5
       end
 
       it 'should calculate weekly all_time ranges correctly' do
-        expect(
-          Aggregate.new(
-            :sum, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
-          ).formatted_amount,
-        ).to eq Money.new(110_00)
+        amount = Aggregate.new(:sum, :savings, :bonus, TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)).formatted_amount
+        expect(amount).to eq Money.new(110_00)
       end
 
       it 'calculates the average weekly all_time ranges correctly' do
-        expect(
-          Aggregate.new(
-            :average, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
-          ).formatted_amount,
-        ).to eq expected_weekly_average
+        amount = Aggregate.new(:average, :savings, :bonus, TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)).formatted_amount
+        expect(amount).to eq expected_weekly_average
       end
 
       it 'returns the correct count for weekly all_time ranges correctly' do
-        expect(
-          Aggregate.new(
-            :count, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
-          ).formatted_amount,
-        ).to eq 3
+        amount = Aggregate.new(:count, :savings, :bonus, TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)).formatted_amount
+        expect(amount).to eq 3
       end
 
       it 'raises an AggregateFunctionNotSupported exception' do
         expect do
           Aggregate.new(
-            :not_supported_calculation, :savings, :bonus,
-            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
+            :not_supported_calculation, :savings, :bonus, TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
           ).amount
         end.to raise_error(AggregateFunctionNotSupported)
       end
 
       context 'filters' do
         let(:range) { TimeRange.make(:year => 2011, :month => 10) }
+        let(:filter) do
+          [
+            :scope => {
+              :name => :test_filter,
+            },
+          ]
+        end
 
         DoubleEntry::Line.class_eval do
           scope :test_filter, -> { where(:amount => 10_00) }
@@ -210,36 +157,35 @@ module DoubleEntry
 
         it 'saves filtered aggregations' do
           expect do
-            Aggregate.new(:sum, :savings, :bonus, :range => range, :filter => [:test_filter]).amount
+            Aggregate.new(:sum, :savings, :bonus, range, :filter => filter).amount
           end.to change { LineAggregate.count }.by 1
         end
 
         it 'saves filtered aggregation only once for a range' do
           expect do
-            Aggregate.new(:sum, :savings, :bonus, :range => range, :filter => [:test_filter]).amount
-            Aggregate.new(:sum, :savings, :bonus, :range => range, :filter => [:test_filter]).amount
+            Aggregate.new(:sum, :savings, :bonus, range, :filter => filter).amount
+            Aggregate.new(:sum, :savings, :bonus, range, :filter => filter).amount
           end.to change { LineAggregate.count }.by 1
         end
 
         it 'saves filtered aggregations and non filtered aggregations separately' do
           expect do
-            Aggregate.new(:sum, :savings, :bonus, :range => range, :filter => [:test_filter]).amount
-            Aggregate.new(:sum, :savings, :bonus, :range => range).amount
+            Aggregate.new(:sum, :savings, :bonus, range, :filter => filter).amount
+            Aggregate.new(:sum, :savings, :bonus, range).amount
           end.to change { LineAggregate.count }.by 2
         end
 
         it 'loads the correct saved aggregation' do
           # cache the results for filtered and unfiltered aggregations
-          Aggregate.new(:sum, :savings, :bonus, :range => range, :filter => [:test_filter]).amount
-          Aggregate.new(:sum, :savings, :bonus, :range => range).amount
+          Aggregate.new(:sum, :savings, :bonus, range, :filter => filter).amount
+          Aggregate.new(:sum, :savings, :bonus, range).amount
 
           # ensure a second call loads the correct cached value
-          expect(
-            Aggregate.new(:sum, :savings, :bonus, :range  => range, :filter => [:test_filter]).formatted_amount,
-          ).to eq Money.new(10_00)
-          expect(
-            Aggregate.new(:sum, :savings, :bonus, :range  => range).formatted_amount,
-          ).to eq Money.new(19_00)
+          amount = Aggregate.new(:sum, :savings, :bonus, range, :filter => filter).formatted_amount
+          expect(amount).to eq Money.new(10_00)
+
+          amount = Aggregate.new(:sum, :savings, :bonus, range).formatted_amount
+          expect(amount).to eq Money.new(19_00)
         end
       end
     end
@@ -251,11 +197,8 @@ module DoubleEntry
       end
 
       it 'should calculate the sum in the correct currency' do
-        expect(
-          Aggregate.new(
-            :sum, :btc_savings, :btc_test_transfer, :range => TimeRange.make(:year => Time.now.year)
-          ).formatted_amount,
-        ).to eq(Money.new(300_000_000, :btc))
+        amount = Aggregate.new(:sum, :btc_savings, :btc_test_transfer, TimeRange.make(:year => Time.now.year)).formatted_amount
+        expect(amount).to eq(Money.new(300_000_000, :btc))
       end
     end
   end