plutus 0.11.0 → 0.16

data/lib/plutus.rb

@@ -2,11 +2,6 @@
 require "rails"
 
 module Plutus
-  class Engine < Rails::Engine
-    isolate_namespace Plutus
-  end
-
-
   # ------------------------------ tenancy ------------------------------
   # configuration to enable or disable tenancy
   mattr_accessor :enable_tenancy
@@ -21,3 +16,5 @@ module Plutus
     yield(self)
   end
 end
+
+require "plutus/engine"

data/lib/plutus/engine.rb

@@ -0,0 +1,5 @@
+module Plutus
+  class Engine < Rails::Engine
+    isolate_namespace Plutus
+  end
+end

data/lib/plutus/version.rb

@@ -1,3 +1,3 @@
 module Plutus
-  VERSION = "0.11.0"
+  VERSION = "0.16"
 end

data/spec/controllers/accounts_controller_spec.rb

@@ -2,27 +2,18 @@ require 'spec_helper'
 
 module Plutus
   describe AccountsController do
-    # Run these tests if you enable routing in your rails app. See README
+    routes { Plutus::Engine.routes }
 
-    #def mock_account(stubs={})
-      #@mock_account ||= mock_model(Account, stubs)
-    #end
-
-    #describe "GET index" do
-      #it "assigns all accounts as @accounts" do
-        #Account.stub(:find).with(:all).and_return([mock_account])
-        #get :index
-        #assigns[:accounts].should == [mock_account]
-      #end
-    #end
-
-    #describe "GET show" do
-      #it "assigns the requested account as @account" do
-        #Account.stub(:find).with("37").and_return(mock_account)
-        #get :show, :id => "37"
-        #assigns[:account].should equal(mock_account)
-      #end
-    #end
+    def mock_account(stubs={})
+      @mock_account ||= FactoryGirl.create(:asset)
+    end
 
+    describe "GET index" do
+      it "assigns all accounts as @accounts" do
+        allow(Account).to receive(:all).and_return([mock_account])
+        get :index
+        expect(assigns[:accounts]).to eq([mock_account])
+      end
+    end
   end
 end

data/spec/controllers/entries_controller_spec.rb

@@ -2,27 +2,18 @@ require 'spec_helper'
 
 module Plutus
   describe EntriesController do
-    # Run these tests if you enable routing in your rails app. See README
+    routes { Plutus::Engine.routes }
 
-    #def mock_entry(stubs={})
-      #@mock_entry ||= mock_model(Entry, stubs)
-    #end
-
-    #describe "GET index" do
-      #it "assigns all entries as @entries" do
-        #Entry.stub(:find).with(:all).and_return([mock_entry])
-        #get :index
-        #assigns[:entries].should == [mock_entry]
-      #end
-    #end
-
-    #describe "GET show" do
-      #it "assigns the requested entry as @entry" do
-        #Entry.stub(:find).with("37").and_return(mock_entry)
-        #get :show, :id => "37"
-        #assigns[:entry].should equal(mock_entry)
-      #end
-    #end
+    def mock_entry(stubs={})
+      @mock_entry ||= FactoryGirl.create(:entry_with_credit_and_debit)
+    end
 
+    describe "GET index" do
+      it "assigns all entries as @entries" do
+        allow(Entry).to receive_message_chain(:per, :order).and_return([mock_entry])
+        get :index
+        expect(assigns[:entries]).to eq([mock_entry])
+      end
+    end
   end
 end

data/spec/controllers/reports_controller_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Plutus
+  describe ReportsController do
+    routes { Plutus::Engine.routes }
+
+    def mock_entry(stubs={})
+      @mock_entry ||= FactoryGirl.create(:entry_with_credit_and_debit)
+    end
+
+    describe "GET balance_sheet" do
+      it "renders when one entry exists" do
+        allow(Entry).to receive_message_chain(:order).and_return([mock_entry])
+        get :balance_sheet
+        assert_template 'reports/balance_sheet'
+      end
+      it "renders when no entries exist" do
+        allow(Entry).to receive_message_chain(:order).and_return([])
+        get :balance_sheet
+        assert_template 'reports/balance_sheet'
+      end
+    end
+  end
+end

data/spec/factories/account_factory.rb

@@ -1,32 +1,32 @@
 FactoryGirl.define do
   factory :account, :class => Plutus::Account do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   factory :asset, :class => Plutus::Asset do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   factory :equity, :class => Plutus::Equity do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   factory :expense, :class => Plutus::Expense do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   factory :liability, :class => Plutus::Liability do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   factory :revenue, :class => Plutus::Revenue do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   sequence :name do |n|

data/spec/factories/amount_factory.rb

@@ -1,18 +1,18 @@
 FactoryGirl.define do
   factory :amount, :class => Plutus::Amount do |amount|
-    amount.amount BigDecimal.new('473')
+    amount.amount { BigDecimal('473') }
     amount.association :entry, :factory => :entry_with_credit_and_debit
     amount.association :account, :factory => :asset
   end
 
   factory :credit_amount, :class => Plutus::CreditAmount do |credit_amount|
-    credit_amount.amount BigDecimal.new('473')
+    credit_amount.amount { BigDecimal('473') }
     credit_amount.association :entry, :factory => :entry_with_credit_and_debit
     credit_amount.association :account, :factory => :revenue
   end
 
   factory :debit_amount, :class => Plutus::DebitAmount do |debit_amount|
-    debit_amount.amount BigDecimal.new('473')
+    debit_amount.amount { BigDecimal('473') }
     debit_amount.association :entry, :factory => :entry_with_credit_and_debit
     debit_amount.association :account, :factory => :asset
   end

data/spec/factories/entry_factory.rb

@@ -1,6 +1,6 @@
 FactoryGirl.define do
   factory :entry, :class => Plutus::Entry do |entry|
-    entry.description 'factory description'
+    entry.description { 'factory description' }
     factory :entry_with_credit_and_debit, :class => Plutus::Entry do |entry_cd|
       entry_cd.after_build do |t|
         t.credit_amounts << FactoryGirl.build(:credit_amount, :entry => t)

data/spec/factories/tenant_factory.rb

@@ -0,0 +1,12 @@
+module Plutus
+class Tenant < ActiveRecord::Base
+end
+end
+
+FactoryGirl.define do
+  factory :tenant, :class => Plutus::Tenant do
+    sequence :name do |n|
+      "Tenant #{n}"
+    end
+  end
+end

data/spec/models/account_spec.rb

@@ -5,27 +5,33 @@ module Plutus
     let(:account) { FactoryGirl.build(:account) }
     subject { account }
 
-    it { should_not be_valid }  # must construct a child type instead
+    it { is_expected.not_to be_valid }  # must construct a child type instead
 
     describe "when using a child type" do
       let(:account) { FactoryGirl.create(:account, type: "Finance::Asset") }
-      it { should be_valid }
+      it { is_expected.to be_valid }
 
       it "should be unique per name" do
         conflict = FactoryGirl.build(:account, name: account.name, type: account.type)
-        conflict.should_not be_valid
-        conflict.errors[:name].should == ["has already been taken"]
+        expect(conflict).not_to be_valid
+        expect(conflict.errors[:name]).to eq(["has already been taken"])
       end
     end
 
-    it { should_not respond_to(:balance) }
+    it "calling the instance method #balance should raise a NoMethodError" do
+      expect { subject.balance }.to raise_error NoMethodError, "undefined method 'balance'"
+    end
+
+    it "calling the class method ::balance should raise a NoMethodError" do
+      expect { subject.class.balance }.to raise_error NoMethodError, "undefined method 'balance'"
+    end
 
     describe ".trial_balance" do
       subject { Account.trial_balance }
-      it { should be_kind_of BigDecimal }
+      it { is_expected.to be_kind_of BigDecimal }
 
       context "when given no entries" do
-        it { should == 0 }
+        it { is_expected.to eq(0) }
       end
 
       context "when given correct entries" do
@@ -63,8 +69,65 @@ module Plutus
           FactoryGirl.create(:entry, :credit_amounts => [ca5], :debit_amounts => [da5])
         }
 
-        it { should == 0 }
+        it { is_expected.to eq(0) }
+      end
+    end
+
+    describe "#amounts" do
+      it "returns all credit and debit amounts" do
+        equity = FactoryGirl.create(:equity)
+        asset = FactoryGirl.create(:asset)
+        expense = FactoryGirl.create(:expense)
+
+        investment = Entry.new(
+          description: "Initial investment",
+          date: Date.today,
+          debits: [{ account_name: equity.name, amount: 1000 }],
+          credits: [{ account_name: asset.name, amount: 1000 }],
+        )
+        investment.save
+
+        purchase = Entry.new(
+          description: "First computer",
+          date: Date.today,
+          debits: [{ account_name: asset.name, amount: 900 }],
+          credits: [{ account_name: expense.name, amount: 900 }],
+        )
+        purchase.save
+
+        expect(equity.amounts.size).to eq 1
+        expect(asset.amounts.size).to eq 2
+        expect(expense.amounts.size).to eq 1
+      end
+    end
+
+    describe "#entries" do
+      it "returns all credit and debit entries" do
+        equity = FactoryGirl.create(:equity)
+        asset = FactoryGirl.create(:asset)
+        expense = FactoryGirl.create(:expense)
+
+        investment = Entry.new(
+          description: "Initial investment",
+          date: Date.today,
+          debits: [{ account_name: equity.name, amount: 1000 }],
+          credits: [{ account_name: asset.name, amount: 1000 }],
+        )
+        investment.save
+
+        purchase = Entry.new(
+          description: "First computer",
+          date: Date.today,
+          debits: [{ account_name: asset.name, amount: 900 }],
+          credits: [{ account_name: expense.name, amount: 900 }],
+        )
+        purchase.save
+
+        expect(equity.entries.size).to eq 1
+        expect(asset.entries.size).to eq 2
+        expect(expense.entries.size).to eq 1
       end
     end
+
   end
 end

data/spec/models/amount_spec.rb

@@ -2,7 +2,12 @@ require 'spec_helper'
 
 module Plutus
   describe Amount do
+
+    describe "attributes" do
+      it { is_expected.to delegate_method(:name).to(:account).with_prefix }
+    end
+
     subject { FactoryGirl.build(:amount) }
-    it { should_not be_valid }  # construct a child class instead
+    it { is_expected.not_to be_valid }  # construct a child class instead
   end
 end

data/spec/models/entry_spec.rb

@@ -5,15 +5,15 @@ module Plutus
     let(:entry) { FactoryGirl.build(:entry) }
     subject { entry }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
 
     context "with credit and debit" do
       let(:entry) { FactoryGirl.build(:entry_with_credit_and_debit) }
-      it { should be_valid }
+      it { is_expected.to be_valid }
 
       it "should require a description" do
         entry.description = nil
-        entry.should_not be_valid
+        expect(entry).not_to be_valid
       end
     end
 
@@ -21,13 +21,13 @@ module Plutus
       before {
         entry.debit_amounts << FactoryGirl.build(:debit_amount, entry: entry)
       }
-      it { should_not be_valid }
+      it { is_expected.not_to be_valid }
 
       context "with an invalid credit" do
         before {
           entry.credit_amounts << FactoryGirl.build(:credit_amount, entry: entry, amount: nil)
         }
-        it { should_not be_valid }
+        it { is_expected.not_to be_valid }
       end
     end
 
@@ -35,29 +35,47 @@ module Plutus
       before {
         entry.credit_amounts << FactoryGirl.build(:credit_amount, entry: entry)
       }
-      it { should_not be_valid }
+      it { is_expected.not_to be_valid }
 
       context "with an invalid debit" do
         before {
           entry.debit_amounts << FactoryGirl.build(:debit_amount, entry: entry, amount: nil)
         }
-        it { should_not be_valid }
+        it { is_expected.not_to be_valid }
+      end
+    end
+
+    context "without a date" do
+      let(:entry) { FactoryGirl.build(:entry_with_credit_and_debit, date: nil) }
+
+      context "should assign a default date before being saved" do
+        before { entry.save! }
+        its(:date) { is_expected.to eq(Time.now.to_date) }
       end
     end
 
     it "should require the debit and credit amounts to cancel" do
       entry.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100, :entry => entry)
       entry.debit_amounts << FactoryGirl.build(:debit_amount, :amount => 200, :entry => entry)
-      entry.should_not be_valid
-      entry.errors['base'].should == ["The credit and debit amounts are not equal"]
+      expect(entry).not_to be_valid
+      expect(entry.errors['base']).to eq(["The credit and debit amounts are not equal"])
     end
 
     it "should require the debit and credit amounts to cancel even with fractions" do
       entry = FactoryGirl.build(:entry)
       entry.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100.1, :entry => entry)
       entry.debit_amounts << FactoryGirl.build(:debit_amount, :amount => 100.2, :entry => entry)
-      entry.should_not be_valid
-      entry.errors['base'].should == ["The credit and debit amounts are not equal"]
+      expect(entry).not_to be_valid
+      expect(entry.errors['base']).to eq(["The credit and debit amounts are not equal"])
+    end
+
+    it "should ignore debit and credit amounts marked for destruction to cancel" do
+      entry.credit_amounts << FactoryGirl.build(:credit_amount, :amount => 100, :entry => entry)
+      debit_amount = FactoryGirl.build(:debit_amount, :amount => 100, :entry => entry)
+      debit_amount.mark_for_destruction
+      entry.debit_amounts << debit_amount
+      expect(entry).not_to be_valid
+      expect(entry.errors['base']).to eq(["The credit and debit amounts are not equal"])
     end
 
     it "should have a polymorphic commercial document associations" do
@@ -65,7 +83,7 @@ module Plutus
       entry = FactoryGirl.build(:entry_with_credit_and_debit, commercial_document: mock_document)
       entry.save!
       saved_entry = Entry.find(entry.id)
-      saved_entry.commercial_document.should == mock_document
+      expect(saved_entry.commercial_document).to eq(mock_document)
     end
 
     context "given a set of accounts" do
@@ -75,13 +93,13 @@ module Plutus
       let!(:sales_tax_payable) { FactoryGirl.create(:liability, name: "Sales Tax Payable") }
 
       shared_examples_for 'a built-from-hash Plutus::Entry' do
-        its(:credit_amounts) { should_not be_empty }
-        its(:debit_amounts) { should_not be_empty }
-        it { should be_valid }
+        its(:credit_amounts) { is_expected.not_to be_empty }
+        its(:debit_amounts) { is_expected.not_to be_empty }
+        it { is_expected.to be_valid }
 
         context "when saved" do
           before { entry.save! }
-          its(:id) { should_not be_nil }
+          its(:id) { is_expected.not_to be_nil }
 
           context "when reloaded" do
             let(:saved_transaction) { Entry.find(entry.id) }
@@ -126,31 +144,6 @@ module Plutus
           }
           include_examples 'a built-from-hash Plutus::Entry'
         end
-
-        context "when given a credit/debits hash with :account => String" do
-          let(:hash) {
-            {
-                description: "Sold some widgets",
-                commercial_document: mock_document,
-                debits: [{account: accounts_receivable.name, amount: 50}],
-                credits: [
-                    {account: sales_revenue.name, amount: 45},
-                    {account: sales_tax_payable.name, amount: 5}
-                ]
-            }
-          }
-
-          before { ::ActiveSupport::Deprecation.silenced = true }
-          after { ::ActiveSupport::Deprecation.silenced = false }
-
-          it("should be deprecated") {
-            # one deprecation per account looked up
-            ::ActiveSupport::Deprecation.should_receive(:warn).exactly(3).times
-            entry
-          }
-
-          include_examples 'a built-from-hash Plutus::Entry'
-        end
       end
 
       describe ".build" do
@@ -165,32 +158,11 @@ module Plutus
 
           it("should be deprecated") {
             # .build is the only thing deprecated
-            ::ActiveSupport::Deprecation.should_receive(:warn).once
+            expect(::ActiveSupport::Deprecation).to receive(:warn).once
             entry
           }
         end
 
-        context "when given a credit/debits hash with :account => String" do
-          let(:hash) {
-            {
-                description: "Sold some widgets",
-                commercial_document: mock_document,
-                debits: [{account: accounts_receivable.name, amount: 50}],
-                credits: [
-                    {account: sales_revenue.name, amount: 45},
-                    {account: sales_tax_payable.name, amount: 5}
-                ]
-            }
-          }
-
-          it("should be deprecated") {
-            # one deprecation for build, plus three for accounts as strings
-            ::ActiveSupport::Deprecation.should_receive(:warn).exactly(4).times
-            entry
-          }
-
-          include_examples 'a built-from-hash Plutus::Entry'
-        end
       end
     end