stockor-core 0.2

data/test/location_test.rb

@@ -0,0 +1,10 @@
+require_relative 'test_helper'
+
+class LocationTest < Skr::TestCase
+
+    def test_it_copies_branch
+        loc = Location.new
+        assert_equal '01', loc.gl_branch_code
+    end
+
+end

data/test/payment_term_test.rb

@@ -0,0 +1,25 @@
+require_relative 'test_helper'
+
+
+class PaymentTermTest < Skr::TestCase
+
+
+    def test_immediate_terms_are_identified
+        assert skr_payment_terms(:cash).immediate?
+        refute skr_payment_terms(:net30).immediate?
+        assert skr_payment_terms(:cred_card).immediate?
+        refute skr_payment_terms(:bonus30).immediate?
+    end
+
+    def test_percnum
+        assert_kind_of  Skr::Core::Numbers::PercNum, skr_payment_terms(:bonus30).discount
+        assert skr_payment_terms('10net30').discount.is_percentage?
+        refute skr_payment_terms(:bonus30).discount.is_percentage?
+    end
+
+    def test_expirations
+        assert_equal Date.today+30.days, skr_payment_terms('10net30').due_date_from(Date.today)
+        assert_equal Date.today+10.days, skr_payment_terms('10net30').discount_expires_at
+     end
+
+end

data/test/pick_ticket_test.rb

@@ -0,0 +1,27 @@
+require_relative "test_helper"
+
+class PickTicketTest < Skr::TestCase
+
+    def test_creation_from_so
+        so = skr_sales_orders(:first)
+        skr_sku_locs(:stringdefault).allocate_available_qty!
+        assert_equal 1, so.lines.pickable.count
+        pt = so.pick_tickets.build
+        assert_equal 1, pt.lines.length
+        assert_equal skr_skus(:string), pt.lines.first.sku
+        assert_equal 1.42, pt.lines.first.price
+        assert_saves pt
+    end
+
+    def test_canceling
+        pt = skr_pick_tickets(:first)
+        assert_equal 1, pt.lines.length
+        refute pt.is_complete?, "Pick Ticket is complete when it shouldn't be"
+
+        pt.mark_complete=true
+        assert_saves pt
+        # pt.is_complete.must_equal true
+        # so_lines(:first_on_first).qty_picking.must_equal 0
+    end
+
+end

data/test/po_line_test.rb

@@ -0,0 +1,36 @@
+require_relative 'test_helper'
+
+class PoLineTest < Skr::TestCase
+
+
+    def test_creation
+        po = skr_purchase_orders(:first)
+        skuloc = skr_sku_locs(:hatdefault)
+        pol = po.lines.build({ sku_loc: skuloc, description: 'a test item',
+                               uom_code: 'EA', uom_size: 1, price: 33.3 })
+        assert_saves pol
+    end
+
+
+    def test_recieving
+        line = skr_po_lines(:second_on_first)
+        line.qty_received = 1
+
+        assert_saves line
+        line.reload
+        assert_equal 0, line.qty_received, "qty received saved, even though it should be locked"
+
+        line.unlock_fields( :qty_received ) do
+            line.qty_received = 33
+            assert_saves line
+        end
+        line.reload
+        assert_equal 33, line.qty_received
+        line.qty_received = 3
+        assert_saves line
+        line.reload
+        assert_equal 33, line.qty_received
+    end
+
+
+end

data/test/po_receipt_test.rb

@@ -0,0 +1,93 @@
+require_relative 'test_helper'
+
+
+class PoReceiptTest < Skr::TestCase
+
+    def test_posting_freight
+        po    = skr_purchase_orders(:first)
+        por   = PoReceipt.new( freight: 42.99, purchase_order: po )
+        assert_difference ->{ por.vendor.gl_freight_account.trial_balance }, 42.99 do
+            assert_saves por
+        end
+    end
+
+    def test_allocations
+        po = skr_purchase_orders(:first)
+
+        poline = po.lines.last
+        qty = poline.qty_unreceived
+
+        sl=poline.sku_loc
+        sol = skr_so_lines(:picking_glove)
+        assert_equal 2, sl.so_lines.count
+
+        por = PoReceipt.new( freight: 42.99, purchase_order: po )
+        por.lines.build( po_line: poline, qty: qty, auto_allocate: true )
+        assert_equal 19, sol.qty-sol.qty_allocated
+        assert_difference( ->{sl.reload.qty_allocated}, 19 ) do
+            assert_saves por
+        end
+        refute por.lines.first.new_record?
+        assert_equal 1, por.lines.first.qty
+
+        assert_equal qty, poline.reload.qty_received
+    end
+
+
+    def test_gl_postings
+        po    = skr_purchase_orders(:first)
+        por   = PoReceipt.new( freight: 42.99, purchase_order: po )
+        por.lines.build({ po_line: po.lines.first, qty: 1 })
+        por.lines.build({ po_line: po.lines.last,  qty: 3 })
+
+        gl = skr_gl_accounts(:inventory)
+
+        # needs more nesting...
+        assert_difference ->{ GlTransaction.count }, 1 do
+            assert_difference ->{ GlPosting.count }, 3 do
+                assert_difference ->{ gl.trial_balance }, 164.62 do
+                    assert_saves por
+                end
+            end
+        end
+        glt = por.gl_transaction
+        assert glt, "Receipt did not record a GlTransaction"
+        assert_equal 1, glt.debits.count
+        assert_equal( -207.61, glt.debits.first.amount )
+        assert_equal skr_gl_accounts(:inv_recpt).default_number, glt.debits.first.account_number
+        assert_equal 2, glt.credits.count
+        assert_equal( 42.99, glt.credits.first.amount )
+        assert_equal po.vendor.gl_freight_account.default_number, glt.credits.first.account_number
+        assert_equal( 207.61-42.99, glt.credits.last.amount )
+        assert_equal skr_gl_accounts(:inventory).default_number, glt.credits.last.account_number
+    end
+
+    def test_no_posting_if_save_failed
+        po    = skr_purchase_orders(:first)
+        por   = PoReceipt.new # <- No PO
+        por.lines.build({ po_line: po.lines.first, qty: 1 })
+        assert_difference ->{ GlTransaction.count }, 0 do
+            assert_difference ->{ GlPosting.count }, 0 do
+                refute_saves por
+            end
+        end
+    end
+
+    def test_failed_posting_raises
+        po    = skr_purchase_orders(:first)
+        por   = PoReceipt.new( freight: 42.99, purchase_order: po )
+        por.lines.build({ po_line: po.lines.first, qty: 1 })
+        assert_difference ->{ PoReceipt.count }, 0 do
+            assert_difference ->{ GlTransaction.count }, 0 do
+                assert_difference ->{ GlPosting.count }, 0 do
+                    por.stub(:attributes_for_gl_transaction,{}) do
+                        assert_raises Skr::InvalidGlTransaction do
+                            refute_saves por
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+end

data/test/por_line_test.rb

@@ -0,0 +1,79 @@
+require_relative 'test_helper'
+
+
+class PorLineTest < Skr::TestCase
+
+
+    def test_gl_postings
+        po = skr_purchase_orders(:first)
+        pol = skr_po_lines(:second_on_first)
+        por = PoReceipt.new( freight: 42.99, purchase_order: po )
+        line = por.lines.build({
+            qty: 1,
+            po_line: pol
+        })
+        assert_difference ->{ GlAccount.default_for(:inventory_receipts_clearing).trial_balance }, (line.price+42.99) * -1 do
+            assert_difference ->{ line.sku_loc.sku.gl_asset_account.trial_balance }, line.price do
+                assert_saves por
+            end
+        end
+    end
+
+    def test_recieving_qty
+        po  = skr_purchase_orders(:first)
+        pol = skr_po_lines(:second_on_first)
+        por = PoReceipt.new({ purchase_order: po })
+        line = por.lines.build({ po_line: pol })
+        assert_difference ->{ line.sku_loc.reload.qty }, 1 do
+            assert_saves por
+            refute_empty line.sku_trans
+            assert_equal 1, line.sku_trans.first.qty
+            assert_equal line.sku_loc, line.sku_trans.first.sku_loc
+            refute line.sku_trans.first.new_record?
+        end
+    end
+
+    def test_mac_adjustments
+        po  = skr_purchase_orders(:first)
+        pol = skr_po_lines(:second_on_first)
+        por  = PoReceipt.new({ purchase_order: po })
+        line = por.lines.build({ po_line: pol })
+        assert_equal '0.12', line.sku_loc.mac.to_s
+        assert_saves por
+        assert_equal '2.9768', line.sku_loc.mac.to_s
+    end
+
+    def test_empty_mac_adjustment
+        po = skr_purchase_orders(:unvouched)
+        sl = skr_sku_locs(:hatdefault)
+        pol = po.lines.where({ sku_loc_id: sl }).first
+        assert_equal 0, pol.qty_received
+        assert_equal 1, pol.qty
+        assert_equal 23.3, pol.price
+        sl.unlock_fields :mac, :qty do
+            sl.qty = sl.mac = 0
+            sl.save!
+        end
+        por = PoReceipt.new({ :freight=>42.99, :purchase_order => po })
+        por.lines.build({ :po_line => pol })
+        assert_saves por
+        sl.reload
+        assert_equal 23.3, sl.mac
+        assert_equal 1, sl.qty
+    end
+
+    def test_prevents_over_receipt
+        pol = skr_po_lines(:second_on_first)
+        por = PoReceipt.new({ purchase_order: pol.purchase_order })
+        line = por.lines.build({ po_line: pol })
+        assert_difference ->{ line.sku_loc.reload.qty }, 1 do
+            assert_saves por
+            assert_equal 0, line.po_line.qty_unreceived
+        end
+        line = por.lines.build({ po_line: pol })
+        assert line.invalid?, "Line should not be valid"
+        assert line.errors[:qty]
+    end
+
+
+end

data/test/pt_line_test.rb

@@ -0,0 +1,29 @@
+require_relative "test_helper"
+
+class PtLineTest < Skr::TestCase
+
+    def test_invoicing
+        pt = skr_pick_tickets(:first)
+        ptl = pt.lines.first
+        assert_equal 0, ptl.qty_invoiced
+
+        inv = Invoice.new({ :pick_ticket=> pt })
+        inv.lines.from_pick_ticket!
+        assert_saves inv
+
+        assert_equal inv.lines.length, pt.lines.length
+        refute_nil inv.lines.first.pt_line
+        assert_equal ptl, inv.lines.first.pt_line
+        assert_equal ptl.reload.qty_invoiced, inv.lines.first.qty
+    end
+
+    def test_bin_is_assigned
+        so = skr_sales_orders(:first)
+        skr_sku_locs(:stringdefault).allocate_available_qty!
+        assert_equal 1, so.lines.pickable.count
+        pt = so.pick_tickets.build
+        assert_saves pt
+        assert_equal skr_sku_locs(:stringdefault).bin, pt.lines.first.bin
+    end
+
+end

data/test/purchase_order_test.rb

@@ -0,0 +1,44 @@
+require_relative 'test_helper'
+
+class PurchaseOrderTest < Skr::TestCase
+
+    def test_creation
+        po = PurchaseOrder.new({
+                                   terms: skr_payment_terms(:cred_card),
+                                   vendor: skr_vendors(:bigco),
+                                   location: skr_locations(:default)
+                               })
+        po.lines.build({
+            sku_loc: skr_sku_locs(:hatdefault),
+            description: 'a test item',
+            uom_code: 'BX',
+            uom_size: 10,
+            price: 33.3
+          })
+        assert_saves po
+    end
+
+
+    def test_state_transistions
+        po = skr_purchase_orders(:first)
+        assert_equal 'open', po.state
+        assert_equal [ :mark_received ], po.valid_state_events
+        po.mark_received!
+        assert_equal 'received', po.state
+        assert_empty po.valid_state_events
+        assert_saves po
+    end
+
+
+    def test_receiving
+        po = skr_purchase_orders(:first)
+        por   = PoReceipt.new( purchase_order: po )
+        po.lines.each do | pol|
+            next if pol.qty_unreceived.zero?
+            por.lines.build({ :po_line => pol })
+        end
+        assert_saves por
+        assert_equal 'received', po.state
+    end
+
+end

data/test/sales_order_test.rb

@@ -0,0 +1,74 @@
+require_relative 'test_helper'
+
+
+class SalesOrderTest < Skr::TestCase
+
+    def test_date_default
+        so = SalesOrder.new
+        assert_equal Date.today, so.order_date
+    end
+
+    def test_updating_location
+        so = skr_sales_orders(:first)
+        so.location = skr_locations(:amazon)
+        assert_not so.save, "SO saved with invalid location"
+        assert_equal "Location AMAZON does not have skus STRING", so.errors.full_messages.first
+        sku = skr_skus(:string)
+        sl = sku.sku_locs.find_or_create_for( so.location )
+        assert_saves so
+        assert sl
+    end
+
+
+    def test_creating
+        customer = skr_customers(:joe)
+        so = SalesOrder.new( customer: customer )
+        Sku.where( code: ['HAT','STRING'] ).each do | sku |
+            so.lines.build(
+              sku_loc: sku.sku_locs.default
+            )
+        end
+        assert_saves so
+    end
+
+
+    def test_allocation_counts
+        sol = skr_so_lines(:first_string)
+        sol.qty_allocated=1
+        assert_saves sol
+        so = SalesOrder.allocated.where({ :id=>skr_sales_orders(:first) }).first
+        assert so, "SO wasn't found"
+        assert_equal 1,so.number_of_lines_allocated
+        assert_equal 0,so.number_of_lines_fully_allocated
+    end
+
+    def test_picking
+        so = skr_sales_orders(:first)
+        skr_sku_locs(:stringdefault).allocate_available_qty!
+        assert_equal 1, so.lines.pickable.count
+        assert_equal 2, so.lines.pickable.first.qty_allocated
+        pt = so.pick_tickets.build
+        pt.save!
+        assert_equal 1, pt.lines.count
+        so.reload
+        assert_equal 0, so.lines.pickable.count
+    end
+
+
+    def test_cancelling
+        so = skr_sales_orders(:picking)
+        assert_equal 'open', so.state
+        assert_equal 5, so.lines.first.qty_picking
+        refute so.pick_tickets.first.is_complete
+        assert so.mark_canceled!
+        assert_equal 0, so.lines.first.qty_picking
+        assert so.pick_tickets.first.is_complete
+    end
+
+    def test_sales_history
+        stats = SalesOrder.sales_history( 5 )
+        assert_equal 5, stats.count
+        assert_equal ["3","5","120.02"], stats[0][2..-1]
+    end
+
+end

data/test/sku_loc_test.rb

@@ -0,0 +1,50 @@
+require_relative 'test_helper'
+
+class SkuLocTest < Skr::TestCase
+
+    def test_qty_locked
+        sl = skr_sku_locs(:hatdefault)
+        sl.qty=800
+        assert_saves sl
+        assert_equal 25, sl.reload.qty
+    end
+
+
+    def test_allocations
+        sol = skr_so_lines(:first_string)
+        sl = sol.sku_loc
+
+        assert_equal 33, sl.qty_available
+        refute sol.is_fully_allocated?, "test line is already allocated"
+        sl.allocate_available_qty!
+        sol.reload # <- needed because sku_loc allocations uses a scope
+        assert sol.is_fully_allocated?, "failed to allocate test line"
+        assert_equal 27, sl.reload.qty_available
+
+        sol.update_attributes :qty_allocated => 0
+        assert_equal 33, sl.reload.qty_available
+    end
+
+    def test_qty_event
+        sl = skr_sku_locs(:hatdefault)
+        assert_event_fires( SkuLoc, :qty_change ) do
+            # NEVER do this directly - it will throw the MAC
+            # and GL out off balance.  Instead use SkuTran
+            sl.unlock_fields( :qty ) do
+                sl.adjust_qty( 10 )
+                assert_saves sl
+            end
+        end
+        assert_equal [sl], last_event_results
+    end
+
+    def test_picking
+        sl = skr_sku_locs(:stringdefault)
+        sol = sl.so_lines.where( sku_loc: sl ).first
+        sl.allocate_available_qty!
+        pt = sol.sales_order.pick_tickets.build
+        assert_difference 'sl.reload.qty_picking', 6 do
+            assert_saves pt
+        end
+    end
+end