public void CancelAsyncTest()
{
// arrange
AsyncCompletedEventArgs eventArgs = null;
string address = DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb);
Options = new DownloadConfiguration {
BufferBlockSize = 1024,
ChunkCount = 8,
ParallelDownload = true,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
DownloadStarted += (s, e) => CancelAsync();
DownloadFileCompleted += (s, e) => eventArgs = e;
// act
DownloadFileTaskAsync(address).Wait();
// assert
Assert.IsTrue(IsCancelled);
Assert.IsNotNull(eventArgs);
Assert.IsTrue(eventArgs.Cancelled);
Assert.AreEqual(typeof(OperationCanceledException), eventArgs.Error.GetType());
Clear();
}
public void DynamicSpeedLimitTest()
{
// arrange
double upperTolerance = 1.2; // 20% upper than expected avg speed
double expectedAverageSpeed = DummyFileHelper.FileSize16Kb / 30; // == (256*16 + 512*8 + 1024*4 + 2048*2)/30
double averageSpeed = 0;
var progressCounter = 0;
Config.MaximumBytesPerSecond = 256; // 256 Byte/s
var downloader = new DownloadService(Config);
downloader.DownloadProgressChanged += (s, e) => {
averageSpeed += e.BytesPerSecondSpeed;
progressCounter++;
var oneSpeedStepSize = 4096; // DummyFileHelper.FileSize16Kb / 4
var pow = Math.Ceiling((double)e.ReceivedBytesSize / oneSpeedStepSize);
Config.MaximumBytesPerSecond = 128 * (int)Math.Pow(2, pow); // 256, 512, 1024, 2048
};
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)).Wait();
averageSpeed /= progressCounter;
// assert
Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.IsTrue(averageSpeed <= expectedAverageSpeed * upperTolerance,
$"Avg Speed: {averageSpeed} , Expected Avg Speed Limit: {expectedAverageSpeed*upperTolerance}, " +
$"Progress Count: {progressCounter}");
}
public void TestTotalReceivedBytesOnResumeDownloadWhenLostDownloadedData()
{
// arrange
var canStopDownload = true;
var totalDownloadSize = 0L;
var lastProgressPercentage = 0.0;
var config = (DownloadConfiguration)Config.Clone();
config.BufferBlockSize = 1024;
config.ChunkCount = 1;
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += (s, e) => {
totalDownloadSize = e.ReceivedBytesSize;
lastProgressPercentage = e.ProgressPercentage;
if (canStopDownload && totalDownloadSize > DummyFileHelper.FileSize16Kb / 2)
{
// Stopping after start of downloading
downloader.CancelAsync();
canStopDownload = false;
}
};
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)).Wait();
downloader.Package.Chunks[0].Storage.Clear(); // set position to zero
downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point.
// assert
Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DummyFileHelper.FileSize16Kb, totalDownloadSize);
Assert.AreEqual(100.0, lastProgressPercentage);
Assert.AreEqual(100.0, downloader.Package.SaveProgress);
}
public void Download1KbWithFilenameTest()
{
// arrange
var downloadCompletedSuccessfully = false;
var downloader = new DownloadService(Config);
downloader.DownloadFileCompleted += (s, e) => {
if (e.Cancelled == false && e.Error == null)
{
downloadCompletedSuccessfully = true;
}
};
// act
var downloadTask = downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb));
downloadTask.Wait();
using var memoryStream = downloadTask.Result;
// assert
Assert.IsTrue(downloadCompletedSuccessfully);
Assert.IsNotNull(memoryStream);
Assert.AreEqual(DummyFileHelper.FileSize1Kb, memoryStream.Length);
Assert.AreEqual(DummyFileHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(100.0, downloader.Package.SaveProgress);
Assert.IsTrue(DummyFileHelper.File1Kb.AreEqual(memoryStream));
}
public void TestDownloadAndExecuteFileInDownloadCompletedEvent()
{
// arrange
byte[] downloadedBytes = null;
var downloadCompletedSuccessfully = false;
var downloader = new DownloadService(Config);
downloader.DownloadFileCompleted += (s, e) => {
if (e.Cancelled == false && e.Error == null)
{
// Execute the downloaded file within completed event
// Note: Execute within this event caused to an IOException:
// The process cannot access the file '...\Temp\tmp14D3.tmp' because it is being used by another process.)
downloadCompletedSuccessfully = true;
downloadedBytes = File.ReadAllBytes(downloader.Package.FileName);
}
};
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb), Path.GetTempFileName()).Wait();
// assert
Assert.IsTrue(downloadCompletedSuccessfully);
Assert.IsNotNull(downloadedBytes);
Assert.AreEqual(DummyFileHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DummyFileHelper.FileSize1Kb, downloadedBytes.Length);
Assert.IsTrue(DummyFileHelper.File1Kb.AreEqual(new MemoryStream(downloadedBytes)));
}
public void TestContentWhenDownloadOnMemoryStream()
{
// arrange
var downloader = new DownloadService(Config);
// act
using var stream = (MemoryStream)downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Result;
// assert
Assert.IsTrue(DummyFileHelper.File1Kb.SequenceEqual(stream.ToArray()));
}
public void TestTypeWhenDownloadOnMemoryStream()
{
// arrange
var downloader = new DownloadService(Config);
// act
using var stream = downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Result;
// assert
Assert.IsTrue(stream is MemoryStream);
}
public void GetUrlDispositionWhenNoUrlFileNameTest()
{
// arrange
var url = DummyFileHelper.GetFileWithContentDispositionUrl(DummyFileHelper.SampleFile1KbName, DummyFileHelper.FileSize1Kb);
// act
var actualFilename = new Request(url).GetUrlDispositionFilenameAsync().Result;
// assert
Assert.AreEqual(DummyFileHelper.SampleFile1KbName, actualFilename);
}
public void GetFileSizeTest()
{
// arrange
var url = DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb);
var expectedSize = DummyFileHelper.FileSize16Kb;
// act
var actualSize = new Request(url).GetFileSize().Result;
// assert
Assert.AreEqual(expectedSize, actualSize);
}
public void TestSizeWhenDownloadOnMemoryStream()
{
// arrange
var downloader = new DownloadService(Config);
// act
using var stream = downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Result;
// assert
Assert.AreEqual(DummyFileHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DummyFileHelper.FileSize1Kb, stream.Length);
}
public void StopResumeDownloadOverFirstPackagePositionTest()
{
// arrange
var packageCheckPoint = new DownloadPackage()
{
Address = DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)
};
var stopThreshold = 4100;
var totalReceivedBytes = 0L;
var downloader = new DownloadService(Config);
var isSavingStateOnCancel = false;
var isSavingStateBeforCancel = false;
downloader.DownloadProgressChanged += (s, e) => {
totalReceivedBytes += e.ReceivedBytes.Length;
isSavingStateBeforCancel |= downloader.Package.IsSaving;
if (e.ReceivedBytesSize > stopThreshold)
{
// Stopping after start of downloading
downloader.CancelAsync();
stopThreshold *= 2;
// check point of package for once time
packageCheckPoint.Chunks ??= downloader.Package.Chunks.Clone() as Chunk[];
}
};
// act
downloader.DownloadFileTaskAsync(packageCheckPoint.Address).Wait();
while (downloader.IsCancelled)
{
isSavingStateOnCancel |= downloader.Package.IsSaving;
var firstCheckPointClone = new DownloadPackage()
{
Address = packageCheckPoint.Address,
Chunks = packageCheckPoint.Chunks.Clone() as Chunk[]
};
// resume download from first stopped point.
downloader.DownloadFileTaskAsync(firstCheckPointClone).Wait();
}
// assert
Assert.IsTrue(downloader.Package.IsSaveComplete);
Assert.IsFalse(downloader.Package.IsSaving);
Assert.IsFalse(isSavingStateOnCancel);
Assert.IsTrue(isSavingStateBeforCancel);
Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DummyFileHelper.FileSize16Kb, totalReceivedBytes);
}
public virtual void Initial()
{
var testData = DummyData.GenerateOrderedBytes(DummyFileHelper.FileSize16Kb);
_package = new DownloadPackage()
{
FileName = DummyFileHelper.SampleFile16KbName,
Address = DummyFileHelper.GetFileWithNameUrl(DummyFileHelper.SampleFile16KbName, DummyFileHelper.FileSize16Kb),
Chunks = new ChunkHub(Configuration).ChunkFile(DummyFileHelper.FileSize16Kb, 8),
TotalFileSize = DummyFileHelper.FileSize16Kb
};
foreach (var chunk in _package.Chunks)
{
chunk.Storage.WriteAsync(testData, (int)chunk.Start, (int)chunk.Length);
}
}
public void Download16KbWithoutFilenameTest()
{
// arrange
var downloader = new DownloadService(Config);
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb),
new DirectoryInfo(DummyFileHelper.TempDirectory)).Wait();
// assert
Assert.IsTrue(File.Exists(downloader.Package.FileName));
Assert.IsTrue(downloader.Package.FileName.StartsWith(DummyFileHelper.TempDirectory));
Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.IsTrue(DummyFileHelper.File16Kb.AreEqual(File.OpenRead(downloader.Package.FileName)));
File.Delete(downloader.Package.FileName);
}
public void GetFileTest()
{
// arrange
int size = 1024;
byte[] bytes = new byte[size];
string url = DummyFileHelper.GetFileUrl(size);
var dummyData = DummyData.GenerateOrderedBytes(size);
// act
var headers = ReadAndGetHeaders(url, bytes);
// assert
Assert.IsTrue(dummyData.SequenceEqual(bytes));
Assert.AreEqual(size.ToString(), headers["Content-Length"]);
Assert.AreEqual(contentType, headers["Content-Type"]);
}
public void StopResumeDownloadTest()
{
// arrange
var expectedStopCount = 2;
var stopCount = 0;
var cancellationsOccurrenceCount = 0;
var downloadFileExecutionCounter = 0;
var downloadCompletedSuccessfully = false;
var downloader = new DownloadService(Config);
downloader.DownloadFileCompleted += (s, e) => {
if (e.Cancelled && e.Error != null)
{
cancellationsOccurrenceCount++;
}
else
{
downloadCompletedSuccessfully = true;
}
};
downloader.DownloadStarted += delegate {
if (expectedStopCount > stopCount)
{
// Stopping after start of downloading
downloader.CancelAsync();
stopCount++;
}
};
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb), Path.GetTempFileName()).Wait();
while (expectedStopCount > downloadFileExecutionCounter++)
{
downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point.
}
// assert
Assert.IsTrue(File.Exists(downloader.Package.FileName));
Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedStopCount, stopCount);
Assert.AreEqual(expectedStopCount, cancellationsOccurrenceCount);
Assert.IsTrue(downloadCompletedSuccessfully);
File.Delete(downloader.Package.FileName);
}
public void GetFileWithoutHeaderTest()
{
// arrange
int size = 2048;
byte[] bytes = new byte[size];
string filename = "testfilename.dat";
string url = DummyFileHelper.GetFileWithoutHeaderUrl(filename, size);
var dummyData = Helper.DummyData.GenerateOrderedBytes(size);
// act
var headers = ReadAndGetHeaders(url, bytes);
// assert
Assert.IsTrue(dummyData.SequenceEqual(bytes));
Assert.IsNull(headers["Content-Length"]);
Assert.IsNull(headers["Content-Type"]);
}
public void DownloadProgressChangedTest()
{
// arrange
var downloader = new DownloadService(Config);
var progressChangedCount = (int)Math.Ceiling((double)DummyFileHelper.FileSize16Kb / Config.BufferBlockSize);
var progressCounter = 0;
downloader.DownloadProgressChanged += (s, e) => Interlocked.Increment(ref progressCounter);
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)).Wait();
// assert
// Note: some times received bytes on read stream method was less than block size!
Assert.IsTrue(progressChangedCount <= progressCounter);
Assert.AreEqual(100.0, downloader.Package.SaveProgress);
Assert.IsTrue(downloader.Package.IsSaveComplete);
Assert.IsFalse(downloader.Package.IsSaving);
}
public void GetFileWithContentDispositionTest()
{
// arrange
int size = 1024;
byte[] bytes = new byte[size];
string filename = "testfilename.dat";
string url = DummyFileHelper.GetFileWithContentDispositionUrl(filename, size);
var dummyData = Helper.DummyData.GenerateOrderedBytes(size);
// act
var headers = ReadAndGetHeaders(url, bytes);
// assert
Assert.IsTrue(dummyData.SequenceEqual(bytes));
Assert.AreEqual(size.ToString(), headers["Content-Length"]);
Assert.AreEqual(contentType, headers["Content-Type"]);
Assert.IsTrue(headers["Content-Disposition"].Contains($"filename={filename};"));
}
public void SpeedLimitTest()
{
// arrange
double averageSpeed = 0;
var progressCounter = 0;
Config.MaximumBytesPerSecond = 256; // 256 Byte/s
var downloader = new DownloadService(Config);
downloader.DownloadProgressChanged += (s, e) => {
averageSpeed = ((averageSpeed * progressCounter) + e.BytesPerSecondSpeed) / (progressCounter + 1);
progressCounter++;
};
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Wait();
// assert
Assert.AreEqual(DummyFileHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.IsTrue(averageSpeed <= Config.MaximumBytesPerSecond, $"Average Speed: {averageSpeed} , Speed Limit: {Config.MaximumBytesPerSecond}");
}
public void GetSuccessDownloadServiceTest()
{
// arrange
var totalSize = 102400;
var bytesCountPerProgress = 1024;
var mockDownloadService = DownloadServiceMockHelper.GetSuccessDownloadService(totalSize, bytesCountPerProgress, 1);
var states = new DownloadServiceEventsState(mockDownloadService);
var url = DummyFileHelper.GetFileWithNameUrl(DummyFileHelper.SampleFile1KbName, DummyFileHelper.FileSize1Kb);
// act
mockDownloadService.DownloadFileTaskAsync(url, DummyFileHelper.SampleFile1KbName).Wait();
// assert
Assert.AreEqual(url, mockDownloadService.Package.Address);
Assert.AreEqual(DummyFileHelper.SampleFile1KbName, mockDownloadService.Package.FileName);
Assert.AreEqual(DummyFileHelper.SampleFile1KbName, states.ActualFileName);
Assert.AreEqual(totalSize / bytesCountPerProgress, states.DownloadProgressCount);
Assert.IsTrue(states.DownloadSuccessfullCompleted);
Assert.IsTrue(states.DownloadProgressIsCorrect);
Assert.IsNull(states.DownloadError);
Assert.IsTrue(mockDownloadService.Package.IsSaveComplete);
Assert.IsFalse(mockDownloadService.Package.IsSaving);
}
public void TestPackageChunksDataAfterDispose()
{
// arrange
var dummyData = DummyData.GenerateOrderedBytes(1024);
Package.Chunks = new ChunkHub(Options).ChunkFile(1024 * 64, 64);
foreach (var chunk in Package.Chunks)
{
chunk.Storage.WriteAsync(dummyData, 0, 1024).Wait();
}
// act
Dispose();
// assert
Assert.IsNotNull(Package.Chunks);
foreach (var chunk in Package.Chunks)
{
Assert.IsTrue(DummyFileHelper.AreEqual(dummyData, chunk.Storage.OpenRead()));
}
Package.Clear();
}
public void StopResumeDownloadFromLastPositionTest()
{
// arrange
var expectedStopCount = 1;
var stopCount = 0;
var downloadFileExecutionCounter = 0;
var totalProgressedByteSize = 0L;
var totalReceivedBytes = 0L;
var config = (DownloadConfiguration)Config.Clone();
config.BufferBlockSize = 1024;
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += (s, e) => {
totalProgressedByteSize += e.ProgressedByteSize;
totalReceivedBytes += e.ReceivedBytes.Length;
if (expectedStopCount > stopCount)
{
// Stopping after start of downloading
downloader.CancelAsync();
stopCount++;
}
};
// act
downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)).Wait();
while (expectedStopCount > downloadFileExecutionCounter++)
{
downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point.
}
// assert
Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DummyFileHelper.FileSize16Kb, totalProgressedByteSize);
Assert.AreEqual(DummyFileHelper.FileSize16Kb, totalReceivedBytes);
}
