class TestGetDestination:
@pytest.mark.parametrize(
"parent,raising",
[
(flywheel.Subject(label="test"), does_not_raise()),
(flywheel.Session(label="test"), does_not_raise()),
(flywheel.Group(label="test"), pytest.raises(ValueError)),
(flywheel.Project(label="test"), pytest.raises(ValueError)),
(flywheel.Acquisition(label="test"), pytest.raises(ValueError)),
],
)
def test_container(self, sdk_mock, parent, raising):
container = flywheel.models.analysis_output.AnalysisOutput(
parent=parent, id="test"
)
sdk_mock.get_analysis.return_value = container
sdk_mock.get.return_value = parent
with raising:
dest = get_destination(sdk_mock, "test")
sdk_mock.get_analysis.assert_called_once_with("test")
# assert dest.__class__ == parent.__class__
assert isinstance(dest, parent.__class__)
def test_analysis_does_not_exist(self, sdk_mock):
container = flywheel.models.analysis_output.AnalysisOutput(
parent=flywheel.Project(), id="test"
)
sdk_mock.get.side_effect = flywheel.rest.ApiException(status=404)
sdk_mock.get_analysis.return_value = container
with pytest.raises(flywheel.rest.ApiException):
dest = get_destination(sdk_mock, "test")
assert isinstance(dest, flywheel.Project)
def find_or_create_group(fw_client, group_id, group_label):
"""
return an existing group or return a created group with group_id and group_label
Args:
fw_client (flywheel.Client): Flywheel Client
group_id (str): The ID of the group
group_label (str): The name of the group
Returns:
tuple: The tuple of created flywheel.Group and CREATED_CONTAINER_TEMPLATE
"""
found_groups = fw_client.groups.find(f'_id="{group_id}"')
if len(found_groups) > 0:
log.info(f"Found Existing Group {group_id}")
return found_groups[0].reload(), []
log.info(f"No existing group {group_id}, creating...")
group_id = fw_client.add_group(flywheel.Group(group_id, group_label))
group = fw_client.groups.find_first(f'_id="{group_id}"')
created_container = define_created(group)
return group.reload(), [created_container]
def test_groups(self):
fw = self.fw
group_id = self.rand_string_lower()
group_name = self.rand_string()
r_id = self.fw.add_group(flywheel.Group(group_id, group_name))
self.assertEqual(group_id, r_id)
# Get
saved_group = fw.get_group(group_id)
self.assertEqual(group_id, saved_group.id)
self.assertEqual(group_name, saved_group.label)
self.assertTimestampBeforeNow(saved_group.created)
self.assertGreaterEqual(saved_group.modified, saved_group.created)
self.assertTrue(hasattr(saved_group, 'container_type'))
self.assertEqual(saved_group.container_type, 'group')
self.assertTrue(hasattr(saved_group, 'child_types'))
self.assertEqual(saved_group.child_types, ['projects'])
# Generic Get is equivalent
self.assertEqual(fw.get(group_id).to_dict(), saved_group.to_dict())
# Get All
groups = fw.get_all_groups()
self.assertIn(saved_group, groups)
self.assertEqual(groups[0].container_type, 'group')
# Modify
new_name = self.rand_string()
fw.modify_group(group_id, {'label': new_name})
changed_group = fw.get_group(group_id)
self.assertEqual(new_name, changed_group.label)
self.assertEqual(saved_group.created, changed_group.created)
self.assertGreater(changed_group.modified, saved_group.modified)
# Tags
tag = 'example-tag-group'
fw.add_group_tag(group_id, tag)
# Check
r_group = fw.get_group(group_id)
self.assertEqual(1, len(r_group.tags))
self.assertEqual(tag, r_group.tags[0])
self.assertGreater(r_group.modified, changed_group.modified)
# Add project
project = r_group.add_project(label='My Project')
self.assertIsNotNone(project)
fw.delete_project(project.id)
# Delete
fw.delete_group(group_id)
groups = fw.get_all_groups()
self.assertNotIn(r_group, groups)
def create_test_group():
group_id = SdkTestCase.rand_string_lower()
return SdkTestCase.fw.add_group(
flywheel.Group(group_id, label=SdkTestCase.rand_string()))
def test_container_hierarchy():
hierarchy_dict = {
"group":
flywheel.Group(id="test_group", label="Test Group"),
"project":
flywheel.Project(label="test_project"),
"subject":
flywheel.Subject(label="test_subject", sex="other"),
"session":
flywheel.Session(
age=31000000,
label="test_session",
weight=50,
),
}
# test from_dict
test_hierarchy = ContainerHierarchy.from_dict(hierarchy_dict)
# test deepcopy
assert deepcopy(test_hierarchy) != test_hierarchy
# test path
assert test_hierarchy.path == "test_group/test_project/test_subject/test_session"
# test parent
assert test_hierarchy.parent.label == "test_subject"
# test from_container
mock_client = MagicMock(spec=dir(flywheel.Client))
parent_dict = dict()
for item in ("group", "project", "subject"):
value = hierarchy_dict.copy().get(item)
parent_dict[item] = item
setattr(mock_client, f"get_{item}", lambda x: value)
session = flywheel.Session(age=31000000, label="test_session", weight=50)
session.parents = parent_dict
assert (ContainerHierarchy.from_container(
mock_client, session).container_type == "session")
# test _get_container
assert test_hierarchy._get_container(None, None, None) is None
with pytest.raises(ValueError) as exc:
test_hierarchy._get_container(None, "garbage", "garbage_id")
assert str(exc) == "Cannot get a container of type garbage"
mock_client = MagicMock(spec=dir(flywheel.Client))
mock_client.get_session = lambda x: x
assert (test_hierarchy._get_container(mock_client, "session",
"session_id") == "session_id")
# test container_type
assert test_hierarchy.container_type == "session"
# test dicom_map
exp_map = {
"PatientWeight": 50,
"PatientAge": "011M",
"ClinicalTrialTimePointDescription": "test_session",
"PatientSex": "O",
"PatientID": "test_subject",
}
assert exp_map == test_hierarchy.dicom_map
# test get
assert test_hierarchy.get("container_type") == "session"
# test get_patient_sex_from_subject
assert test_hierarchy.get_patientsex_from_subject(flywheel.Subject()) == ""
# test get_patientage_from_session
assert test_hierarchy.get_patientage_from_session(
flywheel.Session()) is None
# test get_child_hierarchy
test_acquisition = flywheel.Acquisition(label="test_acquisition")
acq_hierarchy = test_hierarchy.get_child_hierarchy(test_acquisition)
assert acq_hierarchy.dicom_map[
"SeriesDescription"] == test_acquisition.label
# test get_parent_hierarchy
parent_hierarchy = test_hierarchy.get_parent_hierarchy()
assert parent_hierarchy.container_type == "subject"