double_entry 1.0.1 → 2.0.0.beta5

data/lib/double_entry/reporting/year_range.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class YearRange < TimeRange
-      attr_reader :year
-
-      def initialize(options)
-        super options
-
-        year_start = Time.local(@year, 1, 1)
-        @start = year_start
-        @finish = year_start.end_of_year
-      end
-
-      def self.current
-        new(:year => Time.now.year)
-      end
-
-      def self.from_time(time)
-        new(:year => time.year)
-      end
-
-      def ==(other)
-        year == other.year
-      end
-
-      def previous
-        YearRange.new(:year => year - 1)
-      end
-
-      def next
-        YearRange.new(:year => year + 1)
-      end
-
-      def to_s
-        year.to_s
-      end
-    end
-  end
-end

data/script/jack_hammer

@@ -1,210 +0,0 @@
-#!/usr/bin/env ruby
-
-# Run a concurrency test on the double_entry code.
-#
-# This spawns a bunch of processes, and does random transactions between a set
-# of accounts, then validates that all the numbers add up at the end.
-#
-# You can also tell it to flush our the account balances table at regular
-# intervals, to validate that new account balances records get created with the
-# correct balances from the lines table.
-#
-# Run it without arguments to get the usage.
-
-require 'optparse'
-require 'bundler/setup'
-require 'active_record'
-require 'database_cleaner'
-
-support = File.expand_path("../../spec/support/", __FILE__)
-
-db_engine = ENV['DB'] || 'mysql'
-
-if db_engine == 'sqlite'
-  puts "Skipping jackhammer for SQLITE..."
-  exit 0
-end
-
-ActiveRecord::Base.establish_connection YAML.load_file(File.join(support, "database.yml"))[db_engine]
-require "#{support}/schema"
-
-lib = File.expand_path('../../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'double_entry'
-
-def parse_options
-  $account_count       = 5
-  $process_count       = 20
-  $transfer_count      = 20000
-  $balance_flush_count = 1
-  $use_threads         = false
-
-  options = OptionParser.new
-
-  options.on("-a", "--accounts=COUNT", Integer, "Number of accounts (default: #{$account_count})") do |value|
-    $account_count = value
-  end
-
-  options.on("-p", "--processes=COUNT", Integer, "Number of processes (default: #{$process_count})") do |value|
-    $process_count = value
-  end
-
-  options.on("-t", "--transfers=COUNT", Integer, "Number of transfers (default: #{$transfer_count})") do |value|
-    $transfer_count = value
-  end
-
-  options.on("-f", "--flush-balances=COUNT", Integer, "Flush account balances table COUNT times") do |value|
-    $balance_flush_count = value
-  end
-
-  options.on("-z", "--threads", "Use threads instead of processes") do |value|
-    $use_threads = !!value
-  end
-
-  options.parse(*ARGV)
-end
-
-
-def clean_out_database
-  puts "Cleaning out the database..."
-
-  DatabaseCleaner.clean_with(:truncation)
-end
-
-def create_accounts_and_transfers
-  puts "Setting up #{$account_count} accounts..."
-
-  DoubleEntry.configure do |config|
-
-    # Create the accounts.
-    config.define_accounts do |accounts|
-      scope = ->(x) { x }
-      $account_count.times do |i|
-        accounts.define(:identifier => :"account-#{i}", :scope_identifier => scope)
-      end
-    end
-
-    # Create all the possible transfers.
-    config.define_transfers do |transfers|
-      config.accounts.each do |from|
-        config.accounts.each do |to|
-          transfers.define(:from => from.identifier, :to => to.identifier, :code => :test)
-        end
-      end
-    end
-
-    # Find account instances so we have something to work with.
-    $accounts = config.accounts.map do |account|
-      DoubleEntry.account(account.identifier, :scope => 1)
-    end
-  end
-end
-
-
-def run_tests
-  puts "Spawning #{$process_count} processes..."
-
-  iterations_per_process = [ ($transfer_count / $process_count / $balance_flush_count), 1 ].max
-
-  $balance_flush_count.times do
-    puts "Flushing balances"
-    DoubleEntry::AccountBalance.delete_all
-    ActiveRecord::Base.connection_pool.disconnect!
-
-    if $use_threads
-      puts "Using threads as workers"
-      threads = []
-      $process_count.times do |process_num|
-        threads << Thread.new { run_process(iterations_per_process, process_num) }
-      end
-
-      threads.each(&:join)
-    else
-      puts "Using processes as workers"
-      pids = []
-      $process_count.times do |process_num|
-        pids << fork { run_process(iterations_per_process, process_num) }
-      end
-
-      pids.each {|pid| Process.wait2(pid) }
-    end
-  end
-end
-
-
-def run_process(iterations, process_num)
-  srand  # Seed the random number generator separately for each process.
-
-  puts "Process #{process_num} running #{iterations} transfers..."
-
-  iterations.times do |i|
-    account_a = $accounts.sample
-    account_b = ($accounts - [account_a]).sample
-    amount = rand(1000) + 1
-
-    DoubleEntry.transfer(Money.new(amount), :from => account_a, :to => account_b, :code => :test)
-
-    puts "Process #{process_num} completed #{i+1} transfers" if (i+1) % 100 == 0
-  end
-end
-
-
-def reconcile
-  error_count = 0
-  puts "Reconciling..."
-
-  if DoubleEntry::Line.count == $transfer_count * 2
-    puts "All the Line records were written, FTW!"
-  else
-    puts "Not enough Line records written. :("
-    error_count += 1
-  end
-
-  if $accounts.all? {|account| DoubleEntry::Reporting.reconciled?(account) }
-    puts "All accounts reconciled, FTW!"
-  else
-    $accounts.each do |account|
-      if !DoubleEntry::Reporting.reconciled?(account)
-        puts "Account #{account.identifier} failed to reconcile. :("
-
-        # See http://bugs.mysql.com/bug.php?id=51431
-        use_index = if DoubleEntry::Line.connection.adapter_name.match /mysql/i
-                      "USE INDEX (lines_scope_account_id_idx)"
-                    else
-                      ""
-                    end
-
-        rows = ActiveRecord::Base.connection.select_all(<<-SQL)
-             SELECT id, amount, balance
-               FROM #{DoubleEntry::Line.quoted_table_name} #{use_index}
-              WHERE scope   = '#{account.scope_identity}'
-                AND account = '#{account.identifier}'
-           ORDER BY id
-        SQL
-
-        rows.each_cons(2) do |a, b|
-          if a["balance"].to_i + b["amount"].to_i != b["balance"].to_i
-            puts "Bad lines entry id = #{b['id']}"
-            error_count += 1
-          end
-        end
-      end
-    end
-  end
-
-  error_count == 0
-end
-
-
-parse_options
-clean_out_database
-create_accounts_and_transfers
-run_tests
-
-if reconcile
-  puts "Done successfully :)"
-  exit 0
-else
-  puts "Done with errors :("
-  exit 1
-end

data/script/setup.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-echo "This command will setup your local dev environment, including"
-echo "  * bundle install"
-echo
-
-echo "Bundling..."
-bundle install --binstubs bin --path .bundle

data/spec/active_record/locking_extensions_spec.rb

@@ -1,110 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe ActiveRecord::LockingExtensions do
-  PG_DEADLOCK    = ActiveRecord::StatementInvalid.new('PG::Error: ERROR:  deadlock detected')
-  MYSQL_DEADLOCK = ActiveRecord::StatementInvalid.new('Mysql::Error: Deadlock found when trying to get lock')
-  SQLITE3_LOCK   = ActiveRecord::StatementInvalid.new('SQLite3::BusyException: database is locked: UPDATE...')
-
-  context '#restartable_transaction' do
-    it "keeps running the lock until a ActiveRecord::RestartTransaction isn't raised" do
-      expect(User).to receive(:create!).ordered.and_raise(ActiveRecord::RestartTransaction)
-      expect(User).to receive(:create!).ordered.and_raise(ActiveRecord::RestartTransaction)
-      expect(User).to receive(:create!).ordered.and_return(true)
-
-      expect { User.restartable_transaction { User.create! } }.to_not raise_error
-    end
-  end
-
-  context '#with_restart_on_deadlock' do
-    shared_examples 'abstract adapter' do
-      it 'raises a ActiveRecord::RestartTransaction error if a deadlock occurs' do
-        expect { User.with_restart_on_deadlock { fail exception } }.
-          to raise_error(ActiveRecord::RestartTransaction)
-      end
-
-      it 'publishes a notification' do
-        expect(ActiveSupport::Notifications).
-          to receive(:publish).
-          with('deadlock_restart.active_record', hash_including(:exception => exception))
-        expect { User.with_restart_on_deadlock { fail exception } }.to raise_error
-      end
-    end
-
-    context 'mysql' do
-      let(:exception) { MYSQL_DEADLOCK }
-
-      it_behaves_like 'abstract adapter'
-    end
-
-    context 'postgres' do
-      let(:exception) { PG_DEADLOCK }
-
-      it_behaves_like 'abstract adapter'
-    end
-
-    context 'sqlite' do
-      let(:exception) { SQLITE3_LOCK }
-
-      it_behaves_like 'abstract adapter'
-    end
-  end
-
-  context '#create_ignoring_duplicates' do
-    it 'does not raise an error if a duplicate index error is raised in the database' do
-      User.make! :username => 'keith'
-
-      expect { User.make! :username => 'keith' }.to raise_error
-      expect { User.create_ignoring_duplicates! :username => 'keith' }.to_not raise_error
-    end
-
-    it 'publishes a notification when a duplicate is encountered' do
-      User.make! :username => 'keith'
-
-      expect(ActiveSupport::Notifications).
-        to receive(:publish).
-        with('duplicate_ignore.active_record', hash_including(:exception => kind_of(ActiveRecord::RecordNotUnique)))
-
-      expect { User.create_ignoring_duplicates! :username => 'keith' }.to_not raise_error
-    end
-
-    shared_examples 'abstract adapter' do
-      it 'retries the creation if a deadlock error is raised from the database' do
-        expect(User).to receive(:create!).ordered.and_raise(exception)
-        expect(User).to receive(:create!).ordered.and_return(true)
-
-        expect { User.create_ignoring_duplicates! }.to_not raise_error
-      end
-
-      it 'publishes a notification on each retry' do
-        expect(User).to receive(:create!).ordered.and_raise(exception)
-        expect(User).to receive(:create!).ordered.and_raise(exception)
-        expect(User).to receive(:create!).ordered.and_return(true)
-
-        expect(ActiveSupport::Notifications).
-          to receive(:publish).
-          with('deadlock_retry.active_record', hash_including(:exception => exception)).
-          twice
-
-        expect { User.create_ignoring_duplicates! }.to_not raise_error
-      end
-    end
-
-    context 'mysql' do
-      let(:exception) { MYSQL_DEADLOCK }
-
-      it_behaves_like 'abstract adapter'
-    end
-
-    context 'postgres' do
-      let(:exception) { PG_DEADLOCK }
-
-      it_behaves_like 'abstract adapter'
-    end
-
-    context 'sqlite' do
-      let(:exception) { SQLITE3_LOCK }
-
-      it_behaves_like 'abstract adapter'
-    end
-  end
-end

data/spec/double_entry/account_balance_spec.rb

@@ -1,7 +0,0 @@
-# encoding: utf-8
-RSpec.describe DoubleEntry::AccountBalance do
-  describe '.table_name' do
-    subject { DoubleEntry::AccountBalance.table_name }
-    it { should eq('double_entry_account_balances') }
-  end
-end

data/spec/double_entry/account_spec.rb

@@ -1,130 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  RSpec.describe Account do
-    let(:identity_scope) { ->(value) { value } }
-
-    describe '::new' do
-      context 'given an identifier 31 characters in length' do
-        let(:identifier) { 'xxxxxxxx 31 characters xxxxxxxx' }
-        specify do
-          expect { Account.new(:identifier => identifier) }.to_not raise_error
-        end
-      end
-
-      context 'given an identifier 32 characters in length' do
-        let(:identifier) { 'xxxxxxxx 32 characters xxxxxxxxx' }
-        specify do
-          expect { Account.new(:identifier => identifier) }.to raise_error AccountIdentifierTooLongError, /'#{identifier}'/
-        end
-      end
-    end
-
-    describe Account::Instance do
-      it 'is sortable' do
-        account = Account.new(:identifier => 'savings', :scope_identifier => identity_scope)
-        a = Account::Instance.new(:account => account, :scope => '123')
-        b = Account::Instance.new(:account => account, :scope => '456')
-        expect([b, a].sort).to eq [a, b]
-      end
-
-      it 'is hashable' do
-        account = Account.new(:identifier => 'savings', :scope_identifier => identity_scope)
-        a1 = Account::Instance.new(:account => account, :scope => '123')
-        a2 = Account::Instance.new(:account => account, :scope => '123')
-        b  = Account::Instance.new(:account => account, :scope => '456')
-
-        expect(a1.hash).to eq a2.hash
-        expect(a1.hash).to_not eq b.hash
-      end
-
-      describe '::new' do
-        let(:account) { Account.new(:identifier => 'x', :scope_identifier => identity_scope) }
-        subject(:initialize_account_instance) { Account::Instance.new(:account => account, :scope => scope) }
-
-        context 'given a scope identifier 23 characters in length' do
-          let(:scope) { 'xxxx 23 characters xxxx' }
-          specify { expect { initialize_account_instance }.to_not raise_error }
-        end
-
-        context 'given a scope identifier 24 characters in length' do
-          let(:scope) { 'xxxx 24 characters xxxxx' }
-          specify { expect { initialize_account_instance }.to raise_error ScopeIdentifierTooLongError, /'#{scope}'/ }
-        end
-      end
-    end
-
-    describe 'currency' do
-      it 'defaults to USD currency' do
-        account = DoubleEntry::Account.new(:identifier => 'savings', :scope_identifier => identity_scope)
-        expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq('USD')
-      end
-
-      it 'allows the currency to be set' do
-        account = DoubleEntry::Account.new(:identifier => 'savings', :scope_identifier => identity_scope, :currency => 'AUD')
-        expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq('AUD')
-      end
-    end
-
-    describe Account::Set do
-      describe '#define' do
-        context "given a 'savings' account is defined" do
-          before { subject.define(:identifier => 'savings') }
-          its(:first) { should be_an Account }
-          its('first.identifier') { should eq 'savings' }
-        end
-      end
-
-      describe '#active_record_scope_identifier' do
-        subject(:scope) { Account::Set.new.active_record_scope_identifier(ar_class) }
-
-        context 'given ActiveRecordScopeFactory is stubbed' do
-          let(:scope_identifier) { double(:scope_identifier) }
-          let(:scope_factory) { double(:scope_factory, :scope_identifier => scope_identifier) }
-          let(:ar_class) { double(:ar_class) }
-          before { allow(Account::ActiveRecordScopeFactory).to receive(:new).with(ar_class).and_return(scope_factory) }
-
-          it { should eq scope_identifier }
-        end
-      end
-    end
-  end
-
-  RSpec.describe Account::ActiveRecordScopeFactory do
-    context 'given the class User' do
-      subject(:factory) { Account::ActiveRecordScopeFactory.new(User) }
-
-      describe '#scope_identifier' do
-        subject(:scope_identifier) { factory.scope_identifier }
-
-        describe '#call' do
-          subject(:scope) { scope_identifier.call(value) }
-
-          context 'given a User instance with ID 32' do
-            let(:value) { User.make(:id => 32) }
-
-            it { should eq 32 }
-          end
-
-          context 'given differing model instance with ID 32' do
-            let(:value) { double(:id => 32) }
-            it 'raises an error' do
-              expect { scope_identifier.call(value) }.to raise_error DoubleEntry::AccountScopeMismatchError
-            end
-          end
-
-          context "given the String 'I am a bearded lady'" do
-            let(:value) { 'I am a bearded lady' }
-
-            it { should eq 'I am a bearded lady' }
-          end
-
-          context 'given the Integer 42' do
-            let(:value) { 42 }
-
-            it { should eq 42 }
-          end
-        end
-      end
-    end
-  end
-end