public void TestDirectorySetAttributes()
{
Dictionary <string, string> metadata = new Dictionary <string, string>();
if (DMLibTestContext.SourceType != DMLibDataType.Local)
{
metadata.Add("foo", "bar");
}
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
for (int i = 0; i < 3; ++i)
{
FileNode fileNode = new FileNode(DMLibTestBase.FileName + i)
{
SizeInByte = DMLibTestBase.FileSizeInKB * 1024L,
Metadata = metadata
};
sourceDataInfo.RootNode.AddFileNode(fileNode);
}
DirectoryTransferContext context = new DirectoryTransferContext()
{
SetAttributesCallbackAsync = async(destObj) =>
{
dynamic destCloudObj = destObj;
destCloudObj.Properties.ContentType = SetAttributesTest.TestContentType;
destCloudObj.Metadata.Add("aa", "bb");
}
};
var options = new TestExecutionOptions <DMLibDataInfo>();
options.TransferItemModifier = (node, transferItem) =>
{
dynamic transferOptions = DefaultTransferDirectoryOptions;
transferOptions.Recursive = true;
transferItem.Options = transferOptions;
transferItem.TransferContext = context;
};
options.IsDirectoryTransfer = true;
var result = this.ExecuteTestCase(sourceDataInfo, options);
foreach (FileNode fileNode in sourceDataInfo.EnumerateFileNodes())
{
fileNode.Metadata.Add("aa", "bb");
}
VerificationHelper.VerifyTransferSucceed(result, sourceDataInfo);
VerificationHelper.VerifySingleTransferStatus(result, 3, 0, 0, 3 * DMLibTestBase.FileSizeInKB * 1024L);
foreach (FileNode destFileNode in result.DataInfo.EnumerateFileNodes())
{
Test.Assert(TestContentType.Equals(destFileNode.ContentType), "Verify content type: {0}, expected {1}", destFileNode.ContentType, TestContentType);
}
}
private void TestDelimiter(char delimiter)
{
Test.Info("Test delimiter: {0}", delimiter);
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
string fileName = DMLibTestBase.FolderName + delimiter + DMLibTestBase.FolderName + delimiter + DMLibTestBase.FileName;
DMLibDataHelper.AddOneFile(sourceDataInfo.RootNode, fileName, 1);
TransferContext context = new DirectoryTransferContext();
context.FileFailed += (sender, e) =>
{
Test.Info(e.Exception.StackTrace);
};
TestExecutionOptions <DMLibDataInfo> options = new TestExecutionOptions <DMLibDataInfo>()
{
IsDirectoryTransfer = true,
TransferItemModifier = (node, item) =>
{
dynamic dirOptions = DefaultTransferDirectoryOptions;
dirOptions.Recursive = true;
dirOptions.Delimiter = delimiter;
item.Options = dirOptions;
item.TransferContext = context;
}
};
TestResult <DMLibDataInfo> result = this.ExecuteTestCase(sourceDataInfo, options);
DMLibDataInfo expectedDataInfo = new DMLibDataInfo(string.Empty);
DirNode dirNode1 = new DirNode(FolderName);
DirNode dirNode2 = new DirNode(FolderName);
FileNode fileNode = sourceDataInfo.RootNode.GetFileNode(fileName).Clone(DMLibTestBase.FileName);
dirNode2.AddFileNode(fileNode);
dirNode1.AddDirNode(dirNode2);
expectedDataInfo.RootNode.AddDirNode(dirNode1);
VerificationHelper.VerifySingleTransferStatus(result, 1, 0, 0, null);
VerificationHelper.VerifyTransferSucceed(result, expectedDataInfo);
}
public void DirectoryForceOverwriteTest()
{
string destExistName = "destExist";
string destNotExistName = "destNotExist";
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, destExistName, 1024);
DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, destNotExistName, 1024);
DMLibDataInfo destDataInfo = new DMLibDataInfo(string.Empty);
DMLibDataHelper.AddOneFileInBytes(destDataInfo.RootNode, destExistName, 1024);
TransferContext transferContext = new DirectoryTransferContext();
transferContext.ShouldOverwriteCallback = TransferContext.ForceOverwrite;
int skipCount = 0;
int successCount = 0;
transferContext.FileSkipped += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref skipCount);
};
transferContext.FileTransferred += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref successCount);
};
var options = new TestExecutionOptions <DMLibDataInfo>();
options.IsDirectoryTransfer = true;
if (DMLibTestContext.DestType != DMLibDataType.Stream)
{
options.DestTransferDataInfo = destDataInfo;
}
if (IsCloudService(DMLibTestContext.DestType))
{
SharedAccessPermissions permissions;
if (DMLibTestContext.IsAsync)
{
permissions = SharedAccessPermissions.Write | SharedAccessPermissions.Read;
}
else
{
permissions = SharedAccessPermissions.Write;
}
StorageCredentials destSAS = new StorageCredentials(DestAdaptor.GenerateSAS(permissions, (int)new TimeSpan(1, 0, 0, 0).TotalSeconds));
options.DestCredentials = destSAS;
}
options.TransferItemModifier = (fileNode, transferItem) =>
{
transferItem.TransferContext = transferContext;
dynamic transferOptions = DefaultTransferDirectoryOptions;
transferOptions.Recursive = true;
transferItem.Options = transferOptions;
};
var result = this.ExecuteTestCase(sourceDataInfo, options);
// Verify transfer result
Test.Assert(DMLibDataHelper.Equals(sourceDataInfo, result.DataInfo), "Verify transfer result.");
VerificationHelper.VerifySingleTransferStatus(result, 2, 0, 0, 1024 * 2);
Test.Assert(successCount == 2, "Verify success transfers");
Test.Assert(skipCount == 0, "Verify skipped transfer");
}
public void DirectoryOverwriteDestination()
{
string destExistYName = "destExistY";
string destExistNName = "destExistN";
string destNotExistYName = "destNotExistY";
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, destExistYName, 1024);
DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, destExistNName, 1024);
DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, destNotExistYName, 1024);
DMLibDataInfo destDataInfo = new DMLibDataInfo(string.Empty);
DMLibDataHelper.AddOneFileInBytes(destDataInfo.RootNode, destExistYName, 1024);
DMLibDataHelper.AddOneFileInBytes(destDataInfo.RootNode, destExistNName, 1024);
TransferContext transferContext = new DirectoryTransferContext();
transferContext.ShouldOverwriteCallback = (source, destination) =>
{
if (DMLibTestHelper.TransferInstanceToString(source).EndsWith(destExistNName))
{
return(false);
}
else
{
return(true);
}
};
int skipCount = 0;
int successCount = 0;
transferContext.FileSkipped += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref skipCount);
TransferException transferException = args.Exception as TransferException;
Test.Assert(transferException != null, "Verify the exception is a TransferException");
VerificationHelper.VerifyTransferException(transferException, TransferErrorCode.NotOverwriteExistingDestination,
"Skiped file", destExistNName);
};
transferContext.FileTransferred += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref successCount);
};
var options = new TestExecutionOptions <DMLibDataInfo>();
options.IsDirectoryTransfer = true;
if (DMLibTestContext.DestType != DMLibDataType.Stream)
{
options.DestTransferDataInfo = destDataInfo;
}
options.TransferItemModifier = (fileNode, transferItem) =>
{
transferItem.TransferContext = transferContext;
dynamic transferOptions = DefaultTransferDirectoryOptions;
transferOptions.Recursive = true;
transferItem.Options = transferOptions;
};
var result = this.ExecuteTestCase(sourceDataInfo, options);
DMLibDataInfo expectedDataInfo = new DMLibDataInfo(string.Empty);
if (DMLibTestContext.DestType != DMLibDataType.Stream)
{
expectedDataInfo.RootNode.AddFileNode(sourceDataInfo.RootNode.GetFileNode(destExistYName));
expectedDataInfo.RootNode.AddFileNode(destDataInfo.RootNode.GetFileNode(destExistNName));
expectedDataInfo.RootNode.AddFileNode(sourceDataInfo.RootNode.GetFileNode(destNotExistYName));
}
else
{
expectedDataInfo = sourceDataInfo;
}
// Verify transfer result
Test.Assert(DMLibDataHelper.Equals(expectedDataInfo, result.DataInfo), "Verify transfer result.");
// Verify exception
if (DMLibTestContext.DestType != DMLibDataType.Stream)
{
VerificationHelper.VerifySingleTransferStatus(result, 2, 1, 0, 1024 * 2);
Test.Assert(successCount == 2, "Verify success transfers");
Test.Assert(skipCount == 1, "Verify skipped transfer");
}
else
{
VerificationHelper.VerifySingleTransferStatus(result, 3, 0, 0, 1024 * 3);
Test.Assert(successCount == 3, "Very all transfers are success");
Test.Assert(skipCount == 0, "Very no transfer is skipped");
}
}
private void TestDirectorySetAttribute_Restart(
int bigFileSizeInKB,
int smallFileSizeInKB,
int bigFileNum,
int smallFileNum,
Action <DirNode> bigFileDirAddFileAction,
Action <DirNode> smallFileDirAddFileAction,
SetAttributesCallbackAsync setAttributesCallback = null,
Action <DMLibDataInfo> sourceDataInfoDecorator = null)
{
int totalFileNum = bigFileNum + smallFileNum;
long totalSizeInBytes = ((bigFileSizeInKB * bigFileNum) + (smallFileSizeInKB * smallFileNum)) * 1024;
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
DirNode bigFileDirNode = new DirNode("big");
DirNode smallFileDirNode = new DirNode("small");
sourceDataInfo.RootNode.AddDirNode(bigFileDirNode);
sourceDataInfo.RootNode.AddDirNode(smallFileDirNode);
bigFileDirAddFileAction(bigFileDirNode);
smallFileDirAddFileAction(smallFileDirNode);
CancellationTokenSource tokenSource = new CancellationTokenSource();
TransferItem transferItem = null;
var options = new TestExecutionOptions <DMLibDataInfo> {
LimitSpeed = true, IsDirectoryTransfer = true
};
using (Stream journalStream = new MemoryStream())
{
bool isStreamJournal = random.Next(0, 2) == 0;
var transferContext = isStreamJournal ? new DirectoryTransferContext(journalStream) : new DirectoryTransferContext();
transferContext.SetAttributesCallbackAsync = setAttributesCallback;
var progressChecker = new ProgressChecker(totalFileNum, totalSizeInBytes, totalFileNum, null, 0, totalSizeInBytes);
transferContext.ProgressHandler = progressChecker.GetProgressHandler();
var eventChecker = new TransferEventChecker();
eventChecker.Apply(transferContext);
transferContext.FileFailed += (sender, e) =>
{
Helper.VerifyCancelException(e.Exception);
};
options.TransferItemModifier = (fileName, item) =>
{
dynamic dirOptions = DefaultTransferDirectoryOptions;
dirOptions.Recursive = true;
item.Options = dirOptions;
item.CancellationToken = tokenSource.Token;
item.TransferContext = transferContext;
transferItem = item;
};
TransferCheckpoint firstCheckpoint = null, secondCheckpoint = null;
options.AfterAllItemAdded = () =>
{
// Wait until there are data transferred
progressChecker.DataTransferred.WaitOne();
if (!isStreamJournal)
{
// Store the first checkpoint
firstCheckpoint = transferContext.LastCheckpoint;
}
Thread.Sleep(1000);
// Cancel the transfer and store the second checkpoint
tokenSource.Cancel();
};
// Cancel and store checkpoint for resume
var result = this.ExecuteTestCase(sourceDataInfo, options);
if (progressChecker.FailedFilesNumber <= 0)
{
Test.Error("Verify file number in progress. Failed: {0}", progressChecker.FailedFilesNumber);
}
TransferCheckpoint firstResumeCheckpoint = null, secondResumeCheckpoint = null;
if (!isStreamJournal)
{
secondCheckpoint = transferContext.LastCheckpoint;
Test.Info("Resume with the second checkpoint first.");
firstResumeCheckpoint = secondCheckpoint;
secondResumeCheckpoint = firstCheckpoint;
}
// resume with firstResumeCheckpoint
TransferItem resumeItem = transferItem.Clone();
progressChecker.Reset();
TransferContext resumeContext = null;
if (isStreamJournal)
{
resumeContext = new DirectoryTransferContext(journalStream)
{
ProgressHandler = progressChecker.GetProgressHandler()
};
}
else
{
resumeContext = new DirectoryTransferContext(DMLibTestHelper.RandomReloadCheckpoint(firstResumeCheckpoint))
{
ProgressHandler = progressChecker.GetProgressHandler()
};
}
resumeContext.SetAttributesCallbackAsync = setAttributesCallback;
eventChecker.Reset();
eventChecker.Apply(resumeContext);
resumeItem.TransferContext = resumeContext;
result = this.RunTransferItems(new List <TransferItem>()
{
resumeItem
}, new TestExecutionOptions <DMLibDataInfo>());
sourceDataInfoDecorator?.Invoke(sourceDataInfo);
VerificationHelper.VerifyFinalProgress(progressChecker, totalFileNum, 0, 0);
VerificationHelper.VerifySingleTransferStatus(result, totalFileNum, 0, 0, totalSizeInBytes);
VerificationHelper.VerifyTransferSucceed(result, sourceDataInfo);
if (!isStreamJournal)
{
// resume with secondResumeCheckpoint
resumeItem = transferItem.Clone();
progressChecker.Reset();
resumeContext = new DirectoryTransferContext(DMLibTestHelper.RandomReloadCheckpoint(secondResumeCheckpoint))
{
ProgressHandler = progressChecker.GetProgressHandler(),
// Need this overwrite callback since some files is already transferred to destination
ShouldOverwriteCallbackAsync = DMLibInputHelper.GetDefaultOverwiteCallbackY(),
SetAttributesCallbackAsync = setAttributesCallback
};
eventChecker.Reset();
eventChecker.Apply(resumeContext);
resumeItem.TransferContext = resumeContext;
result = this.RunTransferItems(new List <TransferItem>()
{
resumeItem
}, new TestExecutionOptions <DMLibDataInfo>());
VerificationHelper.VerifyFinalProgress(progressChecker, totalFileNum, 0, 0);
VerificationHelper.VerifySingleTransferStatus(result, totalFileNum, 0, 0, totalSizeInBytes);
VerificationHelper.VerifyTransferSucceed(result, sourceDataInfo);
}
}
}