use mock to verify methods are delegated properly in ObjectAssert

Author: memoizr

src/main/kotlin/com/memozr/assertk/CharSequenceAssert.kt

@@ -11,8 +11,8 @@ enum class CharSequenceAssertTest {
 
 class CharSequenceAssert internal constructor(
         private val subject: String?,
-        override val assertion: AbstractCharSequenceAssert<*, String> = assertThat(subject))
-: AbstractAssertBuilder<CharSequenceAssert, String>(subject, CharSequenceAssert::class.java) {
+        override val assertion: AbstractCharSequenceAssert<*, String> = assertThat(subject)) :
+        AbstractAssertBuilder<CharSequenceAssert, String>(subject, CharSequenceAssert::class.java) {
 
     object onlyDigits
 

src/main/kotlin/com/memozr/assertk/MyObjectAssert.kt

@@ -0,0 +1,9 @@
+package com.memozr.assertk
+
+import org.assertj.core.api.AbstractObjectAssert
+import org.assertj.core.api.Assertions
+
+class ObjectAssert<A : Any> internal constructor(
+        actual: A?,
+        override val assertion: AbstractObjectAssert<*, A> = Assertions.assertThat(actual)) :
+        AbstractAssertBuilder<ObjectAssert<A>, A>(actual, ObjectAssert::class.java)

src/main/kotlin/com/memozr/assertk/ObjectAssert.kt

@@ -0,0 +1,103 @@
+package com.memozr.assertk
+
+import com.memozr.assertk.ObjectStuff.notNull
+import com.nhaarman.mockito_kotlin.spy
+import com.nhaarman.mockito_kotlin.verify
+import org.assertj.core.api.AbstractObjectAssert
+import org.assertj.core.api.Assertions
+import org.junit.Test
+
+class `Object assert test` {
+    val nullObject: Any? = null
+
+    lateinit var mockAssertion: AbstractObjectAssert<*, Any>
+    val _expect = object : AssertionHook {
+        override fun <A: Any> that(subjectUnderTest: A?): ObjectAssert<A> {
+            val spy: AbstractObjectAssert<*, A?>? = spy(Assertions.assertThat(subjectUnderTest))
+            mockAssertion = spy as AbstractObjectAssert<*, Any>
+            return ObjectAssert(subjectUnderTest, mockAssertion) as ObjectAssert<A>
+        }
+    }
+
+    @Test
+    fun `isEqualTo performs logical equality`() {
+        _expect that Unit isEqualTo Unit
+
+        val expected = Any()
+        _expect thatThrownBy {
+            _expect that Any() isEqualTo expected
+        }
+
+        verify(mockAssertion).isEqualTo(expected)
+    }
+
+    @Test
+    fun `isNotEqualTo performs logical inequality`() {
+        _expect that Any() isNotEqualTo Any()
+
+        _expect thatThrownBy {
+            _expect that Unit isNotEqualTo Unit
+        }
+
+        verify(mockAssertion).isNotEqualTo(Unit)
+    }
+
+    @Test
+    fun `_is notNull checks whether object is null`() {
+        _expect that Any() _is notNull
+
+        _expect thatThrownBy {
+            _expect that nullObject _is notNull
+        }
+        verify(mockAssertion).isNotNull()
+    }
+
+    @Test
+    fun `_is null checks whether object is not null`() {
+        _expect that nullObject _is null
+
+        _expect thatThrownBy {
+            _expect that Any() _is null
+        }
+        verify(mockAssertion).isNull()
+    }
+
+    @Test
+    fun `isInstance of checks for object instance`() {
+        val anObject = Any()
+
+        _expect that anObject isInstance of<Any>()
+        verify(mockAssertion).isInstanceOf(Any::class.java)
+
+        _expect thatThrownBy {
+            _expect that anObject isInstance of<Unit>()
+        }
+
+    }
+
+    @Test
+    fun `describedAs describes the object when referring to it in failure messages`() {
+        _expect thatThrownBy {
+            _expect that Any() describedAs "A labeled object" isInstance of<Unit>()
+        } hasMessageContaining "A labeled object"
+
+        verify(mockAssertion).describedAs("A labeled object")
+    }
+
+    @Test
+    fun `block _expections are supported`() {
+        _expect that Any() isSuchThat {
+            it _is notNull
+            it isInstance of<Any>()
+            it isNotEqualTo Unit
+            it isNotEqualTo Any()
+        }
+
+        _expect thatThrownBy {
+            _expect that Any() isSuchThat {
+                it _is null
+                it isInstance of<Unit>()
+            }
+        }
+    }
+}