public async Task Should_Just_Work()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var responder = TestClientFactory.CreateNormal())
{
const int numberOfCalls = 10000;
var array = new Task[numberOfCalls];
responder.RespondAsync<FirstRequest, FirstResponse>((req, i) =>
Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() })
);
/* Test */
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < numberOfCalls; i++)
{
var response = requester.RequestAsync<FirstRequest, FirstResponse>();
array[i] = response;
}
Task.WaitAll(array);
sw.Stop();
var ids = array
.OfType<Task<FirstResponse>>()
.Select(b => b.Result.Infered)
.Where(id => id != Guid.Empty)
.Distinct()
.ToList();
/* Assert */
Assert.Equal(expected: numberOfCalls, actual: ids.Count);
}
}
public async Task Should_Work_For_Multiple_Types()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var responder = TestClientFactory.CreateNormal())
{
const int numberOfCalls = 10000;
var firstResponseTasks = new Task[numberOfCalls];
var secondResponseTasks = new Task[numberOfCalls];
responder.RespondAsync<FirstRequest, FirstResponse>((req, i) =>
Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() }));
responder.RespondAsync<SecondRequest, SecondResponse>((request, context) =>
Task.FromResult(new SecondResponse { Source = Guid.NewGuid() }));
/* Test */
for (var i = 0; i < numberOfCalls; i++)
{
var firstResponse = requester.RequestAsync<FirstRequest, FirstResponse>();
var secondResponse = requester.RequestAsync<SecondRequest, SecondResponse>();
firstResponseTasks[i] = firstResponse;
secondResponseTasks[i] = secondResponse;
}
Task.WaitAll(firstResponseTasks.Concat(secondResponseTasks).ToArray());
var firstIds = firstResponseTasks
.OfType<Task<FirstResponse>>()
.Select(b => b.Result.Infered)
.Where(id => id != Guid.Empty)
.Distinct()
.ToList();
var secondIds = secondResponseTasks
.OfType<Task<SecondResponse>>()
.Select(b => b.Result.Source)
.Where(id => id != Guid.Empty)
.Distinct()
.ToList();
/* Assert */
Assert.Equal(expected: numberOfCalls, actual: firstIds.Count);
Assert.Equal(expected: numberOfCalls, actual: secondIds.Count);
}
}
public async Task Should_Work_When_Not_Awaiting_One_Response_At_A_Time()
{
/* Setup */
const int numberOfCalls = 10;
var tasks = new Task[numberOfCalls];
var requester = BusClientFactory.CreateDefault();
var responder = BusClientFactory.CreateDefault();
responder.RespondAsync<FirstRequest, FirstResponse>((req, i) => Task.FromResult(new FirstResponse { Infered = Guid.NewGuid()}));
/* Test */
for (int i = 0; i < numberOfCalls; i++)
{
var responseTask = requester.RequestAsync<FirstRequest, FirstResponse>();
tasks[i] = responseTask;
}
Task.WaitAll(tasks);
var ids = tasks
.OfType<Task<FirstResponse>>()
.Select(t => t.Result.Infered)
.Distinct()
.ToList();
/* Assert */
Assert.Equal(ids.Count, numberOfCalls);
}
private List<MedicineRaw> GetMedicines()
{
string page1 = this.GetResponseTextWithCache(1);
var document1 = new HtmlDocument();
document1.LoadHtml(page1);
HtmlNode linkFim = document1.DocumentNode.SelectSingleNode("//a[contains(text(), 'Fim')]");
string hrefLinkFim = linkFim.GetAttributeValue("href", "");
int regexCountPages = int.Parse(Regex.Match(hrefLinkFim, @"(?<=&pagina=)\d+").Value);
var listTasks = new Task<List<MedicineRaw>>[regexCountPages];
for (int pagina = 0; pagina < regexCountPages; pagina++)
listTasks[pagina] = new Task<List<MedicineRaw>>(this.GetItems, pagina + 1);
foreach (var eachTask in listTasks)
eachTask.Start();
Task.WaitAll(listTasks.OfType<Task>().ToArray());
List<MedicineRaw> medicines = listTasks.SelectMany(t => t.Result).ToList();
return medicines;
}
public async Task Should_Work_When_Not_Awaiting_One_Response_At_A_Time()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var responder = TestClientFactory.CreateNormal())
{
const int numberOfCalls = 10;
var tasks = new Task[numberOfCalls];
responder.RespondAsync<FirstRequest, FirstResponse>((req, i) =>
Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() }),
cfg => cfg.WithQueue(q => q.WithAutoDelete()));
/* Test */
for (int i = 0; i < numberOfCalls; i++)
{
var responseTask = requester.RequestAsync<FirstRequest, FirstResponse>();
tasks[i] = responseTask;
}
Task.WaitAll(tasks);
var ids = tasks
.OfType<Task<FirstResponse>>()
.Select(t => t.Result.Infered)
.Distinct()
.ToList();
/* Assert */
Assert.Equal(expected: numberOfCalls, actual: ids.Count);
}
}
