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()); }