diff --git a/tests/core/conftest.py b/tests/core/conftest.py new file mode 100644 index 0000000000..572a934a51 --- /dev/null +++ b/tests/core/conftest.py @@ -0,0 +1,197 @@ +# -*- coding: utf-8 -*- + +from pytest import fixture + +from openfisca_country_template import CountryTaxBenefitSystem +from openfisca_country_template.entities import * # noqa analysis:ignore + +from openfisca_core.simulation_builder import SimulationBuilder +from openfisca_core.tools.test_runner import yaml +from openfisca_core.variables import Variable +from openfisca_core.periods import ETERNITY +from openfisca_core.entities import Entity, GroupEntity +from openfisca_core.model_api import * # noqa analysis:ignore + + +# PERIODS + +@fixture +def period(): + return "2016-01" + + +# ENTITIES + + +class TestVariable(Variable): + definition_period = ETERNITY + value_type = float + + def __init__(self, entity): + self.__class__.entity = entity + super().__init__() + + +@fixture +def persons(): + class TestPersonEntity(Entity): + def get_variable(self, variable_name): + result = TestVariable(self) + result.name = variable_name + return result + + def check_variable_defined_for_entity(self, variable_name): + return True + + return TestPersonEntity("person", "persons", "", "") + + +@fixture +def group_entity(): + class Household(GroupEntity): + def get_variable(self, variable_name): + result = TestVariable(self) + result.name = variable_name + return result + + def check_variable_defined_for_entity(self, variable_name): + return True + + roles = [{ + 'key': 'parent', + 'plural': 'parents', + 'max': 2 + }, { + 'key': 'child', + 'plural': 'children' + }] + + return Household("household", "households", "", "", roles) + + +@fixture +def single(): + return { + "persons": { + "Alicia": { + "birth": { + "2017-01": None + }, + "disposable_income": { + "2017-01": None + } + } + }, + "households": { + "_": { + "parents": ["Alicia"] + } + } + } + + +@fixture +def couple(): + return { + "persons": { + "Alicia": { + "birth": { + "ETERNITY": "1980-01-01" + }, + "salary": { + "2017-01": 4000 + }, + "disposable_income": { + "2017-01": None + } + }, + "Javier": { + "birth": { + "ETERNITY": "1984-01-01" + }, + "salary": { + "2017-01": 2500 + }, + "disposable_income": { + "2017-01": None + } + } + }, + "households": { + "_": { + "parents": ["Alicia", "Javier"], + "total_benefits": { + "2017-01": None + }, + "total_taxes": { + "2017-01": None + } + } + } + } + +# TAX BENEFIt SYSTEMS + + +@fixture +def tax_benefit_system(): + return CountryTaxBenefitSystem() + + +# SIMULATIONS + + +@fixture +def simulation_builder(): + return SimulationBuilder() + + +@fixture +def simulation(tax_benefit_system, simulation_builder): + return SimulationBuilder().build_default_simulation(tax_benefit_system) + + +@fixture +def make_simulation_from_entities(tax_benefit_system, simulation_builder): + def _make_simulation_from_entities(entities): + return simulation_builder.build_from_entities(tax_benefit_system, entities) + return _make_simulation_from_entities + + +@fixture +def make_simulation_from_tbs_and_variables(simulation_builder, period): + def _make_simulation_from_variables_and_tbs(tbs, variables): + simulation_builder.default_period = period + return simulation_builder.build_from_variables(tbs, variables) + return _make_simulation_from_variables_and_tbs + + +@fixture +def make_simulation_from_yaml(tax_benefit_system, simulation_builder): + def _make_simulation_from_yaml(simulation_yaml): + return simulation_builder.build_from_dict(tax_benefit_system, yaml.safe_load(simulation_yaml)) + return _make_simulation_from_yaml + + +@fixture +def simulation_single(make_simulation_from_entities, single): + return make_simulation_from_entities(single) + + +@fixture +def simulation_couple(make_simulation_from_entities, couple): + return make_simulation_from_entities(couple) + + +# VARIABLES + + +@fixture +def make_variable(): + def _make_variable(name, **new_methods_and_attrs): + methods_and_attrs = {} + default = dict(value_type = int, entity = Person, definition_period = MONTH) + methods_and_attrs.update(default) + methods_and_attrs.update(new_methods_and_attrs) + return type(name, (Variable, ), methods_and_attrs) + return _make_variable diff --git a/tests/core/parameter_validation/test_parameter_clone.py b/tests/core/parameter_validation/test_parameter_clone.py index 7b839caa15..369a5125e9 100644 --- a/tests/core/parameter_validation/test_parameter_clone.py +++ b/tests/core/parameter_validation/test_parameter_clone.py @@ -1,6 +1,4 @@ # -*- coding: utf-8 -*- -from ..test_countries import tax_benefit_system - import os from openfisca_core.parameters import ParameterNode BASE_DIR = os.path.dirname(os.path.abspath(__file__)) @@ -20,7 +18,7 @@ def test_clone(): assert id(clone.node1.param) != id(parameters.node1.param) -def test_clone_parameter(): +def test_clone_parameter(tax_benefit_system): param = tax_benefit_system.parameters.taxes.income_tax_rate clone = param.clone() @@ -32,7 +30,7 @@ def test_clone_parameter(): assert clone.values_list == param.values_list -def test_clone_parameter_node(): +def test_clone_parameter_node(tax_benefit_system): node = tax_benefit_system.parameters.taxes clone = node.clone() @@ -41,7 +39,7 @@ def test_clone_parameter_node(): assert clone.children['income_tax_rate'] is not node.children['income_tax_rate'] -def test_clone_scale(): +def test_clone_scale(tax_benefit_system): scale = tax_benefit_system.parameters.taxes.social_security_contribution clone = scale.clone() @@ -49,7 +47,7 @@ def test_clone_scale(): assert clone.brackets[0].rate is not scale.brackets[0].rate -def test_deep_edit(): +def test_deep_edit(tax_benefit_system): parameters = tax_benefit_system.parameters clone = parameters.clone() diff --git a/tests/core/test_axes.py b/tests/core/test_axes.py index 60c0299f18..fd91c6790a 100644 --- a/tests/core/test_axes.py +++ b/tests/core/test_axes.py @@ -1,13 +1,5 @@ # -*- coding: utf-8 -*- -from pytest import fixture, approx - -from openfisca_core.simulation_builder import SimulationBuilder -from .test_simulation_builder import * # noqa: F401 - - -@fixture -def simulation_builder(): - return SimulationBuilder() +from pytest import approx def test_add_axis_on_persons(simulation_builder, persons): @@ -134,9 +126,8 @@ def test_add_perpendicular_axes(simulation_builder, persons): # Integration test -def test_simulation_with_axes(simulation_builder): - from .test_countries import tax_benefit_system - input_yaml = """ +def test_simulation_with_axes(make_simulation_from_yaml): + simulation = make_simulation_from_yaml(""" persons: Alicia: {salary: {2018-11: 0}} Javier: {} @@ -153,8 +144,6 @@ def test_simulation_with_axes(simulation_builder): min: 0 max: 3000 period: 2018-11 - """ - data = yaml.safe_load(input_yaml) - simulation = simulation_builder.build_from_dict(tax_benefit_system, data) + """) assert simulation.get_array('salary', '2018-11') == approx([0, 0, 0, 0, 0, 0]) assert simulation.get_array('rent', '2018-11') == approx([0, 0, 3000, 0]) diff --git a/tests/core/test_calculate_output.py b/tests/core/test_calculate_output.py index 63959155d2..c31294ef97 100644 --- a/tests/core/test_calculate_output.py +++ b/tests/core/test_calculate_output.py @@ -1,59 +1,47 @@ -from openfisca_core.model_api import * # noqa analysis:ignore -from openfisca_core.simulation_builder import SimulationBuilder -from openfisca_core.tools import assert_near - -from openfisca_country_template import CountryTaxBenefitSystem -from openfisca_country_template.entities import * # noqa analysis:ignore -from openfisca_country_template.situation_examples import single - from pytest import fixture, raises - -@fixture -def simulation(): - return SimulationBuilder().build_from_entities(tax_benefit_system, single) +from openfisca_core.tools import assert_near +from openfisca_core.simulations import calculate_output_add +from openfisca_core.simulations import calculate_output_divide +from openfisca_core.periods import YEAR -class simple_variable(Variable): - entity = Person - definition_period = MONTH - value_type = int +@fixture +def simple_variable(make_variable): + return make_variable('simple_variable') -class variable_with_calculate_output_add(Variable): - entity = Person - definition_period = MONTH - value_type = int - calculate_output = calculate_output_add +@fixture +def variable_with_calculate_output_add(make_variable): + return make_variable('variable_with_calculate_output_add', calculate_output = calculate_output_add) -class variable_with_calculate_output_divide(Variable): - entity = Person - definition_period = YEAR - value_type = int - calculate_output = calculate_output_divide +@fixture +def variable_with_calculate_output_divide(make_variable): + return make_variable('variable_with_calculate_output_divide', + definition_period = YEAR, + calculate_output = calculate_output_divide) -tax_benefit_system = CountryTaxBenefitSystem() -tax_benefit_system.add_variables( - simple_variable, - variable_with_calculate_output_add, - variable_with_calculate_output_divide - ) +@fixture +def simulation_single_with_variables(simulation_builder, tax_benefit_system, single, + simple_variable, variable_with_calculate_output_add, variable_with_calculate_output_divide): + tax_benefit_system.add_variables(simple_variable, variable_with_calculate_output_add, variable_with_calculate_output_divide) + return simulation_builder.build_from_entities(tax_benefit_system, single) -def test_calculate_output_default(simulation): +def test_calculate_output_default(simulation_single_with_variables): with raises(ValueError): - simulation.calculate_output('simple_variable', 2017) + simulation_single_with_variables.calculate_output('simple_variable', 2017) -def test_calculate_output_add(simulation): - simulation.set_input('variable_with_calculate_output_add', '2017-01', [10]) - simulation.set_input('variable_with_calculate_output_add', '2017-05', [20]) - simulation.set_input('variable_with_calculate_output_add', '2017-12', [70]) - assert_near(simulation.calculate_output('variable_with_calculate_output_add', 2017), 100) +def test_calculate_output_add(simulation_single_with_variables): + simulation_single_with_variables.set_input('variable_with_calculate_output_add', '2017-01', [10]) + simulation_single_with_variables.set_input('variable_with_calculate_output_add', '2017-05', [20]) + simulation_single_with_variables.set_input('variable_with_calculate_output_add', '2017-12', [70]) + assert_near(simulation_single_with_variables.calculate_output('variable_with_calculate_output_add', 2017), 100) -def test_calculate_output_divide(simulation): - simulation.set_input('variable_with_calculate_output_divide', 2017, [12000]) - assert_near(simulation.calculate_output('variable_with_calculate_output_divide', '2017-06'), 1000) +def test_calculate_output_divide(simulation_single_with_variables): + simulation_single_with_variables.set_input('variable_with_calculate_output_divide', 2017, [12000]) + assert_near(simulation_single_with_variables.calculate_output('variable_with_calculate_output_divide', '2017-06'), 1000) diff --git a/tests/core/test_countries.py b/tests/core/test_countries.py index e7e8ec0ee1..b1544b54ad 100644 --- a/tests/core/test_countries.py +++ b/tests/core/test_countries.py @@ -4,37 +4,17 @@ from openfisca_core.variables import Variable from openfisca_core.periods import MONTH -from openfisca_core.simulation_builder import SimulationBuilder from openfisca_core.taxbenefitsystems import VariableNameConflict, VariableNotFound from openfisca_core import periods from openfisca_core.populations import DIVIDE -from openfisca_country_template import CountryTaxBenefitSystem from openfisca_core.tools import assert_near -tax_benefit_system = CountryTaxBenefitSystem() - - -@fixture -def period(): - return "2016-01" - - @fixture -def make_simulation(period): - def _make_simulation(data): - builder = SimulationBuilder() - builder.default_period = period - return builder.build_from_variables(tax_benefit_system, data) - return _make_simulation - - -@fixture -def make_isolated_simulation(period): - def _make_simulation(tbs, data): - builder = SimulationBuilder() - builder.default_period = period - return builder.build_from_variables(tbs, data) +def make_simulation(tax_benefit_system, simulation_builder, period): + def _make_simulation(variables): + simulation_builder.default_period = period + return simulation_builder.build_from_variables(tax_benefit_system, variables) return _make_simulation @@ -104,10 +84,8 @@ def test_input_with_wrong_period(make_simulation): make_simulation({'basic_income': {2015: 12000}}) -def test_variable_with_reference(make_isolated_simulation): - tax_benefit_system = CountryTaxBenefitSystem() # Work in isolation - - simulation_base = make_isolated_simulation(tax_benefit_system, {'salary': 4000}) +def test_variable_with_reference(tax_benefit_system, make_simulation_from_tbs_and_variables): + simulation_base = make_simulation_from_tbs_and_variables(tax_benefit_system, {'salary': 4000}) revenu_disponible_avant_reforme = simulation_base.calculate('disposable_income', "2016-01") assert(revenu_disponible_avant_reforme > 0) @@ -120,13 +98,13 @@ def formula(household, period): tax_benefit_system.update_variable(disposable_income) - simulation_reform = make_isolated_simulation(tax_benefit_system, {'salary': 4000}) + simulation_reform = make_simulation_from_tbs_and_variables(tax_benefit_system, {'salary': 4000}) revenu_disponible_apres_reforme = simulation_reform.calculate('disposable_income', "2016-01") assert(revenu_disponible_apres_reforme == 0) -def test_variable_name_conflict(): +def test_variable_name_conflict(tax_benefit_system): class disposable_income(Variable): reference = 'disposable_income' definition_period = MONTH diff --git a/tests/core/test_cycles.py b/tests/core/test_cycles.py index 949df40336..053731fe78 100644 --- a/tests/core/test_cycles.py +++ b/tests/core/test_cycles.py @@ -1,13 +1,7 @@ # -*- coding: utf-8 -*- from openfisca_core import periods -from openfisca_core.periods import MONTH -from openfisca_core.simulation_builder import SimulationBuilder from openfisca_core.simulations import CycleError -from openfisca_core.variables import Variable - -from openfisca_country_template import CountryTaxBenefitSystem -from openfisca_country_template.entities import Person from openfisca_core.tools import assert_near from pytest import fixture, raises @@ -18,126 +12,71 @@ def reference_period(): return periods.period('2013-01') -@fixture -def simulation(reference_period): - return SimulationBuilder().build_default_simulation(tax_benefit_system) - - -# 1 <--> 2 with same period -class variable1(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - return person('variable2', period) - - -class variable2(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - return person('variable1', period) - - -# 3 <--> 4 with a period offset -class variable3(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - return person('variable4', period.last_month) - - -class variable4(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - return person('variable3', period) - - -# 5 -f-> 6 with a period offset -# <--- -class variable5(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - variable6 = person('variable6', period.last_month) - return 5 + variable6 - - -class variable6(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - variable5 = person('variable5', period) - return 6 + variable5 - - -class variable7(Variable): - value_type = int - entity = Person - definition_period = MONTH - - def formula(person, period): - variable5 = person('variable5', period) - return 7 + variable5 - - # december cotisation depending on november value -class cotisation(Variable): - value_type = int - entity = Person - definition_period = MONTH +@fixture +def cotisation(make_variable): + variable = make_variable('cotisation') def formula(person, period): if period.start.month == 12: return 2 * person('cotisation', period.last_month) else: return person.empty_array() + 1 + variable.formula = formula + return variable -# TaxBenefitSystem instance declared after formulas -tax_benefit_system = CountryTaxBenefitSystem() -tax_benefit_system.add_variables(variable1, variable2, variable3, variable4, - variable5, variable6, variable7, cotisation) +@fixture +def cycle_variables(make_variable, cotisation): + variables = [ + # 1 <--> 2 with same period + make_variable('variable1', formula = lambda person, period: person('variable2', period)), + make_variable('variable2', formula = lambda person, period: person('variable1', period)), + # 3 <--> 4 with a period offset + make_variable('variable3', formula = lambda person, period: person('variable4', period.last_month)), + make_variable('variable4', formula = lambda person, period: person('variable3', period)), + # 5 -f-> 6 with a period offset + # <--- + make_variable('variable5', formula = lambda person, period: 5 + person('variable6', period.last_month)), + make_variable('variable6', formula = lambda person, period: 6 + person('variable5', period)), + make_variable('variable7', formula = lambda person, period: 7 + person('variable5', period)), + cotisation + ] + return variables + + +@fixture +def simulation_with_variables(tax_benefit_system, simulation_builder, cycle_variables): + tax_benefit_system.add_variables(*cycle_variables) + return simulation_builder.build_default_simulation(tax_benefit_system) -def test_pure_cycle(simulation, reference_period): +def test_pure_cycle(simulation_with_variables, reference_period): with raises(CycleError): - simulation.calculate('variable1', period = reference_period) + simulation_with_variables.calculate('variable1', period = reference_period) -def test_spirals_result_in_default_value(simulation, reference_period): - variable3 = simulation.calculate('variable3', period = reference_period) +def test_spirals_result_in_default_value(simulation_with_variables, reference_period): + variable3 = simulation_with_variables.calculate('variable3', period = reference_period) assert_near(variable3, [0]) -def test_spiral_heuristic(simulation, reference_period): - variable5 = simulation.calculate('variable5', period = reference_period) - variable6 = simulation.calculate('variable6', period = reference_period) - variable6_last_month = simulation.calculate('variable6', reference_period.last_month) +def test_spiral_heuristic(simulation_with_variables, reference_period): + variable5 = simulation_with_variables.calculate('variable5', period = reference_period) + variable6 = simulation_with_variables.calculate('variable6', period = reference_period) + variable6_last_month = simulation_with_variables.calculate('variable6', reference_period.last_month) assert_near(variable5, [11]) assert_near(variable6, [11]) assert_near(variable6_last_month, [11]) -def test_spiral_cache(simulation, reference_period): - simulation.calculate('variable7', period = reference_period) - cached_variable7 = simulation.get_holder('variable7').get_array(reference_period) +def test_spiral_cache(simulation_with_variables, reference_period): + simulation_with_variables.calculate('variable7', period = reference_period) + cached_variable7 = simulation_with_variables.get_holder('variable7').get_array(reference_period) assert cached_variable7 is not None -def test_cotisation_1_level(simulation, reference_period): +def test_cotisation_1_level(simulation_with_variables, reference_period): month = reference_period.last_month - cotisation = simulation.calculate('cotisation', period = month) + cotisation = simulation_with_variables.calculate('cotisation', period = month) assert_near(cotisation, [0]) diff --git a/tests/core/test_dump_restore.py b/tests/core/test_dump_restore.py index fcc53f516f..3f6117643c 100644 --- a/tests/core/test_dump_restore.py +++ b/tests/core/test_dump_restore.py @@ -6,30 +6,25 @@ from numpy.testing import assert_array_equal -from openfisca_core.simulation_builder import SimulationBuilder -from openfisca_country_template.situation_examples import couple from openfisca_core.tools.simulation_dumper import dump_simulation, restore_simulation -from .test_countries import tax_benefit_system - -def test_dump(): +def test_dump(tax_benefit_system, simulation_single): directory = tempfile.mkdtemp(prefix = "openfisca_") - simulation = SimulationBuilder().build_from_entities(tax_benefit_system, couple) - calculated_value = simulation.calculate('disposable_income', '2018-01') - dump_simulation(simulation, directory) + calculated_value = simulation_single.calculate('disposable_income', '2018-01') + dump_simulation(simulation_single, directory) simulation_2 = restore_simulation(directory, tax_benefit_system) # Check entities structure have been restored - assert_array_equal(simulation.person.ids, simulation_2.person.ids) - assert_array_equal(simulation.person.count, simulation_2.person.count) - assert_array_equal(simulation.household.ids, simulation_2.household.ids) - assert_array_equal(simulation.household.count, simulation_2.household.count) - assert_array_equal(simulation.household.members_position, simulation_2.household.members_position) - assert_array_equal(simulation.household.members_entity_id, simulation_2.household.members_entity_id) - assert_array_equal(simulation.household.members_role, simulation_2.household.members_role) + assert_array_equal(simulation_single.person.ids, simulation_2.person.ids) + assert_array_equal(simulation_single.person.count, simulation_2.person.count) + assert_array_equal(simulation_single.household.ids, simulation_2.household.ids) + assert_array_equal(simulation_single.household.count, simulation_2.household.count) + assert_array_equal(simulation_single.household.members_position, simulation_2.household.members_position) + assert_array_equal(simulation_single.household.members_entity_id, simulation_2.household.members_entity_id) + assert_array_equal(simulation_single.household.members_role, simulation_2.household.members_role) # Check calculated values are in cache diff --git a/tests/core/test_entities.py b/tests/core/test_entities.py index 0702ceaf3b..8120c99e8a 100644 --- a/tests/core/test_entities.py +++ b/tests/core/test_entities.py @@ -1,54 +1,64 @@ # -*- coding: utf-8 -*- -from copy import deepcopy +from pytest import fixture -from openfisca_core.simulation_builder import SimulationBuilder from openfisca_core.tools import assert_near -from openfisca_core.tools.test_runner import yaml from openfisca_country_template.entities import Household -from openfisca_country_template.situation_examples import single, couple -from .test_countries import tax_benefit_system -TEST_CASE = { - 'persons': {'ind0': {}, 'ind1': {}, 'ind2': {}, 'ind3': {}, 'ind4': {}, 'ind5': {}}, - 'households': { - 'h1': {'children': ['ind2', 'ind3'], 'parents': ['ind0', 'ind1']}, - 'h2': {'children': ['ind5'], 'parents': ['ind4']} - }, - } +@fixture +def year_period(): + return "2016" + + +@fixture +def case(): + return { + 'persons': {'ind0': {}, 'ind1': {}, 'ind2': {}, 'ind3': {}, 'ind4': {}, 'ind5': {}}, + 'households': { + 'h1': {'children': ['ind2', 'ind3'], 'parents': ['ind0', 'ind1']}, + 'h2': {'children': ['ind5'], 'parents': ['ind4']} + }, + } + + +@fixture +def ages_case(case): + AGES = [40, 37, 7, 9, 54, 20] + for (individu, age) in zip(case['persons'].values(), AGES): + individu['age'] = age + return case -TEST_CASE_AGES = deepcopy(TEST_CASE) -AGES = [40, 37, 7, 9, 54, 20] -for (individu, age) in zip(TEST_CASE_AGES['persons'].values(), AGES): - individu['age'] = age FIRST_PARENT = Household.FIRST_PARENT SECOND_PARENT = Household.SECOND_PARENT PARENT = Household.PARENT CHILD = Household.CHILD -YEAR = 2016 -MONTH = "2016-01" + +@fixture +def make_simulation_from_entities(tax_benefit_system, simulation_builder, period): + def _make_simulation_from_entities(entities, period=period): + simulation_builder.set_default_period(period) + return simulation_builder.build_from_entities(tax_benefit_system, entities) + return _make_simulation_from_entities -def new_simulation(test_case, period = MONTH): - builder = SimulationBuilder() - builder.set_default_period(period) - return builder.build_from_entities(tax_benefit_system, test_case) +@fixture +def simulation_case(make_simulation_from_entities, case): + return make_simulation_from_entities(case) -def test_role_index_and_positions(): - simulation = new_simulation(TEST_CASE) - assert_near(simulation.household.members_entity_id, [0, 0, 0, 0, 1, 1]) - assert((simulation.household.members_role == [FIRST_PARENT, SECOND_PARENT, CHILD, CHILD, FIRST_PARENT, CHILD]).all()) - assert_near(simulation.household.members_position, [0, 1, 2, 3, 0, 1]) - assert(simulation.person.ids == ["ind0", "ind1", "ind2", "ind3", "ind4", "ind5"]) - assert(simulation.household.ids == ['h1', 'h2']) +def test_role_index_and_positions(simulation_case): + assert_near(simulation_case.household.members_entity_id, [0, 0, 0, 0, 1, 1]) + assert((simulation_case.household.members_role == [FIRST_PARENT, SECOND_PARENT, CHILD, CHILD, FIRST_PARENT, CHILD]).all()) + assert_near(simulation_case.household.members_position, [0, 1, 2, 3, 0, 1]) + assert(simulation_case.person.ids == ["ind0", "ind1", "ind2", "ind3", "ind4", "ind5"]) + assert(simulation_case.household.ids == ['h1', 'h2']) -def test_entity_structure_with_constructor(): - simulation_yaml = """ +def test_entity_structure_with_constructor(make_simulation_from_yaml): + simulation = make_simulation_from_yaml(""" persons: bill: {} bob: {} @@ -66,9 +76,7 @@ def test_entity_structure_with_constructor(): second_household: parents: - claudia - """ - - simulation = SimulationBuilder().build_from_dict(tax_benefit_system, yaml.safe_load(simulation_yaml)) + """) household = simulation.household @@ -77,8 +85,8 @@ def test_entity_structure_with_constructor(): assert_near(household.members_position, [0, 1, 0, 2, 3]) -def test_entity_variables_with_constructor(): - simulation_yaml = """ +def test_entity_variables_with_constructor(make_simulation_from_yaml): + simulation = make_simulation_from_yaml(""" persons: bill: {} bob: {} @@ -100,15 +108,14 @@ def test_entity_variables_with_constructor(): - claudia rent: 2017-06: 600 - """ + """) - simulation = SimulationBuilder().build_from_dict(tax_benefit_system, yaml.safe_load(simulation_yaml)) household = simulation.household assert_near(household('rent', "2017-06"), [800, 600]) -def test_person_variable_with_constructor(): - simulation_yaml = """ +def test_person_variable_with_constructor(make_simulation_from_yaml): + simulation = make_simulation_from_yaml(""" persons: bill: salary: @@ -133,16 +140,15 @@ def test_person_variable_with_constructor(): second_household: parents: - claudia - """ + """) - simulation = SimulationBuilder().build_from_dict(tax_benefit_system, yaml.safe_load(simulation_yaml)) person = simulation.person assert_near(person('salary', "2017-11"), [1500, 0, 3000, 0, 0]) assert_near(person('salary', "2017-12"), [2000, 0, 4000, 0, 0]) -def test_set_input_with_constructor(): - simulation_yaml = """ +def test_set_input_with_constructor(make_simulation_from_yaml): + simulation = make_simulation_from_yaml(""" persons: bill: salary: @@ -172,36 +178,32 @@ def test_set_input_with_constructor(): second_household: parents: - claudia - """ + """) - simulation = SimulationBuilder().build_from_dict(tax_benefit_system, yaml.safe_load(simulation_yaml)) person = simulation.person assert_near(person('salary', "2017-12"), [2000, 0, 4000, 0, 0]) assert_near(person('salary', "2017-10"), [2000, 3000, 1600, 0, 0]) -def test_has_role(): - simulation = new_simulation(TEST_CASE) - individu = simulation.persons +def test_has_role(simulation_case): + individu = simulation_case.persons assert_near(individu.has_role(CHILD), [False, False, True, True, False, True]) -def test_has_role_with_subrole(): - simulation = new_simulation(TEST_CASE) - individu = simulation.persons +def test_has_role_with_subrole(simulation_case): + individu = simulation_case.persons assert_near(individu.has_role(PARENT), [True, True, False, False, True, False]) assert_near(individu.has_role(FIRST_PARENT), [True, False, False, False, True, False]) assert_near(individu.has_role(SECOND_PARENT), [False, True, False, False, False, False]) -def test_project(): - test_case = deepcopy(TEST_CASE) - test_case['households']['h1']['housing_tax'] = 20000 +def test_project(make_simulation_from_entities, case, year_period): + case['households']['h1']['housing_tax'] = 20000 - simulation = new_simulation(test_case, YEAR) + simulation = make_simulation_from_entities(case, year_period) household = simulation.household - housing_tax = household('housing_tax', YEAR) + housing_tax = household('housing_tax', year_period) projected_housing_tax = household.project(housing_tax) assert_near(projected_housing_tax, [20000, 20000, 20000, 20000, 0, 0]) @@ -210,25 +212,23 @@ def test_project(): assert_near(housing_tax_projected_on_parents, [20000, 20000, 0, 0, 0, 0]) -def test_implicit_projection(): - test_case = deepcopy(TEST_CASE) - test_case['households']['h1']['housing_tax'] = 20000 +def test_implicit_projection(make_simulation_from_entities, case, year_period): + case['households']['h1']['housing_tax'] = 20000 - simulation = new_simulation(test_case, YEAR) + simulation = make_simulation_from_entities(case, year_period) individu = simulation.person - housing_tax = individu.household('housing_tax', YEAR) + housing_tax = individu.household('housing_tax', year_period) assert_near(housing_tax, [20000, 20000, 20000, 20000, 0, 0]) -def test_sum(): - test_case = deepcopy(TEST_CASE) - test_case['persons']['ind0']['salary'] = 1000 - test_case['persons']['ind1']['salary'] = 1500 - test_case['persons']['ind4']['salary'] = 3000 - test_case['persons']['ind5']['salary'] = 500 +def test_sum(make_simulation_from_entities, case, period): + case['persons']['ind0']['salary'] = 1000 + case['persons']['ind1']['salary'] = 1500 + case['persons']['ind4']['salary'] = 3000 + case['persons']['ind5']['salary'] = 500 - simulation = new_simulation(test_case, MONTH) + simulation = make_simulation_from_entities(case, period) household = simulation.household salary = household.members('salary', "2016-01") @@ -241,12 +241,11 @@ def test_sum(): assert_near(total_salary_parents_by_household, [2500, 3000]) -def test_any(): - test_case = deepcopy(TEST_CASE_AGES) - simulation = new_simulation(test_case) +def test_any(make_simulation_from_entities, ages_case, period): + simulation = make_simulation_from_entities(ages_case) household = simulation.household - age = household.members('age', period = MONTH) + age = household.members('age', period = period) condition_age = (age <= 18) has_household_member_with_age_inf_18 = household.any(condition_age) assert_near(has_household_member_with_age_inf_18, [True, False]) @@ -256,12 +255,11 @@ def test_any(): assert_near(has_household_CHILD_with_age_sup_18, [False, True]) -def test_all(): - test_case = deepcopy(TEST_CASE_AGES) - simulation = new_simulation(test_case) +def test_all(make_simulation_from_entities, ages_case, period): + simulation = make_simulation_from_entities(ages_case) household = simulation.household - age = household.members('age', period = MONTH) + age = household.members('age', period = period) condition_age = (age >= 18) all_persons_age_sup_18 = household.all(condition_age) @@ -271,12 +269,11 @@ def test_all(): assert_near(all_parents_age_sup_18, [True, True]) -def test_max(): - test_case = deepcopy(TEST_CASE_AGES) - simulation = new_simulation(test_case) +def test_max(make_simulation_from_entities, ages_case, period): + simulation = make_simulation_from_entities(ages_case) household = simulation.household - age = household.members('age', period = MONTH) + age = household.members('age', period = period) age_max = household.max(age) assert_near(age_max, [40, 54]) @@ -285,12 +282,11 @@ def test_max(): assert_near(age_max_child, [9, 20]) -def test_min(): - test_case = deepcopy(TEST_CASE_AGES) - simulation = new_simulation(test_case) +def test_min(make_simulation_from_entities, ages_case, period): + simulation = make_simulation_from_entities(ages_case) household = simulation.household - age = household.members('age', period = MONTH) + age = household.members('age', period = period) age_min = household.min(age) assert_near(age_min, [7, 20]) @@ -299,11 +295,10 @@ def test_min(): assert_near(age_min_parents, [37, 54]) -def test_value_nth_person(): - test_case = deepcopy(TEST_CASE_AGES) - simulation = new_simulation(test_case) +def test_value_nth_person(make_simulation_from_entities, ages_case, period): + simulation = make_simulation_from_entities(ages_case) household = simulation.household - array = household.members('age', MONTH) + array = household.members('age', period) result0 = household.value_nth_person(0, array, default=-1) assert_near(result0, [40, 54]) @@ -318,12 +313,11 @@ def test_value_nth_person(): assert_near(result3, [9, -1]) -def test_rank(): - test_case = deepcopy(TEST_CASE_AGES) - simulation = new_simulation(test_case) +def test_rank(make_simulation_from_entities, ages_case, period): + simulation = make_simulation_from_entities(ages_case) person = simulation.person - age = person('age', MONTH) # [40, 37, 7, 9, 54, 20] + age = person('age', period) # [40, 37, 7, 9, 54, 20] rank = person.get_rank(person.household, age) assert_near(rank, [3, 2, 0, 1, 1, 0]) @@ -331,43 +325,40 @@ def test_rank(): assert_near(rank_in_siblings, [-1, -1, 1, 0, -1, 0]) -def test_partner(): - test_case = deepcopy(TEST_CASE) - test_case['persons']['ind0']['salary'] = 1000 - test_case['persons']['ind1']['salary'] = 1500 - test_case['persons']['ind4']['salary'] = 3000 - test_case['persons']['ind5']['salary'] = 500 +def test_partner(make_simulation_from_entities, case, period): + case['persons']['ind0']['salary'] = 1000 + case['persons']['ind1']['salary'] = 1500 + case['persons']['ind4']['salary'] = 3000 + case['persons']['ind5']['salary'] = 500 - simulation = new_simulation(test_case) + simulation = make_simulation_from_entities(case) persons = simulation.persons - salary = persons('salary', period = MONTH) + salary = persons('salary', period = period) salary_second_parent = persons.value_from_partner(salary, persons.household, PARENT) assert_near(salary_second_parent, [1500, 1000, 0, 0, 0, 0]) -def test_value_from_first_person(): - test_case = deepcopy(TEST_CASE) - test_case['persons']['ind0']['salary'] = 1000 - test_case['persons']['ind1']['salary'] = 1500 - test_case['persons']['ind4']['salary'] = 3000 - test_case['persons']['ind5']['salary'] = 500 +def test_value_from_first_person(make_simulation_from_entities, case, period): + case['persons']['ind0']['salary'] = 1000 + case['persons']['ind1']['salary'] = 1500 + case['persons']['ind4']['salary'] = 3000 + case['persons']['ind5']['salary'] = 500 - simulation = new_simulation(test_case) + simulation = make_simulation_from_entities(case) household = simulation.household - salaries = household.members('salary', period = MONTH) + salaries = household.members('salary', period = period) salary_first_person = household.value_from_first_person(salaries) assert_near(salary_first_person, [1000, 3000]) -def test_projectors_methods(): - simulation = SimulationBuilder().build_from_dict(tax_benefit_system, couple) - household = simulation.household - person = simulation.person +def test_projectors_methods(simulation_couple): + household = simulation_couple.household + person = simulation_couple.person projected_vector = household.first_parent.has_role(Household.FIRST_PARENT) assert(len(projected_vector) == 1) # Must be of a household dimension @@ -381,62 +372,61 @@ def test_projectors_methods(): assert(len(household.first_parent.get_rank(household, salary_i)) == 1) # Must be of a person dimension -def test_sum_following_bug_ipp_1(): - test_case = { +def test_sum_following_bug_ipp_1(make_simulation_from_entities, period): + new_case = { 'persons': {'ind0': {}, 'ind1': {}, 'ind2': {}, 'ind3': {}}, 'households': { 'h1': {'parents': ['ind0']}, 'h2': {'parents': ['ind1'], 'children': ['ind2', 'ind3']} }, } - test_case['persons']['ind0']['salary'] = 2000 - test_case['persons']['ind1']['salary'] = 2000 - test_case['persons']['ind2']['salary'] = 1000 - test_case['persons']['ind3']['salary'] = 1000 + new_case['persons']['ind0']['salary'] = 2000 + new_case['persons']['ind1']['salary'] = 2000 + new_case['persons']['ind2']['salary'] = 1000 + new_case['persons']['ind3']['salary'] = 1000 - simulation = new_simulation(test_case) + simulation = make_simulation_from_entities(new_case) household = simulation.household - eligible_i = household.members('salary', period = MONTH) < 1500 + eligible_i = household.members('salary', period = period) < 1500 nb_eligibles_by_household = household.sum(eligible_i, role = CHILD) assert_near(nb_eligibles_by_household, [0, 2]) -def test_sum_following_bug_ipp_2(): - test_case = { +def test_sum_following_bug_ipp_2(make_simulation_from_entities, period): + new_case = { 'persons': {'ind0': {}, 'ind1': {}, 'ind2': {}, 'ind3': {}}, 'households': { 'h1': {'parents': ['ind1'], 'children': ['ind2', 'ind3']}, 'h2': {'parents': ['ind0']}, }, } - test_case['persons']['ind0']['salary'] = 2000 - test_case['persons']['ind1']['salary'] = 2000 - test_case['persons']['ind2']['salary'] = 1000 - test_case['persons']['ind3']['salary'] = 1000 + new_case['persons']['ind0']['salary'] = 2000 + new_case['persons']['ind1']['salary'] = 2000 + new_case['persons']['ind2']['salary'] = 1000 + new_case['persons']['ind3']['salary'] = 1000 - simulation = new_simulation(test_case) + simulation = make_simulation_from_entities(new_case) household = simulation.household - eligible_i = household.members('salary', period = MONTH) < 1500 + eligible_i = household.members('salary', period = period) < 1500 nb_eligibles_by_household = household.sum(eligible_i, role = CHILD) assert_near(nb_eligibles_by_household, [2, 0]) -def test_get_memory_usage(): - test_case = deepcopy(single) - test_case["persons"]["Alicia"]["salary"] = {"2017-01": 0} - simulation = SimulationBuilder().build_from_dict(tax_benefit_system, test_case) +def test_get_memory_usage(tax_benefit_system, simulation_builder, single): + single["persons"]["Alicia"]["salary"] = {"2017-01": 0} + simulation = simulation_builder.build_from_dict(tax_benefit_system, single) simulation.calculate('disposable_income', '2017-01') memory_usage = simulation.person.get_memory_usage(variables = ['salary']) assert(memory_usage['total_nb_bytes'] > 0) assert(len(memory_usage['by_variable']) == 1) -def test_unordered_persons(): - test_case = { +def test_unordered_persons(make_simulation_from_entities, period): + new_case = { 'persons': {'ind4': {}, 'ind3': {}, 'ind1': {}, 'ind2': {}, 'ind5': {}, 'ind0': {}}, 'households': { 'h1': {'children': ['ind2', 'ind3'], 'parents': ['ind0', 'ind1']}, @@ -444,19 +434,19 @@ def test_unordered_persons(): }, } # 1st family - test_case['persons']['ind0']['salary'] = 1000 - test_case['persons']['ind1']['salary'] = 1500 - test_case['persons']['ind2']['salary'] = 20 - test_case['households']['h1']['accommodation_size'] = 160 + new_case['persons']['ind0']['salary'] = 1000 + new_case['persons']['ind1']['salary'] = 1500 + new_case['persons']['ind2']['salary'] = 20 + new_case['households']['h1']['accommodation_size'] = 160 # 2nd family - test_case['persons']['ind4']['salary'] = 3000 - test_case['persons']['ind5']['salary'] = 500 - test_case['households']['h2']['accommodation_size'] = 60 + new_case['persons']['ind4']['salary'] = 3000 + new_case['persons']['ind5']['salary'] = 500 + new_case['households']['h2']['accommodation_size'] = 60 # household.members_entity_id == [1, 0, 0, 0, 1, 0] - simulation = new_simulation(test_case, MONTH) + simulation = make_simulation_from_entities(new_case, period) household = simulation.household person = simulation.person diff --git a/tests/core/test_extensions.py b/tests/core/test_extensions.py index 864adf606e..1ea95e8844 100644 --- a/tests/core/test_extensions.py +++ b/tests/core/test_extensions.py @@ -1,29 +1,23 @@ import pytest -from openfisca_country_template import CountryTaxBenefitSystem +def test_load_extension(tax_benefit_system): + new_tax_benefit_system = tax_benefit_system.clone() + assert new_tax_benefit_system.get_variable('local_town_child_allowance') is None -original_tbs = CountryTaxBenefitSystem() + new_tax_benefit_system.load_extension('openfisca_extension_template') + assert new_tax_benefit_system.get_variable('local_town_child_allowance') is not None + assert tax_benefit_system.get_variable('local_town_child_allowance') is None -def test_load_extension(): - tbs = original_tbs.clone() - assert tbs.get_variable('local_town_child_allowance') is None - tbs.load_extension('openfisca_extension_template') +def test_access_to_parameters(tax_benefit_system): + tax_benefit_system.load_extension('openfisca_extension_template') - assert tbs.get_variable('local_town_child_allowance') is not None - assert original_tbs.get_variable('local_town_child_allowance') is None + assert tax_benefit_system.parameters('2016-01').local_town.child_allowance.amount == 100.0 + assert tax_benefit_system.parameters.local_town.child_allowance.amount('2016-01') == 100.0 -def test_access_to_parameters(): - tbs = original_tbs.clone() - tbs.load_extension('openfisca_extension_template') - - assert tbs.parameters('2016-01').local_town.child_allowance.amount == 100.0 - assert tbs.parameters.local_town.child_allowance.amount('2016-01') == 100.0 - - -def test_failure_to_load_extension_when_directory_doesnt_exist(): +def test_failure_to_load_extension_when_directory_doesnt_exist(tax_benefit_system): with pytest.raises(ValueError): - original_tbs.load_extension('/this/is/not/a/real/path') + tax_benefit_system.load_extension('/this/is/not/a/real/path') diff --git a/tests/core/test_formulas.py b/tests/core/test_formulas.py index 19dd6bbf4e..8e8693f37b 100644 --- a/tests/core/test_formulas.py +++ b/tests/core/test_formulas.py @@ -1,13 +1,10 @@ # -*- coding: utf-8 -*- - import numpy as np from openfisca_core.periods import MONTH -from openfisca_core.simulation_builder import SimulationBuilder from openfisca_core.variables import Variable from openfisca_core.formula_helpers import switch -from openfisca_country_template import CountryTaxBenefitSystem from openfisca_country_template.entities import Person from pytest import fixture, approx @@ -59,9 +56,10 @@ def formula(person, period): return result -# TaxBenefitSystem instance declared after formulas -our_tbs = CountryTaxBenefitSystem() -our_tbs.add_variables(choice, uses_multiplication, uses_switch, returns_scalar) +@fixture +def our_tbs(tax_benefit_system): + tax_benefit_system.add_variables(choice, uses_multiplication, uses_switch, returns_scalar) + return tax_benefit_system @fixture @@ -70,10 +68,12 @@ def month(): @fixture -def simulation(month): - builder = SimulationBuilder() - builder.default_period = month - simulation = builder.build_from_variables(our_tbs, {'choice': np.random.randint(2, size = 1000) + 1}) +def simulation(our_tbs, simulation_builder, month): + simulation_builder.default_period = month + simulation = simulation_builder.build_from_variables( + our_tbs, + {'choice': np.random.randint(2, size = 1000) + 1} + ) simulation.debug = True return simulation diff --git a/tests/core/test_holders.py b/tests/core/test_holders.py index 9e62d6e64b..46bc1cbf29 100644 --- a/tests/core/test_holders.py +++ b/tests/core/test_holders.py @@ -3,91 +3,70 @@ import numpy as np import pytest -import openfisca_country_template.situation_examples -from openfisca_core.simulation_builder import SimulationBuilder from openfisca_country_template.variables.housing import HousingOccupancyStatus from openfisca_core.periods import period as make_period, ETERNITY from openfisca_core.tools import assert_near from openfisca_core.memory_config import MemoryConfig from openfisca_core.holders import Holder, set_input_dispatch_by_period from openfisca_core.errors import PeriodMismatchError -from .test_countries import tax_benefit_system - -from pytest import fixture - - -@fixture -def single(): - return SimulationBuilder().build_from_entities(tax_benefit_system, openfisca_country_template.situation_examples.single) - - -@fixture -def couple(): - return SimulationBuilder().build_from_entities(tax_benefit_system, openfisca_country_template.situation_examples.couple) period = make_period('2017-12') -def test_set_input_enum_string(couple): - simulation = couple +def test_set_input_enum_string(simulation_couple): status_occupancy = np.asarray(['free_lodger']) - simulation.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) - result = simulation.calculate('housing_occupancy_status', period) + simulation_couple.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) + result = simulation_couple.calculate('housing_occupancy_status', period) assert result == HousingOccupancyStatus.free_lodger -def test_set_input_enum_int(couple): - simulation = couple +def test_set_input_enum_int(simulation_couple): status_occupancy = np.asarray([2], dtype = np.int16) - simulation.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) - result = simulation.calculate('housing_occupancy_status', period) + simulation_couple.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) + result = simulation_couple.calculate('housing_occupancy_status', period) assert result == HousingOccupancyStatus.free_lodger -def test_set_input_enum_item(couple): - simulation = couple +def test_set_input_enum_item(simulation_couple): status_occupancy = np.asarray([HousingOccupancyStatus.free_lodger]) - simulation.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) - result = simulation.calculate('housing_occupancy_status', period) + simulation_couple.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) + result = simulation_couple.calculate('housing_occupancy_status', period) assert result == HousingOccupancyStatus.free_lodger -def test_yearly_input_month_variable(couple): +def test_yearly_input_month_variable(simulation_couple): with pytest.raises(PeriodMismatchError) as error: - couple.set_input('rent', 2019, 3000) + simulation_couple.set_input('rent', 2019, 3000) assert 'Unable to set a value for variable "rent" for year-long period' in error.value.message -def test_3_months_input_month_variable(couple): +def test_3_months_input_month_variable(simulation_couple): with pytest.raises(PeriodMismatchError) as error: - couple.set_input('rent', 'month:2019-01:3', 3000) + simulation_couple.set_input('rent', 'month:2019-01:3', 3000) assert 'Unable to set a value for variable "rent" for 3-months-long period' in error.value.message -def test_month_input_year_variable(couple): +def test_month_input_year_variable(simulation_couple): with pytest.raises(PeriodMismatchError) as error: - couple.set_input('housing_tax', '2019-01', 3000) + simulation_couple.set_input('housing_tax', '2019-01', 3000) assert 'Unable to set a value for variable "housing_tax" for month-long period' in error.value.message -def test_enum_dtype(couple): - simulation = couple +def test_enum_dtype(simulation_couple): status_occupancy = np.asarray([2], dtype = np.int16) - simulation.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) - result = simulation.calculate('housing_occupancy_status', period) + simulation_couple.household.get_holder('housing_occupancy_status').set_input(period, status_occupancy) + result = simulation_couple.calculate('housing_occupancy_status', period) assert result.dtype.kind is not None -def test_permanent_variable_empty(single): - simulation = single - holder = simulation.person.get_holder('birth') +def test_permanent_variable_empty(simulation_single): + holder = simulation_single.person.get_holder('birth') assert holder.get_array(None) is None -def test_permanent_variable_filled(single): - simulation = single - holder = simulation.person.get_holder('birth') +def test_permanent_variable_filled(simulation_single): + holder = simulation_single.person.get_holder('birth') value = np.asarray(['1980-01-01'], dtype = holder.variable.dtype) holder.set_input(make_period(ETERNITY), value) assert holder.get_array(None) == value @@ -95,22 +74,20 @@ def test_permanent_variable_filled(single): assert holder.get_array('2016-01') == value -def test_delete_arrays(single): - simulation = single - salary_holder = simulation.person.get_holder('salary') +def test_delete_arrays(simulation_single): + salary_holder = simulation_single.person.get_holder('salary') salary_holder.set_input(make_period(2017), np.asarray([30000])) salary_holder.set_input(make_period(2018), np.asarray([60000])) - assert simulation.person('salary', '2017-01') == 2500 - assert simulation.person('salary', '2018-01') == 5000 + assert simulation_single.person('salary', '2017-01') == 2500 + assert simulation_single.person('salary', '2018-01') == 5000 salary_holder.delete_arrays(period = 2018) salary_holder.set_input(make_period(2018), np.asarray([15000])) - assert simulation.person('salary', '2017-01') == 2500 - assert simulation.person('salary', '2018-01') == 1250 + assert simulation_single.person('salary', '2017-01') == 2500 + assert simulation_single.person('salary', '2018-01') == 1250 -def test_get_memory_usage(single): - simulation = single - salary_holder = simulation.person.get_holder('salary') +def test_get_memory_usage(simulation_single): + salary_holder = simulation_single.person.get_holder('salary') memory_usage = salary_holder.get_memory_usage() assert memory_usage['total_nb_bytes'] == 0 salary_holder.set_input(make_period(2017), np.asarray([30000])) @@ -122,24 +99,22 @@ def test_get_memory_usage(single): assert memory_usage['total_nb_bytes'] == 4 * 12 * 1 -def test_get_memory_usage_with_trace(single): - simulation = single - simulation.trace = True - salary_holder = simulation.person.get_holder('salary') +def test_get_memory_usage_with_trace(simulation_single): + simulation_single.trace = True + salary_holder = simulation_single.person.get_holder('salary') salary_holder.set_input(make_period(2017), np.asarray([30000])) - simulation.calculate('salary', '2017-01') - simulation.calculate('salary', '2017-01') - simulation.calculate('salary', '2017-02') - simulation.calculate_add('salary', '2017') # 12 calculations + simulation_single.calculate('salary', '2017-01') + simulation_single.calculate('salary', '2017-01') + simulation_single.calculate('salary', '2017-02') + simulation_single.calculate_add('salary', '2017') # 12 calculations memory_usage = salary_holder.get_memory_usage() assert memory_usage['nb_requests'] == 15 assert memory_usage['nb_requests_by_array'] == 1.25 # 15 calculations / 12 arrays -def test_set_input_dispatch_by_period(single): - simulation = single - variable = simulation.tax_benefit_system.get_variable('housing_occupancy_status') - entity = simulation.household +def test_set_input_dispatch_by_period(simulation_single): + variable = simulation_single.tax_benefit_system.get_variable('housing_occupancy_status') + entity = simulation_single.household holder = Holder(variable, entity) set_input_dispatch_by_period(holder, make_period(2019), 'owner') assert holder.get_array('2019-01') == holder.get_array('2019-12') # Check the feature @@ -149,37 +124,34 @@ def test_set_input_dispatch_by_period(single): force_storage_on_disk = MemoryConfig(max_memory_occupation = 0) -def test_delete_arrays_on_disk(single): - simulation = single - simulation.memory_config = force_storage_on_disk - salary_holder = simulation.person.get_holder('salary') +def test_delete_arrays_on_disk(simulation_single): + simulation_single.memory_config = force_storage_on_disk + salary_holder = simulation_single.person.get_holder('salary') salary_holder.set_input(make_period(2017), np.asarray([30000])) salary_holder.set_input(make_period(2018), np.asarray([60000])) - assert simulation.person('salary', '2017-01') == 2500 - assert simulation.person('salary', '2018-01') == 5000 + assert simulation_single.person('salary', '2017-01') == 2500 + assert simulation_single.person('salary', '2018-01') == 5000 salary_holder.delete_arrays(period = 2018) salary_holder.set_input(make_period(2018), np.asarray([15000])) - assert simulation.person('salary', '2017-01') == 2500 - assert simulation.person('salary', '2018-01') == 1250 + assert simulation_single.person('salary', '2017-01') == 2500 + assert simulation_single.person('salary', '2018-01') == 1250 -def test_cache_disk(couple): - simulation = couple - simulation.memory_config = force_storage_on_disk +def test_cache_disk(simulation_couple): + simulation_couple.memory_config = force_storage_on_disk month = make_period('2017-01') - holder = simulation.person.get_holder('disposable_income') + holder = simulation_couple.person.get_holder('disposable_income') data = np.asarray([2000, 3000]) holder.put_in_cache(data, month) stored_data = holder.get_array(month) assert_near(data, stored_data) -def test_known_periods(couple): - simulation = couple - simulation.memory_config = force_storage_on_disk +def test_known_periods(simulation_couple): + simulation_couple.memory_config = force_storage_on_disk month = make_period('2017-01') month_2 = make_period('2017-02') - holder = simulation.person.get_holder('disposable_income') + holder = simulation_couple.person.get_holder('disposable_income') data = np.asarray([2000, 3000]) holder.put_in_cache(data, month) holder._memory_storage.put(data, month_2) @@ -187,28 +159,25 @@ def test_known_periods(couple): assert sorted(holder.get_known_periods()), [month == month_2] -def test_cache_enum_on_disk(single): - simulation = single - simulation.memory_config = force_storage_on_disk +def test_cache_enum_on_disk(simulation_single): + simulation_single.memory_config = force_storage_on_disk month = make_period('2017-01') - simulation.calculate('housing_occupancy_status', month) # First calculation - housing_occupancy_status = simulation.calculate('housing_occupancy_status', month) # Read from cache + simulation_single.calculate('housing_occupancy_status', month) # First calculation + housing_occupancy_status = simulation_single.calculate('housing_occupancy_status', month) # Read from cache assert housing_occupancy_status == HousingOccupancyStatus.tenant -def test_set_not_cached_variable(single): +def test_set_not_cached_variable(simulation_single): dont_cache_variable = MemoryConfig(max_memory_occupation = 1, variables_to_drop = ['salary']) - simulation = single - simulation.memory_config = dont_cache_variable - holder = simulation.person.get_holder('salary') + simulation_single.memory_config = dont_cache_variable + holder = simulation_single.person.get_holder('salary') array = np.asarray([2000]) holder.set_input('2015-01', array) - assert simulation.calculate('salary', '2015-01') == array + assert simulation_single.calculate('salary', '2015-01') == array -def test_set_input_float_to_int(single): - simulation = single +def test_set_input_float_to_int(simulation_single): age = np.asarray([50.6]) - simulation.person.get_holder('age').set_input(period, age) - result = simulation.calculate('age', period) + simulation_single.person.get_holder('age').set_input(period, age) + result = simulation_single.calculate('age', period) assert result == np.asarray([50]) diff --git a/tests/core/test_opt_out_cache.py b/tests/core/test_opt_out_cache.py index 1b76287264..b7dfcb129d 100644 --- a/tests/core/test_opt_out_cache.py +++ b/tests/core/test_opt_out_cache.py @@ -2,8 +2,6 @@ from pytest import fixture -from openfisca_core.simulation_builder import SimulationBuilder -from openfisca_country_template import CountryTaxBenefitSystem from openfisca_country_template.entities import Person from openfisca_core.variables import Variable from openfisca_core.periods import MONTH @@ -14,15 +12,6 @@ def month(): return '2016-05' -@fixture -def make_isolated_simulation(month): - def _make_simulation(tbs, data): - builder = SimulationBuilder() - builder.default_period = month - return builder.build_from_variables(tbs, data) - return _make_simulation - - class input(Variable): value_type = int entity = Person @@ -50,31 +39,20 @@ def formula(person, period): return person('intermediate', period) -def get_filled_tbs(): - tax_benefit_system = CountryTaxBenefitSystem() +@fixture +def simulation(tax_benefit_system, make_simulation_from_tbs_and_variables): + tax_benefit_system.cache_blacklist = set(['intermediate']) tax_benefit_system.add_variables(input, intermediate, output) - - return tax_benefit_system - - -# TaxBenefitSystem instance declared after formulas + return make_simulation_from_tbs_and_variables(tax_benefit_system, {'input': 1}) -tax_benefit_system = get_filled_tbs() - - -tax_benefit_system.cache_blacklist = set(['intermediate']) - - -def test_without_cache_opt_out(make_isolated_simulation, month): - simulation = make_isolated_simulation(tax_benefit_system, {'input': 1}) +def test_without_cache_opt_out(simulation, month): simulation.calculate('output', period = month) intermediate_cache = simulation.persons.get_holder('intermediate') assert(intermediate_cache.get_array(month) is not None) -def test_with_cache_opt_out(make_isolated_simulation, month): - simulation = make_isolated_simulation(tax_benefit_system, {'input': 1}) +def test_with_cache_opt_out(simulation, month): simulation.debug = True simulation.opt_out_cache = True simulation.calculate('output', period = month) @@ -82,11 +60,7 @@ def test_with_cache_opt_out(make_isolated_simulation, month): assert(intermediate_cache.get_array(month) is None) -tax_benefit_system2 = get_filled_tbs() - - -def test_with_no_blacklist(make_isolated_simulation, month): - simulation = make_isolated_simulation(tax_benefit_system2, {'input': 1}) +def test_with_no_blacklist(simulation, month): simulation.calculate('output', period = month) intermediate_cache = simulation.persons.get_holder('intermediate') assert(intermediate_cache.get_array(month) is not None) diff --git a/tests/core/test_parameters.py b/tests/core/test_parameters.py index 88fedcabab..1b585723e3 100644 --- a/tests/core/test_parameters.py +++ b/tests/core/test_parameters.py @@ -1,14 +1,11 @@ # -*- coding: utf-8 -*- -import tempfile - import pytest from openfisca_core.parameters import ParameterNotFound, ParameterNode, ParameterNodeAtInstant, load_parameter_file -from .test_countries import tax_benefit_system -def test_get_at_instant(): +def test_get_at_instant(tax_benefit_system): parameters = tax_benefit_system.parameters assert isinstance(parameters, ParameterNode), parameters parameters_at_instant = parameters('2016-01-01') @@ -17,7 +14,7 @@ def test_get_at_instant(): assert parameters_at_instant.benefits.basic_income == 600 -def test_param_values(): +def test_param_values(tax_benefit_system): dated_values = { '2015-01-01': 0.15, '2014-01-01': 0.14, @@ -29,46 +26,45 @@ def test_param_values(): assert tax_benefit_system.get_parameters_at_instant(date).taxes.income_tax_rate == value -def test_param_before_it_is_defined(): +def test_param_before_it_is_defined(tax_benefit_system): with pytest.raises(ParameterNotFound): tax_benefit_system.get_parameters_at_instant('1997-12-31').taxes.income_tax_rate # The placeholder should have no effect on the parameter computation -def test_param_with_placeholder(): +def test_param_with_placeholder(tax_benefit_system): assert tax_benefit_system.get_parameters_at_instant('2018-01-01').taxes.income_tax_rate == 0.15 -def test_stopped_parameter_before_end_value(): +def test_stopped_parameter_before_end_value(tax_benefit_system): assert tax_benefit_system.get_parameters_at_instant('2011-12-31').benefits.housing_allowance == 0.25 -def test_stopped_parameter_after_end_value(): +def test_stopped_parameter_after_end_value(tax_benefit_system): with pytest.raises(ParameterNotFound): tax_benefit_system.get_parameters_at_instant('2016-12-01').benefits.housing_allowance -def test_parameter_for_period(): +def test_parameter_for_period(tax_benefit_system): income_tax_rate = tax_benefit_system.parameters.taxes.income_tax_rate assert income_tax_rate("2015") == income_tax_rate("2015-01-01") -def test_wrong_value(): +def test_wrong_value(tax_benefit_system): income_tax_rate = tax_benefit_system.parameters.taxes.income_tax_rate with pytest.raises(ValueError): income_tax_rate("test") -def test_parameter_repr(): +def test_parameter_repr(tax_benefit_system, tmp_path): + path = tmp_path / 'parameters' parameters = tax_benefit_system.parameters - tf = tempfile.NamedTemporaryFile(delete = False) - tf.write(repr(parameters).encode('utf-8')) - tf.close() - tf_parameters = load_parameter_file(file_path = tf.name) - assert repr(parameters) == repr(tf_parameters) + path.write_bytes(repr(parameters).encode('utf-8')) + tmp_parameters = load_parameter_file(file_path = path) + assert repr(parameters) == repr(tmp_parameters) -def test_parameters_metadata(): +def test_parameters_metadata(tax_benefit_system): parameter = tax_benefit_system.parameters.benefits.basic_income assert parameter.metadata['reference'] == 'https://law.gov.example/basic-income/amount' assert parameter.metadata['unit'] == 'currency-EUR' @@ -79,7 +75,7 @@ def test_parameters_metadata(): assert scale.metadata['rate_unit'] == '/1' -def test_parameter_node_metadata(): +def test_parameter_node_metadata(tax_benefit_system): parameter = tax_benefit_system.parameters.benefits assert parameter.description == 'Social benefits' @@ -87,12 +83,12 @@ def test_parameter_node_metadata(): assert parameter_2.description == 'Housing tax' -def test_parameter_documentation(): +def test_parameter_documentation(tax_benefit_system): parameter = tax_benefit_system.parameters.benefits.housing_allowance assert parameter.documentation == 'A fraction of the rent.\nFrom the 1st of Dec 2016, the housing allowance no longer exists.\n' -def test_get_descendants(): +def test_get_descendants(tax_benefit_system): all_parameters = {parameter.name for parameter in tax_benefit_system.parameters.get_descendants()} assert all_parameters.issuperset({'taxes', 'taxes.housing_tax', 'taxes.housing_tax.minimal_amount'}) diff --git a/tests/core/test_reforms.py b/tests/core/test_reforms.py index c76739691d..a369eb28ef 100644 --- a/tests/core/test_reforms.py +++ b/tests/core/test_reforms.py @@ -6,41 +6,26 @@ from openfisca_core import periods from openfisca_core.periods import Instant -from openfisca_core.simulation_builder import SimulationBuilder from openfisca_core.tools import assert_near from openfisca_core.parameters import ValuesHistory, ParameterNode from openfisca_country_template.entities import Household, Person from openfisca_core.model_api import * # noqa analysis:ignore -from openfisca_country_template import CountryTaxBenefitSystem -tax_benefit_system = CountryTaxBenefitSystem() @fixture -def make_simulation(): +def make_simulation(simulation_builder): def _make_simulation(tbs, period, data): - builder = SimulationBuilder() - builder.default_period = period - return builder.build_from_variables(tbs, data) + simulation_builder.default_period = period + return simulation_builder.build_from_variables(tbs, data) return _make_simulation -class goes_to_school(Variable): - value_type = bool - default_value = True - entity = Person - label = "The person goes to school (only relevant for children)" - definition_period = MONTH - - -tax_benefit_system.add_variable(goes_to_school) - - class WithBasicIncomeNeutralized(Reform): def apply(self): self.neutralize_variable('basic_income') -def test_formula_neutralization(make_simulation): +def test_formula_neutralization(tax_benefit_system, make_simulation): reform = WithBasicIncomeNeutralized(tax_benefit_system) period = '2017-01' @@ -61,21 +46,31 @@ def test_formula_neutralization(make_simulation): assert_near(disposable_income_reform, 0) -def test_neutralization_variable_with_default_value(make_simulation): +def test_neutralization_variable_with_default_value(tax_benefit_system, make_simulation): + + class goes_to_school(Variable): + value_type = bool + default_value = True + entity = Person + label = "The person goes to school (only relevant for children)" + definition_period = MONTH + class test_goes_to_school_neutralization(Reform): def apply(self): self.neutralize_variable('goes_to_school') + tax_benefit_system.add_variable(goes_to_school) + reform = test_goes_to_school_neutralization(tax_benefit_system) period = "2017-01" simulation = make_simulation(reform.base_tax_benefit_system, period, {}) - goes_to_school = simulation.calculate('goes_to_school', period) - assert_near(goes_to_school, [True], absolute_error_margin = 0) + goes_to_school_result = simulation.calculate('goes_to_school', period) + assert_near(goes_to_school_result, [True], absolute_error_margin = 0) -def test_neutralization_optimization(make_simulation): +def test_neutralization_optimization(tax_benefit_system, make_simulation): reform = WithBasicIncomeNeutralized(tax_benefit_system) period = '2017-01' @@ -90,7 +85,7 @@ def test_neutralization_optimization(make_simulation): assert basic_income_holder.get_known_periods() == [] -def test_input_variable_neutralization(make_simulation): +def test_input_variable_neutralization(tax_benefit_system, make_simulation): class test_salary_neutralization(Reform): def apply(self): @@ -111,7 +106,7 @@ def apply(self): assert_near(disposable_income_reform, [600, 600]) -def test_permanent_variable_neutralization(make_simulation): +def test_permanent_variable_neutralization(tax_benefit_system, make_simulation): class test_date_naissance_neutralization(Reform): def apply(self): @@ -223,7 +218,7 @@ def check_update_items(description, value_history, start_instant, stop_instant, ) -def test_add_variable(make_simulation): +def test_add_variable(tax_benefit_system, make_simulation): class new_variable(Variable): value_type = int label = "Nouvelle variable introduite par la réforme" @@ -247,7 +242,7 @@ def apply(self): assert_near(new_variable1, 10, absolute_error_margin = 0) -def test_add_dated_variable(make_simulation): +def test_add_dated_variable(tax_benefit_system, make_simulation): class new_dated_variable(Variable): value_type = int label = "Nouvelle variable introduite par la réforme" @@ -272,7 +267,7 @@ def apply(self): assert_near(new_dated_variable1, 15, absolute_error_margin = 0) -def test_update_variable(make_simulation): +def test_update_variable(tax_benefit_system, make_simulation): class disposable_income(Variable): definition_period = MONTH @@ -303,7 +298,7 @@ def apply(self): assert(disposable_income2 > 100) -def test_replace_variable(): +def test_replace_variable(tax_benefit_system): class disposable_income(Variable): definition_period = MONTH @@ -324,7 +319,7 @@ def apply(self): assert disposable_income_reform.get_formula('2017') is None -def test_wrong_reform(): +def test_wrong_reform(tax_benefit_system): class wrong_reform(Reform): # A Reform must implement an `apply` method pass @@ -333,7 +328,7 @@ class wrong_reform(Reform): wrong_reform(tax_benefit_system) -def test_modify_parameters(): +def test_modify_parameters(tax_benefit_system): def modify_parameters(reference_parameters): reform_parameters_subtree = ParameterNode( @@ -361,7 +356,7 @@ def apply(self): assert parameters_at_instant.new_node.new_param is True -def test_attributes_conservation(): +def test_attributes_conservation(tax_benefit_system): class some_variable(Variable): value_type = int @@ -391,7 +386,7 @@ def apply(self): assert reform_variable.calculate_output == baseline_variable.calculate_output -def test_formulas_removal(): +def test_formulas_removal(tax_benefit_system): class reform(Reform): def apply(self): diff --git a/tests/core/test_simulation_builder.py b/tests/core/test_simulation_builder.py index 09e594cce1..85348d3fbb 100644 --- a/tests/core/test_simulation_builder.py +++ b/tests/core/test_simulation_builder.py @@ -1,44 +1,42 @@ # -*- coding: utf-8 -*- from typing import Iterable - -from enum import Enum +from pytest import fixture, raises, approx from datetime import date +from enum import Enum -from pytest import raises, fixture, approx - -from openfisca_core.simulation_builder import SimulationBuilder, Simulation +from openfisca_core.simulation_builder import Simulation from openfisca_core.tools import assert_near from openfisca_core.tools.test_runner import yaml -from openfisca_core.entities import Entity, GroupEntity from openfisca_core.populations import Population -from openfisca_core.variables import Variable from openfisca_country_template.entities import Household -from openfisca_country_template.situation_examples import couple from openfisca_core.errors import SituationParsingError +from openfisca_core.variables import Variable from openfisca_core.periods import ETERNITY from openfisca_core.indexed_enums import Enum as OFEnum -from .test_countries import tax_benefit_system - - -class TestVariable(Variable): - definition_period = ETERNITY - value_type = float +@fixture +def enum_variable_instance(): - def __init__(self, entity): - self.__class__.entity = entity - super().__init__() + class TestEnum(Variable): + definition_period = ETERNITY + value_type = OFEnum + dtype = 'O' + default_value = '0' + is_neutralized = False + set_input = None + possible_values = Enum('foo', 'bar') + name = "enum" + def __init__(self): + pass -@fixture -def simulation_builder(): - return SimulationBuilder() + return TestEnum() @fixture -def int_variable(persons): +def int_variable_instance(persons): class intvar(Variable): definition_period = ETERNITY @@ -52,7 +50,7 @@ def __init__(self): @fixture -def date_variable(persons): +def date_variable_instance(persons): class datevar(Variable): definition_period = ETERNITY @@ -65,63 +63,7 @@ def __init__(self): return datevar() -@fixture -def enum_variable(): - - class TestEnum(Variable): - definition_period = ETERNITY - value_type = OFEnum - dtype = 'O' - default_value = '0' - is_neutralized = False - set_input = None - possible_values = Enum('foo', 'bar') - name = "enum" - - def __init__(self): - pass - - return TestEnum() - - -@fixture -def persons(): - class TestPersonEntity(Entity): - def get_variable(self, variable_name): - result = TestVariable(self) - result.name = variable_name - return result - - def check_variable_defined_for_entity(self, variable_name): - return True - - return TestPersonEntity("person", "persons", "", "") - - -@fixture -def group_entity(): - class Household(GroupEntity): - def get_variable(self, variable_name): - result = TestVariable(self) - result.name = variable_name - return result - - def check_variable_defined_for_entity(self, variable_name): - return True - - roles = [{ - 'key': 'parent', - 'plural': 'parents', - 'max': 2 - }, { - 'key': 'child', - 'plural': 'children' - }] - - return Household("household", "households", "", "", roles) - - -def test_build_default_simulation(simulation_builder): +def test_build_default_simulation(tax_benefit_system, simulation_builder): one_person_simulation = simulation_builder.build_default_simulation(tax_benefit_system, 1) assert one_person_simulation.persons.count == 1 assert one_person_simulation.household.count == 1 @@ -135,7 +77,7 @@ def test_build_default_simulation(simulation_builder): assert (several_persons_simulation.household.members_role == Household.FIRST_PARENT).all() -def test_explicit_singular_entities(simulation_builder): +def test_explicit_singular_entities(tax_benefit_system, simulation_builder): assert simulation_builder.explicit_singular_entities( tax_benefit_system, {'persons': {'Javier': {}}, 'household': {'parents': ['Javier']}} @@ -234,27 +176,27 @@ def test_fail_on_ill_formed_expression(simulation_builder, persons): assert excinfo.value.error == {'persons': {'Alicia': {'salary': {'2018-11': "I couldn't understand '2 * / 1000' as a value for 'salary'"}}}} -def test_fail_on_integer_overflow(simulation_builder, persons, int_variable): +def test_fail_on_integer_overflow(simulation_builder, persons, int_variable_instance): instance_index = 0 simulation_builder.entity_counts['persons'] = 1 with raises(SituationParsingError) as excinfo: - simulation_builder.add_variable_value(persons, int_variable, instance_index, 'Alicia', '2018-11', 9223372036854775808) + simulation_builder.add_variable_value(persons, int_variable_instance, instance_index, 'Alicia', '2018-11', 9223372036854775808) assert excinfo.value.error == {'persons': {'Alicia': {'intvar': {'2018-11': "Can't deal with value: '9223372036854775808', it's too large for type 'integer'."}}}} -def test_fail_on_date_parsing(simulation_builder, persons, date_variable): +def test_fail_on_date_parsing(simulation_builder, persons, date_variable_instance): instance_index = 0 simulation_builder.entity_counts['persons'] = 1 with raises(SituationParsingError) as excinfo: - simulation_builder.add_variable_value(persons, date_variable, instance_index, 'Alicia', '2018-11', '2019-02-30') + simulation_builder.add_variable_value(persons, date_variable_instance, instance_index, 'Alicia', '2018-11', '2019-02-30') assert excinfo.value.error == {'persons': {'Alicia': {'datevar': {'2018-11': "Can't deal with date: '2019-02-30'."}}}} -def test_add_unknown_enum_variable_value(simulation_builder, persons, enum_variable): +def test_add_unknown_enum_variable_value(simulation_builder, persons, enum_variable_instance): instance_index = 0 simulation_builder.entity_counts['persons'] = 1 with raises(SituationParsingError): - simulation_builder.add_variable_value(persons, enum_variable, instance_index, 'Alicia', '2018-11', 'baz') + simulation_builder.add_variable_value(persons, enum_variable_instance, instance_index, 'Alicia', '2018-11', 'baz') def test_finalize_person_entity(simulation_builder, persons): @@ -275,7 +217,7 @@ def test_canonicalize_period_keys(simulation_builder, persons): assert_near(population.get_holder('salary').get_array('2018-12'), [100]) -def test_finalize_group_entity(simulation_builder): +def test_finalize_group_entity(tax_benefit_system, simulation_builder): simulation = Simulation(tax_benefit_system, tax_benefit_system.instantiate_entities()) simulation_builder.add_group_entity('persons', ['Alicia', 'Javier', 'Sarah', 'Tom'], simulation.household.entity, { 'Household_1': {'parents': ['Alicia', 'Javier']}, @@ -337,7 +279,7 @@ def test_allocate_person_twice(simulation_builder): assert exception.value.error == {'familles': {'famille1': {'parents': 'Alicia has been declared more than once in familles'}}} -def test_one_person_without_household(simulation_builder): +def test_one_person_without_household(tax_benefit_system, simulation_builder): simulation_dict = {'persons': {'Alicia': {}}} simulation = simulation_builder.build_from_dict(tax_benefit_system, simulation_dict) assert simulation.household.count == 1 @@ -345,7 +287,7 @@ def test_one_person_without_household(simulation_builder): assert parents_in_households.tolist() == [1] # household member default role is first_parent -def test_some_person_without_household(simulation_builder): +def test_some_person_without_household(tax_benefit_system, simulation_builder): input_yaml = """ persons: {'Alicia': {}, 'Bob': {}} household: {'parents': ['Alicia']} @@ -356,7 +298,7 @@ def test_some_person_without_household(simulation_builder): assert parents_in_households.tolist() == [1, 1] # household member default role is first_parent -def test_nb_persons_in_group_entity(simulation_builder): +def test_nb_persons_in_group_entity(tax_benefit_system, simulation_builder): persons_ids: Iterable = [2, 0, 1, 4, 3] households_ids: Iterable = ['c', 'a', 'b'] persons_households: Iterable = ['c', 'a', 'a', 'b', 'a'] @@ -371,7 +313,7 @@ def test_nb_persons_in_group_entity(simulation_builder): assert persons_in_households.tolist() == [1, 3, 1] -def test_nb_persons_no_role(simulation_builder): +def test_nb_persons_no_role(tax_benefit_system, simulation_builder): persons_ids: Iterable = [2, 0, 1, 4, 3] households_ids: Iterable = ['c', 'a', 'b'] persons_households: Iterable = ['c', 'a', 'a', 'b', 'a'] @@ -386,7 +328,7 @@ def test_nb_persons_no_role(simulation_builder): assert parents_in_households.tolist() == [1, 3, 1] # household member default role is first_parent -def test_nb_persons_by_role(simulation_builder): +def test_nb_persons_by_role(tax_benefit_system, simulation_builder): persons_ids: Iterable = [2, 0, 1, 4, 3] households_ids: Iterable = ['c', 'a', 'b'] persons_households: Iterable = ['c', 'a', 'a', 'b', 'a'] @@ -406,7 +348,7 @@ def test_nb_persons_by_role(simulation_builder): assert parents_in_households.tolist() == [0, 1, 1] -def test_integral_roles(simulation_builder): +def test_integral_roles(tax_benefit_system, simulation_builder): persons_ids: Iterable = [2, 0, 1, 4, 3] households_ids: Iterable = ['c', 'a', 'b'] persons_households: Iterable = ['c', 'a', 'a', 'b', 'a'] @@ -430,7 +372,7 @@ def test_integral_roles(simulation_builder): # Test Intégration -def test_from_person_variable_to_group(simulation_builder): +def test_from_person_variable_to_group(tax_benefit_system, simulation_builder): persons_ids: Iterable = [2, 0, 1, 4, 3] households_ids: Iterable = ['c', 'a', 'b'] @@ -456,7 +398,7 @@ def test_from_person_variable_to_group(simulation_builder): assert total_taxes / simulation.calculate('rent', period) == approx(1) -def test_simulation(simulation_builder): +def test_simulation(tax_benefit_system, simulation_builder): input_yaml = """ salary: 2016-10: 12000 @@ -469,7 +411,7 @@ def test_simulation(simulation_builder): simulation.calculate("total_taxes", "2016-10") -def test_vectorial_input(simulation_builder): +def test_vectorial_input(tax_benefit_system, simulation_builder): input_yaml = """ salary: 2016-10: [12000, 20000] @@ -482,13 +424,13 @@ def test_vectorial_input(simulation_builder): simulation.calculate("total_taxes", "2016-10") -def test_fully_specified_entities(simulation_builder): +def test_fully_specified_entities(tax_benefit_system, simulation_builder, couple): simulation = simulation_builder.build_from_dict(tax_benefit_system, couple) assert simulation.household.count == 1 assert simulation.persons.count == 2 -def test_single_entity_shortcut(simulation_builder): +def test_single_entity_shortcut(tax_benefit_system, simulation_builder): input_yaml = """ persons: Alicia: {} @@ -501,7 +443,7 @@ def test_single_entity_shortcut(simulation_builder): assert simulation.household.count == 1 -def test_order_preserved(simulation_builder): +def test_order_preserved(tax_benefit_system, simulation_builder): input_yaml = """ persons: Javier: {} @@ -519,7 +461,7 @@ def test_order_preserved(simulation_builder): assert simulation.persons.ids == ['Javier', 'Alicia', 'Sarah', 'Tom'] -def test_inconsistent_input(simulation_builder): +def test_inconsistent_input(tax_benefit_system, simulation_builder): input_yaml = """ salary: 2016-10: [12000, 20000] diff --git a/tests/core/test_simulations.py b/tests/core/test_simulations.py index 6665cce8e1..dde211a8c6 100644 --- a/tests/core/test_simulations.py +++ b/tests/core/test_simulations.py @@ -1,15 +1,6 @@ # -*- coding: utf-8 -*- - -from openfisca_core.simulation_builder import SimulationBuilder - -from openfisca_country_template.situation_examples import single - -from .test_countries import tax_benefit_system - - -def test_calculate_full_tracer(): - simulation = SimulationBuilder().build_default_simulation(tax_benefit_system) +def test_calculate_full_tracer(simulation): simulation.trace = True simulation.calculate('income_tax', '2017-01') @@ -29,13 +20,12 @@ def test_calculate_full_tracer(): assert income_tax_node.parameters[0].value == 0.15 -def test_get_entity_not_found(): - simulation = SimulationBuilder().build_default_simulation(tax_benefit_system) +def test_get_entity_not_found(simulation): assert simulation.get_entity(plural = "no_such_entities") is None -def test_clone(): - simulation = SimulationBuilder().build_from_entities(tax_benefit_system, +def test_clone(tax_benefit_system, simulation_builder): + simulation = simulation_builder.build_from_entities(tax_benefit_system, { "persons": { "bill": {"salary": {"2017-01": 3000}}, @@ -63,9 +53,8 @@ def test_clone(): assert salary_holder_clone.population == simulation_clone.persons -def test_get_memory_usage(): - simulation = SimulationBuilder().build_from_entities(tax_benefit_system, single) - simulation.calculate('disposable_income', '2017-01') - memory_usage = simulation.get_memory_usage(variables = ['salary']) +def test_get_memory_usage(simulation_single): + simulation_single.calculate('disposable_income', '2017-01') + memory_usage = simulation_single.get_memory_usage(variables = ['salary']) assert(memory_usage['total_nb_bytes'] > 0) assert(len(memory_usage['by_variable']) == 1) diff --git a/tests/core/test_yaml.py b/tests/core/test_yaml.py index 2390eb6929..0d0c80d1bc 100644 --- a/tests/core/test_yaml.py +++ b/tests/core/test_yaml.py @@ -9,8 +9,6 @@ from openfisca_core.tools.test_runner import run_tests -from .test_countries import tax_benefit_system - openfisca_core_dir = pkg_resources.get_distribution('OpenFisca-Core').location yaml_tests_dir = os.path.join(openfisca_core_dir, 'tests', 'core', 'yaml_tests') @@ -18,7 +16,7 @@ EXIT_TESTSFAILED = 1 -def run_yaml_test(path, options = None): +def run_yaml_test(tax_benefit_system, path, options = None): yaml_path = os.path.join(yaml_tests_dir, path) if options is None: @@ -28,53 +26,53 @@ def run_yaml_test(path, options = None): return result -def test_success(): - assert run_yaml_test('test_success.yml') == EXIT_OK +def test_success(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_success.yml') == EXIT_OK -def test_fail(): - assert run_yaml_test('test_failure.yaml') == EXIT_TESTSFAILED +def test_fail(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_failure.yaml') == EXIT_TESTSFAILED -def test_relative_error_margin_success(): - assert run_yaml_test('test_relative_error_margin.yaml') == EXIT_OK +def test_relative_error_margin_success(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_relative_error_margin.yaml') == EXIT_OK -def test_relative_error_margin_fail(): - assert run_yaml_test('failing_test_relative_error_margin.yaml') == EXIT_TESTSFAILED +def test_relative_error_margin_fail(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'failing_test_relative_error_margin.yaml') == EXIT_TESTSFAILED -def test_absolute_error_margin_success(): - assert run_yaml_test('test_absolute_error_margin.yaml') == EXIT_OK +def test_absolute_error_margin_success(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_absolute_error_margin.yaml') == EXIT_OK -def test_absolute_error_margin_fail(): - assert run_yaml_test('failing_test_absolute_error_margin.yaml') == EXIT_TESTSFAILED +def test_absolute_error_margin_fail(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'failing_test_absolute_error_margin.yaml') == EXIT_TESTSFAILED -def test_run_tests_from_directory(): +def test_run_tests_from_directory(tax_benefit_system): dir_path = os.path.join(yaml_tests_dir, 'directory') - assert run_yaml_test(dir_path) == EXIT_OK + assert run_yaml_test(tax_benefit_system, dir_path) == EXIT_OK -def test_with_reform(): - assert run_yaml_test('test_with_reform.yaml') == EXIT_OK +def test_with_reform(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_with_reform.yaml') == EXIT_OK -def test_with_extension(): - assert run_yaml_test('test_with_extension.yaml') == EXIT_OK +def test_with_extension(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_with_extension.yaml') == EXIT_OK -def test_with_anchors(): - assert run_yaml_test('test_with_anchors.yaml') == EXIT_OK +def test_with_anchors(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, 'test_with_anchors.yaml') == EXIT_OK -def test_run_tests_from_directory_fail(): - assert run_yaml_test(yaml_tests_dir) == EXIT_TESTSFAILED +def test_run_tests_from_directory_fail(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, yaml_tests_dir) == EXIT_TESTSFAILED -def test_name_filter(): - assert run_yaml_test( +def test_name_filter(tax_benefit_system): + assert run_yaml_test(tax_benefit_system, yaml_tests_dir, options = {'name_filter': 'success'} ) == EXIT_OK diff --git a/tests/core/tools/test_assert_near.py b/tests/core/tools/test_assert_near.py index 597e3d612b..035ca07466 100644 --- a/tests/core/tools/test_assert_near.py +++ b/tests/core/tools/test_assert_near.py @@ -3,21 +3,19 @@ from openfisca_core.tools import assert_near -from ..test_countries import tax_benefit_system - def test_date(): assert_near(np.array("2012-03-24", dtype = 'datetime64[D]'), "2012-03-24") -def test_enum(): +def test_enum(tax_benefit_system): possible_values = tax_benefit_system.variables['housing_occupancy_status'].possible_values value = possible_values.encode(np.array(['tenant'])) expected_value = 'tenant' assert_near(value, expected_value) -def test_enum_2(): +def test_enum_2(tax_benefit_system): possible_values = tax_benefit_system.variables['housing_occupancy_status'].possible_values value = possible_values.encode(np.array(['tenant', 'owner'])) expected_value = ['tenant', 'owner']