double_double 0.1.0 → 0.2.0

data/README.md

@@ -3,10 +3,12 @@
 [![Dependency Status](https://gemnasium.com/crftr/double_double.png)](https://gemnasium.com/crftr/double_double)
 [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/crftr/double_double)
 
-A double-entry accounting system.  Likely to change heavily in the coming days.
+A double-entry accrual accounting system for your application. Currency-agnostic but uses the Money gem. Account holder support and contexts are built-in.
 
 ## Installation
 
+### Gem
+
 Add this line to your application's Gemfile:
 
     gem 'double_double'
@@ -19,22 +21,181 @@ Or install it yourself as:
 
     $ gem install double_double
 
-## Usage
+### Database structure
+
+Create the expected database structure.  If using Rails, generate a migration:
+
+    $ rails generate migration CreateDoubleDouble
+
+Edit the migration to match:
+
+```ruby
+class CreateDoubleDouble < ActiveRecord::Migration
+  def change
+    create_table :double_double_accounts do |t|
+      t.string  :name,          null: false
+      t.integer :number,        null: false
+      t.string  :type,          null: false
+      t.boolean :contra,        default: false
+    end
+    add_index :double_double_accounts, [:name, :type]
+
+    create_table :double_double_transactions do |t|
+      t.string :description
+      t.references :transaction_type
+      t.timestamps
+    end
+    add_index :double_double_transactions, :transaction_type_id
 
-TODO: Write usage instructions here
+    create_table :double_double_transaction_types do |t|
+      t.integer :number,        null: false
+      t.string :description,    null: false
+    end
+    add_index :double_double_transaction_types, :number
 
-## Name
+    create_table :double_double_amounts do |t|
+      t.string :type
+      t.references :account
+      t.references :transaction
+      t.references :accountee,  polymorphic: true
+      t.references :context,    polymorphic: true
+      t.references :initiator,  polymorphic: true
+      t.integer :amount_cents, limit: 8, default: 0, null: false
+      t.string  :currency
+    end
+    add_index :double_double_amounts, :context_id
+    add_index :double_double_amounts, :context_type
+    add_index :double_double_amounts, :initiator_id
+    add_index :double_double_amounts, :initiator_type
+    add_index :double_double_amounts, :accountee_id
+    add_index :double_double_amounts, :accountee_type
+    add_index :double_double_amounts, :type
+    add_index :double_double_amounts, [:account_id, :transaction_id]
+    add_index :double_double_amounts, [:transaction_id, :account_id]
+  end
+end
+```
+
+Rake the new migration
+
+    $ rake db:migrate
+
+## Overview
+
+[Double-entry accounting][1] practices have been [traced back to the 13th century][2].  double_double strives to make accepted practices accessible and relatively easy to implement within other applications.
+
+[1]: http://en.wikipedia.org/wiki/Double-entry_bookkeeping_system
+[2]: http://en.wikipedia.org/wiki/Double-entry_bookkeeping_system#History
+
+As with many off-the-shelf accounting systems, this project supports:
+* **Accountee**: an account holder.
+* **Context**: to track activity on invoices, purchase orders, jobs, campaigns, etc.
+* **Initiator**: *who* authorized or performed the action.
+
+### Accounts
+
+All accounts created in a double-entry system make up the [chart of accounts][3].  This collection of accounts will determine how money is tracked as it moves through the system.  It is important to design and create the chart of accounts prior to creating transactions.  *If we want people to hold "an individual account" in this system, we will configure them as an accountee, not with a new account.  __See the section on accountees__ *
+
+[3]: http://en.wikipedia.org/wiki/Chart_of_accounts
+
+In double_double, all accounts created are considered to be the chart of accounts.  All accounts are "on the books."
+
+**Account Class**         | **Normal Balance** | **Description**                                    | **Example Uses**
+------------------------- | ------------------ | -------------------------------------------------- | -------------------------------------------
+`DoubleDouble::Asset`     | Debit              | Resources owned or controlled                      | Cash, Office Computers, Grandma's Jewelry
+`DoubleDouble::Liability` | Credit             | Obligations                                        | Accounts Payable, Bank Loan
+`DoubleDouble::Equity`    | Credit             | The claim to assets after all liabilities are paid | Paid-In Capital, Dividends, Retained Earnings
+`DoubleDouble::Revenue`   | Credit             | Income                                             | Sales, Interest Earned
+`DoubleDouble::Expense`   | Debit              | Expenditures                                       | Utilities, Salaries, Rent, Taco Tuesday
+
+Accounts have the following attributes:
+
+* **name**
+* **number**, for reporting purposes
+* **contra** flag, _optional_ `default: false`
+
+An example 'Cash' asset account as account number `20`
+
+```ruby
+DoubleDouble::Asset.create! name: 'Cash', number: 20
+```
+
+An example 'Sales' revenue account and a 'Discounts' contra revenue account.
+
+```ruby
+DoubleDouble::Revenue.create! name: 'Sales',     number: 40
+DoubleDouble::Revenue.create! name: 'Discounts', number: 50, contra: true
+```
+
+Contra accounts are used to offset a related account of the same class.  *The example above is a common method to track sales.  The full __sales value__ of the sale would be assigned to 'Sales' while any discounts given would be assigned to 'Discounts.'*
+
+
+### Amounts & Transactions
+
+* TODO: Transaction basics
+* TODO: Amount basics
+* TODO: Accountees
+* TODO: Contexts
+* TODO: Initiated_by
+
+## Example Scenarios
+
+### Basic Scenarios
+
+#### Basic Scenario: We are creating a personal application to only track loan payments back to Grandpa.  
+
+We've decided to keep things very simple and only create two accounts:
+* 'Cash' an asset account.
+* 'Grandpa Loan' a liability account.
+
+```ruby
+DoubleDouble::Asset.create! name:'Cash', number: 11
+DoubleDouble::Liability.create! name:'Grandpa Loan', number: 12
+```
+Grandpa was kind enough to loan us $800 USD in cash for college textbooks.  To enter this we will require a transaction which will affect both 'Cash' and 'Grandpa Loan'
+```ruby
+DoubleDouble::Transaction.create!(
+  description: 
+    'We received a loan from Grandpa',
+  debits:[
+    {account: 'Cash', amount: '$800'}],
+  credits:[
+    {account: 'Grandpa Loan', amount: '$800'}])
+```
+But because we were surprised to have the option to buy a few used textbooks we can return some of Grandpa's loan.  We will return $320.
+```ruby
+DoubleDouble::Transaction.create!(
+  description: 
+    'Payed back $320 to Grandpa',
+  debits:[
+    {account: 'Grandpa Loan', amount: '$320'}],
+  credits:[
+    {account: 'Cash', amount: '$320'}])
+```
+If we want to know how much we still owed Grandpa we can look at the balance of the account.
+```ruby
+DoubleDouble::Account.find_by_name('Grandpa Loan').balance.to_s    # => "480.00"
+```
 
-The double double is the flagship In-N-Out cheeseburger.  Ask a southern-Californian.
+### Realistic Scenarios
+* TODO: Write a realistic scenario
+
+### Complex Scenarios
+* TODO: Write a realistic & complex scenario
+
+## Tests
+
+All code is backed by Rspec tests.  Clone this repository and either `rspec spec` or `rake spec` if Rake is installed.
 
 ## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
+3. Commit your changes & tests (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
 ## Notes
 
-double_double was heavily influenced by mbulat's plutus project and regularly working with quickbooks.
+double_double was influenced by mbulat's plutus project and regularly working with quickbooks.
+

data/double_double.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.add_dependency('money', '~> 5.1')
-  gem.add_dependency 'activerecord', '~> 3.2.11'
+  gem.add_dependency('activerecord', '~> 3.2.11')
   gem.add_development_dependency('sqlite3')
   gem.add_development_dependency('rspec', '~> 2.12')
   gem.add_development_dependency('factory_girl')

data/lib/double_double/account.rb

@@ -40,14 +40,14 @@ module DoubleDouble
 
     validates_presence_of :type, :name, :number
     validates_uniqueness_of :name, :number
+    validates_length_of :name, :minimum => 1
 
     def side_balance(is_debit, hash)
-      hash_keys = hash.keys
       a = is_debit ? DoubleDouble::DebitAmount.scoped : DoubleDouble::CreditAmount.scoped
       a = a.where(account_id: self.id)
-      a = a.by_context(hash[:context_id], hash[:context_type])       if (hash_keys & [:context_id, :context_type]).count == 2
-      a = a.by_initiator(hash[:initiator_id], hash[:initiator_type]) if (hash_keys & [:initiator_id, :initiator_type]).count == 2
-      a = a.by_accountee(hash[:accountee_id], hash[:accountee_type]) if (hash_keys & [:accountee_id, :accountee_type]).count == 2
+      a = a.by_context(hash[:context])     if hash.has_key? :context
+      a = a.by_initiator(hash[:initiator]) if hash.has_key? :initiator
+      a = a.by_accountee(hash[:accountee]) if hash.has_key? :accountee
       Money.new(a.sum(:amount_cents))
     end
     
@@ -64,12 +64,12 @@ module DoubleDouble
     #
     # @return [Money] The value balance of all accounts
     def self.trial_balance
-      raise(NoMethodError, "undefined method 'trial_balance'") unless self.new.class == DoubleDouble::Account
+      raise(NoMethodError, "undefined method 'trial_balance'") unless self == DoubleDouble::Account
       Asset.balance - (Liability.balance + Equity.balance + Revenue.balance - Expense.balance)
     end
     
     def self.balance
-      raise(NoMethodError, "undefined method 'balance'") if self.new.class == DoubleDouble::Account
+      raise(NoMethodError, "undefined method 'balance'") if self == DoubleDouble::Account
       accounts_balance = Money.new(0)
       accounts = self.all
       accounts.each do |acct|
@@ -83,17 +83,20 @@ module DoubleDouble
     end
 
     protected
-      # Left Side Accounts:
+      # The balance method that derived Accounts utilize.
+      #
+      # Nornal Debit Accounts:
       # if contra { credits_balance(hash) - debits_balance(hash)  }
       # else      { debits_balance(hash)  - credits_balance(hash) }
       #
-      # Right Side Accounts:
+      # Normal Credit Accounts:
       # if contra { debits_balance(hash)  - credits_balance(hash) }
       # else      { credits_balance(hash) - debits_balance(hash)  }
       #
       # @return [Money] The balance of the account instance
-      def child_account_balance(is_left_side_account, hash = {})
-        if (is_left_side_account && contra) || !(is_left_side_account || contra)
+      def child_account_balance(is_normal_debit_account, hash = {})
+        raise(NoMethodError, "undefined method 'balance'") if self == DoubleDouble::Account
+        if (is_normal_debit_account && contra) || !(is_normal_debit_account || contra)
           credits_balance(hash) - debits_balance(hash)
         else
           debits_balance(hash) - credits_balance(hash)

data/lib/double_double/amount.rb

@@ -7,21 +7,22 @@ module DoubleDouble
   class Amount < ActiveRecord::Base
     self.table_name = 'double_double_amounts'
 
-    attr_accessible :account, :amount, :transaction, :context, :initiator, :accountee
+    attr_accessible :account, :amount, :transaction, :context, :initiator, :accountee, as: :transation_builder
     
     belongs_to :transaction
     belongs_to :account
+    belongs_to :accountee,  polymorphic: true
     belongs_to :context,    polymorphic: true
     belongs_to :initiator,  polymorphic: true
-    belongs_to :accountee,  polymorphic: true
     
-    scope :by_context,   ->(c_id, c_base_class) { where(context_id:   c_id, context_type:   c_base_class) }
-    scope :by_initiator, ->(i_id, i_base_class) { where(initiator_id: i_id, initiator_type: i_base_class) }
-    scope :by_accountee, ->(a_id, a_base_class) { where(accountee_id: a_id, accountee_type: a_base_class) }
+    scope :by_accountee, ->(a) { where(accountee_id: a.id, accountee_type: a.class.base_class) }
+    scope :by_context,   ->(c) { where(context_id:   c.id, context_type:   c.class.base_class) }
+    scope :by_initiator, ->(i) { where(initiator_id: i.id, initiator_type: i.class.base_class) }
 
     # scope :by_transaction_type_number, -> {|tt_num| where( transaction: {transaction_type: {number: tt_num}})}
 
-    validates_presence_of :type, :amount_cents, :transaction, :account
+    validates_presence_of :type, :transaction, :account
+    validates :amount_cents, numericality: {greater_than: 0}
     
     composed_of :amount,
       class_name: "Money",

data/lib/double_double/asset.rb

@@ -6,6 +6,6 @@ module DoubleDouble
   #
   # @see http://en.wikipedia.org/wiki/Asset Assets
   #
-  class Asset < LeftSideAccount
+  class Asset < NormalDebitAccount
   end
 end

data/lib/double_double/equity.rb

@@ -6,6 +6,6 @@ module DoubleDouble
   #
   # @see http://en.wikipedia.org/wiki/Equity_(finance) Equity
   #
-  class Equity < RightSideAccount
+  class Equity < NormalCreditAccount
   end
 end

data/lib/double_double/expense.rb

@@ -6,6 +6,6 @@ module DoubleDouble
   #
   # @see http://en.wikipedia.org/wiki/Expense Expenses
   #
-  class Expense < LeftSideAccount
+  class Expense < NormalDebitAccount
   end
 end

data/lib/double_double/liability.rb

@@ -6,6 +6,6 @@ module DoubleDouble
   #
   # @see http://en.wikipedia.org/wiki/Liability_(financial_accounting) Liability
   #
-  class Liability < RightSideAccount
+  class Liability < NormalCreditAccount
   end
 end

data/lib/double_double/{right_side_account.rb → normal_credit_account.rb}

@@ -1,5 +1,5 @@
 module DoubleDouble
-  class RightSideAccount < Account
+  class NormalCreditAccount < Account
     def balance(hash = {})
       child_account_balance(false, hash)
     end

data/lib/double_double/{left_side_account.rb → normal_debit_account.rb}

@@ -1,5 +1,5 @@
 module DoubleDouble
-  class LeftSideAccount < Account
+  class NormalDebitAccount < Account
     def balance(hash = {})
       child_account_balance(true, hash)
     end

data/lib/double_double/revenue.rb

@@ -6,6 +6,6 @@ module DoubleDouble
   #
   # @see http://en.wikipedia.org/wiki/Revenue Revenue
   #
-  class Revenue < RightSideAccount
+  class Revenue < NormalCreditAccount
   end
 end

data/lib/double_double/transaction.rb

@@ -29,8 +29,8 @@ module DoubleDouble
 
     has_many :credit_amounts
     has_many :debit_amounts
-    has_many :credit_accounts, :through => :credit_amounts, :source => :account
-    has_many :debit_accounts,  :through => :debit_amounts,  :source => :account
+    has_many :credit_accounts, through: :credit_amounts, source: :account
+    has_many :debit_accounts,  through: :debit_amounts,  source: :account
 
     validates_presence_of :description
     validate :has_credit_amounts?
@@ -45,27 +45,31 @@ module DoubleDouble
     #   transaction = DoubleDouble::Transaction.build(
     #     description: "Sold some widgets",
     #     debits: [
-    #       {account: "Accounts Receivable", amount: 50}], 
+    #       {account: "Accounts Receivable", amount: 50, context_id: 20, context_type: 'Job'}], 
     #     credits: [
-    #       {account: "Sales Revenue", amount: 45},
-    #       {account: "Sales Tax Payable", amount: 5}])
+    #       {account: "Sales Revenue",       amount: 45},
+    #       {account: "Sales Tax Payable",   amount:  5}])
     #
     # @return [DoubleDouble::Transaction] A Transaction with built credit and debit objects ready for saving
-    def self.build(hash)
-      t = Transaction.new(description: hash[:description])
-      hash[:debits].each do |debit|
-        new_debit_amount = prepare_amount_parameters debit.merge!({transaction: t})
-        t.debit_amounts << DebitAmount.new(new_debit_amount)
-      end
-      hash[:credits].each do |credit|
-        new_credit_amount = prepare_amount_parameters credit.merge!({transaction: t})
-        t.credit_amounts << CreditAmount.new(new_credit_amount)
-      end
-      t.transaction_type = hash[:transaction_type] if hash.has_key?(:transaction_type)
+    def self.build args
+      t = Transaction.new()
+      t.description      = args[:description]
+      t.transaction_type = args[:transaction_type] if args.has_key? :transaction_type
+
+      add_amounts_to_transaction(args[:debits],  t, true) 
+      add_amounts_to_transaction(args[:credits], t, false)
       t
     end
 
+    def self.create! args
+      t = build args
+      t.save!
+    end
+
     private
+
+      # Validation
+      
       def has_credit_amounts?
         errors[:base] << "Transaction must have at least one credit amount" if self.credit_amounts.blank?
       end
@@ -84,21 +88,24 @@ module DoubleDouble
         credit_amount_total - debit_amount_total
       end
 
-      def self.prepare_amount_parameters args
-        prepared_params = { account: Account.find_by_name(args[:account]), transaction: args[:transaction], amount: args[:amount]}
-        
-        args_keys = args.keys
-        if (args_keys & [:context_id, :context_type]).count == 2
-          prepared_params.merge!({context_id: args[:context_id], context_type: args[:context_type]})
-        end
-        
-        if (args_keys & [:initiator_id, :initiator_type]).count == 2
-          prepared_params.merge!({initiator_id: args[:initiator_id], initiator_type: args[:initiator_type]})
-        end
+      # Assist transaction building
 
-        if (args_keys & [:accountee_id, :accountee_type]).count == 2
-          prepared_params.merge!({accountee_id: args[:accountee_id], accountee_type: args[:accountee_type]})
+      def self.add_amounts_to_transaction amounts, transaction, add_to_debits = true
+        return if amounts.nil? || amounts.count == 0
+        amounts.each do |amt|
+          amount_parameters = prepare_amount_parameters amt.merge!({transaction: transaction})
+          new_amount = add_to_debits ? DebitAmount.new : CreditAmount.new
+          new_amount.assign_attributes(amount_parameters, as: :transation_builder)
+          transaction.debit_amounts << new_amount  if add_to_debits
+          transaction.credit_amounts << new_amount unless add_to_debits
         end
+      end
+
+      def self.prepare_amount_parameters args
+        prepared_params = { account: Account.find_by_name(args[:account]), transaction: args[:transaction], amount: args[:amount]}
+        prepared_params.merge!({accountee: args[:accountee]}) if args.has_key? :accountee
+        prepared_params.merge!({context:   args[:context]})   if args.has_key? :context
+        prepared_params.merge!({initiator: args[:initiator]}) if args.has_key? :initiator
         prepared_params
       end
   end

data/lib/double_double/version.rb

@@ -1,3 +1,3 @@
 module DoubleDouble
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/double_double.rb

@@ -5,8 +5,8 @@ require 'double_double/version'
 
 # Accounts
 require 'double_double/account'
-require 'double_double/left_side_account'
-require 'double_double/right_side_account'
+require 'double_double/normal_credit_account'
+require 'double_double/normal_debit_account'
 require 'double_double/asset'
 require 'double_double/equity'
 require 'double_double/expense'

data/spec/models/account_spec.rb

@@ -2,26 +2,26 @@ module DoubleDouble
   describe Account do
 
     it "should not allow creating an account without a subtype" do
-      account = FactoryGirl.build(:account)
+      account = DoubleDouble::Account.new(name: 'Cash', number: 10)
       account.should_not be_valid
     end
 
     it "should be unique per name" do
-      FactoryGirl.create(:asset, :name => "Test1")
-      account = FactoryGirl.build(:asset, :name => "Test1")
+      DoubleDouble::Asset.new(name: 'Petty Cash', number: 10).save
+      account = DoubleDouble::Liability.new(name: 'Petty Cash', number: 11)
       account.should_not be_valid
       account.errors[:name].should == ["has already been taken"]
     end
     
     it "should be unique per number" do
-      FactoryGirl.create(:asset, :number => 88)
-      account = FactoryGirl.build(:asset, :number => 88)
+      DoubleDouble::Asset.new(name: 'Cash', number: 22).save
+      account = DoubleDouble::Liability.new(name: 'Loan', number: 22)
       account.should_not be_valid
       account.errors[:number].should == ["has already been taken"]
     end
 
     it "should not have a balance method" do
-      lambda{Account.balance}.should raise_error(NoMethodError)
+      -> {Account.balance}.should raise_error(NoMethodError)
     end
 
     it "should have a trial balance" do
@@ -31,39 +31,37 @@ module DoubleDouble
 
     it "should report a trial balance of 0 with correct transactions (with a contrived example of transactions)" do
       # credit accounts
-      liability      = FactoryGirl.create(:liability)
-      equity         = FactoryGirl.create(:equity)
-      revenue        = FactoryGirl.create(:revenue)
-      contra_asset   = FactoryGirl.create(:asset, :contra => true)
-      contra_expense = FactoryGirl.create(:expense, :contra => true)
+      FactoryGirl.create(:liability, name: 'liability acct')
+      FactoryGirl.create(:equity,    name: 'equity acct')
+      FactoryGirl.create(:revenue,   name: 'revenue acct')
+      FactoryGirl.create(:asset,     name: 'contra asset acct',   :contra => true)
+      FactoryGirl.create(:expense,   name: 'contra expense acct', :contra => true)
       # debit accounts
-      asset            = FactoryGirl.create(:asset)
-      expense          = FactoryGirl.create(:expense)
-      contra_liability = FactoryGirl.create(:liability, :contra => true)
-      contra_equity    = FactoryGirl.create(:equity, :contra => true)
-      contra_revenue   = FactoryGirl.create(:revenue, :contra => true)
-
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 100_000, account: liability)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 100_000, account: asset)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 1_000, account: equity)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 1_000, account: expense)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 40_404, account: revenue)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 40_404, account: contra_liability)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 2, account: contra_asset)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 2, account: contra_equity)
-      t.save
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 333, account: contra_expense)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 333, account: contra_revenue)
-      t.save
-
+      FactoryGirl.create(:asset,     name: 'asset acct')
+      FactoryGirl.create(:expense,   name: 'expense acct')
+      FactoryGirl.create(:liability, name: 'contra liability acct', :contra => true)
+      FactoryGirl.create(:equity,    name: 'contra equity acct',    :contra => true)
+      FactoryGirl.create(:revenue,   name: 'contra revenue acct',   :contra => true)
+      Transaction.create!(
+        description: 'spec transaction 01',
+        debits:  [{account: 'liability acct', amount: 100_000}],
+        credits: [{account: 'asset acct',     amount: 100_000}])
+      Transaction.create!(
+        description: 'spec transaction 02',
+        debits:  [{account: 'equity acct',  amount: 1_000}],
+        credits: [{account: 'expense acct', amount: 1_000}])
+      Transaction.create!(
+        description: 'spec transaction 03',
+        debits:  [{account: 'revenue acct',          amount: 40_404}],
+        credits: [{account: 'contra liability acct', amount: 40_404}])
+      Transaction.create!(
+        description: 'spec transaction 04',
+        debits:  [{account: 'contra asset acct',  amount: 2}], 
+        credits: [{account: 'contra equity acct', amount: 2}])
+      Transaction.create!(
+        description: 'spec transaction 05',
+        debits:  [{account: 'contra expense acct', amount: 333}], 
+        credits: [{account: 'contra revenue acct', amount: 333}])
       Account.trial_balance.should == 0
     end
   end

data/spec/models/amount_spec.rb

@@ -2,7 +2,8 @@ module DoubleDouble
   describe Amount do
 
     it "should not allow creating an amount without a subtype" do
-      amount = FactoryGirl.build(:amount)
+      cash = DoubleDouble::Asset.create!(name:'Cash', number: 11)
+      amount = DoubleDouble::Amount.new(amount: 50, account: cash)
       amount.should_not be_valid
     end
   end

data/spec/models/asset_spec.rb

@@ -5,8 +5,13 @@ module DoubleDouble
       let(:account_type) {:asset}
     end
 
-    it_behaves_like "a left side account type" do
-      let(:left_side_account_type) {:asset}
+    it_behaves_like "a normal debit account type" do
+      let(:normal_debit_account_type) {:asset}
+    end
+
+    it "should create a proper Asset account" do
+      -> { DoubleDouble::Asset.create! name: 'Asset acct', number: 20
+      }.should change(DoubleDouble::Asset, :count).by(1)
     end
   end
 end