taxcalc 5.2.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

taxcalc/tests/test_records.py

@@ -29,10 +29,80 @@ def test_incorrect_records_instantiation(cps_subsample, cps_fullsample):
         _ = Records(data=cps_subsample, gfactors=None, weights=None,
                     adjust_ratios=[])
     # test error raise when num of records is greater than num of weights
-    wghts_path = os.path.join(Records.CODE_PATH, Records.PUF_WEIGHTS_FILENAME)
-    puf_wghts = pd.read_csv(wghts_path)
+    cps_weights_path = os.path.join(Records.CODE_PATH, 'cps_weights.csv.gz')
+    weights = pd.read_csv(cps_weights_path)
+    some_wghts = weights[:100]
     with pytest.raises(ValueError):
-        _ = Records(data=cps_fullsample, weights=puf_wghts, start_year=2020)
+        _ = Records(data=cps_fullsample, weights=some_wghts, start_year=2020)
+
+
+def test_invalid_variable_values_1(cps_subsample):
+    """Test docstring"""
+    dta = cps_subsample.copy()
+    dta['PT_SSTB_income'] = 2
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['e01700'] = 1000
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['e00650'] = 1000
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['k1bx14s'] = 1000
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['e02100'] = dta['e02100p'] + dta['e02100s'] + 1000
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['e00900'] = dta['e00900p'] + dta['e00900s'] + 1000
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['e00200'] = dta['e00200p'] + dta['e00200s'] + 1000
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['EIC'] = 4
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta['MARS'] = 0
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+
+
+def test_invalid_variable_values_2():
+    """Test docstring"""
+    dta = pd.DataFrame(
+        {
+            'RECID': [1],
+            'MARS': [1],
+            'e00200p': [8e4],
+            'e00200s': [1e4],
+            'e00200': [9e4],
+        }
+    )
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta = pd.DataFrame(
+        {
+            'RECID': [1],
+            'MARS': [1],
+            'e00900p': [8e4],
+            'e00900s': [1e4],
+            'e00900': [9e4],
+        }
+    )
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
+    dta = pd.DataFrame(
+        {
+            'RECID': [1],
+            'MARS': [1],
+            'e02100p': [8e4],
+            'e02100s': [1e4],
+            'e02100': [9e4],
+        }
+    )
+    with pytest.raises(ValueError):
+        _ = Records(data=dta, start_year=2000)
 
 
 def test_correct_records_instantiation(cps_subsample):
@@ -45,16 +115,15 @@ def test_correct_records_instantiation(cps_subsample):
     rec1.increment_year()
     sum_e00200_in_cps_year_plus_one = getattr(rec1, 'e00200').sum()
     assert sum_e00200_in_cps_year_plus_one == sum_e00200_in_cps_year
-    wghts_path = os.path.join(Records.CODE_PATH, Records.CPS_WEIGHTS_FILENAME)
+    wghts_path = os.path.join(Records.CODE_PATH, 'cps_weights.csv.gz')
     wghts_df = pd.read_csv(wghts_path)
-    ratios_path = os.path.join(Records.CODE_PATH, Records.PUF_RATIOS_FILENAME)
-    ratios_df = pd.read_csv(ratios_path, index_col=0).transpose()
     rec2 = Records(data=cps_subsample,
                    start_year=Records.CPSCSV_YEAR,
                    gfactors=GrowFactors(),
                    weights=wghts_df,
-                   adjust_ratios=ratios_df,
-                   exact_calculations=False)
+                   adjust_ratios=None,
+                   exact_calculations=False,
+                   weights_scale=0.01)
     assert rec2
     assert np.all(getattr(rec2, 'MARS') != 0)
     assert getattr(rec2, 'current_year') == getattr(rec2, 'data_year')
@@ -66,7 +135,7 @@ def test_read_cps_data(cps_fullsample):
     assert data.equals(cps_fullsample)
 
 
-@pytest.mark.parametrize("csv", [
+@pytest.mark.parametrize('csv', [
     (
         'RECID,MARS,e00200,e00200p,e00200s\n'
         '1,    2,   200000, 200000,   0.03\n'
@@ -134,21 +203,25 @@ def test_read_data(csv):
 def test_for_duplicate_names():
     """Test docstring"""
     records_varinfo = Records(data=None)
+    num_vars = 0
     varnames = set()
     for varname in records_varinfo.USABLE_READ_VARS:
         assert varname not in varnames
         varnames.add(varname)
         assert varname not in records_varinfo.CALCULATED_VARS
+    num_vars += len(varnames)
     varnames = set()
     for varname in records_varinfo.CALCULATED_VARS:
         assert varname not in varnames
         varnames.add(varname)
         assert varname not in records_varinfo.USABLE_READ_VARS
+    num_vars += len(varnames)
     varnames = set()
     for varname in records_varinfo.INTEGER_READ_VARS:
         assert varname not in varnames
         varnames.add(varname)
         assert varname in records_varinfo.USABLE_READ_VARS
+    assert num_vars == 212  # number of vars in records_variables.json
 
 
 def test_records_variables_content(tests_path):
@@ -245,3 +318,65 @@ def test_csv_input_vars_md_contents(tests_path):
         for var in valid_less_civ:
             msg += f'VARIABLE= {var}\n'  # pylint: disable=consider-using-join
         raise ValueError(msg)
+
+
+def test_cps_availability(tests_path, cps_data_path):
+    """
+    Cross-check records_variables.json data with variables in cps.csv file.
+    """
+    # make set of variable names that are in the cps.csv file
+    cpsdf = pd.read_csv(cps_data_path)
+    cpsvars = set(sorted(list(cpsdf)))
+    # make set of variable names that are marked as cps available in r_v.json
+    rvpath = os.path.join(tests_path, '..', 'records_variables.json')
+    with open(rvpath, 'r', encoding='utf-8') as rvfile:
+        rvdict = json.load(rvfile)
+    recvars = set()
+    for vname, vdict in rvdict['read'].items():
+        if 'taxdata_cps' in vdict.get('availability', ''):
+            recvars.add(vname)
+    # check that cpsvars and recvars sets are the same
+    assert (cpsvars - recvars) == set()
+    assert (recvars - cpsvars) == set()
+
+
+@pytest.mark.requires_puf
+def test_puf_availability(tests_path, puf_data_path):
+    """
+    Cross-check records_variables.json data with variables in puf.csv file
+    """
+    # make set of variable names that are in the puf.csv file
+    pufdf = pd.read_csv(puf_data_path)
+    pufvars = set(sorted(list(pufdf)))
+    # make set of variable names that are marked as puf available in r_v.json
+    rvpath = os.path.join(tests_path, '..', 'records_variables.json')
+    with open(rvpath, 'r', encoding='utf-8') as rvfile:
+        rvdict = json.load(rvfile)
+    recvars = set()
+    for vname, vdict in rvdict['read'].items():
+        if 'taxdata_puf' in vdict.get('availability', ''):
+            recvars.add(vname)
+    # check that pufvars and recvars sets are the same
+    assert (pufvars - recvars) == set()
+    assert (recvars - pufvars) == set()
+
+
+@pytest.mark.requires_tmd
+def test_tmd_availability(tests_path, tmd_data_path):
+    """
+    Cross-check records_variables.json data with variables in tmd.csv file
+    """
+    # make set of variable names that are in the tmd.csv file
+    tmddf = pd.read_csv(tmd_data_path)
+    tmdvars = set(sorted(list(tmddf)))
+    # make set of variable names that are marked as tmd available in r_v.json
+    rvpath = os.path.join(tests_path, '..', 'records_variables.json')
+    with open(rvpath, 'r', encoding='utf-8') as rvfile:
+        rvdict = json.load(rvfile)
+    recvars = set()
+    for vname, vdict in rvdict['read'].items():
+        if 'taxmicrodata_tmd' in vdict.get('availability', ''):
+            recvars.add(vname)
+    # check that tmdvars and recvars sets are the same
+    assert (tmdvars - recvars) == set()
+    assert (recvars - tmdvars) == set()

taxcalc/tests/test_reforms.py

@@ -73,8 +73,19 @@ def test_2017_law_reform(tests_path):
             assert act == exp, f'{name} a={act} != e={exp}'
 
 
+def _apply_reform(policy, reform_path):
+    """
+    Helper function to apply a reform and assert no errors.
+    """
+    with open(reform_path, 'r', encoding='utf-8') as rfile:
+        rtext = rfile.read()
+    policy.implement_reform(Policy.read_json_reform(rtext))
+    assert not policy.parameter_errors
+    assert not policy.errors
+
+
 @pytest.mark.rtr
-@pytest.mark.parametrize('fyear', [2019, 2020, 2021, 2022, 2023])
+@pytest.mark.parametrize('fyear', [2019, 2020, 2021, 2022, 2023, 2024, 2025])
 def test_round_trip_reforms(fyear, tests_path):
     """
     Check that current-law policy has the same policy parameter values in
@@ -83,7 +94,7 @@ def test_round_trip_reforms(fyear, tests_path):
     reforms that represents new tax legislation since 2017.
     This test checks that the future-year parameter values for
     current-law policy (which incorporates recent legislation such as
-    the TCJA, CARES Act, and ARPA) are the same as future-year
+    the TCJA, CARES Act, ARPA, and OBBBA) are the same as future-year
     parameter values for the compound round-trip reform.
     Doing this check ensures that the 2017_law.json
     and subsequent reform files that represent recent legislation are
@@ -97,48 +108,21 @@ def test_round_trip_reforms(fyear, tests_path):
     clp_mdata = dict(clp_pol.items())
     # create rtr metadata dictionary for round-trip reform in fyear
     rtr_pol = Policy()
-    # Revert to 2017 law
-    reform_file = os.path.join(tests_path, '..', 'reforms', '2017_law.json')
-    with open(reform_file, 'r', encoding='utf-8') as rfile:
-        rtext = rfile.read()
-    rtr_pol.implement_reform(Policy.read_json_reform(rtext))
-    assert not rtr_pol.parameter_errors
-    assert not rtr_pol.errors
-    # Layer on TCJA
-    reform_file = os.path.join(tests_path, '..', 'reforms', 'TCJA.json')
-    with open(reform_file, 'r', encoding='utf-8') as rfile:
-        rtext = rfile.read()
-    rtr_pol.implement_reform(Policy.read_json_reform(rtext))
-    assert not rtr_pol.parameter_errors
-    assert not rtr_pol.errors
-    # Layer on the CARES Act
-    reform_file = os.path.join(tests_path, '..', 'reforms', 'CARES.json')
-    with open(reform_file, 'r', encoding='utf-8') as rfile:
-        rtext = rfile.read()
-    rtr_pol.implement_reform(Policy.read_json_reform(rtext))
-    # Layer on the Consolidated Appropriations Act of 2021
-    reform_file = os.path.join(
-        tests_path, '..', 'reforms', 'ConsolidatedAppropriationsAct2021.json'
-    )
-    with open(reform_file, 'r', encoding='utf-8') as rfile:
-        rtext = rfile.read()
-    rtr_pol.implement_reform(Policy.read_json_reform(rtext))
-    assert not rtr_pol.parameter_errors
-    assert not rtr_pol.errors
-    # Layer on ARPA
-    reform_file = os.path.join(tests_path, '..', 'reforms', 'ARPA.json')
-    with open(reform_file, 'r', encoding='utf-8') as rfile:
-        rtext = rfile.read()
-    rtr_pol.implement_reform(Policy.read_json_reform(rtext))
-    assert not rtr_pol.parameter_errors
-    assert not rtr_pol.errors
-    # Layer on rounding from IRS through Policy.LAST_KNOWN_YEAR
-    reform_file = os.path.join(tests_path, '..', 'reforms', 'rounding.json')
-    with open(reform_file, 'r', encoding='utf-8') as rfile:
-        rtext = rfile.read()
-    rtr_pol.implement_reform(Policy.read_json_reform(rtext))
-    assert not rtr_pol.parameter_errors
-    assert not rtr_pol.errors
+
+    reform_files_to_apply = [
+        '2017_law.json',
+        'TCJA.json',
+        'CARES.json',
+        'ConsolidatedAppropriationsAct2021.json',
+        'ARPA.json',
+        'OBBBA.json',
+        'rounding.json'
+    ]
+    for reform_filename in reform_files_to_apply:
+        reform_file_path = os.path.join(tests_path, '..',
+                                        'reforms', reform_filename)
+        _apply_reform(rtr_pol, reform_file_path)
+
     rtr_pol.set_year(fyear)
     rtr_mdata = dict(rtr_pol.items())
     # compare fyear policy parameter values
@@ -158,7 +142,7 @@ def test_round_trip_reforms(fyear, tests_path):
         clp_val = clp_mdata[pname]
         if not np.allclose(rtr_val, clp_val):
             fail_params.append(pname)
-            msg += '\n  {pname} in {fyear} : rtr={rtr_val} clp={clp_val}'
+            msg += f'\n  {pname} in {fyear} : rtr={rtr_val} clp={clp_val}'
             if fail_dump:
                 rtr_fails.write(f'{pname} {fyear} {rtr_val}\n')
                 clp_fails.write(f'{pname} {fyear} {clp_val}\n')
@@ -169,8 +153,23 @@ def test_round_trip_reforms(fyear, tests_path):
         raise ValueError(msg)
 
 
+REFORM_DIR = os.path.join(os.path.dirname(__file__), '..', 'reforms')
+REFORM_FILES = glob.glob(os.path.join(REFORM_DIR, '*.json'))
+REFORM_YEARS = {
+    'ARPA.json': 2022,
+    'ext.json': 2026,
+    'NoOBBBA.json': 2026,
+    'OBBBA.json': 2026,
+}
+
+
 @pytest.mark.reforms
-def test_reform_json_and_output(tests_path):
+@pytest.mark.parametrize(
+    'reform_file,tax_year',
+    [(os.path.basename(f), REFORM_YEARS.get(os.path.basename(f), 2020))
+     for f in REFORM_FILES],
+)
+def test_reform_json_and_output(reform_file, tax_year, tests_path):
     """
     Check that each JSON reform file can be converted into a reform dictionary
     that can then be passed to the Policy class implement_reform method that
@@ -213,7 +212,6 @@ def test_reform_json_and_output(tests_path):
         return not diffs
 
     # specify Records object containing cases data
-    tax_year = 2020
     cases_path = os.path.join(tests_path, '..', 'reforms', 'cases.csv')
     cases = Records(data=cases_path,
                     start_year=tax_year,  # set raw input data year
@@ -226,9 +224,10 @@ def test_reform_json_and_output(tests_path):
     calc = Calculator(policy=Policy(), records=cases, verbose=False)
     calc.advance_to_year(tax_year)
     calc.calc_all()
-    res_path = cases_path.replace('cases.csv', 'clp.res.csv')
+    clp_base = cases_path.replace('cases.csv', f'clp-{tax_year}')
+    res_path = clp_base + '.res.csv'
     write_res_file(calc, res_path)
-    if res_and_out_are_same(res_path.replace('.res.csv', '')):
+    if res_and_out_are_same(clp_base):
         os.remove(res_path)
     else:
         failures.append(res_path)
@@ -237,33 +236,29 @@ def test_reform_json_and_output(tests_path):
     pre_tcja_jrf = os.path.join(tests_path, '..', 'reforms', '2017_law.json')
     pre_tcja = Policy.read_json_reform(pre_tcja_jrf)
     # check reform file contents and reform results for each reform
-    reforms_path = os.path.join(tests_path, '..', 'reforms', '*.json')
-    json_reform_files = glob.glob(reforms_path)
-    for jrf in json_reform_files:
-        if jrf.endswith('ext.json'):
-            continue  # skip ext.json, which is tested below in test_ext_reform
-        # determine reform's baseline by reading contents of jrf
-        with open(jrf, 'r', encoding='utf-8') as rfile:
-            jrf_text = rfile.read()
-        pre_tcja_baseline = 'Reform_Baseline: 2017_law.json' in jrf_text
-        # implement the reform relative to its baseline
-        reform = Policy.read_json_reform(jrf_text)
-        pol = Policy()  # current-law policy
-        if pre_tcja_baseline:
-            pol.implement_reform(pre_tcja)
-            assert not pol.parameter_errors
-        pol.implement_reform(reform)
+    jrf = os.path.join(tests_path, '..', 'reforms', reform_file)
+    # determine reform's baseline by reading contents of jrf
+    with open(jrf, 'r', encoding='utf-8') as rfile:
+        jrf_text = rfile.read()
+    pre_tcja_baseline = 'Reform_Baseline: 2017_law.json' in jrf_text
+    # implement the reform relative to its baseline
+    reform = Policy.read_json_reform(jrf_text)
+    pol = Policy()  # current-law policy
+    if pre_tcja_baseline:
+        pol.implement_reform(pre_tcja)
         assert not pol.parameter_errors
-        calc = Calculator(policy=pol, records=cases, verbose=False)
-        calc.advance_to_year(tax_year)
-        calc.calc_all()
-        res_path = jrf.replace('.json', '.res.csv')
-        write_res_file(calc, res_path)
-        if res_and_out_are_same(res_path.replace('.res.csv', '')):
-            os.remove(res_path)
-        else:
-            failures.append(res_path)
-        del calc
+    pol.implement_reform(reform)
+    assert not pol.parameter_errors
+    calc = Calculator(policy=pol, records=cases, verbose=False)
+    calc.advance_to_year(tax_year)
+    calc.calc_all()
+    res_path = jrf.replace('.json', '.res.csv')
+    write_res_file(calc, res_path)
+    if res_and_out_are_same(res_path.replace('.res.csv', '')):
+        os.remove(res_path)
+    else:
+        failures.append(res_path)
+    del calc
     if failures:
         msg = 'Following reforms have res-vs-out differences:\n'
         for ref in failures:
@@ -271,12 +266,12 @@ def test_reform_json_and_output(tests_path):
         raise ValueError(msg)
 
 
-def reform_results(rid, reform_dict, puf_data, reform_2017_law):
+def reform_results(rid, reform_dict, cps_data, reform_2017_law):
     """
     Return actual results of the reform specified by rid and reform_dict.
     """
     # pylint: disable=too-many-locals
-    rec = Records(data=puf_data)
+    rec = Records.cps_constructor(data=cps_data)
     # create baseline Calculator object, calc1
     pol = Policy()
     if reform_dict['baseline'] == '2017_law.json':
@@ -341,49 +336,54 @@ def fixture_reforms_dict(tests_path):
 NUM_REFORMS = 60  # when changing this also change num_reforms in conftest.py
 
 
-@pytest.mark.requires_pufcsv
 @pytest.mark.parametrize('rid', list(range(1, NUM_REFORMS + 1)))
 def test_reforms(rid, test_reforms_init, tests_path, baseline_2017_law,
-                 reforms_dict, puf_subsample):
+                 reforms_dict, cps_subsample):
     """
     Write actual reform results to files.
     """
     # pylint: disable=too-many-arguments,too-many-positional-arguments
     assert test_reforms_init == NUM_REFORMS
     actual = reform_results(rid, reforms_dict[str(rid)],
-                            puf_subsample, baseline_2017_law)
+                            cps_subsample, baseline_2017_law)
     afile_path = os.path.join(tests_path, f'reform_actual_{rid}.csv')
     with open(afile_path, 'w', encoding='utf-8') as afile:
         afile.write('rid,res1,res2,res3,res4\n')
         afile.write(f'{actual}\n')
 
 
-@pytest.mark.extend_tcja
-def test_ext_reform(tests_path):
+@pytest.mark.parametrize('reform_filename, expected_diff', [
+    ('ext.json', 45.491),
+    ('OBBBA.json', 0.0),
+    ('NoOBBBA.json', 292.402),
+])
+def test_reforms_cps(reform_filename, expected_diff, tests_path):
     """
-    Test ext.json reform that extends TCJA beyond 2025.
+    Test reforms beyond 2025 using public CPS data.
     """
-    # test syntax of ext.json reform file
-    end = Policy()
-    end.set_year(2026)
-    ext = Policy()
-    reform_file = os.path.join(tests_path, '..', 'reforms', 'ext.json')
+    pol = Policy()
+    reform_file = os.path.join(tests_path, '..', 'reforms', reform_filename)
     with open(reform_file, 'r', encoding='utf-8') as rfile:
         rtext = rfile.read()
-    ext.implement_reform(Policy.read_json_reform(rtext))
-    assert not ext.parameter_errors
-    ext.set_year(2026)
-    assert np.allclose([ext.II_em], [end.II_em])
-    # test tax output generated by ext.json reform file using public CPS data
+    pol.implement_reform(Policy.read_json_reform(rtext))
+    assert not pol.parameter_errors
+
     recs = Records.cps_constructor()
-    calc_end = Calculator(policy=end, records=recs, verbose=False)
-    calc_end.advance_to_year(2026)
-    calc_end.calc_all()
-    iitax_end = calc_end.array('iitax')
-    calc_ext = Calculator(policy=ext, records=recs, verbose=False)
-    calc_ext.advance_to_year(2026)
-    calc_ext.calc_all()
-    iitax_ext = calc_ext.array('iitax')
-    rdiff = iitax_ext - iitax_end
-    weighted_sum_rdiff = (rdiff * calc_end.array('s006')).sum() * 1.0e-9
-    assert np.allclose([weighted_sum_rdiff], [45.491], rtol=0.0, atol=0.01)
+
+    # create a Calculator object using current-law policy
+    calc_clp = Calculator(policy=Policy(), records=recs, verbose=False)
+    calc_clp.advance_to_year(2026)
+    calc_clp.calc_all()
+    iitax_clp = calc_clp.array('iitax')
+
+    # create a Calculator object using the reform
+    calc_ref = Calculator(policy=pol, records=recs, verbose=False)
+    calc_ref.advance_to_year(2026)
+    calc_ref.calc_all()
+    iitax_ref = calc_ref.array('iitax')
+
+    # compare aggregate individual income tax liability
+    rdiff = iitax_ref - iitax_clp
+    weighted_sum_rdiff = (rdiff * calc_clp.array('s006')).sum() * 1.0e-9
+    assert np.allclose([weighted_sum_rdiff], [expected_diff],
+                       rtol=0.0, atol=0.01)

taxcalc/tests/test_taxcalcio.py

@@ -320,50 +320,10 @@ def test_init_errors(reformfile0, errorreformfile, errorassumpfile,
     # test TaxCalcIO.init method
     tcio.init(input_data=recdf, tax_year=year,
               baseline=baseline, reform=reform, assump=assump,
-              aging_input_data=False,
               exact_calculations=True)
     assert tcio.errmsg
 
 
-def test_creation_with_aging(reformfile0):
-    """
-    Test TaxCalcIO instantiation with/without no policy reform and with aging.
-    """
-    taxyear = 2021
-    tcio = TaxCalcIO(input_data=pd.read_csv(StringIO(RAWINPUT)),
-                     tax_year=taxyear,
-                     baseline=None,
-                     reform=reformfile0.name,
-                     assump=None,
-                     silent=False)
-    assert not tcio.errmsg
-    tcio.init(input_data=pd.read_csv(StringIO(RAWINPUT)),
-              tax_year=taxyear,
-              baseline=None,
-              reform=reformfile0.name,
-              assump=None,
-              aging_input_data=True,
-              exact_calculations=False)
-    assert not tcio.errmsg
-    assert tcio.tax_year() == taxyear
-    taxyear = 2016
-    tcio = TaxCalcIO(input_data=pd.read_csv(StringIO(RAWINPUT)),
-                     tax_year=taxyear,
-                     baseline=None,
-                     reform=None,
-                     assump=None)
-    assert not tcio.errmsg
-    tcio.init(input_data=pd.read_csv(StringIO(RAWINPUT)),
-              tax_year=taxyear,
-              baseline=None,
-              reform=None,
-              assump=None,
-              aging_input_data=True,
-              exact_calculations=False)
-    assert not tcio.errmsg
-    assert tcio.tax_year() == taxyear
-
-
 def test_ctor_init_with_cps_files():
     """
     Test use of CPS input files.
@@ -372,32 +332,32 @@ def test_ctor_init_with_cps_files():
     txyr = 2020
     for rid in [0, 99]:
         tcio = TaxCalcIO('cps.csv', txyr, None, None, None, runid=rid)
-        tcio.init(
-            'cps.csv', txyr, None, None, None,
-            aging_input_data=True,
-            exact_calculations=False,
-        )
+        tcio.init('cps.csv', txyr, None, None, None, exact_calculations=False)
         assert not tcio.errmsg
         assert tcio.tax_year() == txyr
         # test advance_to_year method
         tcio.silent = False
-        tcio.advance_to_year(txyr + 1, True)
+        tcio.advance_to_year(txyr + 1)
         assert tcio.tax_year() == txyr + 1
     # specify invalid tax_year for cps.csv input data
     txyr = 2013
     tcio = TaxCalcIO('cps.csv', txyr, None, None, None)
-    tcio.init('cps.csv', txyr, None, None, None,
-              aging_input_data=True,
-              exact_calculations=False)
+    tcio.init('cps.csv', txyr, None, None, None, exact_calculations=False)
     assert tcio.errmsg
 
 
-@pytest.mark.parametrize("dumpvar_str, str_valid, num_vars", [
+@pytest.mark.parametrize('dumpvar_str, str_valid, num_vars', [
     ("""
     MARS;iitax	payrolltax|combined,
     c00100
     surtax
-    """, True, 6),  # these 6 parameters minus MARS plus RECID
+    """, True, 6),  # these 6 variables minus MARS plus RECID
+
+    ('ALL', True, 209),
+    # 209 =
+    # all 212 vars in records_variables.json (see test_records.py)
+    # minus 5 TaxCalcIO.BASE_DUMPVARS omitting RECID (see taxcalcio.py)
+    # plus 2 TaxCalcIO.MTR_DUMPVARS (see taxcalcio.py)
 
     ("""
     MARS;iitax	payrolltax|kombined,c00100
@@ -418,7 +378,6 @@ def test_dump_variables(dumpvar_str, str_valid, num_vars):
     assert not tcio.errmsg
     tcio.init(input_data=recdf, tax_year=year,
               baseline=None, reform=None, assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     varlist = tcio.dump_variables(dumpvar_str)
@@ -445,7 +404,6 @@ def test_output_options_min(reformfile1, assumpfile1):
               baseline=None,
               reform=reformfile1.name,
               assump=assumpfile1.name,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     dumppath = tcio.output_filepath().replace('.xxx', '.dumpdb')
@@ -480,7 +438,6 @@ def test_output_options_mtr(reformfile1, assumpfile1):
               baseline=None,
               reform=reformfile1.name,
               assump=assumpfile1.name,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     dumppath = tcio.output_filepath().replace('.xxx', '.dumpdb')
@@ -520,7 +477,6 @@ def test_write_policy_param_files(reformfile1):
               baseline=compound_reform,
               reform=compound_reform,
               assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     tcio.write_policy_params_files()
@@ -557,7 +513,6 @@ def test_no_tables_or_graphs(reformfile1):
               baseline=None,
               reform=reformfile1.name,
               assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     # create several TaxCalcIO output files
@@ -593,7 +548,6 @@ def test_tables(reformfile1):
               baseline=None,
               reform=reformfile1.name,
               assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     # create TaxCalcIO tables file
@@ -627,7 +581,6 @@ def test_graphs(reformfile1):
               baseline=None,
               reform=reformfile1.name,
               assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     tcio.analyze(output_graphs=True)
@@ -671,7 +624,6 @@ def test_analyze_warnings_print(warnreformfile):
               baseline=None,
               reform=warnreformfile.name,
               assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert not tcio.errmsg
     tcio.analyze()
@@ -739,11 +691,10 @@ def test_error_message_parsed_correctly(regression_reform_file):
               baseline=regression_reform_file.name,
               reform=regression_reform_file.name,
               assump=None,
-              aging_input_data=False,
               exact_calculations=False)
     assert isinstance(tcio.errmsg, str) and tcio.errmsg
     exp_errmsg = (
-        "AMEDT_rt[year=2021] 1.8 > max 1 \n"
-        "AMEDT_rt[year=2021] 1.8 > max 1 "
+        'AMEDT_rt[year=2021] 1.8 > max 1 \n'
+        'AMEDT_rt[year=2021] 1.8 > max 1 '
     )
     assert tcio.errmsg == exp_errmsg