public async Task A_Transaction_Will_Be_Created() { const int Quantity_To_Sell = 8; var client = _factory.CreateDefaultClient(); var createdAccountDetails = await CreateAccount(client); var purchase = await CreatePurchase(client, createdAccountDetails); var requestData = new SellRequest() { AccountNumber = createdAccountDetails.AccountNumber, MinUnitPrice = 100, ProductCode = Constants.ProductA, Quantity = Quantity_To_Sell }; var response = await client.PostAsJsonAsync("/api/Sales", requestData); response.EnsureSuccessStatusCode(); var responseData = await response.Content.ReadAsJsonAsync <Sale>(); Assert.True(responseData.Success); Assert.Equal(Constants.ProductA, responseData.ProductCode); Assert.Equal(Quantity_To_Sell, responseData.Quantity); Assert.True(responseData.UnitPrice >= requestData.MinUnitPrice); Assert.Equal(responseData.UnitPrice * Quantity_To_Sell, responseData.TotalValue); Assert.NotEqual(Guid.Empty, responseData.TransactionID); }
/// <summary> /// Asynchronously authenticates the user and returns the claims associated with the authenticated user. /// </summary> /// <param name="server">The test server to use to authenticate the user.</param> /// <returns> /// A dictionary containing the claims for the authenticated user. /// </returns> protected async Task <IDictionary <string, Claim> > AuthenticateUserAsync(WebApplicationFactory <Program> server) { IEnumerable <string> cookies; // Arrange - Force a request chain that challenges the request to the authentication // handler and returns an authentication cookie to log the user in to the application. using (var client = server.CreateDefaultClient(new LoopbackRedirectHandler() { UserIdentity = UserIdentity, UserAttributes = UserAttributes })) { // Act using (var result = await client.GetAsync("/me")) { // Assert result.StatusCode.ShouldBe(HttpStatusCode.Found); cookies = result.Headers.GetValues("Set-Cookie"); } } XElement element; // Arrange - Perform an authenticated HTTP request to get the claims for the logged-in users using (var client = server.CreateDefaultClient()) { client.DefaultRequestHeaders.Add("Cookie", cookies); // Act using (var result = await client.GetAsync("/me")) { // Assert result.StatusCode.ShouldBe(HttpStatusCode.OK); result.Content.Headers.ContentType.MediaType.ShouldBe("text/xml"); string xml = await result.Content.ReadAsStringAsync(); element = XElement.Parse(xml); } } element.Name.ShouldBe("claims"); element.Elements("claim").Count().ShouldBeGreaterThanOrEqualTo(1); var claims = new List <Claim>(); foreach (var claim in element.Elements("claim")) { claims.Add( new Claim( claim.Attribute("type").Value, claim.Attribute("value").Value, claim.Attribute("valueType").Value, claim.Attribute("issuer").Value)); } return(claims.ToDictionary((key) => key.Type, (value) => value)); }
public void WebApplicationFactory_should_initialize_Api_once() { for (int i = 0; i < 10; ++i) { _factory.CreateDefaultClient(); } // This looks ok, the server is initialized once Assert.Equal(1, Startup.NumberOfCalls); }
public async Task Given_A_New_Account_Then_No_Data_Will_Be_Returned() { var client = _factory.CreateDefaultClient(); var createdAccountDetails = await CreateAccount(client); var response = await client.GetAsync($"/api/Accounts/{createdAccountDetails.AccountNumber}/Transactions"); var transactions = await response.Content.ReadAsJsonAsync <IEnumerable <Transaction> >(); Assert.Empty(transactions); }
public async Task ShouldLogHelloWorld() { // Arrange // Act await _factory.CreateDefaultClient().GetAsync("/"); var log = Assert.Single(_factory.GetSerilogTestLoggerSink().LogEntries); // Assert the message rendered by a default formatter Assert.Equal("Hello \"World\"!", log.Message); }
public async Task ShouldLogHelloWorld() { // Arrange // Act await _factory.CreateDefaultClient().GetAsync("/"); // Assert Assert.Equal(1, _sink.Writes.Count); var log = _sink.Writes.Single(); // Assert the message rendered by a default formatter Assert.Equal("Hello World!", log.Message); }
protected virtual WebApplicationFactory <Startup> CreateFactory() { var f = new WebApplicationFactory <Startup>() .WithWebHostBuilder(builder => builder.UseContentRoot(".")); //{ // Environment = TestEnvironment //}; var secretRepository = new SecretStore(); secretRepository.Assign("1234", "ABCD"); var mrb = new HmacMessageRepresentationBuilder(); var calculator = new HmacSignatureCalculator(); HmacClient = new HmacClient { ClientId = "1234" }; var hmacHandler = new HmacClientHandler(HmacClient); var requestContentMd5Handler = new RequestContentMd5Handler(); var hmacSigningHandler = new HmacSigningHandler(secretRepository, mrb, calculator); // Inject all the handlers in the correct order Client = f.CreateDefaultClient(hmacHandler, requestContentMd5Handler, hmacSigningHandler); //Startup = Program.Startup; return(f); }
public static HttpClient CreateClientForGrpc <TEntryPoint>(this WebApplicationFactory <TEntryPoint> webApplicationFactory) where TEntryPoint : class { return(webApplicationFactory.CreateDefaultClient(new DelegatingHandler[] { new OverrideResponseHttpVersionHandler(HttpVersion.Version20) })); }
public static void Initialize() { Instance = new WebApplicationFactory <Startup>(); // Actually the WebApplicationFactory has a problem that until CreateDefaultClient() is called, no underlying TestServer instance is created. // Also, the underlying TestServer creation has a race condition, calling it from tests running in parallel may cause multiple servers to be spawned. Instance.CreateDefaultClient(); }
public static HttpClient CreateHttpClient <TStartup>(this WebApplicationFactory <TStartup> factory) where TStartup : class { return(factory.CreateDefaultClient( new TestHttpClientAuthenticationHandler(), new HttpClientExceptionHandler())); }
public void Test1() { Environment.SetEnvironmentVariable("rp_enabled", "false"); var client = _factory.CreateDefaultClient(); client.MaxResponseContentBufferSize = int.MaxValue; GrpcChannel ch = GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions { HttpClient = client, MaxReceiveMessageSize = null }); var service = new Gauge.Messages.Reporter.ReporterClient(ch); service.NotifyExecutionStarting( new Gauge.Messages.ExecutionStartingRequest() { CurrentExecutionInfo = new Gauge.Messages.ExecutionInfo { ProjectName = new string('A', 150 * 1024 * 1024) } }); }
public async Task The_Account_Number_Is_Generated() { var client = _factory.CreateDefaultClient(); var requestData = new NewAccountRequest() { AccountName = "Test Account - " + Guid.NewGuid().ToString() }; var response = await client.PostAsJsonAsync("/api/Accounts", requestData); response.EnsureSuccessStatusCode(); var responseData = await response.Content.ReadAsJsonAsync <AccountDetails>(); Assert.NotEqual(Guid.Empty, responseData.AccountNumber); }
public ModelBindingShould(WebApplicationFactory <Example.Startup> factory, ITestOutputHelper output) { _factory = factory; _output = output; _postCapture = new HttpPostCaptureDelegatingHandler(); _client = factory.CreateDefaultClient(_postCapture); }
public PaymentsenseCodingChallengeControllerTests(WebApplicationFactory <Startup> factory) { _httpClient = factory.CreateDefaultClient(); _mockLogger = new Mock <ILoggerManager>(); sut = new CountriesController(_mockLogger.Object); }
public TestAppFactory(WebApplicationFactory <Startup> factory) { Environment.SetEnvironmentVariable("SES_ACCESS_KEY", "access-key"); Environment.SetEnvironmentVariable("SES_SECRET_KEY", "secret-key"); _factory = factory.WithWebHostBuilder(builder => { builder .UseEnvironment("integrationtest") .UseContentRoot(Path.GetFullPath(Path.Combine( PlatformServices.Default.Application.ApplicationBasePath, "..", "..", "..", "..", "..", "src", "StockportWebapp"))) .ConfigureTestServices(services => { services.AddSingleton <IHttpClient>(p => GetHttpClient(p.GetService <ILoggerFactory>())); services.AddSingleton <Func <HttpClient> >(p => () => new HttpClient(new FakeResponseHandlerFactory().ResponseHandler)); services.AddSingleton <IHttpEmailClient, FakeHttpEmailClient>(); services.AddMvc(options => { for (var i = 0; i < options.Filters.Count; i++) { options.Filters.RemoveAt(i); } }); }); }); _client = _factory.CreateDefaultClient(); }
public AppFixture() { _webAppFactory = new WebApplicationFactory <Startup>().WithWebHostBuilder(builder => { builder.UseEnvironment("IntegrationTesting"); builder.ConfigureAppConfiguration(configBuilder => { var config = configBuilder.Build(); var azureAdOptions = config.GetSection("AzureAd").Get <AzureAdOptions>(); var appAuthentication = config.GetSection("AppAuthenticationSetting").Get <AppAuthenticationSettings>(); var userAuthentication = config.GetSection("UserAuthenticationSettings").Get <UserAuthenticationSettings>(); var userAdmin = config.GetSection("UserAdmin").Get <UserAuthenticationSettingsDetails>(); var userRegular = config.GetSection("UserRegular").Get <UserAuthenticationSettingsDetails>(); var userNotInDatabase = config.GetSection("UserNotInDatabase").Get <UserAuthenticationSettingsDetails>(); var userNoRoles = config.GetSection("UserNoRoles").Get <UserAuthenticationSettingsDetails>(); var wrongRolesScopesComb = config.GetSection("WrongRolesScopesComb").Get <UserAuthenticationSettingsWrongRolesScopesComb>(); Settings = new IntegrationTestSettings { Authority = $@"{azureAdOptions.Authority}/v2.0", ApplicationIdUri = azureAdOptions.ApplicationIdUri, AppAuthentication = appAuthentication, UserAuthentication = userAuthentication, UserAdmin = userAdmin, UserRegular = userRegular, UserNotInDatabase = userNotInDatabase, UserNoRoles = userNoRoles, WrongRolesScopesComb = wrongRolesScopesComb }; }); }); Client = _webAppFactory.CreateDefaultClient(); }
public async Task HealthCheck_Always_ShouldReturnOk() { var httpClient = _factory.CreateDefaultClient(); var response = await httpClient.GetAsync(HealthCheckEndpoint); response.EnsureSuccessStatusCode(); }
public static GrpcChannel CreateGrpcChannel(this WebApplicationFactory <Startup> factory, DelegatingHandler handler) { var client = factory.CreateDefaultClient(handler); return(GrpcChannel.ForAddress(client.BaseAddress, new GrpcChannelOptions { HttpClient = client })); }
public static GrpcChannel CreateGrpcChannel(this WebApplicationFactory <Startup> factory) { var client = factory.CreateDefaultClient(new ResponseVersionHandler()); return(GrpcChannel.ForAddress(client.BaseAddress, new GrpcChannelOptions { HttpClient = client })); }
public void OneTimeSetUp() { webAppFactory = new WebApplicationFactory <Startup>(port: 4972); webAppFactory.CreateDefaultClient(); client = webAppFactory.CreateClient(); scope = webAppFactory.Host.Services.CreateScope(); serviceProvider = scope.ServiceProvider; usuarioController = new UsuarioController(serviceProvider.GetService <IUsuarioService>()); }
public void OneTimeSetup() { var testEnvironemt = new TestEnvironment(services => { }); factory = new TestAppFactory(); client = factory.CreateDefaultClient(new LoggingHandler()); }
public TestFixture() { _factory = new WebApplicationFactory <Startup>(); var client = _factory.CreateDefaultClient(new ResponseVersionHandler()); GrpcChannel = GrpcChannel.ForAddress(client.BaseAddress, new GrpcChannelOptions { HttpClient = client }); }
public async Task VerifyHealthCheckAPIAsync(string url) { // Arrange var client = factory.CreateDefaultClient(); // Act string healthStatus = await client.GetStringAsync(url); // Assert Assert.Equal("Healthy", healthStatus, true); }
public async Task A_Transaction_Will_Be_Created() { var client = _factory.CreateDefaultClient(); var createdAccountDetails = await CreateAccount(client); var requestData = new BuyRequest() { AccountNumber = createdAccountDetails.AccountNumber, MaxUnitPrice = 150, ProductCode = Constants.ProductA, Quantity = 10 }; var response = await client.PostAsJsonAsync("/api/Purchases", requestData); response.EnsureSuccessStatusCode(); var responseData = await response.Content.ReadAsJsonAsync <Purchase>(); Assert.True(responseData.Success); }
public async Task ShouldReturnSuccessResponse() { using var factory = new WebApplicationFactory <Startup>(); var client = factory.CreateDefaultClient(); var response = await client.GetAsync("api/values"); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); Assert.AreEqual("application/json; charset=utf-8", response.Content.Headers.ContentType?.ToString()); var json = await response.Content.ReadAsStringAsync(); Assert.AreEqual("[\"value1\",\"value2\"]", json); }
public void Start() { var factory = new WebApplicationFactory <Startup>().WithWebHostBuilder(configuration => { configuration.ConfigureLogging(logging => { logging.ClearProviders(); // stop the output being incredibly verbose since we're doing thousands of requests }); }); this.server = factory; this.client = factory.CreateDefaultClient(); }
public BaGetClientIntegrationTests( BaGetWebApplicationFactory factory, ITestOutputHelper output) { _factory = factory.WithOutput(output); var serviceIndexUrl = new Uri(_factory.Server.BaseAddress, "v3/index.json"); var httpClient = _factory.CreateDefaultClient(); _clientFactory = new NuGetClientFactory(httpClient, serviceIndexUrl.AbsoluteUri); _client = new NuGetClient(_clientFactory); }
public async Task GetExchangesShouldGetExchangeRatesFromAllSourcesGivenSourceSpecifiedAsAll() { HttpClient client = _factory.CreateDefaultClient(); HttpResponseMessage response = await client.GetAsync("/api/v1/exchanges/all"); Assert.Equal(HttpStatusCode.OK, response.StatusCode); var exchangeRates = await response.Content.ReadAsAsync <IEnumerable <ExchangeRatesViewModel> >(); Assert.NotNull(exchangeRates); Assert.NotEmpty(exchangeRates); }
public async Task The_Known_Products_Are_Returned() { var client = _factory.CreateDefaultClient(); var response = await client.GetAsync($"/api/Products"); var products = await response.Content.ReadAsJsonAsync <List <Product> >(); Assert.Equal(4, products.Count()); Assert.Equal(Constants.ProductA, products[0].ProductCode); Assert.Equal(Constants.ProductB, products[1].ProductCode); Assert.Equal(Constants.ProductC, products[2].ProductCode); Assert.Equal(Constants.ProductD, products[3].ProductCode); }
public async Task Which_Does_Not_Exist_Then_A_404_Error_Will_Be_Returned() { var client = _factory.CreateDefaultClient(); var madeUpAccountNumber = Guid.NewGuid().ToString(); var response = await client.GetAsync("/api/Accounts/" + madeUpAccountNumber); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); }