mirror of
https://github.com/sartography/cr-connect-workflow.git
synced 2025-02-24 13:48:30 +00:00
264 lines
13 KiB
Python
264 lines
13 KiB
Python
import json
|
|
from datetime import datetime
|
|
from unittest.mock import patch
|
|
|
|
from tests.base_test import BaseTest
|
|
|
|
from crc import db, app
|
|
from crc.models.study import StudyModel, StudyStatus, StudyAssociatedSchema, CategoryMetadata, StudySchema, \
|
|
CategorySchema, Category
|
|
from crc.models.user import UserModel
|
|
from crc.models.workflow import WorkflowModel, WorkflowStatus, WorkflowSpecCategory, WorkflowSpecCategorySchema
|
|
from crc.services.ldap_service import LdapService
|
|
from crc.services.study_service import StudyService
|
|
from crc.services.workflow_processor import WorkflowProcessor
|
|
from crc.services.user_file_service import UserFileService
|
|
from crc.services.user_service import UserService
|
|
from crc.services.workflow_spec_service import WorkflowSpecService
|
|
|
|
|
|
class TestStudyService(BaseTest):
|
|
"""Largely tested via the test_study_api, and time is tight, but adding new tests here."""
|
|
|
|
def create_user_with_study_and_workflow(self):
|
|
self.load_test_spec("top_level_workflow", master_spec=True)
|
|
cat = WorkflowSpecCategory(id="approvals", display_name="Approvals", display_order=0, admin=False)
|
|
self.workflow_spec_service.add_category(cat)
|
|
self.load_test_spec("random_fact", category_id=cat.id)
|
|
user = self.create_user()
|
|
study = StudyModel(title="My title", status=StudyStatus.in_progress, user_uid=user.uid, review_type=2)
|
|
db.session.add(study)
|
|
db.session.commit()
|
|
self.assertIsNotNone(study.id)
|
|
workflow = WorkflowModel(workflow_spec_id="random_fact", study_id=study.id,
|
|
status=WorkflowStatus.not_started, last_updated=datetime.utcnow())
|
|
db.session.add(workflow)
|
|
db.session.commit()
|
|
return user
|
|
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_study_details') # mock_details
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_required_docs') # mock_docs
|
|
def test_study_progress(self, mock_docs, mock_details):
|
|
"""Assure that as a users progress is available when getting a list of studies for that user."""
|
|
app.config['PB_ENABLED'] = True
|
|
docs_response = self.protocol_builder_response('required_docs.json')
|
|
mock_docs.return_value = json.loads(docs_response)
|
|
details_response = self.protocol_builder_response('study_details.json')
|
|
mock_details.return_value = json.loads(details_response)
|
|
|
|
user = self.create_user_with_study_and_workflow()
|
|
|
|
# The load example data script should set us up a user and at least one study, one category, and one workflow.
|
|
spec_service = WorkflowSpecService()
|
|
categories = spec_service.get_categories()
|
|
studies = StudyService().get_studies_for_user(user, categories)
|
|
|
|
self.assertTrue(len(studies) == 1)
|
|
self.assertEqual(0, studies[0].progress)
|
|
|
|
# Initialize the Workflow with the workflow processor.
|
|
workflow_model = db.session.query(WorkflowModel).filter(WorkflowModel.study_id == studies[0].id).first()
|
|
processor = WorkflowProcessor(workflow_model)
|
|
processor.do_engine_steps()
|
|
|
|
# Complete a task
|
|
task = processor.next_task()
|
|
task.data = {"type":"norris"}
|
|
processor.complete_task(task)
|
|
processor.do_engine_steps()
|
|
processor.save()
|
|
|
|
# Assure the progress is now updated
|
|
studies = StudyService().get_studies_for_user(user, categories)
|
|
self.assertGreater(studies[0].progress, 0)
|
|
|
|
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_study_details') # mock_details
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_required_docs') # mock_docs
|
|
def test_get_required_docs(self, mock_docs, mock_details):
|
|
self.create_reference_document()
|
|
app.config['PB_ENABLED'] = True
|
|
# mock out the protocol builder
|
|
docs_response = self.protocol_builder_response('required_docs.json')
|
|
mock_docs.return_value = json.loads(docs_response)
|
|
details_response = self.protocol_builder_response('study_details.json')
|
|
mock_details.return_value = json.loads(details_response)
|
|
|
|
user = self.create_user_with_study_and_workflow()
|
|
spec_service = WorkflowSpecService()
|
|
categories = spec_service.get_categories()
|
|
studies = StudyService().get_studies_for_user(user, categories)
|
|
study = studies[0]
|
|
|
|
|
|
study_service = StudyService()
|
|
documents = study_service.get_documents_status(study_id=study.id, force=True) # Mocked out, any random study id works.
|
|
self.assertIsNotNone(documents)
|
|
self.assertTrue("UVACompl_PRCAppr" in documents.keys())
|
|
self.assertEqual("UVACompl_PRCAppr", documents["UVACompl_PRCAppr"]['code'])
|
|
self.assertEqual("UVA Compliance / PRC Approval", documents["UVACompl_PRCAppr"]['display_name'])
|
|
self.assertEqual("Cancer Center's PRC Approval Form", documents["UVACompl_PRCAppr"]['description'])
|
|
self.assertEqual("UVA Compliance", documents["UVACompl_PRCAppr"]['category1'])
|
|
self.assertEqual("PRC Approval", documents["UVACompl_PRCAppr"]['category2'])
|
|
self.assertEqual("", documents["UVACompl_PRCAppr"]['category3'])
|
|
self.assertEqual("Study Team", documents["UVACompl_PRCAppr"]['who_uploads?'])
|
|
self.assertEqual(0, documents["UVACompl_PRCAppr"]['count'])
|
|
self.assertEqual(True, documents["UVACompl_PRCAppr"]['required'])
|
|
self.assertEqual(6, documents["UVACompl_PRCAppr"]['id'])
|
|
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_required_docs') # mock_docs
|
|
def test_get_documents_has_file_details(self, mock_docs):
|
|
self.create_reference_document()
|
|
# mock out the protocol builder
|
|
docs_response = self.protocol_builder_response('required_docs.json')
|
|
mock_docs.return_value = json.loads(docs_response)
|
|
|
|
user = self.create_user_with_study_and_workflow()
|
|
|
|
# Add a document to the study with the correct code.
|
|
workflow = self.create_workflow('docx')
|
|
irb_code = "UVACompl_PRCAppr" # The first file referenced in pb required docs.
|
|
UserFileService.add_workflow_file(workflow_id=workflow.id,
|
|
task_spec_name='t1',
|
|
name="anything.png", content_type="text",
|
|
binary_data=b'1234', irb_doc_code=irb_code)
|
|
|
|
docs = StudyService().get_documents_status(workflow.study_id)
|
|
self.assertIsNotNone(docs)
|
|
self.assertEqual("not_started", docs["UVACompl_PRCAppr"]['status'])
|
|
self.assertEqual(1, docs["UVACompl_PRCAppr"]['count'])
|
|
self.assertIsNotNone(docs["UVACompl_PRCAppr"]['files'][0])
|
|
self.assertIsNotNone(docs["UVACompl_PRCAppr"]['files'][0]['id'])
|
|
self.assertEqual(workflow.id, docs["UVACompl_PRCAppr"]['files'][0]['workflow_id'])
|
|
|
|
def test_get_all_studies(self):
|
|
user = self.create_user_with_study_and_workflow()
|
|
study = db.session.query(StudyModel).filter_by(user_uid=user.uid).first()
|
|
self.assertIsNotNone(study)
|
|
|
|
# Add a document to the study with the correct code.
|
|
workflow1 = self.create_workflow('docx', study=study)
|
|
workflow2 = self.create_workflow('empty_workflow', study=study)
|
|
|
|
# Add files to both workflows.
|
|
UserFileService.add_workflow_file(workflow_id=workflow1.id,
|
|
task_spec_name="t1",
|
|
name="anything.png", content_type="text",
|
|
binary_data=b'1234', irb_doc_code="UVACompl_PRCAppr" )
|
|
UserFileService.add_workflow_file(workflow_id=workflow1.id,
|
|
task_spec_name="t1",
|
|
name="anything.png", content_type="text",
|
|
binary_data=b'1234', irb_doc_code="AD_Consent_Model")
|
|
UserFileService.add_workflow_file(workflow_id=workflow2.id,
|
|
task_spec_name="t1",
|
|
name="anything.png", content_type="text",
|
|
binary_data=b'1234', irb_doc_code="UVACompl_PRCAppr" )
|
|
|
|
studies = StudyService().get_all_studies_with_files()
|
|
self.assertEqual(1, len(studies))
|
|
self.assertEqual(3, len(studies[0].files))
|
|
|
|
|
|
|
|
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_investigators') # mock_docs
|
|
def test_get_personnel_roles(self, mock_docs):
|
|
self.create_reference_document()
|
|
|
|
# mock out the protocol builder
|
|
docs_response = self.protocol_builder_response('investigators.json')
|
|
mock_docs.return_value = json.loads(docs_response)
|
|
|
|
workflow = self.create_workflow('docx') # The workflow really doesnt matter in this case.
|
|
investigators = StudyService().get_investigators(workflow.study_id, all=True)
|
|
|
|
self.assertEqual(10, len(investigators))
|
|
|
|
# dhf8r is in the ldap mock data.
|
|
self.assertEqual("dhf8r", investigators['PI']['user_id'])
|
|
self.assertEqual("Dan Funk", investigators['PI']['display_name']) # Data from ldap
|
|
self.assertEqual("Primary Investigator", investigators['PI']['label']) # Data from xls file.
|
|
self.assertEqual("Always", investigators['PI']['display']) # Data from xls file.
|
|
|
|
# asd3v is not in ldap, so an error should be returned.
|
|
self.assertEqual("asd3v", investigators['DC']['user_id'])
|
|
self.assertEqual("ApiError: Unable to locate a user with id asd3v in LDAP. ", investigators['DC']['error']) # Data from ldap
|
|
|
|
# No value is provided for Department Chair
|
|
self.assertIsNone(investigators['DEPT_CH']['user_id'])
|
|
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_investigators') # mock_docs
|
|
def test_get_study_personnel(self, mock_docs):
|
|
self.create_reference_document()
|
|
|
|
# mock out the protocol builder
|
|
docs_response = self.protocol_builder_response('investigators.json')
|
|
mock_docs.return_value = json.loads(docs_response)
|
|
|
|
workflow = self.create_workflow('docx') # The workflow really doesnt matter in this case.
|
|
investigators = StudyService().get_investigators(workflow.study_id, all=False)
|
|
|
|
self.assertEqual(5, len(investigators))
|
|
|
|
# dhf8r is in the ldap mock data.
|
|
self.assertEqual("dhf8r", investigators['PI']['user_id'])
|
|
self.assertEqual("Dan Funk", investigators['PI']['display_name']) # Data from ldap
|
|
self.assertEqual("Primary Investigator", investigators['PI']['label']) # Data from xls file.
|
|
self.assertEqual("Always", investigators['PI']['display']) # Data from xls file.
|
|
|
|
# Both Alex and Aaron are SI, and both should be returned.
|
|
self.assertEqual("ajl2j", investigators['SI']['user_id'])
|
|
self.assertEqual("cah3us", investigators['SI_2']['user_id'])
|
|
|
|
@patch('crc.services.protocol_builder.ProtocolBuilderService.get_study_details') # mock_details
|
|
def test_get_user_studies(self, mock_details):
|
|
details_response = self.protocol_builder_response('study_details.json')
|
|
mock_details.return_value = json.loads(details_response)
|
|
|
|
user = self.create_user_with_study_and_workflow()
|
|
spec_service = WorkflowSpecService()
|
|
categories = spec_service.get_categories()
|
|
studies = StudyService().get_studies_for_user(user, categories)
|
|
# study_details has a valid REVIEW_TYPE, so we should get 1 study back
|
|
self.assertEqual(1, len(studies))
|
|
|
|
def test_get_user_studies_bad_review_type(self):
|
|
spec_service = WorkflowSpecService()
|
|
categories = spec_service.get_categories()
|
|
user = self.create_user_with_study_and_workflow()
|
|
study = db.session.query(StudyModel).first()
|
|
study.review_type = 1984 # A particularly bad review type.
|
|
db.session.commit()
|
|
studies = StudyService().get_studies_for_user(user, categories)
|
|
# study_details has an invalid REVIEW_TYPE, so we should get 0 studies back
|
|
self.assertEqual(0, len(studies))
|
|
|
|
def test_study_associates(self):
|
|
user = self.create_user_with_study_and_workflow()
|
|
study = db.session.query(StudyModel).first()
|
|
associates = StudyService.get_study_associates(study.id)
|
|
self.assertEquals(1, len(associates))
|
|
assoc_json = StudyAssociatedSchema(many=True).dump(associates)
|
|
print(assoc_json)
|
|
self.assertEquals("Dan", assoc_json[0]['ldap_info']['given_name'])
|
|
|
|
def test_set_category_metadata(self):
|
|
user = self.create_user_with_study_and_workflow()
|
|
study = db.session.query(StudyModel).filter_by(user_uid=user.uid).first()
|
|
|
|
####
|
|
wfscat = WorkflowSpecCategory(id='test_cat', display_name='test cat', display_order=0, admin=False)
|
|
wfs = self.create_workflow('empty_workflow')
|
|
|
|
wfscat.workflows = wfs
|
|
x = WorkflowSpecCategorySchema().dump(wfscat)
|
|
####
|
|
|
|
s = StudyService.get_study(study.id, [wfscat], None, {'test_cat':{'status':'hidden', 'message': 'msg'}}, process_categories=True)
|
|
d = StudySchema().dump(s)
|
|
self.assertEqual({'id': 'test_cat', 'message': 'msg', 'state': 'hidden'}, d['categories'][0]['meta'])
|
|
|
|
|
|
|
|
|