public void Create_Throws_And_Traces_When_Inner_Throws()
{
// Arrange
Mock<ApiController> mockController = new Mock<ApiController>();
Mock<IHttpControllerActivator> mockActivator = new Mock<IHttpControllerActivator>() { CallBase = true };
InvalidOperationException exception = new InvalidOperationException("test");
mockActivator.Setup(b => b.Create(It.IsAny<HttpRequestMessage>(), It.IsAny<HttpControllerDescriptor>(), It.IsAny<Type>())).Throws(exception);
HttpRequestMessage request = new HttpRequestMessage();
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerActivatorTracer tracer = new HttpControllerActivatorTracer(mockActivator.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Create" },
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "Create" }
};
// Act & Assert
Exception thrown = Assert.Throws<InvalidOperationException>(() => ((IHttpControllerActivator)tracer).Create(request, controllerDescriptor: null, controllerType: mockController.Object.GetType()));
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteBindingAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException();
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
tcs.TrySetException(exception);
Mock<HttpActionBinding> mockBinder = new Mock<HttpActionBinding>() { CallBase = true };
mockBinder.Setup(b => b.ExecuteBindingAsync(
It.IsAny<HttpActionContext>(),
It.IsAny<CancellationToken>())).
Returns(tcs.Task);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionBindingTracer tracer = new HttpActionBindingTracer(mockBinder.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End }
};
// Act
Task task = tracer.ExecuteBindingAsync(_actionContext, CancellationToken.None);
// Assert
Exception thrown = Assert.Throws<InvalidOperationException>(() => task.Wait());
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteAuthorizationFilterAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
Mock<IAuthorizationFilter> mockAttr = new Mock<IAuthorizationFilter>() { CallBase = true };
HttpResponseMessage response = new HttpResponseMessage();
InvalidOperationException exception = new InvalidOperationException("test");
TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(response);
tcs.TrySetException(exception);
mockAttr.Setup(a => a.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>(), It.IsAny<Func<Task<HttpResponseMessage>>>())).Returns(tcs.Task);
Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
Func<Task<HttpResponseMessage>> continuation = () => TaskHelpers.FromResult<HttpResponseMessage>(response);
TestTraceWriter traceWriter = new TestTraceWriter();
AuthorizationFilterTracer tracer = new AuthorizationFilterTracer(mockAttr.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteAuthorizationFilterAsync" },
new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteAuthorizationFilterAsync" }
};
// Act & Assert
Task task = ((IAuthorizationFilter)tracer).ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation);
Exception thrown = Assert.Throws<InvalidOperationException>(() => task.Wait());
// Assert
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteExceptionFilterAsync_Traces()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock<ExceptionFilterAttribute> mockAttr = new Mock<ExceptionFilterAttribute>() { CallBase = true };
Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttr.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnException" },
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "OnException" },
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteAuthorizationFilterAsync_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock<IAuthorizationFilter> mockFilter = new Mock<IAuthorizationFilter>() { CallBase = true };
mockFilter.Setup(f => f.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>(), It.IsAny<Func<Task<HttpResponseMessage>>>())).Returns(TaskHelpers.FromResult(response));
Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
Func<Task<HttpResponseMessage>> continuation = () => TaskHelpers.FromResult<HttpResponseMessage>(new HttpResponseMessage());
TestTraceWriter traceWriter = new TestTraceWriter();
AuthorizationFilterTracer tracer = new AuthorizationFilterTracer(mockFilter.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteAuthorizationFilterAsync" },
new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ExecuteAuthorizationFilterAsync" },
};
// Act
Task task = ((IAuthorizationFilter)tracer).ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation);
task.Wait();
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteExceptionFilterAsync_Throws_And_Traces_When_Inner_OnException_Throws()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock<ExceptionFilterAttribute> mockAttr = new Mock<ExceptionFilterAttribute>() { CallBase = true };
InvalidOperationException exception = new InvalidOperationException("test");
mockAttr.Setup(a => a.OnException(It.IsAny<HttpActionExecutedContext>())).Throws(exception);
Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttr.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnException" },
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "OnException" }
};
// Act
Exception thrown =
Assert.Throws<InvalidOperationException>(
() => ((IExceptionFilter) tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None));
// Assert
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteExceptionFilterAsync_Traces()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock<IExceptionFilter> mockFilter = new Mock<IExceptionFilter>() { CallBase = true };
mockFilter.Setup(
f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(), It.IsAny<CancellationToken>())).
Returns(TaskHelpers.Completed());
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterTracer tracer = new ExceptionFilterTracer(mockFilter.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteExceptionFilterAsync" },
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ExecuteExceptionFilterAsync" },
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ReadFromStream_Traces_And_Throws_When_Inner_Throws()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("test");
Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
mockFormatter.Setup(
f => f.ReadFromStream(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>())).Throws(exception);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStream" },
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ReadFromStream" }
};
// Act
Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.ReadFromStream(typeof(string), new MemoryStream(), request.Content, null));
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void SendAsync_Traces_And_Invokes_Inner()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) =>
TaskHelpers.FromResult<HttpResponseMessage>(response));
TestTraceWriter traceWriter = new TestTraceWriter();
MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);
MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) =>
TaskHelpers.FromResult<HttpResponseMessage>(response));
tracer.InnerHandler = mockInnerHandler;
HttpRequestMessage request = new HttpRequestMessage();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "SendAsync" }
};
MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance);
// Act
Task<HttpResponseMessage> task = method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;
HttpResponseMessage actualResponse = task.Result;
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(response, actualResponse);
}
public void ExecuteBindingAsync_Traces_And_Invokes_Inner()
{
// Arrange
Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object) { CallBase = true };
bool innerInvoked = false;
mockBinding.Setup(
b =>
b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
It.IsAny<CancellationToken>())).Returns(TaskHelpers.Completed()).Callback(() => innerInvoked = true);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, traceWriter);
HttpActionContext actionContext = ContextUtil.CreateActionContext();
ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
};
// Act
Task task = tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.True(innerInvoked);
}
public void OnReadFromStreamAsync_Traces_And_Faults_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("test");
Mock<MediaTypeFormatter> mockFormatter = new Mock<MediaTypeFormatter>() { CallBase = true };
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
tcs.TrySetException(exception);
mockFormatter.Setup(
f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContentHeaders>(), It.IsAny<IFormatterLogger>())).
Returns(tcs.Task);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
MediaTypeFormatterTracer tracer = new MediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync" },
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ReadFromStreamAsync" }
};
// Act
Task<object> task = tracer.ReadFromStreamAsync(typeof(string), new MemoryStream(), request.Content.Headers, null);
// Assert
Exception thrown = Assert.Throws<InvalidOperationException>(() => task.Wait());
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteAsync_Invokes_Inner_And_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(TaskHelpers.FromResult<HttpResponseMessage>(response));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End }
};
// Act
HttpResponseMessage actualResponse = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Result;
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(response, actualResponse);
}
public void OnReadFromStreamAsync_Traces()
{
// Arrange
Mock<MediaTypeFormatter> mockFormatter = new Mock<MediaTypeFormatter>() { CallBase = true };
mockFormatter.Setup(
f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContentHeaders>(), It.IsAny<IFormatterLogger>())).
Returns(TaskHelpers.FromResult<object>("sampleValue"));
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
MediaTypeFormatterTracer tracer = new MediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync" },
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ReadFromStreamAsync" }
};
// Act
Task<object> task = tracer.ReadFromStreamAsync(typeof(string), new MemoryStream(), request.Content.Headers, null);
string result = task.Result as string;
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Equal("sampleValue", result);
}
public void BindValuesAsync_Invokes_Inner_And_Traces()
{
// Arrange
bool wasInvoked = false;
Mock<HttpActionBinding> mockBinder = new Mock<HttpActionBinding>() { CallBase = true };
mockBinder.Setup(b => b.ExecuteBindingAsync(
It.IsAny<HttpActionContext>(),
It.IsAny<CancellationToken>())).
Callback(() => wasInvoked = true).Returns(TaskHelpers.Completed());
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionBindingTracer tracer = new HttpActionBindingTracer(mockBinder.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.End }
};
// Act
tracer.ExecuteBindingAsync(_actionContext, CancellationToken.None).Wait();
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.True(wasInvoked);
}
public void SendAsync_Traces_And_Throws_When_Inner_Throws()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("test");
MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) => { throw exception; });
TestTraceWriter traceWriter = new TestTraceWriter();
MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);
// DelegatingHandlers require an InnerHandler to run. We create a mock one to simulate what
// would happen when a DelegatingHandler executing after the tracer throws.
MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { throw exception; });
tracer.InnerHandler = mockInnerHandler;
HttpRequestMessage request = new HttpRequestMessage();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "SendAsync" }
};
MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance);
// Act
Exception thrown =
Assert.Throws<TargetInvocationException>(
() => method.Invoke(tracer, new object[] { request, CancellationToken.None }));
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown.InnerException);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteExceptionFilterAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock<IExceptionFilter> mockFilter = new Mock<IExceptionFilter>() { CallBase = true };
InvalidOperationException exception = new InvalidOperationException("test");
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
tcs.TrySetException(exception);
mockFilter.Setup(a => a.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterTracer tracer = new ExceptionFilterTracer(mockFilter.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteExceptionFilterAsync" },
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteExceptionFilterAsync" }
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
// Assert
Exception thrown = Assert.Throws<InvalidOperationException>(() => task.Wait());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteBindingAsync_Traces_And_Invokes_Inner_ReadAsync()
{
// Arrange
Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof (string));
FormatterParameterBinding binding = new FormatterParameterBinding(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null);
TestTraceWriter traceWriter = new TestTraceWriter();
FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(binding, traceWriter);
HttpActionContext actionContext = ContextUtil.CreateActionContext();
actionContext.Request.Content = new StringContent("true");
actionContext.Request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
};
// Act
Task task = tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Equal("True", actionContext.ActionArguments["paramName"]);
}
public void ExecuteBindingAsync_Traces_And_Throws_When_Inner_Throws()
{
// Arrange
Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
InvalidOperationException exception = new InvalidOperationException("test");
mockBinding.Setup(
b =>
b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
It.IsAny<CancellationToken>())).Throws(exception);
TestTraceWriter traceWriter = new TestTraceWriter();
FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, traceWriter);
HttpActionContext actionContext = ContextUtil.CreateActionContext();
ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
};
// Act & Assert
Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None));
// Assert
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void SendAsync_Traces_And_Faults_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("test");
TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
tcs.TrySetException(exception);
TestTraceWriter traceWriter = new TestTraceWriter();
RequestMessageHandlerTracer tracer = new RequestMessageHandlerTracer(traceWriter);
// DelegatingHandlers require an InnerHandler to run. We create a mock one to simulate what
// would happen when a DelegatingHandler executing after the tracer returns a Task that throws.
MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { return tcs.Task; });
tracer.InnerHandler = mockInnerHandler;
HttpRequestMessage request = new HttpRequestMessage();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Error) { Kind = TraceKind.End }
};
MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance);
// Act
Task<HttpResponseMessage> task =
method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;
// Assert
Exception thrown = Assert.Throws<InvalidOperationException>(() => task.Wait());
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException();
TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
tcs.TrySetException(exception);
Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End }
};
// Act
Exception thrown = Assert.Throws<InvalidOperationException>(() => ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Wait());
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void Dispose_DoesNotTraceWhenControllerIsNotDisposable()
{
// Arrange
var mockController = new Mock<IHttpController>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Empty(traceWriter.Traces);
}
public void SelectAction_DoesNotWrapHttpActionDescriptorTracer()
{
// Arrange
TestTraceWriter traceWriter = new TestTraceWriter();
Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>();
HttpActionDescriptorTracer actionDescriptorTracer = new HttpActionDescriptorTracer(_controllerContext, _mockActionDescriptor.Object, traceWriter);
mockSelector.Setup(s => s.SelectAction(_controllerContext)).Returns(actionDescriptorTracer);
HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(mockSelector.Object, traceWriter);
// Act
HttpActionDescriptor selectedActionDescriptor = ((IHttpActionSelector)tracer).SelectAction(_controllerContext);
// Assert
Assert.Same(actionDescriptorTracer, selectedActionDescriptor);
}
public void CreateFilterTracers_IFilter_With_IAuthenticationFilter_Returns_Single_Wrapped_IAuthenticationFilter()
{
// Arrange
IAuthenticationFilter expectedInner = new Mock<IAuthenticationFilter>().Object;
ITraceWriter expectedTraceWriter = new TestTraceWriter();
// Act
IEnumerable<IFilter> tracers = FilterTracer.CreateFilterTracers(expectedInner, expectedTraceWriter);
// Assert
Assert.NotNull(tracers);
Assert.Equal(1, tracers.Count());
IFilter untypedFilter = tracers.Single();
Assert.IsType<AuthenticationFilterTracer>(untypedFilter);
AuthenticationFilterTracer tracer = (AuthenticationFilterTracer)untypedFilter;
Assert.Same(expectedInner, tracer.InnerFilter);
Assert.Same(expectedTraceWriter, tracer.TraceWriter);
}
public void InvokeActionAsync_Traces_Begin_And_End_Info()
{
// Arrange
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(new ApiControllerActionInvoker(), traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.End }
};
// Act
Task task = ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal(2, traceWriter.Traces.Count);
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ResolveAssembly_WithIndirectPrivateDependency_IsResolved()
{
var resolver = new FunctionAssemblyLoader("c:\\");
var metadata1 = new FunctionMetadata { Name = "Test1", Source = @"c:\testroot\test1\test.tst" };
var metadata2 = new FunctionMetadata { Name = "Test2", Source = @"c:\testroot\test2\test.tst" };
var traceWriter = new TestTraceWriter(TraceLevel.Verbose);
var mockResolver = new Mock<IFunctionMetadataResolver>();
mockResolver.Setup(m => m.ResolveAssembly("MyTestAssembly.dll"))
.Returns(new TestAssembly(new AssemblyName("MyTestAssembly")));
resolver.CreateOrUpdateContext(metadata1, this.GetType().Assembly, new FunctionMetadataResolver(metadata1, traceWriter), traceWriter);
resolver.CreateOrUpdateContext(metadata2, this.GetType().Assembly, mockResolver.Object, traceWriter);
Assembly result = resolver.ResolveAssembly(null, new System.ResolveEventArgs("MyTestAssembly.dll",
new TestAssembly(new AssemblyName("MyDirectReference"), @"file:///c:/testroot/test2/bin/MyDirectReference.dll")));
Assert.NotNull(result);
}
public void Dispose_TracesAndInvokesInnerDisposeWhenControllerIsDisposable()
{
// Arrange
var mockController = new Mock<IHttpController>();
var mockDisposable = mockController.As<IDisposable>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
var expectedTraces = new[]
{
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Dispose" },
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "Dispose" }
};
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Equal(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
mockDisposable.Verify(d => d.Dispose(), Times.Once());
}
public void SelectAction_Traces_And_Returns_ActionDescriptor_Tracer()
{
// Arrange
TestTraceWriter traceWriter = new TestTraceWriter();
Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>();
mockSelector.Setup(s => s.SelectAction(_controllerContext)).Returns(_mockActionDescriptor.Object);
HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(mockSelector.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.End }
};
// Act
HttpActionDescriptor selectedActionDescriptor = ((IHttpActionSelector)tracer).SelectAction(_controllerContext);
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.IsAssignableFrom<HttpActionDescriptorTracer>(selectedActionDescriptor);
}
public void CreateController_Invokes_Inner_And_Traces()
{
// Arrange
Mock<HttpControllerDescriptor> mockControllerDescriptor = CreateMockControllerDescriptor();
mockControllerDescriptor.Setup(b => b.CreateController(It.IsAny<HttpRequestMessage>())).Returns(_controller);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerDescriptorTracer tracer = GetHttpControllerDescriptorTracer(mockControllerDescriptor.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "CreateController" },
new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "CreateController" }
};
// Act
IHttpController controller = tracer.CreateController(_request);
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.IsAssignableFrom<HttpControllerTracer>(controller);
}
public void SelectController_Invokes_Inner_And_Traces()
{
// Arrange
Mock<HttpControllerDescriptor> mockControllerDescriptor = new Mock<HttpControllerDescriptor>(_controllerContext.Configuration, "AnyController", _controller.GetType());
Mock<IHttpControllerSelector> mockSelector = new Mock<IHttpControllerSelector>();
mockSelector.Setup(b => b.SelectController(It.IsAny<HttpRequestMessage>())).Returns(mockControllerDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerSelectorTracer tracer = new HttpControllerSelectorTracer(mockSelector.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SelectController" },
new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "SelectController" }
};
// Act
HttpControllerDescriptor controllerDescriptor = ((IHttpControllerSelector)tracer).SelectController(_request);
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.IsAssignableFrom<HttpControllerDescriptorTracer>(controllerDescriptor);
}
public void CreateController_Throws_And_Traces_When_Inner_Throws()
{
// Arrange
Mock<HttpControllerDescriptor> mockControllerDescriptor = CreateMockControllerDescriptor();
mockControllerDescriptor.Setup(b => b.CreateController(It.IsAny<HttpRequestMessage>())).Throws(_exception);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerDescriptorTracer tracer = GetHttpControllerDescriptorTracer(mockControllerDescriptor.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "CreateController" },
new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "CreateController" }
};
// Act
Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.CreateController(_request));
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(_exception, thrown);
Assert.Same(_exception, traceWriter.Traces[1].Exception);
}
public void FileWatcherTest(string path, Action <AutoRecoveringFileSystemWatcher> action, Func <FileSystemEventArgs, bool> changeHandler,
WatcherChangeTypes changeTypes = WatcherChangeTypes.All, bool expectEvent = true)
{
var traceWriter = new TestTraceWriter(System.Diagnostics.TraceLevel.Verbose);
using (var watcher = new AutoRecoveringFileSystemWatcher(path, traceWriter: traceWriter))
{
var resetEvent = new ManualResetEventSlim();
watcher.Changed += (s, a) =>
{
if (changeHandler(a))
{
resetEvent.Set();
}
};
action(watcher);
bool eventSignaled = resetEvent.Wait(TimeSpan.FromSeconds(5));
Assert.Equal(expectEvent, eventSignaled);
}
}
public async Task TriggerObject()
{
// Arrange
string itemId = "docid1";
Uri itemUri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, itemId);
string key = "[\"partkey1\"]";
var serviceMock = new Mock <ICosmosDBService>(MockBehavior.Strict);
serviceMock
.Setup(m => m.ReadDocumentAsync(itemUri, It.Is <RequestOptions>(r => r.PartitionKey.ToString() == key)))
.ReturnsAsync(new Document {
Id = itemId
});
var factoryMock = new Mock <ICosmosDBServiceFactory>(MockBehavior.Strict);
factoryMock
.Setup(f => f.CreateService(AttributeConnStr))
.Returns(serviceMock.Object);
var jobject = JObject.FromObject(new QueueData {
DocumentId = "docid1", PartitionKey = "partkey1"
});
var testTrace = new TestTraceWriter(TraceLevel.Warning);
// Act
await RunTestAsync(nameof(CosmosDBEndToEndFunctions.TriggerObject), factoryMock.Object, testTrace, jobject.ToString());
// Assert
factoryMock.Verify(f => f.CreateService(AttributeConnStr), Times.Once());
Assert.Single(testTrace.Events);
Assert.Equal("TriggerObject", testTrace.Events[0].Message);
}
public void WriteToStreamAsync_Traces()
{
// Arrange
Mock <TFormatter> mockFormatter = new Mock <TFormatter>()
{
CallBase = true
};
mockFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny <Type>(), It.IsAny <Object>(), It.IsAny <Stream>(), It.IsAny <HttpContent>(), It.IsAny <TransportContext>()))
.Returns(TaskHelpers.Completed());
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "WriteToStreamAsync"
},
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "WriteToStreamAsync"
}
};
// Act
Task task = tracer.WriteToStreamAsync(typeof(string), "sampleValue", new MemoryStream(), request.Content, transportContext: null);
task.Wait();
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void CreateFilterTracers_With_IOverrideFilter_Returns_Single_Wrapped_IOverrideFilter()
{
// Arrange
IOverrideFilter expectedInner = new Mock <IOverrideFilter>().Object;
FilterInfo inputFilterInfo = new FilterInfo(expectedInner, FilterScope.Action);
ITraceWriter expectedTraceWriter = new TestTraceWriter();
// Act
IEnumerable <FilterInfo> filters = FilterTracer.CreateFilterTracers(inputFilterInfo, expectedTraceWriter);
// Assert
Assert.NotNull(filters);
Assert.Equal(1, filters.Count());
FilterInfo filterInfo = filters.Single();
Assert.NotNull(filterInfo);
IFilter untypedFilter = filterInfo.Instance;
Assert.IsType <OverrideFilterTracer>(untypedFilter);
OverrideFilterTracer tracer = (OverrideFilterTracer)untypedFilter;
Assert.Same(expectedInner, tracer.InnerFilter);
Assert.Same(expectedTraceWriter, tracer.TraceWriter);
}
public void InvokeActionAsync_Traces_Faulted_Inner_Task()
{
// Arrange
Mock <ApiControllerActionInvoker> mockActionInvoker = new Mock <ApiControllerActionInvoker>()
{
CallBase = true
};
InvalidOperationException expectedException = new InvalidOperationException("test message");
TaskCompletionSource <HttpResponseMessage> tcs = new TaskCompletionSource <HttpResponseMessage>(null);
tcs.TrySetException(expectedException);
mockActionInvoker.Setup(
a => a.InvokeActionAsync(It.IsAny <HttpActionContext>(), It.IsAny <CancellationToken>())).Returns(tcs.Task);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(mockActionInvoker.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Error)
{
Kind = TraceKind.End
}
};
// Act
var response = ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None);
// Assert
Assert.Throws <InvalidOperationException>(() => response.Wait());
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Equal(expectedException, traceWriter.Traces[1].Exception);
}
public void GetControllerTypes_CallsMocks()
{
// Arrange
TestTraceWriter traceWriter = new TestTraceWriter();
DefaultHttpControllerTypeResolverTracer tracer =
new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);
// Act
tracer.GetControllerTypes(AssembliesResolver.Object);
// Assert (particularly important tracer delegates to original DefaultHttpControllerTypeResolver)
HttpControllerTypeResolver.Verify(
controller => controller.GetControllerTypes(AssembliesResolver.Object), Times.Once());
// Predicate is not called on null entries or internal types in the Type arrays (see TypeIsVisible)
HttpControllerTypeResolver.VerifyGet(controller => controller.IsControllerTypePredicate, Times.Exactly(7));
AssembliesResolver.Verify(resolver => resolver.GetAssemblies(), Times.Once());
foreach (Mock <MockableAssembly> mock in Assemblies)
{
mock.VerifyGet(assembly => assembly.IsDynamic, Times.Once());
mock.Verify(assembly => assembly.GetTypes(), mock.Object.IsDynamic ? Times.Never() : Times.Once());
}
}
public async Task ExecuteAsync_Traces()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <IDictionary <string, object> >(), CancellationToken.None))
.Returns(Task.FromResult <object>(null));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
IDictionary <string, object> arguments = new Dictionary <string, object>();
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "ExecuteAsync"
},
new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.End
}
};
// Act
await tracer.ExecuteAsync(controllerContext, arguments, CancellationToken.None);
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public async Task ReadFromStreamAsync_Traces()
{
// Arrange
Mock <TFormatter> mockFormatter = new Mock <TFormatter>()
{
CallBase = true
};
mockFormatter.Setup(f => f.ReadFromStreamAsync(It.IsAny <Type>(), It.IsAny <Stream>(), It.IsAny <HttpContent>(), It.IsAny <IFormatterLogger>()))
.Returns(Task.FromResult <object>("sampleValue"));
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync"
},
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "ReadFromStreamAsync"
}
};
// Act
Task <object> task = tracer.ReadFromStreamAsync(typeof(string), new MemoryStream(), request.Content, null);
string result = (await task)as string;
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Equal("sampleValue", result);
}
public async Task BindAsync_ReturnsExpectedTriggerData()
{
ParameterInfo parameter = GetType().GetMethod("TestTimerJob").GetParameters()[0];
MethodInfo methodInfo = (MethodInfo)parameter.Member;
string timerName = string.Format("{0}.{1}", methodInfo.DeclaringType.FullName, methodInfo.Name);
Mock <ScheduleMonitor> mockScheduleMonitor = new Mock <ScheduleMonitor>(MockBehavior.Strict);
ScheduleStatus status = new ScheduleStatus();
mockScheduleMonitor.Setup(p => p.GetStatusAsync(timerName)).ReturnsAsync(status);
TimerTriggerAttribute attribute = parameter.GetCustomAttribute <TimerTriggerAttribute>();
INameResolver nameResolver = new TestNameResolver();
TimerSchedule schedule = TimerSchedule.Create(attribute, nameResolver);
TimersConfiguration config = new TimersConfiguration();
config.ScheduleMonitor = mockScheduleMonitor.Object;
TestTraceWriter trace = new TestTraceWriter();
TimerTriggerBinding binding = new TimerTriggerBinding(parameter, attribute, schedule, config, trace);
// when we bind to a non-TimerInfo (e.g. in a Dashboard invocation) a new
// TimerInfo is created, with the ScheduleStatus populated
FunctionBindingContext functionContext = new FunctionBindingContext(Guid.NewGuid(), CancellationToken.None, trace);
ValueBindingContext context = new ValueBindingContext(functionContext, CancellationToken.None);
TriggerData triggerData = (TriggerData)(await binding.BindAsync(string.Empty, context));
TimerInfo timerInfo = (TimerInfo)(await triggerData.ValueProvider.GetValueAsync());
Assert.Same(status, timerInfo.ScheduleStatus);
// when we pass in a TimerInfo that is used
TimerInfo expected = new TimerInfo(schedule, status);
triggerData = (TriggerData)(await binding.BindAsync(expected, context));
timerInfo = (TimerInfo)(await triggerData.ValueProvider.GetValueAsync());
Assert.Same(expected, timerInfo);
}
private void SetupAndVerifyOutputBindings(string test, int invokeSendNotificationTimes)
{
var serviceMock = new Mock <INotificationHubClientService>(MockBehavior.Strict);
serviceMock
.Setup(x => x.SendNotificationAsync(It.IsAny <Notification>(), It.IsAny <string>()))
.Returns(Task.FromResult(new NotificationOutcome()));
var factoryMock = new Mock <INotificationHubClientServiceFactory>(MockBehavior.Strict);
factoryMock
.Setup(f => f.CreateService(ConfigConnStr, ConfigHubName.ToLowerInvariant(), It.IsAny <bool>()))
.Returns(serviceMock.Object);
var testTrace = new TestTraceWriter(TraceLevel.Warning);
//Act
RunTest(test, factoryMock.Object, testTrace);
// Assert
factoryMock.Verify(f => f.CreateService(ConfigConnStr, ConfigHubName.ToLowerInvariant(), false), Times.Once());
serviceMock.Verify(m => m.SendNotificationAsync(It.IsAny <Notification>(), It.IsAny <string>()), Times.Exactly(invokeSendNotificationTimes));
Assert.Equal(test, testTrace.Events.Single().Message);
}
public void InvokeActionAsync_Traces_Exception_Thrown_From_Inner()
{
// Arrange
InvalidOperationException expectedException = new InvalidOperationException("test message");
Mock <ApiControllerActionInvoker> mockActionInvoker = new Mock <ApiControllerActionInvoker>()
{
CallBase = true
};
mockActionInvoker.Setup(
a => a.InvokeActionAsync(It.IsAny <HttpActionContext>(), It.IsAny <CancellationToken>())).Throws(expectedException);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(mockActionInvoker.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Error)
{
Kind = TraceKind.End
}
};
// Act & Assert
Assert.Throws <InvalidOperationException>(
() => ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None)
);
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Equal(expectedException, traceWriter.Traces[1].Exception);
}
public void TriggerObject()
{
// Arrange
string itemId = "docid1";
Uri itemUri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, itemId);
string key = "[\"partkey1\"]";
var serviceMock = new Mock <IDocumentDBService>(MockBehavior.Strict);
serviceMock
.Setup(m => m.ReadDocumentAsync <dynamic>(itemUri, It.Is <RequestOptions>(r => r.PartitionKey.ToString() == key)))
.ReturnsAsync(new Document {
Id = itemId
});
var factoryMock = new Mock <IDocumentDBServiceFactory>(MockBehavior.Strict);
factoryMock
.Setup(f => f.CreateService(It.IsAny <string>()))
.Returns(serviceMock.Object);
var jobject = JObject.FromObject(new QueueData {
DocumentId = "docid1", PartitionKey = "partkey1"
});
var testTrace = new TestTraceWriter(TraceLevel.Warning);
// Act
RunTest("TriggerObject", factoryMock.Object, testTrace, jobject.ToString());
// Assert
factoryMock.Verify(f => f.CreateService(It.IsAny <string>()), Times.Once());
Assert.Equal(1, testTrace.Events.Count);
Assert.Equal("TriggerObject", testTrace.Events[0].Message);
}
private void CreateTestListener(string expression, bool useMonitor = true, Action functionAction = null)
{
_attribute = new TimerTriggerAttribute(expression);
_schedule = TimerSchedule.Create(_attribute, new TestNameResolver());
_attribute.UseMonitor = useMonitor;
_config = new TimersConfiguration();
_mockScheduleMonitor = new Mock <ScheduleMonitor>(MockBehavior.Strict);
_config.ScheduleMonitor = _mockScheduleMonitor.Object;
_mockTriggerExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
FunctionResult result = new FunctionResult(true);
_mockTriggerExecutor.Setup(p => p.TryExecuteAsync(It.IsAny <TriggeredFunctionData>(), It.IsAny <CancellationToken>()))
.Callback <TriggeredFunctionData, CancellationToken>((mockFunctionData, mockToken) =>
{
_triggeredFunctionData = mockFunctionData;
functionAction?.Invoke();
})
.Returns(Task.FromResult(result));
JobHostConfiguration hostConfig = new JobHostConfiguration();
hostConfig.HostId = "testhostid";
_traceWriter = new TestTraceWriter();
_listener = new TimerListener(_attribute, _schedule, _testTimerName, _config, _mockTriggerExecutor.Object, _traceWriter);
}
public void ExecuteExceptionFilterAsync_Traces()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock <IExceptionFilter> mockFilter = new Mock <IExceptionFilter>()
{
CallBase = true
};
mockFilter.Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny <HttpActionExecutedContext>(), It.IsAny <CancellationToken>()))
.Returns(TaskHelpers.Completed());
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterTracer tracer = new ExceptionFilterTracer(mockFilter.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "ExecuteExceptionFilterAsync"
},
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "ExecuteExceptionFilterAsync"
},
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public async Task ExecuteAsync_IsCancelled_And_Traces_When_Inner_IsCancelled()
{
// Arrange
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController
.Setup(
b =>
b.ExecuteAsync(
It.IsAny <HttpControllerContext>(),
It.IsAny <CancellationToken>()
)
)
.Returns(TaskHelpers.Canceled <HttpResponseMessage>());
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(
request: request
);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(
controllerContext,
actionDescriptor: _mockActionDescriptor.Object
);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(
request,
mockController.Object,
traceWriter
);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(
actionContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info
)
{
Kind = TraceKind.Begin
},
new TraceRecord(
actionContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Warn
)
{
Kind = TraceKind.End
}
};
// Act
Task task = ((IHttpController)tracer).ExecuteAsync(
controllerContext,
CancellationToken.None
);
Exception thrown = await Assert.ThrowsAsync <TaskCanceledException>(() => task);
// Assert
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
}
private static IServiceProvider CreateServiceProvider <TResult>(IStorageAccount storageAccount, Type programType,
IExtensionTypeLocator extensionTypeLocator, IJobActivator activator,
TaskCompletionSource <TResult> taskSource, IFunctionInstanceLogger functionInstanceLogger, IExtensionRegistry extensions = null)
{
IStorageAccountProvider storageAccountProvider = new FakeStorageAccountProvider
{
StorageAccount = storageAccount
};
IHostIdProvider hostIdProvider = new FakeHostIdProvider();
INameResolver nameResolver = null;
IQueueConfiguration queueConfiguration = new FakeQueueConfiguration(storageAccountProvider);
IWebJobsExceptionHandler exceptionHandler =
new TaskBackgroundExceptionHandler <TResult>(taskSource);
ContextAccessor <IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor =
new ContextAccessor <IMessageEnqueuedWatcher>();
ContextAccessor <IBlobWrittenWatcher> blobWrittenWatcherAccessor =
new ContextAccessor <IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
SingletonConfiguration singletonConfig = new SingletonConfiguration();
TestTraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
SingletonManager singletonManager = new SingletonManager(storageAccountProvider, exceptionHandler, singletonConfig, trace, hostIdProvider);
if (extensions == null)
{
extensions = new DefaultExtensionRegistry();
}
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider,
queueConfiguration, exceptionHandler, messageEnqueuedWatcherAccessor,
blobWrittenWatcherAccessor, sharedContextProvider, extensions, singletonManager, new TestTraceWriter(TraceLevel.Verbose));
IBindingProvider bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider,
extensionTypeLocator, messageEnqueuedWatcherAccessor,
blobWrittenWatcherAccessor, extensions);
IFunctionInstanceLoggerProvider functionInstanceLoggerProvider = new NullFunctionInstanceLoggerProvider();
IFunctionOutputLoggerProvider functionOutputLoggerProvider = new NullFunctionOutputLoggerProvider();
IFunctionOutputLogger functionOutputLogger = functionOutputLoggerProvider.GetAsync(CancellationToken.None).Result;
FunctionExecutor executor = new FunctionExecutor(functionInstanceLogger, functionOutputLogger, exceptionHandler, new TestTraceWriter(TraceLevel.Verbose));
ITypeLocator typeLocator = new FakeTypeLocator(programType);
FunctionIndexProvider functionIndexProvider = new FunctionIndexProvider(
typeLocator, triggerBindingProvider, bindingProvider,
activator, executor, extensions, singletonManager, trace);
IJobHostContextFactory contextFactory = new FakeJobHostContextFactory
{
TypeLocator = typeLocator,
FunctionIndexProvider = functionIndexProvider,
StorageAccountProvider = storageAccountProvider,
BackgroundExceptionDispatcher = exceptionHandler,
BindingProvider = bindingProvider,
ConsoleProvider = new NullConsoleProvider(),
HostInstanceLoggerProvider = new NullHostInstanceLoggerProvider(),
FunctionExecutor = executor,
FunctionInstanceLoggerProvider = functionInstanceLoggerProvider,
FunctionOutputLoggerProvider = functionOutputLoggerProvider,
HostIdProvider = hostIdProvider,
QueueConfiguration = queueConfiguration
};
return(new FakeServiceProvider
{
ContextFactory = contextFactory
});
}
public async Task InputBindings()
{
// Arrange
string item1Id = "docid1";
string item2Id = "docid2";
string item3Id = "docid3";
string item4Id = "docid4";
Uri item1Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item1Id);
Uri item2Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item2Id);
Uri item3Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item3Id);
Uri item4Uri = UriFactory.CreateDocumentUri("ResolvedDatabase", "ResolvedCollection", item4Id);
string options2 = string.Format("[\"{0}\"]", item1Id); // this comes from the trigger
string options3 = "[\"partkey3\"]";
var serviceMock = new Mock <IDocumentDBService>(MockBehavior.Strict);
serviceMock
.Setup(m => m.ReadDocumentAsync <object>(item1Uri, null))
.ReturnsAsync(new Document {
Id = item1Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync <dynamic>(item2Uri, It.Is <RequestOptions>(r => r.PartitionKey.ToString() == options2)))
.ReturnsAsync(new Document {
Id = item2Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync <dynamic>(item3Uri, It.Is <RequestOptions>(r => r.PartitionKey.ToString() == options3)))
.ReturnsAsync(new Document {
Id = item3Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync <dynamic>(item4Uri, null))
.ReturnsAsync(new Document {
Id = item4Id
});
// We only expect item2 to be updated
serviceMock
.Setup(m => m.ReplaceDocumentAsync(item2Uri, It.Is <object>(d => ((Document)d).Id == item2Id)))
.ReturnsAsync(new Document());
var factoryMock = new Mock <IDocumentDBServiceFactory>(MockBehavior.Strict);
factoryMock
.Setup(f => f.CreateService(It.IsAny <string>()))
.Returns(serviceMock.Object);
var testTrace = new TestTraceWriter(TraceLevel.Warning);
// Act
await RunTestAsync("Inputs", factoryMock.Object, testTrace, item1Id);
// Assert
factoryMock.Verify(f => f.CreateService(It.IsAny <string>()), Times.Once());
Assert.Equal(1, testTrace.Events.Count);
Assert.Equal("Inputs", testTrace.Events[0].Message);
}
public async Task InputBindings()
{
// Arrange
string item1Id = "docid1";
string item2Id = "docid2";
string item3Id = "docid3";
string item4Id = "docid4";
string item5Id = "docid5";
Uri item1Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item1Id);
Uri item2Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item2Id);
Uri item3Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item3Id);
Uri item4Uri = UriFactory.CreateDocumentUri("ResolvedDatabase", "ResolvedCollection", item4Id);
Uri item5Uri = UriFactory.CreateDocumentUri(DatabaseName, CollectionName, item5Id);
Uri collectionUri = UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName);
string options2 = string.Format("[\"{0}\"]", item1Id); // this comes from the trigger
string options3 = "[\"partkey3\"]";
var serviceMock = new Mock <IDocumentDBService>(MockBehavior.Strict);
serviceMock
.Setup(m => m.ReadDocumentAsync(item1Uri, null))
.ReturnsAsync(new Document {
Id = item1Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync(item2Uri, It.Is <RequestOptions>(r => r.PartitionKey.ToString() == options2)))
.ReturnsAsync(new Document {
Id = item2Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync(item3Uri, It.Is <RequestOptions>(r => r.PartitionKey.ToString() == options3)))
.ReturnsAsync(new Document {
Id = item3Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync(item4Uri, null))
.ReturnsAsync(new Document {
Id = item4Id
});
serviceMock
.Setup(m => m.ReadDocumentAsync(item5Uri, null))
.ReturnsAsync(new Document {
Id = item5Id
});
serviceMock
.Setup(m => m.ExecuteNextAsync <JObject>(
collectionUri,
It.Is <SqlQuerySpec>((s) =>
s.QueryText == "some query" &&
s.Parameters.Count() == 0),
null))
.ReturnsAsync(new DocumentQueryResponse <JObject>());
serviceMock
.Setup(m => m.ExecuteNextAsync <JObject>(
collectionUri,
It.Is <SqlQuerySpec>((s) =>
s.QueryText == "some ResolvedQuery with '@QueueTrigger' replacements" &&
s.Parameters.Count() == 1 &&
s.Parameters[0].Name == "@QueueTrigger" &&
s.Parameters[0].Value.ToString() == "docid1"),
null))
.ReturnsAsync(new DocumentQueryResponse <JObject>());
serviceMock
.Setup(m => m.ExecuteNextAsync <JObject>(
collectionUri,
It.Is <SqlQuerySpec>((s) =>
s.QueryText == null &&
s.Parameters.Count() == 0),
null))
.ReturnsAsync(new DocumentQueryResponse <JObject>());
// We only expect item2 to be updated
serviceMock
.Setup(m => m.ReplaceDocumentAsync(item2Uri, It.Is <object>(d => ((Document)d).Id == item2Id)))
.ReturnsAsync(new Document());
var factoryMock = new Mock <IDocumentDBServiceFactory>(MockBehavior.Strict);
factoryMock
.Setup(f => f.CreateService(It.IsAny <string>()))
.Returns(serviceMock.Object);
var testTrace = new TestTraceWriter(TraceLevel.Warning);
// Act
await RunTestAsync(nameof(DocumentDBEndToEndFunctions.Inputs), factoryMock.Object, testTrace, item1Id);
// Assert
factoryMock.Verify(f => f.CreateService(It.IsAny <string>()), Times.Once());
Assert.Equal(1, testTrace.Events.Count);
Assert.Equal("Inputs", testTrace.Events[0].Message);
serviceMock.VerifyAll();
}
public TraceWriterFunctionInstanceLoggerTests()
{
_traceWriter = new TestTraceWriter(TraceLevel.Verbose);
_logger = new TraceWriterFunctionInstanceLogger(_traceWriter);
}
public async Task ExecuteAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException();
TaskCompletionSource <HttpResponseMessage> tcs =
new TaskCompletionSource <HttpResponseMessage>();
tcs.TrySetException(exception);
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController
.Setup(
b =>
b.ExecuteAsync(
It.IsAny <HttpControllerContext>(),
It.IsAny <CancellationToken>()
)
)
.Returns(tcs.Task);
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(
request: request
);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(
controllerContext,
actionDescriptor: _mockActionDescriptor.Object
);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(
request,
mockController.Object,
traceWriter
);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(
actionContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info
)
{
Kind = TraceKind.Begin
},
new TraceRecord(
actionContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Error
)
{
Kind = TraceKind.End
}
};
// Act
Exception thrown = await Assert.ThrowsAsync <InvalidOperationException>(
() =>
((IHttpController)tracer).ExecuteAsync(
controllerContext,
CancellationToken.None
)
);
// Assert
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public HttpRequestManagerTests()
{
_traceWriter = new TestTraceWriter(TraceLevel.Verbose);
}
public async Task ExecuteExceptionFilterAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock <IExceptionFilter> mockFilter = new Mock <IExceptionFilter>()
{
CallBase = true
};
InvalidOperationException exception = new InvalidOperationException("test");
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(null);
tcs.TrySetException(exception);
mockFilter
.Setup(
a =>
a.ExecuteExceptionFilterAsync(
It.IsAny <HttpActionExecutedContext>(),
It.IsAny <CancellationToken>()
)
)
.Returns(tcs.Task);
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(
request,
response
);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterTracer tracer = new ExceptionFilterTracer(
mockFilter.Object,
traceWriter
);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin,
Operation = "ExecuteExceptionFilterAsync"
},
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Error)
{
Kind = TraceKind.End,
Operation = "ExecuteExceptionFilterAsync"
}
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(
actionExecutedContext,
CancellationToken.None
);
// Assert
Exception thrown = await Assert.ThrowsAsync <InvalidOperationException>(() => task);
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
}
public async Task ExecuteBindingAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException();
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
tcs.TrySetException(exception);
Mock <HttpActionBinding> mockBinder = new Mock <HttpActionBinding>()
{
CallBase = true
};
mockBinder
.Setup(
b =>
b.ExecuteBindingAsync(
It.IsAny <HttpActionContext>(),
It.IsAny <CancellationToken>()
)
)
.Returns(tcs.Task);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionBindingTracer tracer = new HttpActionBindingTracer(
mockBinder.Object,
traceWriter
);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(
_actionContext.Request,
TraceCategories.ModelBindingCategory,
TraceLevel.Info
)
{
Kind = TraceKind.Begin
},
new TraceRecord(
_actionContext.Request,
TraceCategories.ModelBindingCategory,
TraceLevel.Error
)
{
Kind = TraceKind.End
}
};
// Act
Task task = tracer.ExecuteBindingAsync(_actionContext, CancellationToken.None);
// Assert
Exception thrown = await Assert.ThrowsAsync <InvalidOperationException>(() => task);
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ReadFromStreamAsync_Traces_And_Throws_When_Inner_Throws()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("test");
Mock <TFormatter> mockFormatter = new Mock <TFormatter>()
{
CallBase = true
};
mockFormatter
.Setup(
f =>
f.ReadFromStreamAsync(
It.IsAny <Type>(),
It.IsAny <Stream>(),
It.IsAny <HttpContent>(),
It.IsAny <IFormatterLogger>()
)
)
.Throws(exception);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin,
Operation = "ReadFromStreamAsync"
},
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
{
Kind = TraceKind.End,
Operation = "ReadFromStreamAsync"
}
};
// Act
Exception thrown = Assert.Throws <InvalidOperationException>(
() =>
tracer.ReadFromStreamAsync(
typeof(string),
new MemoryStream(),
request.Content,
null
)
);
// Assert
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void CreateQueueProcessor_CreatesProcessorCorrectly()
{
CloudQueue poisonQueue = null;
TestTraceWriter log = new TestTraceWriter(TraceLevel.Verbose);
bool poisonMessageHandlerInvoked = false;
EventHandler poisonMessageEventHandler = (sender, e) => { poisonMessageHandlerInvoked = true; };
Mock <IQueueProcessorFactory> mockQueueProcessorFactory = new Mock <IQueueProcessorFactory>(MockBehavior.Strict);
JobHostQueuesConfiguration queueConfig = new JobHostQueuesConfiguration
{
MaxDequeueCount = 7,
QueueProcessorFactory = mockQueueProcessorFactory.Object
};
QueueProcessor expectedQueueProcessor = null;
bool processorFactoryInvoked = false;
// create for a host queue - don't expect custom factory to be invoked
CloudQueue queue = new CloudQueue(new Uri(string.Format("https://test.queue.core.windows.net/{0}", HostQueueNames.GetHostQueueName("12345"))));
QueueProcessor queueProcessor = QueueListener.CreateQueueProcessor(queue, poisonQueue, log, queueConfig, poisonMessageEventHandler);
Assert.False(processorFactoryInvoked);
Assert.NotSame(expectedQueueProcessor, queueProcessor);
queueProcessor.OnMessageAddedToPoisonQueue(new EventArgs());
Assert.True(poisonMessageHandlerInvoked);
QueueProcessorFactoryContext processorFactoryContext = null;
mockQueueProcessorFactory.Setup(p => p.Create(It.IsAny <QueueProcessorFactoryContext>()))
.Callback <QueueProcessorFactoryContext>((mockProcessorContext) =>
{
processorFactoryInvoked = true;
Assert.Same(queue, mockProcessorContext.Queue);
Assert.Same(poisonQueue, mockProcessorContext.PoisonQueue);
Assert.Equal(queueConfig.MaxDequeueCount, mockProcessorContext.MaxDequeueCount);
Assert.Same(log, mockProcessorContext.Trace);
processorFactoryContext = mockProcessorContext;
})
.Returns(() =>
{
expectedQueueProcessor = new QueueProcessor(processorFactoryContext);
return(expectedQueueProcessor);
});
// when storage host is "localhost" we invoke the processor factory even for
// host queues (this enables local test mocking)
processorFactoryInvoked = false;
queue = new CloudQueue(new Uri(string.Format("https://localhost/{0}", HostQueueNames.GetHostQueueName("12345"))));
queueProcessor = QueueListener.CreateQueueProcessor(queue, poisonQueue, log, queueConfig, poisonMessageEventHandler);
Assert.True(processorFactoryInvoked);
Assert.Same(expectedQueueProcessor, queueProcessor);
// create for application queue - expect processor factory to be invoked
poisonMessageHandlerInvoked = false;
processorFactoryInvoked = false;
queue = new CloudQueue(new Uri("https://test.queue.core.windows.net/testqueue"));
queueProcessor = QueueListener.CreateQueueProcessor(queue, poisonQueue, log, queueConfig, poisonMessageEventHandler);
Assert.True(processorFactoryInvoked);
Assert.Same(expectedQueueProcessor, queueProcessor);
queueProcessor.OnMessageAddedToPoisonQueue(new EventArgs());
Assert.True(poisonMessageHandlerInvoked);
// if poison message watcher not specified, event not subscribed to
poisonMessageHandlerInvoked = false;
processorFactoryInvoked = false;
queueProcessor = QueueListener.CreateQueueProcessor(queue, poisonQueue, log, queueConfig, null);
Assert.True(processorFactoryInvoked);
Assert.Same(expectedQueueProcessor, queueProcessor);
queueProcessor.OnMessageAddedToPoisonQueue(new EventArgs());
Assert.False(poisonMessageHandlerInvoked);
}
public async Task WriteToStreamAsync_Traces_And_Faults_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("test");
Mock <TFormatter> mockFormatter = new Mock <TFormatter>()
{
CallBase = true
};
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
tcs.TrySetException(exception);
mockFormatter
.Setup(
f =>
f.WriteToStreamAsync(
It.IsAny <Type>(),
It.IsAny <Object>(),
It.IsAny <Stream>(),
It.IsAny <HttpContent>(),
It.IsAny <TransportContext>()
)
)
.Returns(tcs.Task);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent("");
MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin,
Operation = "WriteToStreamAsync"
},
new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
{
Kind = TraceKind.End,
Operation = "WriteToStreamAsync"
}
};
// Act
Task task = tracer.WriteToStreamAsync(
typeof(string),
"sampleValue",
new MemoryStream(),
request.Content,
transportContext: null
);
// Assert
Exception thrown = await Assert.ThrowsAsync <InvalidOperationException>(() => task);
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public async Task RecoveryTest(int expectedNumberOfAttempts, bool isFailureScenario)
{
var traceWriter = new TestTraceWriter(TraceLevel.Verbose);
using (var directory = new TempDirectory())
using (var watcher = new AutoRecoveringFileSystemWatcher(directory.Path, traceWriter: traceWriter))
{
Directory.Delete(directory.Path, true);
string fileWatcherLogSuffix = $"(path: '{directory.Path}')";
// 1 trace per attempt + 1 trace per failed attempt
int expectedTracesBeforeRecovery = (expectedNumberOfAttempts * 2) - 1;
// Before + recovery trace
int expectedTracesAfterRecovery = expectedTracesBeforeRecovery + 1;
if (!isFailureScenario)
{
expectedTracesAfterRecovery++;
}
await TestHelpers.Await(() =>
{
return(traceWriter.Traces.Count == expectedTracesBeforeRecovery);
}, pollingInterval : 500);
if (isFailureScenario)
{
watcher.Dispose();
}
else
{
Directory.CreateDirectory(directory.Path);
}
await TestHelpers.Await(() =>
{
return(traceWriter.Traces.Count == expectedTracesAfterRecovery);
}, pollingInterval : 500);
TraceEvent failureEvent = traceWriter.Traces.First();
var retryEvents = traceWriter.Traces.Where(t => t.Level == TraceLevel.Warning).Skip(1).ToList();
Assert.Equal(TraceLevel.Warning, failureEvent.Level);
Assert.Contains("Failure detected", failureEvent.Message);
int expectedRetryEvents = expectedNumberOfAttempts;
if (isFailureScenario)
{
expectedRetryEvents--;
}
Assert.Equal(expectedRetryEvents, retryEvents.Count);
// Validate that our the events happened with the expected intervals
DateTime previoustTimeStamp = failureEvent.Timestamp;
for (int i = 0; i < retryEvents.Count; i++)
{
long expectedInterval = Convert.ToInt64((Math.Pow(2, i + 1) - 1) / 2);
TraceEvent currentEvent = retryEvents[i];
var actualInterval = currentEvent.Timestamp - previoustTimeStamp;
previoustTimeStamp = currentEvent.Timestamp;
Assert.Equal(expectedInterval, (int)actualInterval.TotalSeconds);
}
Assert.True(traceWriter.Traces.All(t => t.Message.EndsWith(fileWatcherLogSuffix)));
if (isFailureScenario)
{
Assert.Contains("Recovery process aborted.", traceWriter.Traces.Last().Message);
}
else
{
Assert.Contains("File watcher recovered.", traceWriter.Traces.Last().Message);
}
Assert.Equal(ScriptConstants.TraceSourceFileWatcher, traceWriter.Traces.Last().Source);
}
}
public async Task GetHostSecrets_UpdatesStaleSecrets()
{
using (var directory = new TempDirectory())
{
string expectedTraceMessage = Resources.TraceStaleHostSecretRefresh;
string hostSecretsJson =
@"{
'masterKey': {
'name': 'master',
'value': '1234',
'encrypted': false
},
'functionKeys': [
{
'name': 'Key1',
'value': 'HostValue1',
'encrypted': false
},
{
'name': 'Key3',
'value': 'HostValue3',
'encrypted': false
}
],
'systemKeys': [
{
'name': 'SystemKey1',
'value': 'SystemHostValue1',
'encrypted': false
},
{
'name': 'SystemKey2',
'value': 'SystemHostValue2',
'encrypted': false
}
]
}";
File.WriteAllText(Path.Combine(directory.Path, ScriptConstants.HostMetadataFileName), hostSecretsJson);
Mock <IKeyValueConverterFactory> mockValueConverterFactory = GetConverterFactoryMock();
HostSecretsInfo hostSecrets;
var traceWriter = new TestTraceWriter(System.Diagnostics.TraceLevel.Verbose);
ISecretsRepository repository = new FileSystemSecretsRepository(directory.Path);
using (var secretManager = new SecretManager(repository, mockValueConverterFactory.Object, null))
{
hostSecrets = await secretManager.GetHostSecretsAsync();
}
// Read the persisted content
var result = JsonConvert.DeserializeObject <HostSecrets>(File.ReadAllText(Path.Combine(directory.Path, ScriptConstants.HostMetadataFileName)));
bool functionSecretsConverted = hostSecrets.FunctionKeys.Values.Zip(result.FunctionKeys, (r1, r2) => string.Equals("!" + r1, r2.Value)).All(r => r);
bool systemSecretsConverted = hostSecrets.SystemKeys.Values.Zip(result.SystemKeys, (r1, r2) => string.Equals("!" + r1, r2.Value)).All(r => r);
Assert.Equal(2, result.FunctionKeys.Count);
Assert.Equal(2, result.SystemKeys.Count);
Assert.Equal("!" + hostSecrets.MasterKey, result.MasterKey.Value);
Assert.True(functionSecretsConverted, "Function secrets were not persisted");
Assert.True(systemSecretsConverted, "System secrets were not persisted");
}
}
public async Task ExecuteAsync_Invokes_Inner_And_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController
.Setup(
b =>
b.ExecuteAsync(
It.IsAny <HttpControllerContext>(),
It.IsAny <CancellationToken>()
)
)
.Returns(Task.FromResult <HttpResponseMessage>(response));
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(
request: request
);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(
controllerContext,
actionDescriptor: _mockActionDescriptor.Object
);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(
request,
mockController.Object,
traceWriter
);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(
actionContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info
)
{
Kind = TraceKind.Begin
},
new TraceRecord(
actionContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info
)
{
Kind = TraceKind.End
}
};
// Act
var task = ((IHttpController)tracer).ExecuteAsync(
controllerContext,
CancellationToken.None
);
HttpResponseMessage actualResponse = await task;
// Assert
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
Assert.Same(response, actualResponse);
}
public void ExecuteAsync_Throws_What_Inner_Throws_And_Traces()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
InvalidOperationException exception = new InvalidOperationException("test");
mockActionDescriptor
.Setup(
a =>
a.ExecuteAsync(
It.IsAny <HttpControllerContext>(),
It.IsAny <IDictionary <string, object> >(),
CancellationToken.None
)
)
.Throws(exception);
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(
controllerContext.Configuration,
"test",
typeof(ApiController)
);
IDictionary <string, object> arguments = new Dictionary <string, object>();
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(
controllerContext,
mockActionDescriptor.Object,
traceWriter
);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(
controllerContext.Request,
TraceCategories.ActionCategory,
TraceLevel.Info
)
{
Kind = TraceKind.Begin
},
new TraceRecord(
controllerContext.Request,
TraceCategories.ActionCategory,
TraceLevel.Error
)
{
Kind = TraceKind.End
}
};
// Act & Assert
Assert.Throws <InvalidOperationException>(
() => tracer.ExecuteAsync(controllerContext, arguments, CancellationToken.None)
);
// Assert
Assert.Equal <TraceRecord>(
expectedTraces,
traceWriter.Traces,
new TraceRecordComparer()
);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
