Combining multiple input validations into one exception
In order to make sure methods fail fast under invalid arguments, I usually do validation at the start of a method. If I'm verifying multiple predicates, this leads to a few lines of checkNotNull or checkArgument, where a NullPointerException or IllegalArgumentException is thrown if something isn't right. public void takeoff(@NotNull Spaceship spaceship) { checkArgument(spaceship.fuel() > MIN_FUEL, "fuel too low"); checkArgument(spaceship.pilot() != null, "pilot is missing"); checkArgument(!spaceship.launchTower().isAttached(), "launch tower is still attached"); // More validation, rest of function... } public static void checkArgument(boolean expression, String message) { if (!expression) { throw new IllegalArgumentException(message); } } This gives a neat block at the top of what assumptions are used in the rest of the method, which is useful for anyone else reading the method in the future. However, this is still a little inconvenient for the caller. If the fuel is too low, the pilot is missing, and the launch tower is still attached, the exception thrown is only IllegalArgumentException: fuel too low. Adding more fuel and re-running then gets the exception for the pilot; repeat for the tower and any other conditions that need to be met. The question: How can I group input validation so that all errors are given in the exception, while also keeping the code neat for reading? Previously, I've done this pattern when bundling multiple exceptions into one, when the first exception thrown doesn't necessarily stop me from checking further: public void takeoff(Spaceship spaceship) { IllegalArgumentException combined = null; try { checkArgument(spaceship.fuel() > MIN_FUEL, "fuel too low"); } catch (IllegalArgumentException e) { combined = e; } try { checkArgument(spaceship.pilot() != null, "pilot is missing"); } catch (IllegalArgumentException e) { if (combined != null) { combined.addSuppressed(e); } else { combined = e; } } try { checkArgument(!spaceship.launchTower().isAttached(), "launch tower is still attached"); } catch (IllegalArgumentException e) { if (combined != null) { combined.addSuppressed(e); } else { combined = e; } } // repeat for remaining validations if (combined != null) throw combined; // rest of method } This adds all IllegalArgumentExceptions beyond the first as suppressed exceptions, but becomes way too verbose even at just three conditions to check, and a reader would have a harder time figuring out what those conditions even are. This was particularly relevant to me when using the javax.mail library, since methods like Message.setContent(), Message.setRecipients(), and Message.setSubject() could each throw a checked MessagingException. I very much wasn't expecting to encounter a situation where such an exception was thrown, but in the slim chance I did, I wanted to attempt all methods to collect as much information as possible about what's wrong before throwing the exception out of my method. Otherwise, the caller would need to run, see that something was thrown, fix the issue, run again, see another thing in the same area was wrong, fix, repeat. The solution I'm looking for is something that can handle multiple calls throwing exceptions. While the spaceship validation could just be a few if-checks and then creating an error message for one IllegalArgumentException, the MessagingException situation requires exception handling. I'm primarily interested in solutions for Java, but I'd also like to see if other languages have tools for handling this problem as well.
In order to make sure methods fail fast under invalid arguments, I usually do validation at the start of a method. If I'm verifying multiple predicates, this leads to a few lines of checkNotNull or checkArgument, where a NullPointerException or IllegalArgumentException is thrown if something isn't right.
public void takeoff(@NotNull Spaceship spaceship) {
checkArgument(spaceship.fuel() > MIN_FUEL, "fuel too low");
checkArgument(spaceship.pilot() != null, "pilot is missing");
checkArgument(!spaceship.launchTower().isAttached(), "launch tower is still attached");
// More validation, rest of function...
}
public static void checkArgument(boolean expression, String message) {
if (!expression) {
throw new IllegalArgumentException(message);
}
}
This gives a neat block at the top of what assumptions are used in the rest of the method, which is useful for anyone else reading the method in the future. However, this is still a little inconvenient for the caller. If the fuel is too low, the pilot is missing, and the launch tower is still attached, the exception thrown is only IllegalArgumentException: fuel too low. Adding more fuel and re-running then gets the exception for the pilot; repeat for the tower and any other conditions that need to be met. The question: How can I group input validation so that all errors are given in the exception, while also keeping the code neat for reading?
Previously, I've done this pattern when bundling multiple exceptions into one, when the first exception thrown doesn't necessarily stop me from checking further:
public void takeoff(Spaceship spaceship) {
IllegalArgumentException combined = null;
try {
checkArgument(spaceship.fuel() > MIN_FUEL, "fuel too low");
} catch (IllegalArgumentException e) {
combined = e;
}
try {
checkArgument(spaceship.pilot() != null, "pilot is missing");
} catch (IllegalArgumentException e) {
if (combined != null) {
combined.addSuppressed(e);
} else {
combined = e;
}
}
try {
checkArgument(!spaceship.launchTower().isAttached(), "launch tower is still attached");
} catch (IllegalArgumentException e) {
if (combined != null) {
combined.addSuppressed(e);
} else {
combined = e;
}
}
// repeat for remaining validations
if (combined != null) throw combined;
// rest of method
}
This adds all IllegalArgumentExceptions beyond the first as suppressed exceptions, but becomes way too verbose even at just three conditions to check, and a reader would have a harder time figuring out what those conditions even are. This was particularly relevant to me when using the javax.mail library, since methods like Message.setContent(), Message.setRecipients(), and Message.setSubject() could each throw a checked MessagingException. I very much wasn't expecting to encounter a situation where such an exception was thrown, but in the slim chance I did, I wanted to attempt all methods to collect as much information as possible about what's wrong before throwing the exception out of my method. Otherwise, the caller would need to run, see that something was thrown, fix the issue, run again, see another thing in the same area was wrong, fix, repeat.
The solution I'm looking for is something that can handle multiple calls throwing exceptions. While the spaceship validation could just be a few if-checks and then creating an error message for one IllegalArgumentException, the MessagingException situation requires exception handling. I'm primarily interested in solutions for Java, but I'd also like to see if other languages have tools for handling this problem as well.
![[Tutorial] Chapter 4: Task and Comment Plugins](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ffl10oejjhn82dwrsm2n2.png)
