double_entry 1.0.1 → 2.0.0.beta1

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

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

@@ -1,123 +0,0 @@
-module DoubleEntry
-  module Reporting
-    RSpec.describe AggregateArray do
-      let(:user) { User.make! }
-      let(:start) { nil }
-      let(:finish) { nil }
-      let(:range_type) { 'year' }
-      let(:function) { 'sum' }
-      let(:account) { :savings }
-      let(:transfer_code) { :bonus }
-      subject(:aggregate_array) do
-        AggregateArray.new(
-          function,
-          account,
-          transfer_code,
-          :range_type => range_type,
-          :start => start,
-          :finish => finish,
-        )
-      end
-
-      context 'given a deposit was made in 2007 and 2008' do
-        before do
-          Timecop.travel(Time.local(2007)) do
-            perform_deposit user, 10_00
-          end
-          Timecop.travel(Time.local(2008)) do
-            perform_deposit user, 20_00
-          end
-        end
-
-        context 'given the date is 2009-03-19' do
-          before { Timecop.travel(Time.local(2009, 3, 19)) }
-
-          context 'when called with range type of "year"' do
-            let(:range_type) { 'year' }
-            let(:start) { '2006-08-03' }
-            it { should eq [Money.zero, Money.new(10_00), Money.new(20_00), Money.zero] }
-
-            describe 'reuse of aggregates' do
-              let(:years) { TimeRangeArray.make(range_type, start, finish) }
-
-              context 'and some aggregates were created previously' do
-                before do
-                  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 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(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
-            end
-          end
-        end
-      end
-
-      context 'given a deposit was made in October and December 2006' do
-        before do
-          Timecop.travel(Time.local(2006, 10)) do
-            perform_deposit user, 10_00
-          end
-          Timecop.travel(Time.local(2006, 12)) do
-            perform_deposit user, 20_00
-          end
-        end
-
-        context 'when called with range type of "month", a start of "2006-09-01", and finish of "2007-01-02"' do
-          let(:range_type) { 'month' }
-          let(:start) { '2006-09-01' }
-          let(:finish) { '2007-01-02' }
-          it { should eq [Money.zero, Money.new(10_00), Money.zero, Money.new(20_00), Money.zero] }
-        end
-
-        context 'given the date is 2007-02-02' do
-          before { Timecop.travel(Time.local(2007, 2, 2)) }
-
-          context 'when called with range type of "month"' do
-            let(:range_type) { 'month' }
-            let(:start) { '2006-08-03' }
-            it { should eq [Money.zero, Money.zero, Money.new(10_00), Money.zero, Money.new(20_00), Money.zero, Money.zero] }
-          end
-        end
-      end
-
-      context 'when account is in BTC currency' do
-        let(:account) { :btc_savings }
-        let(:range_type) { 'year' }
-        let(:start) { "#{Time.now.year}-01-01" }
-        let(:transfer_code) { :btc_test_transfer }
-
-        before do
-          perform_btc_deposit(user, 100_000_000)
-          perform_btc_deposit(user, 100_000_000)
-        end
-
-        it { should eq [Money.new(200_000_000, :btc)] }
-      end
-
-      context 'when called with range type of "invalid_and_should_not_work"' do
-        let(:range_type) { 'invalid_and_should_not_work' }
-        it 'raises an argument error' do
-          expect { aggregate_array }.to raise_error ArgumentError, "Invalid range type 'invalid_and_should_not_work'"
-        end
-      end
-
-      context 'when an invalid function is provided' do
-        let(:range_type) { 'month' }
-        let(:start) { '2006-08-03' }
-        let(:function) { :invalid_function }
-        it 'raises an AggregateFunctionNotSupported error' do
-          expect { aggregate_array }.to raise_error AggregateFunctionNotSupported
-        end
-      end
-    end
-  end
-end

data/spec/double_entry/reporting/aggregate_spec.rb

@@ -1,205 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    RSpec.describe Aggregate do
-      let(:user) { User.make! }
-      let(:expected_weekly_average) do
-        (Money.new(20_00) + Money.new(40_00) + Money.new(50_00)) / 3
-      end
-      let(:expected_monthly_average) do
-        (Money.new(20_00) + Money.new(40_00) + Money.new(50_00) + Money.new(40_00) + Money.new(50_00)) / 5
-      end
-
-      before do
-        # Thursday
-        Timecop.freeze Time.local(2009, 10, 1) do
-          perform_deposit user, 20_00
-        end
-
-        # Saturday
-        Timecop.freeze Time.local(2009, 10, 3) do
-          perform_deposit user, 40_00
-        end
-
-        Timecop.freeze Time.local(2009, 10, 10) do
-          perform_deposit user, 50_00
-        end
-        Timecop.freeze Time.local(2009, 11, 1, 0, 59, 0) do
-          perform_deposit user, 40_00
-        end
-        Timecop.freeze Time.local(2009, 11, 1, 1, 00, 0) do
-          perform_deposit user, 50_00
-        end
-      end
-
-      it 'should store the aggregate for quick retrieval' do
-        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, 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
-        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
-        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
-        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
-        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
-        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
-          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
-          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
-        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
-        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
-        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
-        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
-        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
-        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, 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) }
-        end
-
-        before do
-          Timecop.freeze Time.local(2011, 10, 10) do
-            perform_deposit user, 10_00
-          end
-
-          Timecop.freeze Time.local(2011, 10, 10) do
-            perform_deposit user, 9_00
-          end
-        end
-
-        it 'saves filtered aggregations' do
-          expect do
-            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, :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, :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, :filter => filter).amount
-          Aggregate.new(:sum, :savings, :bonus, range).amount
-
-          # ensure a second call loads the correct cached value
-          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
-    RSpec.describe Aggregate, 'currencies' do
-      let(:user) { User.make! }
-      before do
-        perform_btc_deposit(user, 100_000_000)
-        perform_btc_deposit(user, 200_000_000)
-      end
-
-      it 'should calculate the sum in the correct currency' do
-        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
-end

data/spec/double_entry/reporting/line_aggregate_filter_spec.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-RSpec.describe DoubleEntry::Reporting::LineAggregateFilter do
-  describe '.filter' do
-    let(:function) { :sum }
-    let(:account) { :account }
-    let(:code) { :transfer_code }
-    let(:filter_criteria) { nil }
-    let(:start) { Time.parse('2014-07-27 10:55:44 +1000') }
-    let(:finish) { Time.parse('2015-07-27 10:55:44 +1000') }
-    let(:range) do
-      instance_double(DoubleEntry::Reporting::MonthRange, :start  => start, :finish => finish)
-    end
-
-    let(:lines_scope) { spy(DoubleEntry::Line) }
-
-    subject(:filter) do
-      DoubleEntry::Reporting::LineAggregateFilter.new(account, code, range, filter_criteria)
-    end
-
-    before do
-      stub_const('DoubleEntry::Line', lines_scope)
-
-      allow(DoubleEntry::LineMetadata).to receive(:table_name).and_return('double_entry_line_metadata')
-
-      allow(lines_scope).to receive(:where).and_return(lines_scope)
-      allow(lines_scope).to receive(:joins).and_return(lines_scope)
-      allow(lines_scope).to receive(:ten_dollar_purchases).and_return(lines_scope)
-      allow(lines_scope).to receive(:ten_dollar_purchases_by_category).and_return(lines_scope)
-
-      filter.filter
-    end
-
-    context 'with named scopes specified' do
-      let(:filter_criteria) do
-        [
-          # an example of calling a named scope called with arguments
-          {
-            :scope => {
-              :name => :ten_dollar_purchases_by_category,
-              :arguments => [:cat_videos, :cat_pictures],
-            },
-          },
-          # an example of calling a named scope with no arguments
-          {
-            :scope => {
-              :name => :ten_dollar_purchases,
-            },
-          },
-          # an example of providing a single metadatum criteria to filter on
-          {
-            :metadata => {
-              :meme => 'business_cat',
-            },
-          },
-        ]
-      end
-
-      it 'filters by all the scopes provided' do
-        expect(DoubleEntry::Line).to have_received(:ten_dollar_purchases)
-        expect(DoubleEntry::Line).to have_received(:ten_dollar_purchases_by_category).
-          with(:cat_videos, :cat_pictures)
-      end
-
-      it 'filters by all the metadata provided' do
-        expect(DoubleEntry::Line).to have_received(:joins).with(:metadata)
-        expect(DoubleEntry::Line).to have_received(:where).
-          with(:double_entry_line_metadata => { :key => :meme, :value => 'business_cat' })
-      end
-    end
-
-    context 'with a code specified' do
-      let(:code) { :transfer_code }
-
-      it 'retrieves the appropriate lines for aggregation' do
-        expect(DoubleEntry::Line).to have_received(:where).with(:account => account)
-        expect(DoubleEntry::Line).to have_received(:where).with(:created_at => start..finish)
-        expect(DoubleEntry::Line).to have_received(:where).with(:code => code)
-      end
-    end
-
-    context 'with no code specified' do
-      let(:code) { nil }
-
-      it 'retrieves the appropriate lines for aggregation' do
-        expect(DoubleEntry::Line).to have_received(:where).with(:account => account)
-        expect(DoubleEntry::Line).to have_received(:where).with(:created_at => start..finish)
-      end
-    end
-  end
-end