public async Task Test_DownloadRejected_Error1()
{
Console.WriteLine("Test_DownloadRejected_Error1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadRejected(new DownloadRejected {
Id = 0,
Reason = RejectionEnum.QueueFull
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.DownloadRejected_IdentifierNotFound, error);
}
public async Task Test_FinishDownload_ErrorNotFound2()
{
Console.WriteLine("Test_FinishDownload_ErrorNotFound2");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Downloading,
};
repo.Insert(download);
manager.FinishedDownload(new FinishedDownload {
Id = 666,
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.FinishedDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_FinishDownload_ErrorNotFound2 ()
{
Console.WriteLine ("Test_FinishDownload_ErrorNotFound2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Downloading,
};
repo.Insert (download);
manager.FinishedDownload (new FinishedDownload {
Id = 666,
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.FinishedDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_FinishDownload_Finish1 ()
{
Console.WriteLine ("Test_FinishDownload_Finish1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
};
repo.Insert (download);
manager.FinishedDownload (new FinishedDownload {
Id = download.Id,
});
Assert.AreEqual (ErrorEnum.Empty, downloaderror, "Downloaderror");
Assert.AreEqual (State.Finished, download.State, "Finished");
}
public async Task Test_DownloadError_Error2 ()
{
Console.WriteLine ("Test_DownloadError_Error2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadError (new DownloadError {
Id = 0,
Error = ErrorEnum.DidCompleteWithError_Error,
});
wait1.WaitOne (10);
Assert.AreEqual (ErrorEnum.Empty, error);
}
public async Task Test_QueueUrl_AlreadyQueued1()
{
Console.WriteLine("Test_QueueUrl_AlreadyQueued1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe <AlreadyQueued> (p => {
alreadyQueued = true;
wait1.Set();
});
bus.Subscribe <CheckFreeSlot> (p => {
checkFreeSlot = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip"
});
manager.QueueUrl(new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait1.WaitOne();
Assert.AreEqual(false, checkFreeSlot);
Assert.AreEqual(true, alreadyQueued);
}
public Downloader ()
{
var personal = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
var dbpath = Path.Combine (personal, "download.db");
var db = new SQLiteConnection (
dbpath,
SQLiteOpenFlags.ReadWrite
| SQLiteOpenFlags.Create
| SQLiteOpenFlags.FullMutex ,
true) {
#if DEBUG
Trace = true
#endif
};
int maxdownloads = 3;
_bus = new InProcessBus ();
_repository = new DownloadRepository (db);
_manager = new DownloadManager (_bus, _repository, maxdownloads);
_service = new NSUrlSessionManager (_bus, maxdownloads);
_progress = new ProgressManager (_bus, _repository);
_timer = new Timer (TimerCallback, null, 1000, 1000);
_timer = new Timer (TimerCallback, null, 1000, 1000);
_bus.Subscribe<DownloadError> (DownloadError_Received);
_bus.Subscribe<TaskError> (TaskError_Received);
_bus.Subscribe<QueueEmpty> (QueueEmpty_Received);
_bus.Subscribe<GlobalProgress> (GlobalProgress_Received);
_bus.Subscribe<NotifyFinish> (NotifyFinish_Received);
}
public async Task Test_ResetDownloads_Multiple()
{
Console.WriteLine("Test_ResetDownloads_Multiple");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var waiting = new Download {
State = State.Waiting
};
var error = new Download {
State = State.Error
};
var downloading = new Download {
State = State.Downloading
};
var finished = new Download {
State = State.Finished
};
repo.Insert(waiting);
repo.Insert(downloading);
repo.Insert(error);
repo.Insert(finished);
manager.ResetDownloads(new ResetDownloads {
});
var all = repo.All();
Assert.AreEqual(0, all.Count);
}
public async Task Test_DownloadError_Error3 ()
{
Console.WriteLine ("Test_DownloadError_Error3");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Finished };
repo.Insert (download);
manager.TaskError (new TaskError {
Id = download.Id,
Error = TaskErrorEnum.DownloadError,
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.TaskError_InvalidState, error);
}
public async Task Test_DownloadRejected_1 ()
{
Console.WriteLine ("Test_DownloadRejected_1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Downloading };
repo.Insert (download);
manager.DownloadRejected (new DownloadRejected {
Id = 1,
Reason = RejectionEnum.QueueFull
});
Assert.AreEqual (State.Waiting, download.State);
}
public async Task Test_ProgressDownload_DownloadError1 ()
{
Console.WriteLine ("Test_ProgressDownload_DownloadError1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
manager.ProgressDownload (new ProgressDownload {
Id = 1,
Total = 1000,
Written = 10
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.ProgressDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_DownloadError_Error500()
{
Console.WriteLine("Test_DownloadError_Error500");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download {
Url = "url", State = State.Downloading
};
repo.Insert(download);
manager.TaskError(new TaskError {
Id = download.Id,
Error = TaskErrorEnum.InvalidResponse,
StatusCode = 500
});
Assert.AreEqual(State.Error, download.State);
Assert.AreEqual(500, download.StatusCode);
}
public async Task Test_ProgressDownload_Progress1 ()
{
Console.WriteLine ("Test_ProgressDownload_Progress1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
Total = 0,
Written = 0
};
repo.Insert (download);
manager.ProgressDownload (new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
Assert.AreEqual (10, download.Written, "Written");
Assert.AreEqual (1000, download.Total, "Total");
Assert.AreEqual (ErrorEnum.Empty, downloaderror, "Downloaderror");
}
public async Task Test_QueueUrl_AlreadyQueued1 ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe<AlreadyQueued> (p => {
alreadyQueued = true;
wait1.Set();
});
bus.Subscribe<CheckFreeSlot> (p => {
checkFreeSlot = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip"
});
manager.QueueUrl (new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait1.WaitOne ();
Assert.AreEqual (false, checkFreeSlot);
Assert.AreEqual (true, alreadyQueued);
}
public async Task Test_ProgressDownload_DownloadError1()
{
Console.WriteLine("Test_ProgressDownload_DownloadError1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
manager.ProgressDownload(new ProgressDownload {
Id = 1,
Total = 1000,
Written = 10
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.ProgressDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_CancelDownloads_Multiple ()
{
Console.WriteLine ("Test_CancelDownloads_Multiple");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting = new Download { State = State.Waiting };
var error = new Download { State = State.Error };
var downloading = new Download { State = State.Downloading };
var finished = new Download { State = State.Finished };
repo.Insert (waiting);
repo.Insert (downloading);
repo.Insert (error);
repo.Insert (finished);
manager.CancelDownloads (new CancelDownloads {
});
Assert.AreEqual (State.Finished, waiting.State, "Waiting");
Assert.AreEqual (State.Finished, downloading.State, "Downloading");
Assert.AreEqual (State.Finished, error.State, "Error");
Assert.AreEqual (State.Finished, finished.State, "Finished");
}
public async Task Test_CancelDownloads_Multiple()
{
Console.WriteLine("Test_CancelDownloads_Multiple");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var waiting = new Download {
State = State.Waiting
};
var error = new Download {
State = State.Error
};
var downloading = new Download {
State = State.Downloading
};
var finished = new Download {
State = State.Finished
};
repo.Insert(waiting);
repo.Insert(downloading);
repo.Insert(error);
repo.Insert(finished);
manager.CancelDownloads(new CancelDownloads {
});
Assert.AreEqual(State.Finished, waiting.State, "Waiting");
Assert.AreEqual(State.Finished, downloading.State, "Downloading");
Assert.AreEqual(State.Finished, error.State, "Error");
Assert.AreEqual(State.Finished, finished.State, "Finished");
}
public async Task Test_FreeSlot_Queued_Error()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
var wait1 = new AutoResetEvent(false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe <QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe <QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip",
State = State.Error
});
manager.FreeSlot(new FreeSlot {
});
wait1.WaitOne();
Assert.AreEqual(false, queueDownload);
Assert.AreEqual(true, queueEmpty);
}
public async Task Test_FinishDownload_Finish1()
{
Console.WriteLine("Test_FinishDownload_Finish1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
};
repo.Insert(download);
manager.FinishedDownload(new FinishedDownload {
Id = download.Id,
});
Assert.AreEqual(ErrorEnum.Empty, downloaderror, "Downloaderror");
Assert.AreEqual(State.Finished, download.State, "Finished");
}
public async Task Test_FreeSlot_Nowait1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
var wait1 = new AutoResetEvent(false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe <QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe <QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
manager.FreeSlot(new FreeSlot {
});
wait1.WaitOne();
Assert.AreEqual(false, queueDownload);
Assert.AreEqual(true, queueEmpty);
}
public async Task Test_DownloadRejected_Error1 ()
{
Console.WriteLine ("Test_DownloadRejected_Error1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadRejected (new DownloadRejected {
Id = 0,
Reason = RejectionEnum.QueueFull
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.DownloadRejected_IdentifierNotFound, error);
}
public async Task Test_DownloadError_Error2 ()
{
Console.WriteLine ("Test_DownloadError_Error2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.TaskError (new TaskError {
Id = 0,
Error = TaskErrorEnum.InvalidResponse,
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.TaskError_IdentifierNotFound, error);
}
public async Task Test_ProgressDownload_ErrorInvalidState1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
var wait1 = new AutoResetEvent(false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Finished,
Total = 0,
Written = 0
};
repo.Insert(download);
manager.ProgressDownload(new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
wait1.WaitOne();
Assert.AreEqual(0, download.Written, "Written");
Assert.AreEqual(0, download.Total, "Total");
Assert.AreEqual(ErrorEnum.ProgressDownload_InvalidState, downloaderror, "DownloadError");
}
public async Task Test_DownloadError_Error1()
{
Console.WriteLine("Test_DownloadError_Error1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadError(new DownloadError {
Id = 0,
Error = ErrorEnum.Empty,
});
wait1.WaitOne(10);
Assert.AreEqual(ErrorEnum.Empty, error);
}
public async Task Test_ProgressDownload_Progress1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
Total = 0,
Written = 0
};
repo.Insert(download);
manager.ProgressDownload(new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
Assert.AreEqual(10, download.Written, "Written");
Assert.AreEqual(1000, download.Total, "Total");
Assert.AreEqual(ErrorEnum.Empty, downloaderror, "Downloaderror");
}
public async Task Test_DownloadRejected_1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download {
Url = "url", State = State.Downloading
};
repo.Insert(download);
manager.DownloadRejected(new DownloadRejected {
Id = 1,
Reason = RejectionEnum.QueueFull
});
Assert.AreEqual(State.Waiting, download.State);
}
public async Task Test_DownloadRejected_Error2()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
repo.Insert(new Download {
Url = "url", State = State.Finished
});
manager.DownloadRejected(new DownloadRejected {
Id = 1,
Reason = RejectionEnum.QueueFull
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.DownloadRejected_InvalidState, error);
}
public async Task Test_DownloadError_Error3()
{
Console.WriteLine("Test_DownloadError_Error3");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download {
Url = "url", State = State.Finished
};
repo.Insert(download);
manager.DownloadError(new DownloadError {
Id = download.Id,
Error = ErrorEnum.DidCompleteWithError_Error,
});
wait1.WaitOne(10);
Assert.AreEqual(ErrorEnum.Empty, error);
}
public int CountByState (DownloadManager.iOS.Bo.State state)
{
int count = Database
.Values
.Where (v => v.State == state)
.Count ();
return count;
}
public bool FirstByState (DownloadManager.iOS.Bo.State state, out DownloadManager.iOS.Bo.Download result)
{
var download = Database
.Values
.Where (v => v.State == state)
.FirstOrDefault ();
result = download;
return download != null;
}
public System.Collections.Generic.List<DownloadManager.iOS.Bo.Download> ByState (DownloadManager.iOS.Bo.State[] states)
{
var downloads = Database
.Values
.Where (v => states.Any (s => s == v.State))
.ToList ();
return downloads;
}
public async Task Test_FreeSlot_Empty3()
{
Console.WriteLine("Test_FreeSlot_Empty3");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
bool queuedownload = false;
bool queueempty = false;
bool queuefull = false;
bus.Subscribe <QueueDownload> (p => {
queuedownload = true;
wait1.Set();
});
bus.Subscribe <QueueFull> (p => {
queuefull = true;
wait1.Set();
});
bus.Subscribe <QueueEmpty> (p => {
queueempty = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file1.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file2.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file3.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file4.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file5.zip", State = State.Finished
});
manager.FreeSlot(new FreeSlot {
});
wait1.WaitOne();
Assert.AreEqual(false, queuedownload);
Assert.AreEqual(false, queuefull);
Assert.AreEqual(true, queueempty);
}
public async Task Test_CancelDownloads_Empty ()
{
Console.WriteLine ("Test_CancelDownloads_Empty");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
manager.CancelDownloads (new CancelDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public async Task Test_ResetDownloads_Empty()
{
Console.WriteLine("Test_ResetDownloads_Empty");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
manager.ResetDownloads(new ResetDownloads {
});
var all = repo.All();
Assert.AreEqual(0, all.Count);
}
public async Task Test_CancelDownloads_Single ()
{
Console.WriteLine ("Test_CancelDownloads_Single");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var download = new Download { State = State.Waiting };
repo.Insert (download);
manager.CancelDownloads (new CancelDownloads {
});
Assert.AreEqual (State.Finished, download.State, "First");
}
public async Task Test_ResetDownloads_Single ()
{
Console.WriteLine ("Test_ResetDownloads_Single");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var download = new Download { State = State.Waiting };
repo.Insert (download);
manager.ResetDownloads (new ResetDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public async Task Test_CancelDownloads_Single()
{
Console.WriteLine("Test_CancelDownloads_Single");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var download = new Download {
State = State.Waiting
};
repo.Insert(download);
manager.CancelDownloads(new CancelDownloads {
});
Assert.AreEqual(State.Finished, download.State, "First");
}
public async Task Test_ResetDownloads_Single()
{
Console.WriteLine("Test_ResetDownloads_Single");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var download = new Download {
State = State.Waiting
};
repo.Insert(download);
manager.ResetDownloads(new ResetDownloads {
});
var all = repo.All();
Assert.AreEqual(0, all.Count);
}
public async Task Test_QueueUrl_CheckFreeSlot1 ()
{
Console.WriteLine ("Test_QueueUrl_CheckFreeSlot1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait = new AutoResetEvent (false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe<AlreadyQueued> (p => {
try {
alreadyQueued = true;
wait.Set();
} catch(Exception e) {
Console.WriteLine (e);
}
});
bus.Subscribe<CheckFreeSlot> (p => {
try{
checkFreeSlot = true;
wait.Set();
} catch(Exception e) {
Console.WriteLine (e);
}
});
manager.QueueUrl (new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait.WaitOne ();
Assert.AreEqual (true, checkFreeSlot);
Assert.AreEqual (false, alreadyQueued);
}
public async Task Test_FreeSlot_Empty2 ()
{
Console.WriteLine ("Test_FreeSlot_Empty2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
bool queuedownload = false;
bool queueempty = false;
bool queuefull = false;
bus.Subscribe<QueueDownload> (p => {
queuedownload = true;
wait1.Set();
});
bus.Subscribe<QueueFull> (p => {
queuefull = true;
wait1.Set();
});
bus.Subscribe<QueueEmpty> (p => {
queueempty = true;
wait1.Set();
});
repo.Insert(new Download { Url = "http://url.com/download/file.zip", State = State.Finished });
manager.FreeSlot (new FreeSlot {
});
wait1.WaitOne ();
Assert.AreEqual (false, queuedownload);
Assert.AreEqual (false, queuefull);
Assert.AreEqual (true, queueempty);
}
public async Task Test_CancelDownloads_Multiple2()
{
Console.WriteLine("Test_CancelDownloads_Multiple2");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var waiting1 = new Download {
State = State.Waiting
};
var waiting2 = new Download {
State = State.Waiting
};
var waiting3 = new Download {
State = State.Waiting
};
var waiting4 = new Download {
State = State.Waiting
};
var waiting5 = new Download {
State = State.Waiting
};
repo.Insert(waiting1);
repo.Insert(waiting2);
repo.Insert(waiting3);
repo.Insert(waiting4);
repo.Insert(waiting5);
manager.CancelDownloads(new CancelDownloads {
});
Assert.AreEqual(State.Finished, waiting1.State, "Waiting1");
Assert.AreEqual(State.Finished, waiting2.State, "Waiting2");
Assert.AreEqual(State.Finished, waiting3.State, "Waiting3");
Assert.AreEqual(State.Finished, waiting4.State, "Waiting4");
Assert.AreEqual(State.Finished, waiting5.State, "Waiting5");
}
public async Task Test_ResetDownloads_Multiple2()
{
Console.WriteLine("Test_ResetDownloads_Multiple2");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var waiting1 = new Download {
State = State.Waiting
};
var waiting2 = new Download {
State = State.Waiting
};
var waiting3 = new Download {
State = State.Waiting
};
var waiting4 = new Download {
State = State.Waiting
};
var waiting5 = new Download {
State = State.Waiting
};
repo.Insert(waiting1);
repo.Insert(waiting2);
repo.Insert(waiting3);
repo.Insert(waiting4);
repo.Insert(waiting5);
manager.ResetDownloads(new ResetDownloads {
});
var all = repo.All();
Assert.AreEqual(0, all.Count);
}
public async Task Test_ResetDownloads_Multiple ()
{
Console.WriteLine ("Test_ResetDownloads_Multiple");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting = new Download { State = State.Waiting };
var error = new Download { State = State.Error };
var downloading = new Download { State = State.Downloading };
var finished = new Download { State = State.Finished };
repo.Insert (waiting);
repo.Insert (downloading);
repo.Insert (error);
repo.Insert (finished);
manager.ResetDownloads (new ResetDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public void Insert (DownloadManager.iOS.Bo.Download insert)
{
int id = Interlocked.Increment (ref _iterator);
insert.Id = id;
Database.Add (id, insert);
}
public void Update (DownloadManager.iOS.Bo.Download download)
{
}
public async Task Test_CancelDownloads_Multiple2 ()
{
Console.WriteLine ("Test_CancelDownloads_Multiple2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting1 = new Download { State = State.Waiting };
var waiting2 = new Download { State = State.Waiting };
var waiting3 = new Download { State = State.Waiting };
var waiting4 = new Download { State = State.Waiting };
var waiting5 = new Download { State = State.Waiting };
repo.Insert (waiting1);
repo.Insert (waiting2);
repo.Insert (waiting3);
repo.Insert (waiting4);
repo.Insert (waiting5);
manager.CancelDownloads (new CancelDownloads {
});
Assert.AreEqual (State.Finished, waiting1.State, "Waiting1");
Assert.AreEqual (State.Finished, waiting2.State, "Waiting2");
Assert.AreEqual (State.Finished, waiting3.State, "Waiting3");
Assert.AreEqual (State.Finished, waiting4.State, "Waiting4");
Assert.AreEqual (State.Finished, waiting5.State, "Waiting5");
}
public async Task Test_FreeSlot_Queued_Waiting ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe<QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe<QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip",
State = State.Error
});
repo.Insert(new Download {
Url = "http://url.com/download/file2.zip",
State = State.Waiting
});
manager.FreeSlot (new FreeSlot {
});
wait1.WaitOne ();
Assert.AreEqual (true, queueDownload);
Assert.AreEqual (false, queueEmpty);
}
public async Task Test_ProgressDownload_ErrorNotFound2 ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Downloading,
Total = 0,
Written = 0
};
repo.Insert (download);
manager.ProgressDownload (new ProgressDownload {
Id = 666,
Total = 1000,
Written = 10
});
wait1.WaitOne ();
Assert.AreEqual (0, download.Written, "Written");
Assert.AreEqual (0, download.Total, "Total");
Assert.AreEqual (ErrorEnum.ProgressDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_FreeSlot_Nowait1 ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe<QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe<QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
manager.FreeSlot (new FreeSlot {
});
wait1.WaitOne ();
Assert.AreEqual (false, queueDownload);
Assert.AreEqual (true, queueEmpty);
}
public async Task Test_DownloadError_Error404 ()
{
Console.WriteLine ("Test_DownloadError_Error404");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Downloading };
repo.Insert (download);
manager.DownloadError (new DownloadError {
Id = download.Id,
Error = ErrorEnum.DidCompleteWithError_Error,
});
wait1.WaitOne (10);
Assert.AreEqual (State.Downloading, download.State);
Assert.AreEqual (0, download.StatusCode);
}
public async Task Test_DownloadError_Error500 ()
{
Console.WriteLine ("Test_DownloadError_Error500");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Downloading };
repo.Insert (download);
manager.TaskError (new TaskError {
Id = download.Id,
Error = TaskErrorEnum.InvalidResponse,
StatusCode = 500
});
Assert.AreEqual (State.Error, download.State);
Assert.AreEqual (500, download.StatusCode);
}
public async Task Test_ProgressDownload_ErrorInvalidState1 ()
{
Console.WriteLine ("Test_ProgressDownload_ErrorInvalidState1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Finished,
Total = 0,
Written = 0
};
repo.Insert (download);
manager.ProgressDownload (new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
wait1.WaitOne ();
Assert.AreEqual (0, download.Written, "Written");
Assert.AreEqual (0, download.Total, "Total");
Assert.AreEqual (ErrorEnum.ProgressDownload_OutOfOrder, downloaderror, "DownloadError");
}
