def test_saveNewItemWithFileOutsideRepo(self):
'''
User wants to add an external file into the repo. File is copied to the repo.
'''
item = db.Item("user", "Item's title")
self.srcAbsPath = os.path.abspath(
os.path.join(self.repo.base_path, "..", "tmp", "file.txt"))
self.dstRelPath = os.path.join("dir1", "dir2", "dir3", "newFile.txt")
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item, self.srcAbsPath,
self.dstRelPath)
self.savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
try:
uow = self.repo.createUnitOfWork()
savedItem = uow.executeCommand(
cmds.GetExpungedItemCommand(self.savedItemId))
self.assertEqual(savedItem.title, item.title)
self.assertIsNotNone(savedItem.data_ref)
self.assertEqual(savedItem.data_ref.url_raw,
hlp.to_db_format(self.dstRelPath))
self.assertTrue(
os.path.exists(
os.path.join(self.repo.base_path, savedItem.data_ref.url)))
self.assertTrue(os.path.exists(self.srcAbsPath))
finally:
uow.close()
def test_saveNewItemWithACopyOfAStoredFileInRepo(self):
'''
User wants to add a copy of a stored file from the repo into the same repo
but to the another location. The copy of the original file will be attached
to the new Item object.
'''
item = db.Item("user", "Item's title")
self.srcAbsPath = os.path.abspath(
os.path.join(self.repo.base_path, "lyrics", "led_zeppelin",
"stairway_to_heaven.txt"))
self.dstRelPath = os.path.join("dir1", "dir2", "dir3",
"copy_of_stairway_to_heaven.txt")
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item, self.srcAbsPath,
self.dstRelPath)
self.savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
try:
uow = self.repo.createUnitOfWork()
savedItem = uow.executeCommand(
cmds.GetExpungedItemCommand(self.savedItemId))
self.assertEqual(savedItem.title, item.title)
self.assertIsNotNone(savedItem.data_ref)
self.assertEqual(savedItem.data_ref.url_raw,
hlp.to_db_format(self.dstRelPath))
self.assertTrue(
os.path.exists(
os.path.join(self.repo.base_path, savedItem.data_ref.url)))
self.assertTrue(os.path.exists(self.srcAbsPath))
finally:
uow.close()
def test_saveNewItemWithFileInsideRepo(self):
'''
There is an untracked file inside the repo tree. User wants to add such file
into the repo to make it a stored file. File is not copied, because it is alredy in
the repo tree. It's essential that srcAbsPath and dstRelPath point to the same file.
'''
item = db.Item("user", "Item's title")
self.srcAbsPath = os.path.abspath(
os.path.join(self.repo.base_path, "this", "is", "untracked",
"file.txt"))
self.dstRelPath = os.path.join("this", "is", "untracked", "file.txt")
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item, self.srcAbsPath,
self.dstRelPath)
self.savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
try:
uow = self.repo.createUnitOfWork()
savedItem = uow.executeCommand(
cmds.GetExpungedItemCommand(self.savedItemId))
self.assertEqual(savedItem.title, item.title)
self.assertIsNotNone(savedItem.data_ref)
self.assertEqual(savedItem.data_ref.url_raw,
hlp.to_db_format(self.dstRelPath))
self.assertTrue(
os.path.exists(
os.path.join(self.repo.base_path, savedItem.data_ref.url)))
finally:
uow.close()
def doWork(self):
logger.info(
"CreateGroupOfItemsThread is going to process {} items".format(
len(self.items)))
self.skippedCount = 0
self.createdCount = 0
uow = self.repo.createUnitOfWork()
try:
i = 0
for item in self.items:
try:
#Every item is saved in a separate transaction
srcAbsPath = None
dstRelPath = None
if item.data_ref:
srcAbsPath = item.data_ref.srcAbsPath
dstRelPath = item.data_ref.dstRelPath
savedItemId = uow.executeCommand(
cmds.SaveNewItemCommand(item, srcAbsPath, dstRelPath))
self.lastSavedItemIds.append(savedItemId)
self.createdCount += 1
except (ValueError, errors.DataRefAlreadyExistsError):
self.skippedCount += 1
i = i + 1
self.emit(QtCore.SIGNAL("progress"),
int(100.0 * float(i) / len(self.items)))
finally:
uow.close()
def test_saveNewItemByEmptyUserLogin(self):
userLogin = ""
item = db.Item(userLogin, "Item's title")
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item)
self.assertRaises(err.AccessError, uow.executeCommand, (cmd))
finally:
uow.close()
def doWork(self):
srcArchive = TarFile.open(self.srcFile, "r", format=tarfile.PAX_FORMAT)
try:
filenames = self.__getListOfMetadataFiles(srcArchive)
for i in range(len(filenames)):
filename = filenames[i]
#Restore item from json state
itemStateBytes = srcArchive.extractfile(filename).read()
itemState = str(itemStateBytes, encoding="utf-8")
item = memento.Decoder().decode(itemState)
#Imported item will be owned by that user, who is performing the import
item.user_login = self.userLogin
#Move physical file to repository
dstAbsPath = None
if item.data_ref is not None:
dstAbsPath = os.path.join(self.repo.base_path,
item.data_ref.url)
if os.path.exists(dstAbsPath):
#Skip this item. Count and remember this error
continue
srcArchive.extract(item.data_ref.url_raw,
path=self.repo.base_path)
uow = self.repo.createUnitOfWork()
try:
itemSrcAbsPath = dstAbsPath
itemDstRelPath = os.path.relpath(dstAbsPath, self.repo.base_path) \
if dstAbsPath is not None else None
cmd = cmds.SaveNewItemCommand(item, itemSrcAbsPath,
itemDstRelPath)
uow.executeCommand(cmd)
except Exception:
if dstAbsPath is not None:
os.remove(dstAbsPath)
#count and remember error details to show it later in GUI
finally:
uow.close()
self.emit(QtCore.SIGNAL("progress"),
int(100.0 * float(i) / len(filenames)))
finally:
srcArchive.close()
def test_saveNewMinimalItem(self):
# "Minimal item" here means that this item has no data references, tags or fields
item = db.Item("user", "Minimal Item")
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item)
self.savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
try:
uow = self.repo.createUnitOfWork()
savedItem = uow.executeCommand(
cmds.GetExpungedItemCommand(self.savedItemId))
self.assertEqual(savedItem.title, item.title)
finally:
uow.close()
def addSingleItem(tool, dialogs, file=None):
'''
Creates and saves in repo an Item linked with a given file (or without file).
Returns id of saved Item, or raises an exception.
'''
savedItemId = None
item = db.Item(user_login=tool.user.login)
if not hlp.is_none_or_empty(file):
file = os.path.normpath(file)
item.title, _ = os.path.splitext(os.path.basename(file))
item.data_ref = db.DataRef(objType=db.DataRef.FILE, url=file)
if not dialogs.execItemDialog(item=item,
gui=tool.gui,
repo=tool.repo,
dialogMode=ItemDialog.CREATE_MODE):
raise err.CancelOperationError("User cancelled operation.")
uow = tool.repo.createUnitOfWork()
try:
srcAbsPath = None
dstRelPath = None
if item.data_ref is not None:
srcAbsPath = item.data_ref.srcAbsPath
dstRelPath = item.data_ref.dstRelPath
cmd = cmds.SaveNewItemCommand(item, srcAbsPath, dstRelPath)
thread = BackgrThread(tool.gui, uow.executeCommand, cmd)
dialogs.startThreadWithWaitDialog(thread,
tool.gui,
indeterminate=True)
savedItemId = thread.result
finally:
uow.close()
return savedItemId
def test_saveNewItemWithFields(self):
userLogin = "******"
item = db.Item(userLogin, "Item with fields")
fieldOne = ("Year", 2012)
fieldTwo = ("No items in test repo with such Field!", "Some value")
item.setFieldValue(fieldOne[0], fieldOne[1], userLogin)
item.setFieldValue(fieldTwo[0], fieldTwo[1], userLogin)
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item)
savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
savedItem = self.getExistingItem(savedItemId)
self.assertEqual(savedItem.title, item.title)
self.assertTrue(savedItem.hasField(fieldOne[0], fieldOne[1]))
self.assertTrue(savedItem.hasField(fieldTwo[0], fieldTwo[1]))
self.assertEqual(len(savedItem.item_fields), 2)
def test_saveNewItemWithTags(self):
userLogin = "******"
item = db.Item(userLogin, "Item with tags")
tagNameThatExistsInRepo = "Lyrics"
tagNameNew = "No items in test repo with such Tag!"
item.addTag(tagNameThatExistsInRepo, userLogin)
item.addTag(tagNameNew, userLogin)
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item)
savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
savedItem = self.getExistingItem(savedItemId)
self.assertEqual(savedItem.title, item.title)
self.assertTrue(savedItem.hasTag(tagNameThatExistsInRepo))
self.assertTrue(savedItem.hasTag(tagNameNew))
self.assertEqual(len(savedItem.item_tags), 2)
