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_str():
"""Test that QPPMeasure objects can be represented as strings."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'measure_number': '314159265',
'eligibility_options': [],
'performance_options': []
})
)
assert measure.__str__() == '(Measure 314159265)'
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 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_additional_dx_code_no_prerequisites(self):
"""Check the case where a claim lacks a required dx_code, but has additional ones."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_additional_dx_codes],
'performance_options': []
})
)
test_claim = claim.Claim({
'dx_codes': ['dx_code_2'], 'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
output = measure.filter_by_eligibility_criteria([test_claim])
assert output == []
def test_additional_dx_code_no_match(self):
"""Check the case where a measure has an additional diag code and the claim lacks it."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_additional_dx_codes],
'performance_options': []
})
)
test_claim = claim.Claim({
'dx_codes': ['dx_code_1'], 'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
output = measure.filter_by_eligibility_criteria([test_claim])
assert output == []
def test_dx_code_x_match(self):
"""Check the case where the measure has a dx_code_x and the claim doesn't have it."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_dx_codes],
'performance_options': []
})
)
test_claim = claim.Claim({
'dx_codes': ['dx_code'], 'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
output = measure.filter_by_eligibility_criteria([test_claim])
assert output == [test_claim]
def setup(self):
"""Setup base measure object for these tests."""
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'}
]
})
]
self.measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
self.inverse_measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options,
'is_inverse': True
})
)
def test_get_eligible_instances_raises_attribute_error():
"""
Test that get_eligible_instances raises AttributeError.
This method can only be called from subclasses of QPPMeasure that have
the fields_to_group_by attribute.
"""
claims = []
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
})
)
with pytest.raises(AttributeError):
measure.get_eligible_instances(claims)
def test_pos_match(self):
"""Check that only claims that have the desired encounter code and pos are 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',
'clm_pos_code': 23
}
]
})]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == test_claims
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_assign_performance_markers_multiple_code_sets_fails(self):
"""
Test assign_performance_markers in the case of >1 quality code per performance option.
Verify that marker is not assigned if not all required quality codes are present.
"""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'code_a'},
{'code': 'code_b'}
]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
claim_lines = [
{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': [],
'clm_pos_code': ''
},
{
'clm_line_hcpcs_cd': 'code_c',
'mdfr_cds': [],
'clm_pos_code': ''
}
]
test_claim = claim.Claim({'claim_lines': claim_lines})
output = measure._assign_performance_markers(test_claim)
expected = set()
assert output == expected
def test_assign_performance_markers(self):
"""Test that assigning performance markers to a single claim works as intended."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{
'code': 'code_a',
'placesOfService': ['AA'],
'placesOfServiceExclusions': ['GQ']
}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'code_a'}
]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
claim_lines = [{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': [],
'clm_pos_code': ''
}]
test_claim = claim.Claim({'claim_lines': claim_lines})
output = measure._assign_performance_markers(test_claim)
expected = set(['performanceNotMet'])
assert output == expected
def test_procedure_code_match(self):
"""Check that only claims that have the desired encounter code are returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.plain_eligibility_option],
'performance_options': []
})
)
claim_with_good_code = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
claim_with_bad_code = claim.Claim(
{'claim_lines': [{'clm_line_hcpcs_cd': 'bad_code'}]}
)
other_claim_with_good_code = claim.Claim(
{'claim_lines': [
{'clm_line_hcpcs_cd': 'good_code'},
{'clm_line_hcpcs_cd': 'bad_code'}
]}
)
test_claims = [claim_with_good_code, claim_with_bad_code, other_claim_with_good_code]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == [claim_with_good_code, other_claim_with_good_code]
def test_score_eligible_instances():
"""Test that score_eligible_instances correctly aggregates instances by performance marker."""
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'}
]
})
]
eligibility_options = [
EligibilityOption({
'procedureCodes': [MeasureCode({'code': 'enc_code'})]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': performance_options
})
)
claim_one = claim.Claim({
'bene_sk': '1001',
'claim_lines': [
{'clm_line_hcpcs_cd': 'pn_code'},
{'clm_line_hcpcs_cd': 'enc_code'}
]})
claim_two = claim.Claim({
'bene_sk': '1001',
'claim_lines': [
{'clm_line_hcpcs_cd': 'pn_x_code'},
{'clm_line_hcpcs_cd': 'enc_code'}
]})
claim_three = claim.Claim({
'bene_sk': '2001',
'claim_lines': [
{'clm_line_hcpcs_cd': 'pd_x_code'},
{'clm_line_hcpcs_cd': 'enc_code'}
]})
claim_four = claim.Claim({
'bene_sk': '3001',
'claim_lines': [
{'clm_line_hcpcs_cd': 'irrelevant_code'},
]})
claim_five = claim.Claim({
'bene_sk': '3001',
'claim_lines': [
{'clm_line_hcpcs_cd': 'enc_code'},
]})
# For the sake of this test, assume that the claims for each beneficiary are grouped together
# into a single eligible instance.
eligible_instances = [[claim_one, claim_two], [claim_three], [claim_four, claim_five]]
output = measure.score_eligible_instances(eligible_instances)
expected = collections.defaultdict(int)
expected['eligiblePopulationExclusion'] = 1
expected['performanceMet'] = 1
expected[None] = 1
assert output == expected
