fin_it 0.1.0

data/test/fin_it/plan_test.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class PlanTest < 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 :units_sold do
+          value 100
+        end
+
+        variable :price_per_unit do
+          value 50
+        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: "units_sold * price_per_unit"
+
+        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
+
+        variable :operating_expenses, currency: 'USD' do
+          value 1_500, start_date: "2024-01-01", end_date: "2024-12-31"
+        end
+      end
+
+      # Define plans
+      plan :growth_scenario, description: "10% revenue growth" do
+        scale :service_revenue, 1.10
+      end
+
+      plan :cost_reduction, description: "Reduce costs by 20%" do
+        scale :operating_expenses, 0.80
+      end
+
+      plan :opening_balance_change do
+        set_opening_balance :checking, 50_000
+      end
+    end
+
+    @test_date = Date.new(2024, 6, 15)
+  end
+
+  def test_plan_class_creation
+    plan = FinIt::Plan.new(:test_plan, description: "Test")
+    assert_equal :test_plan, plan.name
+    assert_equal "Test", plan.description
+    assert_empty plan.overrides
+  end
+
+  def test_plan_set_override
+    plan = FinIt::Plan.new(:test)
+    plan.set(:revenue, 5000)
+
+    assert_equal 1, plan.overrides.length
+    assert_equal :set, plan.overrides.first[:type]
+    assert_equal :revenue, plan.overrides.first[:variable]
+    assert_equal 5000, plan.overrides.first[:value]
+  end
+
+  def test_plan_scale_override
+    plan = FinIt::Plan.new(:test)
+    plan.scale(:revenue, 1.15)
+
+    assert_equal 1, plan.overrides.length
+    assert_equal :scale, plan.overrides.first[:type]
+    assert_equal :revenue, plan.overrides.first[:variable]
+    assert_equal 1.15, plan.overrides.first[:factor]
+  end
+
+  def test_plan_adjust_override
+    plan = FinIt::Plan.new(:test)
+    plan.adjust(:revenue, 10000)
+
+    assert_equal 1, plan.overrides.length
+    assert_equal :adjust, plan.overrides.first[:type]
+    assert_equal :revenue, plan.overrides.first[:variable]
+    assert_equal 10000, plan.overrides.first[:amount]
+  end
+
+  def test_plan_formula_override
+    plan = FinIt::Plan.new(:test)
+    plan.formula(:calculated_var, "new_formula * 2")
+
+    assert_equal 1, plan.overrides.length
+    assert_equal :formula, plan.overrides.first[:type]
+    assert_equal :calculated_var, plan.overrides.first[:variable]
+    assert_equal "new_formula * 2", plan.overrides.first[:formula]
+  end
+
+  def test_plan_set_opening_balance
+    plan = FinIt::Plan.new(:test)
+    plan.set_opening_balance(:checking, 50_000)
+
+    assert_equal 1, plan.overrides.length
+    assert_equal :opening_balance, plan.overrides.first[:type]
+    assert_equal :checking, plan.overrides.first[:account]
+    assert_equal 50_000, plan.overrides.first[:amount]
+  end
+
+  def test_plan_chaining
+    plan = FinIt::Plan.new(:test)
+    result = plan
+      .scale(:revenue, 1.10)
+      .adjust(:expenses, -1000)
+      .set(:bonus, 5000)
+
+    assert_equal plan, result
+    assert_equal 3, plan.overrides.length
+  end
+
+  def test_model_has_plans
+    assert @model.plans.key?(:growth_scenario)
+    assert @model.plans.key?(:cost_reduction)
+    assert @model.plans.key?(:opening_balance_change)
+  end
+
+  def test_model_clone_creates_independent_copy
+    @model.generate_transactions(Date.new(2024, 12, 31))
+
+    cloned = @model.clone_model
+
+    # Cloned model should be a different object
+    refute_same @model, cloned
+    refute_same @model.calculator, cloned.calculator
+    refute_same @model.accounts, cloned.accounts
+    refute_same @model.categories, cloned.categories
+
+    # But values should be the same
+    assert_equal @model.accounts[:checking].opening_balance, cloned.accounts[:checking].opening_balance
+  end
+
+  def test_with_plan_returns_new_model
+    original_net_income = @model.period_net_income(
+      Date.new(2024, 1, 1), Date.new(2024, 12, 31)
+    )
+
+    growth_model = @model.with_plan(:growth_scenario)
+
+    # Original model should be unchanged
+    assert_equal original_net_income, @model.period_net_income(
+      Date.new(2024, 1, 1), Date.new(2024, 12, 31)
+    )
+
+    # Growth model should be different
+    refute_same @model, growth_model
+  end
+
+  def test_with_plan_applies_scale_override
+    @model.generate_transactions(Date.new(2024, 12, 31))
+
+    # Service revenue is 2000 monthly = 24000 annual
+    base_revenue = @model.calculator.calculate(
+      :service_revenue,
+      date: Date.new(2024, 6, 15),
+      output_currency: 'USD'
+    )
+
+    growth_model = @model.with_plan(:growth_scenario)
+    growth_model.generate_transactions(Date.new(2024, 12, 31))
+
+    scaled_revenue = growth_model.calculator.calculate(
+      :service_revenue,
+      date: Date.new(2024, 6, 15),
+      output_currency: 'USD'
+    )
+
+    # Should be 10% higher
+    expected = base_revenue.to_f * 1.10
+    assert_in_delta expected, scaled_revenue.to_f, 1.0
+  end
+
+  def test_with_plan_applies_opening_balance_override
+    assert_equal 10_000, @model.accounts[:checking].opening_balance
+
+    modified_model = @model.with_plan(:opening_balance_change)
+
+    # Original unchanged
+    assert_equal 10_000, @model.accounts[:checking].opening_balance
+
+    # Modified model has new opening balance
+    assert_equal 50_000, modified_model.accounts[:checking].opening_balance
+  end
+
+  def test_with_plans_applies_multiple
+    # Apply both growth and cost reduction
+    combined_model = @model.with_plans(:growth_scenario, :cost_reduction)
+
+    refute_same @model, combined_model
+
+    # Verify both plans were applied
+    combined_model.generate_transactions(Date.new(2024, 12, 31))
+
+    # Check that service_revenue was scaled up
+    scaled_revenue = combined_model.calculator.calculate(
+      :service_revenue,
+      date: Date.new(2024, 6, 15),
+      output_currency: 'USD'
+    )
+    base_revenue = @model.calculator.calculate(
+      :service_revenue,
+      date: Date.new(2024, 6, 15),
+      output_currency: 'USD'
+    )
+    expected_revenue = base_revenue.to_f * 1.10
+    assert_in_delta expected_revenue, scaled_revenue.to_f, 1.0
+  end
+
+  def test_with_external_plan
+    # Create plan outside of model definition
+    external_plan = FinIt::Plan.new(:external, description: "External plan")
+    external_plan.set_opening_balance(:checking, 100_000)
+
+    modified_model = @model.with_plan(external_plan)
+
+    assert_equal 10_000, @model.accounts[:checking].opening_balance
+    assert_equal 100_000, modified_model.accounts[:checking].opening_balance
+  end
+
+  def test_plan_with_temporal_scope
+    plan = FinIt::Plan.new(:q1_only, start_date: "2024-01-01", end_date: "2024-03-31")
+    plan.scale(:service_revenue, 2.0)
+
+    assert_equal Date.new(2024, 1, 1), plan.start_date
+    assert_equal Date.new(2024, 3, 31), plan.end_date
+  end
+
+  def test_model_isolation_after_multiple_operations
+    @model.generate_transactions(Date.new(2024, 12, 31))
+    base_income = @model.period_net_income(Date.new(2024, 1, 1), Date.new(2024, 12, 31))
+
+    # Create scenario A
+    scenario_a = @model.with_plan(:growth_scenario)
+    scenario_a.generate_transactions(Date.new(2024, 12, 31))
+
+    # Create scenario B
+    scenario_b = @model.with_plan(:cost_reduction)
+    scenario_b.generate_transactions(Date.new(2024, 12, 31))
+
+    # Create scenario C (both plans)
+    scenario_c = @model.with_plans(:growth_scenario, :cost_reduction)
+    scenario_c.generate_transactions(Date.new(2024, 12, 31))
+
+    # Base model should still have original value
+    @model.generate_transactions(Date.new(2024, 12, 31))
+    final_base_income = @model.period_net_income(Date.new(2024, 1, 1), Date.new(2024, 12, 31))
+
+    assert_equal base_income, final_base_income, "Base model should be unchanged after creating scenarios"
+  end
+
+  def test_plan_not_found_raises_error
+    assert_raises(ArgumentError) do
+      @model.with_plan(:nonexistent_plan)
+    end
+  end
+end

data/test/fin_it/reports/account_balance_test.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class AccountBalanceTest < 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 :credit_card do
+        type :liability
+        currency 'USD'
+        opening_balance 0
+      end
+      
+      # Income that goes to checking account
+      category :income, type: :income do
+        variable :salary, currency: 'USD', frequency: :annual, account: :checking do
+          value 100_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Annual salary"
+        end
+        
+        variable :bonus, currency: 'USD', frequency: :annual, account: :checking do
+          value 20_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Annual bonus"
+        end
+      end
+      
+      # Expenses that come from checking or credit card
+      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
+        
+        variable :utilities, currency: 'USD', frequency: :monthly, account: :checking do
+          value 300, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Monthly utilities"
+        end
+        
+        variable :groceries, currency: 'USD', frequency: :monthly, account: :credit_card do
+          value 500, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Monthly groceries"
+        end
+      end
+      
+      # Assets (checking account balance)
+      category :current_assets, type: :asset do
+        variable :checking_balance, currency: 'USD', frequency: :annual, account: :checking do
+          value 10_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Checking account balance"
+        end
+      end
+      
+      # Liabilities (credit card balance)
+      category :current_liabilities, type: :liability do
+        variable :credit_card_balance, currency: 'USD', frequency: :annual, account: :credit_card do
+          value 0, start_date: "2024-01-01", end_date: "2024-12-31"
+          description "Credit card balance"
+        end
+      end
+      
+      # Equity (to balance the sheet: Assets = Liabilities + Equity)
+      # Use calculated variable with account to get actual balance
+      category :equity, type: :equity do
+        calculated :owner_equity, formula: '0', account: :equity do
+          description "Owner's equity"
+        end
+      end
+    end
+  end
+  
+  def test_income_statement_shows_revenue
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    income_total = report_data[:totals][:income]
+    
+    # Total income: 100,000 + 20,000 = 120,000
+    assert_in_delta 120_000, income_total, 0.01, "Total income should be $120,000"
+  end
+  
+  def test_income_statement_shows_expenses
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    report_data = report.generate
+    expenses_total = report_data[:totals][:expenses]
+    
+    # Total expenses: (2,000 + 300) * 12 + (500 * 12) = 27,600 + 6,000 = 33,600
+    # Actually, these are monthly values that get annualized, so:
+    # rent: 2,000 * 12 = 24,000
+    # utilities: 300 * 12 = 3,600
+    # groceries: 500 * 12 = 6,000
+    # Total: 33,600
+    expected_expenses = (2_000 + 300 + 500) * 12
+    assert_in_delta expected_expenses, expenses_total, 1.0, "Total expenses should be correct"
+  end
+  
+  def test_balance_sheet_shows_assets
+    # Generate transactions to get actual account balances
+    @model.generate_transactions(Date.new(2024, 12, 31))
+    
+    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_total = report_data[:totals][:assets]
+    
+    # Assets: checking account balance at end of year
+    # Opening: 10,000 + Income: 120,000 - Expenses from checking: (2,000 + 300) * 12 = 27,600
+    # = 10,000 + 120,000 - 27,600 = 102,400
+    expected_assets = @model.account_balance(:checking, as_of_date: Date.new(2024, 12, 31))
+    assert_in_delta expected_assets, assets_total, 0.01, "Total assets should show checking balance"
+  end
+  
+  def test_balance_sheet_shows_liabilities
+    # Generate transactions to get actual account balances
+    @model.generate_transactions(Date.new(2024, 12, 31))
+    
+    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_total = report_data[:totals][:liabilities]
+    
+    # Liabilities: credit card balance at end of year
+    # Opening: 0 + Expenses on credit card: 500 * 12 = 6,000
+    expected_liabilities = @model.account_balance(:credit_card, as_of_date: Date.new(2024, 12, 31))
+    assert_in_delta expected_liabilities, liabilities_total, 0.01, "Total liabilities should show credit card balance"
+  end
+  
+  def test_account_opening_balances
+    checking = @model.accounts[:checking]
+    credit_card = @model.accounts[:credit_card]
+    
+    assert_equal 10_000, checking.opening_balance, "Checking should have $10,000 opening balance"
+    assert_equal 0, credit_card.opening_balance, "Credit card should have $0 opening balance"
+  end
+  
+  def test_income_variables_have_accounts
+    income_category = @model.categories.find { |c| c.name == :income }
+    assert income_category, "Should have income category"
+    
+    salary_var = income_category.variables.find { |v| v[:name] == :salary }
+    bonus_var = income_category.variables.find { |v| v[:name] == :bonus }
+    
+    assert_equal :checking, salary_var[:account], "Salary should be associated with checking account"
+    assert_equal :checking, bonus_var[:account], "Bonus should be associated with checking account"
+  end
+  
+  def test_expense_variables_have_accounts
+    expenses_category = @model.categories.find { |c| c.name == :expenses }
+    assert expenses_category, "Should have expenses category"
+    
+    rent_var = expenses_category.variables.find { |v| v[:name] == :rent }
+    groceries_var = expenses_category.variables.find { |v| v[:name] == :groceries }
+    
+    assert_equal :checking, rent_var[:account], "Rent should be associated with checking account"
+    assert_equal :credit_card, groceries_var[:account], "Groceries should be associated with credit card account"
+  end
+  
+  def test_net_income_calculation
+    income_report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    income_data = income_report.generate
+    net_income = income_data[:totals][:net_income]
+    
+    # Net income = income - expenses
+    # 120,000 - 33,600 = 86,400
+    assert net_income > 0, "Net income should be positive"
+    assert_in_delta 120_000 - 33_600, net_income, 1.0, "Net income should be income minus expenses"
+  end
+  
+  def test_both_reports_use_same_model
+    # Verify both reports can be generated from the same model
+    income_report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    balance_sheet = FinIt::Reports::BalanceSheet.new(
+      @model,
+      start_date: Date.new(2024, 1, 1),
+      end_date: Date.new(2024, 12, 31),
+      output_currency: 'USD'
+    )
+    
+    income_data = income_report.generate
+    balance_data = balance_sheet.generate
+    
+    assert income_data, "Income statement should generate"
+    assert balance_data, "Balance sheet should generate"
+    
+    # Both should have the same currency
+    assert_equal 'USD', income_data[:currency], "Income statement should be in USD"
+    assert_equal 'USD', balance_data[:currency], "Balance sheet should be in USD"
+  end
+end
+