public Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { Invoked = true; return(_provider.ProvideResponseAsync(requestMessage, settings)); }
protected InventoryServiceMock(IWireMockServerSettings settings) : base(settings) { }
public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { if (_httpClientForProxy != null) { return _responseMessageFuncWithHttpClient(requestMessage, _settings, _httpClientForProxy); } return _responseMessageFunc(requestMessage, _settings); }
public ProxyHelper([NotNull] IWireMockServerSettings settings) { _settings = Check.NotNull(settings, nameof(settings)); }
/// <summary> /// Initializes a new instance of the <see cref="WireMockServer"/> class. /// </summary> /// <param name="settings">The settings.</param> /// <exception cref="WireMockException"> /// Service start failed with error: {_httpServer.RunningException.Message} /// or /// Service start failed with error: {startTask.Exception.Message} /// </exception> /// <exception cref="TimeoutException">Service start timed out after {TimeSpan.FromMilliseconds(settings.StartTimeout)}</exception> protected WireMockServer(IWireMockServerSettings settings) { _settings = settings; // Set default values if not provided _settings.Logger = settings.Logger ?? new WireMockNullLogger(); _settings.FileSystemHandler = settings.FileSystemHandler ?? new LocalFileSystemHandler(); _settings.Logger.Info("WireMock.Net by Stef Heyenrath (https://github.com/WireMock-Net/WireMock.Net)"); _settings.Logger.Debug("WireMock.Net server settings {0}", JsonConvert.SerializeObject(settings, Formatting.Indented)); HostUrlOptions urlOptions; if (settings.Urls != null) { urlOptions = new HostUrlOptions { Urls = settings.Urls }; } else { urlOptions = new HostUrlOptions { UseSSL = settings.UseSSL == true, Port = settings.Port }; } _options.FileSystemHandler = _settings.FileSystemHandler; _options.PreWireMockMiddlewareInit = _settings.PreWireMockMiddlewareInit; _options.PostWireMockMiddlewareInit = _settings.PostWireMockMiddlewareInit; _options.Logger = _settings.Logger; _options.DisableJsonBodyParsing = _settings.DisableJsonBodyParsing; _options.HandleRequestsSynchronously = settings.HandleRequestsSynchronously; if (settings.CustomCertificateDefined) { _options.X509StoreName = settings.CertificateSettings.X509StoreName; _options.X509StoreLocation = settings.CertificateSettings.X509StoreLocation; _options.X509ThumbprintOrSubjectName = settings.CertificateSettings.X509StoreThumbprintOrSubjectName; _options.X509CertificateFilePath = settings.CertificateSettings.X509CertificateFilePath; _options.X509CertificatePassword = settings.CertificateSettings.X509CertificatePassword; } _matcherMapper = new MatcherMapper(_settings); _mappingConverter = new MappingConverter(_matcherMapper); _mappingToFileSaver = new MappingToFileSaver(_settings, _mappingConverter); #if USE_ASPNETCORE _options.AdditionalServiceRegistration = _settings.AdditionalServiceRegistration; _httpServer = new AspNetCoreSelfHost(_options, urlOptions); #else _httpServer = new OwinSelfHost(_options, urlOptions); #endif 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); } Urls = _httpServer.Urls.ToArray(); Ports = _httpServer.Ports; } if (settings.AllowBodyForAllHttpMethods == true) { _options.AllowBodyForAllHttpMethods = _settings.AllowBodyForAllHttpMethods; _settings.Logger.Info("AllowBodyForAllHttpMethods is set to True"); } if (settings.AllowOnlyDefinedHttpStatusCodeInResponse == true) { _options.AllowOnlyDefinedHttpStatusCodeInResponse = _settings.AllowOnlyDefinedHttpStatusCodeInResponse; _settings.Logger.Info("AllowOnlyDefinedHttpStatusCodeInResponse is set to True"); } 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); } }
public ProxyAsyncResponseProvider(Func<RequestMessage, IWireMockServerSettings, HttpClient, Task<ResponseMessage>> responseMessageFunc, IWireMockServerSettings settings, HttpClient p_httpClientForProxy) { _responseMessageFuncWithHttpClient = responseMessageFunc; _settings = settings; _httpClientForProxy = p_httpClientForProxy; }
public WebhookSender(IWireMockServerSettings settings) { _settings = settings ?? throw new ArgumentNullException(nameof(settings)); }
private async Task <ResponseMessage> ProxyAndRecordAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { var requestUri = new Uri(requestMessage.Url); var proxyUri = new Uri(settings.ProxyAndRecordSettings.Url); var proxyUriWithRequestPathAndQuery = new Uri(proxyUri, requestUri.PathAndQuery); var responseMessage = await HttpClientHelper.SendAsync(_httpClientForProxy, requestMessage, proxyUriWithRequestPathAndQuery.AbsoluteUri); if (HttpStatusRangeParser.IsMatch(settings.ProxyAndRecordSettings.SaveMappingForStatusCodePattern, responseMessage.StatusCode) && (settings.ProxyAndRecordSettings.SaveMapping || settings.ProxyAndRecordSettings.SaveMappingToFile)) { var mapping = ToMapping(requestMessage, responseMessage, settings.ProxyAndRecordSettings.BlackListedHeaders ?? new string[] { }, settings.ProxyAndRecordSettings.BlackListedCookies ?? new string[] { }); if (settings.ProxyAndRecordSettings.SaveMapping) { _options.Mappings.TryAdd(mapping.Guid, mapping); } if (settings.ProxyAndRecordSettings.SaveMappingToFile) { SaveMappingToFile(mapping); } } return(responseMessage); }
public ProxyHelper([NotNull] IWireMockServerSettings settings) { Guard.NotNull(settings, nameof(settings)); _settings = settings; }
/// <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="settings">The WireMockServerSettings.</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, IWireMockServerSettings settings, bool saveToFile = false) { _registrationCallback = registrationCallback; _requestMatcher = requestMatcher; _settings = settings; _saveToFile = saveToFile; }
public MatcherMapper(IWireMockServerSettings settings) { _settings = settings ?? throw new ArgumentNullException(nameof(settings)); }
public static bool TryParseArguments([NotNull] string[] args, out IWireMockServerSettings settings, [CanBeNull] IWireMockLogger logger = null) { Check.HasNoNulls(args, nameof(args)); var parser = new SimpleCommandLineParser(); parser.Parse(args); if (parser.GetBoolSwitchValue("help")) { (logger ?? new WireMockConsoleLogger()).Info("See https://github.com/WireMock-Net/WireMock.Net/wiki/WireMock-commandline-parameters for details on all commandline options."); settings = null; return(false); } settings = new WireMockServerSettings { StartAdminInterface = parser.GetBoolValue("StartAdminInterface", true), ReadStaticMappings = parser.GetBoolValue("ReadStaticMappings"), WatchStaticMappings = parser.GetBoolValue("WatchStaticMappings"), AllowPartialMapping = parser.GetBoolValue("AllowPartialMapping"), WatchStaticMappingsInSubdirectories = parser.GetBoolValue("WatchStaticMappingsInSubdirectories"), AdminUsername = parser.GetStringValue("AdminUsername"), AdminPassword = parser.GetStringValue("AdminPassword"), AdminAzureADTenant = parser.GetStringValue(nameof(IWireMockServerSettings.AdminAzureADTenant)), AdminAzureADAudience = parser.GetStringValue(nameof(IWireMockServerSettings.AdminAzureADAudience)), MaxRequestLogCount = parser.GetIntValue("MaxRequestLogCount"), RequestLogExpirationDuration = parser.GetIntValue("RequestLogExpirationDuration"), AllowCSharpCodeMatcher = parser.GetBoolValue("AllowCSharpCodeMatcher"), AllowBodyForAllHttpMethods = parser.GetBoolValue("AllowBodyForAllHttpMethods"), AllowOnlyDefinedHttpStatusCodeInResponse = parser.GetBoolValue("AllowOnlyDefinedHttpStatusCodeInResponse"), DisableJsonBodyParsing = parser.GetBoolValue("DisableJsonBodyParsing"), HandleRequestsSynchronously = parser.GetBoolValue("HandleRequestsSynchronously"), ThrowExceptionWhenMatcherFails = parser.GetBoolValue("ThrowExceptionWhenMatcherFails") }; 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") ?? parser.GetStringValue("ProxyUrl"); if (!string.IsNullOrEmpty(proxyUrl)) { settings.ProxyAndRecordSettings = new ProxyAndRecordSettings { Url = proxyUrl, SaveMapping = parser.GetBoolValue("SaveMapping"), SaveMappingToFile = parser.GetBoolValue("SaveMappingToFile"), SaveMappingForStatusCodePattern = parser.GetStringValue("SaveMappingForStatusCodePattern"), ClientX509Certificate2ThumbprintOrSubjectName = parser.GetStringValue("ClientX509Certificate2ThumbprintOrSubjectName"), ExcludedHeaders = parser.GetValues("ExcludedHeaders"), ExcludedCookies = parser.GetValues("ExcludedCookies"), AllowAutoRedirect = parser.GetBoolValue("AllowAutoRedirect") }; string proxyAddress = parser.GetStringValue("WebProxyAddress"); if (!string.IsNullOrEmpty(proxyAddress)) { settings.ProxyAndRecordSettings.WebProxySettings = new WebProxySettings { Address = proxyAddress, UserName = parser.GetStringValue("WebProxyUserName"), Password = parser.GetStringValue("WebProxyPassword") }; } } var certificateSettings = new WireMockCertificateSettings { X509StoreName = parser.GetStringValue("X509StoreName"), X509StoreLocation = parser.GetStringValue("X509StoreLocation"), X509StoreThumbprintOrSubjectName = parser.GetStringValue("X509StoreThumbprintOrSubjectName"), X509CertificateFilePath = parser.GetStringValue("X509CertificateFilePath"), X509CertificatePassword = parser.GetStringValue("X509CertificatePassword") }; if (certificateSettings.IsDefined) { settings.CertificateSettings = certificateSettings; } return(true); }
public static WireMockServer Start([NotNull] IWireMockServerSettings settings) { Check.NotNull(settings, nameof(settings)); return(new WireMockServer(settings)); }
public Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { return(Task.FromResult(_responseMessageFunc(requestMessage))); }
private async Task <ResponseMessage> ProxyAndRecordAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { var requestUri = new Uri(requestMessage.Url); var proxyUri = new Uri(settings.ProxyAndRecordSettings.Url); var proxyUriWithRequestPathAndQuery = new Uri(proxyUri, requestUri.PathAndQuery); var proxyHelper = new ProxyHelper(settings); var(responseMessage, mapping) = await proxyHelper.SendAsync( _settings.ProxyAndRecordSettings, _httpClientForProxy, requestMessage, proxyUriWithRequestPathAndQuery.AbsoluteUri ); if (mapping != null) { if (settings.ProxyAndRecordSettings.SaveMapping) { _options.Mappings.TryAdd(mapping.Guid, mapping); } if (settings.ProxyAndRecordSettings.SaveMappingToFile) { _mappingToFileSaver.SaveMappingToFile(mapping); } } return(responseMessage); }
/// <inheritdoc cref="IResponseProvider.ProvideResponseAsync(RequestMessage, IWireMockServerSettings)"/> public async Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { Check.NotNull(requestMessage, nameof(requestMessage)); Check.NotNull(settings, nameof(settings)); if (Delay != null) { await Task.Delay(Delay.Value); } 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, !settings.DisableJsonBodyParsing.GetValueOrDefault(false))); } ResponseMessage responseMessage; if (Callback == null) { responseMessage = ResponseMessage; } else { responseMessage = Callback(requestMessage); if (!WithCallbackUsed) { // Copy StatusCode from ResponseMessage responseMessage.StatusCode = ResponseMessage.StatusCode; // Copy Headers from ResponseMessage (if defined) if (ResponseMessage.Headers != null) { responseMessage.Headers = ResponseMessage.Headers; } } } if (UseTransformer) { var factory = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback); var responseMessageTransformer = new ResponseMessageTransformer(factory); return(responseMessageTransformer.Transform(requestMessage, responseMessage, UseTransformerForBodyAsFile)); } if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true) { ResponseMessage.BodyData.BodyAsBytes = settings.FileSystemHandler.ReadResponseBodyAsFile(responseMessage.BodyData.BodyAsFile); } return(responseMessage); }
public ProxyAsyncResponseProvider(Func<RequestMessage, IWireMockServerSettings, Task<ResponseMessage>> responseMessageFunc, IWireMockServerSettings settings) { _responseMessageFunc = responseMessageFunc; _settings = settings; }
public MatcherMapper(IWireMockServerSettings settings) { Check.NotNull(settings, nameof(settings)); _settings = settings; }
/// <inheritdoc cref="IResponseProvider.ProvideResponseAsync(RequestMessage, IWireMockServerSettings)"/> public async Task <(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) { Check.NotNull(requestMessage, nameof(requestMessage)); Check.NotNull(settings, nameof(settings)); if (Delay != null) { await Task.Delay(Delay.Value); } if (ProxyAndRecordSettings != null && _httpClientForProxy != null) { string RemoveFirstOccurrence(string source, string find) { int place = source.IndexOf(find, StringComparison.OrdinalIgnoreCase); return(place >= 0 ? source.Remove(place, find.Length) : source); } var requestUri = new Uri(requestMessage.Url); // Build the proxy url and skip duplicates string extra = RemoveFirstOccurrence(requestUri.LocalPath.TrimEnd('/'), new Uri(ProxyAndRecordSettings.Url).LocalPath.TrimEnd('/')); requestMessage.ProxyUrl = ProxyAndRecordSettings.Url + extra + requestUri.Query; var proxyHelper = new ProxyHelper(settings); return(await proxyHelper.SendAsync( ProxyAndRecordSettings, _httpClientForProxy, requestMessage, requestMessage.ProxyUrl )); } ResponseMessage responseMessage; if (!WithCallbackUsed) { responseMessage = ResponseMessage; } else { if (Callback != null) { responseMessage = Callback(requestMessage); } else { responseMessage = await CallbackAsync(requestMessage); } // Copy StatusCode from ResponseMessage (if defined) if (ResponseMessage.StatusCode != null) { responseMessage.StatusCode = ResponseMessage.StatusCode; } // Copy Headers from ResponseMessage (if defined) if (ResponseMessage.Headers?.Count > 0) { responseMessage.Headers = ResponseMessage.Headers; } } if (UseTransformer) { ITransformer responseMessageTransformer; switch (TransformerType) { case TransformerType.Handlebars: var factoryHandlebars = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback); responseMessageTransformer = new Transformer(factoryHandlebars); break; case TransformerType.Scriban: case TransformerType.ScribanDotLiquid: var factoryDotLiquid = new ScribanContextFactory(settings.FileSystemHandler, TransformerType); responseMessageTransformer = new Transformer(factoryDotLiquid); break; default: throw new NotImplementedException($"TransformerType '{TransformerType}' is not supported."); } return(responseMessageTransformer.Transform(requestMessage, responseMessage, UseTransformerForBodyAsFile), null); } if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true) { ResponseMessage.BodyData.BodyAsBytes = settings.FileSystemHandler.ReadResponseBodyAsFile(responseMessage.BodyData.BodyAsFile); } return(responseMessage, null); }