[#487] Fix MultipleContextTest

* Make sure test actually runs
* Remove unecessary local variables
* Less strict check on the exception location

Author: DavideD

hibernate-reactive-core/src/test/java/org/hibernate/reactive/MultipleContextTest.java

@@ -5,7 +5,6 @@
  */
 package org.hibernate.reactive;
 
-import java.util.concurrent.CompletionException;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 
@@ -18,12 +17,17 @@
 import io.smallrye.mutiny.Uni;
 import io.vertx.core.Context;
 import io.vertx.core.Vertx;
+import io.vertx.ext.unit.Async;
 import io.vertx.ext.unit.TestContext;
 import org.assertj.core.api.Assertions;
 
 /**
  * It's currently considered an error to share a Session between multiple reactive streams,
  * so we should detect that condition and throw an exception.
+ * <p>
+ * WARNING: Because we are running the code to test inside a function, we must create the {@link Async}
+ * in advance. Otherwise the test will end successfully because the async has not been created yet.
+ * </p>
  */
 public class MultipleContextTest extends BaseReactiveTest {
 
@@ -38,99 +42,91 @@ protected Configuration constructConfiguration() {
 
 	@Test
 	public void testPersistWithStage(TestContext testContext) throws Exception {
+		Async async = testContext.async();
 		Stage.Session session = openSession();
 		Context testVertxContext = Vertx.currentContext();
 
 		// Create a different new context
-		Vertx vertx = Vertx.vertx();
-		Context newContext = vertx.getOrCreateContext();
+		Context newContext = Vertx.vertx().getOrCreateContext();
 		Assertions.assertThat( testVertxContext ).isNotEqualTo( newContext );
 
 		// Run test in the new context
-		newContext.runOnContext( event ->
-			test( testContext, session
-					.persist( new Competition( "Cheese Rolling" ) )
-					.handle( (v, e) -> {
-						testContext.assertNotNull( e );
-						testContext.assertEquals( CompletionException.class, e.getClass() );
-						testContext.assertEquals( IllegalStateException.class, e.getCause().getClass() );
-						testContext.assertTrue( e.getMessage().contains( ERROR_MESSAGE ) );
-						return null;
-					} ) )
+		newContext.runOnContext( event -> test( async, testContext, session
+				.persist( new Competition( "Cheese Rolling" ) )
+				.thenCompose( v -> session.flush() )
+				.handle( (v, e) -> assertExceptionThrown( e ) ) )
 		);
 	}
 
-
 	@Test
 	public void testFindWithStage(TestContext testContext) throws Exception {
+		Async async = testContext.async();
 		Stage.Session session = openSession();
 		Context testVertxContext = Vertx.currentContext();
 
 		// Create a different new context
-		Vertx vertx = Vertx.vertx();
-		Context newContext = vertx.getOrCreateContext();
+		Context newContext = Vertx.vertx().getOrCreateContext();
 		Assertions.assertThat( testVertxContext ).isNotEqualTo( newContext );
 
 		// Run test in the new context
-		newContext.runOnContext( event ->
-			 test( testContext, session
-					 .find( Competition.class, "Chess boxing" )
-					 .handle( (v, e) -> {
-						 testContext.assertNotNull( e );
-						 testContext.assertEquals( CompletionException.class, e.getClass() );
-						 testContext.assertEquals( IllegalStateException.class, e.getCause().getClass() );
-						 testContext.assertTrue( e.getMessage().contains( ERROR_MESSAGE ) );
-						 return null;
-					 } ) )
+		newContext.runOnContext( event -> test( async, testContext, session
+				.find( Competition.class, "Chess boxing" )
+				.handle( (v, e) -> assertExceptionThrown( e ) ) )
 		);
 	}
 
 	@Test
 	public void testOnPersistWithMutiny(TestContext testContext) throws Exception {
+		Async async = testContext.async();
 		Mutiny.Session session = openMutinySession();
 		Context testVertxContext = Vertx.currentContext();
 
 		// Create a different new context
-		Vertx vertx = Vertx.vertx();
-		Context newContext = vertx.getOrCreateContext();
+		Context newContext = Vertx.vertx().getOrCreateContext();
 		Assertions.assertThat( testVertxContext ).isNotEqualTo( newContext );
 
 		// Run test in the new context
-		newContext.runOnContext( event ->
-			 test( testContext, session
-					 .persist( new Competition( "Cheese Rolling" ) )
-					 .onItem().invoke( v -> testContext.fail( "We were expecting an exception" ) )
-					 .onFailure().recoverWithUni( e -> {
-						 testContext.assertEquals( IllegalStateException.class, e.getClass() );
-						 testContext.assertTrue( e.getMessage().contains( ERROR_MESSAGE ) );
-						 return Uni.createFrom().voidItem();
-					 } ) )
+		newContext.runOnContext( event -> test( async, testContext, session
+				.persist( new Competition( "Cheese Rolling" ) )
+				.call( session::flush )
+				.onItem().invoke( v -> testContext.fail( "We were expecting an exception" ) )
+				.onFailure().recoverWithUni( e -> Uni.createFrom().voidItem()
+						.invoke( () -> assertExceptionThrown( e ) ) ) )
 		);
 	}
 
 	@Test
 	public void testFindWithMutiny(TestContext testContext) throws Exception {
+		Async async = testContext.async();
 		Mutiny.Session session = openMutinySession();
 		Context testVertxContext = Vertx.currentContext();
 
 		// Create a different new context
-		Vertx vertx = Vertx.vertx();
-		Context newContext = vertx.getOrCreateContext();
+		Context newContext = Vertx.vertx().getOrCreateContext();
 		Assertions.assertThat( testVertxContext ).isNotEqualTo( newContext );
 
 		// Run test in the new context
-		newContext.runOnContext(event ->
-			 test( testContext, session
-					 .find( Competition.class, "Chess boxing" )
-					 .onItem().invoke( v -> testContext.fail( "We were expecting an exception" ) )
-					 .onFailure().recoverWithUni( e -> {
-						 testContext.assertEquals( IllegalStateException.class, e.getClass() );
-						 testContext.assertTrue( e.getMessage().contains( ERROR_MESSAGE ) );
-						 return Uni.createFrom().nullItem();
-					 } ) )
+		newContext.runOnContext( event -> test( async, testContext, session
+				.find( Competition.class, "Chess boxing" )
+				.onItem().invoke( v -> testContext.fail( "We were expecting an exception" ) )
+				.onFailure().recoverWithUni( e -> Uni.createFrom().voidItem()
+						.replaceWith( () -> assertExceptionThrown( e ) ) ) )
 		);
 	}
 
+	// Check that at least one exception has the expected message
+	private static <T> T assertExceptionThrown(Throwable e) {
+		Throwable t = e;
+		while ( t != null ) {
+			if ( t.getClass().equals( IllegalStateException.class )
+					&& t.getMessage().contains( ERROR_MESSAGE ) ) {
+				return null;
+			}
+			t = t.getCause();
+		}
+		throw new AssertionError( "Expected exception not thrown. Exception thrown: " + e );
+	}
+
 	@Entity
 	static class Competition {
 		@Id