fin_it 0.1.0

data/test/fin_it/reports/period_comparison_test.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class PeriodComparisonTest < 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
+
+      category :income, type: :income,
+               default_account: :checking,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+        variable :sales do
+          value 5_000, start_date: "2024-01-01", end_date: "2024-03-31"
+          value 6_000, start_date: "2024-04-01", end_date: "2024-06-30"
+          value 7_000, start_date: "2024-07-01", end_date: "2024-09-30"
+          value 8_000, start_date: "2024-10-01", end_date: "2024-12-31"
+        end
+      end
+
+      category :expenses, type: :expense,
+               default_account: :checking,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+        variable :rent do
+          value 1_000
+        end
+
+        variable :utilities do
+          value 200
+        end
+      end
+    end
+  end
+
+  def test_period_comparison_basic
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1 2024", start_date: "2024-01-01", end_date: "2024-03-31" },
+        { name: "Q2 2024", start_date: "2024-04-01", end_date: "2024-06-30" }
+      ],
+      metrics: [:net_income, :total_revenue],
+      output_currency: 'USD'
+    )
+
+    data = comparison.generate
+
+    assert_equal "PeriodComparison", data[:report_type]
+    assert data[:metadata]
+    assert data[:periods]
+    assert data[:variances]
+    assert_equal 2, data[:periods].length
+  end
+
+  def test_period_comparison_metadata
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1", start_date: "2024-01-01", end_date: "2024-03-31" },
+        { name: "Q2", start_date: "2024-04-01", end_date: "2024-06-30" }
+      ],
+      metrics: [:net_income],
+      output_currency: 'USD'
+    )
+
+    data = comparison.generate
+
+    assert_equal 'USD', data[:metadata][:currency]
+    assert_equal 2, data[:metadata][:periods].length
+    assert data[:metadata][:normalized_metrics]
+  end
+
+  def test_period_comparison_quarterly
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1 2024", start_date: "2024-01-01", end_date: "2024-03-31" },
+        { name: "Q2 2024", start_date: "2024-04-01", end_date: "2024-06-30" },
+        { name: "Q3 2024", start_date: "2024-07-01", end_date: "2024-09-30" },
+        { name: "Q4 2024", start_date: "2024-10-01", end_date: "2024-12-31" }
+      ],
+      metrics: [:net_income, :total_revenue, :total_expenses],
+      output_currency: 'USD'
+    )
+
+    data = comparison.generate
+
+    assert_equal 4, data[:periods].length
+
+    # Each period should have metrics
+    data[:periods].each do |period|
+      assert period[:name]
+      assert period[:start_date]
+      assert period[:end_date]
+      assert period[:metrics]
+      assert period[:metrics][:net_income]
+      assert period[:metrics][:total_revenue]
+      assert period[:metrics][:total_expenses]
+    end
+  end
+
+  def test_period_comparison_variances
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1", start_date: "2024-01-01", end_date: "2024-03-31" },
+        { name: "Q2", start_date: "2024-04-01", end_date: "2024-06-30" }
+      ],
+      metrics: [:total_revenue],
+      output_currency: 'USD'
+    )
+
+    data = comparison.generate
+
+    # First period has no variance (nil)
+    assert_nil data[:variances][0][:variances]
+
+    # Second period has variance
+    assert data[:variances][1][:variances]
+    assert data[:variances][1][:variances][:total_revenue]
+    assert data[:variances][1][:variances][:total_revenue][:absolute]
+    assert data[:variances][1][:variances][:total_revenue][:percentage]
+
+    # Q2 revenue should be higher than Q1 (6000 vs 5000)
+    assert data[:variances][1][:variances][:total_revenue][:absolute] > 0
+  end
+
+  def test_period_comparison_console_output
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1 2024", start_date: "2024-01-01", end_date: "2024-03-31" },
+        { name: "Q2 2024", start_date: "2024-04-01", end_date: "2024-06-30" }
+      ],
+      metrics: [:net_income, :total_revenue],
+      output_currency: 'USD'
+    )
+
+    output = capture_io do
+      comparison.output(FinIt::Outputs::ConsoleOutput)
+    end.first
+
+    assert_match(/PERIOD COMPARISON/, output)
+    assert_match(/Q1 2024/, output)
+    assert_match(/Q2 2024/, output)
+    assert_match(/Net Income/, output)
+    assert_match(/Total Revenue/, output)
+  end
+
+  def test_period_comparison_normalized_metrics
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1", start_date: "2024-01-01", end_date: "2024-03-31" }
+      ],
+      metrics: [:net_income, :total_revenue],
+      output_currency: 'USD'
+    )
+
+    # Test normalized_metrics accessor
+    normalized = comparison.normalized_metrics
+    assert_equal 2, normalized.length
+    assert_equal :net_income, normalized[0][:variable]
+    assert_equal "Net Income", normalized[0][:label]
+  end
+
+  def test_period_comparison_with_date_objects
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1", start_date: Date.new(2024, 1, 1), end_date: Date.new(2024, 3, 31) },
+        { name: "Q2", start_date: Date.new(2024, 4, 1), end_date: Date.new(2024, 6, 30) }
+      ],
+      metrics: [:net_income],
+      output_currency: 'USD'
+    )
+
+    data = comparison.generate
+
+    assert_equal Date.new(2024, 1, 1), data[:periods][0][:start_date]
+    assert_equal Date.new(2024, 3, 31), data[:periods][0][:end_date]
+  end
+
+  def test_currency_alias
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [{ name: "Q1", start_date: "2024-01-01", end_date: "2024-03-31" }],
+      metrics: [:net_income],
+      output_currency: 'EUR'
+    )
+
+    assert_equal 'EUR', comparison.currency
+    assert_equal 'EUR', comparison.output_currency
+  end
+
+  def test_period_comparison_multiple_metrics
+    comparison = FinIt::Reports::PeriodComparison.new(
+      @model,
+      periods: [
+        { name: "Q1", start_date: "2024-01-01", end_date: "2024-03-31" },
+        { name: "Q2", start_date: "2024-04-01", end_date: "2024-06-30" }
+      ],
+      metrics: [:net_income, :total_revenue, :total_expenses, :ending_cash, :beginning_cash],
+      output_currency: 'USD'
+    )
+
+    data = comparison.generate
+
+    # All metrics should be calculated for each period
+    data[:periods].each do |period|
+      assert period[:metrics].key?(:net_income)
+      assert period[:metrics].key?(:total_revenue)
+      assert period[:metrics].key?(:total_expenses)
+      assert period[:metrics].key?(:ending_cash)
+      assert period[:metrics].key?(:beginning_cash)
+    end
+  end
+end

data/test/fin_it/reports/restaurant_model_test.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class RestaurantModelTest < Minitest::Test
+  def setup
+    @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
+
+      # Driver variables
+      category :drivers, type: :driver do
+        variable :number_of_tables do
+          value 20, start_date: "2024-01-01", end_date: "2024-06-30"
+          value 25, start_date: "2024-07-01", end_date: "2024-12-31"
+        end
+
+        variable :tables_turned_per_day do
+          value 2.5, start_date: "2024-01-01", end_date: "2024-03-31"
+          value 3.0, start_date: "2024-04-01", end_date: "2024-12-31"
+        end
+
+        variable :revenue_per_table do
+          value 85, start_date: "2024-01-01", end_date: "2024-05-31"
+          value 95, start_date: "2024-06-01", end_date: "2024-12-31"
+        end
+
+        variable :operating_days_per_month do
+          value 28
+        end
+
+        variable :food_cost_percentage do
+          value 0.30
+        end
+
+        variable :labor_cost_percentage do
+          value 0.35
+        end
+
+        variable :beverage_percentage_of_food do
+          value 0.25
+        end
+
+        variable :takeout_orders_per_day do
+          value 45, start_date: "2024-01-01", end_date: "2024-06-30"
+          value 60, start_date: "2024-07-01", end_date: "2024-12-31"
+        end
+
+        variable :takeout_revenue_per_order do
+          value 35
+        end
+
+        variable :catering_events_per_month do
+          value 8, start_date: "2024-01-01", end_date: "2024-05-31"
+          value 12, start_date: "2024-06-01", end_date: "2024-12-31"
+        end
+
+        variable :catering_revenue_per_event do
+          value 1_200
+        end
+      end
+
+      # Income categories - using type inheritance, default_account, and defaults
+      category :revenue, type: :income,
+               default_account: :operating_account,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+
+        category :dine_in do  # inherits type: :income, default_account, and defaults
+          calculated :dine_in_revenue,
+            formula: "number_of_tables * tables_turned_per_day * revenue_per_table * operating_days_per_month"
+        end
+
+        category :takeout do  # inherits type: :income, default_account, and defaults
+          calculated :takeout_revenue,
+            formula: "takeout_orders_per_day * takeout_revenue_per_order * operating_days_per_month"
+        end
+
+        category :catering do  # inherits type: :income, default_account, and defaults
+          calculated :catering_revenue,
+            formula: "catering_events_per_month * catering_revenue_per_event"
+        end
+
+        category :beverages do  # inherits type: :income, default_account, and defaults
+          calculated :beverage_revenue,
+            formula: "(dine_in_revenue + takeout_revenue) * beverage_percentage_of_food"
+        end
+
+        calculated :total_revenue,
+          formula: "dine_in_revenue + takeout_revenue + catering_revenue + beverage_revenue"
+      end
+
+      # Expense categories - using type inheritance, default_account, and defaults
+      category :expenses, type: :expense,
+               default_account: :operating_account,
+               defaults: { frequency: :monthly, start_date: "2024-01-01", end_date: "2024-12-31" } do
+
+        category :cogs do  # inherits type: :expense, default_account, and defaults
+          calculated :food_cogs,
+            formula: "(dine_in_revenue + takeout_revenue) * food_cost_percentage"
+
+          calculated :beverage_cogs,
+            formula: "beverage_revenue * 0.20"
+
+          calculated :total_cogs,
+            formula: "food_cogs + beverage_cogs"
+        end
+
+        category :labor do  # inherits type: :expense, default_account, and defaults
+          calculated :labor_costs,
+            formula: "total_revenue * labor_cost_percentage"
+        end
+
+        category :fixed_expenses do  # inherits type: :expense, default_account, and defaults
+          variable :rent, currency: 'USD' do
+            value 8_000, start_date: "2024-01-01", end_date: "2024-12-31"
+          end
+        end
+      end
+    end
+
+    @test_date = Date.new(2024, 2, 15)
+  end
+
+  def test_driver_variables_exist
+    assert @model.calculator.variable_names.include?(:number_of_tables)
+    assert @model.calculator.variable_names.include?(:food_cost_percentage)
+  end
+
+  def test_dine_in_revenue_calculation
+    # Q1: 20 tables × 2.5 turns × $85 per table × 28 days = $119,000
+    revenue = @model.calculator.calculate(:dine_in_revenue, date: @test_date, period_type: :monthly)
+    assert revenue
+    expected = 20 * 2.5 * 85 * 28
+    assert_in_delta expected, revenue.to_f, 1.0
+  end
+
+  def test_takeout_revenue_calculation
+    # Q1: 45 orders × $35 × 28 days = $44,100
+    revenue = @model.calculator.calculate(:takeout_revenue, date: @test_date, period_type: :monthly)
+    assert revenue
+    expected = 45 * 35 * 28
+    assert_in_delta expected, revenue.to_f, 1.0
+  end
+
+  def test_catering_revenue_calculation
+    # Q1: 8 events × $1,200 = $9,600
+    revenue = @model.calculator.calculate(:catering_revenue, date: @test_date, period_type: :monthly)
+    assert revenue
+    expected = 8 * 1_200
+    assert_in_delta expected, revenue.to_f, 1.0
+  end
+
+  def test_beverage_revenue_calculation
+    dine_in = @model.calculator.calculate(:dine_in_revenue, date: @test_date, period_type: :monthly)
+    takeout = @model.calculator.calculate(:takeout_revenue, date: @test_date, period_type: :monthly)
+    beverage = @model.calculator.calculate(:beverage_revenue, date: @test_date, period_type: :monthly)
+
+    assert beverage
+    expected = (dine_in.to_f + takeout.to_f) * 0.25
+    assert_in_delta expected, beverage.to_f, 1.0
+  end
+
+  def test_total_revenue_sums_all_streams
+    total = @model.calculator.calculate(:total_revenue, date: @test_date, period_type: :monthly)
+    dine_in = @model.calculator.calculate(:dine_in_revenue, date: @test_date, period_type: :monthly)
+    takeout = @model.calculator.calculate(:takeout_revenue, date: @test_date, period_type: :monthly)
+    catering = @model.calculator.calculate(:catering_revenue, date: @test_date, period_type: :monthly)
+    beverage = @model.calculator.calculate(:beverage_revenue, date: @test_date, period_type: :monthly)
+
+    assert total
+    expected = dine_in.to_f + takeout.to_f + catering.to_f + beverage.to_f
+    assert_in_delta expected, total.to_f, 1.0
+  end
+
+  def test_cogs_calculation
+    dine_in = @model.calculator.calculate(:dine_in_revenue, date: @test_date, period_type: :monthly)
+    takeout = @model.calculator.calculate(:takeout_revenue, date: @test_date, period_type: :monthly)
+    food_cogs = @model.calculator.calculate(:food_cogs, date: @test_date, period_type: :monthly)
+
+    assert food_cogs
+    expected = (dine_in.to_f + takeout.to_f) * 0.30
+    assert_in_delta expected, food_cogs.to_f, 1.0
+  end
+
+  def test_total_cogs_sums_food_and_beverage
+    food_cogs = @model.calculator.calculate(:food_cogs, date: @test_date, period_type: :monthly)
+    beverage_cogs = @model.calculator.calculate(:beverage_cogs, date: @test_date, period_type: :monthly)
+    total_cogs = @model.calculator.calculate(:total_cogs, date: @test_date, period_type: :monthly)
+
+    assert total_cogs
+    expected = food_cogs.to_f + beverage_cogs.to_f
+    assert_in_delta expected, total_cogs.to_f, 1.0
+  end
+
+  def test_labor_costs_calculation
+    total_revenue = @model.calculator.calculate(:total_revenue, date: @test_date, period_type: :monthly)
+    labor_costs = @model.calculator.calculate(:labor_costs, date: @test_date, period_type: :monthly)
+
+    assert labor_costs
+    expected = total_revenue.to_f * 0.35
+    assert_in_delta expected, labor_costs.to_f, 1.0
+  end
+
+  def test_income_statement_generation
+    report = FinIt::Reports::IncomeStatement.new(
+      @model,
+      start_date: Date.new(2024, 2, 1),
+      end_date: Date.new(2024, 2, 28),
+      output_currency: 'USD'
+    )
+
+    report_data = report.generate
+    assert report_data
+    assert report_data[:sections][:income]
+    assert report_data[:sections][:expenses]
+    assert report_data[:totals]
+  end
+end