public void DirectoryShouldTransfer()
{
// Prepare data
int totaFileNumber = DMLibTestConstants.FlatFileCount;
int expectedTransferred = totaFileNumber, transferred = 0;
int expectedSkipped = 0, skipped = 0;
int expectedFailed = 0, failed = 0;
DMLibDataInfo sourceDataInfo = this.GenerateSourceDataInfo(FileNumOption.FlatFolder, 1024);
DirectoryTransferContext dirTransferContext = new DirectoryTransferContext();
List <String> notTransferredFileNames = new List <String>();
dirTransferContext.ShouldTransferCallbackAsync = async(source, dest) =>
{
if (Helper.RandomBoolean())
{
return(true);
}
else
{
Interlocked.Decrement(ref expectedTransferred);
string fullName = DMLibTestHelper.TransferInstanceToString(source);
string fileName = fullName.Substring(fullName.IndexOf(DMLibTestBase.FileName));
lock (notTransferredFileNames)
{
notTransferredFileNames.Add(fileName);
}
Test.Info("{0} is filterred in ShouldTransfer.", fileName);
return(false);
}
};
dirTransferContext.FileTransferred += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref transferred);
};
dirTransferContext.FileSkipped += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref skipped);
};
dirTransferContext.FileFailed += (object sender, TransferEventArgs args) =>
{
Interlocked.Increment(ref failed);
};
var options = new TestExecutionOptions <DMLibDataInfo>();
options.IsDirectoryTransfer = true;
options.TransferItemModifier = (fileNode, transferItem) =>
{
transferItem.TransferContext = dirTransferContext;
dynamic transferOptions = DefaultTransferDirectoryOptions;
transferOptions.Recursive = true;
transferItem.Options = transferOptions;
};
// Execute test case
var result = this.ExecuteTestCase(sourceDataInfo, options);
// Verify result
DMLibDataInfo expectedDataInfo = sourceDataInfo.Clone();
DirNode expectedRootNode = expectedDataInfo.RootNode;
foreach (string fileNames in notTransferredFileNames)
{
expectedRootNode.DeleteFileNode(fileNames);
}
VerificationHelper.VerifyTransferSucceed(result, expectedDataInfo);
Test.Assert(expectedTransferred == transferred, string.Format("Verify transferred number. Expected: {0}, Actual: {1}", expectedTransferred, transferred));
Test.Assert(expectedSkipped == skipped, string.Format("Verify skipped number. Expected: {0}, Actual: {1}", expectedSkipped, skipped));
Test.Assert(expectedFailed == failed, string.Format("Verify failed number. Expected: {0}, Actual: {1}", expectedFailed, failed));
}
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");
}
}