Add EndpointServiceExceptionAssert

[mpritham]

Before this PR

We have test utilities for asserting properties of ServiceException but do not have any utilities for EndpointServiceException.

After this PR

==COMMIT_MSG==
Add EndpointServiceExceptionAssert
==COMMIT_MSG==

Possible downsides?

[changelog-app]

Generate changelog in changelog/@unreleased

Type (Select exactly one)

• Feature (Adding new functionality)
• Improvement (Improving existing functionality)
• Fix (Fixing an issue with existing functionality)
• Break (Creating a new major version by breaking public APIs)
• Deprecation (Removing functionality in a non-breaking way)
• Migration (Automatically moving data/functionality to a new system)

Description

Add EndpointServiceExceptionAssert

Check the box to generate changelog(s)

• Generate changelog entry

[changelog-app]

✅ Successfully generated changelog entry!

Need to regenerate?

Simply interact with the changelog bot comment again to regenerate these entries.

---

📋Changelog Preview

💡 Improvements

• Add EndpointServiceExceptionAssert (#1519)

[mpritham]

Replicating the test cases in

conjure-java-runtime-api/test-utils/src/test/java/com/palantir/conjure/java/api/testing/ServiceExceptionAssertTest.java

Lines 30 to 96 in aad80d0

	public void testSanity() {
	ErrorType actualType = ErrorType.FAILED_PRECONDITION;
	Assertions.assertThat(new ServiceException(actualType, SafeArg.of("a", "b"), UnsafeArg.of("c", "d")))
	.hasCode(actualType.code())
	.hasType(actualType)
	.hasArgs(SafeArg.of("a", "b"), UnsafeArg.of("c", "d"));
	Assertions.assertThat(new ServiceException(actualType, SafeArg.of("a", "b"), UnsafeArg.of("c", "d")))
	.hasCode(actualType.code())
	.hasType(actualType)
	.hasArgs(UnsafeArg.of("c", "d"), SafeArg.of("a", "b")); // Order doesn't matter
	Assertions.assertThat(new ServiceException(actualType)).hasNoArgs();
	assertThatThrownBy(() ->
	Assertions.assertThat(new ServiceException(actualType)).hasCode(ErrorType.Code.INTERNAL))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining(
	"Expected ErrorType.Code to be %s, but found %s", ErrorType.Code.INTERNAL, actualType.code());
	assertThatThrownBy(() ->
	Assertions.assertThat(new ServiceException(actualType)).hasType(ErrorType.INTERNAL))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected ErrorType to be %s, but found %s", ErrorType.INTERNAL, actualType);
	assertThatThrownBy(() -> Assertions.assertThat(new ServiceException(actualType, SafeArg.of("a", "b")))
	.hasArgs(SafeArg.of("c", "d")))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected safe args to be {c=d}, but found {a=b}");
	assertThatThrownBy(() -> Assertions.assertThat(new ServiceException(actualType, UnsafeArg.of("a", "b")))
	.hasArgs(UnsafeArg.of("c", "d")))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected unsafe args to be {c=d}, but found {a=b}");
	assertThatThrownBy(() -> Assertions.assertThat(new ServiceException(actualType, SafeArg.of("a", "b")))
	.hasNoArgs())
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected no args, but found {a=b}");
	assertThatThrownBy(() -> Assertions.assertThat(
	new ServiceException(actualType, SafeArg.of("a", "b"), UnsafeArg.of("c", "d")))
	.hasNoArgs())
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected no args, but found {a=b, c=d}");
	Assertions.assertThat(new ServiceException(actualType, UnsafeArg.of("a", "b"), UnsafeArg.of("c", "d")))
	.containsArgs(UnsafeArg.of("a", "b"));
	// Safety matters
	assertThatThrownBy(() -> Assertions.assertThat(
	new ServiceException(actualType, SafeArg.of("a", "b"), UnsafeArg.of("c", "d")))
	.containsArgs(UnsafeArg.of("a", "b")))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected unsafe args to contain {a=b}, but found {c=d}");
	assertThatThrownBy(() -> Assertions.assertThat(new ServiceException(actualType, SafeArg.of("a", "b")))
	.containsArgs(SafeArg.of("c", "d")))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected safe args to contain {c=d}, but found {a=b}");
	assertThatThrownBy(() -> Assertions.assertThat(new ServiceException(actualType, UnsafeArg.of("a", "b")))
	.containsArgs(UnsafeArg.of("c", "d")))
	.isInstanceOf(AssertionError.class)
	.hasMessageContaining("Expected unsafe args to contain {c=d}, but found {a=b}");
	}

[aldexis]

Wondering whether we could simply have a main testing class that tests the abstract base class, once we do the changes I proposed to share more of the actual implementation and methods?

[aldexis]

Instead of defining methods that take the actual value and redefining methods in the implementation, could you just do this instead?

Suggested change

	abstract class AbstractServiceExceptionAssert<T extends AbstractThrowableAssert<T, U>, U extends Throwable>
	extends AbstractThrowableAssert<T, U> {
	protected AbstractServiceExceptionAssert(U throwable, Class<T> selfType) {
	super(throwable, selfType);
	}
	void hasCode(ErrorType.Code code, ErrorType.Code actualCode) {
	isNotNull();
	failIfNotEqual("Expected ErrorType.Code to be %s, but found %s", code, actualCode);
	}
	abstract class AbstractServiceExceptionAssert<T extends AbstractThrowableAssert<T, U>, U extends Throwable>
	extends AbstractThrowableAssert<T, U> {
	protected AbstractServiceExceptionAssert(U throwable, Class<T> selfType) {
	super(throwable, selfType);
	}
	protected abstract ErrorType actualErrorType();
	public final void hasCode(ErrorType.Code code) {
	isNotNull();
	failIfNotEqual("Expected ErrorType.Code to be %s, but found %s", code, actualErrorType().code();
	}

?

I realize that EndpointServiceException and ServiceException unfortunately don't implement any shared interface (which they probably should to be honest?), but we should still be able to share most of the implementation and thereby also guarantee that they have the exact same methods, without having to redefine them in the concrete implementation either

[aldexis]

Suggested change

	abstract class AbstractServiceExceptionAssert<T extends AbstractThrowableAssert<T, U>, U extends Throwable>
	abstract class AbstractServiceExceptionAssert<T extends AbstractServiceExceptionAssert<T, U>, U extends Throwable>

[aldexis]

Wondering whether we could simply have a main testing class that tests the abstract base class, once we do the changes I proposed to share more of the actual implementation and methods?