Issue #66 - Add methods for ordered ExceptionMapper

Author: boretti

README.md

@@ -170,11 +170,11 @@ To do so, create all the required implementation, for example :
 ```java
 public class MyExceptionMapper implements ch.powerunit.extensions.exceptions.ExceptionMapper {
   public RuntimeException apply(Exception e) {
-    //TODO
+    //Add code here
   }
 
   public Class<? extends Exception> targetException() {
-    return //TODO;
+    return //Add code here;
   }
 
   // Optional, to define the order between the ExceptionMapper

src/main/java/ch/powerunit/extensions/exceptions/Constants.java

@@ -22,9 +22,9 @@
 import static ch.powerunit.extensions.exceptions.ExceptionMapper.forException;
 import static ch.powerunit.extensions.exceptions.SupplierWithException.ignored;
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.toList;
 
 import java.sql.SQLException;
-import java.util.Comparator;
 import java.util.ServiceLoader;
 import java.util.ServiceLoader.Provider;
 import java.util.function.Function;
@@ -100,8 +100,8 @@ private static ExceptionMapper buildTransformerExceptionMapper() throws ClassNot
 	}
 
 	private static Function<Exception, RuntimeException> computeDefaultMapper() {
-		return ExceptionMapper.forExceptions(ServiceLoader.load(ExceptionMapper.class).stream().map(Provider::get)
-				.sorted(Comparator.comparingInt(ExceptionMapper::order)).toArray(ExceptionMapper[]::new));
+		return ExceptionMapper.forOrderedExceptions(
+				ServiceLoader.load(ExceptionMapper.class).stream().map(Provider::get).collect(toList()));
 	}
 
 	private Constants() {

src/main/java/ch/powerunit/extensions/exceptions/ExceptionMapper.java

@@ -21,7 +21,11 @@
 
 import static java.util.Arrays.stream;
 
+import java.util.Collection;
+import java.util.Comparator;
 import java.util.Optional;
+import java.util.ServiceLoader;
+import java.util.ServiceLoader.Provider;
 import java.util.function.Function;
 
 /**
@@ -135,6 +139,26 @@ default int order() {
 	 *         for the other exception just create a {@code WrappedException}.
 	 */
 	static <E extends Exception> ExceptionMapper forException(Class<E> clazz, Function<E, RuntimeException> mapper) {
+		return forException(clazz, mapper, 0);
+	}
+
+	/**
+	 * Helper method to create exception wrapper that check the exception class.
+	 *
+	 * @param clazz
+	 *            the class of the exception to be wrapped.
+	 * @param mapper
+	 *            the exception mapper.
+	 * @param order
+	 *            the order
+	 * @param <E>
+	 *            the type of the exception.
+	 * @return A new exception mapper, which use the one received as parameter or
+	 *         for the other exception just create a {@code WrappedException}.
+	 * @since 2.2.0
+	 */
+	static <E extends Exception> ExceptionMapper forException(Class<E> clazz, Function<E, RuntimeException> mapper,
+			int order) {
 		return new ExceptionMapper() {
 
 			@Override
@@ -146,6 +170,11 @@ public RuntimeException apply(Exception t) {
 			public Class<E> targetException() {
 				return clazz;
 			}
+
+			@Override
+			public int order() {
+				return order;
+			}
 		};
 	}
 
@@ -196,4 +225,21 @@ static Function<Exception, RuntimeException> forExceptions(ExceptionMapper... ma
 				.orElseGet(() -> new WrappedException(e));
 	}
 
+	/**
+	 * Helper method to create exception wrapper that use the first one that is
+	 * applicable, but having them sorted using the {@link #order()} method.
+	 *
+	 * @param mappers
+	 *            the mapper to be tried
+	 * @return the mapping function.
+	 * @since 2.2.0
+	 */
+	static Function<Exception, RuntimeException> forOrderedExceptions(Collection<ExceptionMapper> mappers) {
+		if (mappers.isEmpty()) {
+			return WrappedException::new;
+		}
+		return ExceptionMapper.forExceptions(mappers.stream().sorted(Comparator.comparingInt(ExceptionMapper::order))
+				.toArray(ExceptionMapper[]::new));
+	}
+
 }

src/test/java/ch/powerunit/extensions/exceptions/ExceptionMapperTest.java

@@ -21,6 +21,8 @@
 
 import java.io.IOException;
 import java.sql.SQLException;
+import java.util.Collections;
+import java.util.List;
 
 import javax.xml.bind.JAXBException;
 import javax.xml.transform.TransformerException;
@@ -70,12 +72,6 @@ public void testForExceptions2MapperForOtherException() {
 				new SQLException("test")).is(both(exceptionMessage("test")).and(instanceOf(WrappedException.class)));
 	}
 
-	@Test
-	public void testForExceptions3None() {
-		assertThatFunction(ExceptionMapper.forExceptions(), new IOException("test"))
-				.is(instanceOf(WrappedException.class));
-	}
-
 	@Test
 	public void testForExceptions3SameExceptionFirst() {
 		assertThatFunction(
@@ -122,6 +118,12 @@ public void testForExceptions3MapperForOtherException() {
 				new SQLException("test")).is(both(exceptionMessage("test")).and(instanceOf(WrappedException.class)));
 	}
 
+	@Test
+	public void testForExceptionsAnyNone() {
+		assertThatFunction(ExceptionMapper.forExceptions(), new IOException("test"))
+				.is(instanceOf(WrappedException.class));
+	}
+
 	@Test
 	public void testForExceptionsAnySameExceptionFirst() {
 		assertThatFunction(ExceptionMapper.forExceptions(
@@ -175,6 +177,31 @@ public void testForExceptionsAnyMapperForOtherException() {
 				new SQLException("test")).is(both(exceptionMessage("test")).and(instanceOf(WrappedException.class)));
 	}
 
+	@Test
+	public void testForOrderedExceptionsNone() {
+		assertThatFunction(ExceptionMapper.forOrderedExceptions(Collections.emptyList()), new IOException("test"))
+				.is(instanceOf(WrappedException.class));
+	}
+
+	@Test
+	public void testForOrderedOneElement() {
+		assertThatFunction(
+				ExceptionMapper.forOrderedExceptions(List.of(
+						ExceptionMapper.forException(RuntimeException.class, e -> new WrappedException("testme1"), 2))),
+				new IllegalArgumentException("test"))
+						.is(both(exceptionMessage("testme1")).and(instanceOf(WrappedException.class)));
+	}
+
+	@Test
+	public void testForOrderedTwoElement() {
+		assertThatFunction(ExceptionMapper.forOrderedExceptions(
+				List.of(ExceptionMapper.forException(RuntimeException.class, e -> new WrappedException("testme1"), 2),
+						ExceptionMapper.forException(IllegalArgumentException.class,
+								e -> new WrappedException("testme2"), 1))),
+				new IllegalArgumentException("test"))
+						.is(both(exceptionMessage("testme2")).and(instanceOf(WrappedException.class)));
+	}
+
 	@Test
 	public void testJaxbException() {
 		ExceptionMapper.jaxbExceptionMapper().apply(new JAXBException("msg"));