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