double_entry 0.10.0 → 0.10.1

data/spec/double_entry_spec.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
-require 'spec_helper'
-describe DoubleEntry do
-
+RSpec.describe DoubleEntry do
   # these specs blat the DoubleEntry configuration, so take
   # a copy and clean up after ourselves
   before do
@@ -18,25 +16,25 @@ describe DoubleEntry do
 
   describe 'configuration' do
     it 'checks for duplicates of accounts' do
-      expect {
+      expect do
         DoubleEntry.configure do |config|
           config.define_accounts do |accounts|
             accounts.define(:identifier => :gah!)
             accounts.define(:identifier => :gah!)
           end
         end
-      }.to raise_error DoubleEntry::DuplicateAccount
+      end.to raise_error DoubleEntry::DuplicateAccount
     end
 
     it 'checks for duplicates of transfers' do
-      expect {
+      expect do
         DoubleEntry.configure do |config|
           config.define_transfers do |transfers|
             transfers.define(:from => :savings, :to => :cash, :code => :xfer)
             transfers.define(:from => :savings, :to => :cash, :code => :xfer)
           end
         end
-      }.to raise_error DoubleEntry::DuplicateTransfer
+      end.to raise_error DoubleEntry::DuplicateTransfer
     end
   end
 
@@ -74,17 +72,17 @@ describe DoubleEntry do
       end
     end
 
-    context "an unscoped account" do
+    context 'an unscoped account' do
       subject(:unscoped) { DoubleEntry.account(:unscoped) }
 
-      it "has an identifier" do
+      it 'has an identifier' do
         expect(unscoped.identifier).to eq :unscoped
       end
     end
-    context "a scoped account" do
+    context 'a scoped account' do
       subject(:scoped) { DoubleEntry.account(:scoped, :scope => scope) }
 
-      it "has an identifier" do
+      it 'has an identifier' do
         expect(scoped.identifier).to eq :scoped
       end
     end
@@ -122,46 +120,46 @@ describe DoubleEntry do
     end
 
     it 'raises an exception when the transfer is not allowed (wrong direction)' do
-      expect {
+      expect do
         DoubleEntry.transfer(
           Money.new(100_00),
           :from => cash,
           :to   => savings,
           :code => :xfer,
         )
-      }.to raise_error DoubleEntry::TransferNotAllowed
+      end.to raise_error DoubleEntry::TransferNotAllowed
     end
 
     it 'raises an exception when the transfer is not allowed (wrong code)' do
-      expect {
+      expect do
         DoubleEntry.transfer(
           Money.new(100_00),
           :from => savings,
           :to   => cash,
           :code => :yfer,
         )
-      }.to raise_error DoubleEntry::TransferNotAllowed
+      end.to raise_error DoubleEntry::TransferNotAllowed
     end
 
     it 'raises an exception when the transfer is not allowed (does not exist, at all)' do
-      expect {
+      expect do
         DoubleEntry.transfer(
           Money.new(100_00),
           :from => cash,
           :to   => trash,
         )
-      }.to raise_error DoubleEntry::TransferNotAllowed
+      end.to raise_error DoubleEntry::TransferNotAllowed
     end
 
     it 'raises an exception when the transfer is not allowed (mismatched currencies)' do
-      expect {
+      expect do
         DoubleEntry.transfer(
           Money.new(100_00),
           :from => trash,
           :to   => bitbucket,
-          :code => :mismatch_xfer
+          :code => :mismatch_xfer,
         )
-      }.to raise_error DoubleEntry::MismatchedCurrencies
+      end.to raise_error DoubleEntry::MismatchedCurrencies
     end
   end
 
@@ -187,19 +185,19 @@ describe DoubleEntry do
     let(:debit_line) { lines_for_account(account_b).first }
 
     it 'has an amount' do
-      expect(credit_line.amount).to eq -Money.new(10_00)
-      expect(debit_line.amount).to eq Money.new(10_00)
+      expect(credit_line.amount).to eq(Money.new(-10_00))
+      expect(debit_line.amount).to eq(Money.new(10_00))
     end
 
     it 'has a code' do
-      expect(credit_line.code).to eq :xfer
-      expect(debit_line.code).to eq :xfer
+      expect(credit_line.code).to eq(:xfer)
+      expect(debit_line.code).to eq(:xfer)
     end
 
     it 'auto-sets scope when assigning account (and partner_accout, is this implementation?)' do
-      expect(credit_line[:account]).to eq 'a'
+      expect(credit_line[:account]).to eq('a')
       expect(credit_line[:scope]).to be_nil
-      expect(credit_line[:partner_account]).to eq 'b'
+      expect(credit_line[:partner_account]).to eq('b')
       expect(credit_line[:partner_scope]).to be_nil
     end
 
@@ -215,23 +213,22 @@ describe DoubleEntry do
     end
 
     it 'can reference its partner' do
-      expect(credit_line.partner).to eq debit_line
-      expect(debit_line.partner).to eq credit_line
+      expect(credit_line.partner).to eq(debit_line)
+      expect(debit_line.partner).to eq(credit_line)
     end
 
     it 'can ask for its pair (credit always coming first)' do
-      expect(credit_line.pair).to eq [credit_line, debit_line]
-      expect(debit_line.pair).to eq [credit_line, debit_line]
+      expect(credit_line.pair).to eq([credit_line, debit_line])
+      expect(debit_line.pair).to eq([credit_line, debit_line])
     end
 
     it 'can ask for the account (and get an instance)' do
-      expect(credit_line.account).to eq account_a
-      expect(debit_line.account).to eq account_b
+      expect(credit_line.account).to eq(account_a)
+      expect(debit_line.account).to eq(account_b)
     end
   end
 
   describe 'balances' do
-
     let(:work)       { DoubleEntry.account(:work) }
     let(:savings)    { DoubleEntry.account(:savings) }
     let(:cash)       { DoubleEntry.account(:cash) }
@@ -261,14 +258,14 @@ describe DoubleEntry do
         end
       end
 
-      Timecop.freeze 3.weeks.ago+1.day do
+      Timecop.freeze 3.weeks.ago + 1.day do
         # got paid from work
         DoubleEntry.transfer(Money.new(1_000_00), :from => work, :code => :salary, :to => cash)
         # transfer half salary into savings
         DoubleEntry.transfer(Money.new(500_00), :from => cash, :code => :xfer, :to => savings)
       end
 
-      Timecop.freeze 2.weeks.ago+1.day do
+      Timecop.freeze 2.weeks.ago + 1.day do
         # got myself a darth vader helmet
         DoubleEntry.transfer(Money.new(200_00), :from => cash, :code => :purchase, :to => store)
         # paid off some of my darth vader suit layby (to go with the helmet)
@@ -277,7 +274,7 @@ describe DoubleEntry do
         DoubleEntry.transfer(Money.new(100_00), :from => cash, :code => :deposit, :to => store)
       end
 
-      Timecop.freeze 1.week.ago+1.day do
+      Timecop.freeze 1.week.ago + 1.day do
         # transfer 200 out of savings
         DoubleEntry.transfer(Money.new(200_00), :from => savings, :code => :xfer, :to => cash)
         # pay the remaining balance on the darth vader voice changer module
@@ -291,21 +288,21 @@ describe DoubleEntry do
     end
 
     it 'has the initial balances that we expect' do
-      expect(work.balance).to eq -Money.new(1_000_00)
-      expect(cash.balance).to eq Money.new(100_00)
-      expect(savings.balance).to eq Money.new(300_00)
-      expect(store.balance).to eq Money.new(600_00)
-      expect(btc_wallet.balance).to eq Money.new(200_00, 'BTC')
+      expect(work.balance).to eq(Money.new(-1_000_00))
+      expect(cash.balance).to eq(Money.new(100_00))
+      expect(savings.balance).to eq(Money.new(300_00))
+      expect(store.balance).to eq(Money.new(600_00))
+      expect(btc_wallet.balance).to eq(Money.new(200_00, 'BTC'))
     end
 
     it 'should have correct account balance records' do
       [work, cash, savings, store, btc_wallet].each do |account|
-        expect(DoubleEntry::AccountBalance.find_by_account(account).balance).to eq account.balance
+        expect(DoubleEntry::AccountBalance.find_by_account(account).balance).to eq(account.balance)
       end
     end
 
     it 'should have correct account balance currencies' do
-      expect(DoubleEntry::AccountBalance.find_by_account(btc_wallet).balance.currency).to eq 'BTC'
+      expect(DoubleEntry::AccountBalance.find_by_account(btc_wallet).balance.currency).to eq('BTC')
     end
 
     it 'affects origin/destination balance after transfer' do
@@ -315,20 +312,20 @@ describe DoubleEntry do
 
       DoubleEntry.transfer(amount, :from => savings, :code => :xfer, :to => cash)
 
-      expect(savings.balance).to eq savings_balance - amount
-      expect(cash.balance).to eq cash_balance + amount
+      expect(savings.balance).to eq(savings_balance - amount)
+      expect(cash.balance).to eq(cash_balance + amount)
     end
 
     it 'can be queried at a given point in time' do
-      expect(cash.balance(:at => 1.week.ago)).to eq Money.new(100_00)
+      expect(cash.balance(:at => 1.week.ago)).to eq(Money.new(100_00))
     end
 
     it 'can be queries between two points in time' do
-      expect(cash.balance(:from => 3.weeks.ago, :to => 2.weeks.ago)).to eq Money.new(500_00)
+      expect(cash.balance(:from => 3.weeks.ago, :to => 2.weeks.ago)).to eq(Money.new(500_00))
     end
 
     it 'can be queried between two points in time, even in the future' do
-      expect(btc_wallet.balance(:from => Time.now, :to => 2.weeks.from_now)).to eq Money.new(200_00, 'BTC')
+      expect(btc_wallet.balance(:from => Time.now, :to => 2.weeks.from_now)).to eq(Money.new(200_00, 'BTC'))
     end
 
     it 'can report on balances, scoped by code' do
@@ -336,18 +333,18 @@ describe DoubleEntry do
     end
 
     it 'can report on balances, scoped by many codes' do
-      expect(store.balance(:codes => [:layby, :deposit])).to eq Money.new(200_00)
+      expect(store.balance(:codes => [:layby, :deposit])).to eq(Money.new(200_00))
     end
 
     it 'has running balances for each line' do
       lines = lines_for_account(cash)
-      expect(lines[0].balance).to eq Money.new(1_000_00) # salary
-      expect(lines[1].balance).to eq Money.new(500_00) # savings
-      expect(lines[2].balance).to eq Money.new(300_00) # purchase
-      expect(lines[3].balance).to eq Money.new(200_00) # layby
-      expect(lines[4].balance).to eq Money.new(100_00) # deposit
-      expect(lines[5].balance).to eq Money.new(300_00) # savings
-      expect(lines[6].balance).to eq Money.new(100_00) # purchase
+      expect(lines[0].balance).to eq(Money.new(1_000_00)) # salary
+      expect(lines[1].balance).to eq(Money.new(500_00)) # savings
+      expect(lines[2].balance).to eq(Money.new(300_00)) # purchase
+      expect(lines[3].balance).to eq(Money.new(200_00)) # layby
+      expect(lines[4].balance).to eq(Money.new(100_00)) # deposit
+      expect(lines[5].balance).to eq(Money.new(300_00)) # savings
+      expect(lines[6].balance).to eq(Money.new(100_00)) # purchase
     end
   end
 
@@ -384,32 +381,32 @@ describe DoubleEntry do
     it 'treats each separately scoped account having their own separate balances' do
       DoubleEntry.transfer(Money.new(20_00), :from => bank, :to => johns_cash, :code => :xfer)
       DoubleEntry.transfer(Money.new(10_00), :from => bank, :to => ryans_cash, :code => :xfer)
-      expect(johns_cash.balance).to eq Money.new(20_00)
-      expect(ryans_cash.balance).to eq Money.new(10_00)
+      expect(johns_cash.balance).to eq(Money.new(20_00))
+      expect(ryans_cash.balance).to eq(Money.new(10_00))
     end
 
     it 'allows transfer between two separately scoped accounts' do
       DoubleEntry.transfer(Money.new(10_00), :from => ryans_cash, :to => johns_cash, :code => :xfer)
-      expect(ryans_cash.balance).to eq -Money.new(10_00)
-      expect(johns_cash.balance).to eq Money.new(10_00)
+      expect(ryans_cash.balance).to eq(Money.new(-10_00))
+      expect(johns_cash.balance).to eq(Money.new(10_00))
     end
 
     it 'reports balance correctly if called from either account or finances object' do
       DoubleEntry.transfer(Money.new(10_00), :from => ryans_cash, :to => johns_cash, :code => :xfer)
-      expect(ryans_cash.balance).to eq -Money.new(10_00)
-      expect(DoubleEntry.balance(:cash, :scope => ryan)).to eq -Money.new(10_00)
+      expect(ryans_cash.balance).to eq(Money.new(-10_00))
+      expect(DoubleEntry.balance(:cash, :scope => ryan)).to eq(Money.new(-10_00))
     end
 
     it 'raises an exception if you try to scope with an object instance of differing class to that defined on the account' do
       not_a_user = double(:id => 7)
 
-      expect {
+      expect do
         DoubleEntry.account(:savings, :scope => not_a_user)
-      }.to raise_error DoubleEntry::AccountScopeMismatchError
+      end.to raise_error DoubleEntry::AccountScopeMismatchError
 
-      expect {
+      expect do
         DoubleEntry.balance(:savings, :scope => not_a_user)
-      }.to raise_error DoubleEntry::AccountScopeMismatchError
+      end.to raise_error DoubleEntry::AccountScopeMismatchError
     end
 
     it 'raises exception if you try to transfer between the same account, despite it being scoped' do
@@ -420,8 +417,8 @@ describe DoubleEntry do
 
     it 'allows transfer from one persons account to the same persons other kind of account' do
       DoubleEntry.transfer(Money.new(100_00), :from => ryans_cash, :to => ryans_savings, :code => :xfer)
-      expect(ryans_cash.balance).to eq -Money.new(100_00)
-      expect(ryans_savings.balance).to eq Money.new(100_00)
+      expect(ryans_cash.balance).to eq(Money.new(-100_00))
+      expect(ryans_savings.balance).to eq(Money.new(100_00))
     end
 
     it 'disallows you to report on scoped accounts globally' do

data/spec/generators/double_entry/install/install_generator_spec.rb

@@ -1,13 +1,11 @@
-require 'spec_helper'
 require 'action_controller'
 require 'generator_spec/test_case'
 require 'generators/double_entry/install/install_generator'
 
-
-describe DoubleEntry::Generators::InstallGenerator do
+RSpec.describe DoubleEntry::Generators::InstallGenerator do
   include GeneratorSpec::TestCase
 
-  destination File.expand_path("../../../../../tmp", __FILE__)
+  destination File.expand_path('../../../../../tmp', __FILE__)
 
   before do
     prepare_destination
@@ -15,10 +13,10 @@ describe DoubleEntry::Generators::InstallGenerator do
   end
 
   specify do
-    expect(destination_root).to have_structure {
-      directory "db" do
-        directory "migrate" do
-          migration "create_double_entry_tables" do
+    expect(destination_root).to have_structure do
+      directory 'db' do
+        directory 'migrate' do
+          migration 'create_double_entry_tables' do
             contains 'class CreateDoubleEntryTable'
             contains 'create_table "double_entry_account_balances"'
             contains 'create_table "double_entry_lines"'
@@ -27,7 +25,6 @@ describe DoubleEntry::Generators::InstallGenerator do
           end
         end
       end
-    }
+    end
   end
-
 end

data/spec/spec_helper.rb

@@ -9,12 +9,12 @@ FileUtils.mkdir_p 'tmp'
 FileUtils.mkdir_p 'log'
 FileUtils.rm 'log/test.log', :force => true
 
-database_config_file = File.expand_path("../support/database.yml", __FILE__)
-if File.exists?(database_config_file)
+database_config_file = File.expand_path('../support/database.yml', __FILE__)
+if File.exist?(database_config_file)
   ActiveRecord::Base.establish_connection YAML.load_file(database_config_file)[db_engine]
 else
-  puts "Please configure your spec/support/database.yml file."
-  puts "See spec/support/database.example.yml"
+  puts 'Please configure your spec/support/database.yml file.'
+  puts 'See spec/support/database.example.yml'
   exit 1
 end
 
@@ -28,16 +28,74 @@ end
 
 I18n.config.enforce_available_locales = false
 
+silence_warnings do
+  require 'rspec'
+  require 'rspec/its'
+  require 'database_cleaner'
+  require 'machinist/active_record'
+  require 'timecop'
+  require 'money'
+end
+
 require 'double_entry'
-require 'rspec'
-require 'rspec/its'
-require 'database_cleaner'
-require 'machinist/active_record'
-require 'timecop'
 
-Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require f }
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
 
 RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  else
+    config.default_formatter = 'RSpec::Instafail'
+  end
+
+  # Print the 5 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 5
+
   config.include DoubleEntrySpecHelper
 
   config.before(:suite) do