/// <summary>
/// Initializes a new instance of the <see cref="Response"/> class.
/// </summary>
/// <param name="responseMessage">
/// The response.
/// </param>
private Response(ResponseMessage responseMessage)
{
ResponseMessage = responseMessage;
_fileSystemHandler = new LocalFileSystemHandler();
_responseMessageTransformer = new ResponseMessageTransformer(_fileSystemHandler);
}
/// <summary>
/// Initializes a new instance of the <see cref="RespondWithAProvider"/> class.
/// </summary>
/// <param name="registrationCallback">The registration callback.</param>
/// <param name="requestMatcher">The request matcher.</param>
/// <param name="fileSystemHandler">The fileSystemHandler.</param>
/// <param name="saveToFile">Optional boolean to indicate if this mapping should be saved as static mapping file.</param>
public RespondWithAProvider(RegistrationCallback registrationCallback, IRequestMatcher requestMatcher, IFileSystemHandler fileSystemHandler, bool saveToFile = false)
{
_registrationCallback = registrationCallback;
_requestMatcher = requestMatcher;
_fileSystemHandler = fileSystemHandler;
_saveToFile = saveToFile;
}
public CollectionsStorageRepository(
IJsonSerializer jsonSerializer,
IFileSystemHandler fileSystemHandler)
{
this.jsonSerializer = jsonSerializer;
this.fileSystemHandler = fileSystemHandler;
}
public CachedFileStorage(
IFileSystemHandler fileSystemHandler,
IJsonSerializer jsonSerializer)
{
this.fileSystemHandler = fileSystemHandler;
this.jsonSerializer = jsonSerializer;
}
/// <summary>
/// Run the server. The method will not return until Stop() is called.
/// </summary>
public void Run()
{
if (authHandler == null)
{
authHandler = new DefaultAuthHandler();
}
if (fsHandler == null)
{
fsHandler = new DefaultFileSystemHandler();
}
if (socket == null)
{
socket = new TcpListener(endpoint);
}
socket.Start();
// listen for new connections
try
{
while (true)
{
Socket peer = socket.AcceptSocket();
IPEndPoint peerPort = (IPEndPoint)peer.RemoteEndPoint;
Session session = new Session(peer, bufferSize,
authHandler.Clone(peerPort),
fsHandler.Clone(peerPort),
logHandler.Clone(peerPort));
session.Start();
sessions.Add(session);
// purge old sessions
for (int i = sessions.Count - 1; i >= 0; --i)
{
if (!sessions[i].IsOpen)
{
sessions.RemoveAt(i);
--i;
}
}
}
}
catch (SocketException)
{
// ignore, Stop() will probably cause this exception
}
finally
{
// close all running connections
foreach (Session s in sessions)
{
s.Stop();
}
}
}
public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
{
Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
Check.Condition(transformerType, t => t == TransformerType.Scriban || t == TransformerType.ScribanDotLiquid, nameof(transformerType));
_fileSystemHandler = fileSystemHandler;
_transformerType = transformerType;
}
public CollectionsStorage(
IJsonSerializer jsonSerializer,
IFileSystemHandler fileSystemHandler,
string fileName)
{
this.jsonSerializer = jsonSerializer;
this.fileSystemHandler = fileSystemHandler;
this.fileName = fileName;
}
public WireMockService(string map, int port, bool useSsl, string assemblyFile, string typeName)
{
_port = port;
_useSsl = useSsl;
_fileHandler = new LocalFileSystemHandler(map);
_assemblyFile = assemblyFile;
_typeName = typeName;
_logger = new WireMockConsoleLogger();
}
public void Initialize(IBuildMusicOptions options, IFileSystemHandler fileSystemHandler = null)
{
_FileSystemHandler = fileSystemHandler ?? new FileSystemHandler();
_IsInitializing = true;
OptionPage = options;
InitializeDuringBuildControls();
_IsInitializing = false;
_ResourceManager = new ResourceManager(this.GetType());
}
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
HandleBarsRegex.Register(handlebarsContext);
HandleBarsJsonPath.Register(handlebarsContext);
HandleBarsLinq.Register(handlebarsContext);
HandleBarsRandom.Register(handlebarsContext);
HandleBarsXeger.Register(handlebarsContext);
HandleBarsFile.Register(handlebarsContext, fileSystemHandler);
}
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
handlebarsContext.RegisterHelper("File", (writer, context, arguments) =>
{
string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments);
writer.Write(value);
});
handlebarsContext.RegisterHelper("File", (writer, options, context, arguments) =>
{
string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments);
options.Template(writer, value);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="Mapping"/> class.
/// </summary>
/// <param name="guid">The unique identifier.</param>
/// <param name="title">The unique title (can be null).</param>
/// <param name="path">The full file path from this mapping title (can be null).</param>
/// <param name="fileSystemHandler">The fileSystemHandler.</param>
/// <param name="requestMatcher">The request matcher.</param>
/// <param name="provider">The provider.</param>
/// <param name="priority">The priority for this mapping.</param>
/// <param name="scenario">The scenario. [Optional]</param>
/// <param name="executionConditionState">State in which the current mapping can occur. [Optional]</param>
/// <param name="nextState">The next state which will occur after the current mapping execution. [Optional]</param>
public Mapping(Guid guid, [CanBeNull] string title, [CanBeNull] string path,
[NotNull] IFileSystemHandler fileSystemHandler, [NotNull] IRequestMatcher requestMatcher, [NotNull] IResponseProvider provider,
int priority, [CanBeNull] string scenario, [CanBeNull] string executionConditionState, [CanBeNull] string nextState)
{
Guid = guid;
Title = title;
Path = path;
FileSystemHandler = fileSystemHandler;
RequestMatcher = requestMatcher;
Provider = provider;
Priority = priority;
Scenario = scenario;
ExecutionConditionState = executionConditionState;
NextState = nextState;
}
/// <summary>
/// Creates a new session, which can afterwards be started with Start().
/// </summary>
public Session(Socket socket, int bufferSize, IAuthHandler authHandler, IFileSystemHandler fileSystemHandler, ILogHandler logHandler)
{
this.controlSocket = socket;
this.dataBufferSize = bufferSize;
this.authHandler = authHandler;
this.fsHandler = fileSystemHandler;
this.logHandler = logHandler;
this.cmdRcvBuffer = new byte[CMD_BUFFER_SIZE];
this.cmdRcvBytes = 0;
this.dataBuffer = new byte[dataBufferSize + 1]; // +1 for partial EOL
this.randomTextIndex = new Random();
this.thread = new Thread(new ThreadStart(this.Work));
}
public static string ReadAllTextWithRetryAndDelay([NotNull] IFileSystemHandler filehandler, [NotNull] string path)
{
Check.NotNull(filehandler, nameof(filehandler));
Check.NotNullOrEmpty(path, nameof(path));
for (int i = 1; i <= NumberOfRetries; ++i)
{
try
{
return(filehandler.ReadMappingFile(path));
}
catch
{
Thread.Sleep(DelayOnRetry);
}
}
throw new IOException();
}
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
// Register https://github.com/StefH/Handlebars.Net.Helpers
HandlebarsHelpers.Register(handlebarsContext);
// Register WireMock.Net specific helpers
HandlebarsRegex.Register(handlebarsContext);
HandlebarsJsonPath.Register(handlebarsContext);
HandlebarsLinq.Register(handlebarsContext);
HandlebarsRandom.Register(handlebarsContext);
HandlebarsXeger.Register(handlebarsContext);
HandlebarsXPath.Register(handlebarsContext);
HandlebarsFile.Register(handlebarsContext, fileSystemHandler);
}
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
// Register https://github.com/StefH/Handlebars.Net.Helpers
HandlebarsHelpers.Register(handlebarsContext, o =>
{
o.CustomHelperPaths = new string[]
{
Directory.GetCurrentDirectory()
#if !NETSTANDARD1_3
, Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
#endif
}
.Distinct()
.ToList();
o.CustomHelpers = new Dictionary <string, IHelpers>
{
{ "File", new FileHelpers(handlebarsContext, fileSystemHandler) }
};
});
}
public static bool TryReadMappingFileWithRetryAndDelay([NotNull] IFileSystemHandler handler, [NotNull] string path, out string value)
{
Check.NotNull(handler, nameof(handler));
Check.NotNullOrEmpty(path, nameof(path));
value = null;
for (int i = 1; i <= NumberOfRetries; ++i)
{
try
{
value = handler.ReadMappingFile(path);
return(true);
}
catch
{
Thread.Sleep(DelayOnRetry);
}
}
return(false);
}
private FluentMockServer(IFluentMockServerSettings settings)
{
settings.Logger = settings.Logger ?? new WireMockConsoleLogger();
_logger = settings.Logger;
_fileSystemHandler = settings.FileSystemHandler ?? new LocalFileSystemHandler();
_logger.Info("WireMock.Net by Stef Heyenrath (https://github.com/WireMock-Net/WireMock.Net)");
_logger.Debug("WireMock.Net server settings {0}", JsonConvert.SerializeObject(settings, Formatting.Indented));
if (settings.Urls != null)
{
Urls = settings.Urls.ToArray();
}
else
{
int port = settings.Port > 0 ? settings.Port.Value : PortUtils.FindFreeTcpPort();
Urls = new[] { $"{(settings.UseSSL == true ? "https" : "http")}://localhost:{port}" };
}
_options.PreWireMockMiddlewareInit = settings.PreWireMockMiddlewareInit;
_options.PostWireMockMiddlewareInit = settings.PostWireMockMiddlewareInit;
_options.Logger = _logger;
#if USE_ASPNETCORE
_httpServer = new AspNetCoreSelfHost(_options, Urls);
#else
_httpServer = new OwinSelfHost(_options, Urls);
#endif
Ports = _httpServer.Ports;
var startTask = _httpServer.StartAsync();
using (var ctsStartTimeout = new CancellationTokenSource(settings.StartTimeout))
{
while (!_httpServer.IsStarted)
{
// Throw exception if service start fails
if (_httpServer.RunningException != null)
{
throw new WireMockException($"Service start failed with error: {_httpServer.RunningException.Message}", _httpServer.RunningException);
}
if (ctsStartTimeout.IsCancellationRequested)
{
// In case of an aggregate exception, throw the exception.
if (startTask.Exception != null)
{
throw new WireMockException($"Service start failed with error: {startTask.Exception.Message}", startTask.Exception);
}
// Else throw TimeoutException
throw new TimeoutException($"Service start timed out after {TimeSpan.FromMilliseconds(settings.StartTimeout)}");
}
ctsStartTimeout.Token.WaitHandle.WaitOne(ServerStartDelayInMs);
}
}
if (settings.AllowPartialMapping == true)
{
AllowPartialMapping();
}
if (settings.StartAdminInterface == true)
{
if (!string.IsNullOrEmpty(settings.AdminUsername) && !string.IsNullOrEmpty(settings.AdminPassword))
{
SetBasicAuthentication(settings.AdminUsername, settings.AdminPassword);
}
InitAdmin();
}
if (settings.ReadStaticMappings == true)
{
ReadStaticMappings();
}
if (settings.WatchStaticMappings == true)
{
WatchStaticMappings();
}
if (settings.ProxyAndRecordSettings != null)
{
InitProxyAndRecord(settings);
}
if (settings.RequestLogExpirationDuration != null)
{
SetRequestLogExpirationDuration(settings.RequestLogExpirationDuration);
}
if (settings.MaxRequestLogCount != null)
{
SetMaxRequestLogCount(settings.MaxRequestLogCount);
}
}
internal Data(IFileSystemHandler fileSystemHandler = null)
{
this.FileSystemHandler = fileSystemHandler ?? new FileSystemHandler();
}
private static string ParseArgumentAndReadFileFragment(IHandlebars handlebarsContext, dynamic context, IFileSystemHandler fileSystemHandler, object[] arguments)
{
Check.Condition(arguments, args => args.Length == 1, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
switch (arguments[0])
{
case string path:
var templateFunc = handlebarsContext.Compile(path);
string transformed = templateFunc(context);
return(fileSystemHandler.ReadResponseBodyAsString(transformed));
}
throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars File.");
}
public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
{
FileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
_transformerType = transformerType;
}
/// <summary>
/// Run the server. The method will not return until Stop() is called.
/// </summary>
public void Run()
{
if (authHandler == null)
authHandler = new DefaultAuthHandler();
if (fsHandler == null)
fsHandler = new DefaultFileSystemHandler();
if (socket == null)
socket = new TcpListener(endpoint);
socket.Start();
// listen for new connections
try {
while (true)
{
Socket peer = socket.AcceptSocket();
IPEndPoint peerPort = (IPEndPoint) peer.RemoteEndPoint;
Session session = new Session(peer, bufferSize,
authHandler.Clone(peerPort),
fsHandler.Clone(peerPort),
logHandler.Clone(peerPort));
session.Start();
sessions.Add(session);
// purge old sessions
for (int i = sessions.Count - 1; i >= 0; --i)
{
if (!sessions[i].IsOpen) {
sessions.RemoveAt(i);
--i;
}
}
}
} catch (SocketException) {
// ignore, Stop() will probably cause this exception
} finally {
// close all running connections
foreach (Session s in sessions) {
s.Stop();
}
}
}
public Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
{
return(_responseMessageFunc(requestMessage, _settings));
}
public ResponseMessageTransformer([NotNull] IFileSystemHandler fileSystemHandler)
{
Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
HandlebarsHelpers.Register(HandlebarsContext, fileSystemHandler);
}
private ExplorerTree.Data.API.Data CreateData(IFileSystemHandler fileSystemHandler = null)
{
fileSystemHandler = fileSystemHandler ?? Substitute.For <IFileSystemHandler>();
return(new ExplorerTree.Data.API.Data(fileSystemHandler));
}
public ProjectFactory(IFileSystemHandler fileSystemHandler)
{
this.fileSystemHandler = fileSystemHandler;
}
public HandlebarsContextFactory(IFileSystemHandler fileSystemHandler, Action <IHandlebars, IFileSystemHandler> action)
{
_fileSystemHandler = fileSystemHandler;
_action = action;
}
public async Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
{
Check.NotNull(requestMessage, nameof(requestMessage));
if (Delay != null)
{
await Task.Delay(Delay.Value);
}
if (Callback != null)
{
var callbackResponseMessage = Callback(requestMessage);
if (!WithCallbackUsed)
{
// Copy StatusCode from ResponseMessage
callbackResponseMessage.StatusCode = ResponseMessage.StatusCode;
// Copy Headers from ResponseMessage (if defined)
if (ResponseMessage.Headers != null)
{
callbackResponseMessage.Headers = ResponseMessage.Headers;
}
}
return(callbackResponseMessage);
}
if (ProxyUrl != null && _httpClientForProxy != null)
{
var requestUri = new Uri(requestMessage.Url);
var proxyUri = new Uri(ProxyUrl);
var proxyUriWithRequestPathAndQuery = new Uri(proxyUri, requestUri.PathAndQuery);
return(await HttpClientHelper.SendAsync(_httpClientForProxy, requestMessage, proxyUriWithRequestPathAndQuery.AbsoluteUri));
}
if (UseTransformer)
{
var responseMessageTransformer = new ResponseMessageTransformer(fileSystemHandler);
return(responseMessageTransformer.Transform(requestMessage, ResponseMessage));
}
if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true)
{
ResponseMessage.BodyData.BodyAsBytes = fileSystemHandler.ReadResponseBodyAsFile(ResponseMessage.BodyData.BodyAsFile);
ResponseMessage.BodyData.BodyAsFile = null;
}
return(ResponseMessage);
}
public ProjectFactory(IFileSystemHandler fileSystemHandler)
{
this.fileSystemHandler = fileSystemHandler;
}
public Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
{
return(Task.FromResult(_responseMessageFunc(requestMessage)));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="fileSystemHandler">The IFileSystemHandler.</param>
public OwinResponseMapper(IFileSystemHandler fileSystemHandler)
{
Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
_fileSystemHandler = fileSystemHandler;
}
public HandlebarsContextFactory([NotNull] IFileSystemHandler fileSystemHandler, [CanBeNull] Action <IHandlebars, IFileSystemHandler> action)
{
_fileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
_action = action;
}
