stockor-core 0.2

data/test/customer_test.rb

@@ -0,0 +1,34 @@
+require_relative 'test_helper'
+
+class CustomerTest < Skr::TestCase
+
+    def setup
+        @customer=Customer.new({
+            code: 'TEST',
+            name: 'Mr Test Co',
+            billing_address: skr_addresses(:bigco),
+            shipping_address: skr_addresses(:bigco),
+            terms: skr_payment_terms(:net30)
+        })
+    end
+
+    def test_saving
+        assert_saves @customer
+    end
+
+    def test_it_sets_gl
+        assert_saves @customer
+        assert_equal '1200', @customer.gl_receivables_account.number
+    end
+
+
+    def test_balance_recording
+        inv = Invoice.new( sales_order: skr_sales_orders(:picking) )
+        inv.lines.from_sales_order!
+        customer = inv.sales_order.customer
+        assert_difference ->{ customer.reload.open_balance }, 18.94 do
+            assert_saves inv
+        end
+    end
+
+end

data/test/gl_account_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+
+class GlAccountTest < Skr::TestCase
+
+    def test_balance
+        gla = skr_gl_accounts(:marketing)
+
+        assert_equal 3033.28, gla.balance_for( skr_gl_periods(:nov2013) )
+
+        assert_equal 3133.28, gla.balance_for( skr_gl_periods(:dec2013) )
+
+        assert_equal 0, gla.balance_for( skr_gl_periods(:close2013) )
+
+        assert_equal 356.81, gla.balance_for( skr_gl_periods(:jan2014) )
+
+        assert_equal -843.61, gla.trial_balance # Our free hats brings the expense account to a negative balance
+
+    end
+
+
+
+end

data/test/gl_manual_entry_test.rb

@@ -0,0 +1,17 @@
+require_relative 'test_helper'
+
+class GlManualEntryTest < Skr::TestCase
+
+    def test_notes_are_copied
+        gle = GlManualEntry.new({ notes: 'A good test' })
+        tran = gle.gl_transaction = GlTransaction.new( location: Location.default )
+        tran.add_posting( amount: 33.42, debit: skr_gl_accounts(:cash), credit: skr_gl_accounts(:inventory) )
+
+        assert_saves gle
+        assert_equal gle.notes, tran.description
+    end
+
+    def test_querying_using_visible_id
+        GlManualEntry.with_visible_id( 23)
+    end
+end

data/test/gl_period_test.rb

@@ -0,0 +1,12 @@
+require_relative 'test_helper'
+
+class GlPeriodTest < Skr::TestCase
+
+    def test_it_returns_current_period
+        glp = GlPeriod.current
+        glp.new_record?.must_equal false
+        glp.period.must_equal Time.now.month
+        glp.year.must_equal Time.now.year
+    end
+
+end

data/test/gl_posting_test.rb

@@ -0,0 +1,39 @@
+require_relative 'test_helper'
+
+class GlPostingTest < Skr::TestCase
+
+    def setup
+        gle = GlManualEntry.create({ notes: 'A good test' })
+        @glt = gle.gl_transaction = GlTransaction.new({ source: gle })
+        @glt.location = skr_locations(:default)
+        @glt.add_posting( amount: 33.42, debit: skr_gl_accounts(:cash), credit: skr_gl_accounts(:inventory) )
+    end
+
+    def test_attribute_caching
+        assert_saves @glt
+        assert_equal '110001', @glt.credits.first.account_number
+        assert_equal Date.today.year,  @glt.credits.first.year
+        assert_equal Date.today.month, @glt.credits.first.period
+    end
+
+
+    def test_it_cannot_be_updated
+        assert_saves @glt
+        @glt.credits.first.amount = 33
+        assert_raises( ActiveRecord::ReadOnlyRecord ) do
+            @glt.credits.first.save
+        end
+    end
+
+    def test_no_adding_to_transaction
+        assert_saves @glt
+        posting = @glt.credits.create({
+                                 account_number: '100000',
+                                 amount: 22
+                             })
+        assert posting.new_record?, "allowed saving an adhoc posting"
+        assert_equal ["does not accept new postings"], posting.errors[:gl_transaction]
+    end
+
+
+end

data/test/gl_transaction_test.rb

@@ -0,0 +1,58 @@
+require_relative 'test_helper'
+
+class GlTransactionTest < Skr::TestCase
+
+
+    def setup
+        @gle = GlManualEntry.create({ notes: 'A good test' })
+        @glt = @gle.build_gl_transaction({ description: 'test manual source', source: @gle, location: Location.default })
+    end
+
+    def test_stand_alone_creation
+        @glt.add_posting( amount: 22.1, debit: skr_gl_accounts(:cash), credit: skr_gl_accounts(:inventory) )
+        assert_saves @glt
+    end
+
+    def test_no_updates
+        glt = skr_gl_transactions(:free_hats)
+        assert_raises( ActiveRecord::ReadOnlyRecord ) do
+            glt.description = 'updated'
+            assert_saves glt
+        end
+    end
+
+    def test_no_differing_amounts
+        @glt.add_posting( amount: 22.42, debit: skr_gl_accounts(:cash), credit: skr_gl_accounts(:inventory) )
+        @glt.credits.first.amount = 18
+        refute @glt.save, "allowed saving with mismatched amounts"
+        assert_equal ['must equal debits'], @glt.errors[:credits]
+    end
+
+    def test_nested_recording
+        tran = GlTransaction.record do | glt |
+            assert_equal glt, GlTransaction.current
+            GlTransaction.record( description: '2nd level' ) do | glt2 |
+                refute_equal glt, glt2
+                assert_equal glt2, GlTransaction.current
+            end
+        end
+        assert tran.new_record?
+        assert tran.errors.empty?, "since no postings, it shouldn't attempt to save"
+        refute_saves tran
+        refute tran.errors.empty?
+    end
+
+    def test_compacting
+        tran = GlTransaction.record do | glt |
+            glt.add_posting( amount: 12.12, debit: skr_gl_accounts(:cash), credit: skr_gl_accounts(:inventory) )
+            glt.add_posting( amount: 42.42, debit: skr_gl_accounts(:cash), credit: skr_gl_accounts(:inventory) )
+            { attributes: { source: @gle, description: 'A Test', location: Location.default } }
+        end
+        assert_saves tran
+        assert_equal 1, tran.debits.size
+        assert_equal 1, tran.credits.count
+        assert_equal '54.54', tran.credits.total.to_s
+        assert_equal '-54.54', tran.debits.total.to_s
+    end
+
+end

data/test/ia_line_test.rb

@@ -0,0 +1,68 @@
+require_relative 'test_helper'
+
+class IaLineTest < Skr::TestCase
+
+
+    def test_cost_adjustment
+        ial = skr_ia_lines(:first)
+        prior_mac = ial.sku_loc.mac
+        ial.cost = 2332.33
+        ial.cost_was_set = true
+        ial.qty = -3
+        refute_saves ial
+        refute_nil ial.errors[:cost]
+
+        ial.cost_was_set =false
+        assert_saves ial
+
+        assert_in_delta prior_mac * ial.uom_size, ial.cost
+    end
+
+    def test_setting_mac_cost
+        ial = skr_ia_lines(:first)
+        il = ial.sku_loc
+        refute ial.is_applied?
+        assert_in_delta 0.64, il.mac
+        assert_nil ial.read_attribute('cost')
+        assert_equal 6.4, ial.ledger_cost
+        assert_saves ial
+        adj = ial.inventory_adjustment
+        adj.state_event='mark_applied'
+        assert_saves ial#.inventory_adjustment.mark_applied!, "marking applied failed"
+        ial.reload
+        assert ial.cost, "Cost wasn't set from sku_loc"
+        assert_in_delta 6.4, ial.cost
+    end
+
+    def test_no_mac_on_negative_qty
+        ia = InventoryAdjustment.new({
+                "reason_id" => skr_ia_reasons(:free).id,  "description"=>"A Groovy Adjustment",
+                "lines_attributes"=>[ {
+                        "qty"=>-10, "cost"=>3, "cost_was_set"=>true, "uom_code"=>"EA",
+                        "uom_size"=>1, "sku_loc_id"=> skr_sku_locs(:hatdefault).id
+                    } ],
+                "location_id"=>skr_sku_locs(:hatdefault).location.id
+            })
+        refute_saves ia, 'lines.cost'
+    end
+
+    def test_adjusting_mac_cost
+        ial = skr_ia_lines(:first)
+        il = ial.sku_loc
+        assert_equal 0.64, il.mac
+        assert_equal  25,  il.qty
+        assert_equal 16.0, il.onhand_mac_value
+        ial.cost         = 10
+        ial.qty          = 100
+        ial.uom_size     = 2
+        ial.cost_was_set = true
+        assert_equal 1000, ial.total
+        assert_saves ial
+        assert ial.inventory_adjustment.mark_applied, "Failed to mark adj as applied"
+        refute_nil ial.reload.sku_tran, "SkuTran wasn't created"
+        il.reload
+        assert_in_delta 4.515, il.mac # ( 16.0 + 1000 ) / ( 25 + 200 )
+    end
+
+
+end

data/test/ia_reason_test.rb

@@ -0,0 +1,11 @@
+require_relative 'test_helper'
+
+class IaReasonTest < Skr::TestCase
+
+    def test_gl_posting
+        il = skr_inventory_adjustments(:first)
+        il.state.must_equal 'pending'
+        il.mark_applied
+    end
+
+end

data/test/inv_line_test.rb

@@ -0,0 +1,58 @@
+require_relative 'test_helper'
+
+class InvLineTest < Skr::TestCase
+
+    def test_inventory_adjusting
+        inv = Invoice.new( customer: skr_customers(:argosity) )
+        sl = skr_sku_locs(:stringdefault)
+        inv.lines.build({
+                :sku_loc => sl, :qty => 2
+            })
+        assert_difference ->{ sl.reload.qty }, -2 do
+            assert_difference ->{ sl.reload.mac }, 0, "MAC was adjusted by invoice?" do
+                assert_saves inv
+            end
+        end
+    end
+
+    def test_setting_price
+        price = BigDecimal.new('112.54')
+        inv = Invoice.new( location: skr_locations(:default), customer: skr_customers( :bigco ) )
+        inv.lines.build(
+            sku_loc: skr_sku_locs(:hatdefault),
+            qty: 2,
+            price: price
+        )
+        assert_saves inv
+        line = inv.lines(true).first
+        assert_equal price, line.price
+        assert_equal price*2, line.extended_price
+    end
+
+    def test_no_updates
+        inv = Invoice.new( customer: skr_customers( :argosity ) )
+        inv.lines.build( sku_loc: skr_sku_locs(:hatdefault), qty: 1 )
+        assert inv.save
+        assert_raises(  ActiveRecord::ReadOnlyRecord ){ inv.lines.first.destroy }
+    end
+
+    def test_gl_posting
+        inv = Invoice.new( customer: skr_customers(:argosity) )
+        inv.lines.build({  :sku_loc => skr_sku_locs( :hatdefault ),    :qty => 1 }) # price is 3.11 from UOM
+        inv.lines.build({  :sku_loc => skr_sku_locs( :stringdefault ), :qty => 2, price: 1.8 })
+        inv.lines.build({  :sku_loc => skr_sku_locs( :glovedefault ),  :qty => 4, price: 2.1 })
+        gl = skr_gl_accounts(:inventory)
+
+        assert_difference ->{ GlPosting.count }, 2 do
+            assert_difference ->{ gl.trial_balance }, -15.11 do
+                assert_saves inv
+            end
+        end
+    end
+
+    def test_creating_with_sku
+        inv = Invoice.new( customer: skr_customers(:argosity) )
+        inv.lines.build({ sku: Sku.find_by_code('GLOVE'), qty: 1, price: 8.27 })
+        assert_saves inv
+    end
+end

data/test/inventory_adjustment_test.rb

@@ -0,0 +1,72 @@
+require_relative 'test_helper'
+
+class InventoryAdjustmentTest < Skr::TestCase
+
+    def test_state_transitioning
+        il = skr_sku_locs(:hatdefault)
+        assert_equal 25, il.qty
+        ia = InventoryAdjustment.create!({ reason: skr_ia_reasons(:free),
+            location: skr_locations(:default), description: 'A testing adjustment' })
+        ia.lines.create!({ sku_loc: il,   uom_code: 'BX',  uom_size: 10,  qty: 3 })
+
+        assert_equal 'pending', ia.state
+        assert_equal 1, ia.lines.unapplied.size
+
+        ia.mark_applied!
+        assert_equal 'applied', ia.state
+        assert ia.lines.first.is_applied?, "line wasn't applied when parent was"
+        il.reload
+        assert_equal 55, il.qty
+        assert_empty ia.lines.unapplied
+
+    end
+
+    def test_apply_while_saving
+        ia = InventoryAdjustment.create!({
+                "reason_id" => skr_ia_reasons(:free).id,  "description"=>"A Groovy Adjustment",
+                :state_event=>:mark_applied,
+                "lines_attributes"=>[ {
+                        "qty"=>10, "cost"=>3, "cost_was_set"=>true, "uom_code"=>"EA",
+                        "uom_size"=>1, "sku_loc_id"=> skr_sku_locs(:hatdefault).id
+                    } ],
+                "location_id"=>skr_sku_locs(:hatdefault).location.id
+            })
+        refute ia.new_record?
+        assert_equal 'applied', ia.state
+    end
+
+    def test_gl_postings
+        ia = InventoryAdjustment.new({
+                reason: skr_ia_reasons(:free), "description"=>"This is going to cost us",
+                state_event: :mark_applied, location: Location.default
+              })
+        assert_equal 25, skr_sku_locs( :hatdefault ).qty
+        [ :hatdefault, :stringdefault ].each do | sl |
+            ia.lines.build({
+                sku_loc: skr_sku_locs( sl ),
+                qty: 2, uom_code: 'CS', uom_size: 5,
+              })
+        end
+
+        assert_difference ->{ GlTransaction.count }, 1 do
+            assert_difference ->{ GlPosting.count }, 2 do # would be 4, except it should compact
+                assert_saves ia
+                assert_equal 'applied', ia.state
+            end
+        end
+        assert_equal 35, skr_sku_locs( :hatdefault ).qty
+        assert_equal 43, skr_sku_locs( :stringdefault ).qty
+        assert_equal '2.12', skr_sku_locs( :stringdefault ).mac.to_s
+
+        assert ia.gl_transaction, "Missing GL Transaction?"
+
+        # credits inventory
+        assert_equal '27.6', ia.gl_transaction.credits.first.amount.to_s
+        assert_equal '110001', ia.gl_transaction.credits.first.account_number
+
+        # debits marketing (free reason code)
+        assert_equal '-27.6', ia.gl_transaction.debits.first.amount.to_s
+        assert_equal '610001', ia.gl_transaction.debits.first.account_number
+    end
+
+end

data/test/invoice_test.rb

@@ -0,0 +1,63 @@
+require_relative 'test_helper'
+
+class InvoiceTest < Skr::TestCase
+
+    def test_create_from_pt
+        pt = skr_pick_tickets(:first)
+        pt.lines.each{|l| l.qty_to_ship = l.qty }
+        inv = Invoice.new
+        inv.pick_ticket = pt
+        inv.lines.from_pick_ticket!
+        assert_saves inv
+    end
+
+    def test_applying_payments
+        inv = skr_invoices(:unpaid)
+        assert_equal 'open', inv.state
+        inv.amount_paid = inv.total-10.2
+        assert_difference ->{ GlAccount.default_for(:deposit_holding).trial_balance }, inv.total-10.2 do
+            assert_saves inv
+            assert_equal 'partial', inv.state
+        end
+        inv.amount_paid += 1.12
+        assert_difference ->{ GlAccount.default_for(:deposit_holding).trial_balance }, 1.12 do
+            assert_saves inv
+            assert_equal 'partial', inv.state
+        end
+
+        assert_difference ->{ GlAccount.default_for(:deposit_holding).trial_balance }, inv.unpaid_amount do
+            inv.amount_paid = inv.total
+            assert_saves inv
+            assert_equal 'paid', inv.state
+        end
+    end
+
+    def test_applying_payments_while_saving
+        inv = Invoice.new({ customer: skr_customers(:argosity), location: skr_locations(:default) })
+        inv.lines.build({ sku_loc: skr_sku_locs(:hatdefault),   qty: 1, price: 8 })
+        inv.lines.build({ sku_loc: skr_sku_locs(:glovedefault), qty: 1, price: 2 })
+        inv.amount_paid = inv.total
+        assert_difference ->{ GlAccount.default_for(:deposit_holding).trial_balance }, 10.0 do
+            assert_saves inv
+            assert_equal 'paid', inv.state
+        end
+    end
+
+    def test_detail_view
+        inv = Invoice.with_details.where( id: skr_invoices(:unpaid).id ).first
+        assert_equal inv.sales_order.visible_id, inv.sales_order_visible_id
+        assert_equal 13.88, inv.total
+    end
+
+    def test_create_from_sales_order
+        inv = Invoice.new( sales_order: skr_sales_orders(:picking) )
+        inv.lines.from_sales_order!
+        assert_saves inv
+        assert_equal 2, inv.lines.size
+        assert_equal 3.11, inv.lines.first.price
+        assert_equal 5, inv.lines.first.qty
+        assert_equal 18.94, inv.total
+
+    end
+
+end