def test_matches_measure_code_no_code_match(self):
"""Test matches measure_code if the code doesn't match."""
measure_code = MeasureCode({'code': 'bad_code'})
filtered_lines = [
line for line in self.claim_lines if measure_code.matches_line(line)
]
assert filtered_lines == []
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):
"""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_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 setup(self):
"""Initialize performance options."""
self.valid_performance_option = PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [MeasureCode({'code': 'g-code'})]
})
self.invalid_performance_option = PerformanceOption({
'optionType': 'typographical_error',
'qualityCodes': []
})
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 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 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
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_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_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)
class TestMeasureCodeMatchesClaimLine():
"""Tests for methods matching lines to MeasureCodes."""
def setup(self):
claim_line_data = [
{
'clm_line_hcpcs_cd': 'code',
'mdfr_cds': ['GQ', 'GY'],
'clm_pos_code': '23',
'clm_line_num': 1
},
{'clm_line_hcpcs_cd': 'code', 'mdfr_cds': ['GQ'], 'clm_pos_code': '24'},
{'clm_line_hcpcs_cd': 'code', 'mdfr_cds': ['GY'], 'clm_pos_code': '25'},
{'clm_line_hcpcs_cd': 'code', 'mdfr_cds': [], 'clm_pos_code': None}
]
self.claim_lines = [claim_line.ClaimLine(line) for line in claim_line_data]
self.claim_line_GQ_GY_23 = self.claim_lines[0]
self.claim_line_GQ_24 = self.claim_lines[1]
self.claim_line_GY_25 = self.claim_lines[2]
self.claim_line_no_modifier_no_pos = self.claim_lines[3]
self.plain_measure_code = MeasureCode({'code': 'code'})
self.irrelevant_measure_code = MeasureCode({'code': 'bad_code'})
self.measure_code_pos_24 = MeasureCode(
{'code': 'code', 'placesOfService': ['24']}
)
self.measure_code_pos_26 = MeasureCode(
{'code': 'code', 'placesOfService': ['26']}
)
self.measure_code_exclude_pos_24 = MeasureCode(
{'code': 'code', 'placesOfServiceExclusions': ['24']}
)
self.measure_code_exclude_pos_26 = MeasureCode(
{'code': 'code', 'placesOfServiceExclusions': ['26']}
)
self.measure_code_exclude_GQ = MeasureCode(
{'code': 'code', 'modifierExclusions': ['GQ']}
)
self.measure_code_exclude_GT = MeasureCode(
{'code': 'code', 'modifierExclusions': ['GT']}
)
self.measure_code_include_GQ = MeasureCode(
{'code': 'code', 'modifiers': ['GQ']}
)
self.measure_code_include_GT = MeasureCode(
{'code': 'code', 'modifiers': ['GT']}
)
self.measure_code_both_modifier_x_and_modifiers = MeasureCode(
{'code': 'code', 'modifiers': ['GY'], 'modifierExclusions': ['GT', 'GQ']}
)
def test_matches_measure_code_no_constraints(self):
filtered_lines = [
line for line in self.claim_lines if self.plain_measure_code.matches_line(line)
]
assert filtered_lines == self.claim_lines
def test_matches_measure_code_no_code_match(self):
"""Test matches measure_code if the code doesn't match."""
measure_code = MeasureCode({'code': 'bad_code'})
filtered_lines = [
line for line in self.claim_lines if measure_code.matches_line(line)
]
assert filtered_lines == []
def test_matches_measure_code_pos_x_true(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_exclude_pos_24.matches_line(line)
]
assert filtered_lines == [
self.claim_line_GQ_GY_23, self.claim_line_GY_25, self.claim_line_no_modifier_no_pos]
def test_matches_measure_code_pos_x_false(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_exclude_pos_26.matches_line(line)
]
assert filtered_lines == self.claim_lines
def test_matches_measure_code_pos_true(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_pos_24.matches_line(line)
]
assert filtered_lines == [self.claim_line_GQ_24]
def test_matches_measure_code_pos_false(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_pos_26.matches_line(line)
]
assert filtered_lines == []
def test_matches_measure_code_mdfr_x_true(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_exclude_GQ.matches_line(line)
]
assert filtered_lines == [self.claim_line_GY_25, self.claim_line_no_modifier_no_pos]
def test_matches_measure_code_mdfr_x_false(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_exclude_GT.matches_line(line)
]
assert filtered_lines == self.claim_lines
def test_matches_measure_code_mdfr_true(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_include_GQ.matches_line(line)
]
assert filtered_lines == [self.claim_line_GQ_GY_23, self.claim_line_GQ_24]
def test_matches_measure_code_mdfr_false(self):
filtered_lines = [
line for line in self.claim_lines if self.measure_code_include_GT.matches_line(line)
]
assert filtered_lines == []
def test_matches_measure_code_mdfr_x_multiple_constraints(self):
filtered_lines = [
line for line in self.claim_lines
if self.measure_code_both_modifier_x_and_modifiers.matches_line(line)
]
assert filtered_lines == [self.claim_line_GY_25]
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
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 setup(self):
claim_line_data = [
{
'clm_line_hcpcs_cd': 'code',
'mdfr_cds': ['GQ', 'GY'],
'clm_pos_code': '23',
'clm_line_num': 1
},
{'clm_line_hcpcs_cd': 'code', 'mdfr_cds': ['GQ'], 'clm_pos_code': '24'},
{'clm_line_hcpcs_cd': 'code', 'mdfr_cds': ['GY'], 'clm_pos_code': '25'},
{'clm_line_hcpcs_cd': 'code', 'mdfr_cds': [], 'clm_pos_code': None}
]
self.claim_lines = [claim_line.ClaimLine(line) for line in claim_line_data]
self.claim_line_GQ_GY_23 = self.claim_lines[0]
self.claim_line_GQ_24 = self.claim_lines[1]
self.claim_line_GY_25 = self.claim_lines[2]
self.claim_line_no_modifier_no_pos = self.claim_lines[3]
self.plain_measure_code = MeasureCode({'code': 'code'})
self.irrelevant_measure_code = MeasureCode({'code': 'bad_code'})
self.measure_code_pos_24 = MeasureCode(
{'code': 'code', 'placesOfService': ['24']}
)
self.measure_code_pos_26 = MeasureCode(
{'code': 'code', 'placesOfService': ['26']}
)
self.measure_code_exclude_pos_24 = MeasureCode(
{'code': 'code', 'placesOfServiceExclusions': ['24']}
)
self.measure_code_exclude_pos_26 = MeasureCode(
{'code': 'code', 'placesOfServiceExclusions': ['26']}
)
self.measure_code_exclude_GQ = MeasureCode(
{'code': 'code', 'modifierExclusions': ['GQ']}
)
self.measure_code_exclude_GT = MeasureCode(
{'code': 'code', 'modifierExclusions': ['GT']}
)
self.measure_code_include_GQ = MeasureCode(
{'code': 'code', 'modifiers': ['GQ']}
)
self.measure_code_include_GT = MeasureCode(
{'code': 'code', 'modifiers': ['GT']}
)
self.measure_code_both_modifier_x_and_modifiers = MeasureCode(
{'code': 'code', 'modifiers': ['GY'], 'modifierExclusions': ['GT', 'GQ']}
)
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
