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