public async Task BasicExceptionPropagation() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var exception = await Assert.ThrowsAsync <InvalidOperationException>( () => grain.ThrowsInvalidOperationException()); Assert.Equal("Test exception", exception.Message); }
public async Task GrainForwardingExceptionPropagation() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var otherGrainId = GetRandomGrainId(); var exception = await Assert.ThrowsAsync <InvalidOperationException>( () => grain.GrainCallToThrowsInvalidOperationException(otherGrainId)); Assert.Equal("Test exception", exception.Message); }
public async Task BasicExceptionPropagation() { IExceptionGrain grain = this.fixture.GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var exception = await Assert.ThrowsAsync <InvalidOperationException>( () => grain.ThrowsInvalidOperationException()); output.WriteLine(exception.ToString()); Assert.Equal("Test exception", exception.Message); }
public async Task ExceptionPropagationDoesNotUnwrapAggregateExceptions() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var exception = await Assert.ThrowsAsync <AggregateException>( () => grain.ThrowsAggregateExceptionWrappingInvalidOperationException()); var nestedEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerException); Assert.Equal("Test exception", nestedEx.Message); }
public async Task SynchronousExceptionThrownShouldResultInFaultedTask() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); // start the grain call but don't await it nor wrap in try/catch, to make sure it doesn't throw synchronously var grainCallTask = grain.ThrowsSynchronousInvalidOperationException(); var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => grainCallTask); Assert.Equal("Test exception", exception.Message); }
public async Task ExceptionPropagationDoesNoFlattenAggregateExceptions() { IExceptionGrain grain = this.fixture.GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var exception = await Assert.ThrowsAsync <AggregateException>( () => grain.ThrowsNestedAggregateExceptionsWrappingInvalidOperationException()); var nestedAggEx = Assert.IsAssignableFrom <AggregateException>(exception.InnerException); var doubleNestedEx = Assert.IsAssignableFrom <InvalidOperationException>(nestedAggEx.InnerException); Assert.Equal("Test exception", doubleNestedEx.Message); }
public void ExceptionContainsOriginalStackTrace() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); // Explicitly using .Wait() instead of await the task to avoid any modification of the inner exception var aggEx = Assert.Throws <AggregateException>( () => grain.ThrowsInvalidOperationException().Wait()); var exception = aggEx.InnerException; output.WriteLine(exception.ToString()); Assert.IsAssignableFrom <InvalidOperationException>(exception); Assert.Equal("Test exception", exception.Message); Assert.Contains("ThrowsInvalidOperationException", exception.StackTrace); }
public void ExceptionPropagationForwardsEntireAggregateException() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var grainCall = grain.ThrowsMultipleExceptionsAggregatedInFaultedTask(); // use Wait() so that we get the entire AggregateException ('await' would just catch the first inner exception) var exception = Assert.Throws <AggregateException>( () => grainCall.Wait()); // make sure that all exceptions in the task are present, and not just the first one. Assert.Equal(2, exception.InnerExceptions.Count); var firstEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerExceptions[0]); Assert.Equal("Test exception 1", firstEx.Message); var secondEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerExceptions[1]); Assert.Equal("Test exception 2", secondEx.Message); }
public async Task ExceptionContainsOriginalStackTraceWhenRethrowingLocally() { IExceptionGrain grain = this.fixture.GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); try { // Use await to force the exception to be rethrown and validate that the remote stack trace is still present await grain.ThrowsInvalidOperationException(); Assert.True(false, "should have thrown"); } catch (InvalidOperationException exception) { output.WriteLine(exception.ToString()); Assert.IsAssignableFrom <InvalidOperationException>(exception); Assert.Equal("Test exception", exception.Message); Assert.Contains("ThrowsInvalidOperationException", exception.StackTrace); } }
public async Task SynchronousAggregateExceptionThrownShouldResultInFaultedTaskWithOriginalAggregateExceptionUnmodifiedAsInnerException() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); // start the grain call but don't await it nor wrap in try/catch, to make sure it doesn't throw synchronously var grainCallTask = grain.ThrowsSynchronousAggregateExceptionWithMultipleInnerExceptions(); // assert that the faulted task has an inner exception of type AggregateException, which should be our original exception var exception = await Assert.ThrowsAsync <AggregateException>(() => grainCallTask); Assert.Equal("Test AggregateException message", exception.Message); // make sure that all exceptions in the task are present, and not just the first one. Assert.Equal(2, exception.InnerExceptions.Count); var firstEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerExceptions[0]); Assert.Equal("Test exception 1", firstEx.Message); var secondEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerExceptions[1]); Assert.Equal("Test exception 2", secondEx.Message); }
public async Task TaskCancelationPropagation() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var actualException = default(Exception); try { await grain.Cancelled(); } catch (Exception exception) { actualException = exception; } Assert.IsNotNull(actualException, "Expected grain call to throw a cancellation exception."); Assert.IsTrue(actualException is AggregateException); Assert.AreEqual( typeof(TaskCanceledException), ((AggregateException)actualException).InnerException.GetType()); }
public void ExceptionPropagationForwardsEntireAggregateException() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); var grainCall = grain.ThrowsMultipleExceptionsAggregatedInFaultedTask(); try { // use Wait() so that we get the entire AggregateException ('await' would just catch the first inner exception) // Do not use Assert.Throws to avoid any tampering of the AggregateException itself from the test framework grainCall.Wait(); Assert.True(false, "Expected AggregateException"); } catch (AggregateException exception) { output.WriteLine(exception.ToString()); // make sure that all exceptions in the task are present, and not just the first one. Assert.Equal(2, exception.InnerExceptions.Count); var firstEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerExceptions[0]); Assert.Equal("Test exception 1", firstEx.Message); var secondEx = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerExceptions[1]); Assert.Equal("Test exception 2", secondEx.Message); } }
public async Task TaskCancelationPropagation() { IExceptionGrain grain = GrainFactory.GetGrain <IExceptionGrain>(GetRandomGrainId()); await Assert.ThrowsAsync <TaskCanceledException>( () => grain.Canceled()); }