Rename Throwable extractor functions

Prior functions are deprecated

Author: Joseph Cooper

assertk/src/commonMain/kotlin/assertk/assertions/throwable.kt

@@ -6,38 +6,59 @@ import assertk.all
 /**
  * Returns an assert on the throwable's message.
  */
-fun Assert<Throwable>.message() = having("message", Throwable::message)
+fun Assert<Throwable>.havingMessage() = having("message", Throwable::message)
+
+@Deprecated(
+    message = "Function message has been renamed to havingMessage",
+    replaceWith = ReplaceWith("havingMessage()"),
+    level = DeprecationLevel.WARNING
+)
+fun Assert<Throwable>.message() = havingMessage()
 
 /**
  * Returns an assert on the throwable's cause.
  */
-fun Assert<Throwable>.cause() = having("cause", Throwable::cause)
+fun Assert<Throwable>.havingCause() = having("cause", Throwable::cause)
+
+@Deprecated(
+    message = "Function cause has been renamed to havingCause",
+    replaceWith = ReplaceWith("havingCause()"),
+    level = DeprecationLevel.WARNING
+)
+fun Assert<Throwable>.cause() = havingCause()
 
 /**
  * Returns an assert on the throwable's root cause.
  */
-fun Assert<Throwable>.rootCause() = having("rootCause", Throwable::rootCause)
+fun Assert<Throwable>.havingRootCause() = having("rootCause", Throwable::rootCause)
+
+@Deprecated(
+    message = "Function rootCause has been renamed to havingRootCause",
+    replaceWith = ReplaceWith("havingRootCause()"),
+    level = DeprecationLevel.WARNING
+)
+fun Assert<Throwable>.rootCause() = havingRootCause()
 
 /**
  * Asserts the throwable has the expected message.
  */
 fun Assert<Throwable>.hasMessage(message: String?) {
-    message().isEqualTo(message)
+    havingMessage().isEqualTo(message)
 }
 
 /**
  * Asserts the throwable contains the expected text
  */
 fun Assert<Throwable>.messageContains(text: String) {
-    message().isNotNull().contains(text)
+    havingMessage().isNotNull().contains(text)
 }
 
 /**
  * Asserts the throwable is similar to the expected cause, checking the type and message.
  * @see [hasNoCause]
  */
 fun Assert<Throwable>.hasCause(cause: Throwable) {
-    cause().isNotNull().all {
+    havingCause().isNotNull().all {
         kClass().isEqualTo(cause::class)
         hasMessage(cause.message)
     }
@@ -48,14 +69,14 @@ fun Assert<Throwable>.hasCause(cause: Throwable) {
  * @see [hasCause]
  */
 fun Assert<Throwable>.hasNoCause() {
-    cause().isNull()
+    havingCause().isNull()
 }
 
 /**
  * Asserts the throwable is similar to the expected root cause, checking the type and message.
  */
 fun Assert<Throwable>.hasRootCause(cause: Throwable) {
-    rootCause().all {
+    havingRootCause().all {
         kClass().isEqualTo(cause::class)
         hasMessage(cause.message)
     }

assertk/src/commonTest/kotlin/test/assertk/AssertFailureTest.kt

@@ -3,7 +3,7 @@ package test.assertk
 import assertk.assertFailure
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
-import assertk.assertions.message
+import assertk.assertions.havingMessage
 import com.willowtreeapps.opentest4k.AssertionFailedError
 import test.assertk.assertions.valueOrFail
 import kotlin.coroutines.resume
@@ -28,7 +28,7 @@ class AssertFailureTest {
     fun failure_originating_subject_not_wrapped_in_result() {
         val t = assertFailsWith<AssertionFailedError> {
             assertFailure { throw RuntimeException("foo") }
-                .message()
+                .havingMessage()
                 .isEqualTo("bar")
         }
         assertTrue("RuntimeException" in t.message!!)

assertk/src/commonTest/kotlin/test/assertk/assertions/ThrowableTest.kt

@@ -14,17 +14,17 @@ class ThrowableTest {
 
     @Test
     fun extracts_message() {
-        assertEquals(subject.message, assertThat(subject).message().valueOrFail)
+        assertEquals(subject.message, assertThat(subject).havingMessage().valueOrFail)
     }
 
     @Test
     fun extracts_cause() {
-        assertEquals(cause, assertThat(subject).cause().valueOrFail)
+        assertEquals(cause, assertThat(subject).havingCause().valueOrFail)
     }
 
     @Test
     fun extracts_root_cause() {
-        assertEquals(rootCause, assertThat(subject).rootCause().valueOrFail)
+        assertEquals(rootCause, assertThat(subject).havingRootCause().valueOrFail)
     }
 
     //region hasMessage

assertk/src/commonTest/kotlin/test/assertk/assertions/support/SupportTest.kt

@@ -1,11 +1,9 @@
 package test.assertk.assertions.support
 
 import assertk.assertThat
-import assertk.assertions.hasMessage
-import assertk.assertions.isEqualTo
 import assertk.assertions.isFailure
 import assertk.assertions.isSuccess
-import assertk.assertions.message
+import assertk.assertions.havingMessage
 import assertk.assertions.support.expected
 import assertk.assertions.support.fail
 import assertk.assertions.support.show
@@ -236,7 +234,7 @@ class SupportTest {
     @Test
     fun expected_originating_throwable_included_as_cause() {
         val subject = RuntimeException()
-        val assert = assertThat(subject).message()
+        val assert = assertThat(subject).havingMessage()
         val error = assertFailsWith<AssertionFailedError> {
             assert.expected("message")
         }
@@ -246,7 +244,7 @@ class SupportTest {
     @Test
     fun expected_originating_failure_result_included_as_cause() {
         val subject = RuntimeException()
-        val assert = assertThat(Result.failure<String>(subject)).isFailure().message()
+        val assert = assertThat(Result.failure<String>(subject)).isFailure().havingMessage()
         val error = assertFailsWith<AssertionFailedError> {
             assert.expected("message")
         }