def test_select_date_ranges_claim_belongs_to():
"""Test that _select_date_ranges_claim_belongs_to returns the correct indexes."""
date_ranges = [(datetime.date(2017, 1, 1), datetime.date(2017, 3, 31)),
(datetime.date(2017, 10, 1), datetime.date(2017, 12, 31))]
claim_none = claim.Claim({
'bene_sk': '1001',
'clm_from_dt': datetime.date(2017, 4, 1),
'clm_thru_dt': datetime.date(2017, 4, 1),
})
claim_first_only = claim.Claim({
'bene_sk': '1001',
'clm_from_dt': datetime.date(2017, 1, 1),
'clm_thru_dt': datetime.date(2017, 1, 1),
})
claim_second_only = claim.Claim({
'bene_sk': '2001',
'clm_from_dt': datetime.date(2017, 12, 31),
'clm_thru_dt': datetime.date(2017, 12, 31),
})
claim_both = claim.Claim({
'bene_sk': '1001',
'clm_from_dt': datetime.date(2017, 1, 1),
'clm_thru_dt': datetime.date(2017, 12, 31),
})
assert PatientPeriodicMeasure._select_date_ranges_claim_belongs_to(
claim_none, date_ranges) == []
assert PatientPeriodicMeasure._select_date_ranges_claim_belongs_to(
claim_first_only, date_ranges) == [0]
assert PatientPeriodicMeasure._select_date_ranges_claim_belongs_to(
claim_second_only, date_ranges) == [1]
assert PatientPeriodicMeasure._select_date_ranges_claim_belongs_to(
claim_both, date_ranges) == [0, 1]
def test_does_claim_meet_additional_procedure_criteria():
""""Check that the eligibility option correctly filters by additional diagnosis codes."""
measure_code = MeasureCode({
'code': 'code'
})
additional_measure_code = MeasureCode({
'code': 'additional_code'
})
option = EligibilityOption({
'procedureCodes': [measure_code],
'additionalProcedureCodes': [additional_measure_code]
})
claim_measure_code_only = claim.Claim({
'claim_lines': [claim_line.ClaimLine({'clm_line_hcpcs_cd': 'code'})]
})
claim_additional_code_only = claim.Claim({
'claim_lines': [claim_line.ClaimLine({'clm_line_hcpcs_cd': 'additional_code'})]
})
claim_both_codes = claim.Claim({
'claim_lines': [
claim_line.ClaimLine({'clm_line_hcpcs_cd': 'code'}),
claim_line.ClaimLine({'clm_line_hcpcs_cd': 'additional_code'})]
})
assert option._does_claim_meet_additional_procedure_criteria(claim_additional_code_only)
assert option._does_claim_meet_additional_procedure_criteria(claim_both_codes)
assert not (option._does_claim_meet_additional_procedure_criteria(claim_measure_code_only))
def setup(self):
"""Initialization of measure 155."""
self.measure = measure_mapping.get_measure_calculator('155')
self.claim_meets_prefilter_and_filter = claim.Claim({
'bene_sk':
'elderly_patient_id',
'clm_ptnt_birth_dt':
date(1920, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [
claim_line.ClaimLine({'clm_line_hcpcs_cd': '1100F'},
{'mdfr_cds': []}),
claim_line.ClaimLine({'clm_line_hcpcs_cd': '92541'}, )
]
})
self.claim_meets_prefilter_but_not_filter = claim.Claim({
'bene_sk':
'elderly_patient_id',
'clm_ptnt_birth_dt':
date(1920, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [
claim_line.ClaimLine({'clm_line_hcpcs_cd': '1100F'},
{'mdfr_cds': []})
]
})
self.claim_does_not_meet_prefilter_1 = claim.Claim({
'bene_sk':
'elderly_patient_id',
'clm_ptnt_birth_dt':
date(1920, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [
claim_line.ClaimLine(
{'clm_line_hcpcs_cd': '1100F'},
{'mdfr_cds': ['1P']},
),
claim_line.ClaimLine({'clm_line_hcpcs_cd': '92541'}, )
]
})
self.claim_does_not_meet_prefilter_2 = claim.Claim({
'bene_sk':
'elderly_patient_id',
'clm_ptnt_birth_dt':
date(1920, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines':
[claim_line.ClaimLine({'clm_line_hcpcs_cd': '92541'}, )]
})
self.claims = [
self.claim_meets_prefilter_and_filter,
self.claim_meets_prefilter_but_not_filter,
self.claim_does_not_meet_prefilter_1,
self.claim_does_not_meet_prefilter_2,
]
def test_does_claim_meet_age_criteria():
""""Check that the eligibility option can determine what claims match its age criteria."""
# This patient is 75.5 years old and should be counted.
matching_claim = claim.Claim({
'clm_ptnt_birth_dt': datetime.date(1942, 1, 1),
'clm_from_dt': datetime.date(2017, 7, 1)
})
# This patient is 76.5 years old.
claim_too_old = claim.Claim({
'clm_ptnt_birth_dt': datetime.date(1941, 1, 1),
'clm_from_dt': datetime.date(2017, 7, 1)
})
# This patient is 64.5 years old.
claim_too_young = claim.Claim({
'clm_ptnt_birth_dt': datetime.date(1953, 1, 1),
'clm_from_dt': datetime.date(2017, 7, 1)
})
eligibility_option = EligibilityOption({
'minAge': 65,
'maxAge': 75
})
assert (eligibility_option._does_claim_meet_age_criteria(matching_claim))
assert not (eligibility_option._does_claim_meet_age_criteria(claim_too_old))
assert not (eligibility_option._does_claim_meet_age_criteria(claim_too_young))
def test_does_claim_meet_age_criteria_fractional_boundaries():
""""Check that the eligibility option can determine what claims match its age criteria."""
# This patient is 0.5 years old (exactly).
matching_claim = claim.Claim({
'clm_ptnt_birth_dt': datetime.date(2017, 1, 1),
'clm_from_dt': datetime.date(2017, 7, 1)
})
# This patient is 1.51 years old.
claim_too_old = claim.Claim({
'clm_ptnt_birth_dt': datetime.date(2015, 12, 31),
'clm_from_dt': datetime.date(2017, 7, 1)
})
# This patient is 0.41 years old.
claim_too_young = claim.Claim({
'clm_ptnt_birth_dt': datetime.date(2017, 2, 1),
'clm_from_dt': datetime.date(2017, 7, 1)
})
eligibility_option = EligibilityOption({
'minAge': 0.5,
'maxAge': 1.5
})
assert (eligibility_option._does_claim_meet_age_criteria(matching_claim))
assert not (eligibility_option._does_claim_meet_age_criteria(claim_too_old))
assert not (eligibility_option._does_claim_meet_age_criteria(claim_too_young))
def test_filter_instances_by_multiple_encounters():
"""Test that instances with enough encounters are returned (without the initial encounter)."""
bene_2_claim_1 = claim.Claim({
'bene_sk': 'bene_2',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_2_claim_2 = claim.Claim({
'bene_sk': 'bene_2',
'clm_from_dt': datetime.date(2017, 6, 1),
})
bene_3_claim_1 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_3_claim_2 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 3, 1),
})
bene_3_claim_3 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 12, 1),
})
instances = [
[bene_2_claim_1] * 2 + [bene_2_claim_2],
[bene_3_claim_1, bene_3_claim_2, bene_3_claim_3],
]
expected = [[bene_2_claim_2], [bene_3_claim_2, bene_3_claim_3]]
output = MultipleEncounterMeasure._filter_instances_by_multiple_encounters(
instances=instances, minimum_number_of_encounters=2)
assert output == expected
def test_filter_instances_by_multiple_encounters_one_encounter():
"""
Test that instances with insufficiently many encounters are not returned.
If two claims occur on the same date of service, they should count as the same encounter.
"""
bene_1_claim_1 = claim.Claim({
'bene_sk': 'bene_1',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_4_claim_1 = claim.Claim({
'bene_sk': 'bene_4',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_4_claim_2 = claim.Claim({
'bene_sk': 'bene_4',
'clm_from_dt': datetime.date(2017, 1, 1),
})
instances = [
[bene_1_claim_1],
[bene_4_claim_1, bene_4_claim_2],
]
expected = []
output = MultipleEncounterMeasure._filter_instances_by_multiple_encounters(
instances=instances, minimum_number_of_encounters=2)
assert output == expected
def test_get_claims_from_latest_date():
"""Test get_most_recent_claim method."""
oldest_claim = claim.Claim({'clm_from_dt': datetime.date(2017, 1, 1)})
newest_claim = claim.Claim({'clm_from_dt': datetime.date(2017, 2, 1)})
claims = [oldest_claim, newest_claim]
output = PatientIntermediateMeasure.get_claims_from_latest_date(claims)
expected = [newest_claim]
assert output == expected
def test_get_earliest_claims():
"""Test get_most_recent_claim method."""
oldest_claim = claim.Claim({'clm_from_dt': datetime.date(2017, 1, 1)})
newest_claim = claim.Claim({'clm_from_dt': datetime.date(2017, 2, 1)})
claims = [oldest_claim, newest_claim]
output = DateWindowEOCMeasure.get_claims_from_earliest_date(claims)
expected = [oldest_claim]
assert output == expected
def test_get_most_advantageous_claim(self):
"""Test of get_most_advantageous_claim."""
best_claim = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_code'}]})
other_claim = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_x_code'}]})
test_claims = [best_claim, other_claim]
output = self.measure.get_most_advantageous_claim(test_claims)
expected = (best_claim, 'performanceMet')
assert output == expected
def test_group_claims_splits_claims_correctly(self):
"""The _regroup method shouldn't group claims with diagnosis codes in common."""
claim_one = claim.Claim({'dx_codes': ['dx_code_a']})
claim_two = claim.Claim({'dx_codes': ['dx_code_b']})
claims = [claim_one, claim_two]
output = list(self.measure.group_claims_by_common_diagnosis(claims))
expected = [[claim_one], [claim_two]]
assert output == expected
def test_get_most_advantageous_claim_no_performance(self):
"""Test of get_most_advantageous_claim if it's None."""
claim_a = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'not_a_quality_code_a'}]})
claim_b = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'not_a_quality_code_b'}]})
test_claims = [claim_a, claim_b]
output = self.measure.get_most_advantageous_claim(test_claims)
expected = (claim_a, None)
# If no claim with a quality code exists, the function should just return the first claim.
assert output == expected
def test_group_claims_groups_claims_correctly(self):
"""The _regroup method should group claims with common diagnosis codes."""
claim_one = claim.Claim({'dx_codes': ['dx_code_a']})
claim_two = claim.Claim({'dx_codes': ['dx_code_a', 'dx_code_b']})
claim_three = claim.Claim({'dx_codes': ['dx_code_b']})
claims = [claim_one, claim_two, claim_three]
output = list(self.measure.group_claims_by_common_diagnosis(claims))
expected = [[claim_one, claim_two, claim_three]]
assert output == expected
def test_get_most_advantageous_claim_inverse_measure(self):
"""Test of get_most_advantageous_claim with an inverse measure."""
worst_claim = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_code'}]})
okay_claim = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pd_x_code'}]})
best_claim = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_x_code'}]})
irrelevant_claim = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'random_code'}]})
test_claims = [best_claim, worst_claim, okay_claim, irrelevant_claim]
output = self.inverse_measure.get_most_advantageous_claim(test_claims)
expected = (best_claim, 'performanceNotMet')
assert output == expected
def test_does_claim_meet_sex_criteria():
""""Check that the eligibility option can determine what claims match its sex criteria."""
matching_claim = claim.Claim({'clm_bene_sex_cd': '1'})
non_matching_claim = claim.Claim({'clm_bene_sex_cd': '2'})
null_claim = claim.Claim()
eligibility_option = EligibilityOption({
'sexCode': 'M'
})
assert (eligibility_option._does_claim_meet_sex_criteria(matching_claim))
assert not (eligibility_option._does_claim_meet_sex_criteria(non_matching_claim))
assert not (eligibility_option._does_claim_meet_sex_criteria(null_claim))
def test_claims_have_quality_codes_false(self):
"""Test do_claims_have_quality_codes return False if there are none."""
test_claims_with_no_quality_codes = [
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'G9607'}]}),
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'G9607'}]}),
claim.Claim({'claim_lines': [
{'clm_line_hcpcs_cd': 'G9607'},
{'clm_line_hcpcs_cd': 'G9607'}
]}),
]
quality_codes = self.measure_definition.get_measure_quality_codes()
assert not claim_filtering.do_any_claims_have_quality_codes(
test_claims_with_no_quality_codes, quality_codes=quality_codes)
def test_claims_have_quality_codes_true(self):
"""Test do_claims_have_quality_codes if there are matching codes."""
test_claims_with_quality_codes = [
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'G9607'}]}),
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_code'}]}),
claim.Claim({'claim_lines': [
{'clm_line_hcpcs_cd': 'pn_x_code'},
{'clm_line_hcpcs_cd': 'pn_code'}
]}),
]
quality_codes = self.measure_definition.get_measure_quality_codes()
assert claim_filtering.do_any_claims_have_quality_codes(
test_claims_with_quality_codes, quality_codes=quality_codes)
def test_get_most_recent_claim_same_date():
"""Test get_most_recent_claim in the case that two claims have the same date."""
claim_a = claim.Claim({
'splt_clm_id': 'most_advantageous',
'clm_from_dt': datetime.date(2017, 1, 1)
})
claim_b = claim.Claim({
'splt_clm_id': 'least_advantageous',
'clm_from_dt': datetime.date(2017, 1, 1)
})
output = PatientIntermediateMeasure.get_claims_from_latest_date(
[claim_a, claim_b])
expected = [claim_a, claim_b]
assert output == expected
def test_filter_by_valid_dates_with_restrictions():
"""Test that filter by valid dates behaves correctly for measures with date restrictions."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
})
)
measure.date_ranges = [
(datetime.date(2017, 1, 1), datetime.date(2017, 3, 31)),
(datetime.date(2017, 10, 1), datetime.date(2017, 12, 31))
]
claims = [
claim.Claim({
'clm_from_dt': datetime.date(2017, month, 1),
'clm_thru_dt': datetime.date(2017, month, 1),
}) for month in range(1, 13)
]
output = measure.filter_by_valid_dates(claims)
expected = claims[:3] + claims[-3:]
assert output == expected
def test_is_claim_in_date_range_edge_cases():
"""Test that _is_claim_in_date_range returns True when the claim overlaps the date range."""
date_range = (
datetime.date(2017, 6, 1),
datetime.date(2017, 9, 1),
)
claim_overlapping_start_date = claim.Claim({
'clm_from_dt': datetime.date(2017, 5, 30),
'clm_thru_dt': datetime.date(2017, 6, 1),
})
claim_overlapping_end_date = claim.Claim({
'clm_from_dt': datetime.date(2017, 9, 1),
'clm_thru_dt': datetime.date(2017, 9, 10),
})
assert qpp_measure.QPPMeasure._is_claim_in_date_range(claim_overlapping_start_date, date_range)
assert qpp_measure.QPPMeasure._is_claim_in_date_range(claim_overlapping_end_date, date_range)
def test_get_eligible_instances():
"""Test that get_eligible_instances groups by diagnosis code and beneficiary."""
eligibility_options = [
EligibilityOption({
'diagnosisCodes': ['dx_code_a', 'dx_code_b'],
}),
EligibilityOption({
'diagnosisCodes': ['dx_code_c'],
})
]
measure = IntersectingDiagnosisMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': []
}))
claim_one = claim.Claim({
'dx_codes': ['dx_code_a'],
'bene_sk': 1001,
})
claim_two = claim.Claim({
'dx_codes': ['dx_code_a', 'dx_code_b'],
'bene_sk': 1001,
})
claim_three = claim.Claim({
'dx_codes': ['dx_code_c'],
'bene_sk': 1001,
})
claim_four = claim.Claim({
'dx_codes': ['dx_code_a'],
'bene_sk': 2001,
})
claims = [claim_one, claim_two, claim_three, claim_four]
output = measure.get_eligible_instances(claims)
expected = [[claim_one, claim_two], [claim_three], [claim_four]]
for instance in output:
assert instance in expected
for instance in expected:
assert instance in output
assert len(output) == len(expected)
def test_get_eligible_instances():
"""Test that get eligible instances only returns instances with enough encounters."""
bene_1_claim_1 = claim.Claim({
'bene_sk': 'bene_1',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_2_claim_1 = claim.Claim({
'bene_sk': 'bene_2',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_2_claim_2 = claim.Claim({
'bene_sk': 'bene_2',
'clm_from_dt': datetime.date(2017, 6, 1),
})
bene_3_claim_1 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_3_claim_2 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 3, 1),
})
bene_3_claim_3 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 12, 1),
})
bene_4_claim_1 = claim.Claim({
'bene_sk': 'bene_4',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_4_claim_2 = claim.Claim({
'bene_sk': 'bene_4',
'clm_from_dt': datetime.date(2017, 1, 1),
})
claims = [
bene_1_claim_1,
bene_2_claim_1,
bene_2_claim_2,
bene_3_claim_1,
bene_3_claim_2,
bene_3_claim_3,
bene_4_claim_1,
bene_4_claim_2,
]
measure = MultipleEncounterMeasure(measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
}))
output = measure.get_eligible_instances(claims)
expected = [[bene_2_claim_2], [bene_3_claim_2, bene_3_claim_3]]
assert output == expected
def test_group_claims_by_date():
"""Test that group_claims_by_date groups claims into episodes correctly."""
measure = DateWindowEOCMeasure(measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
}))
a1 = claim.Claim({'clm_from_dt': datetime.date(2016, 1, 1)})
a2 = claim.Claim({'clm_from_dt': datetime.date(2016, 1, 10)})
b1 = claim.Claim({'clm_from_dt': datetime.date(2016, 6, 1)})
b2 = claim.Claim({'clm_from_dt': datetime.date(2016, 6, 10)})
c1 = claim.Claim({'clm_from_dt': datetime.date(2016, 12, 1)})
claims = [a1, b1, a2, b2, c1]
output = measure.group_claims_by_date(claims)
expected = [[a1, a2], [b1, b2], [c1]]
assert output == expected
def test_group_claims_by_field_values_with_single_field():
"""Test that claims with the same values are grouped together."""
fields_to_group_by = 'bene_sk'
claim_a = claim.Claim({'bene_sk': 'bene1'})
claim_b = claim.Claim({'bene_sk': 'bene1'})
claim_c = claim.Claim({'bene_sk': 'bene2'})
claims_data = [claim_a, claim_b, claim_c]
output = qpp_measure.QPPMeasure.group_claims_by_field_values(fields_to_group_by, claims_data)
expected = [[claim_a, claim_b], [claim_c]]
# output and expected should be equal, but their internal orders might differ.
# Therefore, we check that each element of output is an element of expected (and vice versa).
for claim_group in output:
assert claim_group in expected
for claim_group in expected:
assert claim_group in output
def test_filter_by_presence_of_quality_codes():
"""Test filter_by_presence_of_quality_codes returns all claims with quality codes."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'pn_code'}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'pn_x_code'}
]
}),
PerformanceOption({
'optionType': 'eligiblePopulationExclusion',
'qualityCodes': [
{'code': 'pd_x_code'}
]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
claim_with_quality_code = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_code'}]})
claim_without_quality_code = claim.Claim(
{'claim_lines': [{'clm_line_hcpcs_cd': 'irrelevant_code'}]}
)
claims = [claim_with_quality_code, claim_without_quality_code]
output = measure.filter_by_presence_of_quality_codes(claims)
expected = [claim_with_quality_code]
assert output == expected
def test_early_exit_during_filtering(procedure_check):
""""Check that the eligibility option filtering exits early when possible."""
claim_failing_sex_filtering = claim.Claim(
{'clm_bene_sex_cd': '1'}
)
eligibility_option = EligibilityOption({
'sexCode': 'F',
'procedureCodes': [MeasureCode({'code': '99201'})],
})
eligibility_option._does_claim_meet_eligibility_option(claim_failing_sex_filtering)
procedure_check.assert_not_called()
def test_pos_not_match(self):
"""Check that claim lines that do not have the require place of service are not returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_place_of_service],
'performance_options': []
})
)
test_claims = [claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == []
def test_procedure_code_not_match(self):
"""Check that claims that do not have the desired encounter code are not returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.plain_eligibility_option],
'performance_options': []
})
)
test_claims = [claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'other_code'}]})]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == []
def _lines_to_claim(self, claim_lines, columns):
"""
Convert set of lines of a claim into a claim model.
TODO: Add null / empty string handling for each of the values in case they don't exist.
"""
# If major header columns are different among the lines being merged, raise an error.
self._assert_split_claims_have_same_header_level_values(
claim_lines, columns)
# Assign claim-level values.
top = claim_lines[0]
tmp_claim = {
new_col: top[columns[old_col]]
for old_col, new_col in self.CLAIM_LEVEL_COLUMNS.items()
}
# Collect diagnosis codes from every line (in case of varying codes across split claims).
tmp_claim['dx_codes'] = list({
code
for row in claim_lines
for code in self._get_dx_code_list(row, columns)
})
# Collect claim start and thru dates accounting for split claims.
# Take the earliest and latest dates if there is more than one claim.
tmp_claim['clm_from_dt'] = min(
[line[columns['clm_from_dt']] for line in claim_lines])
tmp_claim['clm_thru_dt'] = max(
[line[columns['clm_thru_dt']] for line in claim_lines])
# Collect line-level values.
procedure_codes = {}
tmp_claim['claim_lines'] = []
for claim_line in claim_lines:
line = {
new_col: claim_line[columns[old_col]]
for old_col, new_col in self.LINE_LEVEL_COLUMNS.items()
}
line['mdfr_cds'] = [
claim_line[columns[col]] for col in self.MODIFIER_CODE_COLUMNS
if claim_line[columns[col]]
]
procedure_codes[line['clm_line_hcpcs_cd']] = True
tmp_claim['claim_lines'].append(line)
tmp_claim['aggregated_procedure_codes'] = procedure_codes
return claim.Claim(tmp_claim)
def test_is_claim_in_date_range_simple_cases():
"""Test that _is_claim_in_date_range returns True when expected."""
date_range = (
datetime.date(2017, 6, 1),
datetime.date(2017, 9, 1),
)
claim_too_early = claim.Claim({
'clm_from_dt': datetime.date(2016, 1, 1),
'clm_thru_dt': datetime.date(2016, 1, 1),
})
claim_too_late = claim.Claim({
'clm_from_dt': datetime.date(2017, 12, 30),
'clm_thru_dt': datetime.date(2017, 12, 30),
})
claim_just_right = claim.Claim({
'clm_from_dt': datetime.date(2017, 7, 1),
'clm_thru_dt': datetime.date(2017, 7, 1),
})
assert not qpp_measure.QPPMeasure._is_claim_in_date_range(claim_too_early, date_range)
assert not qpp_measure.QPPMeasure._is_claim_in_date_range(claim_too_late, date_range)
assert qpp_measure.QPPMeasure._is_claim_in_date_range(claim_just_right, date_range)
