public async void FluentMockServer_LogEntriesChanged_WithException_Should_LogError()
{
// Assign
string path = $"/log_{Guid.NewGuid()}";
var loggerMock = new Mock <IWireMockLogger>();
loggerMock.Setup(l => l.Error(It.IsAny <string>(), It.IsAny <object[]>()));
var settings = new FluentMockServerSettings
{
Logger = loggerMock.Object
};
var server = FluentMockServer.Start(settings);
server
.Given(Request.Create()
.WithPath(path)
.UsingGet())
.RespondWith(Response.Create()
.WithBody(@"{ msg: ""Hello world!""}"));
server.LogEntriesChanged += (sender, args) => throw new Exception();
// Act
await new HttpClient().GetAsync($"http://localhost:{server.Ports[0]}{path}");
// Assert
loggerMock.Verify(l => l.Error(It.IsAny <string>(), It.IsAny <object[]>()), Times.Once);
}
internal static async Task <FluentMockServer> StartServerAsync()
{
var settings = new FluentMockServerSettings()
{
StartTimeout = 2000
};
var server = FluentMockServer.Start(settings);
// We've sometimes seen some instability in FluentMockServer that causes the server to not really be
// ready when Start() returns, so we'll poll it to make sure.
int nAttempts = 0;
using (var client = new HttpClient())
{
while (true)
{
try
{
await client.GetAsync(server.Urls[0]);
break;
}
catch (HttpRequestException)
{
if (nAttempts++ > 10)
{
throw new Exception("Test HTTP server did not become available within a reasonable time");
}
await Task.Delay(50);
}
}
}
server.ResetLogEntries();
return(server);
}
public async Task FluentMockServer_Proxy_Should_change_absolute_location_header_in_proxied_response()
{
// Assign
var settings = new FluentMockServerSettings {
AllowPartialMapping = false
};
_serverForProxyForwarding = FluentMockServer.Start(settings);
_serverForProxyForwarding
.Given(Request.Create().WithPath("/*"))
.RespondWith(Response.Create()
.WithStatusCode(HttpStatusCode.Redirect)
.WithHeader("Location", _serverForProxyForwarding.Urls[0] + "testpath"));
_server = FluentMockServer.Start(settings);
_server
.Given(Request.Create().WithPath("/prx"))
.RespondWith(Response.Create().WithProxy(_serverForProxyForwarding.Urls[0]));
// Act
var requestMessage = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(_server.Urls[0] + "/prx")
};
var httpClientHandler = new HttpClientHandler {
AllowAutoRedirect = false
};
var response = await new HttpClient(httpClientHandler).SendAsync(requestMessage);
// Assert
Check.That(response.Headers.Contains("Location")).IsTrue();
Check.That(response.Headers.GetValues("Location")).ContainsExactly(_server.Urls[0] + "testpath");
}
public async Task FluentMockServer_Proxy_Should_log_proxied_requests()
{
// Assign
var settings = new FluentMockServerSettings
{
ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = "http://www.google.com",
SaveMapping = true,
SaveMappingToFile = false
}
};
var server = FluentMockServer.Start(settings);
// Act
var requestMessage = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(server.Urls[0])
};
var httpClientHandler = new HttpClientHandler {
AllowAutoRedirect = false
};
await new HttpClient(httpClientHandler).SendAsync(requestMessage);
// Assert
Check.That(server.Mappings).HasSize(2);
Check.That(server.LogEntries).HasSize(1);
}
public static FluentMockServer Start([NotNull] string[] args, [CanBeNull] IWireMockLogger logger = null)
{
Check.NotNull(args, nameof(args));
var parser = new SimpleCommandLineParser();
parser.Parse(args);
var settings = new FluentMockServerSettings
{
StartAdminInterface = parser.GetBoolValue("StartAdminInterface", true),
ReadStaticMappings = parser.GetBoolValue("ReadStaticMappings"),
WatchStaticMappings = parser.GetBoolValue("WatchStaticMappings"),
AllowPartialMapping = parser.GetBoolValue("AllowPartialMapping"),
AdminUsername = parser.GetStringValue("AdminUsername"),
AdminPassword = parser.GetStringValue("AdminPassword"),
MaxRequestLogCount = parser.GetIntValue("MaxRequestLogCount"),
RequestLogExpirationDuration = parser.GetIntValue("RequestLogExpirationDuration"),
AllowCSharpCodeMatcher = parser.GetBoolValue("AllowCSharpCodeMatcher"),
};
if (logger != null)
{
settings.Logger = logger;
}
if (parser.GetStringValue("WireMockLogger") == "WireMockConsoleLogger")
{
settings.Logger = new WireMockConsoleLogger();
}
if (parser.Contains("Port"))
{
settings.Port = parser.GetIntValue("Port");
}
else
{
settings.Urls = parser.GetValues("Urls", new[] { "http://*:9091/" });
}
string proxyURL = parser.GetStringValue("ProxyURL");
if (!string.IsNullOrEmpty(proxyURL))
{
settings.ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = proxyURL,
SaveMapping = parser.GetBoolValue("SaveMapping"),
SaveMappingToFile = parser.GetBoolValue("SaveMappingToFile"),
ClientX509Certificate2ThumbprintOrSubjectName = parser.GetStringValue("ClientX509Certificate2ThumbprintOrSubjectName"),
BlackListedHeaders = parser.GetValues("BlackListedHeaders"),
BlackListedCookies = parser.GetValues("BlackListedCookies")
};
}
settings.Logger.Debug("WireMock.Net server arguments [{0}]", string.Join(", ", args.Select(a => $"'{a}'")));
return(Start(settings));
}
public static WireMockServer Start([NotNull] FluentMockServerSettings settings)
{
Check.NotNull(settings, nameof(settings));
var server = WireMockServer.Start(settings);
settings.Logger.Info("WireMock.Net server listening at {0}", string.Join(",", server.Urls));
return(server);
}
public async Task FluentMockServer_Proxy_Should_exclude_blacklisted_cookies_in_mapping()
{
// Assign
string path = $"/prx_{Guid.NewGuid().ToString()}";
var serverForProxyForwarding = FluentMockServer.Start();
serverForProxyForwarding
.Given(Request.Create().WithPath(path))
.RespondWith(Response.Create());
var settings = new FluentMockServerSettings
{
ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = serverForProxyForwarding.Urls[0],
SaveMapping = true,
SaveMappingToFile = false,
BlackListedCookies = new[] { "ASP.NET_SessionId" }
}
};
var server = FluentMockServer.Start(settings);
var defaultMapping = server.Mappings.First();
// Act
var requestMessage = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri($"{server.Urls[0]}{path}"),
Content = new StringContent("stringContent")
};
var cookieContainer = new CookieContainer(3);
cookieContainer.Add(new Uri("http://localhost"), new Cookie("ASP.NET_SessionId", "exact_match"));
cookieContainer.Add(new Uri("http://localhost"), new Cookie("AsP.NeT_SessIonID", "case_mismatch"));
cookieContainer.Add(new Uri("http://localhost"), new Cookie("GoodCookie", "I_should_pass"));
var handler = new HttpClientHandler {
CookieContainer = cookieContainer
};
await new HttpClient(handler).SendAsync(requestMessage);
// Assert
var mapping = server.Mappings.FirstOrDefault(m => m.Guid != defaultMapping.Guid);
Check.That(mapping).IsNotNull();
var matchers = ((Request)mapping.RequestMatcher).GetRequestMessageMatchers <RequestMessageCookieMatcher>().Select(m => m.Name).ToList();
Check.That(matchers).Not.Contains("ASP.NET_SessionId");
Check.That(matchers).Not.Contains("AsP.NeT_SessIonID");
Check.That(matchers).Contains("GoodCookie");
}
public static FluentMockServer Start([NotNull] string[] args)
{
Check.NotNull(args, nameof(args));
Console.WriteLine("WireMock.Net server arguments [{0}]", string.Join(", ", args.Select(a => $"'{a}'")));
var parser = new SimpleCommandLineParser();
parser.Parse(args);
var settings = new FluentMockServerSettings
{
StartAdminInterface = parser.GetBoolValue("StartAdminInterface", true),
ReadStaticMappings = parser.GetBoolValue("ReadStaticMappings"),
AllowPartialMapping = parser.GetBoolValue("AllowPartialMapping", true),
AdminUsername = parser.GetStringValue("AdminUsername"),
AdminPassword = parser.GetStringValue("AdminPassword"),
MaxRequestLogCount = parser.GetIntValue("MaxRequestLogCount"),
RequestLogExpirationDuration = parser.GetIntValue("RequestLogExpirationDuration"),
};
if (parser.Contains("Port"))
{
settings.Port = parser.GetIntValue("Port");
}
else
{
settings.Urls = parser.GetValues("Urls", new[] { "http://*:9091/" });
}
string proxyURL = parser.GetStringValue("ProxyURL");
if (!string.IsNullOrEmpty(proxyURL))
{
settings.ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = proxyURL,
SaveMapping = parser.GetBoolValue("SaveMapping"),
SaveMappingToFile = parser.GetBoolValue("SaveMappingToFile"),
X509Certificate2ThumbprintOrSubjectName = parser.GetStringValue("X509Certificate2ThumbprintOrSubjectName")
};
}
Console.WriteLine("WireMock.Net server settings {0}", JsonConvert.SerializeObject(settings, Formatting.Indented));
FluentMockServer server = Start(settings);
Console.WriteLine("WireMock.Net server listening at {0}", string.Join(" and ", server.Urls));
return(server);
}
private WireMockServer SetupMockedServer()
{
FluentMockServerSettings settings = new FluentMockServerSettings()
{
Urls = new[] { _testSupportConfigurationOptions.ServerMockUrl },
ReadStaticMappings = true,
};
WireMockServer mockServer = WireMockServer.Start(settings);
mockServer.ReadStaticMappings("Mappings/");
return(mockServer);
}
static void Main(string[] args)
{
var options = new Options();
var parser = new CommandLineParser.CommandLineParser();
parser.ExtractArgumentAttributes(options);
try
{
parser.ParseCommandLine(args);
if (!options.Urls.Any())
{
options.Urls.Add("http://localhost:9090/");
}
var settings = new FluentMockServerSettings
{
Urls = options.Urls.ToArray(),
StartAdminInterface = options.StartAdminInterface,
ReadStaticMappings = options.ReadStaticMappings,
};
if (!string.IsNullOrEmpty(options.ProxyURL))
{
settings.ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = options.ProxyURL,
SaveMapping = options.SaveMapping
};
}
var server = FluentMockServer.Start(settings);
if (options.AllowPartialMapping)
{
server.AllowPartialMapping();
}
Console.WriteLine("WireMock.Net server listening at {0}", string.Join(" and ", server.Urls));
}
catch (CommandLineException e)
{
Console.WriteLine(e.Message);
parser.ShowUsage();
}
Console.WriteLine("Press any key to stop the server");
Console.ReadKey();
}
public async Task FluentMockServer_Proxy_Should_preserve_content_header_in_proxied_request()
{
// Assign
string path = $"/prx_{Guid.NewGuid().ToString()}";
var serverForProxyForwarding = FluentMockServer.Start();
serverForProxyForwarding
.Given(Request.Create().WithPath(path))
.RespondWith(Response.Create());
var settings = new FluentMockServerSettings
{
ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = serverForProxyForwarding.Urls[0],
SaveMapping = true,
SaveMappingToFile = false
}
};
var server = FluentMockServer.Start(settings);
// Act
var requestMessage = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri($"{server.Urls[0]}{path}"),
Content = new StringContent("stringContent", Encoding.ASCII)
};
requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
requestMessage.Content.Headers.Add("bbb", "test");
await new HttpClient().SendAsync(requestMessage);
// Assert
var receivedRequest = serverForProxyForwarding.LogEntries.First().RequestMessage;
Check.That(receivedRequest.BodyData.BodyAsString).IsEqualTo("stringContent");
Check.That(receivedRequest.Headers).ContainsKey("Content-Type");
Check.That(receivedRequest.Headers["Content-Type"].First()).Contains("text/plain");
Check.That(receivedRequest.Headers).ContainsKey("bbb");
// check that new proxied mapping is added
Check.That(server.Mappings).HasSize(2);
//var newMapping = _server.Mappings.First(m => m.Guid != guid);
//var matcher = ((Request)newMapping.RequestMatcher).GetRequestMessageMatchers<RequestMessageHeaderMatcher>().FirstOrDefault(m => m.Name == "bbb");
//Check.That(matcher).IsNotNull();
}
public void FluentMockServer_Admin_WatchStaticMappings()
{
// Assign
var fileMock = new Mock <IFileSystemHandler>();
var settings = new FluentMockServerSettings
{
FileSystemHandler = fileMock.Object
};
var server = FluentMockServer.Start(settings);
// Act
server.WatchStaticMappings();
// Verify
fileMock.Verify(f => f.GetMappingFolder(), Times.Once);
fileMock.Verify(f => f.FolderExists(It.IsAny <string>()), Times.Once);
}
public async Task FluentMockServer_Proxy_Should_exclude_blacklisted_content_header_in_mapping()
{
// given
_serverForProxyForwarding = FluentMockServer.Start();
_serverForProxyForwarding
.Given(Request.Create().WithPath("/*"))
.RespondWith(Response.Create());
var settings = new FluentMockServerSettings
{
ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = _serverForProxyForwarding.Urls[0],
SaveMapping = true,
SaveMappingToFile = false,
BlackListedHeaders = new[] { "blacklisted" }
}
};
_server = FluentMockServer.Start(settings);
//_server
// .Given(Request.Create().WithPath("/*"))
// .RespondWith(Response.Create());
// when
var requestMessage = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri(_server.Urls[0]),
Content = new StringContent("stringContent")
};
requestMessage.Headers.Add("blacklisted", "test");
requestMessage.Headers.Add("ok", "ok-value");
await new HttpClient().SendAsync(requestMessage);
// then
var receivedRequest = _serverForProxyForwarding.LogEntries.First().RequestMessage;
Check.That(receivedRequest.Headers).Not.ContainsKey("bbb");
Check.That(receivedRequest.Headers).ContainsKey("ok");
//var mapping = _server.Mappings.Last();
//var matcher = ((Request)mapping.RequestMatcher).GetRequestMessageMatchers<RequestMessageHeaderMatcher>().FirstOrDefault(m => m.Name == "bbb");
//Check.That(matcher).IsNull();
}
public CustomWebApplicationFactory()
{
var settings = new FluentMockServerSettings
{
AllowPartialMapping = false,
StartAdminInterface = true,
Port = 5001
};
WireMockServer = StandAloneApp.Start(settings);
MongoDb = new MongoClient(Runner.ConnectionString).GetDatabase("ServiceName");
MessageReceiver = new MessageHelper(InMemoryBus);
//mock consul request
WireMockServer.Given(Request.Create().WithPath("/v1/kv/ServiceName")
.UsingGet())
.RespondWith(WireMock.ResponseBuilders.Response.Create().WithNotFound());
}
public async Task FluentMockServer_Proxy_Should_exclude_blacklisted_content_header_in_mapping()
{
// Assign
string path = $"/prx_{Guid.NewGuid().ToString()}";
var serverForProxyForwarding = FluentMockServer.Start();
serverForProxyForwarding
.Given(Request.Create().WithPath(path))
.RespondWith(Response.Create());
var settings = new FluentMockServerSettings
{
ProxyAndRecordSettings = new ProxyAndRecordSettings
{
Url = serverForProxyForwarding.Urls[0],
SaveMapping = true,
SaveMappingToFile = false,
BlackListedHeaders = new[] { "blacklisted" }
}
};
var server = FluentMockServer.Start(settings);
var defaultMapping = server.Mappings.First();
// Act
var requestMessage = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri($"{server.Urls[0]}{path}"),
Content = new StringContent("stringContent")
};
requestMessage.Headers.Add("blacklisted", "exact_match");
requestMessage.Headers.Add("ok", "ok-value");
await new HttpClient().SendAsync(requestMessage);
// Assert
var mapping = server.Mappings.FirstOrDefault(m => m.Guid != defaultMapping.Guid);
Check.That(mapping).IsNotNull();
var matchers = ((Request)mapping.RequestMatcher).GetRequestMessageMatchers <RequestMessageHeaderMatcher>().Select(m => m.Name).ToList();
Check.That(matchers).Not.Contains("blacklisted");
Check.That(matchers).Contains("ok");
}
static void Main(string[] args)
{
int port;
if (args.Length == 0 || !int.TryParse(args[0], out port))
{
port = 8080;
}
var settings = new FluentMockServerSettings
{
Port = port
};
var server = FluentMockServer.Start(settings);
server.Given(Request.Create().WithUrl(u => u.Contains("medium_gz")).UsingGet())
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithHeader("Content-Type", "text/plain")
.WithHeader("Content-Encoding", "gzip")
.WithBodyFromFile("stations_medium.ion.gz", true));
server.Given(Request.Create().WithUrl(u => u.Contains("small")).UsingGet())
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithHeader("Content-Type", "text/plain")
.WithBodyFromFile("stations_small.ion", true));
server.Given(Request.Create().WithUrl(u => u.Contains("large")).UsingGet())
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithHeader("Content-Type", "text/plain")
.WithBodyFromFile("stations_large.ion", true));
server.Given(Request.Create().WithUrl(u => u.Contains("medium")).UsingGet())
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithHeader("Content-Type", "text/plain")
.WithBodyFromFile("stations_medium.ion", true));
Console.WriteLine("Press any key to stop the server");
Console.ReadKey();
}
public bool Start(HostControl hostControl)
{
_logger.Debug("Starting...");
var handleBarTransformers = new List <IHandleBarTransformer>();
try
{
var currentAssembly = Assembly.LoadFrom(_assemblyFile);
var item = currentAssembly.GetType(_typeName);
handleBarTransformers.Add((IHandleBarTransformer)Activator.CreateInstance(item));
}
catch (Exception ex)
{
// ignored
}
var settings = new FluentMockServerSettings()
{
UseSSL = _useSsl,
Port = _port,
ReadStaticMappings = true,
WatchStaticMappings = true,
WatchStaticMappingsInSubdirectories = true,
AllowPartialMapping = true,
StartAdminInterface = true,
Logger = _logger,
FileSystemHandler = _fileHandler,
HandlebarsRegistrationCallback = (a, b) =>
{
foreach (var handleBarTransformer in handleBarTransformers)
{
a.RegisterHelper(handleBarTransformer.Name, handleBarTransformer.Render);
}
}
};
_server = StandAloneApp.Start(settings);
_logger.Debug("Started");
return(true);
}
static void Main(string[] args)
{
Console.WriteLine("Starting WireMock.");
var settings = new FluentMockServerSettings
{
ReadStaticMappings = true,
WatchStaticMappings = true,
StartAdminInterface = true,
};
StandAloneApp.Start(settings);
//var server = StandAloneApp.Start(settings);
//server.ReadStaticMappings("CustomMappingFolder\\GetMapping");
//server.WatchStaticMappings("CustomMappingFolder\\GetMapping");
Console.WriteLine("WireMock started");
Console.ReadLine();
}
private void SetupMockWebServices(IKernel services)
{
ISettingsProvider settingsProvider = services.Get <ISettingsProvider>();
string abnUrl = settingsProvider.Get("abnservice");
IFluentMockServerSettings mockServerSettings = new FluentMockServerSettings
{
Urls = new[]
{
abnUrl
}
};
services.Bind <IFluentMockServerSettings>()
.ToConstant(mockServerSettings)
.InTransientScope();
IHttpMock httpMock = services.Get <IHttpMock>();
httpMock.SetupRequest(Request.Create().WithPath("/validate").UsingGet(), Response.Create().WithBody("Test"));
}
public static void Main(string[] args)
{
var settings = new FluentMockServerSettings
{
AllowPartialMapping = false,
StartAdminInterface = true,
Port = 5555
};
var server = StandAloneApp.Start(settings);
Console.WriteLine("FluentMockServer running at {0}", server.Ports.Single());
server.Given(Request.Create().UsingGet().WithPath("/api"))
.RespondWith(Response.Create().WithBodyAsJson(
new
{
Message = "Welcome to the stub API"
}));
BuildWebHost(args).Run();
}
public void FluentMockServer_Admin_ReadStaticMappings_FolderDoesNotExist()
{
// Assign
var loggerMock = new Mock <IWireMockLogger>();
loggerMock.Setup(l => l.Info(It.IsAny <string>(), It.IsAny <object[]>()));
var settings = new FluentMockServerSettings
{
Logger = loggerMock.Object
};
var server = FluentMockServer.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);
}
private FluentMockServer(FluentMockServerSettings settings)
{
if (settings.Urls != null)
{
Urls = settings.Urls;
}
else
{
int port = settings.Port > 0 ? settings.Port.Value : PortUtil.FindFreeTcpPort();
Urls = new[] { (settings.UseSSL == true ? "https" : "http") + "://localhost:" + port + "/" };
}
#if NET45
_httpServer = new OwinSelfHost(_options, Urls);
#else
_httpServer = new AspNetCoreSelfHost(_options, Urls);
#endif
Ports = _httpServer.Ports;
_httpServer.StartAsync();
if (settings.StartAdminInterface == true)
{
InitAdmin();
}
if (settings.ReadStaticMappings == true)
{
ReadStaticMappings();
}
if (settings.ProxyAndRecordSettings != null)
{
InitProxyAndRecord(settings.ProxyAndRecordSettings);
}
}
public static FluentMockServer Start(FluentMockServerSettings settings)
{
Check.NotNull(settings, nameof(settings));
return(new FluentMockServer(settings));
}
