plutus 0.10.1 → 0.15

data/spec/models/account_spec.rb

@@ -4,30 +4,36 @@ module Plutus
   describe Account do
     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
         before {
           # credit accounts
@@ -57,14 +63,71 @@ module Plutus
           da5 = FactoryGirl.build(:debit_amount, :account => contra_revenue, :amount => 333)
 
           FactoryGirl.create(:entry, :credit_amounts => [ca1], :debit_amounts => [da1])
-          FactoryGirl.create(:entry, :credit_amounts => [ca2], :debit_amounts => [da2]) 
+          FactoryGirl.create(:entry, :credit_amounts => [ca2], :debit_amounts => [da2])
           FactoryGirl.create(:entry, :credit_amounts => [ca3], :debit_amounts => [da3])
           FactoryGirl.create(:entry, :credit_amounts => [ca4], :debit_amounts => [da4])
           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/debit_amount_spec.rb

@@ -4,4 +4,4 @@ module Plutus
   describe DebitAmount do
     it_behaves_like 'a Plutus::Amount subtype', kind: :debit_amount
   end
-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,26 +83,87 @@ 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
 
-    it "should allow building an entry and credit and debits with a hash" do
-      FactoryGirl.create(:asset, name: "Accounts Receivable")
-      FactoryGirl.create(:revenue, name: "Sales Revenue")
-      FactoryGirl.create(:liability, name: "Sales Tax Payable")
-      mock_document = FactoryGirl.create(:asset)
-      entry = Entry.build(
-        description: "Sold some widgets",
-        commercial_document: mock_document,
-        debits: [
-          {account: "Accounts Receivable", amount: 50}], 
-        credits: [
-          {account: "Sales Revenue", amount: 45},
-          {account: "Sales Tax Payable", amount: 5}])
-      entry.save!
+    context "given a set of accounts" do
+      let(:mock_document) { FactoryGirl.create(:asset) }
+      let!(:accounts_receivable) { FactoryGirl.create(:asset, name: "Accounts Receivable") }
+      let!(:sales_revenue) { FactoryGirl.create(:revenue, name: "Sales Revenue") }
+      let!(:sales_tax_payable) { FactoryGirl.create(:liability, name: "Sales Tax Payable") }
 
-      saved_entry = Entry.find(entry.id)
-      saved_entry.commercial_document.should == mock_document
+      shared_examples_for 'a built-from-hash Plutus::Entry' do
+        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) { is_expected.not_to be_nil }
+
+          context "when reloaded" do
+            let(:saved_transaction) { Entry.find(entry.id) }
+            subject { saved_transaction }
+            it("should have the correct commercial document") {
+              saved_transaction.commercial_document == mock_document
+            }
+          end
+        end
+      end
+
+      describe ".new" do
+        let(:entry) { Entry.new(hash) }
+        subject { entry }
+
+        context "when given a credit/debits hash with :account => Account" do
+          let(:hash) {
+            {
+                description: "Sold some widgets",
+                commercial_document: mock_document,
+                debits: [{account: accounts_receivable, amount: 50}],
+                credits: [
+                    {account: sales_revenue, amount: 45},
+                    {account: sales_tax_payable, amount: 5}
+                ]
+            }
+          }
+          include_examples 'a built-from-hash Plutus::Entry'
+        end
+
+        context "when given a credit/debits hash with :account_name => String" do
+          let(:hash) {
+            {
+                description: "Sold some widgets",
+                commercial_document: mock_document,
+                debits: [{account_name: accounts_receivable.name, amount: 50}],
+                credits: [
+                    {account_name: sales_revenue.name, amount: 45},
+                    {account_name: sales_tax_payable.name, amount: 5}
+                ]
+            }
+          }
+          include_examples 'a built-from-hash Plutus::Entry'
+        end
+      end
+
+      describe ".build" do
+        let(:entry) { Entry.build(hash) }
+        subject { entry }
+
+        before { ::ActiveSupport::Deprecation.silenced = true }
+        after { ::ActiveSupport::Deprecation.silenced = false }
+
+        context "when used at all" do
+          let(:hash) { Hash.new }
+
+          it("should be deprecated") {
+            # .build is the only thing deprecated
+            expect(::ActiveSupport::Deprecation).to receive(:warn).once
+            entry
+          }
+        end
+
+      end
     end
 
   end

data/spec/models/tenancy_spec.rb

@@ -3,12 +3,27 @@ require 'spec_helper'
 module Plutus
   describe Account do
     describe 'tenancy support' do
+
+      before(:all) do
+				m = ActiveRecord::Migration.new
+				m.verbose = false
+				m.create_table :plutus_tenants do |t|
+					t.string :name
+				end
+      end
+
+			after :all do
+				m = ActiveRecord::Migration.new
+				m.verbose = false
+				m.drop_table :plutus_tenants
+			end
+
       before(:each) do
         ActiveSupportHelpers.clear_model('Account')
         ActiveSupportHelpers.clear_model('Asset')
 
         Plutus.enable_tenancy = true
-        Plutus.tenant_class = 'Plutus::Entry'
+        Plutus.tenant_class = 'Plutus::Tenant'
 
         FactoryGirlHelpers.reload()
         Plutus::Asset.new
@@ -27,18 +42,21 @@ module Plutus
       end
 
       it 'validate uniqueness of name scoped to tenant' do
-        account = FactoryGirl.create(:asset, tenant_id: 10)
+        tenant = FactoryGirl.create(:tenant)
+        account = FactoryGirl.create(:asset, tenant: tenant)
 
-        record = FactoryGirl.build(:asset, name: account.name, tenant_id: 10)
-        record.should_not be_valid
-        record.errors[:name].should == ['has already been taken']
+        record = FactoryGirl.build(:asset, name: account.name, tenant: tenant)
+        expect(record).not_to be_valid
+        expect(record.errors[:name]).to eq(['has already been taken'])
       end
 
       it 'allows same name scoped under a different tenant' do
-        account = FactoryGirl.create(:asset, tenant_id: 10)
+        tenant_1 = FactoryGirl.create(:tenant)
+        tenant_2 = FactoryGirl.create(:tenant)
+        account = FactoryGirl.create(:asset, tenant: tenant_1)
 
-        record = FactoryGirl.build(:asset, name: account.name, tenant_id: 11)
-        record.should be_valid
+        record = FactoryGirl.build(:asset, name: account.name, tenant: tenant_2)
+        expect(record).to be_valid
       end
     end
   end

data/spec/routing/accounts_routing_spec.rb

@@ -2,31 +2,12 @@ require 'spec_helper'
 
 module Plutus
   describe AccountsController do
-    # Run these tests if you enable routing in your rails app. See README 
-    #describe "routing" do
-      #it "recognizes and generates #index" do
-        #{ :get => "/accounts" }.should route_to(:controller => "accounts", :action => "index")
-      #end
+    routes { Plutus::Engine.routes }
 
-      #it "recognizes and generates #show" do
-        #{ :get => "/accounts/1" }.should route_to(:controller => "accounts", :action => "show", :id => "1")
-      #end
-
-      #it "recognizes and generates #edit" do
-        #{ :get => "/accounts/1/edit" }.should_not be_routable
-      #end
-
-      #it "recognizes and generates #create" do
-        #{ :post => "/accounts" }.should_not be_routable
-      #end
-
-      #it "recognizes and generates #update" do
-        #{ :put => "/accounts/1" }.should_not be_routable
-      #end
-
-      #it "recognizes and generates #destroy" do
-        #{ :delete => "/accounts/1" }.should_not be_routable
-      #end
-    #end
+    describe "routing" do
+      it "recognizes and generates #index" do
+        expect(:get => "/accounts").to route_to(:controller => "plutus/accounts", :action => "index")
+      end
+    end
   end
 end

data/spec/routing/entries_routing_spec.rb

@@ -2,31 +2,12 @@ require 'spec_helper'
 
 module Plutus
   describe EntriesController do
-    # Run these tests if you enable routing in your rails app. See README 
-    #describe "routing" do
-      #it "recognizes and generates #index" do
-        #{ :get => "/entries" }.should route_to(:controller => "entries", :action => "index")
-      #end
+    routes { Plutus::Engine.routes }
 
-      #it "recognizes and generates #show" do
-        #{ :get => "/entries/1" }.should route_to(:controller => "entries", :action => "show", :id => "1")
-      #end
-
-      #it "recognizes and generates #edit" do
-        #{ :get => "/entries/1/edit" }.should_not be_routable
-      #end
-
-      #it "recognizes and generates #create" do
-        #{ :post => "/entries" }.should_not be_routable
-      #end
-
-      #it "recognizes and generates #update" do
-        #{ :put => "/entries/1" }.should_not be_routable
-      #end
-
-      #it "recognizes and generates #destroy" do
-        #{ :delete => "/entries/1" }.should_not be_routable
-      #end
-    #end
+    describe "routing" do
+      it "recognizes and generates #index" do
+        expect(:get => "/entries").to route_to(:controller => "plutus/entries", :action => "index")
+      end
+    end
   end
 end