Пример #1
0
 def test_Keep_accepts_bsonBinary(self):
     from niprov.pictures import PictureCache
     myImg = Mock()
     myImg.provenance = {'id':'007'}
     pictures = PictureCache(sentinel.dependencies)
     pictures.keep(bson.Binary('/x10/x05/x5f'), for_=myImg)
     self.assertEqual('/x10/x05/x5f', pictures.getBytes(for_=myImg))
Пример #2
0
 def test_update(self):
     self.setupRepo()
     img = Mock()
     img.provenance = {'a':1, 'b':2}
     self.repo.update(img)
     self.db.provenance.update.assert_called_with(
         {'location':img.location.toString()}, {'a':1, 'b':2})
Пример #3
0
 def test_copiesOf(self):
     from niprov.querying import Query
     target = Mock()
     target.provenance = {'hash':'a7b8c9', 'size':1}
     q = Query(self.dependencies).copiesOf(target)
     self.assertEqual(1, len(q.getFields()))
     self.assertEqual('hash', q.getFields()[0].name)
     self.assertEqual('a7b8c9', q.getFields()[0].value)
Пример #4
0
 def test_If_no_snapshot_doesnt_add_data_field(self):
     self.pictureCache.getBytes.return_value = None
     with patch('niprov.mongo.bson') as bson:
         self.setupRepo()
         img = Mock()
         img.provenance = {'a':1}
         self.repo.add(img)
         assert not bson.Binary.called
         self.db.provenance.insert_one.assert_called_with({'a':1})
Пример #5
0
 def test_Stored_picture_can_be_retrieved_as_filepath(self):
     from niprov.pictures import PictureCache
     myImg = Mock()
     myImg.provenance = {'id':'007'}
     pictures = PictureCache(sentinel.dependencies)
     self.assertIsNone(pictures.getFilepath(for_=myImg))
     pictures.keep(io.BytesIO('/x10/x05/x5f'), for_=myImg)
     picfpath = os.path.expanduser('~/.niprov-snapshots/007.png')
     self.assertEqual(picfpath, pictures.getFilepath(for_=myImg))
Пример #6
0
 def test_If_pic_is_not_in_cache_but_on_filesystem_provides_that(self):
     import niprov.pictures
     myImg = Mock()
     myImg.provenance = {'id':'007'}
     pictures = niprov.pictures.PictureCache(sentinel.dependencies)
     pictures.keep(io.BytesIO('/x10/x05/x5f'), for_=myImg)
     pictures.saveToDisk(for_=myImg)
     niprov.pictures._CACHE = {} # reset cache
     picfpath = os.path.expanduser('~/.niprov-snapshots/007.png')
     self.assertEqual(picfpath, pictures.getFilepath(for_=myImg))
Пример #7
0
 def test_Stored_picture_can_be_retrieved_as_bytes(self):
     from niprov.pictures import PictureCache
     myImg = Mock()
     myImg.provenance = {'id':'007'}
     pictures = PictureCache(sentinel.dependencies)
     newPicture = pictures.new()
     newPicture.write('/x10/x05/x5f')
     pictures.keep(newPicture, for_=myImg)
     outBytes = pictures.getBytes(for_=myImg)
     self.assertEqual('/x10/x05/x5f', outBytes)
Пример #8
0
 def test_keepVersionsFromPrevious(self):
     img = self.constructor(self.path, dependencies=self.dependencies)
     prev = Mock()
     prev.provenance = {'y':1501, '_versions':[{'y':1499},{'y':1500}]}
     img.keepVersionsFromPrevious(prev)
     self.assertEqual('new-version', img.status)
     self.assertEqual(3, len(img.provenance['_versions']))
     self.assertEqual({'y':1501}, img.provenance['_versions'][-1])
     self.assertEqual({'y':1500}, img.provenance['_versions'][-2])
     self.assertEqual({'y':1499}, img.provenance['_versions'][-3])
Пример #9
0
 def test_Found_copy_set_as_parent_inherits_and_flags_and_informs_listener(self):
     self.img.provenance = {}
     copy = Mock()
     copy.provenance = {'location':'copy-location'}
     self.query.copiesOf.return_value = [self.img, copy]
     out = self.add('p/afile.f')
     self.inheritFrom.assert_called_with(self.img.provenance, copy.provenance)
     self.listener.usingCopyAsParent.assert_called_with(copy)
     self.assertEqual(copy.location.toString(), out.provenance['parents'][0])
     self.assertEqual(True, out.provenance['copy-as-parent'])
Пример #10
0
 def test_Can_be_told_to_persist_picture_to_disk_now(self):
     from niprov.pictures import PictureCache
     myImg = Mock()
     myImg.provenance = {'id':'007'}
     pictures = PictureCache(sentinel.dependencies)
     pictures.saveToDisk(for_=myImg) #shouldn't do anything
     pictures.keep(io.BytesIO('/x10/x05/x5f'), for_=myImg)
     pictures.saveToDisk(for_=myImg)
     picfpath = os.path.expanduser('~/.niprov-snapshots/007.png')
     self.assertTrue(os.path.isfile(picfpath))
     with open(picfpath) as picFile:
         self.assertEqual(picFile.read(), '/x10/x05/x5f')
Пример #11
0
 def test_Obtains_optional_snapshot_data_from_cache_when_serializing(self):
     self.pictureCache.getBytes.return_value = sentinel.snapbytes
     with patch('niprov.mongo.bson') as bson:
         bson.Binary.return_value = sentinel.snapbson
         self.setupRepo()
         img = Mock()
         img.provenance = {'a':1}
         self.repo.add(img)
         self.pictureCache.getBytes.assert_called_with(for_=img)
         bson.Binary.assert_called_with(sentinel.snapbytes)
         self.db.provenance.insert_one.assert_called_with({'a':1, 
             '_snapshot-data':sentinel.snapbson})
Пример #12
0
 def test_updateApproval(self):
     from niprov.jsonfile import JsonFile
     repo = JsonFile(self.dependencies)
     img = Mock()
     img.provenance = {'fiz':'baf','approval':'notsure'}
     def assertion(img):
         self.assertEqual({'fiz':'baf','approval':'excellent!'}, img.provenance)
     repo.byLocation = Mock()
     repo.byLocation.return_value = img
     repo.update = Mock()
     repo.update.side_effect = assertion
     repo.updateApproval('/p/f1','excellent!')
Пример #13
0
 def test_File(self):
     from niprov.formatnarrated import NarratedFormat
     img = Mock()
     p = {}
     p['protocol'] = 'T1'
     p['acquired'] = datetime(2013, 9, 7, 11, 27, 34)
     p['subject'] = 'John Doe'
     p['size'] = 345123
     img.provenance = p
     storyteller = NarratedFormat()
     self.assertEqual(storyteller.serializeSingle(img), ("This is a T1 image. "
         "It was recorded September 7, 2013. "
         "The participant's name is John Doe. "
         "It is 345KB in size. "))
Пример #14
0
 def test_fileAdded(self):
     from niprov.commandline import Commandline
     self.dependencies.config.verbosity = 'info'
     cmd = Commandline(self.dependencies)
     cmd.log = Mock()
     img = Mock()
     img.path = 'xyz'
     img.status = 'new'
     cmd.fileAdded(img)
     cmd.log.assert_called_with('info', 'New file: xyz')
     img.status = 'series-new-file'
     img.provenance = {'filesInSeries':[1, 2, 3]}
     img.getSeriesId.return_value = 'series987'
     cmd.fileAdded(img)
     cmd.log.assert_called_with('info', 'Added 3rd file to series: series987')
     img.status = 'new-version'
     cmd.fileAdded(img)
     cmd.log.assert_called_with('info', 'Added new version for: xyz')
Пример #15
0
 def aFile(self):
     somefile = Mock()
     somefile.provenance = {'a':'b'}
     return somefile
Пример #16
0
 def aFile(self):
     somefile = Mock()
     somefile.provenance = {}
     somefile.location.toUrl.return_value = 'xkcd://HAL/location.loc'
     return somefile
Пример #17
0
 def fileWithLocation(self, loc):
     f = Mock()
     f.location.toString.return_value = loc
     f.provenance = {}
     return f
Пример #18
0
 def mockImg(self):
     img = Mock()
     img.provenance = {}
     return img
Пример #19
0
 def test_Add(self):
     self.setupRepo()
     img = Mock()
     img.provenance = {'a':1, 'b':2}
     self.repo.add(img)
     self.db.provenance.insert_one.assert_called_with({'a':1, 'b':2})
Пример #20
0
 def imageWithProvenance(self, prov):
     img = Mock()
     img.provenance = prov
     if 'location' in prov:
         img.location.toString.return_value = prov['location']
     return img
Пример #21
0
 def fileWithLocationAndParents(self, loc, parents):
     f = Mock()
     f.location.toString.return_value = loc
     f.provenance = {'parents':parents}
     f.parents = parents
     return f
Пример #22
0
 def test_copiesOf_returns_empty_list_for_size_0_file(self):
     from niprov.querying import Query
     target = Mock()
     target.provenance = {'size':0}
     results = Query(self.dependencies).copiesOf(target)
     self.assertEqual(0, len(results))