subledger 0.7.7

data/spec/subledger_book_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory) { Subledger::Factory.create }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'Book' do
+      # POST /books
+      RespondsTo 'book.create' do
+        ByReturning 'an instance of Subledger::Domain::ActiveBook' do
+          subject.book.create( factory.book_args ).
+                         must_be_instance_of Subledger::Domain::ActiveBook
+        end
+      end
+
+      # GET /books/:id
+      RespondsTo 'books.read' do
+        let(:book) { factory.create_book :active }
+
+        ByReturning 'a kind of Subledger::Domain::Book' do
+          subject.books.read( :id => book.id ).
+                          must_be_instance_of Subledger::Domain::ActiveBook
+        end
+      end
+
+      # PATCH /books/:id
+      RespondsTo 'books.update' do
+        let(:book       ) { factory.create_book :active }
+        let(:description) { 'updated description' }
+        let(:args       ) { book.attributes }
+        let(:update_args) { args.merge :description => description,
+                                       :version     => 2 }
+
+        ByReturning 'an updated kind of Subledger::Domain::Book' do
+          patched = subject.books.update update_args
+
+          patched.must_be_instance_of Subledger::Domain::ActiveBook
+          patched.description.must_equal description
+        end
+      end
+
+      # GET /books ? before   = :description & limit = :limit & state = :state
+      #              ending
+      #              starting
+      #              after
+      #              preceding = :book_id & limit = :limit & state = :state
+      #              following
+      [ :archived, :active ].each do |state|
+        Subledger.scenarios.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          value_key = if action == :preceding or action == :following
+                        'id'
+                      else
+                        'description'
+                      end
+
+          RespondsTo "books.collect :state => #{state}, :action => #{action.inspect}" do
+            let(:books) { factory.create_book_collection state }
+            let(:book ) { books[2] }
+            let(:limit) { 2 }
+
+            if action == :preceding or action == :following
+              let(:value) { book.id }
+            else
+              let(:value) { URI.escape book.description }
+            end
+
+            let(:args) { { :action          => action,
+                           value_key.to_sym => value,
+                           :state           => state,
+                           :limit           => limit } }
+
+            When 'not given a block' do
+              let(:collection) { subject.books.collect args }
+
+              ByReturning "a list of #{state} books" do
+                collection.length.must_equal limit
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} books" do
+                count = 0
+
+                subject.books.collect( args ).each do |item|
+                  expectation = expectations[count]
+
+                  item.description.must_equal expectation
+
+                  item.must_be_instance_of book.class
+
+                  count += 1
+                end
+
+                count.must_equal limit
+              end
+            end
+          end
+        end
+      end
+
+      # POST /books/:id/archive
+      [ :archived, :active ].each do |state|
+        RespondsTo "#{state}_book_instance.archive" do
+          let(:book) { factory.create_book state }
+
+          ByReturning 'an instance of Subledger::Domain::ArchivedBook' do
+            book.archive.must_be_instance_of Subledger::Domain::ArchivedBook
+          end
+        end
+      end
+
+      # POST /books/:id/activate
+      [ :archived, :active ].each do |state|
+        RespondsTo "#{state}_book_instance.activate" do
+          let(:book) { factory.create_book state }
+
+          ByReturning 'an instance of Subledger::Domain::ActiveBook' do
+            book.activate.must_be_instance_of Subledger::Domain::ActiveBook
+          end
+        end
+      end
+    end
+  end
+end

data/spec/subledger_category_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory) { Subledger::Factory.create }
+  let(:amount ) { '1' }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'Category' do
+
+      # POST /books/:book_id/categories
+      RespondsTo 'category.create' do
+        ByReturning 'an instance of Subledger::Domain::ActiveCategory' do
+          subject.category.create( factory.category_args ).
+                     must_be_instance_of Subledger::Domain::ActiveCategory
+        end
+      end
+
+      # GET /books/:book_id/categories/:id
+      [ :archived, :active ].each do |state|
+        RespondsTo 'category.read' do
+          let(:category) { factory.create_category state }
+
+          ByReturning "an instance of #{state} category" do
+            subject.category.read( :id => category.id ).
+                       must_be_instance_of category.class
+          end
+        end
+      end
+
+      # PATCH /books/:book_id/categories/:id
+      [ :archived, :active ].each do |state|
+        RespondsTo 'categories.update' do
+          let(:category   ) { factory.create_category state }
+          let(:args       ) { category.attributes }
+          let(:description) { 'updated description' }
+          let(:update_args) { args.merge :description => description,
+                                         :version     => 2 }
+
+          ByReturning "an instance of #{state} category" do
+            patched = subject.categories.update update_args
+
+            patched.must_be_instance_of category.class
+            patched.description.must_equal description
+          end
+        end
+      end
+
+      # GET /books/:book_id/categories ? before   = :description & limit = :limit & state = :state
+      #                                  ending
+      #                                  starting
+      #                                  after
+      [ :active, :archived ].each do |state|
+        Subledger.scenarios_order.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "categories.collect :action => #{action}, :state => #{state}" do
+            let(:categories) { factory.create_category_collection state }
+            let(:item      ) { categories[2] }
+            let(:limit     ) { 2 }
+            let(:collection) { subject.categories.collect args }
+            let(:klass     ) { item.class }
+
+            let(:args) { { :action      => action,
+                           :description => item.description,
+                           :state       => state,
+                           :limit       => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} categories" do
+                collection.length.must_equal limit
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} categories" do
+                count = 0
+
+                collection.each do |category|
+                  expectation = expectations[count]
+
+                  category.description.must_equal expectation
+
+                  category.must_be_instance_of klass
+
+                  count += 1
+                end
+
+                count.must_equal limit
+              end
+            end
+          end
+        end
+      end
+
+      # GET /categories ? preceding = :book_id & limit = :limit & state = :state
+      #                   following = :book_id & limit = :limit & state = :state
+      [ :active, :archived ].each do |state|
+        Subledger.scenarios_id.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "categories.collect :action => #{action}" do
+            let(:categories) { factory.create_category_collection state }
+            let(:item      ) { categories[2] }
+            let(:limit     ) { 2 }
+            let(:collection) { subject.categories.collect args }
+            let(:klass     ) { item.class }
+
+            let(:args) { { :action => action,
+                           :id     => item.id,
+                           :state  => state,
+                           :limit  => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} categories" do
+                collection.length.must_equal limit
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} categories" do
+                count = 0
+
+                collection.each do |category|
+                  expectation = expectations[count]
+
+                  category.description.must_equal expectation
+
+                  category.must_be_instance_of klass
+
+                  count += 1
+                end
+
+                count.must_equal limit
+              end
+            end
+          end
+        end
+      end
+
+      # GET /books/:book_id/categories/:id/accounts
+      if Subledger::STORE == :api
+        RespondsTo 'category_instance.accounts' do
+          ByRaising 'a Store::ReportError' do
+            lambda do
+              factory.create_category(:active).accounts
+            end.must_raise Subledger::Store::CategoryError
+          end
+        end
+      else
+        RespondsTo "category_instance.accounts" do
+          let(:category) { factory.create_category :active }
+
+          let(:category_accounts) {  }
+
+          When 'not given a block' do
+            ByReturning 'a list of accounts' #do
+            #   category.accounts.length.must_equal category_accounts.length
+            # end
+          end
+
+          When 'given a block' do
+            ByYielding 'a list of accounts' #do
+            #   count = 0
+            #
+            #   category.accounts do |account|
+            #     expectation = category_accounts[count]
+            #
+            #     account.description.must_equal expectation.description
+            #
+            #     account.must_be_instance_of Subledger::Domain::ActiveAccount
+            #
+            #     count += 1
+            #   end
+            #
+            #   count.must_equal category_accounts.length
+            # end
+          end
+        end
+      end
+
+      # POST /books/:book_id/categories/:id/archive
+      RespondsTo 'category_instance.archive' do
+        ByReturning 'an instance of Subledger::Domain::ArchivedCategory' do
+          factory.create_category(:active).archive.
+                     must_be_instance_of Subledger::Domain::ArchivedCategory
+        end
+      end
+
+      # POST /books/:book_id/archived_categories/:id/activate
+      RespondsTo 'archived_category_instance.activate' do
+        ByReturning 'an instance of Subledger::Domain::ActiveCategory' do
+          factory.create_category(:archived).activate.
+                     must_be_instance_of Subledger::Domain::ActiveCategory
+        end
+      end
+    end
+  end
+end

data/spec/subledger_control_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 'Control' do
+#       # POST /v2/orgs/:org_id/controls
+#       RespondsTo 'controls.create' do
+#         ByReturning 'an instance of Subledger::Domain::ActiveControl' do
+#           subject.controls.create( factory.control_args ).
+#                              must_be_instance_of Subledger::Domain::ActiveControl
+#         end
+#       end
+#
+#       # POST /v2/orgs/:org_id/controls/:control_id/archive
+#       [ :archived, :active ].each do |state|
+#         RespondsTo "#{state}_control_instance.archive" do
+#           let(:control) { factory.create_control state, identity }
+#
+#           ByReturning 'an instance of Subledger::Domain::ArchivedControl' do
+#             control.archive.must_be_instance_of Subledger::Domain::ArchivedControl
+#           end
+#         end
+#       end
+#
+#       # POST /v2/orgs/:org_id/controls/:control_id/activate
+#       [ :archived, :active ].each do |state|
+#         RespondsTo "#{state}_control_instance.activate" do
+#           let(:control) { factory.create_control state, identity }
+#
+#           ByReturning 'an instance of Subledger::Domain::ActiveControl' do
+#             control.activate.must_be_instance_of Subledger::Domain::ActiveControl
+#           end
+#         end
+#       end
+#     end
+#   end
+# end

data/spec/subledger_identity_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory) { Subledger::Factory.create }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'Identities' do
+      # POST /identities
+      RespondsTo 'identities.create' do
+        ByReturning 'an instance of ActiveIdentity and ActiveKey' do
+          identity, key = subject.identities.create factory.identity_args
+          identity.must_be_instance_of Subledger::Domain::ActiveIdentity
+          key.must_be_instance_of Subledger::Domain::ActiveKey
+        end
+      end
+
+      # GET /identities/:id
+      RespondsTo 'identities.read' do
+        let(:identity) { factory.identity }
+
+        ByReturning 'a kind of Subledger::Domain::ActiveIdentity' do
+          subject.identities.read( :id => identity.id ).
+                          must_be_instance_of Subledger::Domain::ActiveIdentity
+        end
+      end
+
+      # PATCH /identities/:id
+      RespondsTo 'identities.update' do
+        let(:identity   ) { factory.identity }
+        let(:description) { 'updated description' }
+        let(:args       ) { identity.attributes }
+        let(:update_args) { args.merge :description => description,
+                                       :version     => 2 }
+
+        ByReturning 'an updated kind of Subledger::Domain::ActiveIdentity' do
+          patched = subject.identities.update update_args
+
+          patched.must_be_instance_of Subledger::Domain::ActiveIdentity
+          patched.description.must_equal description
+        end
+      end
+    end
+  end
+end