public AsyncTask UploadAsync(UploadParameter uploadParam, AsyncCallbacks <UploadResult> asyncCallbacks)
{
CheckParameter(uploadParam != null, "uploadParam is required");
var asyncTask = new AsyncTask();
AsyncUtils.ProcessFirstItem(DoUpload(uploadParam), asyncCallbacks, asyncTask);
return(asyncTask);
}
public AsyncTask SearchAsync(SearchParameter param, AsyncCallbacks <SearchResult> asyncCallbacks = null)
{
CheckParameter(param != null, "param is required");
var asyncTask = new AsyncTask();
AsyncUtils.ProcessFirstItem(DoSearch(param), asyncCallbacks, asyncTask);
return(asyncTask);
}
public AsyncTask DownloadAsync(DownloadParameter downloadParam,
AsyncCallbacks <DownloadResult> asyncCallbacks = null)
{
CheckParameter(downloadParam != null, "downloadParam is required");
var asyncTask = new AsyncTask();
AsyncUtils.ProcessFirstItem(DoCompleteDownload(downloadParam), asyncCallbacks, asyncTask);
return(asyncTask);
}
public AsyncTask DirectDownloadAsync(DirectDownloadParameter directDownloadParameter,
AsyncCallbacks <Stream> asyncCallbacks = null)
{
CheckParameter(directDownloadParameter != null, "directDownloadParameter is required");
var asyncTask = new AsyncTask();
AsyncUtils.ProcessFirstItem(DoDirectDownload(directDownloadParameter), asyncCallbacks, asyncTask);
return(asyncTask);
}
public void ShouldDownloadAsynchronouslyWithFailureCallback()
{
var param = DownloadParameter.Create("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA").Build();
var taskCompletionSource = new TaskCompletionSource <Exception>();
var asyncCallbacks = AsyncCallbacks <DownloadResult> .Create <DownloadResult>(
null, ex => taskCompletionSource.SetResult(ex));
UnitUnderTest.DownloadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var exception = taskCompletionSource.Task.Result;
Assert.IsInstanceOfType(exception, exception.GetType());
}
public void ShouldSearchAsynchronouslyWithSuccessCallback()
{
var param = SearchParameter.CreateForAddress(AccountAddress1).Build();
var taskCompletionSource = new TaskCompletionSource <SearchResult>();
var asyncCallbacks = AsyncCallbacks <SearchResult> .Create <SearchResult>(
searchResult => taskCompletionSource.SetResult(searchResult), null);
UnitUnderTest.SearchAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var result = taskCompletionSource.Task.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Results);
Assert.AreEqual(result.Results.Count, 10);
}
public void ShouldUploadAsynchronouslyWithFailureCallback()
{
var param = UploadParameter
.CreateForFileUpload(TestTextFile, AccountPrivateKey1)
.WithPrivacyStrategy(new NotImplementedPrivacyStrategy())
.Build();
var taskCompletionSource = new TaskCompletionSource <Exception>();
var asyncCallbacks = AsyncCallbacks <UploadResult> .Create <UploadResult>(
null, ex => taskCompletionSource.SetResult(ex));
UnitUnderTest.UploadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var exception = taskCompletionSource.Task.Result;
Assert.IsInstanceOfType(exception, exception.GetType());
}
public void ShouldUploadAsynchronouslyWithSuccessCallback()
{
var param = UploadParameter
.CreateForFileUpload(TestTextFile, AccountPrivateKey1)
.Build();
var taskCompletionSource = new TaskCompletionSource <UploadResult>();
var asyncCallbacks = AsyncCallbacks <UploadResult> .Create <UploadResult>(
uploadResult => taskCompletionSource.SetResult(uploadResult), null);
UnitUnderTest.UploadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var result = taskCompletionSource.Task.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
}
public static void ProcessFirstItem <T>(IObservable <T> observable, AsyncCallbacks <T> asyncCallbacks,
AsyncTask asyncTask)
{
CheckParameter(observable != null, "observable is required");
CheckParameter(asyncTask != null, "asyncTask is required");
observable.FirstAsync()
.Subscribe(
result =>
{
asyncCallbacks?.OnSuccess(result);
asyncTask.SetToDone();
}, exception =>
{
asyncCallbacks?.OnFailure(exception);
asyncTask.SetToDone();
});
}
public void ShouldDownloadAsynchronouslyWithSuccessCallback()
{
var transactionHash = TestDataRepository
.GetData("UploaderIntegrationTests.ShouldUploadByteArray", "transactionHash");
var param = DownloadParameter.Create(transactionHash).Build();
var taskCompletionSource = new TaskCompletionSource <DownloadResult>();
var asyncCallbacks = AsyncCallbacks <DownloadResult> .Create <DownloadResult>(
downloadResult => taskCompletionSource.SetResult(downloadResult), null);
UnitUnderTest.DownloadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var result = taskCompletionSource.Task.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Data.GetByteStream().GetContentAsByteArray());
}
public void ShouldDirectDownloadAsynchronouslyWithSuccessCallback()
{
var dataHash = TestDataRepository
.GetData("UploaderIntegrationTests.ShouldUploadByteArray", "dataHash");
var param = DirectDownloadParameter.CreateFromDataHash(dataHash).Build();
var taskCompletionSource = new TaskCompletionSource <Stream>();
var asyncCallbacks = AsyncCallbacks <Stream> .Create <Stream>(
streamResult => taskCompletionSource.SetResult(streamResult), null);
UnitUnderTest.DirectDownloadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var result = taskCompletionSource.Task.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.GetContentAsByteArray());
}
public void ShouldDirectDownloadMultipleRequestsAsynchronously()
{
var dataHash = TestDataRepository
.GetData("UploaderIntegrationTests.ShouldUploadByteArray", "dataHash");
var param = DirectDownloadParameter.CreateFromDataHash(dataHash).Build();
;
var taskCompletionSource1 = new TaskCompletionSource <Stream>();
var taskCompletionSource2 = new TaskCompletionSource <Stream>();
var taskCompletionSource3 = new TaskCompletionSource <Stream>();
var asyncCallbacks1 = AsyncCallbacks <Stream> .Create <Stream>(
streamResult => taskCompletionSource1.SetResult(streamResult), null);
var asyncCallbacks2 = AsyncCallbacks <Stream> .Create <Stream>(
streamResult => taskCompletionSource2.SetResult(streamResult), null);
var asyncCallbacks3 = AsyncCallbacks <Stream> .Create <Stream>(
streamResult => taskCompletionSource3.SetResult(streamResult), null);
UnitUnderTest.DirectDownloadAsync(param, asyncCallbacks1);
UnitUnderTest.DirectDownloadAsync(param, asyncCallbacks2);
UnitUnderTest.DirectDownloadAsync(param, asyncCallbacks3);
taskCompletionSource1.Task.Wait(5000);
taskCompletionSource2.Task.Wait(5000);
taskCompletionSource3.Task.Wait(5000);
var result1 = taskCompletionSource1.Task.Result;
Assert.IsNotNull(result1);
Assert.IsNotNull(result1.GetContentAsByteArray());
var result2 = taskCompletionSource1.Task.Result;
Assert.IsNotNull(result2);
Assert.IsNotNull(result2.GetContentAsByteArray());
var result3 = taskCompletionSource1.Task.Result;
Assert.IsNotNull(result3);
Assert.IsNotNull(result3.GetContentAsByteArray());
}
public void ShouldDownloadMultipleRequestsAsynchronously()
{
var transactionHash = TestDataRepository
.GetData("UploaderIntegrationTests.ShouldUploadByteArray", "transactionHash");
var param = DownloadParameter.Create(transactionHash).Build();
var taskCompletionSource1 = new TaskCompletionSource <DownloadResult>();
var taskCompletionSource2 = new TaskCompletionSource <DownloadResult>();
var taskCompletionSource3 = new TaskCompletionSource <DownloadResult>();
var asyncCallbacks1 = AsyncCallbacks <DownloadResult> .Create <DownloadResult>(
downloadResult => taskCompletionSource1.SetResult(downloadResult), null);
var asyncCallbacks2 = AsyncCallbacks <DownloadResult> .Create <DownloadResult>(
downloadResult => taskCompletionSource2.SetResult(downloadResult), null);
var asyncCallbacks3 = AsyncCallbacks <DownloadResult> .Create <DownloadResult>(
downloadResult => taskCompletionSource3.SetResult(downloadResult), null);
UnitUnderTest.DownloadAsync(param, asyncCallbacks1);
UnitUnderTest.DownloadAsync(param, asyncCallbacks2);
UnitUnderTest.DownloadAsync(param, asyncCallbacks3);
taskCompletionSource1.Task.Wait(5000);
taskCompletionSource2.Task.Wait(5000);
taskCompletionSource3.Task.Wait(5000);
var result1 = taskCompletionSource1.Task.Result;
Assert.IsNotNull(result1);
Assert.IsNotNull(result1.Data.GetByteStream().GetContentAsByteArray());
var result2 = taskCompletionSource1.Task.Result;
Assert.IsNotNull(result2);
Assert.IsNotNull(result2.Data.GetByteStream().GetContentAsByteArray());
var result3 = taskCompletionSource1.Task.Result;
Assert.IsNotNull(result3);
Assert.IsNotNull(result3.Data.GetByteStream().GetContentAsByteArray());
}
