fin_it 0.1.0

data/test/fin_it/reports/balance_sheet_test.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class BalanceSheetTest < Minitest::Test
+  def setup
+    @model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      account :checking do
+        type :asset
+        currency 'USD'
+        opening_balance 10_000
+      end
+      
+      account :savings do
+        type :asset
+        currency 'USD'
+        opening_balance 50_000
+      end
+      
+      account :credit_card do
+        type :liability
+        currency 'USD'
+        opening_balance 5_000
+      end
+      
+      # Assets
+      category :current_assets, type: :asset do
+        variable :cash, currency: 'USD', frequency: :annual, account: :checking do
+          value 10_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Cash in checking"
+        end
+        
+        variable :savings_account, currency: 'USD', frequency: :annual, account: :savings do
+          value 50_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Savings account"
+        end
+      end
+      
+      account :equipment_account do
+        type :asset
+        currency 'USD'
+        opening_balance 25_000
+      end
+      
+      category :fixed_assets, type: :asset do
+        variable :equipment, currency: 'USD', frequency: :annual, account: :equipment_account do
+          value 25_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Equipment"
+        end
+      end
+      
+      # Liabilities
+      category :current_liabilities, type: :liability do
+        variable :credit_card_debt, currency: 'USD', frequency: :annual, account: :credit_card do
+          value 5_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Credit card debt"
+        end
+      end
+      
+      account :loan_account do
+        type :liability
+        currency 'USD'
+        opening_balance 20_000
+      end
+      
+      category :long_term_liabilities, type: :liability do
+        # Loan account already has opening balance, variable just references it
+        variable :loan, currency: 'USD', frequency: :annual, account: :loan_account do
+          value 0, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Long-term loan"
+        end
+      end
+      
+      # Equity
+      # Equity account will be auto-created with balance = Assets (85,000) - Liabilities (25,000) = 60,000
+      category :equity, type: :equity do
+        # Variable will be automatically created for the equity account
+      end
+    end
+  end
+  
+  def test_generate_balance_sheet
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    assert report_data, "Report should generate"
+    assert report_data[:sections], "Report should have sections"
+    assert report_data[:sections][:assets], "Report should have assets section"
+    assert report_data[:sections][:liabilities], "Report should have liabilities section"
+    assert report_data[:sections][:equity], "Report should have equity section"
+    assert report_data[:totals], "Report should have totals"
+  end
+  
+  def test_assets_section
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    assets_section = report_data[:sections][:assets]
+    
+    assert assets_section[:current_assets], "Should have current assets"
+    assert assets_section[:fixed_assets], "Should have fixed assets"
+    assert assets_section[:total], "Should have total assets"
+    
+    # Current assets: 10,000 + 50,000 = 60,000
+    assert_in_delta 60_000, assets_section[:current_assets], 0.01
+    # Fixed assets: 25,000
+    assert_in_delta 25_000, assets_section[:fixed_assets], 0.01
+    # Total assets: 85,000
+    assert_in_delta 85_000, assets_section[:total], 0.01
+  end
+  
+  def test_liabilities_section
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    liabilities_section = report_data[:sections][:liabilities]
+    
+    assert liabilities_section[:current_liabilities], "Should have current liabilities"
+    assert liabilities_section[:long_term_liabilities], "Should have long-term liabilities"
+    assert liabilities_section[:total], "Should have total liabilities"
+    
+    # Current liabilities: 5,000
+    assert_in_delta 5_000, liabilities_section[:current_liabilities], 0.01
+    # Long-term liabilities: 20,000
+    assert_in_delta 20_000, liabilities_section[:long_term_liabilities], 0.01
+    # Total liabilities: 25,000
+    assert_in_delta 25_000, liabilities_section[:total], 0.01
+  end
+  
+  def test_equity_section
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    equity_section = report_data[:sections][:equity]
+    
+    assert equity_section[:total], "Should have total equity"
+    # Equity: 60,000
+    assert_in_delta 60_000, equity_section[:total], 0.01
+  end
+  
+  def test_balance_sheet_equation
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    totals = report_data[:totals]
+    
+    # Balance sheet equation: Assets = Liabilities + Equity
+    # Assets: 85,000 (60,000 current + 25,000 fixed)
+    # Liabilities: 25,000 (5,000 current + 20,000 long-term)
+    # Equity: 60,000
+    # 85,000 = 25,000 + 60,000 ✓
+    
+    total_assets = totals[:assets]
+    total_liabilities = totals[:liabilities]
+    total_equity = totals[:equity]
+    total_liabilities_and_equity = totals[:total_liabilities_and_equity]
+    
+    assert_in_delta 85_000, total_assets, 0.01, "Total assets should be 85,000"
+    assert_in_delta 25_000, total_liabilities, 0.01, "Total liabilities should be 25,000"
+    assert_in_delta 60_000, total_equity, 0.01, "Total equity should be 60,000"
+    assert_in_delta 85_000, total_liabilities_and_equity, 0.01, "Total liabilities and equity should equal total assets"
+    
+    # Verify the balance sheet equation: Assets = Liabilities + Equity
+    assert_in_delta total_assets, total_liabilities_and_equity, 0.01, 
+      "Balance sheet must balance: Assets (#{total_assets}) = Liabilities + Equity (#{total_liabilities_and_equity})"
+  end
+  
+  def test_generate_at_specific_date
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    date_report = report.generate_at(Date.new(2024, 6, 15))
+    
+    assert date_report[:period], "Should have period info"
+    assert_equal Date.new(2024, 6, 15), date_report[:period][:start], "Should start on specified date"
+    assert_equal Date.new(2024, 6, 15), date_report[:period][:end], "Should end on specified date"
+    assert date_report[:report], "Should have report data"
+  end
+  
+  def test_generate_monthly_balance_sheets
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 3, 31),
+      output_currency: 'USD'
+    )
+    
+    monthly_reports = report.generate_monthly(Date.new(2024, 1, 1), Date.new(2024, 3, 31))
+    
+    assert_equal 3, monthly_reports.length, "Should generate 3 monthly balance sheets"
+    
+    # Check January report
+    jan_report = monthly_reports[0]
+    assert jan_report[:period], "Should have period info"
+    assert_equal Date.new(2024, 1, 1), jan_report[:period][:start], "January should start on Jan 1"
+    assert_equal Date.new(2024, 1, 31), jan_report[:period][:end], "January should end on Jan 31"
+    assert jan_report[:report], "Should have report data"
+  end
+  
+  def test_section_value
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    assets_value = report.section_value(:assets)
+    liabilities_value = report.section_value(:liabilities)
+    equity_value = report.section_value(:equity)
+    
+    assert assets_value, "Should have assets value"
+    assert liabilities_value, "Should have liabilities value"
+    assert equity_value, "Should have equity value"
+  end
+  
+  def test_section_count
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    assets_count = report.section_count(:assets)
+    liabilities_count = report.section_count(:liabilities)
+    equity_count = report.section_count(:equity)
+    
+    assert assets_count > 0, "Should have asset items"
+    assert liabilities_count > 0, "Should have liability items"
+    assert equity_count > 0, "Should have equity items"
+  end
+  
+  def test_assets_show_individual_variables
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    assets_section = report_data[:sections][:assets]
+    current_assets_item = assets_section[:items].find { |item| item[:name] == :current_assets }
+    
+    # Should have subcategories showing individual variables
+    assert current_assets_item[:subcategories], "Current assets should have subcategories"
+    assert_equal 2, current_assets_item[:subcategories].length, "Should have 2 current asset variables"
+    
+    # Check that cash and savings are shown separately
+    variable_names = current_assets_item[:subcategories].map { |sub| sub[:name] }
+    assert variable_names.include?(:cash), "Should show cash separately"
+    assert variable_names.include?(:savings_account), "Should show savings_account separately"
+  end
+  
+  def test_balance_sheet_validation_raises_error_when_unbalanced
+    # Create an unbalanced model
+    # Note: This test is tricky because equity account is auto-created to balance
+    # To create an unbalanced model, we need to manually set equity account balance incorrectly
+    unbalanced_model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      account :cash_account do
+        type :asset
+        currency 'USD'
+        opening_balance 100_000
+      end
+      
+      account :debt_account do
+        type :liability
+        currency 'USD'
+        opening_balance 50_000
+      end
+      
+      # Equity account will be auto-created with balance = 100,000 - 50,000 = 50,000
+      # But we'll manually override it to create imbalance
+      category :current_assets, type: :asset do
+        variable :cash, currency: 'USD', frequency: :annual, account: :cash_account do
+          value 100_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+      
+      category :current_liabilities, type: :liability do
+        variable :debt, currency: 'USD', frequency: :annual, account: :debt_account do
+          value 50_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+      
+      category :equity, type: :equity do
+        # Equity account auto-created with 50,000 balance
+        # But we'll manually add a variable that makes it unbalanced
+        variable :owner_equity, currency: 'USD', frequency: :annual do
+          value 30_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          # This makes it unbalanced: Assets (100,000) != Liabilities (50,000) + Equity (50,000 + 30,000 = 80,000)
+        end
+      end
+    end
+    
+    # Manually override equity account balance to create imbalance
+    # This simulates an unbalanced model
+    equity_account = unbalanced_model.accounts[:equity]
+    equity_account.instance_variable_set(:@opening_balance, 30_000) if equity_account
+    
+    report = FinIt::Reports::BalanceSheet.new(
+      unbalanced_model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    error = assert_raises(FinIt::Reports::BalanceSheetError) do
+      report.generate
+    end
+    
+    assert_match(/does not balance/, error.message, "Error should mention balance issue")
+    assert_match(/Assets/, error.message, "Error should mention Assets")
+    assert_match(/Liabilities \+ Equity/, error.message, "Error should mention Liabilities + Equity")
+  end
+end
+

data/test/fin_it/reports/cash_flow_statement_test.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class CashFlowStatementTest < Minitest::Test
+  def setup
+    @model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      account :checking do
+        type :asset
+        currency 'USD'
+        opening_balance 10_000
+      end
+
+      # Driver variables
+      category :drivers, type: :driver do
+        variable :sales_volume do
+          value 100
+        end
+
+        variable :unit_price do
+          value 50
+        end
+
+        variable :expense_rate do
+          value 0.30
+        end
+      end
+
+      # Income categories
+      category :income, type: :income,
+               default_account: :checking,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+
+        calculated :product_sales,
+          formula: "sales_volume * unit_price"
+
+        variable :service_revenue, currency: 'USD' do
+          value 2_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+
+      # Expense categories
+      category :expenses, type: :expense,
+               default_account: :checking,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+
+        calculated :cost_of_sales,
+          formula: "product_sales * expense_rate"
+
+        variable :operating_expenses, currency: 'USD' do
+          value 1_500, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+    end
+
+    @test_date = Date.new(2024, 6, 15)
+  end
+
+  def test_cash_flow_statement_generates
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data
+    assert report_data[:sections]
+    assert report_data[:totals]
+  end
+
+  def test_cash_flow_has_operating_section
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data[:sections][:operating], "Should have operating section"
+    assert report_data[:sections][:operating][:total].is_a?(Numeric), "Operating total should be numeric"
+  end
+
+  def test_cash_flow_has_investing_section
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data[:sections][:investing], "Should have investing section"
+  end
+
+  def test_cash_flow_has_financing_section
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data[:sections][:financing], "Should have financing section"
+  end
+
+  def test_cash_flow_calculates_net_change
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data[:sections][:net_change_in_cash], "Should have net change in cash"
+
+    net_change = report_data[:sections][:net_change_in_cash][:total]
+    operating = report_data[:sections][:operating][:total] || 0
+    investing = report_data[:sections][:investing][:total] || 0
+    financing = report_data[:sections][:financing][:total] || 0
+
+    assert_in_delta(operating + investing + financing, net_change, 0.01, "Net change should equal sum of sections")
+  end
+
+  def test_cash_flow_has_beginning_and_ending_cash
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data[:sections][:beginning_cash], "Should have beginning cash"
+    assert report_data[:sections][:ending_cash], "Should have ending cash"
+
+    beginning = report_data[:sections][:beginning_cash][:total]
+    net_change = report_data[:sections][:net_change_in_cash][:total]
+    ending = report_data[:sections][:ending_cash][:total]
+
+    assert_in_delta(beginning + net_change, ending, 0.01, "Ending cash = Beginning + Net Change")
+  end
+
+  def test_simple_display_mode
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD',
+      display_mode: :simple
+    )
+
+    report_data = report.generate
+    assert report_data[:sections][:cash_in], "Simple mode should have cash_in section"
+    assert report_data[:sections][:cash_out], "Simple mode should have cash_out section"
+  end
+
+  def test_generate_monthly
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    monthly = report.generate_monthly(Date.new(2024, 1, 1), Date.new(2024, 3, 31))
+
+    assert_equal 3, monthly.length, "Should have 3 monthly periods"
+    monthly.each do |period|
+      assert period[:period], "Each period should have period info"
+      assert period[:report], "Each period should have report data"
+    end
+  end
+
+  def test_period_summary
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    summary = report.period_summary(period_type: :monthly)
+
+    assert summary[:periods], "Should have periods"
+    assert summary[:summary], "Should have summary"
+    assert summary[:summary][:total_operating], "Summary should have total_operating"
+    assert summary[:summary][:total_net_change], "Summary should have total_net_change"
+  end
+
+  def test_totals_structure
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    totals = report_data[:totals]
+
+    assert totals[:operating], "Totals should have operating"
+    assert totals[:investing], "Totals should have investing"
+    assert totals[:financing], "Totals should have financing"
+    assert totals[:net_change_in_cash], "Totals should have net_change_in_cash"
+    assert totals[:beginning_cash], "Totals should have beginning_cash"
+    assert totals[:ending_cash], "Totals should have ending_cash"
+  end
+
+  def test_indirect_method_starts_with_net_income
+    report = FinIt::Reports::CashFlowStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 6, 30),
+      output_currency: 'USD',
+      method: :indirect
+    )
+
+    report_data = report.generate
+    operating_items = report_data[:sections][:operating][:items]
+
+    # First item should be net income in indirect method
+    assert operating_items.any? { |item| item[:name] == :net_income },
+           "Indirect method should include net income in operating section"
+  end
+end