def test_recover_missing(self):
cyan = self._load_data(self.cyan)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(cyan, False)
img_fd = obj.get_root_stream().read()
self.assertIsNotNone(img_fd, 'Failed opening image')
img_fd.close()
s = obj.get_root_stream()
h.imgdb.delete(s.get_stream_id(), s.get_priority(), s.get_extension())
h.imgdb.commit()
img_fd = obj.get_root_stream().read()
self.assertIsNone(img_fd, 'Remove failed')
cyan = self._load_data(self.cyan)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(cyan, False)
img_fd = obj.get_root_stream().read()
self.assertTrue(self._diff_data(img_fd, self.cyan),
'Image not recovered')
def test_tag_album(self):
h = hdbfs.Database()
h.enable_write_access()
tag = h.make_tag('bw')
h.close()
white = self._load_data(self.white)
grey = self._load_data(self.grey)
black = self._load_data(self.black)
self._run([white, grey, black], album='bw', taglist=['bw'])
h = hdbfs.Database()
al = h.get_object_by_id(2)
wo = h.get_object_by_id(3)
lo = h.get_object_by_id(4)
ko = h.get_object_by_id(5)
self.assertTrue(isinstance(al, hdbfs.Album), 'Expected album')
query = hdbfs.query.Query()
query.add_require_constraint(hdbfs.query.TagConstraint('bw'))
it = query.execute(h).__iter__()
self.assertEqual(it.next(), al, 'Unexpected tagged item')
try:
it.next()
self.fail('Unexpected tagged item')
except StopIteration:
pass
def test_double_add(self):
green = self._load_data(self.green)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(green, False)
self.assertFalse(os.path.exists(green), 'Old image was not removed')
img_fd = obj.get_root_stream().read()
self.assertIsNotNone(img_fd, 'Failed opening image')
img_fd.close()
green = self._load_data(self.green)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(green, False)
self.assertTrue(os.path.exists(green), 'Double image was removed')
img_fd = obj.get_root_stream().read()
self.assertIsNotNone(img_fd, 'Invalid image returned after double-add')
img_fd.close()
def test_album_set_text(self):
h = hdbfs.Database()
h.enable_write_access()
album = h.create_album()
album.set_text('This is some test text')
obj_id = album.get_id()
h = hdbfs.Database()
album = h.get_object_by_id(obj_id)
self.assertEqual(album.get_text(), 'This is some test text',
'Album text not properly returned')
def subtest_ensure_files_present(self, ver):
h = hdbfs.Database()
files = self._lookup(h, type=hdbfs.TYPE_FILE)
self.assertEqual(len(files), 8, 'Unexpected number of files in DB')
for f in files:
self.assertTrue(isinstance(f, hdbfs.File),
'Unexpected file type found %s' % (str(type(f))))
fnames = map(lambda x: x.get_name(), files)
self.assertTrue(self.magenta in fnames, 'Magenta not found')
self.assertTrue(self.red in fnames, 'Red not found')
self.assertTrue(self.yellow in fnames, 'Yellow not found')
self.assertTrue(self.green in fnames, 'Green not found')
self.assertTrue(self.cyan in fnames, 'Cyan not found')
self.assertTrue(self.blue in fnames, 'Blue not found')
if (ver == (
1,
0,
)):
self.assertTrue(self.white in fnames, 'White not found')
else:
self.assertTrue(None in fnames, 'White not found')
self.assertTrue(self.grey in fnames, 'Grey not found')
def subtest_check_album(self, ver):
h = hdbfs.Database()
if (ver[0] < 2):
cl_al = self._single(h, type=hdbfs.TYPE_ALBUM)
self.assertTrue(isinstance(cl_al, hdbfs.Album),
'Unexpected type found %s' % (str(type(cl_al))))
cl_files = cl_al.get_files()
self.assertEqual(len(cl_files), 5,
'Unexpected number of files in colour album')
else:
cl_al = self._single(h, ['colour_album'])
bw_al = self._single(h, ['white_blue_album'])
self.assertTrue(isinstance(cl_al, hdbfs.Album),
'Unexpected type found %s' % (str(type(cl_al))))
self.assertTrue(isinstance(cl_al, hdbfs.Album),
'Unexpected type found %s' % (str(type(bw_al))))
cl_files = cl_al.get_files()
bw_files = bw_al.get_files()
self.assertEqual(len(cl_files), 6,
'Unexpected number of files in colour album')
self.assertEqual(len(bw_files), 2,
'Unexpected number of files in white/blue album')
def test_thumbs_not_moved_with_existing(self):
red = self._load_data(self.red)
blue = self._load_data(self.blue)
h = hdbfs.Database()
h.enable_write_access()
o1 = h.register_file(blue, False)
o2 = h.register_file(red, False)
t1_4_hash = o1.get_thumb_stream(4).get_hash()
t1_5_hash = o1.get_thumb_stream(5).get_hash()
t2_4_hash = o2.get_thumb_stream(4).get_hash()
t2_5_hash = o2.get_thumb_stream(5).get_hash()
h.merge_objects(o1, o2)
tx_4_hash = o1.get_thumb_stream(4).get_hash()
tx_5_hash = o1.get_thumb_stream(5).get_hash()
self.assertTrue(tx_4_hash == t1_4_hash,
'New thumb not matching from o1')
self.assertTrue(tx_5_hash == t1_5_hash,
'New thumb not matching from o1')
self.assertFalse(tx_4_hash == t2_4_hash,
'New thumb matches moved from o2')
self.assertFalse(tx_5_hash == t2_5_hash,
'New thumb matches moved from o2')
def test_albums_moved(self):
red = self._load_data(self.red)
yellow = self._load_data(self.yellow)
green = self._load_data(self.green)
blue = self._load_data(self.blue)
h = hdbfs.Database()
h.enable_write_access()
album = h.create_album()
ro = h.register_file(red, False)
yo = h.register_file(yellow, False)
go = h.register_file(green, False)
bo = h.register_file(blue, False)
yo.assign(album, 2)
bo.assign(album, 3)
ro.assign(album, 1)
h.merge_objects(go, yo)
files = album.get_files()
self.assertEqual(len(files), 3, 'Album size mismatch')
self.assertEqual(files[0], ro, 'Red not first in album')
self.assertEqual(files[1], go, 'Green not second in album')
self.assertEqual(files[2], bo, 'Blue not third in album')
def test_tags_moved(self):
red = self._load_data(self.red)
green = self._load_data(self.green)
blue = self._load_data(self.blue)
h = hdbfs.Database()
h.enable_write_access()
tag1 = h.make_tag('a_tag')
tag2 = h.make_tag('b_tag')
tag3 = h.make_tag('c_tag')
ro = h.register_file(red, False)
go = h.register_file(green, False)
bo = h.register_file(blue, False)
ro.assign(tag1)
go.assign(tag1)
go.assign(tag2)
bo.assign(tag3)
h.merge_objects(ro, go)
h.merge_objects(ro, bo)
self.assertEqual(len(ro.get_tags()), 3, 'Red tag list mismatch')
tags = ro.get_tags()
self.assertTrue(tag1 in tags, 'tag1 not in dup list')
self.assertTrue(tag2 in tags, 'tag2 not in dup list')
self.assertTrue(tag3 in tags, 'tag3 not in dup list')
def run(self, max_exp, force=False, sleep=None):
db = hdbfs.Database()
try:
db.enable_write_access()
obj = self.__pop_object(db)
if (obj is None):
return
if (isinstance(obj, hdbfs.ImageFile)):
print 'Generating thumbs and meta for file', obj.get_id()
obj.check_metadata()
exp = hdbfs.imgdb.MIN_THUMB_EXP
while (db.tbcache.make_thumb(obj, exp) is not None
and exp <= max_exp):
exp += 1
if (sleep is not None):
time.sleep(sleep)
elif (isinstance(obj, hdbfs.Album)):
print 'Generating metadata for album', obj.get_id()
obj.check_metadata()
db.tbcache.init_album_metadata(obj)
if (sleep is not None):
time.sleep(sleep)
finally:
db.close()
def test_variants_moved(self):
red = self._load_data(self.red)
yellow = self._load_data(self.yellow)
green = self._load_data(self.green)
blue = self._load_data(self.blue)
h = hdbfs.Database()
h.enable_write_access()
ro = h.register_file(red, False)
yo = h.register_file(yellow, False)
go = h.register_file(green, False)
bo = h.register_file(blue, False)
yo.set_variant_of(ro)
bo.set_variant_of(go)
h.merge_objects(ro, go)
self.assertEqual(len(ro.get_variants_of()), 0, 'Red is a variant')
self.assertEqual(len(yo.get_variants_of()), 1,
'Yellow is not a variant')
self.assertEqual(len(bo.get_variants_of()), 1, 'Blue is not a variant')
self.assertEqual(len(ro.get_duplicate_streams()), 1,
'Red duplicate list mismatch')
self.assertEqual(len(ro.get_variants()), 2,
'Red variant list mismatch')
variants = ro.get_variants()
self.assertTrue(yo in variants, 'Yellow not in variant list')
self.assertTrue(bo in variants, 'Blue not in variant list')
def test_recover_missing_file(self):
black = self._load_data(self.black)
self._run(black)
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertFalse(obj is None, 'Image not in DB')
s = obj.get_root_stream()
h.imgdb.delete(s.get_stream_id(), s.get_priority(), s.get_extension())
h.imgdb.commit()
img_fd = obj.get_root_stream().read()
self.assertFalse(img_fd is not None, 'Remove failed')
black = self._load_data(self.black)
self._run(black, recover=True)
self.assertTrue(
self._diff_data(obj.get_root_stream().read(), self.black),
'Image not recovered')
self.assertFalse(os.path.exists(black),
'Recovery image was not removed')
def test_tag_multi_file(self):
red = self._load_data(self.red)
green = self._load_data(self.green)
blue = self._load_data(self.blue)
h = hdbfs.Database()
h.enable_write_access()
ro = h.register_file(red, False)
go = h.register_file(green, False)
bo = h.register_file(blue, False)
mt = h.make_tag('magenta')
yt = h.make_tag('yellow')
ct = h.make_tag('cyan')
ro.assign(mt)
bo.assign(mt)
ro.assign(yt)
go.assign(yt)
go.assign(ct)
bo.assign(ct)
magenta = mt.get_files()
yellow = yt.get_files()
cyan = ct.get_files()
self.assertEqual(len(magenta), 2,
'Unexpected number of files (magenta)')
self.assertEqual(len(yellow), 2, 'Unexpected number of files (yellow)')
self.assertEqual(len(cyan), 2, 'Unexpected number of files (cyan)')
self.assertTrue(ro in magenta, 'Red not in magenta')
self.assertTrue(bo in magenta, 'Blue not in magenta')
self.assertTrue(ro in yellow, 'Red not in yellow')
self.assertTrue(go in yellow, 'Green not in yellow')
self.assertTrue(go in cyan, 'Green not in cyan')
self.assertTrue(bo in cyan, 'Blue not in cyan')
red_in = ro.get_tags()
green_in = go.get_tags()
blue_in = bo.get_tags()
self.assertEqual(len(red_in), 2, 'Unexpected number of tags (red)')
self.assertEqual(len(green_in), 2, 'Unexpected number of tags (green)')
self.assertEqual(len(blue_in), 2, 'Unexpected number of tags (blue)')
self.assertTrue(mt in red_in, 'Red does not have magenta')
self.assertTrue(yt in red_in, 'Red does not have yellow')
self.assertTrue(yt in green_in, 'Green does not have yellow')
self.assertTrue(ct in green_in, 'Green does not have cyan')
self.assertTrue(mt in blue_in, 'Blue does not have magenta')
self.assertTrue(ct in blue_in, 'Blue does not have cyan')
def test_create_tag(self):
h = hdbfs.Database()
black = self._load_data(self.black)
self._run(black, newtags=['black'])
h = hdbfs.Database()
try:
tag = h.get_tag('black')
except KeyError:
self.fail('Failed creating tag')
except StopIteration:
pass
files = tag.get_files()
self.assertEqual(len(files), 1, 'Unexpected number of files')
def subtest_check_single_names(self, ver):
h = hdbfs.Database()
red = self._single(h, ['red'])
names = red.get_origin_names()
self.assertEqual(red.get_name(), self.red, 'Unexpected name')
self.assertTrue(self.red in names, 'Name not found')
def test_create_tag(self):
h = hdbfs.Database()
h.enable_write_access()
tag = h.make_tag('a_tag')
tag2 = h.get_tag('a_tag')
self.assertEqual(tag.get_id(), tag2.get_id(), 'Tag ID mismatch')
def test_fetch_missing_tag(self):
h = hdbfs.Database()
try:
h.get_tag('tag_that_doesnt_exist')
self.fail('Did not except on missing tag')
except KeyError:
pass
def subtest_check_multi_names(self, ver):
h = hdbfs.Database()
grey = self._single(h, ['grey'])
names = grey.get_origin_names()
self.assertTrue(self.grey in names, 'Primary name not found')
self.assertTrue('grey_sq2.png' in names, 'Secondary name not found')
def test_name2(self):
black = self._load_data(self.black)
self._run(black, name='setundef')
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertFalse(obj is None, 'Image not in DB')
self.assertEqual(obj.get_name(), self.black, 'Name not loaded')
def test_no_name(self):
black = self._load_data(self.black)
self._run(black, name='noset')
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertFalse(obj is None, 'Image not in DB')
self.assertTrue(obj.get_name() is None, 'Name loaded')
def test_duplicate_name(self):
grey = self._load_data(self.grey)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(grey)
grey2 = self._load_data(self.grey)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(grey2)
names = obj.get_origin_names()
self.assertTrue(self.grey in names, 'Name not loaded')
self.assertEqual(len(names), 1, 'Name count does not match')
def test_tag_file(self):
h = hdbfs.Database()
h.enable_write_access()
tag = h.make_tag('black')
files = tag.get_files()
self.assertEqual(len(files), 0, 'Unexpected number of files')
h.close()
black = self._load_data(self.black)
self._run(black, taglist=['black'])
h = hdbfs.Database()
tag = h.get_tag('black')
files = tag.get_files()
self.assertEqual(len(files), 1, 'Unexpected number of files')
def test_different_names(self):
grey = self._load_data(self.grey)
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(grey)
grey2 = self._load_data(self.grey, 'altname.png')
h = hdbfs.Database()
h.enable_write_access()
obj = h.register_file(grey2)
names = obj.get_origin_names()
self.assertTrue(self.grey in names, 'First name not loaded')
self.assertTrue('altname.png' in names, 'Second name not loaded')
self.assertEqual(len(names), 2, 'Name count does not match')
def test_recover_not_in_db(self):
black = self._load_data(self.black)
self._run(black, recover=True)
self.assertTrue(os.path.exists(black), 'Image was removed')
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertTrue(obj is None, 'Image in DB')
def test_create_album(self):
h = hdbfs.Database()
h.enable_write_access()
obj_id = h.create_album().get_id()
album = h.get_object_by_id(obj_id)
self.assertIsNotNone(album, 'Unable to get album after creation')
self.assertTrue(isinstance(album, hdbfs.Group),
'Created album is not a group')
def test_add(self):
black = self._load_data(self.black)
self._run(black)
self.assertFalse(os.path.exists(black), 'Old image was not removed')
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertFalse(obj is None, 'Image not in DB')
def subtest_check_album_text(self, ver):
if (ver[0] < 5):
return
h = hdbfs.Database()
album = self._single(h, ['white_blue_album'])
self.assertEqual(album.get_text(), 'White & Blue',
'Text mismatch in album')
def subtest_check_dup_moved(self, ver):
h = hdbfs.Database()
grey = self._single(h, ['grey'])
grey2 = self._single(h, ['black'])
self.assertEqual(grey, grey2, 'Black tag not moved')
self.assertEqual(len(grey.get_variants()), 1,
'Unexpected variant count')
self.assertEqual(grey.get_variants()[0].get_name(), self.blue,
'Blue not moved as black\'s variant')
def subtest_ensure_files_have_timestamp(self, ver):
h = hdbfs.Database()
files = self._lookup(h, type=hdbfs.TYPE_FILE)
now = datetime.datetime.utcnow()
for f in files:
self.assertTrue(
now - f.get_creation_time_utc() <
datetime.timedelta(minutes=5),
'Unexpected timestamp in file, %r' %
(f.get_creation_time_utc(), ))
def test_load_name(self):
black = self._load_data(self.black)
self._run(black, name='noset')
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertFalse(obj is None, 'Image not in DB')
self.assertTrue(obj.get_name() is None,
'Name loaded when it shouldn\'t have been')
h.close()
black = self._load_data(self.black)
self._run(black)
h = hdbfs.Database()
obj = h.get_object_by_id(1)
self.assertEqual(obj.get_name(), self.black, 'name not loaded')
