fin_it 0.1.0

data/test/fin_it/financial_model_test.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require_relative "../test_helper"
+
+class FinancialModelTest < 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 5_000
+      end
+      
+      account :credit_card do
+        type :liability
+        currency 'USD'
+        opening_balance 2_000  # Positive value
+      end
+      
+      category :income, type: :income do
+        variable :salary, currency: 'USD', frequency: :monthly, account: :checking do
+          value 5_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+      
+      category :expenses, type: :expense do
+        variable :rent, currency: 'USD', frequency: :monthly, account: :credit_card do
+          value 2_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+        
+        calculated :utilities,
+          formula: "500",
+          frequency: :monthly,
+          account: :credit_card,
+          start_date: "2024-01-01",
+          end_date: "2024-12-31" do
+          description "Monthly utilities"
+        end
+      end
+    end
+  end
+  
+  def test_account_balance_calculation
+    # Generate transactions up to end of February
+    @model.generate_transactions(Date.new(2024, 2, 28))
+    
+    # Checking account: opening 10,000 + 2 months salary (5,000 each) = 20,000
+    checking_balance = @model.account_balance(:checking, as_of_date: Date.new(2024, 2, 28))
+    assert_in_delta 20_000, checking_balance, 0.01, "Checking balance should be 20,000"
+    
+    # Credit card: opening 2,000 + 2 months rent (2,000 each) + 2 months utilities (500 each) = 7,000
+    # (Liabilities increase with credits, so expenses credit the liability account)
+    credit_balance = @model.account_balance(:credit_card, as_of_date: Date.new(2024, 2, 28))
+    assert_in_delta 7_000, credit_balance, 0.01, "Credit card balance should be 7,000"
+  end
+  
+  def test_transaction_queries
+    @model.generate_transactions(Date.new(2024, 3, 31))
+    
+    # Query by account
+    checking_txns = @model.transactions(account: :checking)
+    assert checking_txns.any?, "Should have transactions for checking account"
+    assert checking_txns.all? { |t| t[:debit_account] == :checking || t[:credit_account] == :checking },
+      "All transactions should involve checking account"
+    
+    # Query by date range
+    jan_txns = @model.transactions(date_range: { start: Date.new(2024, 1, 1), end: Date.new(2024, 1, 31) })
+    assert jan_txns.any?, "Should have transactions in January"
+    assert jan_txns.all? { |t| t[:date].month == 1 }, "All transactions should be in January"
+    
+    # Query by variable
+    salary_txns = @model.transactions(variable: :salary)
+    assert salary_txns.any?, "Should have salary transactions"
+    assert salary_txns.all? { |t| t[:variable] == :salary }, "All transactions should be for salary"
+  end
+  
+  def test_balance_sheet_validation
+    # Model should validate A = L + E
+    # Assets: checking 10,000 + savings 5,000 = 15,000
+    # Liabilities: credit_card 2,000 (positive value)
+    # Equity: auto-created to balance = 15,000 - 2,000 = 13,000
+    
+    assert @model.accounts.key?(:equity), "Equity account should exist"
+    equity_balance = @model.accounts[:equity].opening_balance
+    
+    total_assets = @model.accounts.values.select { |a| a.type == :asset }.sum { |a| a.opening_balance.to_f.abs }
+    total_liabilities = @model.accounts.values.select { |a| a.type == :liability }.sum { |a| a.opening_balance.to_f.abs }
+    equity_abs = equity_balance.to_f.abs
+    
+    assert_in_delta total_assets, total_liabilities + equity_abs, 0.01,
+      "Balance sheet should balance: Assets = Liabilities + Equity"
+  end
+  
+  def test_start_date_validation
+    # Test with year number
+    model1 = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2023
+      end
+      
+      account :checking do
+        type :asset
+        currency 'USD'
+        opening_balance 0
+      end
+    end
+    
+    assert_equal Date.new(2023, 1, 1), model1.start_date
+    
+    # Test with date string
+    model2 = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date "2023-06-15"
+      end
+      
+      account :checking do
+        type :asset
+        currency 'USD'
+        opening_balance 0
+      end
+    end
+    
+    assert_equal Date.new(2023, 6, 15), model2.start_date
+  end
+  
+  def test_date_validation_prevents_before_start_date
+    error = assert_raises(FinIt::StartDateValidationError) do
+      @model.account_balance(:checking, as_of_date: Date.new(2023, 12, 31))
+    end
+    
+    assert_match(/before model start_date/, error.message)
+  end
+  
+  def test_variable_value_query
+    # Get variable value for a specific period
+    jan_salary = @model.variable_value(:salary, date: Date.new(2024, 1, 15), period_type: :monthly)
+    assert jan_salary, "Salary should exist"
+    assert_in_delta 5_000, jan_salary.to_f, 0.01, "Monthly salary should be 5,000"
+    
+    # Annual value
+    annual_salary = @model.variable_value(:salary, date: Date.new(2024, 1, 15), period_type: :annual)
+    assert_in_delta 60_000, annual_salary.to_f, 0.01, "Annual salary should be 60,000"
+  end
+  
+  def test_transaction_cache_validation
+    # Initially cache should be invalid (no transactions generated)
+    assert !@model.transaction_cache_valid?, "Cache should be invalid initially"
+    
+    # Generate transactions
+    @model.generate_transactions(Date.new(2024, 12, 31))
+    
+    # Cache should now be valid
+    assert @model.transaction_cache_valid?, "Cache should be valid after generation"
+  end
+  
+  def test_default_start_date_warning
+    # Capture warning output
+    warning_output = capture_warnings do
+      model = FinIt.define(default_currency: 'USD') do
+        account :checking do
+          type :asset
+          currency 'USD'
+          opening_balance 0
+        end
+      end
+      
+      assert model.start_date, "Should have default start date"
+      assert_equal Date.new(Date.today.year, 1, 1), model.start_date
+    end
+    
+    assert_match(/Warning.*start_date/, warning_output, "Should warn about default start_date")
+  end
+  
+  private
+  
+  def capture_warnings
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = old_stderr
+  end
+end
+

data/test/fin_it/frequency_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class FrequencyTest < Minitest::Test
+  def setup
+    @model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      account :test_account do
+        type :asset
+        currency 'USD'
+      end
+      
+      category :income, type: :income do
+        variable :daily_income, currency: 'USD', frequency: :daily, account: :test_account do
+          value 100  # $100/day
+        end
+        
+        variable :monthly_salary, currency: 'USD', frequency: :monthly, account: :test_account do
+          value 5_000  # $5,000/month
+        end
+      end
+    end
+    
+    @date = Date.new(2024, 6, 15)
+  end
+
+  def test_daily_income_annualized
+    daily_annual = @model.calculator.calculate(:daily_income, date: @date, period_type: :annual).to_f
+    assert_in_delta 36_500, daily_annual, 0.01, "Daily income should annualize to $36,500"
+  end
+  
+  def test_monthly_salary_annualized
+    monthly_annual = @model.calculator.calculate(:monthly_salary, date: @date, period_type: :annual).to_f
+    assert_in_delta 60_000, monthly_annual, 0.01, "Monthly salary should annualize to $60,000"
+  end
+  
+  def test_daily_income_monthly
+    daily_monthly = @model.calculator.calculate(:daily_income, date: @date, period_type: :monthly).to_f
+    assert_in_delta 3_041.67, daily_monthly, 0.01, "Daily income should scale to $3,041.67/month"
+  end
+  
+  def test_monthly_salary_monthly
+    monthly_monthly = @model.calculator.calculate(:monthly_salary, date: @date, period_type: :monthly).to_f
+    assert_in_delta 5_000, monthly_monthly, 0.01, "Monthly salary should be $5,000/month"
+  end
+end
+

data/test/fin_it/outputs/console_output_test.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class ConsoleOutputTest < Minitest::Test
+  def setup
+    @model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      category :current_assets, type: :asset do
+        account :checking do
+          currency 'USD'
+          opening_balance 10_000
+        end
+        
+        variable :cash, currency: 'USD', frequency: :annual do
+          value 10_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+      
+      category :income, type: :income do
+        variable :salary, currency: 'USD', frequency: :annual do
+          value 100_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Annual salary"
+        end
+        
+        variable :bonus, currency: 'USD', frequency: :annual do
+          value 20_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Annual bonus"
+        end
+      end
+      
+      category :expenses, type: :expense do
+        variable :rent, currency: 'USD', frequency: :monthly, account: :checking do
+          value 2_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Monthly rent"
+        end
+      end
+      
+      category :current_liabilities, type: :liability do
+        variable :debt, currency: 'USD', frequency: :annual do
+          value 5_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+      
+      category :equity, type: :equity do
+        variable :owner_equity, currency: 'USD', frequency: :annual do
+          value 5_000, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+    end
+  end
+  
+  def test_monthly_income_statement_output
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 1, 31),
+      output_currency: 'USD'
+    )
+    
+    # Should generate output without error
+    suppress_output do
+      result = report.output(FinIt::Outputs::ConsoleOutput)
+      assert_nil result, "Output should return nil"
+    end
+  end
+  
+  def test_quarterly_income_statement_output
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 3, 31),
+      output_currency: 'USD'
+    )
+    
+    # Should generate output without error
+    suppress_output do
+      result = report.output(FinIt::Outputs::ConsoleOutput)
+      assert_nil result, "Output should return nil"
+    end
+  end
+  
+  def test_monthly_balance_sheet_output
+    report = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 1, 31),
+      output_currency: 'USD'
+    )
+    
+    # Should generate output without error
+    suppress_output do
+      result = report.output(FinIt::Outputs::ConsoleOutput)
+      assert_nil result, "Output should return nil"
+    end
+  end
+  
+  def test_generate_monthly_reports_output
+    report = FinIt::Reports::IncomeStatement.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
+    
+    # Output each monthly report - should not raise errors
+    suppress_output do
+      monthly_reports.each do |month_data|
+        temp_report = FinIt::Reports::IncomeStatement.new(
+          @model,
+          start_date: month_data[:period][:start],
+          end_date: month_data[:period][:end],
+          output_currency: 'USD'
+        )
+        
+        result = temp_report.output(FinIt::Outputs::ConsoleOutput)
+        assert_nil result, "Output should return nil"
+      end
+    end
+  end
+  
+  def test_generate_yearly_report_output
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    yearly_report = report.generate_yearly(2024)
+    
+    assert yearly_report[:period]
+    assert yearly_report[:report]
+    
+    # Output yearly report - should not raise errors
+    suppress_output do
+      temp_report = FinIt::Reports::IncomeStatement.new(
+        @model,
+        start_date: yearly_report[:period][:start],
+        end_date: yearly_report[:period][:end],
+        output_currency: 'USD'
+      )
+      
+      result = temp_report.output(FinIt::Outputs::ConsoleOutput)
+      assert_nil result, "Output should return nil"
+    end
+  end
+  
+  def test_generate_at_specific_date_output
+    report = FinIt::Reports::IncomeStatement.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]
+    assert date_report[:report]
+    
+    # Output date-specific report - should not raise errors
+    suppress_output do
+      temp_report = FinIt::Reports::IncomeStatement.new(
+        @model,
+        start_date: date_report[:period][:start],
+        end_date: date_report[:period][:end],
+        output_currency: 'USD'
+      )
+      
+      result = temp_report.output(FinIt::Outputs::ConsoleOutput)
+      assert_nil result, "Output should return nil"
+    end
+  end
+  
+  def test_balance_sheet_monthly_output
+    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, 2, 28))
+    
+    assert monthly_reports.length > 0
+    
+    # Output each monthly balance sheet - should not raise errors
+    suppress_output do
+      monthly_reports.each do |month_data|
+        temp_report = FinIt::Reports::BalanceSheet.new(
+          @model,
+          start_date: month_data[:period][:start],
+          end_date: month_data[:period][:end],
+          output_currency: 'USD'
+        )
+        
+        result = temp_report.output(FinIt::Outputs::ConsoleOutput)
+        assert_nil result, "Output should return nil"
+      end
+    end
+  end
+  
+  def test_periods_as_columns_output
+    report = FinIt::Reports::IncomeStatement.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))
+    
+    # Test output with periods as columns
+    suppress_output do
+      output = FinIt::Outputs::ConsoleOutput.new(report, periods: monthly_reports)
+      result = output.generate
+      
+      assert_nil result, "Output should return nil"
+    end
+  end
+  
+  def test_period_summary_as_columns_output
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 3, 31),
+      output_currency: 'USD'
+    )
+    
+    summary = report.period_summary(period_type: :monthly)
+    
+    # Test output with period summary as columns
+    suppress_output do
+      output = FinIt::Outputs::ConsoleOutput.new(report, periods: summary)
+      result = output.generate
+      
+      assert_nil result, "Output should return nil"
+    end
+  end
+end
+