public void Get_UnderlyingGetResultThrowsException_RethrowsInnerException() { // To avoid leaking STP's WorkItemResultException out beyond our thread pooling layer, // our wrappers around STP should unwrap the exception thrown by the pool and just // rethrow its inner exception, which should be what got thrown from ExecuteAsync(). var inner = new ExpectedTestException("Root cause inner"); var cause = new ExpectedTestException("Test root cause", inner); var itemException = new WorkItemResultException("Work item result exception", cause); var timeout = TimeSpan.FromSeconds(1); var mockWorkItemResult = new Mock<IWorkItemResult<object>>(); mockWorkItemResult.Setup(m => m.GetResult(timeout, false)).Throws(itemException); var stpWorkItem = new StpWorkItem<object>(mockWorkItemResult.Object); try { stpWorkItem.Get(new CancellationToken(), timeout); } catch (ExpectedTestException e) { Assert.Equal(cause, e); Assert.Equal(inner, e.InnerException); return; // Expected. } AssertX.FailExpectedException(); }
public async Task InvokeAsync_TaskFaultsAndFallbackThrows_RethrowsFallbackException() { var expected = new ExpectedTestException("Expected rethrown exception"); var command = new FaultingTaskWithEchoThrowingFallbackCommand(expected); var e = await Assert.ThrowsAsync<ExpectedTestException>(() => command.InvokeAsync()); Assert.Equal(expected, e); }
public async Task GenericTask_WithThrowingImplementation_ThrowsCommandFailedExceptionOnAwait() { var exception = new ExpectedTestException("Expected"); var instance = new TestThrowingImplementation(exception); var proxy = CreateForImplementation(instance); var task = proxy.InvokeGenericTask(); var e = await Assert.ThrowsAsync<CommandFailedException>(() => task); Assert.Equal(exception, e.InnerException); }
public void String_WithThrowingImplementation_ThrowsCommandFailedException() { var exception = new ExpectedTestException("Expected"); var instance = new TestThrowingImplementation(exception); var proxy = CreateForImplementation(instance); var ex = Assert.Throws<CommandFailedException>(() => { proxy.InvokeString(); }); Assert.Equal(exception, ex.InnerException); }
public async Task InvokeAsync_WhenReturnedTaskThrowsException_RethrowsException() { var exception = new ExpectedTestException("Expected"); var mockBreaker = CreateMockBreaker(true); var command = new FaultingTaskEchoCommandWithoutFallback(exception) { CircuitBreaker = mockBreaker.Object, }; var e = await Assert.ThrowsAsync<CommandFailedException>(() => command.InvokeAsync()); Assert.True(e.InnerException == exception); }
public async Task InvokeAsync_TimesOutAndFallbackThrows_RethrowsFallbackException() { var expected = new ExpectedTestException("Expected rethrown exception"); var command = new TimingOutWithEchoThrowingFallbackCommand(expected); try { await command.InvokeAsync(); } catch (ExpectedTestException e) { Assert.Equal(expected, e); return; // Expected. } AssertX.FailExpectedException(); }
public async Task GenericTask_WithThrowingImplementation_ThrowsCommandFailedExceptionOnAwait() { var exception = new ExpectedTestException("Expected"); var instance = new TestThrowingImplementation(exception); var proxy = CreateForImplementation(instance); var task = proxy.InvokeGenericTask(); try { // Using Assert.Throws(async () => {}) doesn't work right here, // so falling back to the ol' try/catch. await task; } catch (CommandFailedException e) { Assert.Equal(exception, e.InnerException); return; } AssertX.FailExpectedException(); }
public async Task InvokeAsync_WhenExecuteThrowsException_RethrowsException() { var exception = new ExpectedTestException("Expected"); var mockBreaker = CreateMockBreaker(true); var command = new FaultingExecuteEchoCommandWithoutFallback(exception) { CircuitBreaker = mockBreaker.Object, }; try { await command.InvokeAsync(); } catch (CommandFailedException e) { Assert.True(e.InnerException == exception); return; // Expected. } AssertX.FailExpectedException(); }
public async Task InvokeAsync_TaskFaultsAndFallbackNotImplemented() { var exception = new ExpectedTestException("foo"); var mockStats = new Mock<IStats>(); var command = new FaultingTaskEchoCommandWithoutFallback(exception) { Stats = mockStats.Object, }; try { await command.InvokeAsync(); } catch (CommandFailedException e) { if (e.GetBaseException() != exception) throw; mockStats.Verify(m => m.Elapsed("mjolnir command test.FaultingTaskEchoCommandWithoutFallback fallback", "NotImplemented", It.IsAny<TimeSpan>()), Times.Once); return; // Expected. } AssertX.FailExpectedException(); }
public async Task InvokeAsync_WhenFallbackFails_ReleasesSemaphore() { var mockSemaphore = new Mock<IIsolationSemaphore>(); mockSemaphore.Setup(m => m.TryEnter()).Returns(true); var exception = new ExpectedTestException("Expected"); var command = new FaultingTaskWithEchoThrowingFallbackCommand(exception) { FallbackSemaphore = mockSemaphore.Object, }; try { await command.InvokeAsync(); } catch (ExpectedTestException e) { Assert.Equal(exception, e); mockSemaphore.Verify(m => m.Release(), Times.Once); return; // Expected. } AssertX.FailExpectedException(); }
public async Task InvokeAsync_CommandExceptionFromExecute_RetainsOriginalExceptionCause() { var cause = new ExpectedTestException("Root cause exception"); var command = new FaultingExecuteEchoCommandWithoutFallback(cause); var e = await Assert.ThrowsAsync<CommandFailedException>(() => command.InvokeAsync()); Assert.Equal(cause, e.GetBaseException()); }
public async Task InvokeAsync_TaskFaultsAndFallbackThrowsNonInstigator() { var expected = new ExpectedTestException("foo"); var mockStats = new Mock<IStats>(); var command = new FaultingTaskWithEchoThrowingFallbackCommand(expected) { Stats = mockStats.Object, }; try { await command.InvokeAsync(); } catch (ExpectedTestException e) { if (e != expected) throw; mockStats.Verify(m => m.Elapsed("mjolnir command test.FaultingTaskWithEchoThrowingFallback fallback", "Failure", It.IsAny<TimeSpan>()), Times.Once); return; // Expected. } AssertX.FailExpectedException(); }
public async Task InvokeAsync_TaskFaultsAndFallbackThrowsNonInstigator() { var expected = new ExpectedTestException("foo"); var mockStats = new Mock<IStats>(); var command = new FaultingTaskWithEchoThrowingFallbackCommand(expected) { Stats = mockStats.Object, }; var e = await Assert.ThrowsAsync<ExpectedTestException>(command.InvokeAsync); Assert.Equal(expected, e); mockStats.Verify(m => m.Elapsed("mjolnir command test.FaultingTaskWithEchoThrowingFallback fallback", "Failure", It.IsAny<TimeSpan>()), Times.Once); }
public TestThrowingImplementation(ExpectedTestException exceptionToThrow) { _exceptionToThrow = exceptionToThrow; }
public void WhenUnsuccessful_HasPopulatedException() { var exception = new ExpectedTestException("expected"); var result = new CommandResult<object>(new { }, exception); Assert.Equal(exception, result.Exception); }
public async Task InvokeAsync_TaskFaultsAndFallbackNotImplemented() { var exception = new ExpectedTestException("foo"); var mockStats = new Mock<IStats>(); var command = new FaultingTaskEchoCommandWithoutFallback(exception) { Stats = mockStats.Object, }; var e = await Assert.ThrowsAsync<CommandFailedException>(command.InvokeAsync); Assert.Equal(exception, e.GetBaseException()); mockStats.Verify(m => m.Elapsed("mjolnir command test.FaultingTaskEchoCommandWithoutFallback fallback", "NotImplemented", It.IsAny<TimeSpan>()), Times.Once); }
internal TimingOutWithEchoThrowingFallbackCommand(ExpectedTestException toRethrow) : base(TimeSpan.FromMilliseconds(100)) { _exception = toRethrow; }
internal FaultingTaskWithEchoThrowingFallbackCommand(ExpectedTestException toRethrow) { _exception = toRethrow; }
public async Task InvokeAsync_CommandExceptionFromTask_RetainsOriginalExceptionCause() { var cause = new ExpectedTestException("Root cause exception"); var command = new FaultingTaskEchoCommandWithoutFallback(cause); try { await command.InvokeAsync(); } catch (CommandFailedException e) { Assert.Equal(cause, e.GetBaseException()); return; } AssertX.FailExpectedException(); }