示例#1
0
    def setUpClass(cls):
        cls.view_id = None
        cls.group_id, cls.project_id, cls.session_id, cls.acquisition_id = create_test_acquisition()
        
        # Get user id
        user = cls.fw.get_current_user()
        cls.user_id = user.id

        cls.session = cls.fw.get_session(cls.session_id)
        cls.subject = cls.session.subject
示例#2
0
 def setUp(self):
     self.group_id, self.project_id, self.session_id, self.acquisition_id = create_test_acquisition(
     )
     self.gear_id = create_test_gear()
示例#3
0
 def setUp(self):
     self.group_id, self.project_id, self.session_id, self.acquisition_id = create_test_acquisition()
     self.tmpfile = None
示例#4
0
 def setUp(self):
     self.group_id, self.project_id, self.subject_id, self.session_id, self.acquisition_id = create_test_acquisition(
         return_subject=True)
     self.gear_id = None
示例#5
0
 def createDestination(self):
     self.group_id, self.project_id, self.session_id, self.acquisition_id = create_test_acquisition(
     )
     self.context.destination['id'] = self.acquisition_id
示例#6
0
    def test_collections(self):
        fw = self.fw

        collection_name = self.rand_string()
        collection = flywheel.Collection(label=collection_name,
                                         description=self.rand_string())

        # Add
        self.collection_id = collection_id = fw.add_collection(collection)
        self.assertNotEmpty(collection_id)

        # Get
        saved_collection = fw.get_collection(collection_id)
        self.assertEqual(saved_collection.id, collection_id)
        self.assertEqual(saved_collection.label, collection_name)
        self.assertEqual(saved_collection.description, collection.description)
        self.assertTimestampBeforeNow(saved_collection.created)
        self.assertGreaterEqual(saved_collection.modified,
                                saved_collection.created)

        # Generic Get is equivalent
        self.assertEqual(
            fw.get(collection_id).to_dict(), saved_collection.to_dict())

        # Add acquisition to the collection
        group_id, project_id, session_id, acquisition_id = create_test_acquisition(
        )
        self.group_ids.append(group_id)
        self.project_ids.append(project_id)
        saved_collection.add_acquisitions(acquisition_id)

        # Get sessions
        saved_sessions = saved_collection.sessions()
        self.assertEqual(len(saved_sessions), 1)
        self.assertEqual(saved_sessions[0].id, session_id)

        # Get acquisitions
        saved_acquisitions = saved_collection.acquisitions()
        self.assertEqual(len(saved_acquisitions), 1)
        self.assertEqual(saved_acquisitions[0].id, acquisition_id)

        # Get session acquisitions
        saved_session_acquisitions = fw.get_collection_acquisitions(
            collection_id, session=session_id)
        self.assertEqual(len(saved_session_acquisitions), 1)
        self.assertEqual(saved_session_acquisitions[0].id, acquisition_id)

        # Add session to the collection
        group_id, project_id, session_id2, acquisition_id2 = create_test_acquisition(
        )
        self.group_ids.append(group_id)
        self.project_ids.append(project_id)
        saved_collection.add_sessions(session_id2)
        saved_collection = saved_collection.reload()

        # Get sessions
        saved_sessions = saved_collection.sessions()
        self.assertEqual(len(saved_sessions), 2)
        self.assertEqual(
            len(list(filter(lambda x: x.id == session_id, saved_sessions))), 1)
        self.assertEqual(
            len(list(filter(lambda x: x.id == session_id2, saved_sessions))),
            1)

        # Get acquisitions
        saved_acquisitions = saved_collection.acquisitions()
        self.assertEqual(len(saved_acquisitions), 2)
        self.assertEqual(
            len(
                list(
                    filter(lambda x: x.id == acquisition_id,
                           saved_acquisitions))), 1)
        self.assertEqual(
            len(
                list(
                    filter(lambda x: x.id == acquisition_id2,
                           saved_acquisitions))), 1)

        # Get session acquisitions
        saved_session_acquisitions = fw.get_collection_acquisitions(
            collection_id, session=session_id)
        self.assertEqual(len(saved_session_acquisitions), 1)
        self.assertEqual(saved_session_acquisitions[0].id, acquisition_id)

        # Get All
        saved_collection = saved_collection.reload()  # Clear internal state
        collections = fw.get_all_collections()
        self.sanitize_for_collection(saved_collection, info_exists=False)
        self.assertIn(saved_collection, collections)

        # Modify
        new_name = self.rand_string()
        saved_collection.update(label=new_name)

        changed_collection = saved_collection.reload()
        self.assertEqual(changed_collection.label, new_name)
        self.assertEqual(changed_collection.created, saved_collection.created)
        self.assertGreater(changed_collection.modified,
                           saved_collection.modified)

        # Add note
        message = 'This is a note'
        saved_collection.add_note(message)

        tag = 'example-tag'
        saved_collection.add_tag(tag)

        # Replace Info
        saved_collection.replace_info({'foo': 3, 'bar': 'qaz'})

        # Set Info
        saved_collection.update_info({'foo': 42, 'hello': 'world'})

        # Check
        changed_collection = saved_collection.reload()

        self.assertEqual(len(changed_collection.notes), 1)
        self.assertEqual(changed_collection.notes[0].text, message)

        self.assertEqual(len(changed_collection.tags), 1)
        self.assertEqual(changed_collection.tags[0], tag)

        self.assertEqual(changed_collection.info['foo'], 42)
        self.assertEqual(changed_collection.info['bar'], 'qaz')
        self.assertEqual(changed_collection.info['hello'], 'world')

        # Delete info fields
        saved_collection.delete_info(['foo', 'bar'])

        changed_collection = saved_collection.reload()
        self.assertNotIn('foo', changed_collection.info)
        self.assertNotIn('bar', changed_collection.info)
        self.assertEqual(changed_collection.info['hello'], 'world')

        # Delete
        fw.delete_collection(collection_id)
        self.collection_id = None

        collections = fw.get_all_collections()
        self.sanitize_for_collection(changed_collection)
        self.assertNotIn(changed_collection, collections)