public void getAndAssertChildren(ObjectsHierarchy hierarchy, string filter, int skipCount, int maxItems, RenditionData renditionData)
{
string[] foldersIds = hierarchy.FolderIds.ToArray();
string[] documentsIds = hierarchy.DocumentIds.ToArray();
string[] allCreatedObjectsIds = hierarchy.toIdsArray();
string rootFolderId = hierarchy.RootFolder.ObjectId;
cmisObjectInFolderListType children = getAndAssertChildren(rootFolderId, filter, null, maxItems, skipCount, renditionData != null ? renditionData.getFilter() : null);
cmisObjectType[] childrenObjects = new cmisObjectType[children.objects.Length];
for (int i = 0; i < children.objects.Length; ++i)
{
childrenObjects[i] = children.objects[i] != null ? children.objects[i].@object : null;
}
if (maxItems > 0)
{
int resultCount = (skipCount + maxItems) < allCreatedObjectsIds.Length ? maxItems : allCreatedObjectsIds.Length - skipCount;
Assert.IsTrue(resultCount == childrenObjects.Length, "Count of returned items doesn't equal to expected count");
}
else
{
assertObjectsByType(enumTypesOfFileableObjects.any, documentsIds, foldersIds, allCreatedObjectsIds, childrenObjects);
}
foreach (cmisObjectType cmisObject in childrenObjects)
{
assertObjectProperties(cmisObject.properties, filter);
if (renditionData != null)
{
assertRenditions(cmisObject, renditionData.getFilter(), renditionData.getExpectedKinds(), renditionData.getExpectedMimetypes());
}
}
logger.log("Children were successfully received");
logger.log("");
}
public void testChildrenRecevingIncludeRenditions()
{
if (!isRenditionsEnabled())
{
Assert.Skip("Renditions are not supported");
}
FileableObject document = createAndAssertObject(getAndAssertRootFolder(), null);
List <RenditionData> testRenditions = getTestRenditions(document.ObjectId);
if (testRenditions == null)
{
Assert.Skip("No renditions found for document type");
}
FileableObject rootFolder = createAndAssertFolder(getAndAssertRootFolder());
ObjectsHierarchy hierarchy = createAndAssertFilesHierarchy(rootFolder, 1, MINIMAL_CHILDREN, MAXIMUM_CHILDREN, enumTypesOfFileableObjects.any);
foreach (RenditionData renditionData in testRenditions)
{
getAndAssertChildren(hierarchy, ANY_PROPERTY_FILTER, 0, MAX_REQUESTED_COUNT, renditionData);
}
deleteAndAssertHierarchy(hierarchy, enumUnfileObject.delete, true);
deleteAndAssertObject(document, true);
}
public void getAndAssertChildren(string filter, int skipCount, int maxItems)
{
FileableObject rootFolder = createAndAssertFolder(getAndAssertRootFolder());
ObjectsHierarchy hierarchy = createAndAssertFilesHierarchy(rootFolder, 1, MINIMAL_CHILDREN, MAXIMUM_CHILDREN, enumTypesOfFileableObjects.any);
getAndAssertChildren(hierarchy, filter, skipCount, maxItems, null);
deleteAndAssertHierarchy(hierarchy, enumUnfileObject.delete, true);
}
private void assertFolderParentReceiving()
{
FileableObject rootFolder = createAndAssertFolder(getAndAssertRootFolder());
ObjectsHierarchy hierarchy = createAndAssertFilesHierarchy(rootFolder, 1, 1, 1, enumTypesOfFileableObjects.folders);
string[] createdObjectsIds = hierarchy.toIdsArray();
assertFolderParents(createdObjectsIds[createdObjectsIds.Length - 1], new string[] { rootFolder.ObjectId }, false);
deleteAndAssertHierarchy(hierarchy, enumUnfileObject.delete, true);
}
private void assertObjectParentsReceiving()
{
FileableObject rootFolder = createAndAssertFolder(getAndAssertRootFolder());
ObjectsHierarchy hierarchy = createAndAssertFilesHierarchy(rootFolder, 1, 2, 3, enumTypesOfFileableObjects.documents);
string[] createdObjectsIds = hierarchy.toIdsArray();
foreach (string objectId in createdObjectsIds)
{
assertDocumentParents(objectId, new string[] { rootFolder.ObjectId });
}
deleteAndAssertHierarchy(hierarchy, enumUnfileObject.delete, true);
}
public string[] deleteAndAssertHierarchy(ObjectsHierarchy hierarchy, enumUnfileObject unfilingStrategy, bool continueOnFailure)
{
logger.log("[ObjectService->deleteTree]");
logger.log("Delete Tree with Root Folder Id='" + hierarchy.RootFolder.ObjectId + "'. It is " + ((continueOnFailure) ? ("") : ("not ")) + "allowed Continue On Failure");
deleteTreeResponseFailedToDelete response = objectServiceClient.deleteTree(getAndAssertRepositoryId(), hierarchy.RootFolder.ObjectId, true, unfilingStrategy, continueOnFailure, null);
string[] undeletedObjectsIds = response != null ? response.objectIds : null;
if (isValueNotSet(undeletedObjectsIds))
{
foreach (FileableObject currentObject in hierarchy.toObjectsList())
{
assertObjectAbsence(currentObject.ObjectId);
}
logger.log("Objects Tree deletion was performed. Deletion was completed with fail. Undeleted Object Amount: " + undeletedObjectsIds);
}
else
{
foreach (string objectId in undeletedObjectsIds)
{
try
{
getAndAssertObjectProperties(objectId, null, false);
}
catch (Exception)
{
Assert.Fail("Undeleted Object with Id='" + objectId + "' is not exist");
}
}
logger.log("Objects Tree was successfully deleted. Deleted elements Amount=" + hierarchy.getObjectsAmount());
}
assertObjectAbsence(hierarchy.RootFolder.ObjectId);
logger.log("");
return undeletedObjectsIds;
}
public ObjectsHierarchy createAndAssertFilesHierarchy(FileableObject rootFolder, int depth, int minimalChildrenAmount, int maximumChildrenAmount, enumTypesOfFileableObjects allowedObjects)
{
if ((depth <= 0) || (maximumChildrenAmount <= 0) || (minimalChildrenAmount > maximumChildrenAmount))
{
logger.log("Invalid linear parameter(s) for Hierarchy were specified. Expected: depth > 0; maximumChildrenAmount > 0; minimalChildrenAmount <= maximumChildrenAmount. Hierarchy can't be created");
return null;
}
logger.log("Creating objects hierarchy. Depth=" + depth + ", Root Folder Id='" + rootFolder.ObjectId + "', Allowed Objects Type='" + allowedObjects + "'");
ObjectsHierarchy hierarchy = new ObjectsHierarchy(rootFolder, allowedObjects);
List<FileableObject> folders = new List<FileableObject>();
folders.Add(rootFolder);
Random randomCounter = new Random();
for (int i = 0; i < depth; i++)
{
List<FileableObject> nextLayerFolders = new List<FileableObject>();
int requiredFolderContainerNumber = randomCounter.Next(folders.Count);
int currentObjectNumber = 0;
foreach (FileableObject currentLevelFolder in folders)
{
int maximum = calculateMaximumChildrenAmount(randomCounter, minimalChildrenAmount, maximumChildrenAmount);
int foldersMaximum = randomCounter.Next(Convert.ToInt32(Math.Round(Math.Sqrt(maximum))) + 1);
foldersMaximum = ((0 >= foldersMaximum) && (i < (depth - 1)) && (currentObjectNumber++ == requiredFolderContainerNumber)) ? (1) : (foldersMaximum);
for (int j = 0; j < maximum; j++)
{
bool folder = (enumTypesOfFileableObjects.folders == allowedObjects) || ((enumTypesOfFileableObjects.any == allowedObjects) && (j < foldersMaximum));
string objectTypeId = (folder) ? (getAndAssertFolderTypeId()) : (getAndAssertDocumentTypeId());
FileableObject currentObject = createAndAssertObject(folder, currentLevelFolder.ObjectId, objectTypeId);
hierarchy.tryAddObject(currentObject);
if (folder)
{
nextLayerFolders.Add(currentObject);
}
}
}
folders = nextLayerFolders;
}
logger.log(hierarchy.getObjectsAmount() + " Object(s) were included to Hierarchy successfully");
logger.log("");
return hierarchy;
}
