def test_get_dates_status_from_arm(self, patient_data, exp_date_assigned,
exp_date_on, exp_date_off, exp_status):
p = Patient(patient_data)
(date_assigned, date_on, date_off,
status) = p.get_dates_status_from_arm()
self.assertEqual(date_assigned, exp_date_assigned)
self.assertEqual(date_on, exp_date_on)
self.assertEqual(date_off, exp_date_off)
self.assertEqual(status, exp_status)
def test_match(self, patient_type, add_patient_by_type_expected,
mock_assignment_record, mock_sum_rpt):
sr = mock_sum_rpt.return_value
ar = mock_assignment_record.return_value
orig_create_assignment_record = Refresher._create_assignment_record
orig_determine_patient_classification_by_dates = Refresher._determine_patient_classification_by_dates
Refresher._determine_patient_classification_by_dates = \
MagicMock(name='patient_type',
return_value=patient_type)
Refresher._create_assignment_record = MagicMock(name='_create_assignment_record', return_value=ar)
try:
patient = Patient(pd.create_patient())
Refresher._match(patient, sr)
self.maxDiff = None
if add_patient_by_type_expected:
sr.add_patient_by_type.assert_called_once_with(patient_type, ar)
else:
sr.add_patient_by_type.assert_not_called()
finally: # Because these are static methods, they must be reassigned to the original function or else
# their mocking will persist to other test cases.
Refresher._create_assignment_record = orig_create_assignment_record
Refresher._determine_patient_classification_by_dates = orig_determine_patient_classification_by_dates
def test_update_summary_report(self, patients, ta_data_for_sum_rpt, expected_sum_rpt_json, expected_ar_patients,
mock_ta_accessor, mock_patient_accessor, mock_create_token, mock_logging):
self.maxDiff = None
ar_records = []
for patient in expected_ar_patients:
assmt_rec = Refresher._create_assignment_record(Patient(patient), ta_data_for_sum_rpt['treatmentArmId'])
ar_records.append(assmt_rec.get_json())
expected_sum_rpt_json['assignmentRecords'] = SummaryReport._finalize_assignment_records(ar_records)
# Set up the mocked PatientAccessor
pa_instance = mock_patient_accessor.return_value
pa_instance.get_patients_by_treatment_arm_id.return_value = patients
# Set up the mocked TreatmentArmsAccessor
taa_instance = mock_ta_accessor.return_value
taa_instance.update_summary_report = lambda _id, json: self.assertEqual(json, expected_sum_rpt_json)
# Set up the mocked create_authentication_token method
mock_create_token.return_value = "Bearer my_fake_authentication_token"
sum_rpt = SummaryReport(ta_data_for_sum_rpt)
r = Refresher()
r._update_summary_report(sum_rpt)
def _update_summary_report(self, sum_rpt):
"""
Update the given summary report with counts and assignment records.
:param sum_rpt: The summary report of a treatment arm that requires updating.
"""
# Get all patients associated with the Treatment Arm of the given Summary Report.
# Patients are sorted by patientSequenceNumber (ascending) and patientAssignments.dateConfirmed (descending).
# patients = [Patient(p) for p in self.pat_accessor.get_patients_by_treatment_arm_id(sum_rpt.treatmentArmId)]
patients = [
Patient(p)
for p in self.pat_accessor.get_patients_by_treatment_arm_id(
sum_rpt.treatmentArmId, self.token)
]
self.logger.info("{cnt} patients returned for '{trtmt_id}".format(
cnt=len(patients), trtmt_id=sum_rpt.treatmentArmId))
# Update the summary report object for any patients that meet the criteria.
pat_id = []
for pat in patients:
# Only match the patient the first time he/she is encountered. (A patient can be assigned to an arm more
# than once [different versions], but only the most recent occurrence should be counted.)
if pat.patientSequenceNumber not in pat_id:
Refresher._match(pat, sum_rpt)
pat_id.append(pat.patientSequenceNumber)
# Update the summary report in the treatmentArms collection on the database
return self.ta_accessor.update_summary_report(sum_rpt._id,
sum_rpt.get_json())
def test_constructor_and_get(self):
p = Patient(pd.TEST_PATIENT)
self.assertEqual(p.diseases, pd.TEST_PATIENT['diseases'])
self.assertEqual(p.currentTreatmentArm,
pd.TEST_PATIENT['currentTreatmentArm'])
self.assertEqual(p.currentPatientStatus,
pd.TEST_PATIENT['currentPatientStatus'])
self.assertEqual(p.currentStepNumber,
pd.TEST_PATIENT['currentStepNumber'])
self.assertEqual(p.patientTriggers, pd.TEST_PATIENT['patientTriggers'])
self.assertEqual(p.patientAssignments,
pd.TEST_PATIENT['patientAssignments'])
self.assertEqual(p.patientAssignmentIdx,
pd.TEST_PATIENT['patientAssignmentIdx'])
self.assertEqual(p.get_patient_assignment_step_number(),
pd.DEFAULT_PAT_ASSNMNT_STEP_NUM)
def test_trigger_belongs_to_assignment(self, trigger, assignment_date,
exp_result):
# assignment_date_ts = pd.datetime_to_timestamp(assignment_date)
# result = Patient._trigger_belongs_to_assignment(trigger, assignment_date_ts)
result = Patient._trigger_belongs_to_assignment(
trigger, assignment_date)
self.assertEqual(result, exp_result)
def test_create_assignment_record(self, patient, trtmt_id, ar_constructor_args):
exp_ar = AssignmentRecord(*ar_constructor_args)
ar = Refresher._create_assignment_record(Patient(patient), trtmt_id)
self.assertEqual(ar.patient_sequence_number, exp_ar.patient_sequence_number)
self.assertEqual(ar.patient_type, exp_ar.patient_type)
self.assertEqual(ar.treatment_arm_version, exp_ar.treatment_arm_version)
self.assertEqual(ar.assignment_status_outcome, exp_ar.assignment_status_outcome)
self.assertEqual(ar.analysis_id, exp_ar.analysis_id)
self.assertEqual(ar.biopsy_seq_num, exp_ar.biopsy_seq_num)
self.assertEqual(ar.patient_assmt_idx, exp_ar.patient_assmt_idx)
self.assertEqual(ar.date_selected, exp_ar.date_selected)
self.assertEqual(ar.date_on_arm, exp_ar.date_on_arm)
self.assertEqual(ar.date_off_arm, exp_ar.date_off_arm)
self.assertEqual(ar.step_number, exp_ar.step_number)
self.assertEqual(ar.diseases, exp_ar.diseases)
self.assertEqual(ar.assignment_reason, exp_ar.assignment_reason)
def test_get_assignment_reason(self, treatment_id, treatment_version,
exp_reason):
p = Patient(pd.TEST_PATIENT)
self.assertEqual(
p.get_assignment_reason(treatment_id, treatment_version),
exp_reason)
def test_find_trigger_by_status(self, status, exp_trigger):
p = Patient(pd.TEST_PATIENT)
self.assertEqual(p.find_trigger_by_status(status), exp_trigger)
def test_treatment_arm_version(self, patient_json, exp_trtmt_ver):
patient = Patient(patient_json)
self.assertEqual(patient.treatment_arm_version(), exp_trtmt_ver)
def test_get_patient_assignment_step_number(self, patient_json,
exp_step_number):
p = Patient(patient_json)
step_number = p.get_patient_assignment_step_number()
self.assertEqual(step_number, exp_step_number)
def test_get_analysis_id_and_bsn(self, biopsies, exp_analysis_id,
exp_biopsy_seq_num):
p = Patient(pd.create_patient(biopsies=biopsies))
analysis_id, biopsy_seq_num = p.get_analysis_id_and_bsn()
self.assertEqual(analysis_id, exp_analysis_id)
self.assertEqual(biopsy_seq_num, exp_biopsy_seq_num)
def test_get_date_assigned(self, patient_data, exp_date):
p = Patient(patient_data)
assd_date = p.get_date_assigned()
self.assertEqual(assd_date, exp_date)