public JwtClaimValidatorTests() { var logger = new TestLogger <JwtClaimValidator>(); _DateTimeProvider = new StandardUtcDateTimeProvider(); _Server = WireMockServer.Start(); var iccPortalConfigMock = new Mock <IIccPortalConfig>(); iccPortalConfigMock.Setup(x => x.ClaimLifetimeHours).Returns(_ClaimLifetimeHours); iccPortalConfigMock.Setup(x => x.FrontendBaseUrl).Returns("http://test.test"); iccPortalConfigMock.Setup(x => x.JwtSecret).Returns("test_secret123"); iccPortalConfigMock.Setup(x => x.StrictRolePolicyEnabled).Returns(true); _JwtClaimValidator = new JwtClaimValidator(TestTheIdentityHubServiceCreator.CreateInstance(_Server), logger, _DateTimeProvider, iccPortalConfigMock.Object); }
public async Task RegularMatcherTest() { var server = WireMockServer.Start(9090); server .Given(Request.Create() .WithPath("/reg") // user must start with word, end with digit .WithParam("user", new RegexMatcher(@"^\w.*\d+$"))) .RespondWith(Response.Create().WithBody("reg match")); var client = new HttpClient(); var body = await client.GetStringAsync("http://localhost:9090/reg?user=Tom1993"); Assert.Equal("reg match", body); await Assert.ThrowsAsync <HttpRequestException>(async() => await client.GetStringAsync("http://localhost:9090/reg?user=Tom1993nice")); }
public void WireMockServer_WireMockServerSettings_ProxyAndRecordSettings_ProxyPriority_Is1000_When_StartAdminInterface_IsTrue() { // Assign and Act var server = WireMockServer.Start(new WireMockServerSettings { StartAdminInterface = true, ProxyAndRecordSettings = new ProxyAndRecordSettings { Url = "www.google.com" } }); // Assert var mappings = server.Mappings; Check.That(mappings.Count()).IsEqualTo(25); Check.That(mappings.Count(m => m.Priority == int.MinValue)).IsEqualTo(24); Check.That(mappings.Count(m => m.Priority == 1000)).IsEqualTo(1); }
public static TheIdentityHubService CreateInstance(WireMockServer Server) { var logger = new TestLogger <TheIdentityHubService>(); var serviceCollection = new ServiceCollection(); serviceCollection.AddCustomOptions(TheIdentityHubDefaults.AuthenticationScheme, options => { options.TheIdentityHubUrl = new Uri(Server.Urls[0]); options.Tenant = "ggdghornl_test"; options.ClientId = "0"; options.ClientSecret = "supersecret"; options.CallbackPath = "/signin-identityhub"; options.Backchannel = new HttpClient(); }); var builder = serviceCollection.BuildServiceProvider(); var options = builder.GetService <IOptionsMonitor <TheIdentityHubOptions> >(); return(new TheIdentityHubService(options, logger)); }
public void WireMockServer_WithMappingAsModel_Should_Add_Mapping() { // Arrange var guid = Guid.NewGuid(); var pattern = "hello wiremock"; var path = "/foo"; var response = "OK"; var mapping = new MappingModel { Guid = guid, Request = new RequestModel { Path = path, Body = new BodyModel { Matcher = new MatcherModel { Name = "ExactMatcher", Pattern = pattern } } }, Response = new ResponseModel { Body = response, StatusCode = 201 } }; var server = WireMockServer.Start(); // Act server.WithMapping(mapping); // Assert server.MappingModels.Should().HaveCount(1).And.Contain(m => m.Guid == guid && //((PathModel)m.Request.Path).Matchers.OfType<WildcardMatcher>().First().GetPatterns().First() == "/foo*" // m.Request.Body.Matchers.OfType<ExactMatcher>().First().GetPatterns().First() == pattern && m.Response.Body == response && (int)m.Response.StatusCode == 201 ); }
public void WireMockServer_Admin_ReadStaticMappingAndAddOrUpdate() { // Assign string mapping = "{\"Request\": {\"Path\": {\"Matchers\": [{\"Name\": \"WildcardMatcher\",\"Pattern\": \"/static/mapping\"}]},\"Methods\": [\"get\"]},\"Response\": {\"BodyAsJson\": { \"body\": \"static mapping\" }}}"; var staticMappingHandlerMock = new Mock <IFileSystemHandler>(); staticMappingHandlerMock.Setup(m => m.ReadMappingFile(It.IsAny <string>())).Returns(mapping); var server = WireMockServer.Start(new WireMockServerSettings { FileSystemHandler = staticMappingHandlerMock.Object }); // Act server.ReadStaticMappingAndAddOrUpdate(@"c:\test.json"); // Assert and Verify staticMappingHandlerMock.Verify(m => m.ReadMappingFile(@"c:\test.json"), Times.Once); }
public void WireMockServer_Admin_ResetMappings() { var server = WireMockServer.Start(); string folder = Path.Combine(GetCurrentFolder(), "__admin", "mappings"); server.ReadStaticMappings(folder); Check.That(server.Mappings).HasSize(6); Check.That(server.MappingModels).HasSize(6); // Act server.ResetMappings(); // Assert Check.That(server.Mappings).HasSize(0); Check.That(server.MappingModels).HasSize(0); server.Stop(); }
public async Task WireMockServer_Should_exclude_restrictedResponseHeader() { // Assign string path = $"/foo_{Guid.NewGuid()}"; var server = WireMockServer.Start(); server .Given(Request.Create().WithPath(path).UsingGet()) .RespondWith(Response.Create().WithHeader("Transfer-Encoding", "chunked").WithHeader("test", "t")); // Act var response = await new HttpClient().GetAsync("http://localhost:" + server.Ports[0] + path); // Assert Check.That(response.Headers.Contains("test")).IsTrue(); Check.That(response.Headers.Contains("Transfer-Encoding")).IsFalse(); server.Stop(); }
public static WireMockServer AddPostEndpoint(this WireMockServer server, string path, object response, Func <string, bool> bodyMatcher) { server.AddOptionEndpoint(path); server.Given( Request.Create() .WithPath(path) .WithBody(bodyMatcher) .UsingPost() ) .RespondWith( Response.Create() .AddHeaders() .WithBody(SerializeObject(response)) .WithStatusCode(200) ); return(server); }
public void ConfigureServices(IServiceCollection services) { services.AddControllers(); services.AddDbContext <ImpostoRendaContext>(options => options.UseSqlServer(Configuration.GetConnectionString("ImpostoRendaDatabase"))); services.AddScoped <HistoricoCalculoRepositorio>(); services.AddScoped <CalculadoraImposto>(); var tabelaJson = @"{""faixas"": [ { ""valorInicial"": 0, ""valorFinal"": 1903.98, ""aliquota"": 0 }, { ""valorInicial"": 1903.99, ""valorFinal"": 2826.65, ""aliquota"": 7.5 }, { ""valorInicial"": 2826.66, ""valorFinal"": 3751.05, ""aliquota"": 15 }, { ""valorInicial"": 3751.06, ""aliquota"": 27.5 } ] }"; if (!_hostEnvironment.IsEnvironment("Test")) { var server = WireMockServer.Start(7070); server.Given(Request.Create().UsingAnyMethod()) .RespondWith(Response.Create().WithBody(tabelaJson)); } services.AddHttpClient <IServicoImpostoRenda, ServicoImpostoRenda>(x => x.BaseAddress = new Uri("http://localhost:7070/")); }
public async Task WireMockServer_Should_delay_responses() { // given var server = WireMockServer.Start(); server.AddGlobalProcessingDelay(TimeSpan.FromMilliseconds(200)); server .Given(Request.Create().WithPath("/*")) .RespondWith(Response.Create().WithBody(@"{ msg: ""Hello world!""}")); // when var watch = new Stopwatch(); watch.Start(); await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/foo"); watch.Stop(); // then Check.That(watch.ElapsedMilliseconds).IsStrictlyGreaterThan(200); }
public void WireMockServer_Should_reset_mappings() { // given string path = $"/foo_{Guid.NewGuid()}"; var server = WireMockServer.Start(); server .Given(Request.Create() .WithPath(path) .UsingGet()) .RespondWith(Response.Create() .WithBody(@"{ msg: ""Hello world!""}")); // when server.ResetMappings(); // then Check.That(server.Mappings).IsEmpty(); Check.ThatAsyncCode(() => new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path)).ThrowsAny(); }
public async Task WireMockServer_WithBodyAsJson_Using_PostAsync_And_WildcardMatcher_ShouldMatch() { // Arrange var server = WireMockServer.Start(); server.Given( Request.Create().UsingPost().WithPath("/foo").WithBody(new WildcardMatcher("*Hello*")) ) .RespondWith( Response.Create().WithStatusCode(200) ); // Act var response = await new HttpClient().PostAsync("http://localhost:" + server.Ports[0] + "/foo", new StringContent("{ Hi = \"Hello World\" }")); // Assert response.StatusCode.Should().Be(HttpStatusCode.OK); server.Stop(); }
public async Task RequestTemplatingTest() { var server = WireMockServer.Start(); server .Given(Request.Create() .WithPath("/some/thing").UsingGet()) .RespondWith(Response.Create() .WithBody("Hello world! Your path is {{request.path}}.") // do not forget! .WithTransformer()); var client = new HttpClient(); var body = await client.GetStringAsync($"{server.Urls[0]}/some/thing"); Assert.Equal("Hello world! Your path is /some/thing.", body); await Assert.ThrowsAsync <HttpRequestException>(async() => await client.GetStringAsync($"{server.Urls[0]}/some/thing/1")); }
public void WireMockServer_Admin_ReadStaticMapping_WithGuidFilename() { string guid = "00000002-ee28-4f29-ae63-1ac9b0802d86"; var server = WireMockServer.Start(); string path = Path.Combine(GetCurrentFolder(), "__admin", "mappings", guid + ".json"); server.ReadStaticMappingAndAddOrUpdate(path); var mappings = server.Mappings.ToArray(); Check.That(mappings).HasSize(1); Check.That(mappings.First().RequestMatcher).IsNotNull(); Check.That(mappings.First().Provider).IsNotNull(); Check.That(mappings.First().Guid).Equals(Guid.Parse(guid)); Check.That(mappings.First().Title).IsNullOrEmpty(); server.Stop(); }
static void Main(string[] args) { //Create a stub http server var settings = new WireMockServerSettings { // Urls = new[] { "http://+:5001" }, StartAdminInterface = true }; var server = WireMockServer.Start(settings); var port = server.Ports[0]; var url = server.Urls[0]; Configure(server); Console.WriteLine($"Mock Server listening on : {url}"); Console.WriteLine("Press any key to stop the server"); Console.ReadLine(); server.Stop(); }
public void WireMockServer_Admin_ReadStaticMapping_WithNonGuidFilename() { var guid = Guid.Parse("04ee4872-9efd-4770-90d3-88d445265d0d"); string title = "documentdb_root_title"; var server = WireMockServer.Start(); string path = Path.Combine(GetCurrentFolder(), "__admin", "mappings", "documentdb_root.json"); server.ReadStaticMappingAndAddOrUpdate(path); var mappings = server.Mappings.ToArray(); Check.That(mappings).HasSize(1); Check.That(mappings.First().RequestMatcher).IsNotNull(); Check.That(mappings.First().Provider).IsNotNull(); Check.That(mappings.First().Guid).Equals(guid); Check.That(mappings.First().Title).Equals(title); }
static void Main(string[] args) { var server = WireMockServer.Start(); foreach (var url in server.Urls) { Console.WriteLine(url); } var path = System.IO.Directory.GetCurrentDirectory(); server.ReadStaticMappings(path); Console.WriteLine(path); //server // .Given(Request.Create().WithPath("/exact") // .WithParam("from", new ExactMatcher("abc"))) // .RespondWith(Response.Create() // .WithBody("Exact match") // ); Console.ReadKey(); }
public async Task ScenarioWithJsonTest() { // Assign var server = WireMockServer.StartWithAdminInterfaceAndReadStaticMappings("http://localhost"); // Act and Assert var client = new HttpClient(); string url = server.Urls[0]; string getResponse1 = await client.GetStringAsync(url + "/todo/items"); Assert.Equal("Buy milk", getResponse1); var postResponse = await client.PostAsync(url + "/todo/items", new StringContent("Cancel newspaper subscription")); Assert.Equal(HttpStatusCode.Created, postResponse.StatusCode); string getResponse2 = await client.GetStringAsync(url + "/todo/items"); Assert.Equal("Buy milk;Cancel newspaper subscription", getResponse2); }
public async Task Scenarios_Should_skip_non_relevant_states() { // given string path = $"/foo_{Guid.NewGuid()}"; var server = WireMockServer.Start(); server .Given(Request.Create().WithPath(path).UsingGet()) .InScenario("s") .WhenStateIs("Test state") .RespondWith(Response.Create()); // when var response = await new HttpClient().GetAsync("http://localhost:" + server.Ports[0] + path); // then Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound); server.Stop(); }
public async Task WireMockServer_Should_respond_to_ipv6_loopback() { // Assign var server = WireMockServer.Start(); server .Given(Request.Create() .WithPath("/*")) .RespondWith(Response.Create() .WithStatusCode(200) .WithBody("from ipv6 loopback")); // Act var response = await new HttpClient().GetStringAsync($"http://[::1]:{server.Ports[0]}/foo"); // Assert Check.That(response).IsEqualTo("from ipv6 loopback"); server.Stop(); }
public async void RunAsync_EnqueuesLocationBatchJob() { _mockEnv.Setup(m => m.IsDevelopment).Returns(false); var server = WireMockServer.Start(); var ukPostcodeCsvUrl = $"http://localhost:{server.Ports[0]}/test"; server .Given(Request.Create().WithUrl(ukPostcodeCsvUrl)) .RespondWith(Response.Create() .WithBodyFromFile("./Fixtures/ukpostcodes.csv.zip") ); await _job.RunAsync(ukPostcodeCsvUrl); // Run again to verify upsert/no duplicates await _job.RunAsync(ukPostcodeCsvUrl); var batch = new List <dynamic> { new { Postcode = "ky119yu", Latitude = 56.02748, Longitude = -3.35870 }, new { Postcode = "ca48le", Latitude = 54.89014, Longitude = -2.84000 }, new { Postcode = "ky62nj", Latitude = 56.182790, Longitude = -3.178240 }, new { Postcode = "kw14yl", Latitude = 58.64102, Longitude = -3.10075 }, new { Postcode = "tr182ab", Latitude = 50.12279, Longitude = -5.53987 }, }; DbContext.Locations.Count().Should().Be(batch.Count); DbContext.Locations.ToList().All(l => batch.Any(b => BatchLocationMatchesExistingLocation(b, l))).Should().BeTrue(); DbContext.Locations.All(l => l.Source == GetIntoTeachingApi.Models.Location.SourceType.CSV); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - Started"); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - ZIP Downloaded"); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - CSV Extracted"); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - ZIP Deleted"); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - Processed 5 Locations (1 Batches)"); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - CSV Deleted"); _mockLogger.VerifyInformationWasCalled("LocationSyncJob - Succeeded"); _metrics.LocationSyncDuration.Count.Should().BeGreaterOrEqualTo(1); }
public async Task WireMockServer_WithCallback_Should_Use_StatusCodeFromResponse(object statusCode) { // Arrange var server = WireMockServer.Start(); server.Given(Request.Create().UsingPost().WithPath("/foo")) .RespondWith(Response.Create() .WithCallback(request => new ResponseMessage { StatusCode = statusCode })); // Act var httpClient = new HttpClient(); var response = await httpClient.PostAsync("http://localhost:" + server.Ports[0] + "/foo", new StringContent("dummy")); // Assert response.StatusCode.Should().Be(HttpStatusCode.Conflict); server.Stop(); }
public void WireMockServer_Admin_ReadStaticMappings_FolderDoesNotExist() { // Assign var loggerMock = new Mock <IWireMockLogger>(); loggerMock.Setup(l => l.Info(It.IsAny <string>(), It.IsAny <object[]>())); var settings = new WireMockServerSettings { Logger = loggerMock.Object }; var server = WireMockServer.Start(settings); // Act server.ReadStaticMappings(Guid.NewGuid().ToString()); // Assert Check.That(server.Mappings).HasSize(0); // Verify loggerMock.Verify(l => l.Info(It.Is <string>(s => s.StartsWith("The Static Mapping folder")), It.IsAny <object[]>()), Times.Once); }
public void BeforeEachTest() { var serverSettings = new WireMockServerSettings(); //serverSettings.Port = 5005; serverSettings.AllowPartialMapping = true; //by default WireMock.NET returns 404 if request doesn't match exact parameter _server = WireMockServer.Start(serverSettings); _server .Given(Request.Create().WithPath("/test").UsingGet()) .RespondWith( Response.Create() .WithStatusCode(200) .WithBody(jsonResponse) ); Console.WriteLine("Press any key to stop the server"); //Console.ReadKey(); //app = AppInitializer.StartApp(platform); }
protected override Task ExecuteAsync(CancellationToken stoppingToken) { var server = WireMockServer.Start(new WireMockServerSettings { Urls = new[] { _acquiringBankSettings.ApiUrl }, StartAdminInterface = true, ReadStaticMappings = true, Logger = new WireMockConsoleLogger() }); server .Given(Request.Create() .WithPath($"/api/payment").UsingPost()) .RespondWith(Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json") .WithBody((new BankPaymentResponse { PaymentIdentifier = Guid.NewGuid().ToString(), PaymentStatus = PaymentStatus.Success }).ToJson())); return(Task.CompletedTask); }
static void Main(params string[] args) { var server = WireMockServer.Start(new WireMockServerSettings { Urls = new[] { "http://localhost:9091/", "https://localhost:9443/" }, StartAdminInterface = true, ReadStaticMappings = false, //ProxyAndRecordSettings = new ProxyAndRecordSettings //{ // Url = "https://www.google.com", // //ClientX509Certificate2ThumbprintOrSubjectName = "www.yourclientcertname.com OR yourcertificatethumbprint (only if the service you're proxying to requires it)", // SaveMapping = true, // SaveMappingToFile = false, // ExcludedHeaders = new [] { "dnt", "Content-Length" } //} }); server .Given(Request.Create().UsingGet()) .RespondWith(Response.Create() .WithProxy(new ProxyAndRecordSettings { Url = "http://postman-echo.com/post", SaveMapping = true, SaveMappingToFile = true })); System.Console.WriteLine("Press any key to stop the server"); System.Console.ReadKey(); server.Stop(); System.Console.WriteLine("Displaying all requests"); var allRequests = server.LogEntries; System.Console.WriteLine(JsonConvert.SerializeObject(allRequests, Formatting.Indented)); System.Console.WriteLine("Press any key to quit"); System.Console.ReadKey(); }
public async Task GlobalProxyTest() { var settings = new WireMockServerSettings { Urls = new[] { "http://localhost/" }, StartAdminInterface = true, ReadStaticMappings = true, ProxyAndRecordSettings = new ProxyAndRecordSettings { Url = "http://www.bbc.com", SaveMapping = true, SaveMappingToFile = true, SaveMappingForStatusCodePattern = "2xx" } }; var server = WireMockServer.Start(settings); // please access: http://localhost:9090/earth/story/20170510-terrifying-20m-tall-rogue-waves-are-actually-real // and refresh the __admin/mappings/ directory and see the files added this.OpenUrl($"{server.Urls[0]}/earth/story/20170510-terrifying-20m-tall-rogue-waves-are-actually-real"); await this.WaitingForResponse(); }
public async Task WireMockServer_LogEntriesChanged_Parallel() { int expectedCount = 10; // Assign string path = $"/log_p_{Guid.NewGuid()}"; var server = WireMockServer.Start(); server .Given(Request.Create() .WithPath(path) .UsingGet()) .RespondWith(Response.Create() .WithSuccess()); int count = 0; server.LogEntriesChanged += (sender, args) => count++; var http = new HttpClient(); // Act var listOfTasks = new List <Task <HttpResponseMessage> >(); for (var i = 0; i < expectedCount; i++) { Thread.Sleep(50); listOfTasks.Add(http.GetAsync($"{server.Urls[0]}{path}")); } var responses = await Task.WhenAll(listOfTasks); var countResponsesWithStatusNotOk = responses.Count(r => r.StatusCode != HttpStatusCode.OK); // Assert Check.That(countResponsesWithStatusNotOk).Equals(0); Check.That(count).Equals(expectedCount); server.Dispose(); }
public void WireMockServer_Admin_ReadStaticMappings_FolderExistsIsTrue() { // Assign var staticMappingHandlerMock = new Mock <IFileSystemHandler>(); staticMappingHandlerMock.Setup(m => m.GetMappingFolder()).Returns("folder"); staticMappingHandlerMock.Setup(m => m.FolderExists(It.IsAny <string>())).Returns(true); staticMappingHandlerMock.Setup(m => m.EnumerateFiles(It.IsAny <string>(), It.IsAny <bool>())).Returns(new string[0]); var server = WireMockServer.Start(new WireMockServerSettings { FileSystemHandler = staticMappingHandlerMock.Object }); // Act server.ReadStaticMappings(); // Assert and Verify staticMappingHandlerMock.Verify(m => m.GetMappingFolder(), Times.Once); staticMappingHandlerMock.Verify(m => m.FolderExists("folder"), Times.Once); staticMappingHandlerMock.Verify(m => m.EnumerateFiles("folder", false), Times.Once); }