fin_it 0.1.0

data/test/fin_it/dsl_test.rb

@@ -0,0 +1,581 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class DSLTest < Minitest::Test
+  def test_model_builder_creates_model
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        base_year 2024
+        start_date 2024
+      end
+    end
+    
+    assert model, "Model should be created"
+    assert_equal 2024, model.config[:base_year], "Config should be set"
+    assert_equal Date.new(2024, 1, 1), model.start_date, "Start date should be set"
+  end
+  
+  def test_start_date_as_year_number
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2023
+      end
+    end
+    
+    assert_equal Date.new(2023, 1, 1), model.start_date, "Start date should parse year number"
+  end
+  
+  def test_start_date_as_date_string
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date "2023-06-15"
+      end
+    end
+    
+    assert_equal Date.new(2023, 6, 15), model.start_date, "Start date should parse date string"
+  end
+  
+  def test_equity_account_auto_created
+    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
+    end
+    
+    assert model.accounts.key?(:equity), "Equity account should be auto-created"
+    assert_equal :equity, model.accounts[:equity].type, "Equity account type should be correct"
+  end
+  
+  def test_account_definition
+    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
+    end
+    
+    assert model.accounts.key?(:checking), "Account should be defined"
+    assert_equal :asset, model.accounts[:checking].type, "Account type should be set"
+    assert_equal 10_000, model.accounts[:checking].opening_balance, "Opening balance should be set"
+  end
+  
+  def test_accounts_exist
+    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
+    end
+    
+    assert model.accounts.key?(:checking), "Checking account should exist"
+    assert model.accounts.key?(:savings), "Savings account should exist"
+  end
+  
+  def test_account_opening_balances
+    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
+    end
+    
+    assert_equal 10_000, model.accounts[:checking].opening_balance, "Checking opening balance"
+    assert_equal 50_000, model.accounts[:savings].opening_balance, "Savings opening balance"
+  end
+  
+  def test_account_auto_created_for_variables_in_category
+    # Accounts are auto-created when inside income/expense categories
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      account :valid_account do
+        type :asset
+        currency 'USD'
+      end
+      
+      category :test, type: :income do
+        # Account is auto-created for variable
+        variable :bad_var, currency: 'USD' do
+          value 100
+        end
+      end
+    end
+    
+    # Verify account was auto-created
+    assert model.accounts.key?(:bad_var), "Account should be auto-created for variable in income category"
+    assert_equal :income, model.accounts[:bad_var].type, "Account type should match category type"
+  end
+  
+  def test_category_definition
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      account :checking do
+        type :asset
+        currency 'USD'
+        opening_balance 0
+      end
+      
+      category :income, type: :income, description: "Test income" do
+        variable :salary, currency: 'USD', frequency: :annual, account: :checking do
+          value 100_000
+        end
+      end
+    end
+    
+    income_category = model.categories.find { |c| c.name == :income }
+    assert income_category, "Category should be defined"
+    assert_equal :income, income_category.type, "Category type should be set"
+    assert_equal 1, income_category.variables.length, "Category should have one variable"
+  end
+  
+  def test_calculated_variable_auto_creates_accounts_in_income_category
+    # Accounts are now auto-created for calculated variables
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      category :income, type: :income do
+        calculated :revenue, formula: "1000" do
+          # Account is auto-created
+        end
+      end
+    end
+    
+    # Verify account was auto-created
+    assert model.accounts.key?(:revenue), "Account should be auto-created for calculated variable"
+    assert_equal :income, model.accounts[:revenue].type, "Account type should match category type"
+  end
+  
+  def test_account_within_category_inherits_type
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      category :assets, type: :asset, description: 'Assets' do
+        account :checking do
+          currency 'USD'
+          opening_balance 10_000
+          # type :asset is inherited from category
+        end
+      end
+    end
+    
+    assert model.accounts.key?(:checking), "Account should be defined"
+    assert_equal :asset, model.accounts[:checking].type, "Account type should be inherited from category"
+    
+    # Check that variable was automatically created
+    asset_category = model.categories.find { |c| c.name == :assets }
+    assert asset_category, "Asset category should exist"
+    assert_equal 1, asset_category.variables.length, "Category should have one variable"
+    
+    var = asset_category.variables.first
+    assert_equal :checking, var[:name], "Variable name should match account name"
+    assert_equal :checking, var[:account], "Variable should reference the account"
+  end
+  
+  def test_account_within_nested_category
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      category :assets, type: :asset, description: 'Assets' do
+        category :real_estate, description: 'Real Estate' do  # inherits type: :asset
+          account :homes do
+            currency 'USD'
+            opening_balance 500_000
+          end
+        end
+      end
+    end
+
+    assert model.accounts.key?(:homes), "Account should be defined"
+    assert_equal :asset, model.accounts[:homes].type, "Account type should be inherited"
+
+    # Check that variable was created in nested category
+    asset_category = model.categories.find { |c| c.name == :assets }
+    real_estate_category = asset_category.children.find { |c| c.name == :real_estate }
+    assert_equal 1, real_estate_category.variables.length, "Nested category should have one variable"
+    assert_equal :homes, real_estate_category.variables.first[:name], "Variable should reference account"
+  end
+  
+  def test_equity_category_custom_name
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+      
+      account :cash do
+        type :asset
+        currency 'USD'
+        opening_balance 100_000
+      end
+      
+      category :networth, type: :equity, description: 'Net Worth' do
+        # Equity account will be auto-created
+      end
+    end
+    
+    # Equity account should be auto-created
+    assert model.accounts.key?(:equity), "Equity account should be auto-created"
+    
+    # Net worth category should exist
+    networth_category = model.categories.find { |c| c.name == :networth }
+    assert networth_category, "Net worth category should exist"
+    assert_equal :equity, networth_category.type, "Category type should be equity"
+    
+    # Variable should be added to networth category
+    assert networth_category.variables.any?, "Net worth category should have variables"
+  end
+  
+  def test_account_outside_category_still_requires_type
+    error = assert_raises(ArgumentError) do
+      FinIt.define(default_currency: 'USD') do
+        config do
+          start_date 2024
+        end
+        
+        account :checking do
+          currency 'USD'
+          opening_balance 10_000
+          # Missing type - should raise error
+        end
+      end
+    end
+    
+    assert_match(/must specify type/, error.message, "Error should mention missing type")
+  end
+  
+  def test_top_level_calculated_value_no_accounts_required
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      calculated_value :profit_margin, formula: "net_income / revenue"
+    end
+
+    # Should not raise error - top-level calculated values don't need accounts
+    assert model, "Model should be created"
+  end
+
+  # === Type Inheritance Tests ===
+
+  def test_nested_category_inherits_type_from_parent
+    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
+
+      category :expenses, type: :expense do
+        category :cogs do  # No type specified - should inherit :expense
+          category :food do  # No type - should inherit :expense
+            variable :food_cost, account: :checking do
+              value 1000
+            end
+          end
+        end
+      end
+    end
+
+    expenses_cat = model.categories.find { |c| c.name == :expenses }
+    cogs_cat = expenses_cat.children.find { |c| c.name == :cogs }
+    food_cat = cogs_cat.children.find { |c| c.name == :food }
+
+    assert_equal :expense, cogs_cat.type, "COGS should inherit :expense from parent"
+    assert_equal :expense, food_cat.type, "Food should inherit :expense from grandparent"
+  end
+
+  def test_nested_category_can_override_type
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      category :operations, type: :expense do
+        category :metrics, type: :metric do  # Override type
+          variable :conversion_rate do
+            value 0.05
+          end
+        end
+      end
+    end
+
+    operations_cat = model.categories.find { |c| c.name == :operations }
+    metrics_cat = operations_cat.children.find { |c| c.name == :metrics }
+
+    assert_equal :expense, operations_cat.type
+    assert_equal :metric, metrics_cat.type, "Should use explicit type, not inherit"
+  end
+
+  def test_top_level_category_requires_type
+    error = assert_raises(ArgumentError) do
+      FinIt.define(default_currency: 'USD') do
+        config do
+          start_date 2024
+        end
+
+        category :income do  # No type - should raise
+          variable :revenue do
+            value 1000
+          end
+        end
+      end
+    end
+
+    assert_match(/must specify type/, error.message)
+  end
+
+  # === Default Account Inheritance Tests ===
+
+  def test_default_account_inherited_by_children
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      account :operating_account do
+        type :asset
+        currency 'USD'
+        opening_balance 50_000
+      end
+
+      category :revenue, type: :income, default_account: :operating_account do
+        category :sales do
+          calculated :product_sales, formula: "100 * 10"
+        end
+
+        category :services do
+          calculated :consulting, formula: "500 * 5"
+        end
+      end
+    end
+
+    revenue_cat = model.categories.find { |c| c.name == :revenue }
+    sales_cat = revenue_cat.children.find { |c| c.name == :sales }
+    services_cat = revenue_cat.children.find { |c| c.name == :services }
+
+    assert_equal :operating_account, revenue_cat.default_account
+    assert_equal :operating_account, sales_cat.default_account, "Sales should inherit default_account"
+    assert_equal :operating_account, services_cat.default_account, "Services should inherit default_account"
+  end
+
+  def test_child_category_can_override_default_account
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      account :main_account do
+        type :asset
+        currency 'USD'
+        opening_balance 50_000
+      end
+
+      account :special_account do
+        type :asset
+        currency 'USD'
+        opening_balance 10_000
+      end
+
+      category :income, type: :income, default_account: :main_account do
+        category :special, default_account: :special_account do
+          calculated :special_income, formula: "1000"
+        end
+      end
+    end
+
+    income_cat = model.categories.find { |c| c.name == :income }
+    special_cat = income_cat.children.find { |c| c.name == :special }
+
+    assert_equal :main_account, income_cat.default_account
+    assert_equal :special_account, special_cat.default_account, "Should use overridden default_account"
+  end
+
+  # === Defaults Hash Tests (frequency, start_date, end_date) ===
+
+  def test_defaults_hash_inherited_by_children
+    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
+
+      category :expenses, type: :expense,
+               default_account: :checking,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+        category :cogs do
+          calculated :food_costs, formula: "1000"
+        end
+      end
+    end
+
+    expenses_cat = model.categories.find { |c| c.name == :expenses }
+    cogs_cat = expenses_cat.children.find { |c| c.name == :cogs }
+
+    expected_defaults = { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" }
+
+    assert_equal expected_defaults, expenses_cat.defaults
+    assert_equal expected_defaults, cogs_cat.defaults, "COGS should inherit defaults from parent"
+  end
+
+  def test_child_can_merge_defaults
+    model = FinIt.define(default_currency: 'USD') do
+      config do
+        start_date 2024
+      end
+
+      account :checking do
+        type :asset
+        currency 'USD'
+      end
+
+      category :expenses, type: :expense,
+               default_account: :checking,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+        category :special, defaults: { frequency: :weekly } do  # Override frequency only
+          calculated :special_expense, formula: "500"
+        end
+      end
+    end
+
+    expenses_cat = model.categories.find { |c| c.name == :expenses }
+    special_cat = expenses_cat.children.find { |c| c.name == :special }
+
+    assert_equal :monthly, expenses_cat.defaults[:frequency]
+    assert_equal :weekly, special_cat.defaults[:frequency], "Should override frequency"
+    assert_equal "2024-01-01", special_cat.defaults[:start_date], "Should inherit start_date"
+    assert_equal "2024-12-31", special_cat.defaults[:end_date], "Should inherit end_date"
+  end
+
+  # === Formula Variable Validation Tests ===
+
+  def test_undefined_variable_in_formula_raises_error
+    error = assert_raises(FinIt::UndefinedVariableError) do
+      FinIt.define(default_currency: 'USD') do
+        config do
+          start_date 2024
+        end
+
+        account :checking do
+          type :asset
+          currency 'USD'
+        end
+
+        category :income, type: :income do
+          calculated :revenue, formula: "undefined_var * 2", account: :checking
+        end
+      end
+    end
+
+    assert_match(/revenue/, error.message, "Should mention the variable with bad formula")
+    assert_match(/undefined_var/, error.message, "Should mention the undefined variable")
+  end
+
+  def test_multiple_undefined_variables_listed_in_error
+    error = assert_raises(FinIt::UndefinedVariableError) do
+      FinIt.define(default_currency: 'USD') do
+        config do
+          start_date 2024
+        end
+
+        account :checking do
+          type :asset
+          currency 'USD'
+        end
+
+        category :income, type: :income do
+          calculated :revenue, formula: "var_a + var_b + var_c", account: :checking
+        end
+      end
+    end
+
+    assert_match(/var_a/, error.message)
+    assert_match(/var_b/, error.message)
+    assert_match(/var_c/, error.message)
+  end
+
+  def test_defined_variables_pass_validation
+    # Should not raise any error
+    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
+
+      category :drivers, type: :driver do
+        variable :units_sold do
+          value 100
+        end
+
+        variable :price_per_unit do
+          value 50
+        end
+      end
+
+      category :income, type: :income do
+        calculated :revenue, formula: "units_sold * price_per_unit", account: :checking
+      end
+    end
+
+    assert model, "Model should be created when all variables are defined"
+  end
+end
+