public void MethodShouldTimeout_WhenTimeoutsAreNotIgnored() { var classToProxy = new CancellableWithOverrunnningMethod(); var proxy = CommandInterceptor.CreateProxy <ICancellableTimeoutPreserved>(classToProxy); Assert.Throws <CommandTimeoutException>(() => proxy.CancellableMethod(CancellationToken.None)); }
public void CreateProxy_NonInterface_ThrowsInvalidOperationException() { var ex = Assert.Throws <InvalidOperationException>(() => { CommandInterceptor.CreateProxy(typeof(TestImplementation)); }); Assert.Equal("Proxies may only be created for interfaces", ex.Message); }
public void MethodShouldNotTimeout_WhenTimeoutsAreIgnored() { ConfigProvider.Instance.Set(IgnoreTimeoutsKey, true); var classToProxy = new CancellableWithOverrunnningMethodTimeoutsIgnored(); var proxy = CommandInterceptor.CreateProxy <ICancellableIgnoredTimeout>(classToProxy); Assert.DoesNotThrow(() => proxy.CancellableMethod(CancellationToken.None)); ConfigProvider.Instance.Set(IgnoreTimeoutsKey, false); }
public void InterceptorCreateCommand_CommandName_IsInterfaceNameAndMethodName() { var method = typeof(ITestInterfaceWithImplementation).GetMethod("InvokeString"); var mockInvocation = new Mock <IInvocation>(); mockInvocation.SetupGet(m => m.Method).Returns(method); var command = new CommandInterceptor().CreateCommand <string>(mockInvocation.Object); Assert.Equal("foo.ITestInterfaceWithImplementation-InvokeString", command.Name); }
public void WithNonNullableCancellationTokenParameter_CancellationTokenIsEmpty_UsesTokenFromExecuteAsync() { const string expected = "quux"; var instance = new Cancellable(expected); var proxy = CommandInterceptor.CreateProxy <ICancellable>(instance); proxy.CancellationTokenOnly(CancellationToken.None); Assert.NotNull(instance.ReceivedToken); Assert.False(instance.ReceivedToken.Value.IsCancellationRequested); Thread.Sleep(Cancellable.CancellationTestTimeoutMillis + 50); Assert.True(instance.ReceivedToken.Value.IsCancellationRequested); }
public void ProxyPassesOnTokenToMethod_WhenTimeoutsNotIgnored() { var expectedResult = "test"; var classToProxy = new CancellableWithTimeoutPreserved(expectedResult); var proxy = CommandInterceptor.CreateProxy <ICancellableTimeoutPreserved>(classToProxy); // If we pass a valid token to the proxy then it should pass the token to the method call. var token = new CancellationTokenSource(500).Token; var result = proxy.CancellableMethod(token); Assert.True(classToProxy.CallMade); Assert.Equal(classToProxy.TokenRecievedFromProxy, token); Assert.Equal(expectedResult, result); }
public void SlowSleepMethod_WithoutFireAndForget_BlocksUntilCompletion() { var instance = new Sleepy(); var proxy = CommandInterceptor.CreateProxy <ISleepy>(instance); var stopwatch = Stopwatch.StartNew(); proxy.SleepWithoutFireAndForget(500); stopwatch.Stop(); Assert.True(stopwatch.Elapsed.TotalMilliseconds > 500); Assert.True(instance.IsCompleted); }
public void FireAndForget_WhenThrows_DoesntThrowExceptionToCaller() { // The default TaskScheduler doesn't guarantee execution on another thread, // so we might get the exception back here. We catch and log in the interceptor // to avoid that. var instance = new ThrowingFireAndForget(); var proxy = CommandInterceptor.CreateProxy <IThrowingFireAndForget>(instance); proxy.ImmediatelyThrowWithFireAndForget(); Assert.True(true); // Expecting no exception to be thrown. }
public void WithNonNullableCancellationTokenParameter_NonEmptyCancellationToken_DoesntReplace() { const string expected = "quux"; var instance = new Cancellable(expected); var proxy = CommandInterceptor.CreateProxy <ICancellable>(instance); var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(10000)); // Not 500, which is the value in the [Command] attribute. var token = source.Token; var result = proxy.CancellationTokenOnly(token); Assert.Equal(token, instance.ReceivedToken); Assert.Equal(expected, result); }
public void ProxyStillPassesOnTokenToMethod_WhenTimeoutsAreIgnored() { ConfigProvider.Instance.Set(IgnoreTimeoutsKey, true); var expectedResult = "test"; var classToProxy = new CancellableWithIgnoredTimeout(expectedResult); var proxy = CommandInterceptor.CreateProxy <ICancellableIgnoredTimeout>(classToProxy); // If we pass CancellationToken.None to the proxy then it should pass a timeout tokem to the method call. var token = new CancellationTokenSource(500).Token; var result = proxy.CancellableMethod(token); Assert.True(classToProxy.CallMade); Assert.Equal(classToProxy.TokenRecievedFromProxy, token); Assert.Equal(expectedResult, result); ConfigProvider.Instance.Set(IgnoreTimeoutsKey, false); }
public void ProxyPassesNoneToMethod_WhenTimeoutsIgnored() { ConfigProvider.Instance.Set(IgnoreTimeoutsKey, true); var expectedResult = "test"; var classToProxy = new CancellableWithIgnoredTimeout(expectedResult); var proxy = CommandInterceptor.CreateProxy <ICancellableIgnoredTimeout>(classToProxy); // If we pass CancellationToken.None to the proxy then it should pass this along to the method call, rather than a CancellationToken with a timeout. This should // be the case because we've set the Command to ignore timeouts var result = proxy.CancellableMethod(CancellationToken.None); Assert.True(classToProxy.CallMade); Assert.Equal(classToProxy.TokenRecievedFromProxy, CancellationToken.None); Assert.Equal(expectedResult, result); ConfigProvider.Instance.Set(IgnoreTimeoutsKey, false); }
public void ProxyPassesATimeoutTokenToMethod_WhenTimeoutsNotIgnored() { var expectedResult = "test"; var classToProxy = new CancellableWithTimeoutPreserved(expectedResult); var proxy = CommandInterceptor.CreateProxy <ICancellableTimeoutPreserved>(classToProxy); // If we pass CancellationToken.None to the proxy then it should pass a timeout tokem to the method call. var result = proxy.CancellableMethod(CancellationToken.None); Assert.True(classToProxy.CallMade && classToProxy.TokenRecievedFromProxy != CancellationToken.None); // This shouldn't be cancelled yet. Assert.False(classToProxy.TokenRecievedFromProxy.IsCancellationRequested); // Now sleep past the timeout. Thread.Sleep(CancellableWithTimeoutPreserved.Timeout + 50); Assert.True(classToProxy.TokenRecievedFromProxy.IsCancellationRequested); Assert.Equal(expectedResult, result); }
public void SlowSleepMethod_FireAndForget_ReturnsImmediatelyButStillCompletes() { var instance = new Sleepy(); var proxy = CommandInterceptor.CreateProxy <ISleepy>(instance); var stopwatch = Stopwatch.StartNew(); proxy.SleepWithFireAndForget(500); stopwatch.Stop(); // Should have returned immediately; for sure before the sleep time. Assert.True(stopwatch.Elapsed.TotalMilliseconds < 400); Assert.False(instance.IsCompleted); Thread.Sleep(510); Assert.True(instance.IsCompleted); }
private async Task <ChartSet> IdealCommandAttribute(string key) { _testConfigProvider.Set("mjolnir.breaker." + key + ".minimumOperations", 5); _testConfigProvider.Set("mjolnir.breaker." + key + ".thresholdPercentage", 50); _testConfigProvider.Set("mjolnir.breaker." + key + ".trippedDurationMillis", 5000); _testConfigProvider.Set("mjolnir.metrics." + key + ".windowMillis", 10000); // Command timeout is defined on the interface. var instance = new HttpClientService(); var proxy = CommandInterceptor.CreateProxy <IHttpClientService>(instance); using (var server = new HttpServer(1)) { var url = string.Format("http://*****:*****@"c:\hudl\logs\mjolnir-metrics-{0}-{1}.txt", key, DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")), _testStats.Metrics.Select(m => m.ToCsvLine())); return(new ChartSet { Name = "Ideal (Command Attribute)", Description = "30s @ 5/sec.<br/>Command: Inherited<br/>Timeout: 10000<br/>Server: Immediate 200<br/>Breaker: 50% / 10sec, min 5 ops, 5s tripped", Charts = GatherChartData(_testStats.Metrics, key, key + ".IHttpClientService-MakeRequest"), }); }
public void RaiseCanExecuteChangedShouldRaiseEvent() { // arrange var command = new Mock<INotifyCommandChanged>(); command.Setup( c => c.RaiseCanExecuteChanged() ); var interceptor = new CommandInterceptor<object>( DefaultAction.None, DefaultAction.None, command.Object ); // act interceptor.RaiseCanExecuteChanged(); // assert command.Verify( c => c.RaiseCanExecuteChanged(), Times.Once() ); }
public void InterceptorCreateCommand_CommandName_IsInterfaceNameAndMethodName() { var method = typeof (ITestInterfaceWithImplementation).GetMethod("InvokeString"); var mockInvocation = new Mock<IInvocation>(); mockInvocation.SetupGet(m => m.Method).Returns(method); var command = new CommandInterceptor().CreateCommand<string>(mockInvocation.Object); Assert.Equal("foo.ITestInterfaceWithImplementation-InvokeString", command.Name); }
public void CanExecuteShouldInvokeCommand() { // arrange var command = new Mock<ICommand>(); command.Setup( c => c.CanExecute( It.IsAny<object>() ) ).Returns( true ); var interceptor = new CommandInterceptor<object>( DefaultAction.None, DefaultAction.None, command.Object ); // act Assert.True( interceptor.CanExecute() ); // assert command.Verify( c => c.CanExecute( null ), Times.Once() ); }
// TODO How do we test for an unhandled exception thrown by a FireAndForget on a different thread? private ITestInterfaceWithImplementation CreateForImplementation(ITestInterfaceWithImplementation instance) { return(CommandInterceptor.CreateProxy(instance)); }
public void ExecuteShouldInvokeCommand() { // arrange var pre = new Mock<Action<object>>(); var post = new Mock<Action<object>>(); pre.Setup( f => f( It.IsAny<object>() ) ); post.Setup( f => f( It.IsAny<object>() ) ); var command = new Mock<INotifyCommandChanged>(); command.Setup( c => c.Execute( It.IsAny<object>() ) ).Raises( c => c.Executed += null, EventArgs.Empty ); var interceptor = new CommandInterceptor<object>( pre.Object, post.Object, command.Object ); var raised = false; interceptor.Executed += ( s, e ) => raised = true; // act interceptor.Execute(); // assert pre.Verify( f => f( null ), Times.Once() ); command.Verify( c => c.Execute( null ), Times.Once() ); post.Verify( f => f( null ), Times.Once() ); Assert.True( raised ); }