Skip to content

Commit 2a7c5a6

Browse files
scordioscordio
authored
Revert "Provide value when assertThatThrownBy/thenThrownBy fail" (#3318)
This reverts commit cf06398 and adds a new test to prevent further regression.
1 parent 887f97b commit 2a7c5a6

File tree

6 files changed

+34
-125
lines changed

6 files changed

+34
-125
lines changed

‎assertj-core/src/main/java/org/assertj/core/api/Assertions.java

Lines changed: 0 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@
1212
*/
1313
package org.assertj.core.api;
1414

15-
import static java.lang.String.format;
1615
import static org.assertj.core.configuration.ConfigurationProvider.CONFIGURATION_PROVIDER;
1716
import static org.assertj.core.data.Percentage.withPercentage;
1817

@@ -76,7 +75,6 @@
7675
import java.util.stream.Stream;
7776

7877
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
79-
import org.assertj.core.api.ThrowableAssert.ThrowingCallableWithValue;
8078
import org.assertj.core.api.filter.FilterOperator;
8179
import org.assertj.core.api.filter.Filters;
8280
import org.assertj.core.api.filter.InFilter;
@@ -98,7 +96,6 @@
9896
import org.assertj.core.description.Description;
9997
import org.assertj.core.groups.Properties;
10098
import org.assertj.core.groups.Tuple;
101-
import org.assertj.core.internal.Failures;
10299
import org.assertj.core.presentation.BinaryRepresentation;
103100
import org.assertj.core.presentation.HexadecimalRepresentation;
104101
import org.assertj.core.presentation.Representation;
@@ -1212,26 +1209,6 @@ public static <T extends Throwable> AbstractThrowableAssert<?, T> assertThat(T a
12121209
return assertThat(catchThrowable(shouldRaiseThrowable)).hasBeenThrown();
12131210
}
12141211

1215-
/**
1216-
* Similar to {@link #assertThatThrownBy(ThrowingCallable)}, but when the called code returns a value instead of
1217-
* throwing, the assertion error shows the returned value to help understand what went wrong.
1218-
*
1219-
* @param shouldRaiseThrowable The {@link ThrowingCallableWithValue} or lambda with the code that should raise the throwable.
1220-
* @return the created {@link ThrowableAssert}.
1221-
* @since 3.25.0
1222-
*/
1223-
@CanIgnoreReturnValue
1224-
public static AbstractThrowableAssert<?, ? extends Throwable> assertThatThrownBy(
1225-
ThrowingCallableWithValue shouldRaiseThrowable) {
1226-
Object value;
1227-
try {
1228-
value = shouldRaiseThrowable.call();
1229-
} catch (Throwable throwable) {
1230-
return assertThat(throwable);
1231-
}
1232-
throw Failures.instance().failure(format("Expecting code to raise a throwable, but it returned [%s] instead", value));
1233-
}
1234-
12351212
/**
12361213
* Allows to capture and then assert on a {@link Throwable} like {@code assertThatThrownBy(ThrowingCallable)} but this method
12371214
* let you set the assertion description the same way you do with {@link AbstractAssert#as(String, Object...) as(String, Object...)}.
@@ -1270,26 +1247,6 @@ public static <T extends Throwable> AbstractThrowableAssert<?, T> assertThat(T a
12701247
return assertThat(catchThrowable(shouldRaiseThrowable)).as(description, args).hasBeenThrown();
12711248
}
12721249

1273-
/**
1274-
* Similar to {@link #assertThatThrownBy(ThrowingCallable, String, Object...)}, but when the called code returns a value
1275-
* instead of throwing, the assertion error shows the returned value to help understand what went wrong.
1276-
*
1277-
* @param shouldRaiseThrowable The {@link ThrowingCallableWithValue} or lambda with the code that should raise the throwable.
1278-
* @return the created {@link ThrowableAssert}.
1279-
* @since 3.25.0
1280-
*/
1281-
@CanIgnoreReturnValue
1282-
public static AbstractThrowableAssert<?, ? extends Throwable> assertThatThrownBy(ThrowingCallableWithValue shouldRaiseThrowable,
1283-
String description, Object... args) {
1284-
Object value;
1285-
try {
1286-
value = shouldRaiseThrowable.call();
1287-
} catch (Throwable throwable) {
1288-
return assertThat(throwable).as(description, args);
1289-
}
1290-
throw Failures.instance().failure(format("Expecting code to raise a throwable, but it returned [%s] instead", value));
1291-
}
1292-
12931250
/**
12941251
* Allows to capture and then assert on a {@link Throwable} (easier done with lambdas).
12951252
* <p>

‎assertj-core/src/main/java/org/assertj/core/api/BDDAssertions.java

Lines changed: 0 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -12,8 +12,6 @@
1212
*/
1313
package org.assertj.core.api;
1414

15-
import static java.lang.String.format;
16-
1715
import java.io.File;
1816
import java.io.IOException;
1917
import java.io.InputStream;
@@ -74,7 +72,6 @@
7472
import java.util.stream.Stream;
7573

7674
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
77-
import org.assertj.core.api.ThrowableAssert.ThrowingCallableWithValue;
7875
import org.assertj.core.api.filter.FilterOperator;
7976
import org.assertj.core.api.filter.InFilter;
8077
import org.assertj.core.api.filter.NotFilter;
@@ -92,7 +89,6 @@
9289
import org.assertj.core.description.Description;
9390
import org.assertj.core.groups.Properties;
9491
import org.assertj.core.groups.Tuple;
95-
import org.assertj.core.internal.Failures;
9692
import org.assertj.core.presentation.BinaryRepresentation;
9793
import org.assertj.core.presentation.HexadecimalRepresentation;
9894
import org.assertj.core.presentation.Representation;
@@ -1334,25 +1330,6 @@ public static <T extends Throwable> AbstractThrowableAssert<?, T> then(T actual)
13341330
return assertThat(catchThrowable(shouldRaiseThrowable)).hasBeenThrown();
13351331
}
13361332

1337-
/**
1338-
* Similar to {@link #thenThrownBy(ThrowingCallable)}, but when the called code returns a value instead of
1339-
* throwing, the assertion error shows the returned value to help understand what went wrong.
1340-
*
1341-
* @param shouldRaiseThrowable The {@link ThrowingCallableWithValue} or lambda with the code that should raise the throwable.
1342-
* @return the created {@link ThrowableAssert}.
1343-
* @since 3.25.0
1344-
*/
1345-
@CanIgnoreReturnValue
1346-
public static AbstractThrowableAssert<?, ? extends Throwable> thenThrownBy(ThrowingCallableWithValue shouldRaiseThrowable) {
1347-
Object value;
1348-
try {
1349-
value = shouldRaiseThrowable.call();
1350-
} catch (Throwable throwable) {
1351-
return assertThat(throwable);
1352-
}
1353-
throw Failures.instance().failure(format("Expecting code to raise a throwable, but it returned [%s] instead", value));
1354-
}
1355-
13561333
/**
13571334
* Allows to capture and then assert on a {@link Throwable} like {@code thenThrownBy(ThrowingCallable)} but this method
13581335
* let you set the assertion description the same way you do with {@link AbstractAssert#as(String, Object...) as(String, Object...)}.
@@ -1390,26 +1367,6 @@ public static <T extends Throwable> AbstractThrowableAssert<?, T> then(T actual)
13901367
return assertThat(catchThrowable(shouldRaiseThrowable)).as(description, args).hasBeenThrown();
13911368
}
13921369

1393-
/**
1394-
* Similar to {@link #thenThrownBy(ThrowingCallable, String, Object...)}, but when the called code returns a value instead of
1395-
* throwing, the assertion error shows the returned value to help understand what went wrong.
1396-
*
1397-
* @param shouldRaiseThrowable The {@link ThrowingCallableWithValue} or lambda with the code that should raise the throwable.
1398-
* @return the created {@link ThrowableAssert}.
1399-
* @since 3.25.0
1400-
*/
1401-
@CanIgnoreReturnValue
1402-
public static AbstractThrowableAssert<?, ? extends Throwable> thenThrownBy(ThrowingCallableWithValue shouldRaiseThrowable,
1403-
String description, Object... args) {
1404-
Object value;
1405-
try {
1406-
value = shouldRaiseThrowable.call();
1407-
} catch (Throwable throwable) {
1408-
return assertThat(throwable).as(description, args);
1409-
}
1410-
throw Failures.instance().failure(format("Expecting code to raise a throwable, but it returned [%s] instead", value));
1411-
}
1412-
14131370
/**
14141371
* Allows to capture and then assert on a {@link Throwable} more easily when used with Java 8 lambdas.
14151372
*

‎assertj-core/src/main/java/org/assertj/core/api/ThrowableAssert.java

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -33,10 +33,6 @@ public interface ThrowingCallable {
3333
void call() throws Throwable;
3434
}
3535

36-
public interface ThrowingCallableWithValue {
37-
Object call() throws Throwable;
38-
}
39-
4036
public ThrowableAssert(ACTUAL actual) {
4137
super(actual, ThrowableAssert.class);
4238
}

‎assertj-core/src/test/java/org/assertj/core/api/Assertions_assertThatThrownBy_Test.java

Lines changed: 32 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,8 @@
1414

1515
import static java.lang.String.format;
1616
import static org.assertj.core.api.Assertions.assertThatThrownBy;
17-
import static org.assertj.core.api.Assertions_catchThrowableOfType_Test.raisingException;
18-
import static org.assertj.core.api.Assertions_catchThrowable_Test.codeThrowing;
1917
import static org.assertj.core.api.BDDAssertions.then;
18+
import static org.assertj.core.error.ShouldHaveMessage.shouldHaveMessage;
2019
import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
2120

2221
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
@@ -25,47 +24,63 @@
2524
class Assertions_assertThatThrownBy_Test {
2625

2726
@Test
28-
void should_build_ThrowableAssert_with_runtime_exception_thrown() {
27+
void should_work_with_runtime_exception_thrown() {
28+
// WHEN/THEN
2929
assertThatThrownBy(codeThrowing(new IllegalArgumentException("boom"))).isInstanceOf(IllegalArgumentException.class)
3030
.hasMessage("boom");
3131
}
3232

3333
@Test
34-
void should_build_ThrowableAssert_with_throwable_thrown() {
34+
void should_work_with_throwable_thrown() {
35+
// WHEN/THEN
3536
assertThatThrownBy(codeThrowing(new Throwable("boom"))).isInstanceOf(Throwable.class)
3637
.hasMessage("boom");
3738
}
3839

3940
@Test
40-
void should_be_able_to_pass_a_description_to_assertThatThrownBy() {
41+
void should_work_with_method_reference_having_vararg_parameter() {
42+
// WHEN/THEN
43+
assertThatThrownBy(Assertions_assertThatThrownBy_Test::methodThrowing).isInstanceOf(Exception.class)
44+
.hasMessage("boom");
45+
}
46+
47+
@Test
48+
void should_support_description() {
4149
// GIVEN
42-
// make assertThatThrownBy fail to verify the description afterwards
43-
ThrowingCallable code = () -> assertThatThrownBy(raisingException("boom"), "Test %s", "code").hasMessage("bam");
50+
Throwable throwable = new Exception("boom");
4451
// WHEN
45-
AssertionError assertionError = expectAssertionError(code);
52+
AssertionError assertionError = expectAssertionError(() -> assertThatThrownBy(codeThrowing(throwable), "Test %s",
53+
"code").hasMessage("bam"));
4654
// THEN
4755
then(assertionError).hasMessageContaining("[Test code]");
4856
}
4957

5058
@Test
5159
void should_fail_if_no_throwable_was_thrown() {
52-
// GIVEN
53-
ThrowingCallable code = () -> {};
5460
// WHEN
55-
AssertionError assertionError = expectAssertionError(() -> assertThatThrownBy(code).hasMessage("boom ?"));
61+
AssertionError assertionError = expectAssertionError(() -> assertThatThrownBy(() -> {}).hasMessage("boom ?"));
5662
// THEN
5763
then(assertionError).hasMessage(format("%nExpecting code to raise a throwable."));
5864
}
5965

6066
@Test
61-
void should_fail_with_good_message_when_assertion_is_failing() {
67+
void should_fail_with_proper_message_when_assertion_is_failing() {
68+
// GIVEN
69+
Throwable throwable = new Exception("boom");
6270
// WHEN
63-
AssertionError assertionError = expectAssertionError(() -> assertThatThrownBy(raisingException("boom")).hasMessage("bam"));
71+
AssertionError assertionError = expectAssertionError(() -> assertThatThrownBy(codeThrowing(throwable)).hasMessage("bam"));
6472
// THEN
65-
then(assertionError).hasMessageContainingAll("Expecting message to be:",
66-
"\"bam\"",
67-
"but was:",
68-
"\"boom\"");
73+
then(assertionError).hasMessage(shouldHaveMessage(throwable, "bam").create());
74+
}
75+
76+
private static ThrowingCallable codeThrowing(Throwable t) {
77+
return () -> {
78+
throw t;
79+
};
80+
}
81+
82+
private static void methodThrowing(Object... parameters) throws Exception {
83+
throw new Exception("boom");
6984
}
7085

7186
}

‎assertj-core/src/test/java/org/assertj/core/api/throwable/ThrowableAssert_built_from_ThrowingCallable_Test.java

Lines changed: 1 addition & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -12,10 +12,8 @@
1212
*/
1313
package org.assertj.core.api.throwable;
1414

15-
import static java.lang.String.format;
1615
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
1716
import static org.assertj.core.api.Assertions.assertThatThrownBy;
18-
import static org.assertj.core.util.AssertionsUtil.assertThatAssertionErrorIsThrownBy;
1917

2018
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
2119
import org.junit.jupiter.api.Test;
@@ -52,14 +50,7 @@ public void call() {
5250
// no exception
5351
}
5452
});
55-
}).withMessage(format("%nExpecting code to raise a throwable."));
53+
}).withMessage(String.format("%nExpecting code to raise a throwable."));
5654
}
5755

58-
@Test
59-
void should_fail_and_show_value_returned_by_callable_code() {
60-
// GIVEN
61-
ThrowingCallable code = () -> assertThatThrownBy(() -> 42);
62-
// WHEN/THEN
63-
assertThatAssertionErrorIsThrownBy(code).withMessage("Expecting code to raise a throwable, but it returned [42] instead");
64-
}
6556
}

‎assertj-core/src/test/java/org/assertj/core/api/throwable/ThrowableAssert_built_with_then_method_Test.java

Lines changed: 1 addition & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -14,11 +14,11 @@
1414

1515
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
1616
import static org.assertj.core.api.BDDAssertions.thenThrownBy;
17-
import static org.assertj.core.util.AssertionsUtil.assertThatAssertionErrorIsThrownBy;
1817

1918
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
2019
import org.junit.jupiter.api.Test;
2120

21+
// TODO build two throwable assert with then and assertThat and compare them.
2222
class ThrowableAssert_built_with_then_method_Test {
2323

2424
@Test
@@ -54,11 +54,4 @@ public void call() {
5454
}).withMessage(String.format("%nExpecting code to raise a throwable."));
5555
}
5656

57-
@Test
58-
void should_fail_if_value_is_returned_by_callable_code() {
59-
// GIVEN
60-
ThrowingCallable code = () -> thenThrownBy(() -> 42);
61-
// WHEN/THEN
62-
assertThatAssertionErrorIsThrownBy(code).withMessage("Expecting code to raise a throwable, but it returned [42] instead");
63-
}
6457
}

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy