doczyai-pipelines/fieldExtraction/tests/postprocessing_funcs_test.py

import pytest
import pandas as pd
import numpy as np
from src.postprocessing_funcs import check_add_on
from src.postprocessing_funcs import (
    InvalidDateException,
    yn_fixes,
    convert_to_us_date_format,
    filter_service_column,
    filter_methodology_column,
    clean_td,
    get_parent_agreement_code,
    consolidate_subheader,
    clean_msr_lesser,
    clean_default_term,
    clean_lesser_rate,
    clean_prov_2,
    clean_term_clause,
    clean_auto_renewal_ind,
    clean_npi,
    clean_network_access_fees,
    clean_health_plan_state,
    get_health_plan_state,
    state_check,
    clean_health_plan_state_from_hotfix,
    clean_notice_provider_name_and_address,
    get_tin_from_filename,
    clean_policies_and_procedures,
    clean_tin,
    clean_tin_npi_other,
    filter_add_ons,
    add_scmr,
    add_hyphen_if_needed,
    remove_unnamed_columns,
    format_tin,
    count_dollar_values
)
class TestPostprocessingFuncs:
    @pytest.fixture
    def valid_dates(self):
        return [
            ("2023-12-01", "12/01/2023"),
            ("2023-01-12", "01/12/2023"),
            ("2023-13-01", "01/13/2023"),
        ]
    @pytest.fixture
    def invalid_dates(self):
        return ["2023-13-32", "2023-00-01", "2023-12-00", "2023-12-32", "2023-13-13"]
    @pytest.fixture
    def empty_dates(self):
        return ["", "N/A", "null", "none"]
    @pytest.fixture
    def invalid_format_dates(self):
        return ["2023/12/01", "12-01-2023", "2023.12.01"]
    @pytest.fixture
    def invalid_type_dates(self):
        return [None]
    def test_convert_to_us_date_format(
        self,
        valid_dates,
        invalid_dates,
        empty_dates,
        invalid_format_dates,
        invalid_type_dates,
    ):
        for input_date, expected_output in valid_dates:
            assert convert_to_us_date_format(input_date) == expected_output
        for input_date in invalid_dates:
            with pytest.raises(InvalidDateException):
                convert_to_us_date_format(input_date)
        for input_date in empty_dates:
            with pytest.raises(InvalidDateException):
                convert_to_us_date_format(input_date)
        for input_date in invalid_format_dates:
            with pytest.raises(InvalidDateException):
                convert_to_us_date_format(input_date)
        for input_date in invalid_type_dates:
            with pytest.raises(TypeError):
                convert_to_us_date_format(input_date)
    
    @pytest.fixture
    def sample_answer_dicts(self):
        return [
            {"FULL_SERVICE": "Service Risk", "FULL_METHODOLOGY": "Methodology interest"},
            {"FULL_SERVICE": "Service B", "FULL_METHODOLOGY": "PMPM"},
            {"FULL_SERVICE": "damages", "FULL_METHODOLOGY": "Invalid Methodology"},
        ]
    
    def test_filter_service_column(self, sample_answer_dicts):
        filtered = filter_service_column(sample_answer_dicts)
        assert len(filtered) == 1
        assert all(d["FULL_SERVICE"] == "Service B" for d in filtered)
    def test_filter_methodology_column(self, sample_answer_dicts):
        filtered = filter_methodology_column(sample_answer_dicts)
        assert len(filtered) == 1
        assert all(d["FULL_METHODOLOGY"] == "Invalid Methodology" for d in filtered)
    @pytest.mark.parametrize("input_td, expected_output", [
        (
            {"DATE": "01/01/2023", "Health Plan State": "Chicago", "page_num": 1, "Filename": "file1.txt"},
            {"DATE": ["01/01/2023"], "Health Plan State": ["Chicago"], "page_num": 1, "Filename": "file1.txt"}
        ),
        (
            {"DATE": "01/01/2023", "Health Plan State": ["New York", "Michigan"], "page_num": 1, "Filename": "file1.txt"},
            {"DATE": ["01/01/2023"], "Health Plan State": ["New York", "Michigan"], "page_num": 1, "Filename": "file1.txt"}
        ),
        (
            {"DATE": "N/A", "Health Plan State": "N/A", "page_num": 2, "Filename": "file2.txt"},
            {"DATE": ["N/A"], "Health Plan State": [], "page_num": 2, "Filename": "file2.txt"}
        ),
        (
            {"DATE": "02/01/2023", "Health Plan State": "California, Texas", "page_num": 3, "Filename": "file3.txt"},
            {"DATE": ["02/01/2023"], "Health Plan State": ["California", "Texas"], "page_num": 3, "Filename": "file3.txt"}
        ),
    ])
    def test_clean_td(self, input_td, expected_output):
        cleaned = clean_td([input_td])
        assert cleaned[0] == expected_output
    @pytest.mark.parametrize("filename, expected_code", [
        ("contract_1234(1).txt", "1234"),
        ("contract_5678.txt", "5678"),
        ("invalid_filename.txt", "N/A"),
    ])
    def test_get_parent_agreement_code(self, filename, expected_code):
        code = get_parent_agreement_code(filename)
        assert code == expected_code
    
    @pytest.mark.parametrize("input_dict, expected_output", [
        ({"FULL_SERVICE": "Service A", "SUBHEADER": "Header A"}, {"FULL_SERVICE": "Header A - Service A"}),
        ({"FULL_SERVICE": "Service B", "SUBHEADER": ""}, {"FULL_SERVICE": " - Service B"}),
        ({"FULL_SERVICE": "Service C", "SUBHEADER": "N/A"}, {"FULL_SERVICE": "Service C"}),
    ])
    def test_consolidate_subheader(self, input_dict, expected_output):
        consolidated = consolidate_subheader([input_dict])
        assert consolidated[0] == expected_output
    @pytest.mark.parametrize("input_df, expected_lesser, expected_lesser_rate", [
        (
            pd.DataFrame({
                "FULL_SERVICE": ["Multiple Outpatient", "Multiple Outpatient", "Not multiple"],
                "EXHIBIT": ["Type A", "Type A", "Type B"],
                "LESSER": ["", "Y", "N"],
                "LESSER_RATE": [100, 200, 300]
            }),
            ["Y", "Y", "N"],
            [200, 200, 300]
        ),
        (
            pd.DataFrame({
                "FULL_SERVICE": ["Multiple Outpatient", "Multiple Outpatient", "Not multiple"],
                "EXHIBIT": ["Type A", "Type A", "Type B"],
                "LESSER": ["Y", "Y", "N"],
                "LESSER_RATE": [100, 200, 300]
            }),
            ["Y", "Y", "N"],
            [100, 100, 300]
        ),
    ])
    def test_clean_msr_lesser(self, input_df, expected_lesser, expected_lesser_rate):
        cleaned_df = clean_msr_lesser(input_df)
        assert cleaned_df["LESSER"].tolist() == expected_lesser
        assert cleaned_df["LESSER_RATE"].tolist() == expected_lesser_rate
    @pytest.mark.parametrize("input_df, expected_df", [
        (
            pd.DataFrame({
                "DEFAULT_TERM": ["Except as otherwise provided"],
                "DEFAULT_RATE": ["Invalid"],
                "IP_OP": ["IP"]
            }),
            pd.DataFrame({
                "DEFAULT_TERM": ["N/A"],
                "DEFAULT_RATE": ["N/A"],
                "IP_OP": ["IP"]
            })
        ),
        (
            pd.DataFrame({
                "DEFAULT_TERM": ["Medicare Outpatient", "Medicaid Inpatient", "Invalid"],
                "DEFAULT_RATE": ["AC", "BC", "Amount Payable by Medicaid:NA"],
                "IP_OP": ["IP", "OP", "IP"]
            }),
            pd.DataFrame({
                "DEFAULT_TERM": ["N/A", "N/A", "Invalid"],
                "DEFAULT_RATE": ["N/A", "N/A", "Amount Payable by MCD:NA"],
                "IP_OP": ["IP", "OP", "IP"]
            })
        ),
    ])
    def test_clean_default_term(self, input_df, expected_df):
        cleaned_df = clean_default_term(input_df)
        pd.testing.assert_frame_equal(cleaned_df, expected_df)
    @pytest.mark.parametrize("input_df, expected_output", [
        (
            pd.DataFrame({
                "LESSER_RATE": [np.nan, "200", "300"],
                "RATE_STANDARD": ["150", "250", "350"],
                "LESSER": ["Y", "Y", "N"]
            }),
            pd.DataFrame({
                "LESSER_RATE": ["150", "200", "300"],
                "RATE_STANDARD": ["N/A", "250", "350"],
                "LESSER": ["Y", "Y", "N"]
            })
        )
    ])
    def test_clean_lesser_rate(self, input_df, expected_output):
        cleaned_df = clean_lesser_rate(input_df)
        pd.testing.assert_frame_equal(cleaned_df, expected_output)
    
    @pytest.mark.parametrize("input_df, expected_output", [
        (
            pd.DataFrame({
                "PROV_TYPE_LEVEL_2": ["", "Type A", "Type B"],
                "FULL_SERVICE": ["Specialist", "ASC", "Invalid Service - Skilled Nursing Facility"],
                "EXHIBIT": ["Exhibit A", "Exhibit B", "Exhibit C"],
                "PROV_TYPE": ["Professional", "Ancilliary","Invalid"]
            }),
            ["Specialist", "ASC", "Skilled Nursing Facility"],
        ),
        (
            pd.DataFrame({
                "PROV_TYPE_LEVEL_2": [""],
                "FULL_SERVICE": [""],
                "EXHIBIT": ["This has keyword, Primary Care Provider"],
                "PROV_TYPE": ["Invalid"]
            }),
            ["Primary Care Provider"],
        ),
        (
            pd.DataFrame({
                "PROV_TYPE_LEVEL_2": ["", "Lab","",""],
                "FULL_SERVICE": ["", "ASC","","Hospital"],
                "EXHIBIT": ["Invalid", "Invalid","Invalid2","Invalid2"],
                "PROV_TYPE": ["", "Ancilliary","","Facility"]
            }),
            ["Lab", "ASC", "Hospital", "Hospital"],
        )
    ])
    def test_clean_prov_2(self, input_df, expected_output):
        cleaned_df = clean_prov_2(input_df)
        cleaned_df['PROV_TYPE_LEVEL_2'].tolist() == expected_output
    @pytest.mark.parametrize("input_df, expected_output", [
        (
            pd.DataFrame({
                "TERM_CLAUSE": ["IL-4 Termination", "bonus payment shall be effective", "No term or termination", "does not contain", "valid term clause"]
            }),
            pd.DataFrame({
                "TERM_CLAUSE": ["N/A", "N/A", "N/A", "N/A", "valid term clause"]
            })
        )
    ])
    def test_clean_term_clause(self, input_df, expected_output):
        cleaned_df = clean_term_clause(input_df)
        pd.testing.assert_frame_equal(cleaned_df, expected_output)
    @pytest.mark.parametrize("input_df, column, expected_output", [
        (
            pd.DataFrame({
                "TERM_CLAUSE": ["Contract automatically renews", "coterminous with the agreement", "N/A", " "],
                "CONTRACT_AUTO_RENEWAL_IND": ["N", "N", "N", "N"]}),
            "CONTRACT_AUTO_RENEWAL_IND",
            ["Y", "Y", "N", "N"]
        ),
        (
            pd.DataFrame({
                "TERM_CLAUSE": ["N/A", ""],
                "CONTRACT_TERMINATION_DT": ["Y", "Y"]}),
            "CONTRACT_TERMINATION_DT",
            [np.nan, np.nan]
        ),
        (
            pd.DataFrame({
                "CONTRACT_AUTO_RENEWAL_IND": ["Yes", "Y", "N"],
                "CONTRACT_TERMINATION_DT": ["", "N/A", "12/31/2022"],
            }),
            "CONTRACT_TERMINATION_DT",
            [np.nan, np.nan, "12/31/2022"]
        ),
        (
            pd.DataFrame({
                "CONTRACT_AUTO_RENEWAL_IND": ["Y",""],
            }),
            "CONTRACT_AUTO_RENEWAL_IND",
            ["Y", "N"]
        ),
        (
            pd.DataFrame({
                "Contract Name": ["1234_contract.txt"]}),
            "CONTRACT_AUTO_RENEWAL_IND",
            ["N"]
        )
    ])
    def test_clean_auto_renewal_ind(self, input_df, column, expected_output):
        cleaned_df = clean_auto_renewal_ind(input_df)
        assert cleaned_df[column].tolist() == expected_output
    @pytest.mark.parametrize("input_df, expected_npi", [
        (
            pd.DataFrame({"PROV_GROUP_NPI": ["1234567890", "123", "N/A"]}),
            ["1234567890", "N/A - (model detected: 123)", "N/A"]
        )
    ])
    def test_clean_npi(self, input_df, expected_npi):
        cleaned_df = clean_npi(input_df)
        assert cleaned_df["PROV_GROUP_NPI"].tolist() == expected_npi
    @pytest.mark.parametrize("input_df, expected_output", [
        (
            pd.DataFrame({
                "NETWORK_ACCESS_FEES_IND": ["Yes", "N/A", np.nan, None, "nan","Test", "No"]
            }),
            ["Yes", "N/A", np.nan, None, "nan", "Yes", "Yes"]
        )
    ])
    def test_clean_network_access_fees(self, input_df, expected_output):
        cleaned_df = clean_network_access_fees(input_df)
        assert cleaned_df["NETWORK_ACCESS_FEES_IND"].tolist() == expected_output
    @pytest.mark.parametrize("input_df, expected_state", [
        (pd.DataFrame({"HEALTH_PLAN_STATE": ["IL", "TX", "CA"],
                       "PAYER_NAME":["Illinios Payer","",""]}), ["Illinois","Texas","California"]),
        (pd.DataFrame({"HEALTH_PLAN_STATE": ["TX", "TX", "CA"]}), ["Texas","Texas","California"]),
        (pd.DataFrame({"HEALTH_PLAN_STATE": ["CA", "TX", "CA"]}), ["California","Texas","California"]),
    ])
    def test_clean_health_plan_state(self, input_df, expected_state):
        cleaned_df = clean_health_plan_state(input_df)
        assert cleaned_df["HEALTH_PLAN_STATE"].tolist() == expected_state
    @pytest.mark.parametrize("text_dict, expected_state", [
        ({"page1": "This contract is for Illinois and Texas."}, "Multiple"),
        ({"page1": "This contract is for IL."}, "Illinois"),
        ({"page1": "This contract is for TX and Texas."}, "Texas"),
        ({"page1": "This contract is for California."}, "California"),
        ({"page1": "This contract is for New York."}, "New York"),
        ({"page1": "This contract is for Illinois, Texas, and California."}, "Multiple"),
        ({"page1": "This contract is for Illinois and California."}, "Multiple"),
        ({"page1": "This contract is for Texas and New York."}, "Multiple"),
        ({"page1": "This contract is for."}, "N/A"),
        ({"page1": ""}, "N/A"),
    ])
    def test_get_health_plan_state(self, text_dict, expected_state):
        state = get_health_plan_state(text_dict)
        assert state == expected_state
    @pytest.mark.parametrize("state_abbr, text_dict, expected_state", [
        ("IL", {"page1": "This contract is for Illinois and Texas."}, "Illinois"),
        ("TX", {"page1": "This contract is for Illinois and Texas."}, "Texas"),
        ("CA", {"page1": "This contract is for California."}, "California"),
        ("NY", {"page1": "This contract is for New York."}, "New York"),
        ("FL", {"page1": "This contract is for Hlorida."}, "Florida"),
        ("", {"page1": "This contract is for Illinois and Texas."}, "Multiple"),
    ])
    def test_state_check(self, state_abbr, text_dict, expected_state):
        state = state_check(state_abbr, text_dict)
        assert state == expected_state
    
    @pytest.mark.parametrize("input_df, contract_name, text_dict, expected_state", [
        (
            pd.DataFrame({"HEALTH_PLAN_STATE": [["IL", "TX", "CA"]]}),
            "contract_1234_v1.txt",
            {"page1": "This is a sample contract contract"},
            "Multiple"
        ),
        (
            pd.DataFrame({"HEALTH_PLAN_STATE": ["IL,"]}),
            "contract_1234_v1.txt",
            {"page1": "This is a sample contract"},
            "Illinois"
        ),
        (
            pd.DataFrame({"HEALTH_PLAN_STATE": [""]}),
            "contract_1234_v1.txt",
            {"page1": "This contract is for Illinois and Texas."},
            "Multiple"
        )
    ])
    def test_clean_health_plan_state_from_hotfix(self, input_df, contract_name, text_dict, expected_state):
        input_df["HEALTH_PLAN_STATE"] = input_df["HEALTH_PLAN_STATE"].apply(
            lambda x: f"[{','.join(x)}]" if isinstance(x, list) else x
        )
        cleaned_df = clean_health_plan_state_from_hotfix(input_df, contract_name, text_dict)
        assert cleaned_df.loc[0, "HEALTH_PLAN_STATE"] == expected_state
    @pytest.mark.parametrize("input_df, expected_name, expected_address", [
        (
            pd.DataFrame({
                "NOTICE_PROVIDER_NAME": ["Superior HealthPlan", "Provider A", "Provider B"],
                "NOTICE_PROVIDER_ADDRESS": ["Address A", "Address B", "Address C"]
            }),
            [np.nan, "Provider A", "Provider B"],
            [np.nan, "Address B", "Address C"]
        ),
    ])
    def test_clean_notice_provider_name_and_address(self, input_df, expected_name, expected_address):
        cleaned_df = clean_notice_provider_name_and_address(input_df)
        assert cleaned_df["NOTICE_PROVIDER_NAME"].tolist() == expected_name
        assert cleaned_df["NOTICE_PROVIDER_ADDRESS"].tolist() == expected_address
    
    @pytest.mark.parametrize("input_df, expected_tin", [
        (pd.DataFrame({"Contract Name":["12-3456789_contract(1)", "12-3456789_contract(2)"],
                      "PROV_GROUP_TIN": ["", "123456789"]}
                    ), ["123456789", "123456789"]
        ),
    ])
    def test_get_tin_from_filename(self, input_df, expected_tin):
        cleaned_df = get_tin_from_filename(input_df)
        assert cleaned_df["PROV_GROUP_TIN"].tolist() == expected_tin
    @pytest.mark.parametrize("input_df, expected_output", [
        (
            pd.DataFrame({
                "POLICIES_AND_PROCEDURES": ["Policy A", "Procedure B", "Invalid", ""]
            }),
            pd.DataFrame({
                "POLICIES_AND_PROCEDURES": ["Policy A", "Procedure B", "N/A", "N/A"]
            })
        ),
    ])
    def test_clean_policies_and_procedures(self, input_df, expected_output):
        cleaned_df = clean_policies_and_procedures(input_df)
        pd.testing.assert_frame_equal(cleaned_df, expected_output)
    @pytest.mark.parametrize("input_df, expected_tin", [
        (pd.DataFrame({"PROV_GROUP_TIN": ["123-45-6789"]}), "N/A"),
        (pd.DataFrame({"PROV_GROUP_TIN": ["12-34-56"]}), "N/A - (model detected: 12-34-56)"),
        (pd.DataFrame({"PROV_GROUP_TIN": ["12-3456789"]}), "12-3456789"),        
        (pd.DataFrame({"PROV_GROUP_TIN": ["N/A"]}), "N/A"),
    ])
    def test_clean_tin(self, input_df, expected_tin):
        cleaned_df = clean_tin(input_df)
        assert cleaned_df.loc[0, "PROV_GROUP_TIN"] == expected_tin
    @pytest.mark.parametrize("input_df, column, expected_tin", [
        (pd.DataFrame({"PROV_TIN_OTHER": [["123456789", "123456789"], "N/A"]}), "PROV_TIN_OTHER", ["123456789,123456789","N/A"]),
        (pd.DataFrame({"PROV_NPI_OTHER": ["12-3456789"]}), "PROV_NPI_OTHER", ["12-3456789"]),
        (pd.DataFrame({"PROV_TIN_OTHER": [""]}), "PROV_TIN_OTHER", [""]),
        (pd.DataFrame({"PROV_NPI_OTHER": [""]}), "PROV_NPI_OTHER", [""]),
    ])
    
    def test_clean_tin_npi_other(self, input_df, column, expected_tin):
        input_df[column] = input_df[column].apply(lambda x: f"[{','.join(x)}]" if isinstance(x, list) else x)
        cleaned_df = clean_tin_npi_other(input_df)
        assert cleaned_df[column].tolist() == expected_tin
    @pytest.mark.parametrize("input_df, expected_output", [
        (
            pd.DataFrame({
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["in no event", "forward", "Valid"],
                "ADD_ON_REIMBURSEMENT_IND": ["Y", "N", "Y"],
                "FULL_SERVICE": ["Add-on service", "No add-on", "Valid service"],
                "Contract Name": ["Contract A", "Contract A", "Contract B"],
                "EXHIBIT": ["Exhibit 1", "Exhibit 1", "Exhibit 2"]
            }),
            pd.DataFrame({
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["N/A", "N/A", "Valid"],
                "ADD_ON_REIMBURSEMENT_IND": ["N", "N", "Y"],
                "FULL_SERVICE": ["Add-on service", "No add-on", "Valid service"],
                "Contract Name": ["Contract A", "Contract A", "Contract B"],
                "EXHIBIT": ["Exhibit 1", "Exhibit 1", "Exhibit 2"]
            })
        ),
        (
            pd.DataFrame({
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["", "additional fees", "N/A"],
                "ADD_ON_REIMBURSEMENT_IND": ["Y", "Y", "N"],
                "FULL_SERVICE": ["No add-on", "Add On service", "N/A"],
                "Filename": ["File1", "File1", "File2"],
                "EXHIBIT": ["Exhibit 1", "Exhibit 1", "Exhibit 2"]
            }),
            pd.DataFrame({
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["N/A", "N/A", "N/A"],
                "ADD_ON_REIMBURSEMENT_IND": ["N", "N", "N"],
                "FULL_SERVICE": ["No add-on", "Add On service", "N/A"],
                "Filename": ["File1", "File1", "File2"],
                "EXHIBIT": ["Exhibit 1", "Exhibit 1", "Exhibit 2"]
            })
        )
    ])
    
    @pytest.mark.filterwarnings("ignore::UserWarning")
    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
    def test_filter_add_ons(self, input_df, expected_output):
        # Call the function and reset the index
        cleaned_df = filter_add_ons(input_df).reset_index(drop=True)
        
        # Assert that the cleaned DataFrame matches the expected output
        pd.testing.assert_frame_equal(cleaned_df, expected_output)
        
    @pytest.mark.parametrize("input_df, expected_df", [
        (pd.DataFrame({"FLAT_FEE_STANDARD": ["$100", "$200 30%", "$400"]}),
        pd.DataFrame({
            "Single Code Multiple Rates (Language)": ["N/A", "$200 30%", "N/A"],
            "Single Code Multiple Rates (Y/N)": ["N", "Y", "N"]
        }))
    ])
    
    def test_add_scmr(self, input_df, expected_df):
        cleaned_df = add_scmr(input_df)
        
        pd.testing.assert_series_equal(
        cleaned_df["Single Code Multiple Rates (Language)"],
        expected_df["Single Code Multiple Rates (Language)"],
        )
        pd.testing.assert_series_equal(
            cleaned_df["Single Code Multiple Rates (Y/N)"],
            expected_df["Single Code Multiple Rates (Y/N)"],
        )
    @pytest.mark.parametrize("input_df, expected_df", [
        (
            pd.DataFrame({
                "DUMMY_COL(Y/N)": ["Yes", "No", ""],
                "SINGLE_CODE_MULTIPLE_RATES_IND": ["Y", "N", "Y"],
                "SINGLE_CODE_MULTIPLE_RATES_LANGUAGE": ["Language 1", "Language 2", "N/A"],
                "RATE_ESCALATOR_IND": ["Y", "N", "N"],
                "RATE_ESCALATOR_DT": ["12/1/2022", "12/11/2022", "01/05/2018"],
            }),
            pd.DataFrame({
                "DUMMY_COL(Y/N)": ["Y", "N", "N"],
                "SINGLE_CODE_MULTIPLE_RATES_IND": ["Y", "N", "Y"],
                "SINGLE_CODE_MULTIPLE_RATES_LANGUAGE": ["Language 1", "", "N/A"],
                "RATE_ESCALATOR_IND": ["Y", "N", "N"],
                "RATE_ESCALATOR_DT": ["12/1/2022", "", ""],
            })
        ),
        
    ])
    def test_yn_fixes(self, input_df, expected_df):
        cleaned_df = yn_fixes(input_df)
        pd.testing.assert_frame_equal(cleaned_df, expected_df)
        
    @pytest.mark.parametrize("input_tin, expected_output", [
        ("12345678", "01-2345678"),
        ("123456789", "12-3456789"),
        ("1-2345678", "01-2345678"),
        ("123-45", None),
        ("", None),
    ])
    
    def test_add_hyphen_if_needed(self, input_tin, expected_output):
        assert add_hyphen_if_needed(input_tin) == expected_output
    @pytest.mark.parametrize("input_date, expected_output", [
        ("2023-12-31", "12/31/2023"),
        ("2023-01-12", "01/12/2023"),
    ])
    def test_convert_to_us_date_format_valid(self, input_date, expected_output):
        assert convert_to_us_date_format(input_date) == expected_output
    @pytest.mark.parametrize("input_date", [
        "N/A",
        "2023-13-32",
        "2023-00-01",
        "2023-12-00",
        "2023-12-32",
        "2023-13-13",
        "",
        "null",
        "none",
        "2023/12/01",
        "12-01-2023",
        "2023.12.01",
        None,
    ])
    def test_convert_to_us_date_format_invalid(self, input_date):
        with pytest.raises((InvalidDateException, TypeError)):
            convert_to_us_date_format(input_date)
    @pytest.mark.parametrize("input_df, expected_columns", [
        (pd.DataFrame({"Unnamed: 0": [1, 2], "A": [3, 4]}), ["A"]),
        (pd.DataFrame({"Unnamed: 0": [1, 2], "Unnamed: 1": [3, 4], "B": [5, 6]}), ["B"]),
        (pd.DataFrame({"A": [1, 2], "B": [3, 4]}), ["A", "B"]),
    ])
    def test_remove_unnamed_columns(self, input_df, expected_columns):
        cleaned_df = remove_unnamed_columns(input_df)
        assert list(cleaned_df.columns) == expected_columns
    @pytest.mark.parametrize("input_tin, expected_output", [
        ("123456789", "12-3456789"),
        ("12-3456789", "12-3456789"),
        ("123-45-6789", "12-3456789"),
        ("N/A", "N/A"),
        ("invalidTIN", "N/A - (model detected: invalidTIN)"),
        ("", "N/A - (model detected: )"),
    ])
    def test_format_tin(self, input_tin, expected_output):
        assert format_tin(input_tin) == expected_output
    @pytest.mark.parametrize("input_str, expected_count", [
        ("$100", 1),
        ("100%", 1),
        ("$100 and 50%", 2),
        ("No dollar or percentage signs", 0),
        ("$$$ and %%%", 6),
        ("$100 $200 $300", 3),
        ("100% 200% 300%", 3),
        ("", 0),
        ("$%$%", 4),
    ])
    def test_count_dollar_values(self, input_str, expected_count):
        assert count_dollar_values(input_str) == expected_count
        
    @pytest.mark.parametrize("input_df, expected_df", [
        (
            pd.DataFrame({
                "FULL_SERVICE": ["Add-on Service", "Add-on Service"],
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["Language A", "Language B"],
                "ADD_ON_REIMBURSEMENT_IND": ["Y", "Y"]
            }),
            pd.DataFrame({
                "FULL_SERVICE": ["Add-on Service", "Add-on Service"],
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["N/A", "N/A"],
                "ADD_ON_REIMBURSEMENT_IND": ["N", "N"]
            })
        ),
        (
            pd.DataFrame({
                "FULL_SERVICE": ["Add On Service", "Add On Service"],
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["Language A", "Language B"],
                "ADD_ON_REIMBURSEMENT_IND": ["Y", "Y"]
            }),
            pd.DataFrame({
                "FULL_SERVICE": ["Add On Service", "Add On Service"],
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["N/A", "N/A"],
                "ADD_ON_REIMBURSEMENT_IND": ["N", "N"]
            })
        ),
        (
            pd.DataFrame({
                "FULL_SERVICE": ["Regular Service", "Regular Service"],
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["Language A", "Language B"],
                "ADD_ON_REIMBURSEMENT_IND": ["Y", "Y"]
            }),
            pd.DataFrame({
                "FULL_SERVICE": ["Regular Service", "Regular Service"],
                "ADD_ON_REIMBURSEMENT_LANGUAGE": ["Language A", "Language B"],
                "ADD_ON_REIMBURSEMENT_IND": ["Y", "Y"]
            })
        )
    ])
    def test_check_add_on(self, input_df, expected_df):
        cleaned_df = check_add_on(input_df)
        pd.testing.assert_frame_equal(cleaned_df, expected_df)