double_entry 0.10.0 → 0.10.1

data/spec/double_entry/reporting/time_range_spec.rb

@@ -1,44 +1,45 @@
 # encoding: utf-8
-require 'spec_helper'
-module DoubleEntry::Reporting
- describe TimeRange do
-  it 'should correctly calculate a month range' do
-    ar = TimeRange.make(:year => 2009, :month => 10)
-    expect(ar.start.to_s).to eq Time.mktime(2009, 10, 1, 0, 0, 0).to_s
-    expect(ar.finish.to_s).to eq Time.mktime(2009, 10, 31, 23, 59, 59).to_s
-  end
+module DoubleEntry
+  module Reporting
+    RSpec.describe TimeRange do
+      it 'should correctly calculate a month range' do
+        ar = TimeRange.make(:year => 2009, :month => 10)
+        expect(ar.start.to_s).to eq Time.mktime(2009, 10, 1, 0, 0, 0).to_s
+        expect(ar.finish.to_s).to eq Time.mktime(2009, 10, 31, 23, 59, 59).to_s
+      end
 
-  it "should correctly calculate the beginning of the financial year" do
-    range = TimeRange.make(:year => 2009, :month => 6).beginning_of_financial_year
-    expect(range.month).to eq 7
-    expect(range.year).to eq 2008
-    range = TimeRange.make(:year => 2009, :month => 7).beginning_of_financial_year
-    expect(range.month).to eq 7
-    expect(range.year).to eq 2009
-  end
+      it 'should correctly calculate the beginning of the financial year' do
+        range = TimeRange.make(:year => 2009, :month => 6).beginning_of_financial_year
+        expect(range.month).to eq 7
+        expect(range.year).to eq 2008
+        range = TimeRange.make(:year => 2009, :month => 7).beginning_of_financial_year
+        expect(range.month).to eq 7
+        expect(range.year).to eq 2009
+      end
 
-  it "should correctly calculate the current week range for New Year's Day" do
-    Timecop.freeze Time.mktime(2009, 1, 1) do
-      expect(WeekRange.current.week).to eq 1
-    end
-  end
+      it "should correctly calculate the current week range for New Year's Day" do
+        Timecop.freeze Time.mktime(2009, 1, 1) do
+          expect(WeekRange.current.week).to eq 1
+        end
+      end
 
-  it "should correctly calculate the current week range for the first Sunday in the year after New Years" do
-    Timecop.freeze Time.mktime(2009, 1, 4) do
-      expect(WeekRange.current.week).to eq 1
-    end
-  end
+      it 'should correctly calculate the current week range for the first Sunday in the year after New Years' do
+        Timecop.freeze Time.mktime(2009, 1, 4) do
+          expect(WeekRange.current.week).to eq 1
+        end
+      end
 
-  it "should correctly calculate the current week range for the first Monday in the year after New Years" do
-    Timecop.freeze Time.mktime(2009, 1, 5) do
-      expect(WeekRange.current.week).to eq 2
-    end
-  end
+      it 'should correctly calculate the current week range for the first Monday in the year after New Years' do
+        Timecop.freeze Time.mktime(2009, 1, 5) do
+          expect(WeekRange.current.week).to eq 2
+        end
+      end
 
-  it "should correctly calculate the current week range for my birthday" do
-    Timecop.freeze Time.mktime(2009, 3, 27) do
-      expect(WeekRange.current.week).to eq 13
+      it 'should correctly calculate the current week range for my birthday' do
+        Timecop.freeze Time.mktime(2009, 3, 27) do
+          expect(WeekRange.current.week).to eq 13
+        end
+      end
     end
   end
- end
 end

data/spec/double_entry/reporting/week_range_spec.rb

@@ -1,97 +1,103 @@
 # encoding: utf-8
-require 'spec_helper'
-module DoubleEntry::Reporting
-describe WeekRange do
+module DoubleEntry
+  module Reporting
+    RSpec.describe WeekRange do
+      it 'should start week 1 of a year in the first week that has any day in the year' do
+        range = WeekRange.new(:year => 2011, :week => 1)
+        expect(range.start).to eq Time.parse('2010-12-27 00:00:00')
+      end
 
-  it "should start week 1 of a year in the first week that has any day in the year" do
-    range = WeekRange.new(:year => 2011, :week => 1)
-    expect(range.start).to eq Time.parse("2010-12-27 00:00:00")
-  end
+      it 'should handle times in the last week of the year properly' do
+        range = WeekRange.from_time(Time.parse('2010-12-29 11:30:00'))
+        expect(range.year).to eq 2011
+        expect(range.week).to eq 1
+        expect(range.start).to eq Time.parse('2010-12-27 00:00:00')
+      end
 
-  it "should handle times in the last week of the year properly" do
-    range = WeekRange.from_time(Time.parse("2010-12-29 11:30:00"))
-    expect(range.year).to eq 2011
-    expect(range.week).to eq 1
-    expect(range.start).to eq Time.parse("2010-12-27 00:00:00")
-  end
+      it 'handles daylight savings time properly' do
+        Time.use_zone('America/Los_Angeles') do
+          time = Time.zone.parse('Mon, 10 Mar 2014')
+          range = WeekRange.from_time time
+          expect(range.start.day).to eq 10
+        end
+      end
 
-  it "handles daylight savings time properly" do
-    Time.use_zone('America/Los_Angeles') do
-      time = Time.zone.parse('Mon, 10 Mar 2014')
-      range = WeekRange.from_time time
-      expect(range.start.day).to eq 10
-    end
-  end
+      describe '::from_time' do
+        subject(:from_time) { WeekRange.from_time(given_time) }
 
-  describe "::from_time" do
-    subject(:from_time) { WeekRange.from_time(given_time) }
+        context 'given the Time 31st March 2012' do
+          let(:given_time) { Time.new(2012, 3, 31) }
+          its(:year) { should eq 2012 }
+          its(:week) { should eq 14 }
+        end
 
-    context "given the Time 31st March 2012" do
-      let(:given_time) { Time.new(2012, 3, 31) }
-      its(:year) { should eq 2012 }
-      its(:week) { should eq 14 }
-    end
+        context 'given the Date 31st March 2012' do
+          let(:given_time) { Date.parse('2012-03-31') }
+          its(:year) { should eq 2012 }
+          its(:week) { should eq 14 }
+        end
+      end
 
-    context "given the Date 31st March 2012" do
-      let(:given_time) { Date.parse("2012-03-31") }
-      its(:year) { should eq 2012 }
-      its(:week) { should eq 14 }
-    end
-  end
+      describe '::reportable_weeks' do
+        subject(:reportable_weeks) { WeekRange.reportable_weeks }
 
-  describe "::reportable_weeks" do
-    subject(:reportable_weeks) { WeekRange.reportable_weeks }
+        context 'The date is 1st Feb 1970' do
+          before { Timecop.freeze(Time.new(1970, 2, 1)) }
 
-    context "The date is 1st Feb 1970" do
-      before { Timecop.freeze(Time.new(1970, 2, 1)) }
+          specify do
+            should eq [
+              WeekRange.new(:year => 1970, :week => 1),
+              WeekRange.new(:year => 1970, :week => 2),
+              WeekRange.new(:year => 1970, :week => 3),
+              WeekRange.new(:year => 1970, :week => 4),
+              WeekRange.new(:year => 1970, :week => 5),
+            ]
+          end
 
-      it { should eq [
-        WeekRange.new(year: 1970, week: 1),
-        WeekRange.new(year: 1970, week: 2),
-        WeekRange.new(year: 1970, week: 3),
-        WeekRange.new(year: 1970, week: 4),
-        WeekRange.new(year: 1970, week: 5),
-      ] }
+          context 'My business started on 25th Jan 1970' do
+            before do
+              DoubleEntry::Reporting.configure do |config|
+                config.start_of_business = Time.new(1970, 1, 25)
+              end
+            end
 
-      context "My business started on 25th Jan 1970" do
-        before do
-          DoubleEntry::Reporting.configure do |config|
-            config.start_of_business = Time.new(1970, 1, 25)
+            specify do
+              should eq [
+                WeekRange.new(:year => 1970, :week => 4),
+                WeekRange.new(:year => 1970, :week => 5),
+              ]
+            end
           end
         end
 
-        it { should eq [
-          WeekRange.new(year: 1970, week: 4),
-          WeekRange.new(year: 1970, week: 5),
-        ] }
-      end
-    end
+        context 'The date is 1st Jan 1970' do
+          before { Timecop.freeze(Time.new(1970, 1, 1)) }
 
-    context "The date is 1st Jan 1970" do
-      before { Timecop.freeze(Time.new(1970, 1, 1)) }
-
-      it { should eq [ WeekRange.new(year: 1970, week: 1) ] }
-    end
+          it { should eq [WeekRange.new(:year => 1970, :week => 1)] }
+        end
 
-    context "Given a start time of 3rd Dec 1982" do
-      subject(:reportable_weeks) { WeekRange.reportable_weeks(from: Time.new(1982, 12, 3)) }
+        context 'Given a start time of 3rd Dec 1982' do
+          subject(:reportable_weeks) { WeekRange.reportable_weeks(:from => Time.new(1982, 12, 3)) }
 
-      context "The date is 12nd Jan 1983" do
-        before { Timecop.freeze(Time.new(1983, 2, 2)) }
-        it { should eq [
-          WeekRange.new(year: 1982, week: 49),
-          WeekRange.new(year: 1982, week: 50),
-          WeekRange.new(year: 1982, week: 51),
-          WeekRange.new(year: 1982, week: 52),
-          WeekRange.new(year: 1983, week: 1),
-          WeekRange.new(year: 1983, week: 2),
-          WeekRange.new(year: 1983, week: 3),
-          WeekRange.new(year: 1983, week: 4),
-          WeekRange.new(year: 1983, week: 5),
-          WeekRange.new(year: 1983, week: 6),
-        ] }
+          context 'The date is 12nd Jan 1983' do
+            before { Timecop.freeze(Time.new(1983, 2, 2)) }
+            specify do
+              should eq [
+                WeekRange.new(:year => 1982, :week => 49),
+                WeekRange.new(:year => 1982, :week => 50),
+                WeekRange.new(:year => 1982, :week => 51),
+                WeekRange.new(:year => 1982, :week => 52),
+                WeekRange.new(:year => 1983, :week => 1),
+                WeekRange.new(:year => 1983, :week => 2),
+                WeekRange.new(:year => 1983, :week => 3),
+                WeekRange.new(:year => 1983, :week => 4),
+                WeekRange.new(:year => 1983, :week => 5),
+                WeekRange.new(:year => 1983, :week => 6),
+              ]
+            end
+          end
+        end
       end
     end
   end
- end
 end

data/spec/double_entry/reporting_spec.rb

@@ -1,12 +1,10 @@
 # encoding: utf-8
-require "spec_helper"
-describe DoubleEntry::Reporting do
-
-  describe "::configure" do
-    describe "start_of_business" do
+RSpec.describe DoubleEntry::Reporting do
+  describe '::configure' do
+    describe 'start_of_business' do
       subject(:start_of_business) { DoubleEntry::Reporting.configuration.start_of_business }
 
-      context "configured to 2011-03-12" do
+      context 'configured to 2011-03-12' do
         before do
           DoubleEntry::Reporting.configure do |config|
             config.start_of_business = Time.new(2011, 3, 12)
@@ -16,34 +14,32 @@ describe DoubleEntry::Reporting do
         it { should eq Time.new(2011, 3, 12) }
       end
 
-      context "not configured" do
+      context 'not configured' do
         it { should eq Time.new(1970, 1, 1) }
       end
     end
   end
 
-  describe "::scopes_with_minimum_balance_for_account" do
+  describe '::scopes_with_minimum_balance_for_account' do
     subject(:scopes) { DoubleEntry::Reporting.scopes_with_minimum_balance_for_account(minimum_balance, :checking) }
 
     context "a 'checking' account with balance $100" do
       let!(:user) { User.make!(:checking_balance => Money.new(100_00)) }
 
-      context "when searching for balance $99" do
+      context 'when searching for balance $99' do
         let(:minimum_balance) { Money.new(99_00) }
         it { should include user.id }
       end
 
-      context "when searching for balance $100" do
+      context 'when searching for balance $100' do
         let(:minimum_balance) { Money.new(100_00) }
         it { should include user.id }
       end
 
-      context "when searching for balance $101" do
+      context 'when searching for balance $101' do
         let(:minimum_balance) { Money.new(101_00) }
         it { should_not include user.id }
       end
     end
   end
-
-
 end

data/spec/double_entry/transfer_spec.rb

@@ -1,18 +1,16 @@
 # encoding: utf-8
-require 'spec_helper'
 module DoubleEntry
-  describe Transfer do
-
-    describe "::new" do
-      context "given a code 47 characters in length" do
-        let(:code) { "xxxxxxxxxxxxxxxx 47 characters xxxxxxxxxxxxxxxx" }
+  RSpec.describe Transfer do
+    describe '::new' do
+      context 'given a code 47 characters in length' do
+        let(:code) { 'xxxxxxxxxxxxxxxx 47 characters xxxxxxxxxxxxxxxx' }
         specify do
           expect { Transfer.new(:code => code) }.to_not raise_error
         end
       end
 
-      context "given a code 48 characters in length" do
-        let(:code) { "xxxxxxxxxxxxxxxx 48 characters xxxxxxxxxxxxxxxxx" }
+      context 'given a code 48 characters in length' do
+        let(:code) { 'xxxxxxxxxxxxxxxx 48 characters xxxxxxxxxxxxxxxxx' }
         specify do
           expect { Transfer.new(:code => code) }.to raise_error TransferCodeTooLongError, /'#{code}'/
         end
@@ -20,18 +18,18 @@ module DoubleEntry
     end
 
     describe Transfer::Set do
-      describe "#define" do
+      describe '#define' do
         before do
           subject.define(
-            :code => "code",
-            :from => double(:identifier => "from"),
-            :to => double(:identifier => "to"),
+            :code => 'code',
+            :from => double(:identifier => 'from'),
+            :to => double(:identifier => 'to'),
           )
         end
         its(:first) { should be_a Transfer }
-        its("first.code") { should eq "code" }
-        its("first.from.identifier") { should eq "from" }
-        its("first.to.identifier") { should eq "to" }
+        its('first.code') { should eq 'code' }
+        its('first.from.identifier') { should eq 'from' }
+        its('first.to.identifier') { should eq 'to' }
       end
     end
   end

data/spec/double_entry/validation/line_check_spec.rb

@@ -1,105 +1,99 @@
 # encoding: utf-8
-require 'spec_helper'
-module DoubleEntry::Validation
- describe LineCheck do
-
-  describe '#last' do
+module DoubleEntry
+  module Validation
+    RSpec.describe LineCheck do
+      describe '#last' do
+        context 'Given some checks have been created' do
+          before do
+            Timecop.freeze 3.minutes.ago do
+              LineCheck.create! :last_line_id => 100, :errors_found => false, :log => ''
+            end
+            Timecop.freeze 1.minute.ago do
+              LineCheck.create! :last_line_id => 300, :errors_found => false, :log => ''
+            end
+            Timecop.freeze 2.minutes.ago do
+              LineCheck.create! :last_line_id => 200, :errors_found => false, :log => ''
+            end
+          end
 
-    context 'Given some checks have been created' do
-      before do
-        Timecop.freeze 3.minutes.ago do
-          LineCheck.create! :last_line_id => 100, :errors_found => false, :log => ''
-        end
-        Timecop.freeze 1.minute.ago do
-          LineCheck.create! :last_line_id => 300, :errors_found => false, :log => ''
-        end
-        Timecop.freeze 2.minutes.ago do
-          LineCheck.create! :last_line_id => 200, :errors_found => false, :log => ''
+          it 'should find the newest LineCheck created (by creation_date)' do
+            expect(LineCheck.last.last_line_id).to eq 300
+          end
         end
       end
 
-      it 'should find the newest LineCheck created (by creation_date)' do
-        expect(LineCheck.last.last_line_id).to eq 300
-      end
-    end
+      describe '#perform!' do
+        subject(:performed_line_check) { LineCheck.perform! }
 
-  end
-
-  describe '#perform!' do
-    subject(:performed_line_check) { LineCheck.perform! }
+        context 'Given a user with 100 dollars' do
+          before { User.make!(:savings_balance => Money.new(100_00)) }
 
-    context 'Given a user with 100 dollars' do
-      before { User.make!(:savings_balance => Money.new(100_00)) }
+          context 'And all is consistent' do
+            context 'And all lines have been checked' do
+              before { LineCheck.perform!  }
 
-      context 'And all is consistent' do
+              it { should be_nil }
 
-        context 'And all lines have been checked' do
-          before { LineCheck.perform!  }
+              it 'should not persist a new LineCheck' do
+                expect { LineCheck.perform!  }.
+                  to_not change { LineCheck.count }
+              end
+            end
 
-          it { should be_nil }
+            it { should be_instance_of LineCheck }
+            its(:errors_found) { should eq false }
 
-          it 'should not persist a new LineCheck' do
-            expect {
-              LineCheck.perform!
-            }.to_not change { LineCheck.count }
+            it 'should persist the LineCheck' do
+              line_check = LineCheck.perform!
+              expect(LineCheck.last).to eq line_check
+            end
           end
-        end
-
-        it { should be_instance_of LineCheck }
-        its(:errors_found) { should eq false }
-
-        it 'should persist the LineCheck' do
-          line_check = LineCheck.perform!
-          expect(LineCheck.last).to eq line_check
-        end
-      end
 
-      context 'And there is a consistency error in lines' do
-        before { DoubleEntry::Line.order(:id).limit(1).update_all('balance = balance + 1') }
+          context 'And there is a consistency error in lines' do
+            before { DoubleEntry::Line.order(:id).limit(1).update_all('balance = balance + 1') }
 
-        its(:errors_found) { should be true }
-        its(:log) { should match /Error on line/ }
+            its(:errors_found) { should be true }
+            its(:log) { should match(/Error on line/) }
 
-        it 'should correct the running balance' do
-          expect {
-            LineCheck.perform!
-          }.to change { DoubleEntry::Line.order(:id).first.balance }.by Money.new(-1)
-        end
-      end
+            it 'should correct the running balance' do
+              expect { LineCheck.perform!  }.
+                to change { DoubleEntry::Line.order(:id).first.balance }.
+                by Money.new(-1)
+            end
+          end
 
-      context 'And there is a consistency error in account balance' do
-        before { DoubleEntry::AccountBalance.order(:id).limit(1).update_all('balance = balance + 1') }
+          context 'And there is a consistency error in account balance' do
+            before { DoubleEntry::AccountBalance.order(:id).limit(1).update_all('balance = balance + 1') }
 
-        its(:errors_found) { should be true }
+            its(:errors_found) { should be true }
 
-        it 'should correct the account balance' do
-          expect {
-            LineCheck.perform!
-          }.to change { DoubleEntry::AccountBalance.order(:id).first.balance }.by Money.new(-1)
+            it 'should correct the account balance' do
+              expect { LineCheck.perform!  }.
+                to change { DoubleEntry::AccountBalance.order(:id).first.balance }.
+                by Money.new(-1)
+            end
+          end
         end
-      end
-    end
 
+        context 'Given a user with a non default currency balance' do
+          before { User.make!(:bitcoin_balance => Money.new(100_00, 'BTC')) }
+          its(:errors_found) { should eq false }
+          context 'And there is a consistency error in lines' do
+            before { DoubleEntry::Line.order(:id).limit(1).update_all('balance = balance + 1') }
+
+            its(:errors_found) { should eq true }
+            it 'should correct the running balance' do
+              expect { LineCheck.perform!  }.
+                to change { DoubleEntry::Line.order(:id).first.balance }.
+                by Money.new(-1, 'BTC')
+            end
+          end
+        end
 
-    context 'Given a user with a non default currency balance' do
-      before { User.make!(:bitcoin_balance => Money.new(100_00, 'BTC')) }
-      its(:errors_found) { should eq false }
-      context 'And there is a consistency error in lines' do
-        before { DoubleEntry::Line.order(:id).limit(1).update_all('balance = balance + 1') }
-
-        its(:errors_found) { should eq true }
-        it 'should correct the running balance' do
-          expect {
-            LineCheck.perform!
-          }.to change { DoubleEntry::Line.order(:id).first.balance }.by Money.new(-1, 'BTC')
+        it 'has a table name prefixed with double_entry_' do
+          expect(LineCheck.table_name).to eq 'double_entry_line_checks'
         end
       end
     end
-
-    it "has a table name prefixed with double_entry_" do
-      expect(LineCheck.table_name).to eq "double_entry_line_checks"
-    end
-
   end
- end
 end