public void ShouldStartTimerWhenServiceStarts()
{
//arrange
var stubServiceTimer = MockRepository.GenerateStub<ICbxServiceEventProvider>();
//stubServiceTimer.Interval = 1000;
stubServiceTimer.Expect(x => x.Start());
//act
_serviceClass = new DownloadService();
_serviceClass.Start();
//assert
stubServiceTimer.VerifyAllExpectations();
}
public void Service_Should_Always_Return_Same_Data()
{
List <BufferedDataBlock> blockList = new List <BufferedDataBlock>();
long blockNumber = 0;
while (true)
{
BufferedDataBlock block = DownloadService.ReadBlock(Token.TransferId, blockNumber++);
blockList.Add(block);
if (block.IsLastBlock)
{
break;
}
}
for (int i = 0; i < blockList.Count; i++)
{
BufferedDataBlock block = blockList[i];
BufferedDataBlock copy = DownloadService.ReadBlock(Token.TransferId, i);
Assert.AreEqual(block.BlockLength, copy.BlockLength);
Assert.AreEqual(block.BlockNumber, copy.BlockNumber);
CollectionAssert.AreEqual(block.Data, copy.Data);
Assert.AreEqual(block.Offset, copy.Offset);
}
//the same in the other direction
for (int i = blockList.Count - 1; i >= 0; i--)
{
BufferedDataBlock block = blockList[i];
BufferedDataBlock copy = DownloadService.ReadBlock(Token.TransferId, i);
Assert.AreEqual(block.BlockLength, copy.BlockLength);
Assert.AreEqual(block.BlockNumber, copy.BlockNumber);
CollectionAssert.AreEqual(block.Data, copy.Data);
Assert.AreEqual(block.Offset, copy.Offset);
}
}
public void Refreshing_Token_After_Multiple_Read_Should_Still_Indicate_The_Last_Block_Number()
{
for (int i = 0; i < 10; i++)
{
DownloadService.ReadBlock(Token.TransferId, i);
}
DataBlockInfo lastBlock = null;
//redownload a few of these blocks
for (int i = 0; i < 10; i++)
{
if (i % 2 == 0)
{
lastBlock = DownloadService.ReadBlock(Token.TransferId, i);
}
}
DownloadToken copy = DownloadService.RenewToken(Token, false);
Assert.AreEqual(lastBlock.BlockNumber, copy.LastTransmittedBlockInfo.BlockNumber);
}
public ForgeInstallViewModel(
ForgeInstallService forgeInstallService,
VersionService versionService,
LibraryService libraryService,
DownloadService downloadService,
IWindowManager windowManager,
DownloadStatusViewModel downloadStatusVM
)
{
_forgeInstallService = forgeInstallService;
_versionService = versionService;
_libraryService = libraryService;
_downloadService = downloadService;
_windowManager = windowManager;
_downloadStatusVM = downloadStatusVM;
_forgeInstallService.InstallProgressChanged += progress => InstallProgress = progress;
Forges = new BindableCollection <Forge>();
}
public RootViewModel(IViewModelFactory viewModelFactory, DialogManager dialogManager,
SettingsService settingsService, UpdateService updateService, QueryService queryService,
DownloadService downloadService)
{
_viewModelFactory = viewModelFactory;
_dialogManager = dialogManager;
_settingsService = settingsService;
_updateService = updateService;
_queryService = queryService;
_downloadService = downloadService;
// Title
var version = Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
DisplayName = $"YoutubeDownloader v{version}";
// Update busy state when progress manager changes
ProgressManager.Bind(o => o.IsActive,
(sender, args) => IsProgressIndeterminate = ProgressManager.IsActive && ProgressManager.Progress.IsEither(0, 1));
ProgressManager.Bind(o => o.Progress,
(sender, args) => IsProgressIndeterminate = ProgressManager.IsActive && ProgressManager.Progress.IsEither(0, 1));
}
private static async Task <DownloadService> DownloadFile(DownloadItem downloadItem,
DownloadConfiguration downloadOpt)
{
DownloadService ds = new DownloadService(downloadOpt);
ds.ChunkDownloadProgressChanged += OnChunkDownloadProgressChanged;
ds.DownloadProgressChanged += OnDownloadProgressChanged;
ds.DownloadFileCompleted += OnDownloadFileCompleted;
ds.DownloadStarted += OnDownloadStarted;
if (string.IsNullOrWhiteSpace(downloadItem.FileName))
{
await ds.DownloadFileAsync(downloadItem.Url, new DirectoryInfo(downloadItem.FolderPath))
.ConfigureAwait(false);
}
else
{
await ds.DownloadFileAsync(downloadItem.Url, downloadItem.FileName).ConfigureAwait(false);
}
return(ds);
}
/// <summary>
/// Instance Downloader with base constructor
/// </summary>
public BlackVueDownloader() : this(new FileSystemHelper())
{
var config = new DownloadConfiguration
{
MaxTryAgainOnFailover = 3,
ChunkCount = 1,
ParallelDownload = true,
Timeout = 2500,
RequestConfiguration =
{
KeepAlive = true
}
};
downloader = new DownloadService();
downloader.DownloadStarted += OnDownloadStarted;
downloader.DownloadFileCompleted += OnDownloadFileCompleted;
//downloader.ChunkDownloadProgressChanged += OnChunkDownloadProgressChanged;
downloader.DownloadProgressChanged += OnDownloadProgressChanged;;
}
/// <summary>
/// Download MSIX from Azure
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void btnUpdate_Click(object sender, RoutedEventArgs e)
{
btnUpdate.IsEnabled = false;
bool isConnected = ApplicationHelper.IsConnectedToInternet();
if (isConnected)
{
txtStatus.Text = "Downloading Database...";
txtMSIXStatus.Text = string.Empty;
prgMSIX.Value = 0;
prgMSIX.Visibility = Visibility.Visible;
prgMSIX.IsIndeterminate = false;
var downloader = new DownloadService();
downloader.DownloadProgressChanged += Downloader_DownloadProgressChanged;
downloader.DownloadFileCompleted += Downloader_DownloadFileCompleted;
await downloader.DownloadFileTaskAsync(Consts.MSIXSourceUrl, new DirectoryInfo(Consts.MSIXPath));
}
else
{
CreateInfoBar("Network UnAvailable", "Unable to connect to the Internet", panel, Severity.Error);
btnUpdate.IsEnabled = true;
}
}
public async Task MangaStream_Test()
{
string url = "http://mangastream.com/manga/dragon_ball_super";
var service = FrameworkProvider.GetService(url);
var chapters = await service.FindChapters(url, new Progress <int>(), _source.Token);
Assert.IsTrue(chapters.Any(), "Cannot find chapters.");
var chapter = chapters.Last();
Assert.AreEqual("001 - The God of Destruction's Prophetic Dream", chapter.Name);
Assert.AreEqual("http://readms.net/r/dragon_ball_super/001/2831/1", chapter.Url);
var images = await service.FindImages(chapter, new Progress <int>(), _source.Token);
Assert.AreEqual(17, images.Count());
Assert.IsTrue(images.ToArray()[0].StartsWith("http://img.readms.net/cdn/manga/107/2831/001.jpg"));
Assert.IsTrue(images.ToArray()[1].StartsWith("http://img.readms.net/cdn/manga/107/2831/001a.jpg"));
Assert.IsTrue(images.ToArray()[2].StartsWith("http://img.readms.net/cdn/manga/107/2831/002.png"));
var downloader = new DownloadService();
string imageString = await downloader.DownloadStringAsync(images.ToArray()[0], _source.Token);
Assert.IsNotNull(imageString, "Cannot download image!");
}
protected async void CheckUpdate()
{
string guid = mngPreferences.GetPrefereceStringValue("key_Guid");
string lastUpdate = mngPreferences.GetPrefereceStringValue("key_LastUpdate");
HttpClient client = new HttpClient();
Uri uri = new Uri("https://api.socialscore.be/api/v1/tv/projectinfo/" + guid);
try
{
HttpResponseMessage response = await client.GetAsync(uri);
var result = await response.Content.ReadAsStringAsync();
ProjectInfo projectInfo = JsonConvert.DeserializeObject <ProjectInfo>(result);
if (projectInfo.lastUpdate != lastUpdate)
{
mngPreferences.SaveProjectInfo(projectInfo);
IFileService fileService = DependencyService.Get <IFileService>();
DownloadService downloadService = new DownloadService(fileService);
await downloadService.DownloadFileAsync(App.appInfo.projectInfo.url);
Type CurPageType = MainPage.GetType();
if (ImInPinView == false)
{
MainPage = new NavigationPage(new Views.MainPage());
}
}
}
catch (Exception er)
{
var lb = er.ToString();
}
}
public void Setup(UpdateInfo info)
{
var download = _updateService.GetDownload(info);
_downloadService = new DownloadService(download);
_downloadService.ProgressChanged += progress =>
{
DownloadProgress = (double)progress.DownloadedBytes / progress.TotalBytes;
Percentage = (DownloadProgress * 100.0).ToString("0.0") + '%';
};
_downloadService.Completed += result =>
{
if (result == DownloadResult.Incomplete)
{
_downloadService.Cancel();
}
};
IsDownloading = false;
DisplayUpdateInfo(info);
}
public void DownloadJson1KTest()
{
var expectedFileSize = 20471; // real bytes size
var address = "https://file-examples.com/wp-content/uploads/2017/02/file_example_JSON_1kb.json";
var file = new FileInfo(Path.GetTempFileName());
var config = new DownloadConfiguration()
{
BufferBlockSize = 1024,
ChunkCount = 16,
ParallelDownload = false,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
var progressCount = config.ChunkCount * (int)Math.Ceiling((double)expectedFileSize / config.ChunkCount / config.BufferBlockSize);
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += delegate
{
Interlocked.Decrement(ref progressCount);
};
downloader.DownloadFileAsync(address, file.FullName).Wait();
Assert.IsTrue(file.Exists);
Assert.AreEqual(expectedFileSize, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedFileSize, file.Length);
Assert.AreEqual(0, progressCount);
using (var reader = file.OpenText())
{
var json = reader.ReadToEnd();
var obj = JsonConvert.DeserializeObject(json);
Assert.IsNotNull(obj);
}
file.Delete();
}
public void StopResumeDownloadFromLastPositionTest()
{
// arrange
var expectedStopCount = 2;
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(DownloadTestHelper.File16KbUrl).Wait();
while (expectedStopCount > downloadFileExecutionCounter++)
{
downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point.
}
// assert
Assert.AreEqual(DownloadTestHelper.FileSize16Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DownloadTestHelper.FileSize16Kb, totalProgressedByteSize);
Assert.AreEqual(DownloadTestHelper.FileSize16Kb, totalReceivedBytes);
}
public void SpeedLimitTest()
{
// arrange
double averageSpeed = 0;
var progressCounter = 0;
Config.MaximumBytesPerSecond = 128; // 128 Byte/s
var downloader = new DownloadService(Config);
downloader.DownloadProgressChanged += (s, e) => {
averageSpeed = ((averageSpeed * progressCounter) + e.BytesPerSecondSpeed) / (progressCounter + 1);
progressCounter++;
};
// act
downloader.DownloadFileAsync(DownloadTestHelper.File1KbUrl, Path.GetTempFileName()).Wait();
// assert
Assert.IsTrue(File.Exists(downloader.Package.FileName));
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.IsTrue(averageSpeed <= Config.MaximumBytesPerSecond, $"Average Speed: {averageSpeed} , Speed Limit: {Config.MaximumBytesPerSecond}");
File.Delete(downloader.Package.FileName);
}
public GameInstallViewModel(
ConfigService configService,
GamePathService gamePathService,
VersionService versionService,
LibraryService libraryService,
AssetService assetService,
DownloadService downloadService,
IWindowManager windowManager,
DownloadStatusViewModel downloadVM)
{
_config = configService.Entries;
_gamePathService = gamePathService;
_versionService = versionService;
_libraryService = libraryService;
_assetService = assetService;
_downloadService = downloadService;
_versionDownloads = new BindableCollection <VersionDownload>();
VersionDownloads = CollectionViewSource.GetDefaultView(_versionDownloads);
VersionDownloads.Filter = obj =>
{
if (_isReleaseOnly)
{
return((obj as VersionDownload).Type == VersionType.Release);
}
return(true);
};
_windowManager = windowManager;
_downloadStatusVM = downloadVM;
_isVersionListLoaded = false;
_isReleaseOnly = true;
}
public void TearDown()
{
if (_serviceClass == null) return;
_serviceClass.Stop();
_serviceClass = null;
}
public void Setup()
{
if (_serviceClass == null) return;
_serviceClass.Stop();
_serviceClass = null;
}
