def setUp_decimal(self): """ Set up stock variables with Decimal inputs. """ self.initial_year = 2000 # Live on $24000/yr while working and $12000/yr in retirement: self.working = LivingExpensesStrategy( LivingExpensesStrategy.strategy_const_living_expenses, base_amount=Decimal(24000)) self.retirement = LivingExpensesStrategy( LivingExpensesStrategy.strategy_const_living_expenses, base_amount=Decimal(12000)) self.strategy = LivingExpensesStrategySchedule(self.working, self.retirement) # Simple tax treatment: 50% tax rate across the board. tax = Tax(tax_brackets={self.initial_year: {Decimal(0): Decimal(0.5)}}) # Set up a person with $50000 gross income, $2000 net income: self.person1 = Person( initial_year=self.initial_year, name="Test 1", birth_date="1 January 1980", retirement_date="31 December 2001", # next year gross_income=Decimal(50000), tax_treatment=tax, payment_timing=Timing(frequency="BW")) self.people = {self.person1}
def test_strategy_princ_pct_ret_inf(self): """ Test inflation-adjustment when living on principal. """ # Live off of 50% of the principal balance at retirement, # adjusted to inflation: method = LivingExpensesStrategy.strategy_principal_percent_ret strategy = LivingExpensesStrategy( strategy=method, rate=0.5, inflation_adjust=self.variable_inflation) # Retire in this year and advance to next year: retirement_year = self.initial_year year = retirement_year + 1 for person in self.people: person.next_year() # Determine the inflation between retirement_year and # the current year (since all figs. are in nominal terms) inflation_adjustment = self.variable_inflation( year, base_year=retirement_year) principal = self.account1.balance + self.account2.balance self.assertEqual( strategy(people=self.people, year=year, retirement_year=retirement_year), strategy.rate * principal * inflation_adjustment)
def setUp(self): """ Builds stock variables to test with. """ self.initial_year = 2000 # Simple tax treatment: 50% tax rate across the board. tax = Tax(tax_brackets={self.initial_year: {0: 0.5}}) # A person who is paid $200 gross ($100 net) every 2 weeks: timing = Timing(frequency='BW') self.person1 = Person(initial_year=self.initial_year, name="Test 1", birth_date="1 January 1980", retirement_date="31 December 2045", gross_income=5200, tax_treatment=tax, payment_timing=timing) # A person who is paid $100 gross ($50 net) every 2 weeks: self.person2 = Person(initial_year=self.initial_year, name="Test 2", birth_date="1 January 1982", retirement_date="31 December 2047", gross_income=2600, tax_treatment=tax, payment_timing=timing) # Track inflows from employment: self.available = {0.5 + i / 26: 150 for i in range(26)} self.total_available = sum(self.available.values()) # Contribute 50% of net income (i.e. $3900): self.strategy = LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_gross_percent, rate=0.5) self.forecast = LivingExpensesForecast( initial_year=self.initial_year, people={self.person1, self.person2}, living_expenses_strategy=self.strategy)
def test_run_forecast_basic(self): """ Test Forecaster.run_forecast with simple arguments. """ # Run a simple forecast with $10,000 income, $500 in annual # contributions, and $1000 in starting balances with no growth: self.forecaster = Forecaster( living_expenses_strategy=LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_const_contribution, base_amount=500, inflation_adjust=None), settings=self.settings) forecast = self.forecaster.run_forecast(people={self.person}, accounts={self.account}, debts={}) # Test that it starts and ends in the right place and that # income and total balance (principal) are correct self.assertEqual(forecast.scenario, self.scenario) # Pylint has trouble with attributes added by metaclass # pylint: disable=no-member self.assertEqual(len(forecast.principal_history), self.scenario.num_years) # pylint: enable=no-member # Test that the $500 in contributions have been added to the # initial $1000 principal by the start of year 2: self.assertAlmostEqual(forecast.principal, 1500, places=2) # Gross income should be unchanged at $10,000: self.assertAlmostEqual(forecast.income_forecast.gross_income, 10000, places=2)
def test_insufficient_income(self): """ Test a lower net income than the contribution rate. """ # Try to contribute more than net income: method = LivingExpensesStrategy.strategy_const_contribution strategy = LivingExpensesStrategy(method, 2001) # Living expenses are $0 in this case, not -$1: self.assertEqual(strategy(people=self.people), 0)
def test_const_contrib_inf(self): """ Test inflation-adjusted constant contributions. """ # Contribute $500/yr, leaving $1500/yr for living. method = LivingExpensesStrategy.strategy_const_contribution strategy = LivingExpensesStrategy(method, base_amount=Money(500), inflation_adjust=lambda year: { 2000: Decimal(0.5), 2001: Decimal(1), 2002: Decimal(2) }[year]) # Test different inflation_adjustments for different years. # 2000: the adjustment is 50% so $500 contribution is reduced # to $250, leaving $1750 for living expenses. self.assertEqual(strategy(people=self.people, year=2000), Money('1750')) # 2001: the adjustment is 100% so $500 contribution is # unchanged, leaving $1500 for living expenses. self.assertEqual(strategy(people=self.people, year=2001), Money('1500')) # 2002: the adjustment is 200% so $500 contribution is # increased to $1000, leaving $1000 for living expenses. self.assertEqual(strategy(people=self.people, year=2002), Money('1000'))
def test_decimal_inputs(self): """ Test LivingExpensesStrategy with Decimal inputs. """ # This is based on test_const_contrib_inf, with inputs # converted to Decimal. # Convert values to Decimal: self.setUp_decimal() # Contribute $250/yr in the first year and double it each year: method = LivingExpensesStrategy.strategy_const_contribution inflation_schedule = { 2000: Decimal(0.5), 2001: Decimal(1), 2002: Decimal(2) } strategy = LivingExpensesStrategy( method, base_amount=Decimal(500), inflation_adjust=lambda year: inflation_schedule[year]) # In 2000, contribute $250, leaving $1750 for living expenses. self.assertEqual(strategy(people=self.people, year=2000), Decimal(1750)) # 2001: the adjustment is 100% so $500 contribution is # unchanged, leaving $1500 for living expenses. self.assertEqual(strategy(people=self.people, year=2001), Decimal(1500)) # 2002: the adjustment is 200% so $500 contribution is # increased to $1000, leaving $1000 for living expenses. self.assertEqual(strategy(people=self.people, year=2002), Decimal(1000))
def test_strategy_gross_pct_ret_inf(self): """ Test inflation-adjustment when living on gross income. """ # Live off of 50% of gross income at retirement, # adjusted to inflation: method = LivingExpensesStrategy.strategy_gross_percent_ret strategy = LivingExpensesStrategy( strategy=method, rate=0.5, inflation_adjust=self.variable_inflation) # Retire in this year, advance to next year, set income to $0 # (record income first, since this is the year that matters): gross_income = sum(person.gross_income for person in self.people) retirement_year = self.initial_year year = retirement_year + 1 for person in self.people: person.next_year() person.gross_income = 0 person.net_income = 0 # Determine the inflation between retirement_year and # the current year (since all figs. are in nominal terms) inflation_adjustment = self.variable_inflation( year, base_year=retirement_year) self.assertEqual( strategy(people=self.people, year=year, retirement_year=retirement_year), strategy.rate * gross_income * inflation_adjustment)
def test_minimum(self): """ Test minimum living expenses. """ self.strategy.minimum = LivingExpensesStrategy( LivingExpensesStrategy.strategy_const_living_expenses, base_amount=18000) self.assertEqual( self.strategy(year=2001, retirement_year=2000, people=self.people), 18000)
def test_init_default(self): """ Test LivingExpensesStrategy.__init__ with default args.""" # Test default init: method = "Constant contribution" strategy = LivingExpensesStrategy(method) self.assertEqual(strategy.strategy, method) self.assertEqual(strategy.base_amount, 0) self.assertEqual(strategy.rate, 0)
def test_strategy_gross_percent(self): """ Test living off percentage of gross income. """ # Live on 50% of gross income: method = LivingExpensesStrategy.strategy_gross_percent strategy = LivingExpensesStrategy(method, rate=0.5) gross_income = sum(person.gross_income for person in self.people) self.assertEqual(strategy(people=self.people), gross_income * strategy.rate)
def test_strategy_net_percent(self): """ Test LivingExpensesStrategy.strategy_net_percent. """ # Live on 50% of net income: method = LivingExpensesStrategy.strategy_net_percent strategy = LivingExpensesStrategy(method, rate=0.5) net_income = sum(person.net_income for person in self.people) self.assertEqual(strategy(people=self.people), net_income * strategy.rate)
def test_strategy_earnings_percent(self): """ Test living off of percentage of earnings over a base amount. """ # Live off the first $1000 plus 50% of amounts above that: method = LivingExpensesStrategy.strategy_percent_over_base strategy = LivingExpensesStrategy(method, base_amount=1000, rate=0.5) # The test people earn $2000 net. They spend $1000 plus # another $500 for a total of $1500. self.assertEqual(strategy(people=self.people), 1500)
def test_strategy_const_living_exp(self): """ Test LivingExpensesStrategy.strategy_const_living_expenses. """ # Rather than hardcode the key, let's look it up here. method = LivingExpensesStrategy.strategy_const_living_expenses # Contribute $1000 annually, regardless of income: strategy = LivingExpensesStrategy(method, base_amount=1000) # This method requires net_income self.assertEqual(strategy(people=self.people), 1000)
def test_strategy_const_contrib(self): """ Test LivingExpensesStrategy.strategy_const_contribution. """ # Rather than hardcode the key, let's look it up here. method = LivingExpensesStrategy.strategy_const_contribution # Default strategy. Set to $1 constant contributions. strategy = LivingExpensesStrategy(method, base_amount=1) # Test all default parameters (no inflation adjustments here) self.assertAlmostEqual( strategy(people=self.people), sum(person.net_income for person in self.people) - strategy.base_amount)
def test_init(self): """ Test LivingExpensesStrategy.__init__ """ # Test default init: method = "Constant contribution" strategy = LivingExpensesStrategy(method) self.assertEqual(strategy.strategy, method) self.assertEqual(strategy.base_amount, Money(0)) self.assertEqual(strategy.rate, Decimal(0)) # Test explicit init: method = 'Constant contribution' base_amount = Money('1000') rate = Decimal('0.5') inflation_adjust = self.variable_inflation strategy = LivingExpensesStrategy(strategy=method, base_amount=base_amount, rate=rate, inflation_adjust=inflation_adjust) self.assertEqual(strategy.strategy, method) self.assertEqual(strategy.base_amount, base_amount) self.assertEqual(strategy.rate, rate) self.assertEqual(strategy.inflation_adjust, inflation_adjust) # Test invalid strategies with self.assertRaises(ValueError): strategy = LivingExpensesStrategy(strategy='Not a strategy') with self.assertRaises(TypeError): strategy = LivingExpensesStrategy(strategy=1) # Test invalid base_amount with self.assertRaises(decimal.InvalidOperation): strategy = LivingExpensesStrategy(strategy=method, base_amount='a') # Test invalid rate with self.assertRaises(decimal.InvalidOperation): strategy = LivingExpensesStrategy(strategy=method, rate='a')
def test_gross_percent_inf(self): """ Test inflation-adjusted gross-percent living expenses. """ # Live on 50% of gross income, and also provide inflation-adjust: method = LivingExpensesStrategy.strategy_gross_percent strategy = LivingExpensesStrategy( strategy=method, rate=0.5, inflation_adjust=self.variable_inflation) # Since gross_income is nominal, inflation should have no effect: gross_income = sum(person.gross_income for person in self.people) self.assertEqual(strategy(people=self.people, year=2000), gross_income * strategy.rate) self.assertEqual(strategy(people=self.people, year=2002), gross_income * strategy.rate)
def test_const_living_exp_inf(self): """ Test inflation-adjusted constant living expenses. """ # Contribute $1000 every year, adjusted to inflation: method = LivingExpensesStrategy.strategy_const_living_expenses strategy = LivingExpensesStrategy( strategy=method, inflation_adjust=self.variable_inflation, base_amount=1000) self.assertEqual(strategy(year=2000), strategy.base_amount * self.variable_inflation(2000)) self.assertEqual(strategy(year=2001), strategy.base_amount * self.variable_inflation(2001)) self.assertEqual(strategy(year=2002), strategy.base_amount * self.variable_inflation(2002))
def test_living_const_contrib(self): """ Test living expenses based on constant contribution. """ # Contribute $100 and live off the rest: self.strategy = LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_const_contribution, base_amount=100) self.forecast.living_expenses_strategy = self.strategy # It _is_ necessary to record inflows from employment # for this strategy: self.forecast(self.available) # Calculate manually and compare results: living_expenses = self.total_available - 100 self.assertEqual(living_expenses, self.forecast.living_expenses)
def test_living_gross_percent(self): """ Test living expenses based on percent of gross income. """ # Contribute 50% of gross income: self.strategy = LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_gross_percent, rate=0.5) self.forecast.living_expenses_strategy = self.strategy # It's not necessary to record inflows from employment, # but since this is usually how it'll be called we do # so here: self.forecast(self.available) # Calculate manually and compare results: living_expenses = (self.person1.gross_income + self.person2.gross_income) / 2 self.assertEqual(living_expenses, self.forecast.living_expenses)
def test_living_const_living(self): """ Test living expenses based on constant living expenses. """ # Live off of $1200/yr: self.strategy = LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_const_living_expenses, base_amount=Money(1200)) self.forecast.living_expenses_strategy = self.strategy # It's not necessary to record inflows from employment, # but since this is usually how it'll be called we do # so here: self.forecast(self.available) # Calculate manually and compare results: living_expenses = Money(1200) self.assertEqual(living_expenses, self.forecast.living_expenses)
def test_living_earnings_pct(self): """ Test living expenses based on percentage of raises. """ # Live off of $1200/yr: self.strategy = LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_percent_over_base, base_amount=1200) self.forecast.living_expenses_strategy = self.strategy # It's not necessary to record inflows from employment, # but since this is usually how it'll be called we do # so here: self.forecast(self.available) # Calculate manually and compare results: living_expenses = 1200 self.assertEqual(living_expenses, self.forecast.living_expenses)
def test_init_decimal(self): """ Tests init with Decimal inputs. """ method = 'Constant contribution' base_amount = Decimal(1000) rate = Decimal(0.5) def inflation_adjust(year, base_year=self.year_1): return Decimal(self.variable_inflation(year, base_year=base_year)) strategy = LivingExpensesStrategy(strategy=method, base_amount=base_amount, rate=rate, inflation_adjust=inflation_adjust) self.assertEqual(strategy.strategy, method) self.assertEqual(strategy.base_amount, base_amount) self.assertEqual(strategy.rate, rate) self.assertEqual(strategy.inflation_adjust, inflation_adjust)
def test_strategy_principal_pct_ret(self): """ Test living off of percentage of principal at retirement. """ # Live off of 50% of the principal balance at retirement: method = LivingExpensesStrategy.strategy_principal_percent_ret strategy = LivingExpensesStrategy(strategy=method, rate=0.5) # Retire in this year and advance to next year: retirement_year = self.initial_year year = retirement_year + 1 for person in self.people: person.next_year() principal = self.account1.balance + self.account2.balance self.assertEqual( strategy(people=self.people, year=year, retirement_year=retirement_year), strategy.rate * principal)
def test_earnings_percent_inf(self): """ Test inflation-adjusted earnings-percent living expenses. """ # Live off the first $1000 plus 50% of amounts above that: method = LivingExpensesStrategy.strategy_percent_over_base strategy = LivingExpensesStrategy( strategy=method, base_amount=1000, rate=0.5, inflation_adjust=self.variable_inflation) # 1999: Adjustment is 50%, so live on $500 plus 50% of # remaining $1500 (i.e. $750) for a total of $1250: self.assertAlmostEqual( strategy(people=self.people, year=self.year_half), 1250) # 2000: Adjustment is 100%; should yield the usual $1500: self.assertAlmostEqual(strategy(people=self.people, year=self.year_1), 1500) # 2001: Adjustment is 200%, so live on $2000. That's all # of the net income, so the 50% rate doesn't apply: self.assertAlmostEqual(strategy(people=self.people, year=self.year_2), 2000)
def test_strategy_gross_pct_ret(self): """ Test living off of gross income at retirement. """ # Live off of 50% of gross income at retirement: method = LivingExpensesStrategy.strategy_gross_percent_ret strategy = LivingExpensesStrategy(strategy=method, rate=0.5) # Retire in this year, advance to next year, set income to $0 # (record income first, since this is the year that matters): gross_income = sum(person.gross_income for person in self.people) retirement_year = self.initial_year year = retirement_year + 1 for person in self.people: person.next_year() person.gross_income = 0 person.net_income = 0 self.assertEqual( strategy(people=self.people, year=year, retirement_year=retirement_year), strategy.rate * gross_income)
def setUp_decimal(self): """ Builds stock variables to test with. """ # pylint: disable=invalid-name # Pylint doesn't like `setUp_decimal`, but it's not our naming # convention, so don't complain to us! # pylint: enable=invalid-name self.initial_year = 2000 # Simple tax treatment: 50% tax rate across the board. tax = Tax(tax_brackets={self.initial_year: {Decimal(0): Decimal(0.5)}}) # A person who is paid $200 gross ($100 net) every 2 weeks: timing = Timing(frequency='BW', high_precision=Decimal) self.person1 = Person(initial_year=self.initial_year, name="Test 1", birth_date="1 January 1980", retirement_date="31 December 2045", gross_income=Decimal(5200), tax_treatment=tax, payment_timing=timing) # A person who is paid $100 gross ($50 net) every 2 weeks: self.person2 = Person(initial_year=self.initial_year, name="Test 2", birth_date="1 January 1982", retirement_date="31 December 2047", gross_income=Decimal(2600), tax_treatment=tax, payment_timing=timing) # Track inflows from employment: self.available = { Decimal(0.5 + i) / 26: Decimal(150) for i in range(26) } self.total_available = sum(self.available.values()) # Contribute 50% of net income (i.e. $3900): self.strategy = LivingExpensesStrategy( strategy=LivingExpensesStrategy.strategy_gross_percent, rate=Decimal(0.5)) self.forecast = LivingExpensesForecast( initial_year=self.initial_year, people={self.person1, self.person2}, living_expenses_strategy=self.strategy)
def setUp(self): """ Builds default strategies, persons, etc. """ # Use a default settings object: # (This is conditional so that subclasses can assign their own # settings object before calling super().setUp()) if not hasattr(self, 'settings'): self.settings = Settings() # To simplify tests, modify Settings so that forecasts are # just 2 years with easy-to-predict contributions ($1000/yr) self.settings.num_years = 2 self.settings.living_expenses_strategy = ( LivingExpensesStrategy.strategy_const_contribution) self.settings.living_expenses_base_amount = 1000 # Allow subclasses to use subclasses of Forecaster by assigning # to forecaster_type if not hasattr(self, 'forecaster_type'): self.forecaster_type = Forecaster # Build default `SubForecast` inputs based on `settings`: self.initial_year = self.settings.initial_year self.scenario = Scenario(inflation=self.settings.inflation, stock_return=self.settings.stock_return, bond_return=self.settings.bond_return, other_return=self.settings.other_return, management_fees=self.settings.management_fees, initial_year=self.settings.initial_year, num_years=self.settings.num_years) self.living_expenses_strategy = LivingExpensesStrategy( strategy=self.settings.living_expenses_strategy, base_amount=self.settings.living_expenses_base_amount, rate=self.settings.living_expenses_rate, inflation_adjust=self.scenario.inflation_adjust) self.saving_strategy = TransactionStrategy( strategy=self.settings.saving_strategy, weights=self.settings.saving_weights) self.withdrawal_strategy = TransactionStrategy( strategy=self.settings.withdrawal_strategy, weights=self.settings.withdrawal_weights) self.allocation_strategy = AllocationStrategy( strategy=self.settings.allocation_strategy, min_equity=self.settings.allocation_min_equity, max_equity=self.settings.allocation_max_equity, target=self.settings.allocation_target, standard_retirement_age=( self.settings.allocation_std_retirement_age), risk_transition_period=self.settings.allocation_risk_trans_period, adjust_for_retirement_plan=( self.settings.allocation_adjust_retirement)) self.debt_payment_strategy = DebtPaymentStrategy( strategy=self.settings.debt_payment_strategy) self.tax_treatment = Tax( tax_brackets=self.settings.tax_brackets, personal_deduction=self.settings.tax_personal_deduction, credit_rate=self.settings.tax_credit_rate, inflation_adjust=self.scenario.inflation_adjust) # Now build some Ledger objects to test against: # A person making $10,000/yr self.person = Person(initial_year=self.initial_year, name="Test 1", birth_date="1 January 1980", retirement_date="31 December 2040", gross_income=10000, raise_rate=0, spouse=None, tax_treatment=self.tax_treatment) # An account with $1000 in it (and no interest) self.account = Account(owner=self.person, balance=1000) # A debt with a $100 balance (and no interest) self.debt = Debt(owner=self.person, balance=100) # Init a Forecaster object here for convenience: self.forecaster = self.forecaster_type(settings=self.settings)
def setUp_decimal(self): """ Builds default strategies/persons/etc. with Decimal inputs. """ # pylint: disable=invalid-name # This name is based on `setUp`, which doesn't follow Pylint's rules # pylint: enable=invalid-name # Use a default settings object: # (This is conditional so that subclasses can assign their own # settings object before calling super().setUp()) if not hasattr(self, 'settings'): self.settings = Settings() # To simplify tests, modify Settings so that forecasts are # just 2 years with easy-to-predict contributions ($1000/yr) self.settings.num_years = 2 self.settings.living_expenses_strategy = ( LivingExpensesStrategy.strategy_const_contribution) self.settings.living_expenses_base_amount = Decimal(1000) # Allow subclasses to use subclasses of Forecaster by assigning # to forecaster_type if not hasattr(self, 'forecaster_type'): self.forecaster_type = Forecaster # Build default `SubForecast` inputs based on `settings`: self.initial_year = self.settings.initial_year self.scenario = Scenario( inflation=Decimal(self.settings.inflation), stock_return=Decimal(self.settings.stock_return), bond_return=Decimal(self.settings.bond_return), other_return=Decimal(self.settings.other_return), management_fees=Decimal(self.settings.management_fees), initial_year=self.settings.initial_year, num_years=self.settings.num_years) self.living_expenses_strategy = LivingExpensesStrategy( strategy=self.settings.living_expenses_strategy, base_amount=Decimal(self.settings.living_expenses_base_amount), rate=Decimal(self.settings.living_expenses_rate), inflation_adjust=self.scenario.inflation_adjust) self.saving_strategy = TransactionStrategy( strategy=self.settings.saving_strategy, weights={ year: Decimal(val) for (year, val) in self.settings.saving_weights.items() }) self.withdrawal_strategy = TransactionStrategy( strategy=self.settings.withdrawal_strategy, weights={ year: Decimal(val) for (year, val) in self.settings.withdrawal_weights.items() }) self.allocation_strategy = AllocationStrategy( strategy=self.settings.allocation_strategy, min_equity=Decimal(self.settings.allocation_min_equity), max_equity=Decimal(self.settings.allocation_max_equity), target=Decimal(self.settings.allocation_target), standard_retirement_age=( self.settings.allocation_std_retirement_age), risk_transition_period=self.settings.allocation_risk_trans_period, adjust_for_retirement_plan=( self.settings.allocation_adjust_retirement)) self.debt_payment_strategy = DebtPaymentStrategy( strategy=self.settings.debt_payment_strategy, high_precision=Decimal) self.tax_treatment = Tax( tax_brackets={ year: { Decimal(lower): Decimal(upper) } for (year, vals) in self.settings.tax_brackets.items() for (lower, upper) in vals.items() }, personal_deduction={ year: Decimal(val) for (year, val) in self.settings.tax_personal_deduction.items() }, credit_rate={ year: Decimal(val) for (year, val) in self.settings.tax_credit_rate.items() }, inflation_adjust=self.scenario.inflation_adjust, high_precision=Decimal) # Now build some Ledger objects to test against: # A person making $10,000/yr self.person = Person(initial_year=self.initial_year, name="Test 1", birth_date="1 January 1980", retirement_date="31 December 2040", gross_income=Decimal(10000), raise_rate=Decimal(0), spouse=None, tax_treatment=self.tax_treatment, high_precision=Decimal) # An account with $1000 in it (and no interest) self.account = Account(owner=self.person, balance=Decimal(1000), high_precision=Decimal) # A debt with a $100 balance (and no interest) self.debt = Debt(owner=self.person, balance=Decimal(100), high_precision=Decimal) # Init a Forecaster object here for convenience: self.forecaster = self.forecaster_type(settings=self.settings, high_precision=Decimal)
def test_invalid_strategies(self): """ Tests invalid strategies. """ with self.assertRaises(ValueError): _ = LivingExpensesStrategy(strategy='Not a strategy') with self.assertRaises(TypeError): _ = LivingExpensesStrategy(strategy=1)