public async Task Post_Accepts_Contact_With_Name_Mocked_Repo()
{
var mockRepo = new DataRepositoryCodeMock {
AllContacts = new List <ContactInfo>()
};
var webHost = new Microsoft.AspNetCore.Hosting.WebHostBuilder()
.UseStartup <Demo.WebApp.Startup>()
.ConfigureServices(
services =>
{
services.AddSingleton <IDataRepository>(t => mockRepo);
}
);;
var server = new Microsoft.AspNetCore.TestHost.TestServer(webHost);
var client = server.CreateClient();
var content = new StringContent(@"{'name':'Bobby Tables','email': '*****@*****.**'}", Encoding.UTF8, "application/json");
var response = await client.PostAsync("api/contact", content);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var responseString = await response.Content.ReadAsStringAsync();
mockRepo.AllContacts.Any(c => c.Name == "Bobby Tables");
}
private static HttpClient GetByConfig(Action <WebHostBuilder> configureDelegate)
{
var b = new WebHostBuilder();
configureDelegate(b);
b.UseStartup <TSetup>();
var fc = new FeatureCollection();
var f = new HttpConnectionFeature();
f.RemoteIpAddress = new IPAddress(new byte[] { 172, 0, 0, 1 });
f.RemotePort = 80;
fc.Set(f);
var srv = new Microsoft.AspNetCore.TestHost.TestServer(b, fc);
return(srv.CreateClient());
}
public async Task Post_Rejects_Contact_With_Missing_Name()
{
var webHost = new Microsoft.AspNetCore.Hosting.WebHostBuilder().UseStartup <Demo.WebApp.Startup>();
var server = new Microsoft.AspNetCore.TestHost.TestServer(webHost);
var client = server.CreateClient();
var content = new StringContent(@"{'email': '*****@*****.**'}", Encoding.UTF8, "application/json");
var response = await client.PostAsync("api/contact", content);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var responseString = await response.Content.ReadAsStringAsync();
var actualErrors = JsonConvert.DeserializeObject <Dictionary <string, string[]> >(responseString);
Assert.Equal("The Name field is required.", actualErrors["Name"][0]);
}
public async Task Get_Returns_Data_With_Moq()
{
var mockRepo = new Mock <IDataRepository>();
var webHost = new Microsoft.AspNetCore.Hosting.WebHostBuilder()
.UseStartup <Demo.WebApp.Startup>()
.ConfigureServices(
services =>
{
services.AddSingleton <IDataRepository>(t => mockRepo.Object);
}
);;
var server = new Microsoft.AspNetCore.TestHost.TestServer(webHost);
var client = server.CreateClient();
client.DefaultRequestHeaders.Add("ApiKey", "SomeKey");
var response = await client.GetAsync("api/contact");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
mockRepo.Verify(r => r.GetAllContacts(), Times.Once);
}
public async Task Get_Returns_Data_With_Mock()
{
var mockRepo = A.Fake <IDataRepository>();
var webHost = new Microsoft.AspNetCore.Hosting.WebHostBuilder()
.UseStartup <Demo.WebApp.Startup>()
.ConfigureServices(
services =>
{
services.AddSingleton <IDataRepository>(t => mockRepo);
}
);;
var server = new Microsoft.AspNetCore.TestHost.TestServer(webHost);
var client = server.CreateClient();
client.DefaultRequestHeaders.Add("ApiKey", "SomeKey");
var response = await client.GetAsync("api/contact");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
A.CallTo(() => mockRepo.GetAllContacts()).MustHaveHappened();
}
public async Task ClientStreaming_ResponseCompletesWithoutReadingRequest()
{
// Arrange
var requestStreamTcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var responseEndingSyncPoint = new SyncPoint();
RequestDelegate appDelegate = async ctx =>
{
await ctx.Response.WriteAsync("POST Response");
await responseEndingSyncPoint.WaitToContinue();
};
Stream requestStream = null;
var builder = new WebHostBuilder().Configure(app => app.Run(appDelegate));
var server = new TestServer(builder);
var client = server.CreateClient();
var httpRequest = new HttpRequestMessage(HttpMethod.Post, "http://localhost:12345");
httpRequest.Version = new Version(2, 0);
httpRequest.Content = new PushContent(async stream =>
{
requestStream = stream;
await requestStreamTcs.Task;
});
// Act
var response = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead).WithTimeout();
var responseContent = await response.Content.ReadAsStreamAsync().WithTimeout();
// Assert
// Read response
byte[] buffer = new byte[1024];
var length = await responseContent.ReadAsync(buffer).AsTask().WithTimeout();
Assert.Equal("POST Response", Encoding.UTF8.GetString(buffer, 0, length));
// Send large content and block on back pressure
var writeTask = Task.Run(async() =>
{
try
{
await requestStream.WriteAsync(Encoding.UTF8.GetBytes(new string('!', 1024 * 1024 * 50))).AsTask().WithTimeout();
requestStreamTcs.SetResult(null);
}
catch (Exception ex)
{
requestStreamTcs.SetException(ex);
}
});
responseEndingSyncPoint.Continue();
// No more response content
length = await responseContent.ReadAsync(buffer).AsTask().WithTimeout();
Assert.Equal(0, length);
await writeTask;
}
public async Task ClientStreaming_Cancellation()
{
// Arrange
var responseStartedSyncPoint = new SyncPoint();
var responseReadSyncPoint = new SyncPoint();
var responseEndingSyncPoint = new SyncPoint();
var requestStreamSyncPoint = new SyncPoint();
var readCanceled = false;
RequestDelegate appDelegate = async ctx =>
{
// Send headers
await ctx.Response.BodyWriter.FlushAsync();
// Ensure headers received by client
await responseStartedSyncPoint.WaitToContinue();
var serverBuffer = new byte[1024];
var serverLength = await ctx.Request.Body.ReadAsync(serverBuffer);
Assert.Equal("SENT", Encoding.UTF8.GetString(serverBuffer, 0, serverLength));
await responseReadSyncPoint.WaitToContinue();
try
{
await ctx.Request.Body.ReadAsync(serverBuffer);
}
catch (OperationCanceledException)
{
readCanceled = true;
}
await responseEndingSyncPoint.WaitToContinue();
};
Stream requestStream = null;
var builder = new WebHostBuilder().Configure(app => app.Run(appDelegate));
var server = new TestServer(builder);
var client = server.CreateClient();
var httpRequest = new HttpRequestMessage(HttpMethod.Post, "http://localhost:12345");
httpRequest.Version = new Version(2, 0);
httpRequest.Content = new PushContent(async stream =>
{
requestStream = stream;
await requestStreamSyncPoint.WaitToContinue();
});
// Act
var response = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead).WithTimeout();
await responseStartedSyncPoint.WaitForSyncPoint().WithTimeout();
responseStartedSyncPoint.Continue();
var responseContent = await response.Content.ReadAsStreamAsync().WithTimeout();
// Assert
// Ensure request stream has started
await requestStreamSyncPoint.WaitForSyncPoint();
// Write to request
await requestStream.WriteAsync(Encoding.UTF8.GetBytes("SENT")).AsTask().WithTimeout();
await requestStream.FlushAsync().WithTimeout();
await responseReadSyncPoint.WaitForSyncPoint().WithTimeout();
// Cancel request. Disposing response must be used because SendAsync has finished.
response.Dispose();
responseReadSyncPoint.Continue();
await responseEndingSyncPoint.WaitForSyncPoint().WithTimeout();
responseEndingSyncPoint.Continue();
Assert.True(readCanceled);
requestStreamSyncPoint.Continue();
}
public async Task ClientStreamingWorks()
{
// Arrange
var responseStartedSyncPoint = new SyncPoint();
var requestEndingSyncPoint = new SyncPoint();
var requestStreamSyncPoint = new SyncPoint();
RequestDelegate appDelegate = async ctx =>
{
// Send headers
await ctx.Response.BodyWriter.FlushAsync();
// Ensure headers received by client
await responseStartedSyncPoint.WaitToContinue();
await ctx.Response.WriteAsync("STARTED");
// ReadToEndAsync will wait until request body is complete
var requestString = await new StreamReader(ctx.Request.Body).ReadToEndAsync();
await ctx.Response.WriteAsync(requestString + " POST Response");
await requestEndingSyncPoint.WaitToContinue();
};
Stream requestStream = null;
var builder = new WebHostBuilder().Configure(app => app.Run(appDelegate));
var server = new TestServer(builder);
var client = server.CreateClient();
var httpRequest = new HttpRequestMessage(HttpMethod.Post, "http://localhost:12345");
httpRequest.Version = new Version(2, 0);
httpRequest.Content = new PushContent(async stream =>
{
requestStream = stream;
await requestStreamSyncPoint.WaitToContinue();
});
// Act
var response = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead).WithTimeout();
await responseStartedSyncPoint.WaitForSyncPoint().WithTimeout();
responseStartedSyncPoint.Continue();
var responseContent = await response.Content.ReadAsStreamAsync().WithTimeout();
// Assert
// Ensure request stream has started
await requestStreamSyncPoint.WaitForSyncPoint();
byte[] buffer = new byte[1024];
var length = await responseContent.ReadAsync(buffer).AsTask().WithTimeout();
Assert.Equal("STARTED", Encoding.UTF8.GetString(buffer, 0, length));
// Send content and finish request body
await requestStream.WriteAsync(Encoding.UTF8.GetBytes("Hello world")).AsTask().WithTimeout();
await requestStream.FlushAsync().WithTimeout();
requestStreamSyncPoint.Continue();
// Ensure content is received while request is in progress
length = await responseContent.ReadAsync(buffer).AsTask().WithTimeout();
Assert.Equal("Hello world POST Response", Encoding.UTF8.GetString(buffer, 0, length));
// Request is ending
await requestEndingSyncPoint.WaitForSyncPoint().WithTimeout();
requestEndingSyncPoint.Continue();
// No more response content
length = await responseContent.ReadAsync(buffer).AsTask().WithTimeout();
Assert.Equal(0, length);
}
public async Task CancelAborts()
{
var builder = new WebHostBuilder()
.Configure(app =>
{
app.Run(context =>
{
TaskCompletionSource <int> tcs = new TaskCompletionSource <int>();
tcs.SetCanceled();
return(tcs.Task);
});
});
var server = new TestServer(builder);
await Assert.ThrowsAsync <TaskCanceledException>(async() => { string result = await server.CreateClient().GetStringAsync("/path"); });
}
private static HttpClient MintClient()
{
return(_testServer.CreateClient());
}
