rvgp 0.3.2

data/test/test_commodity.rb

@@ -0,0 +1,270 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+
+# Minitest class, used to test RVGP::Journal::Commodity
+class TestCommodity < Minitest::Test
+  def test_commodity_comparision_when_precision_not_equal
+    assert_equal commodity('$ 23.01'), commodity('$ 23.010')
+    assert_equal commodity('$ 23.010'), commodity('$ 23.01')
+
+    assert_equal commodity('$ 23.010'), commodity('$ 23.01')
+    assert_equal commodity('$ 23.01'), commodity('$ 23.010')
+
+    assert_equal commodity('$ 23.00'), commodity('$ 23.000000')
+    assert_equal commodity('$ 23.000000'), commodity('$ 23.00')
+
+    assert(commodity('$ 13.000') != commodity('$ 23.00'))
+    assert(commodity('$ 23.00') != commodity('$ 13.000'))
+
+    assert(commodity('$ 23.00') != commodity('$ 13.000'))
+    assert(commodity('$ 13.000') != commodity('$ 23.00'))
+  end
+
+  def test_commodity_add_and_sub_when_precision_not_equal
+    assert_equal '$ 32.00', commodity_op('$ 2', :+, '$ 30')
+    assert_equal '$ 25.01', commodity_op('$ 24.01', :+, '$ 1')
+    assert_equal '$ 46.02', commodity_op('$ 23.01', :+, '$ 23.010')
+    assert_equal '$ 15.01002', commodity_op('$ 5.000020', :+, '$ 10.010')
+    assert_equal '$ 110.00001', commodity_op('$ 10.000004', :+, '$ 100.000006')
+    assert_equal '$ 15.20', commodity_op('$ 5.1', :+, '$ 10.1')
+    assert_equal '$ 15.10', commodity_op('$ 5.10', :+, '$ 10')
+    assert_equal '$ 10.01', commodity_op('$ 5.005', :+, '$ 5.005')
+
+    assert_equal '$ 0.00', commodity_op('$ 1', :-, '$ 1')
+    assert_equal '$ 1.9996', commodity_op('$ 3.0009', :-, '$ 1.0013')
+    assert_equal '$ -1.00', commodity_op('$ 1.000000000000001', :-, '$ 2.000000000000001')
+    assert_equal '$ 0.10', commodity_op('$ 0.2', :-, '$ 0.1')
+    assert_equal '$ 0.01', commodity_op('$ 0.02', :-, '$ 0.01')
+    assert_equal '$ 0.05', commodity_op('$ 0.1', :-, '$ 0.05')
+    assert_equal '$ 0.90', commodity_op('$ 1.0', :-, '$ 0.1')
+    assert_equal '$ 0.99', commodity_op('$ 1.0', :-, '$ 0.01')
+
+    assert_equal '$ -0.10', commodity_op('$ -0.2', :-, '$ -0.1')
+    assert_equal '$ -0.01', commodity_op('$ -0.02', :-, '$ -0.01')
+    assert_equal '$ -0.05', commodity_op('$ -0.1', :-, '$ -0.05')
+    assert_equal '$ -0.90', commodity_op('$ -1.0', :-, '$ -0.1')
+    assert_equal '$ -0.99', commodity_op('$ -1.0', :-, '$ -0.01')
+
+    assert_equal '$ -0.30', commodity_op('$ -0.2', :-, '$ 0.1')
+    assert_equal '$ -0.03', commodity_op('$ -0.02', :-, '$ 0.01')
+    assert_equal '$ -0.15', commodity_op('$ -0.1', :-, '$ 0.05')
+    assert_equal '$ -1.10', commodity_op('$ -1.0', :-, '$ 0.1')
+    assert_equal '$ -1.01', commodity_op('$ -1.0', :-, '$ 0.01')
+
+    assert_equal '$ 0.30', commodity_op('$ 0.2', :-, '$ -0.1')
+    assert_equal '$ 0.03', commodity_op('$ 0.02', :-, '$ -0.01')
+    assert_equal '$ 0.15', commodity_op('$ 0.1', :-, '$ -0.05')
+    assert_equal '$ 1.10', commodity_op('$ 1.0', :-, '$ -0.1')
+    assert_equal '$ 1.01', commodity_op('$ 1.0', :-, '$ -0.01')
+  end
+
+  def test_sum
+    assert_equal commodity('$ 100.00'), ['$ 22.00', '$ 60.00', '$ 8.00', '$ 10.00'].collect { |s| commodity s }.sum
+  end
+
+  def test_commodity_mul_by_numeric
+    assert_equal commodity('$ 32.00'), commodity('$ 2') * 16
+    assert_equal commodity('$ 17.00'), commodity('$ 2') * 8.5
+    assert_equal commodity('$ 2.00'), commodity('$ 0.5') * 4
+
+    assert_equal commodity('$ -32.00'), commodity('$ -2') * 16
+    assert_equal commodity('$ -17.00'), commodity('$ -2') * 8.5
+    assert_equal commodity('$ -2.00'), commodity('$ -0.5') * 4
+
+    assert_equal commodity('$ -32.00'), commodity('$ 2') * -16
+    assert_equal commodity('$ -17.00'), commodity('$ 2') * -8.5
+    assert_equal commodity('$ -2.00'), commodity('$ 0.5') * -4
+
+    assert_equal commodity('$ 0.5000125'), commodity('$ 2.00005') * 0.25
+    assert_equal commodity('$ 0.5000125'), commodity('$ 0.25') * 2.00005
+  end
+
+  def test_commodity_div_by_numeric
+    assert_equal commodity('$ 2'), commodity('$ 32.00') / 16
+    assert_equal commodity('$ 2'), commodity('$ 17.00') / 8.5
+    assert_equal commodity('$ 0.5'), commodity('$ 2.00') / 4
+
+    assert_equal commodity('$ -2'), commodity('$ -32.00') / 16
+    assert_equal commodity('$ -2'), commodity('$ -17.00') / 8.5
+    assert_equal commodity('$ -0.5'), commodity('$ -2.00') / 4
+
+    assert_equal commodity('$ 2'), commodity('$ -32.00') / -16
+    assert_equal commodity('$ 2'), commodity('$ -17.00') / -8.5
+    assert_equal commodity('$ 0.5'), commodity('$ -2.00') / -4
+
+    assert_equal commodity('$ 2.00005'), commodity('$ 0.5000125') / 0.25
+    assert_equal commodity('$ 0.25'), commodity('$ 0.5000125') / 2.00005
+    assert_equal commodity('$ 0.005'), commodity('$ 0.01') / 2
+  end
+
+  def test_huge_decimal_sum_when_decimal_zeros
+    # This bug showed up while testing the HLedger::balance ...
+    assert_equal '$ 493.00', ['$ 443.0000000000'.to_commodity, '$ 50.0000000000'.to_commodity].sum.to_s
+    assert_equal '$ 493.10', ['$ 443.0500000000'.to_commodity, '$ 50.0500000000'.to_commodity].sum.to_s
+    assert_equal '$ 0.00', ['$ 0.0000000000'.to_commodity, '$ 0.0000000000'.to_commodity].sum.to_s
+  end
+
+  def test_round
+    assert_equal '$ 123.46', '$ 123.455'.to_commodity.round(2).to_s
+    assert_equal '$ -123.46', '$ -123.455'.to_commodity.round(2).to_s
+    assert_equal '$ 123.46', '$ 123.459999999999'.to_commodity.round(2).to_s
+    assert_equal '$ 123.454545', '$ 123.4545454545454'.to_commodity.round(6).to_s
+    assert_equal '$ -123.46', '$ -123.459999999999'.to_commodity.round(2).to_s
+    assert_equal '$ 123.45', '$ 123.454444449'.to_commodity.round(2).to_s
+    assert_equal '$ -123.45', '$ -123.454444449'.to_commodity.round(2).to_s
+    assert_equal '$ 123.44', '$ 123.44'.to_commodity.round(2).to_s
+    assert_equal '$ -123.44', '$ -123.44'.to_commodity.round(2).to_s
+    assert_equal '$ 123.4000', '$ 123.4'.to_commodity.round(4).to_s
+    assert_equal '$ -123.4000', '$ -123.4'.to_commodity.round(4).to_s
+    assert_equal '$ 123.0000', '$ 123'.to_commodity.round(4).to_s
+    assert_equal '$ -123.0000', '$ -123'.to_commodity.round(4).to_s
+    assert_equal '$ 123', '$ 123.0455555555'.to_commodity.round(0).to_s
+    assert_equal '$ -123', '$ -123.0455555555'.to_commodity.round(0).to_s
+    assert_equal '$ 1000.00', '$ 999.99999'.to_commodity.round(2).to_s
+    assert_equal '$ -1000.00', '$ -999.99999'.to_commodity.round(2).to_s
+
+    assert_equal '$ 123.45', '$ 123.454'.to_commodity.round(2).to_s
+    assert_equal '$ -123.45', '$ -123.454'.to_commodity.round(2).to_s
+
+    # Found/fixed on 2021-10-25:
+    assert_equal '$ 2584.09', '$ 2584.09'.to_commodity.round(2).to_s
+    assert_equal '$ 2584.009', '$ 2584.009'.to_commodity.round(3).to_s
+    assert_equal '$ 2584.009', '$ 2584.009'.to_commodity.round(3).to_s
+    assert_equal '$ 2584.900', '$ 2584.900'.to_commodity.round(3).to_s
+    assert_equal '$ 2584.9', '$ 2584.9'.to_commodity.round(1).to_s
+
+    # Found/fixed on 2022-11-13:
+    # The reason this is a bug, is because the mantissa begins with zero's. We
+    # had to cheange the implementation to switch to precision, from a log10() operation
+    assert_equal '$ 5.01', ('$ 139.76'.to_commodity * (22_290.0 / 622_290.0)).round(2).to_s
+  end
+
+  def test_floor
+    assert_equal '$ 123.45', '$ 123.455'.to_commodity.floor(2).to_s
+    assert_equal '$ -123.45', '$ -123.455'.to_commodity.floor(2).to_s
+    assert_equal '$ 123.45', '$ 123.459999999999'.to_commodity.floor(2).to_s
+    assert_equal '$ 123.454545', '$ 123.4545454545454'.to_commodity.floor(6).to_s
+    assert_equal '$ -123.45', '$ -123.459999999999'.to_commodity.floor(2).to_s
+    assert_equal '$ 123.45', '$ 123.454444449'.to_commodity.floor(2).to_s
+    assert_equal '$ -123.45', '$ -123.454444449'.to_commodity.floor(2).to_s
+    assert_equal '$ 123.44', '$ 123.44'.to_commodity.floor(2).to_s
+    assert_equal '$ -123.44', '$ -123.44'.to_commodity.floor(2).to_s
+    assert_equal '$ 123.4000', '$ 123.4'.to_commodity.floor(4).to_s
+    assert_equal '$ -123.4000', '$ -123.4'.to_commodity.floor(4).to_s
+    assert_equal '$ 123.0000', '$ 123'.to_commodity.floor(4).to_s
+    assert_equal '$ -123.0000', '$ -123'.to_commodity.floor(4).to_s
+    assert_equal '$ 123', '$ 123.0455555555'.to_commodity.floor(0).to_s
+    assert_equal '$ -123', '$ -123.0455555555'.to_commodity.floor(0).to_s
+    assert_equal '$ 999.99', '$ 999.99999'.to_commodity.floor(2).to_s
+    assert_equal '$ -999.99', '$ -999.99999'.to_commodity.floor(2).to_s
+
+    assert_equal '$ 123.45', '$ 123.454'.to_commodity.floor(2).to_s
+    assert_equal '$ -123.45', '$ -123.454'.to_commodity.floor(2).to_s
+
+    # Found/fixed on 2021-10-25:
+    assert_equal '$ 2584.09', '$ 2584.09'.to_commodity.floor(2).to_s
+    assert_equal '$ 2584.009', '$ 2584.009'.to_commodity.floor(3).to_s
+    assert_equal '$ 2584.009', '$ 2584.009'.to_commodity.floor(3).to_s
+    assert_equal '$ 2584.900', '$ 2584.900'.to_commodity.floor(3).to_s
+    assert_equal '$ 2584.9', '$ 2584.9'.to_commodity.floor(1).to_s
+  end
+
+  def test_to_s_features
+    assert_equal '$ 0.00', '$ 0'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 1.00', '$ 1.00'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 12.00', '$ 12.00'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 123.00', '$ 123.00'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 1,234.00', '$ 1234.00'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 12,345.00', '$ 12345.00'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 123,456.00', '$ 123456.00'.to_commodity.to_s(commatize: true)
+    assert_equal '$ 1,234,567.00', '$ 1234567.00'.to_commodity.to_s(commatize: true)
+
+    assert_equal '$ 123', '$ 123.00'.to_commodity.to_s(precision: 0)
+    assert_equal '$ 123.0', '$ 123.00'.to_commodity.to_s(precision: 1)
+    assert_equal '$ 123.00', '$ 123.00'.to_commodity.to_s(precision: 2)
+    assert_equal '$ 123.000', '$ 123.00'.to_commodity.to_s(precision: 3)
+    assert_equal '$ 123.0000', '$ 123.00'.to_commodity.to_s(precision: 4)
+
+    assert_equal '$ 123.46', '$ 123.455'.to_commodity.to_s(precision: 2)
+    assert_equal '$ 123.45', '$ 123.454'.to_commodity.to_s(precision: 2)
+    assert_equal '$ 124', '$ 123.5'.to_commodity.to_s(precision: 0)
+    assert_equal '$ 123', '$ 123.4'.to_commodity.to_s(precision: 0)
+    assert_equal '$ 1000', '$ 999.5'.to_commodity.to_s(precision: 0)
+
+    assert_equal '$ 0.00000', '$ 0'.to_commodity.to_s(precision: 5)
+
+    assert_equal '$ 1,234,567.00000', '$ 1234567.00'.to_commodity.to_s(commatize: true, precision: 5)
+  end
+
+  def test_commodity_from_s_with_double_quotes
+    # Seems like we need to support commodities in these forms, after spending
+    # some time going through the ledger documentation:
+
+    palette_cleanser = '1 FLORIDAHOME'.to_commodity
+    assert_equal 1, palette_cleanser.quantity
+    assert_equal 'FLORIDAHOME', palette_cleanser.alphabetic_code
+    assert_equal 'FLORIDAHOME', palette_cleanser.code
+    assert_equal '1 FLORIDAHOME', palette_cleanser.to_s
+
+    crab_apples = '100 "crab apples"'.to_commodity
+    assert_equal 100, crab_apples.quantity
+    assert_equal 'crab apples', crab_apples.alphabetic_code
+    assert_equal 'crab apples', crab_apples.code
+    assert_equal '100 "crab apples"', crab_apples.to_s
+
+    reverse_crab_apples = '"crab apples" 100'.to_commodity
+    assert_equal 100, reverse_crab_apples.quantity
+    assert_equal 'crab apples', reverse_crab_apples.alphabetic_code
+    assert_equal 'crab apples', reverse_crab_apples.code
+    # NOTE: We're opinionated on this, in our to_s. So, we don't return the
+    # original string
+    assert_equal '100 "crab apples"', reverse_crab_apples.to_s
+
+    pesky_code = '1 "test \\" ing"'.to_commodity
+    assert_equal 1, pesky_code.quantity
+    assert_equal 'test \\" ing', pesky_code.alphabetic_code
+    assert_equal 'test \\" ing', pesky_code.code
+    assert_equal '1 "test \\" ing"', pesky_code.to_s
+
+    reverse_pesky_code = '"test \\" ing" 1'.to_commodity
+    assert_equal 1, reverse_pesky_code.quantity
+    assert_equal 'test \\" ing', reverse_pesky_code.alphabetic_code
+    assert_equal 'test \\" ing', reverse_pesky_code.code
+    # NOTE: We're opinionated on this, in our to_s. So, we don't return the
+    # original string
+    assert_equal '1 "test \\" ing"', reverse_pesky_code.to_s
+  end
+
+  # This code path appeared, when parsing the results of '--empty' in register
+  # queries. Here's what's in the xml:
+  #  <post-amount>
+  #    <amount>
+  #    <quantity>0</quantity>
+  #    </amount>
+  #  </post-amount>
+  # For some months, when 'nothing' happens, a commodity of type '0'
+  # appears. I don't know what the 'best' thing to do is here. But, atm, I think
+  # this output suffices....
+  def test_commodity_from_string_of_zero
+    zero = RVGP::Journal::Commodity.from_symbol_and_amount(nil, '0')
+
+    assert_equal 0, zero.quantity
+    assert_nil zero.alphabetic_code
+    assert_nil zero.code
+    assert_equal '0', zero.to_s
+  end
+
+  private
+
+  def commodity(str)
+    RVGP::Journal::Commodity.from_s str
+  end
+
+  def commodity_op(lstr, operation, rstr)
+    commodity(lstr).send(operation, commodity(rstr)).to_s
+  end
+end

data/test/test_csv_reconciler.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+
+# Minitest class, used to test RVGP::Reconcilers::CsvReconciler
+class TestCsvReconciler < Minitest::Test
+  THREE_LINES = "Line 1\nLine 2\nLine 3\n"
+  THREE_LINES_WO_ENDLINE = "Line 1\nLine 2\nLine 3"
+  THREE_LINES_W_ENDLINE_AS_CHAR0 = "\nLine 2\nLine 3\n"
+
+  def test_input_file_contents
+    assert_equal THREE_LINES, input_file_contents(THREE_LINES)
+    assert_equal "Line 2\nLine 3\n", input_file_contents(THREE_LINES, 1)
+    assert_equal "Line 3\n", input_file_contents(THREE_LINES, 2)
+    assert_equal '', input_file_contents(THREE_LINES, 3)
+
+    assert_equal "Line 1\nLine 2\n", input_file_contents(THREE_LINES, nil, 1)
+    assert_equal "Line 1\n", input_file_contents(THREE_LINES, nil, 2)
+    assert_equal '', input_file_contents(THREE_LINES, nil, 3)
+
+    assert_equal "Line 2\n", input_file_contents(THREE_LINES, 1, 1)
+    assert_equal '', input_file_contents(THREE_LINES, 0, 3)
+    assert_equal '', input_file_contents(THREE_LINES, nil, 3)
+    assert_equal '', input_file_contents(THREE_LINES, 3, 0)
+    assert_equal '', input_file_contents(THREE_LINES, 3)
+    assert_equal '', input_file_contents(THREE_LINES, 1, 2)
+    assert_equal '', input_file_contents(THREE_LINES, 2, 1)
+
+    # Test the case of the first line being empty
+    assert_equal THREE_LINES_W_ENDLINE_AS_CHAR0, input_file_contents(THREE_LINES_W_ENDLINE_AS_CHAR0)
+
+    assert_equal "Line 2\nLine 3\n", input_file_contents(THREE_LINES_W_ENDLINE_AS_CHAR0, 1)
+    assert_equal "Line 3\n", input_file_contents(THREE_LINES_W_ENDLINE_AS_CHAR0, 2)
+    assert_equal '', input_file_contents(THREE_LINES_W_ENDLINE_AS_CHAR0, 3)
+
+    # Test to see what happens if we exceed the number of lines in the file
+    assert_equal '', input_file_contents(THREE_LINES, 4, 1)
+    assert_equal '', input_file_contents(THREE_LINES, 1, 4)
+    assert_equal '', input_file_contents(THREE_LINES, 4, nil)
+    assert_equal '', input_file_contents(THREE_LINES, nil, 4)
+    assert_equal '', input_file_contents(THREE_LINES, 2, 2)
+
+    # Test the case of more trims/skips than lines
+    assert_equal THREE_LINES_WO_ENDLINE, input_file_contents(THREE_LINES_WO_ENDLINE)
+    assert_equal "Line 1\nLine 2\n", input_file_contents(THREE_LINES_WO_ENDLINE, nil, 1)
+
+    assert_equal "Line 1\n", input_file_contents(THREE_LINES_WO_ENDLINE, nil, 2)
+    assert_equal '', input_file_contents(THREE_LINES_WO_ENDLINE, nil, 3)
+  end
+
+  private
+
+  # This is just to may the tests a bit easier to type
+  def input_file_contents(*args)
+    RVGP::Reconcilers::CsvReconciler.input_file_contents(*args)
+  end
+end

data/test/test_currency.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+
+# Minitest class, used to test RVGP::Journal::Currency
+class TestCurrency < Minitest::Test
+  def test_currency
+    currency = RVGP::Journal::Currency.from_code_or_symbol 'USD'
+    assert_equal 'UNITED STATES', currency.entity
+    assert_equal 'US Dollar', currency.currency
+    assert_equal 'USD', currency.alphabetic_code
+    assert_equal 840, currency.numeric_code
+    assert_equal 2, currency.minor_unit
+    assert_equal '$', currency.symbol
+  end
+
+  def test_currency_nil
+    currency = RVGP::Journal::Currency.from_code_or_symbol nil
+    assert_nil nil, currency
+  end
+end

data/test/test_fake_feed.rb

@@ -0,0 +1,228 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+require_relative '../lib/rvgp/fakers/fake_feed'
+require_relative '../lib/rvgp/fakers/fake_reconciler'
+
+# Minitest class, used to test RVGP::Fakers::FakeJournal
+class TestFakeFeed < Minitest::Test
+  def test_basic_feed
+    feed = RVGP::Fakers::FakeFeed.basic_checking from: Date.new(2020, 1, 1),
+                                                 to: Date.new(2020, 3, 31),
+                                                 post_count: 300
+
+    assert_kind_of String, feed
+
+    csv = CSV.parse feed, headers: true
+    assert_equal 300, csv.length
+
+    assert_equal ['Date', 'Type', 'Description', 'Withdrawal (-)', 'Deposit (+)',
+                  'RunningBalance'], csv.headers
+    assert_equal '01/01/2020', csv.first['Date']
+    assert_equal '03/31/2020', csv[-1]['Date']
+
+    csv.each do |row|
+      assert_kind_of String, row['Date']
+      assert_kind_of String, row['Type']
+      assert_kind_of String, row['Description']
+      assert_kind_of String, row['Withdrawal (-)']
+      assert_kind_of String, row['Deposit (+)']
+      assert_kind_of String, row['RunningBalance']
+
+      assert_match(%r{\A\d{2}/\d{2}/\d{4}\Z}, row['Date'])
+      assert !row['Type'].empty?
+      assert !row['Description'].empty?
+      assert_match(/\$ \d+\.\d{2}/,
+                   row['Withdrawal (-)'].empty? ? row['Deposit (+)'] : row['Withdrawal (-)'])
+      assert_match(/\$ -?\d+\.\d{2}/, row['RunningBalance'])
+    end
+  end
+
+  def test_descriptions_param
+    expense_descriptions = %w[Walmart Amazon Apple CVS Exxon Berkshire Google Microsoft Costco]
+    income_descriptions = %w[Uber Cyberdyne]
+    feed = RVGP::Fakers::FakeFeed.basic_checking post_count: 50,
+                                                 expense_descriptions: expense_descriptions,
+                                                 income_descriptions: income_descriptions
+
+    csv = CSV.parse feed, headers: true
+    assert_equal 50, csv.length
+    csv.each do |row|
+      if row['Withdrawal (-)'].empty?
+        assert(/\A(.+) DIRECT DEP\Z/.match(row['Description']))
+        assert_includes income_descriptions, ::Regexp.last_match(1)
+      else
+        assert_includes expense_descriptions, row['Description']
+      end
+    end
+  end
+
+  def test_entries_param
+    # There isn't an easy way to sort this, atm... so, we just test that these lines are appended
+    additional_entries = [
+      { 'Date' => Date.new(2019, 12, 31),
+        'Type' => 'VISA',
+        'Description' => 'Posting from Dec 2019',
+        'Withdrawal (-)' => '$ 9.00'.to_commodity },
+      { 'Date' => Date.new(2020, 1, 31),
+        'Type' => 'VISA',
+        'Description' => 'Posting from Jan 2020',
+        'Withdrawal (-)' => '$ 12.00'.to_commodity },
+      { 'Date' => Date.new(2020, 4, 1),
+        'Type' => 'ACH',
+        'Description' => 'Posting from Apr 2020',
+        'Deposit (+)' => '$ 8.00'.to_commodity }
+    ]
+
+    starting_balance = '$ 10000.00'.to_commodity
+
+    feed = RVGP::Fakers::FakeFeed.basic_checking from: Date.new(2020, 1, 1),
+                                                 to: Date.new(2020, 3, 31),
+                                                 post_count: 300,
+                                                 starting_balance: starting_balance,
+                                                 entries: additional_entries
+    csv = CSV.parse feed, headers: true
+
+    # First:
+    assert_equal csv[0].to_h.values,
+                 ['12/31/2019', 'VISA', 'Posting from Dec 2019', '$ 9.00', '',
+                  (starting_balance - '$ 9.00'.to_commodity).to_s]
+
+    # Middle (This just happened to consistently be element 100)
+    assert_equal csv[100].to_h.values,
+                 ['01/31/2020', 'VISA', 'Posting from Jan 2020', '$ 12.00', '',
+                  (csv[99]['RunningBalance'].to_commodity - '$ 12.00'.to_commodity).to_s]
+
+    # Last:
+    assert_equal csv[-1].to_h.values,
+                 ['04/01/2020', 'ACH', 'Posting from Apr 2020', '', '$ 8.00',
+                  (csv[-2]['RunningBalance'].to_commodity + '$ 8.00'.to_commodity).to_s]
+  end
+
+  def test_personal_checking_feed
+    duration_in_months = 12
+    from = Date.new 2020, 1, 1
+    expense_sources = [Faker::Company.name.tr('^a-zA-Z0-9 ', '')]
+    income_sources = [Faker::Company.name.tr('^a-zA-Z0-9 ', '')]
+    liability_sources = [Faker::Company.name.tr('^a-zA-Z0-9 ', '')]
+    liabilities, assets = 2.times.map do |_|
+      duration_in_months.times.map do
+        RVGP::Journal::Commodity.from_symbol_and_amount '$', Faker::Number.between(from: 0, to: 2_000_000)
+      end
+    end
+
+    categories = ['Personal:Expenses:Rent', 'Personal:Expenses:Food:Restaurants',
+                  'Personal:Expenses:Food:Groceries', 'Personal:Expenses:Drug Stores']
+
+    category_to_company = (categories.map { |category| [category, Faker::Company.name] }).to_h
+
+    monthly_expenses = (category_to_company.keys.map do |category|
+      [category_to_company[category],
+       12.times.map do |_|
+         RVGP::Journal::Commodity.from_symbol_and_amount '$', Faker::Number.between(from: 10, to: 1000)
+       end]
+    end).to_h
+
+    # This one, we'll just try something different with:
+    monthly_expenses[category_to_company['Personal:Expenses:Rent']] = ['$ 1500.00'.to_commodity] * 12
+
+    feed = RVGP::Fakers::FakeFeed.personal_checking from: from,
+                                                    to: from >> (duration_in_months - 1),
+                                                    expense_sources: expense_sources,
+                                                    income_sources: income_sources,
+                                                    monthly_expenses: monthly_expenses,
+                                                    liability_sources: liability_sources,
+                                                    liabilities_by_month: liabilities,
+                                                    assets_by_month: assets
+
+    # Ensure the running balance is making sense:
+    running_balance = nil
+    CSV.parse(feed, headers: true).each_with_index do |row, i|
+      if i.zero?
+        running_balance = row['RunningBalance'].to_commodity
+        next
+      end
+
+      running_balance -= row['Withdrawal (-)'].to_commodity unless row['Withdrawal (-)'].empty?
+      running_balance += row['Deposit (+)'].to_commodity unless row['Deposit (+)'].empty?
+
+      assert_equal running_balance.to_s, row['RunningBalance']
+    end
+
+    # Now let's ensure the Monthly balances:
+    liabilities_match, incomes_match, expenses_match = *[
+      'Personal:Liabilities', liability_sources,
+      'Personal:Income', income_sources,
+      'Personal:Expenses', expense_sources
+    ].each_slice(2).map do |category, sources|
+      sources.map do |name|
+        { match: format('/%s/', name), to: format([category, ':%s'].join, name.tr(' ', '')) }
+      end
+    end
+
+    monthly_expenses_match = category_to_company.each_with_object([]) do |pair, sum|
+      sum << { match: format('/%s/', pair.last), to: pair.first }
+    end
+
+    journal = reconcile_journal feed,
+                                income: incomes_match + liabilities_match,
+                                expense: expenses_match + liabilities_match + monthly_expenses_match
+
+    # This was kinda copy pasta'd from the ReportBase
+    result_assets, result_liabilities = %w[Assets Liabilities].collect { |acct| account_by_month acct, journal }
+
+    assert_equal duration_in_months, result_liabilities.length
+    assert_equal liabilities, result_liabilities.map(&:invert!)
+    assert_equal duration_in_months, result_assets.length
+    assert_equal assets, result_assets
+
+    # Run the monthly for each of the monthly_expenses
+    categories.each do |category|
+      category_by_month = account_by_month category, journal, :amount_in
+
+      assert_equal duration_in_months, category_by_month.length
+      assert_equal monthly_expenses[category_to_company[category]], category_by_month
+    end
+
+    assert_equal [], account_by_month('Unknown', journal)
+  end
+
+  private
+
+  def account_by_month(acct, journal_s, accrue_by = :total_in)
+    ledger = RVGP::Pta::Ledger.new
+    ledger.register(acct, monthly: true, from_s: journal_s)
+          .transactions.map do |tx|
+            assert_equal 1, tx.postings.length
+            tx.postings[0].send(accrue_by, '$')
+          end
+  end
+
+  def reconcile_journal(feed, reconciler_opts)
+    journal_file = Tempfile.open %w[rvgp_test .journal]
+
+    feed_file = Tempfile.open %w[rvgp_test .csv]
+    feed_file.write feed
+    feed_file.close
+
+    yaml_file = Tempfile.open %w[rvgp_test .yaml]
+
+    yaml_file.write RVGP::Fakers::FakeReconciler.basic_checking(
+      **{ label: 'Personal AcmeBank:Checking',
+          input_path: feed_file.path,
+          output_path: journal_file.path }.merge(reconciler_opts)
+    )
+
+    yaml_file.close
+
+    RVGP::Reconcilers::CsvReconciler.new(RVGP::Utilities::Yaml.new(yaml_file.path)).to_ledger
+  ensure
+    [feed_file, yaml_file, journal_file].each do |f|
+      f.close
+      f.unlink
+    end
+  end
+end