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_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 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 setup(self):
"""Setup base measure object for these tests."""
plain_measure_code = {
'code': 'good_code',
}
other_measure_code = {
'code': 'other_good_code',
}
self.plain_eligibility_option = EligibilityOption({
'procedureCodes': [plain_measure_code]
})
self.eligibility_option_with_place_of_service = EligibilityOption({
'procedureCodes': [MeasureCode({'code': 'good_code', 'placesOfService': [23]})]
})
self.eligibility_option_with_dx_codes = EligibilityOption({
'diagnosisCodes': ['dx_code'],
'diagnosisExclusionCodes': ['dx_code_x'],
'procedureCodes': [plain_measure_code]
})
self.eligibility_option_with_additional_dx_codes = EligibilityOption({
'diagnosisCodes': ['dx_code_1'],
'additionalDiagnosisCodes': ['dx_code_2'],
'procedureCodes': [plain_measure_code]
})
self.eligibility_option_other_code = EligibilityOption({
'procedureCodes': [other_measure_code]
})
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_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_compute_eligible_instance_weight(self):
"""Make sure the _count_eligible_instances calculation is accurate."""
procedure_codes = [
MeasureCode({'code': 'code_a'}),
MeasureCode({'code': 'code_b'}),
MeasureCode({'code': 'code_c'})
]
eligibility_options = [
EligibilityOption({
'procedureCodes': procedure_codes[:2]
}),
EligibilityOption({
'procedureCodes': procedure_codes[2:]
})
]
measure = visit_measure.VisitMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': []
})
)
claim_lines = [
{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': [],
'clm_pos_code': '23'
},
{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': ['GQ'],
'clm_pos_code': '43'
},
{
'clm_line_hcpcs_cd': 'code_c',
'mdfr_cds': ['AX'],
'clm_pos_code': ''
}
]
test_claims = [claim.Claim({'claim_lines': claim_lines})]
output = measure._compute_eligible_instance_weight(test_claims)
assert output == 3
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 setup(self):
"""Instantiate a measure for each of the tests."""
eligibility_options = [
EligibilityOption({'diagnosisCodes': ['dx_code_a', 'dx_code_b']})
]
self.measure = IntersectingDiagnosisMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': []
}))
def test_eligibility_option_updated_diagnosis_codes():
"""Test that importing an eligibility option converts diagnosis type codes properly."""
test_eligibility_option = {
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
}
option = EligibilityOption(test_eligibility_option)
assert option.diagnosis_codes == ['abc']
assert option.diagnosis_exclusion_codes == ['def']
assert option.additional_diagnosis_codes == ['ghi']
def setup(self):
"""Create sample models for use in the tests."""
self.measure_code = MeasureCode({
'code': 'code',
'modifiers': ['a', 'b'],
'placesOfService': ['a', 'b'],
'modifierExclusions': ['a', 'b'],
'placesOfServiceExclusions': ['a', 'b']
})
self.eligibility_option = EligibilityOption({
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
})
self.performance_option = PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'code_a'}
]
})
self.measure = MeasureDefinition({
'isInverse': True,
'eligibilityOptions': [{
'minAge': 0,
'maxAge': 100,
'sexCode': 'F',
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
'procedureCodes': [self.measure_code]
}],
'performanceOptions': [{
'optionType': 'performanceMet',
'qualityCodes': [self.measure_code]
}]
})
self.stratum = Stratum({'name': 'primary_stratum'})
def get_test_measure():
"""Build the Measure used in the CT Scan Measure tests."""
eligibility_options = [
EligibilityOption({
'procedureCodes': [MeasureCode({'code': '99281'})],
'diagnosis_codes': ['dx_code_1']
})
]
performance_options = [
PerformanceOption({
'optionType':
'performanceNotMet',
'quality_codes': [MeasureCode({
'code': 'quality_code',
})]
})
]
return CTScanMeasure(measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
def setup(self):
"""Initialize useful values."""
self.performance_year = 2017
self.line_with_quality_code = ClaimLine({'clm_line_hcpcs_cd': 'G9607'})
self.line_without_quality_code = ClaimLine(
{'clm_line_hcpcs_cd': 'not_a_real_code'})
self.claim_with_quality_code_january = Claim({
'clm_from_dt':
datetime.date(self.performance_year, 1, 1),
'claim_lines': [self.line_with_quality_code]
})
self.claim_without_quality_code_january = Claim({
'clm_from_dt':
datetime.date(self.performance_year, 1, 1),
'claim_lines': [self.line_without_quality_code]
})
self.all_claims = [
self.__getattribute__(attr) for attr in dir(self)
if type(self.__getattribute__(attr)) == Claim
]
self.all_claims_in_performance_year = [
claim for claim in self.all_claims
if claim['clm_from_dt'].year == self.performance_year
]
self.claim_with_relevant_procedure_code = self.claim_with_quality_code_january
self.measure_definition = MeasureDefinition({
'eligibility_options':
[EligibilityOption({'procedureCodes': [{
'code': 'G9607'
}]})],
'performance_options': []
})
class TestReprFunctionality():
"""Test to ensure that all models' representations can recreate the original object."""
def setup(self):
"""Create sample models for use in the tests."""
self.measure_code = MeasureCode({
'code': 'code',
'modifiers': ['a', 'b'],
'placesOfService': ['a', 'b'],
'modifierExclusions': ['a', 'b'],
'placesOfServiceExclusions': ['a', 'b']
})
self.eligibility_option = EligibilityOption({
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
})
self.performance_option = PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'code_a'}
]
})
self.measure = MeasureDefinition({
'isInverse': True,
'eligibilityOptions': [{
'minAge': 0,
'maxAge': 100,
'sexCode': 'F',
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
'procedureCodes': [self.measure_code]
}],
'performanceOptions': [{
'optionType': 'performanceMet',
'qualityCodes': [self.measure_code]
}]
})
self.stratum = Stratum({'name': 'primary_stratum'})
def test_repr_for_measure_codes(self):
"""Test that measure codes are represented correctly."""
assert(self.measure_code == eval(self.measure_code.__repr__()))
def test_repr_for_eligibility_option(self):
"""Test that eligibility options are represented correctly."""
assert(self.eligibility_option == eval(self.eligibility_option.__repr__()))
def test_repr_for_performance_option(self):
"""Test that performance options are represented correctly."""
assert(self.performance_option == eval(self.performance_option.__repr__()))
def test_repr_for_measure_definitions(self):
"""Test that measure definitions are represented correctly."""
assert(self.measure == eval(self.measure.__repr__()))
def test_repr_for_strata(self):
"""Test that strata are represented correctly."""
assert(self.stratum == eval(self.stratum.__repr__()))
def test_execute():
"""
Test for execute method.
Note that some patient process measures have multiple eligibility options.
"""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [{
'code': 'pn_code'
}]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [{
'code': 'pn_x_code'
}]
}),
PerformanceOption({
'optionType': 'eligiblePopulationExclusion',
'qualityCodes': [{
'code': 'pd_exl_code'
}]
}),
PerformanceOption({
'optionType': 'eligiblePopulationException',
'qualityCodes': [{
'code': 'pd_exe_code'
}]
})
]
eligibility_options = [
EligibilityOption(
{'procedureCodes': [MeasureCode({'code': 'enc_code'})]}),
EligibilityOption(
{'procedureCodes': [MeasureCode({'code': 'other_enc_code'})]})
]
measure = PatientProcessMeasure(measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
best_line = claim_line.ClaimLine({'clm_line_hcpcs_cd': 'pn_code'})
second_best_line = claim_line.ClaimLine(
{'clm_line_hcpcs_cd': 'pd_exl_code'})
worst_claim_line = claim_line.ClaimLine({'clm_line_hcpcs_cd': 'pn_x_code'})
enc_line = claim_line.ClaimLine({'clm_line_hcpcs_cd': 'enc_code'})
exception_line = claim_line.ClaimLine({'clm_line_hcpcs_cd': 'pd_exe_code'})
other_enc_line = claim_line.ClaimLine(
{'clm_line_hcpcs_cd': 'other_enc_code'})
claim_best_a = claim.Claim({
'bene_sk': 'a',
'claim_lines': [second_best_line, enc_line]
})
claim_worst_a = claim.Claim({
'bene_sk': 'a',
'claim_lines': [worst_claim_line, enc_line]
})
claim_best_b = claim.Claim({
'bene_sk': 'b',
'claim_lines': [worst_claim_line, enc_line]
})
claim_best_c = claim.Claim({
'bene_sk': 'c',
'claim_lines': [best_line, enc_line]
})
claim_worst_c = claim.Claim({
'bene_sk': 'c',
'claim_lines': [second_best_line, enc_line]
})
claim_best_d = claim.Claim({
'bene_sk': 'd',
'claim_lines': [exception_line, enc_line]
})
claim_irrelevant_e = claim.Claim({
'bene_sk': 'e',
'claim_lines': [best_line]
})
claim_best_f = claim.Claim({
'bene_sk': 'f',
'claim_lines': [best_line, other_enc_line]
})
claims = [
claim_best_a, claim_worst_a, claim_best_b, claim_best_c, claim_worst_c,
claim_best_d, claim_irrelevant_e, claim_best_f
]
output = measure.execute(claims)
expected = {
'eligible_population_exclusion': 1,
'eligible_population_exception': 1,
'performance_met': 2,
'performance_not_met': 1,
'eligible_population': 5
}
assert output == expected
def test_get_eligible_instances():
"""
Test that get_eligible_instances correctly groups and filters claims.
For these measures, claims should be grouped by beneficiary ID and then grouped
further into episodes by date range. Each episode is filtered further to the earliest
claims with QDCs. If no claims for a beneficiary have QDCs, filter to the .
"""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [{
'code': 'pn_code'
}]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [{
'code': 'pn_x_code'
}]
}),
PerformanceOption({
'optionType': 'performanceExclusion',
'qualityCodes': [{
'code': 'pd_x_code'
}]
})
]
eligibility_options = [
EligibilityOption(
{'procedureCodes': [MeasureCode({'code': 'enc_code'})]})
]
measure = DateWindowEOCMeasure(measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
claim_one = claim.Claim({
'bene_sk':
'1001',
'clm_from_dt':
datetime.date(2016, 12, 30),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_two = claim.Claim({
'bene_sk':
'1001',
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_x_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_three = claim.Claim({
'bene_sk':
'2001',
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pd_x_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_four = claim.Claim({
'bene_sk':
'3001',
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [
{
'clm_line_hcpcs_cd': 'irrelevant_code'
},
]
})
claims = [claim_one, claim_two, claim_three, claim_four]
output = measure.get_eligible_instances(claims)
expected = [[claim_one], [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 correctly groups and filters claims.
For PatientIntermediate measures, claims should be grouped by beneficiary ID and filtered
by most recent claims with QDCs when possible. If no claims for a beneficiary have QDCs,
filter to the most recent claim.
"""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [{
'code': 'pn_code'
}]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [{
'code': 'pn_x_code'
}]
}),
PerformanceOption({
'optionType': 'eligiblePopulationExclusion',
'qualityCodes': [{
'code': 'pd_exl_code'
}]
}),
PerformanceOption({
'optionType': 'eligiblePopulationException',
'qualityCodes': [{
'code': 'pd_exe_code'
}]
})
]
eligibility_options = [
EligibilityOption(
{'procedureCodes': [MeasureCode({'code': 'enc_code'})]})
]
measure = PatientIntermediateMeasure(measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
claim_one = claim.Claim({
'bene_sk':
'1001',
'clm_ptnt_birth_dt':
datetime.date(1940, 1, 1),
'clm_from_dt':
datetime.date(2016, 12, 30),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_two = claim.Claim({
'bene_sk':
'1001',
'clm_ptnt_birth_dt':
datetime.date(1940, 1, 1),
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_x_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_three = claim.Claim({
'bene_sk':
'2001',
'clm_ptnt_birth_dt':
datetime.date(1940, 1, 1),
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pd_exl_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_four = claim.Claim({
'bene_sk':
'3001',
'clm_ptnt_birth_dt':
datetime.date(1940, 1, 1),
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [
{
'clm_line_hcpcs_cd': 'irrelevant_code'
},
]
})
claim_five = claim.Claim({
'bene_sk':
'4001',
'clm_ptnt_birth_dt':
datetime.date(1955, 1, 1),
'clm_from_dt':
datetime.date(2017, 1, 1),
'claim_lines': [
{
'clm_line_hcpcs_cd': 'pd_exe_code'
},
]
})
claims = [claim_one, claim_two, claim_three, claim_four, claim_five]
output = measure.get_eligible_instances(claims)
expected = [[claim_two], [claim_three], [claim_four], [claim_five]]
for instance in output:
assert instance in expected
for instance in expected:
assert instance in output
assert len(output) == len(expected)
def setup(self):
"""Initialisation of measure 407."""
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'})]})
]
self.measure = measure_407.Measure407(
measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
self.bene_1_claim_1 = claim.Claim({
'bene_sk':
'bene_1',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
self.bene_1_claim_2 = claim.Claim({
'bene_sk':
'bene_1',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_x_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
self.bene_2_claim_2 = claim.Claim({
'bene_sk':
'bene_2',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pd_x_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
self.bene_3_claim_1 = claim.Claim({
'bene_sk':
'bene_3',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'no'
}, {
'clm_line_hcpcs_cd': 'no'
}]
})
self.claims = [
self.bene_1_claim_1, self.bene_1_claim_2, self.bene_2_claim_2,
self.bene_3_claim_1
]
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
def test_get_eligible_instances(mock_config):
"""
Test that get_eligible_instances correctly groups and filters claims.
For these measures, claims should be grouped by beneficiary ID and then grouped
further into eligible instances according to the provided date ranges.
"""
mock_config.get.side_effect = mocking_config.config_measures_year(2018)
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [{
'code': 'pn_code'
}]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [{
'code': 'pn_x_code'
}]
}),
]
eligibility_options = [
EligibilityOption(
{'procedureCodes': [MeasureCode({'code': 'enc_code'})]})
]
measure = PatientPeriodicMeasure(measure_definition=MeasureDefinition(
{
'measure_number': '110',
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
claims = [
claim.Claim({
'bene_sk': '1001',
'clm_from_dt': datetime.date(2018, 1, 1),
'clm_thru_dt': datetime.date(2018, 1, 1),
}),
claim.Claim({
'bene_sk': '1001',
'clm_from_dt': datetime.date(2018, 12, 1),
'clm_thru_dt': datetime.date(2018, 12, 1),
}),
claim.Claim({
'bene_sk': '2001',
'clm_from_dt': datetime.date(2018, 11, 1),
'clm_thru_dt': datetime.date(2018, 11, 1),
}),
claim.Claim({
'bene_sk': '2001',
'clm_from_dt': datetime.date(2018, 4, 1),
'clm_thru_dt': datetime.date(2018, 4, 1),
}),
claim.Claim({
'bene_sk': '2001',
'clm_from_dt': datetime.date(2018, 12, 1),
'clm_thru_dt': datetime.date(2018, 12, 1),
})
]
output = measure.get_eligible_instances(claims)
expected = [[claims[0]], [claims[1]], [claims[2], claims[4]]]
for instance in output:
assert instance in expected
for instance in expected:
assert instance in output
assert len(output) == len(expected)
def test_execute(self):
"""Test that the execute method returns the expected values and runs without error."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [{
'code': 'pn_code'
}]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [{
'code': 'pn_x_code'
}]
}),
PerformanceOption({
'optionType': 'eligiblePopulationExclusion',
'qualityCodes': [{
'code': 'pd_exl_code'
}]
}),
PerformanceOption({
'optionType': 'eligiblePopulationException',
'qualityCodes': [{
'code': 'pd_exe_code'
}]
})
]
eligibility_options = [
EligibilityOption(
{'procedureCodes': [MeasureCode({'code': 'enc_code'})]})
]
measure = procedure_measure.ProcedureMeasure(
measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
claim_one = claim.Claim({
'bene_sk':
'1001',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_two = claim.Claim({
'bene_sk':
'1001',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pn_x_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_three = claim.Claim({
'bene_sk':
'2001',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pd_exl_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claim_four = claim.Claim({
'bene_sk':
'3001',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [
{
'clm_line_hcpcs_cd': 'irrelevant_code'
},
]
})
claim_five = claim.Claim({
'bene_sk':
'3001',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [
{
'clm_line_hcpcs_cd': 'enc_code'
},
]
})
claim_six = claim.Claim({
'bene_sk':
'4001',
'clm_ptnt_birth_dt':
date(1940, 1, 1),
'clm_from_dt':
date(2017, 1, 1),
'claim_lines': [{
'clm_line_hcpcs_cd': 'pd_exe_code'
}, {
'clm_line_hcpcs_cd': 'enc_code'
}]
})
claims = [
claim_one, claim_two, claim_three, claim_four, claim_five,
claim_six
]
output = measure.execute(claims)
expected = {
'eligible_population_exclusion': 1,
'eligible_population_exception': 1,
'performance_met': 1,
'performance_not_met': 0,
'eligible_population': 4
}
assert output == expected
def test_score_eligible_instances(self):
"""Test that score_eligible_instances returns the expected values and runs without error."""
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 = visit_measure.VisitMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': performance_options
})
)
bene_1_claim_1 = claim.Claim({
'bene_sk': 'bene_1',
'clm_ptnt_birth_dt': date(1940, 1, 1),
'clm_from_dt': date(2017, 1, 1),
'claim_lines': [
{'clm_line_hcpcs_cd': 'pn_code'},
{'clm_line_hcpcs_cd': 'enc_code'}
]})
bene_1_claim_2 = claim.Claim({
'bene_sk': 'bene_1',
'clm_ptnt_birth_dt': date(1940, 1, 1),
'clm_from_dt': date(2017, 1, 1),
'claim_lines': [
{'clm_line_hcpcs_cd': 'pn_x_code'},
{'clm_line_hcpcs_cd': 'enc_code'}
]})
bene_2_claim_2 = claim.Claim({
'bene_sk': 'bene_2',
'clm_ptnt_birth_dt': date(1940, 1, 1),
'clm_from_dt': date(2017, 1, 1),
'claim_lines': [
{'clm_line_hcpcs_cd': 'pd_x_code'},
{'clm_line_hcpcs_cd': 'enc_code'}
]})
eligible_instances = [[bene_1_claim_1, bene_1_claim_2], [bene_2_claim_2]]
output = measure.score_eligible_instances(eligible_instances)
expected = collections.defaultdict(int)
expected['eligiblePopulationExclusion'] = 1
expected['performanceMet'] = 2
assert output == expected