subledger 0.7.7

data/spec/subledger_journal_entry_spec.rb

@@ -0,0 +1,417 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory   ) { Subledger::Factory.create }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'JournalEntry' do
+
+      # POST /books/:book_id/journal_entries
+      RespondsTo 'journal_entry.create' do
+        ByReturning 'an instance of Subledger::Domain::ActiveJournalEntry' do
+          subject.journal_entry.create( factory.journal_entry_args ).
+                     must_be_instance_of Subledger::Domain::ActiveJournalEntry
+        end
+      end
+
+      # GET /books/:book_id/journal_entries/:id
+      [ :archived, :active, :posting, :posted ].each do |state|
+        RespondsTo 'journal_entry.read' do
+          let(:journal_entry) { factory.create_journal_entry state }
+
+          ByReturning "an instance of #{state} journal entry" do
+            subject.journal_entry.read( :id => journal_entry.id ).
+                       must_be_instance_of journal_entry.class
+          end
+        end
+      end
+
+      # PATCH /books/:book_id/journal_entries/:id
+      [ :archived, :active ].each do |state|
+        RespondsTo 'journal_entries.update' do
+          let(:je         ) { factory.create_journal_entry state }
+          let(:args       ) { je.attributes }
+          let(:description) { 'updated description' }
+          let(:update_args) { args.merge :description => description,
+                                         :version     => 2 }
+
+          ByReturning "an instance of #{state} journal entry" do
+            patched = subject.journal_entries.update update_args
+
+            patched.must_be_instance_of je.class
+            patched.description.must_equal description
+          end
+        end
+      end
+
+      # POST /books/:book_id/journal_entries/create_and_post
+      RespondsTo 'journal_entry.create_and_post' do
+        ByReturning 'a Subledger::Domain::PostingJournalEntry' do
+          posting_je = subject.journal_entry.
+                                 create_and_post( factory.create_and_post_args )
+          posting_je.must_be_instance_of Subledger::Domain::PostingJournalEntry
+        end
+
+        When 'lines are out-of-balance' do
+          ByReturning 'a Subledger::Domain::ActiveJournalEntry w/ reason' do
+            aje = subject.journal_entry.
+                            create_and_post factory.oob_create_and_post_args
+            aje.must_be_instance_of Subledger::Domain::ActiveJournalEntry
+
+            aje.reason.wont_be_nil
+          end
+        end
+
+        When 'it has no lines' do
+          ByReturning 'a Subledger::Domain::ActiveJournalEntry w/ reason' do
+            aje = subject.journal_entry.
+                            create_and_post factory.no_lines_create_and_post_args
+            aje.must_be_instance_of Subledger::Domain::ActiveJournalEntry
+
+            aje.reason.wont_be_nil
+          end
+        end
+
+        When 'lines have no account' do
+          ByRaising 'an error' do
+
+            insane_args = factory.create_and_post_args
+
+            insane_args[:lines].first.delete :account
+
+            lambda { subject.journal_entry.create_and_post insane_args }.
+              must_raise Subledger::Domain::JournalEntryError
+          end
+        end
+      end
+
+      # GET /books/:book_id/journal_entries ? before   = :effective_at & limit = :limit & state = :state
+      #                                       ending
+      #                                       starting
+      #                                       after
+      [ :active, :archived, :posting, :posted ].each do |state|
+        Subledger.scenarios_order.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "journal_entries.collect action => #{action}, state => #{state}" do
+            let(:journal_entries) { factory.create_journal_entry_collection state }
+            let(:journal_entry  ) { journal_entries[2] }
+            let(:limit          ) { 2 }
+            let(:klass          ) { journal_entry.class }
+            let(:collection     ) { subject.journal_entries.collect args }
+
+            # TODO Does factory.now work here?
+            let(:effective_at) { journal_entry.effective_at }
+
+            let(:args) { { :action       => action,
+                           :effective_at => effective_at,
+                           :state        => state,
+                           :limit        => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} journal entries" do
+                collection.length.must_equal expectations.length
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} journal entries" do
+                count = 0
+
+                collection.each do |aje|
+                  expectation = expectations[count]
+
+                  aje.description.must_equal expectation
+
+                  aje.must_be_instance_of klass
+
+                  count += 1
+                end
+
+                count.must_equal expectations.length
+              end
+            end
+          end
+        end
+      end
+
+      # GET /books/:book_id/journal_entries ? preceding = :je_id & limit = :limit & state = :state
+      #                                       following
+      [ :archived, :active, :posting, :posted ].each do |state|
+        Subledger.scenarios_id.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "journal_entries.collect action => #{action}, state => #{state}" do
+            let(:journal_entries) { factory.create_journal_entry_collection state }
+
+            let(:journal_entry) { journal_entries[2] }
+            let(:limit        ) { 2 }
+            let(:collection   ) { subject.journal_entries.collect args }
+            let(:klass        ) { journal_entry.class }
+
+            let(:args) { { :action => action,
+                           :id     => journal_entry.id,
+                           :state  => state,
+                           :limit  => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} journal entries" do
+                collection.length.must_equal expectations.length
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} journal entries" do
+                count = 0
+
+                collection.each do |aje|
+                  expectation = expectations[count]
+
+                  aje.send( :description ).must_equal expectation
+
+                  aje.must_be_instance_of klass
+
+                  count += 1
+                end
+
+                count.must_equal expectations.length
+              end
+            end
+          end
+        end
+      end
+
+      # POST /books/:book_id/active_journal_entries/:id/archive
+      RespondsTo 'active_journal_entry_instance.archive' do
+        ByReturning 'an instance of Subledger::Domain::ArchivedJournalEntry' do
+          factory.create_journal_entry(:active).archive.
+                     must_be_instance_of Subledger::Domain::ArchivedJournalEntry
+        end
+      end
+
+      # POST /books/:book_id/archived_journal_entries/:id/activate
+      RespondsTo 'archived_journal_entry_instance.activate' do
+        ByReturning 'an instance of Subledger::Domain::ActiveJournalEntry' do
+          factory.create_journal_entry(:archived).activate.
+                     must_be_instance_of Subledger::Domain::ActiveJournalEntry
+        end
+      end
+
+      # POST /books/:book_id/journal_entries/:je_id/create_line
+      RespondsTo 'active_journal_entry_instance.create_line' do
+        let(:dje      ) { factory.create_journal_entry :active }
+        let(:line_args) { factory.journal_entry_line_args }
+
+        ByReturning 'an instance of Subledger::Domain::ActiveLine' do
+          dje.create_line(line_args).
+                     must_be_instance_of Subledger::Domain::ActiveLine
+        end
+      end
+
+      # GET /books/:book_id/journal_entries/:je_id/lines ? state = :state & action = before & order = :order & limit = :limit
+      #                                                                              ending
+      #                                                                              starting
+      #                                                                              after
+      [ :active, :archived, :posted ].each do |state|
+        Subledger.scenarios_order.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "journal_entry_instance.lines action => #{action}, state => #{state}" do
+            let(:aje       ) { factory.create_journal_entry :active }
+            let(:lines     ) { factory.create_line_collection aje, state }
+            let(:line      ) { lines[2] }
+            let(:order     ) { line.order }
+            let(:limit     ) { 2 }
+            let(:klass     ) { line.class }
+            let(:collection) { aje.lines args }
+
+            let(:args) { { :action => action,
+                           :order  => order,
+                           :state  => state,
+                           :limit  => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} journal entry lines" do
+                collection.length.must_equal expectations.length
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} journal entry lines" do
+                count = 0
+
+                collection.each do |line|
+                  expectation = expectations[count]
+
+                  line.description.must_equal expectation
+
+                  line.must_be_instance_of klass
+
+                  if state == :posted
+                    line.effective_at.wont_be_nil
+                    line.posted_at.wont_be_nil
+                  end
+
+                  count += 1
+                end
+
+                count.must_equal expectations.length
+              end
+            end
+          end
+        end
+      end
+
+      # GET /books/:book_id/journal_entries/:je_id/lines ? preceding = :line_id & limit = :limit & state = :state
+      #                                                    following
+      [ :preceding, :following ].each do |action|
+        RespondsTo "active_journal_entry.lines action => #{action}" do
+          let(:debit_account ) { factory.create_account :active, factory.client.debit }
+          let(:credit_account) { factory.create_account :active, factory.client.credit }
+          let(:journal_entry ) { factory.create_journal_entry :active }
+
+          let(:order) do
+                        if action == :preceding
+                          '102'
+                        else
+                          '1'
+                        end
+                      end
+
+          let(:line) { journal_entry.create_line :account     => debit_account,
+                                                 :description => 'description',
+                                                 :value       => factory.client.zero( 0 ),
+                                                 :order       => order }
+
+          let(:args) { { :action => action,
+                         :id     => line.id,
+                         :state  => :active,
+                         :limit  => 100 } }
+
+          before do
+            line
+
+            2.upto 51 do |number|
+              journal_entry.create_line :account     => debit_account,
+                                        :description => 'description',
+                                        :value       => factory.client.debit( 1 ),
+                                        :order       => number.to_s
+            end
+
+            52.upto 101 do |number|
+              journal_entry.create_line :account     => credit_account,
+                                        :description => 'description',
+                                        :value       => factory.client.credit( 1 ),
+                                        :order       => number.to_s
+            end
+          end
+
+          let(:collection) { journal_entry.lines args }
+
+          ByReturning "a list of active journal entry lines" do
+            journal_entry.lines( args ).length.must_equal 100
+          end
+        end
+      end
+
+      # GET /books/:book_id/journal_entries/:je_id/lines/:id
+      RespondsTo 'journal_entry.line.read' do
+        let(:dje  ) { factory.create_journal_entry :active }
+        let(:line ) { factory.create_line dje, :active }
+
+        ByReturning 'a Subledger::Domain::ActiveLine' do
+          dje.line( :id => line.id ).
+                read.
+                  must_be_instance_of Subledger::Domain::ActiveLine
+        end
+      end
+
+      # PATCH /books/:book_id/journal_entry/:je_id/lines/:id
+      RespondsTo 'active_lines.update' do
+        let(:journal_entry) { factory.create_journal_entry :active }
+        let(:line         ) { factory.create_line journal_entry, :active }
+        let(:description  ) { 'updated description' }
+
+        ByReturning 'an instance of Subledger::Domain::ActiveLine' do
+          args = line.attributes
+          args.merge! :description => description,
+                      :version     => 2
+
+          patched = subject.active_lines.update args
+
+          patched.must_be_instance_of Subledger::Domain::ActiveLine
+          patched.send( :description ).must_equal description
+        end
+      end
+
+      # POST /books/:book_id/journal_entries/:je_id/lines/:id/archive
+      RespondsTo 'journal_entry_line_instance.archive' do
+        let(:journal_entry) { factory.create_journal_entry :active }
+
+        ByReturning 'an instance of Subledger::Domain::ArchivedLine' do
+          factory.create_line( journal_entry, :active ).
+                    archive.
+                      must_be_instance_of Subledger::Domain::ArchivedLine
+        end
+      end
+
+      # POST /books/:book_id/journal_entries/:je_id/lines/:id/activate
+      RespondsTo 'journal_entry_line_instance.activate' do
+        let(:journal_entry) { factory.create_journal_entry :active }
+
+        ByReturning 'an instance of Subledger::Domain::ActiveLine' do
+          factory.create_line( journal_entry, :archived ).
+                    activate.
+                      must_be_instance_of Subledger::Domain::ActiveLine
+        end
+      end
+
+      # Accounting post!
+      # POST /books/:book_id/journal_entries/:id
+      [ :active, :posting, :posted ].each do |state|
+        klass = if state == :posted
+                  Subledger::Domain::PostedJournalEntry
+                else
+                  Subledger::Domain::PostingJournalEntry
+                end
+
+        RespondsTo 'journal_entry_instance.post successfully' do
+          When "state is #{state}" do
+            let(:journal_entry) { factory.create_journal_entry state, :lines }
+
+            ByReturning "an instance #{klass}" do
+              journal_entry.post.must_be_instance_of klass
+            end
+          end
+        end
+      end
+
+      RespondsTo 'journal_entry_instance.post unsuccessfully' do
+        When 'state is archived' do
+          let(:journal_entry) { factory.create_journal_entry( :active, :lines ).archive }
+
+          ByRaising 'a NoMethodError' do
+            lambda { journal_entry.post }.must_raise NoMethodError
+          end
+        end
+      end
+
+      # GET /books/:book_id/journal_entries/:id/progress
+      [ :archived, :active, :posting, :posted ].each do |state|
+        RespondsTo 'journal_entry_instance.progress' do
+          let(:journal_entry) { factory.create_journal_entry state }
+
+          ByReturning 'an integer from 0-100' do
+            journal_entry.progress.must_be_instance_of Fixnum
+          end
+        end
+      end
+    end
+  end
+end

data/spec/subledger_key_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory) { Subledger::Factory.create }
+  let(:identity) { factory.identity }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'Key' do
+      # POST /identities/:identity_id/keys
+      RespondsTo 'keys.create' do
+        ByReturning 'an instance of Subledger::Domain::ActiveKey' do
+          subject.keys.create( factory.key_args( identity ) ).
+                         must_be_instance_of Subledger::Domain::ActiveKey
+        end
+      end
+
+      # POST /identities/:identity_id/keys/:key_id/archive
+      [ :archived, :active ].each do |state|
+        RespondsTo "#{state}_key_instance.archive" do
+          let(:key) { factory.create_key state, identity }
+
+          ByReturning 'an instance of Subledger::Domain::ArchivedKey' do
+            key.archive.must_be_instance_of Subledger::Domain::ArchivedKey
+          end
+        end
+      end
+
+      # POST /identities/:identity_id/keys/:key_id/activate
+      [ :archived, :active ].each do |state|
+        RespondsTo "#{state}_key_instance.activate" do
+          let(:key) { factory.create_key state, identity }
+
+          ByReturning 'an instance of Subledger::Domain::ActiveKey' do
+            key.activate.must_be_instance_of Subledger::Domain::ActiveKey
+          end
+        end
+      end
+    end
+  end
+end

data/spec/subledger_org_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory) { Subledger::Factory.create }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'Org' do
+      # POST /orgs
+      RespondsTo 'orgs.create' do
+        ByReturning 'an instance of Subledger::Domain::ActiveOrg' do
+          subject.orgs.create( factory.org_args ).
+                         must_be_instance_of Subledger::Domain::ActiveOrg
+        end
+      end
+
+      # GET /orgs/:id
+      RespondsTo 'orgs.read' do
+        let(:org) { factory.create_org :active }
+
+        ByReturning 'a kind of Subledger::Domain::ActiveOrg' do
+          subject.orgs.read( :id => org.id ).
+                          must_be_instance_of Subledger::Domain::ActiveOrg
+        end
+      end
+
+      # PATCH /orgs/:id
+      RespondsTo 'orgs.update' do
+        let(:org       ) { factory.create_org :active }
+        let(:description) { 'updated description' }
+        let(:args       ) { org.attributes }
+        let(:update_args) { args.merge :description => description,
+                                       :version     => 2 }
+
+        ByReturning 'an updated kind of Subledger::Domain::ActiveOrg' do
+          patched = subject.orgs.update update_args
+
+          patched.must_be_instance_of Subledger::Domain::ActiveOrg
+          patched.description.must_equal description
+        end
+      end
+
+      # POST /orgs/:id/archive
+      [ :archived, :active ].each do |state|
+        RespondsTo "#{state}_org_instance.archive" do
+          let(:org) { factory.create_org state }
+
+          ByReturning 'an instance of Subledger::Domain::ArchivedOrg' do
+            org.archive.must_be_instance_of Subledger::Domain::ArchivedOrg
+          end
+        end
+      end
+
+      # POST /orgs/:id/activate
+      [ :archived, :active ].each do |state|
+        RespondsTo "#{state}_org_instance.activate" do
+          let(:org) { factory.create_org state }
+
+          ByReturning 'an instance of Subledger::Domain::ActiveOrg' do
+            org.activate.must_be_instance_of Subledger::Domain::ActiveOrg
+          end
+        end
+      end
+    end
+  end
+end