double_entry 0.0.1.pre → 0.1.0.pre.pre.alpha

data/spec/double_entry/reporting_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require "spec_helper"
+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
+        before do
+          DoubleEntry::Reporting.configure do |config|
+            config.start_of_business = Time.new(2011, 3, 12)
+          end
+        end
+
+        it { should eq Time.new(2011, 3, 12) }
+      end
+
+      context "not configured" do
+        it { should eq Time.new(1970, 1, 1) }
+      end
+    end
+  end
+
+end

data/spec/double_entry/time_range_array_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+describe DoubleEntry::TimeRangeArray do
+  describe '.make' do
+    subject(:time_range_array) { DoubleEntry::TimeRangeArray.make(range_type, start, finish) }
+
+    context 'for "hour" range type' do
+      let(:range_type) { 'hour' }
+
+      context 'given start is "2007-05-03 15:00:00" and finish is "2007-05-03 18:00:00"' do
+        let(:start)  { '2007-05-03 15:00:00' }
+        let(:finish) { '2007-05-03 18:00:00' }
+        it { should eq [
+          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 15)),
+          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 16)),
+          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 17)),
+          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 18)),
+        ] }
+      end
+
+      context 'given start and finish are nil' do
+        it 'should raise an error' do
+          expect { DoubleEntry::TimeRangeArray.make(range_type, nil, nil) }.
+            to raise_error 'Must specify range for hour-by-hour reports'
+        end
+      end
+    end
+
+    context 'for "day" range type' do
+      let(:range_type) { 'day' }
+
+      context 'given start is "2007-05-03" and finish is "2007-05-07"' do
+        let(:start)  { '2007-05-03' }
+        let(:finish) { '2007-05-07' }
+        it { should eq [
+          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 3)),
+          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 4)),
+          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 5)),
+          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 6)),
+          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 7)),
+        ] }
+      end
+
+      context 'given start and finish are nil' do
+        it 'should raise an error' do
+          expect { DoubleEntry::TimeRangeArray.make(range_type, nil, nil) }.
+            to raise_error 'Must specify range for day-by-day reports'
+        end
+      end
+    end
+
+    context 'for "week" range type' do
+      let(:range_type) { 'week' }
+
+      context 'given start is "2007-05-03" and finish is "2007-05-24"' do
+        let(:start)  { '2007-05-03' }
+        let(:finish) { '2007-05-24' }
+        it { should eq [
+          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 3)),
+          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 10)),
+          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 17)),
+          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 24)),
+        ] }
+      end
+
+      context 'given start and finish are nil' do
+        it 'should raise an error' do
+          expect { DoubleEntry::TimeRangeArray.make(range_type, nil, nil) }.
+            to raise_error 'Must specify range for week-by-week reports'
+        end
+      end
+    end
+
+    context 'for "month" range type' do
+      let(:range_type) { 'month' }
+
+      context 'given start is "2007-05-03" and finish is "2007-08-24"' do
+        let(:start)  { '2007-05-03' }
+        let(:finish) { '2007-08-24' }
+        it { should eq [
+          DoubleEntry::MonthRange.from_time(Time.new(2007, 5)),
+          DoubleEntry::MonthRange.from_time(Time.new(2007, 6)),
+          DoubleEntry::MonthRange.from_time(Time.new(2007, 7)),
+          DoubleEntry::MonthRange.from_time(Time.new(2007, 8)),
+        ] }
+      end
+
+      context 'given finish is nil' do
+        let(:start)  { '2006-08-03' }
+        let(:finish) { nil }
+
+        context 'and the date is "2007-04-13"' do
+          before { Timecop.freeze(Time.new(2007, 4, 13)) }
+
+          it { should eq [
+            DoubleEntry::MonthRange.from_time(Time.new(2006, 8)),
+            DoubleEntry::MonthRange.from_time(Time.new(2006, 9)),
+            DoubleEntry::MonthRange.from_time(Time.new(2006, 10)),
+            DoubleEntry::MonthRange.from_time(Time.new(2006, 11)),
+            DoubleEntry::MonthRange.from_time(Time.new(2006, 12)),
+            DoubleEntry::MonthRange.from_time(Time.new(2007, 1)),
+            DoubleEntry::MonthRange.from_time(Time.new(2007, 2)),
+            DoubleEntry::MonthRange.from_time(Time.new(2007, 3)),
+            DoubleEntry::MonthRange.from_time(Time.new(2007, 4)),
+          ] }
+        end
+      end
+    end
+
+    context 'for "year" range type' do
+      let(:range_type) { 'year' }
+
+      context 'given start is "2007-05-03" and finish is "2008-08-24"' do
+        let(:start)  { '2007-05-03' }
+        let(:finish) { '2008-08-24' }
+
+        context 'and the date is "2009-11-23"' do
+          before { Timecop.freeze(Time.new(2009, 11, 23)) }
+
+          it 'takes no notice of start and finish' do
+            should eq [
+              DoubleEntry::YearRange.from_time(Time.new(2007)),
+              DoubleEntry::YearRange.from_time(Time.new(2008)),
+              DoubleEntry::YearRange.from_time(Time.new(2009)),
+            ]
+          end
+
+          context 'given finish is nil' do
+            let(:start)  { '2006-08-03' }
+            let(:finish) { nil }
+            it {
+              should eq [
+                DoubleEntry::YearRange.from_time(Time.new(2006)),
+                DoubleEntry::YearRange.from_time(Time.new(2007)),
+                DoubleEntry::YearRange.from_time(Time.new(2008)),
+                DoubleEntry::YearRange.from_time(Time.new(2009)),
+              ]
+            }
+          end
+        end
+      end
+    end
+
+    context 'given an invalid range type "ueue"' do
+      it 'should raise an error' do
+        expect { DoubleEntry::TimeRangeArray.make('ueue') }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/spec/double_entry/time_range_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe DoubleEntry::TimeRange do
+  it 'should correctly calculate a month range' do
+    ar = DoubleEntry::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 = DoubleEntry::TimeRange.make(:year => 2009, :month => 6).beginning_of_financial_year
+    expect(range.month).to eq 7
+    expect(range.year).to eq 2008
+    range = DoubleEntry::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(DoubleEntry::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(DoubleEntry::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(DoubleEntry::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(DoubleEntry::WeekRange.current.week).to eq 13
+    end
+  end
+end

data/spec/double_entry/week_range_spec.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe DoubleEntry::WeekRange do
+
+  it "should start week 1 of a year in the first week that has any day in the year" do
+    range = DoubleEntry::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 = DoubleEntry::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
+
+  describe "::from_time" do
+    subject(:from_time) { DoubleEntry::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 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) { DoubleEntry::WeekRange.reportable_weeks }
+
+    context "The date is 1st Feb 1970" do
+      before { Timecop.freeze(Time.new(1970, 2, 1)) }
+
+      it { should eq [
+        DoubleEntry::WeekRange.new(year: 1970, week: 1),
+        DoubleEntry::WeekRange.new(year: 1970, week: 2),
+        DoubleEntry::WeekRange.new(year: 1970, week: 3),
+        DoubleEntry::WeekRange.new(year: 1970, week: 4),
+        DoubleEntry::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
+
+        it { should eq [
+          DoubleEntry::WeekRange.new(year: 1970, week: 4),
+          DoubleEntry::WeekRange.new(year: 1970, week: 5),
+        ] }
+      end
+    end
+
+    context "The date is 1st Jan 1970" do
+      before { Timecop.freeze(Time.new(1970, 1, 1)) }
+
+      it { should eq [ DoubleEntry::WeekRange.new(year: 1970, week: 1) ] }
+    end
+
+    context "Given a start time of 3rd Dec 1982" do
+      subject(:reportable_weeks) { DoubleEntry::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 [
+          DoubleEntry::WeekRange.new(year: 1982, week: 49),
+          DoubleEntry::WeekRange.new(year: 1982, week: 50),
+          DoubleEntry::WeekRange.new(year: 1982, week: 51),
+          DoubleEntry::WeekRange.new(year: 1982, week: 52),
+          DoubleEntry::WeekRange.new(year: 1983, week: 1),
+          DoubleEntry::WeekRange.new(year: 1983, week: 2),
+          DoubleEntry::WeekRange.new(year: 1983, week: 3),
+          DoubleEntry::WeekRange.new(year: 1983, week: 4),
+          DoubleEntry::WeekRange.new(year: 1983, week: 5),
+          DoubleEntry::WeekRange.new(year: 1983, week: 6),
+        ] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'action_controller'
+require 'generator_spec/test_case'
+require 'generators/double_entry/install/install_generator'
+
+
+describe DoubleEntry::Generators::InstallGenerator do
+  include GeneratorSpec::TestCase
+
+  destination File.expand_path("../../../../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+    run_generator
+  end
+
+  specify do
+    expect(destination_root).to have_structure {
+      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"'
+            contains 'create_table "double_entry_line_aggregates"'
+            contains 'create_table "double_entry_line_checks"'
+          end
+        end
+      end
+    }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require 'bundler/setup'
+require 'active_record'
+require 'active_support'
+
+ENV['DB'] ||= 'mysql'
+ActiveRecord::Base.establish_connection YAML.load_file(File.expand_path("../support/database.yml", __FILE__))[ENV['DB']]
+
+FileUtils.mkdir_p 'log'
+FileUtils.rm 'log/test.log', :force => true
+
+# Buffered Logger was deprecated in ActiveSupport 4.0.0 and was removed in 4.1.0
+# Logger was added in ActiveSupport 4.0.0
+if defined? ActiveSupport::Logger
+  ActiveRecord::Base.logger = ActiveSupport::Logger.new('log/test.log')
+else
+  ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new('log/test.log')
+end
+
+I18n.config.enforce_available_locales = false
+
+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 }
+
+RSpec.configure do |config|
+  config.include DoubleEntrySpecHelper
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :deletion
+    DatabaseCleaner.clean_with(:deletion)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    Timecop.return
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/accounts.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+# These make it easier to quickly set up account balances for testing.
+
+# user scoping magic, accepts a User, Fixnum, or String
+user_scope = lambda do |user_identifier|
+  if user_identifier.is_a?(Fixnum) or user_identifier.is_a?(String)
+    user_identifier
+  elsif user_identifier.is_a?(User)
+    user_identifier.id
+  else
+    raise "unknown type expected fixnum, string or user, got: #{user_identifier.inspect}"
+  end
+end
+
+# A set of accounts to test with
+DoubleEntry.accounts = DoubleEntry::Account::Set.new.tap do |accounts|
+  accounts << DoubleEntry::Account.new(:identifier => :savings, :scope_identifier => user_scope, :positive_only => true)
+  accounts << DoubleEntry::Account.new(:identifier => :checking, :scope_identifier => user_scope, :positive_only => true)
+  accounts << DoubleEntry::Account.new(:identifier => :test, :scope_identifier => user_scope)
+end
+
+# A set of allowed transfers between accounts
+DoubleEntry.transfers = DoubleEntry::Transfer::Set.new.tap do |transfers|
+  transfers << DoubleEntry::Transfer.new(:from => :test, :to => :savings, :code => :bonus)
+  transfers << DoubleEntry::Transfer.new(:from => :test, :to => :checking, :code => :pay)
+end

data/spec/support/blueprints.rb

@@ -0,0 +1,34 @@
+class UserBlueprint < Machinist::ActiveRecord::Blueprint
+  def make!(attributes = {})
+    savings_balance = attributes.delete(:savings_balance)
+    checking_balance = attributes.delete(:checking_balance)
+    user = super(attributes)
+    if savings_balance
+      DoubleEntry.transfer(
+        savings_balance,
+        :from => DoubleEntry.account(:test, :scope => user),
+        :to   => DoubleEntry.account(:savings, :scope => user),
+        :code => :bonus,
+      )
+    end
+    if checking_balance
+      DoubleEntry.transfer(
+        checking_balance,
+        :from => DoubleEntry.account(:test, :scope => user),
+        :to   => DoubleEntry.account(:checking, :scope => user),
+        :code => :pay,
+      )
+    end
+    user
+  end
+end
+
+class User < ActiveRecord::Base
+  def self.blueprint_class
+    UserBlueprint
+  end
+end
+
+User.blueprint do
+  username { "user#{sn}" }
+end