public async Task Invoke( HttpContext httpContext, IMockacoContext mockacoContext, IOptionsSnapshot <MockacoOptions> statusCodeOptions, IMockProvider mockProvider, ILogger <ErrorHandlingMiddleware> logger) { try { await _next(httpContext); } catch (Exception ex) { logger.LogError(ex, "Error generating mocked response"); mockacoContext.Errors.Add(new Error("Error generating mocked response", ex)); } finally { if (mockacoContext.Errors.Any() && !httpContext.Response.HasStarted) { httpContext.Response.StatusCode = (int)statusCodeOptions.Value.ErrorHttpStatusCode; httpContext.Response.ContentType = HttpContentTypes.ApplicationJson; IncludeMockProviderErrors(mockacoContext, mockProvider); await httpContext.Response.WriteAsync(mockacoContext.Errors.ToJson()); } } }
public async Task Invoke(HttpContext httpContext, IMockacoContext mockacoContext, ILogger <ResponseDelayMiddleware> logger) { var stopwatch = Stopwatch.StartNew(); await _next(httpContext); var transformedTemplate = mockacoContext.TransformedTemplate; if (transformedTemplate == default) { return; } int responseDelay = transformedTemplate.Response?.Delay.GetValueOrDefault() ?? 0; stopwatch.Stop(); var remainingDelay = responseDelay - (int)stopwatch.ElapsedMilliseconds; if (remainingDelay > 0) { logger.LogDebug("Response delay: {responseDelay} milliseconds", responseDelay); await Task.Delay(remainingDelay); } }
private async Task PerformCallbacks( HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext, ITemplateTransformer templateTransformer, MockacoOptions options) { try { var stopwatch = Stopwatch.StartNew(); var template = await templateTransformer.Transform(mockacoContext.Mock.RawTemplate, scriptContext); var callbackTasks = new List <Task>(); foreach (var callbackTemplate in template.Callbacks) { callbackTasks.Add(PerformCallback(httpContext, callbackTemplate, options, stopwatch.ElapsedMilliseconds)); } await Task.WhenAll(callbackTasks); } catch (Exception ex) { _logger.LogError(ex, "Error preparing callback(s)"); } }
private async Task PerformCallback( HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext, ITemplateTransformer templateTransformer, MockacoOptions options) { try { var stopwatch = Stopwatch.StartNew(); var callbackTemplate = await PrepareCallbackTemplate(mockacoContext, scriptContext, templateTransformer); var request = PrepareHttpRequest(callbackTemplate, options); var httpClient = PrepareHttpClient(httpContext, callbackTemplate); await DelayRequest(callbackTemplate, stopwatch.ElapsedMilliseconds); stopwatch.Restart(); _logger.LogDebug("Callback started"); await PerformRequest(request, httpClient); _logger.LogDebug("Callback finished in {0} ms", stopwatch.ElapsedMilliseconds); } catch (Exception ex) { _logger.LogError(ex, "Callback error"); } }
public ResponseDelayMiddlewareTest() { _next = Moq.Mock.Of <RequestDelegate>(); _mockacoContext = Moq.Mock.Of <IMockacoContext>(); _middleware = new ResponseDelayMiddleware(_next); _httpContext = Moq.Mock.Of <HttpContext>(); _logger = Moq.Mock.Of <ILogger <ResponseDelayMiddleware> >(); }
public async Task Invoke( HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext, IMockProvider mockProvider, ITemplateTransformer templateTransformer, IEnumerable <IRequestMatcher> requestMatchers ) { LogHttpContext(httpContext); AttachRequestToScriptContext(httpContext, mockacoContext, scriptContext); if (mockacoContext.Errors.Any()) { return; } foreach (var mock in mockProvider.GetMocks()) { if (requestMatchers.All(_ => _.IsMatch(httpContext.Request, mock))) { scriptContext.AttachRouteParameters(httpContext.Request, mock); var template = await templateTransformer.Transform(mock.RawTemplate, scriptContext); var conditionIsMatch = template.Request?.Condition ?? true; if (conditionIsMatch) { _logger.LogInformation("Incoming request matched {mock}", mock); mockacoContext.Mock = mock; mockacoContext.TransformedTemplate = template; await _next(httpContext); return; } else { _logger.LogDebug("Incoming request didn't match condition for {mock}", mock); } } else { _logger.LogDebug("Incoming request didn't match {mock}", mock); } } _logger.LogInformation("Incoming request didn't match any mock"); mockacoContext.Errors.Add(new Error("Incoming request didn't match any mock")); }
public async Task Invoke( HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext, IResponseBodyFactory responseBodyFactory, IOptionsSnapshot <MockacoOptions> options) { await PrepareResponse(httpContext.Response, mockacoContext.TransformedTemplate, responseBodyFactory, options.Value); scriptContext.AttachResponse(httpContext.Response, mockacoContext.TransformedTemplate.Response); await _next(httpContext); }
private void AttachRequestToScriptContext(HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext) { try { scriptContext.AttachRequest(httpContext.Request); } catch (Exception ex) { mockacoContext.Errors.Add(new Error("An error occurred while reading request", ex)); _logger.LogWarning(ex, "An error occurred while reading request"); return; } }
public RequestConditionMatcher( ITemplateTransformer templateTransformer, IFakerFactory fakerFactory, IRequestBodyFactory requestBodyFactory, IMockacoContext mockacoContext, IGlobalVariableStorage globalVariableStoreage, ILogger <RequestConditionMatcher> logger) { _templateTransformer = templateTransformer; _fakerFactory = fakerFactory; _requestBodyFactory = requestBodyFactory; _mockacoContext = mockacoContext; _globalVarialeStorage = globalVariableStoreage; _logger = logger; }
public Task Invoke( HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext, ITemplateTransformer templateTransformer, IOptionsSnapshot <MockacoOptions> options) { if (mockacoContext.TransformedTemplate?.Callback == null) { return(Task.CompletedTask); } httpContext.Response.OnCompleted( () => { var fireAndForgetTask = PerformCallback(httpContext, mockacoContext, scriptContext, templateTransformer, options.Value); return(Task.CompletedTask); }); return(Task.CompletedTask); }
public Task Invoke( HttpContext httpContext, IMockacoContext mockacoContext, IScriptContext scriptContext, ITemplateTransformer templateTransformer, IOptionsSnapshot <MockacoOptions> options) { if (mockacoContext.TransformedTemplate?.Callbacks?.Any() != true) { return(Task.CompletedTask); } httpContext.Response.OnCompleted( () => { //TODO Refactor to avoid method with too many parameters (maybe a CallbackRunnerFactory?) var fireAndForgetTask = PerformCallbacks(httpContext, mockacoContext, scriptContext, templateTransformer, options.Value); return(Task.CompletedTask); }); return(Task.CompletedTask); }
private static void IncludeMockProviderErrors(IMockacoContext mockacoContext, IMockProvider mockProvider) { mockacoContext.Errors .AddRange(mockProvider.GetErrors() .Select(_ => new Error($"{_.TemplateName} - {_.ErrorMessage}"))); }
private static async Task <CallbackTemplate> PrepareCallbackTemplate(IMockacoContext mockacoContext, IScriptContext scriptContext, ITemplateTransformer templateTransformer) { var template = await templateTransformer.Transform(mockacoContext.Mock.RawTemplate, scriptContext); return(template.Callback); }