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_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 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'}
]
})
]
self.measure_definition = MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
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 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 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_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 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_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 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)
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 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():
"""
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_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)
