From c009a176c19549ca5ba8bf01136253e05ea43edd Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Mon, 27 Jan 2025 03:53:34 +0530 Subject: [PATCH 01/12] Added Test For AsyncResultSubject --- testing/build.gradle | 1 + .../testing/data/AsyncResultSubject.kt | 2 - .../testing/data/AsyncResultSubjectTest.kt | 384 ++++++++++++++++++ .../oppia/android/testing/data/BUILD.bazel | 29 ++ 4 files changed, 414 insertions(+), 2 deletions(-) create mode 100644 testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt diff --git a/testing/build.gradle b/testing/build.gradle index ae6d8acae0a..fa393b34601 100644 --- a/testing/build.gradle +++ b/testing/build.gradle @@ -103,6 +103,7 @@ dependencies { 'junit:junit:4.12', "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version", 'org.mockito:mockito-core:2.19.0', + 'org.robolectric:robolectric:4.5', project(":domain"), ) kapt( diff --git a/testing/src/main/java/org/oppia/android/testing/data/AsyncResultSubject.kt b/testing/src/main/java/org/oppia/android/testing/data/AsyncResultSubject.kt index a4f3eeb8155..f72868030b7 100644 --- a/testing/src/main/java/org/oppia/android/testing/data/AsyncResultSubject.kt +++ b/testing/src/main/java/org/oppia/android/testing/data/AsyncResultSubject.kt @@ -20,8 +20,6 @@ import com.google.common.truth.extensions.proto.LiteProtoTruth.assertThat import com.google.protobuf.MessageLite import org.oppia.android.util.data.AsyncResult -// TODO(#4236): Add tests for this class. - /** * Truth subject for verifying properties of [AsyncResult]s. * diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt new file mode 100644 index 00000000000..c1873aa0507 --- /dev/null +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -0,0 +1,384 @@ +package org.oppia.android.testing.data + +import com.google.common.truth.FailureMetadata +import com.google.common.truth.StringSubject +import com.google.common.truth.Subject +import com.google.common.truth.Truth.assertThat +import org.junit.Test +import org.junit.runner.RunWith +import org.oppia.android.testing.data.AsyncResultSubject.Companion.assertThat +import org.oppia.android.util.data.AsyncResult +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode +import org.robolectric.junit4.RobolectricTestRunner + +/** Tests for [AsyncResultSubject]. */ +@RunWith(RobolectricTestRunner::class) +@LooperMode(LooperMode.Mode.PAUSED) +@Config(manifest = Config.NONE) +class AsyncResultSubjectTest { + + @Test + fun testIsPending_withPendingResult_succeeds() { + val result = AsyncResult.Pending() + + assertThat(result).isPending() + } + + @Test + fun testIsPending_withNonPendingResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isPending() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsNotPending_withPendingResult_fails() { + val result = AsyncResult.Pending() + + val failure = assertThrows(AssertionError::class) { assertThat(result).isNotPending() } + + assertThat(failure).hasMessageThat().contains("expected not to be an instance of") + } + + @Test + fun testIsNotPending_withNonPendingResult_succeeds() { + val result = AsyncResult.Success("value") + + assertThat(result).isNotPending() + } + + @Test + fun testIsSuccess_withSuccessResult_succeeds() { + val result = AsyncResult.Success("value") + + assertThat(result).isSuccess() + } + + @Test + fun testIsSuccess_withNonSuccessResult_fails() { + val result = AsyncResult.Pending() + + val failure = assertThrows(AssertionError::class) { assertThat(result).isSuccess() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsNotSuccess_withSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isNotSuccess() } + + assertThat(failure).hasMessageThat().contains("expected not to be an instance of") + } + + @Test + fun testIsNotSuccess_withNonSuccessResult_succeeds() { + val result = AsyncResult.Pending() + + assertThat(result).isNotSuccess() + } + + @Test + fun testIsFailure_withFailureResult_succeeds() { + val result = AsyncResult.Failure(RuntimeException()) + + assertThat(result).isFailure() + } + + @Test + fun testIsFailure_withNonFailureResult_fails() { + val result = AsyncResult.Pending() + + val failure = assertThrows(AssertionError::class) { assertThat(result).isFailure() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsNotFailure_withFailureResult_fails() { + val result = AsyncResult.Failure(RuntimeException()) + + val failure = assertThrows(AssertionError::class) { assertThat(result).isNotFailure() } + + assertThat(failure).hasMessageThat().contains("expected not to be an instance of") + } + + @Test + fun testIsNotFailure_withNonFailureResult_succeeds() { + val result = AsyncResult.Pending() + + assertThat(result).isNotFailure() + } + + @Test + fun testHasSuccessValueWhere_withSuccessResult_succeeds() { + val result = AsyncResult.Success("value") + + assertThat(result).hasSuccessValueWhere { assertThat(this).isEqualTo("value") } + } + + @Test + fun testHasSuccessValueWhere_withNonSuccessResult_fails() { + val result = AsyncResult.Pending() + + val failure = assertThrows(AssertionError::class) { + assertThat(result).hasSuccessValueWhere { assertThat(this).isEqualTo("value") } + } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsSuccessThat_withSuccessResult_succeeds() { + val result = AsyncResult.Success("value") + + assertThat(result).isSuccessThat().isEqualTo("value") + } + + @Test + fun testIsSuccessThat_withNonSuccessResult_fails() { + val result = AsyncResult.Pending() + + val failure = assertThrows(AssertionError::class) { assertThat(result).isSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsStringSuccessThat_withStringSuccessResult_succeeds() { + val result = AsyncResult.Success("value") + + assertThat(result).isStringSuccessThat().isEqualTo("value") + } + + @Test + fun testIsStringSuccessThat_withNonStringSuccessResult_fails() { + val result = AsyncResult.Success(123) + + val failure = assertThrows(AssertionError::class) { assertThat(result).isStringSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsBooleanSuccessThat_withBooleanSuccessResult_succeeds() { + val result = AsyncResult.Success(true) + + assertThat(result).isBooleanSuccessThat().isTrue() + } + + @Test + fun testIsBooleanSuccessThat_withNonBooleanSuccessResult_fails() { + val result = AsyncResult.Success(123) + + val failure = assertThrows(AssertionError::class) { assertThat(result).isBooleanSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsIntSuccessThat_withIntSuccessResult_succeeds() { + val result = AsyncResult.Success(123) + + assertThat(result).isIntSuccessThat().isEqualTo(123) + } + + @Test + fun testIsIntSuccessThat_withNonIntSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isIntSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsLongSuccessThat_withLongSuccessResult_succeeds() { + val result = AsyncResult.Success(123L) + + assertThat(result).isLongSuccessThat().isEqualTo(123L) + } + + @Test + fun testIsLongSuccessThat_withNonLongSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isLongSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsFloatSuccessThat_withFloatSuccessResult_succeeds() { + val result = AsyncResult.Success(123.0f) + + assertThat(result).isFloatSuccessThat().isEqualTo(123.0f) + } + + @Test + fun testIsFloatSuccessThat_withNonFloatSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isFloatSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsDoubleSuccessThat_withDoubleSuccessResult_succeeds() { + val result = AsyncResult.Success(123.0) + + assertThat(result).isDoubleSuccessThat().isEqualTo(123.0) + } + + @Test + fun testIsDoubleSuccessThat_withNonDoubleSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isDoubleSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsProtoSuccessThat_withProtoSuccessResult_succeeds() { + val result = AsyncResult.Success(TestProto.getDefaultInstance()) + + assertThat(result).isProtoSuccessThat().isEqualTo(TestProto.getDefaultInstance()) + } + + @Test + fun testIsProtoSuccessThat_withNonProtoSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isProtoSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsIterableSuccessThat_withIterableSuccessResult_succeeds() { + val result = AsyncResult.Success(listOf("value")) + + assertThat(result).isIterableSuccessThat().containsExactly("value") + } + + @Test + fun testIsIterableSuccessThat_withNonIterableSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isIterableSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testAsMapSuccessThat_withMapSuccessResult_succeeds() { + val result = AsyncResult.Success(mapOf("key" to "value")) + + assertThat(result).asMapSuccessThat().containsExactly("key", "value") + } + + @Test + fun testAsMapSuccessThat_withNonMapSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).asMapSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testAsThrowableSuccessThat_withThrowableSuccessResult_succeeds() { + val result = AsyncResult.Success(RuntimeException("error")) + + assertThat(result).asThrowableSuccessThat().hasMessageThat().contains("error") + } + + @Test + fun testAsThrowableSuccessThat_withNonThrowableSuccessResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).asThrowableSuccessThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsFailureThat_withFailureResult_succeeds() { + val result = AsyncResult.Failure(RuntimeException("error")) + + assertThat(result).isFailureThat().hasMessageThat().contains("error") + } + + @Test + fun testIsFailureThat_withNonFailureResult_fails() { + val result = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result).isFailureThat() } + + assertThat(failure).hasMessageThat().contains("expected to be an instance of") + } + + @Test + fun testIsNewerOrSameAgeAs_withNewerResult_succeeds() { + val result1 = AsyncResult.Success("value") + Thread.sleep(10) + val result2 = AsyncResult.Success("value") + + assertThat(result2).isNewerOrSameAgeAs(result1) + } + + @Test + fun testIsNewerOrSameAgeAs_withOlderResult_fails() { + val result1 = AsyncResult.Success("value") + Thread.sleep(10) + val result2 = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result1).isNewerOrSameAgeAs(result2) } + + assertThat(failure).hasMessageThat().contains("expected to be true") + } + + @Test + fun testIsOlderThan_withOlderResult_succeeds() { + val result1 = AsyncResult.Success("value") + Thread.sleep(10) + val result2 = AsyncResult.Success("value") + + assertThat(result1).isOlderThan(result2) + } + + @Test + fun testIsOlderThan_withNewerResult_fails() { + val result1 = AsyncResult.Success("value") + Thread.sleep(10) + val result2 = AsyncResult.Success("value") + + val failure = assertThrows(AssertionError::class) { assertThat(result2).isOlderThan(result1) } + + assertThat(failure).hasMessageThat().contains("expected to be false") + } + + @Test + fun testHasSameEffectiveValueAs_withSameEffectiveValue_succeeds() { + val result1 = AsyncResult.Success("value") + val result2 = AsyncResult.Success("value") + + assertThat(result1).hasSameEffectiveValueAs(result2) + } + + @Test + fun testHasSameEffectiveValueAs_withDifferentEffectiveValue_fails() { + val result1 = AsyncResult.Success("value") + val result2 = AsyncResult.Success("different value") + + val failure = assertThrows(AssertionError::class) { assertThat(result1).hasSameEffectiveValueAs(result2) } + + assertThat(failure).hasMessageThat().contains("expected to be true") + } +} diff --git a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel index f56cf1bf1b9..ef5cada019b 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel +++ b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel @@ -33,3 +33,32 @@ oppia_android_test( "//utility/src/main/java/org/oppia/android/util/networking:debug_module", ], ) + +oppia_android_test( + name = "AsyncResultSubjectTest", + srcs = ["AsyncResultSubjectTest.kt"], + custom_package = "org.oppia.android.testing.data", + test_class = "org.oppia.android.testing.data.AsyncResultSubjectTest", + test_manifest = "//testing:test_manifest", + deps = [ + "//:dagger", + "//domain/src/main/java/org/oppia/android/domain/locale:locale_controller", + "//domain/src/main/java/org/oppia/android/domain/translation:translation_controller", + "//model/src/main/proto:languages_java_proto_lite", + "//testing", + "//testing/src/main/java/org/oppia/android/testing/data:async_result_subject", + "//testing/src/main/java/org/oppia/android/testing/data:data_provider_test_monitor", + "//testing/src/main/java/org/oppia/android/testing/robolectric:test_module", + "//testing/src/main/java/org/oppia/android/testing/threading:test_coroutine_dispatchers", + "//testing/src/main/java/org/oppia/android/testing/threading:test_module", + "//testing/src/main/java/org/oppia/android/testing/time:test_module", + "//third_party:androidx_test_ext_junit", + "//third_party:com_google_truth_truth", + "//third_party:junit_junit", + "//third_party:org_robolectric_robolectric", + "//third_party:robolectric_android-all", + "//utility/src/main/java/org/oppia/android/util/data:data_providers", + "//utility/src/main/java/org/oppia/android/util/locale:prod_module", + "//utility/src/main/java/org/oppia/android/util/networking:debug_module", + ], +) From 9dfebea36cdbf7009511e0dff5597471f582621e Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Mon, 27 Jan 2025 03:59:08 +0530 Subject: [PATCH 02/12] Reformatting --- .../testing/data/AsyncResultSubjectTest.kt | 27 ++++++++++++------- 1 file changed, 17 insertions(+), 10 deletions(-) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index c1873aa0507..42ffa2d8623 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -1,8 +1,5 @@ package org.oppia.android.testing.data -import com.google.common.truth.FailureMetadata -import com.google.common.truth.StringSubject -import com.google.common.truth.Subject import com.google.common.truth.Truth.assertThat import org.junit.Test import org.junit.runner.RunWith @@ -268,10 +265,12 @@ class AsyncResultSubjectTest { } @Test - fun testIsIterableSuccessThat_withNonIterableSuccessResult_fails() { + fun testIsIterable_withNonIterableResult_fails() { val result = AsyncResult.Success("value") - val failure = assertThrows(AssertionError::class) { assertThat(result).isIterableSuccessThat() } + val failure = assertThrows(AssertionError::class) { + assertThat(result).isIterableSuccessThat() + } assertThat(failure).hasMessageThat().contains("expected to be an instance of") } @@ -287,7 +286,9 @@ class AsyncResultSubjectTest { fun testAsMapSuccessThat_withNonMapSuccessResult_fails() { val result = AsyncResult.Success("value") - val failure = assertThrows(AssertionError::class) { assertThat(result).asMapSuccessThat() } + val failure = assertThrows(AssertionError::class) { + assertThat(result).asMapSuccessThat() + } assertThat(failure).hasMessageThat().contains("expected to be an instance of") } @@ -300,10 +301,12 @@ class AsyncResultSubjectTest { } @Test - fun testAsThrowableSuccessThat_withNonThrowableSuccessResult_fails() { + fun testIsIterable_withNonIterableResult_fails() { val result = AsyncResult.Success("value") - val failure = assertThrows(AssertionError::class) { assertThat(result).asThrowableSuccessThat() } + val failure = assertThrows(AssertionError::class) { + assertThat(result).asThrowableSuccessThat() + } assertThat(failure).hasMessageThat().contains("expected to be an instance of") } @@ -339,7 +342,9 @@ class AsyncResultSubjectTest { Thread.sleep(10) val result2 = AsyncResult.Success("value") - val failure = assertThrows(AssertionError::class) { assertThat(result1).isNewerOrSameAgeAs(result2) } + val failure = assertThrows(AssertionError::class) { + assertThat(result1).isNewerOrSameAgeAs(result2) + } assertThat(failure).hasMessageThat().contains("expected to be true") } @@ -377,7 +382,9 @@ class AsyncResultSubjectTest { val result1 = AsyncResult.Success("value") val result2 = AsyncResult.Success("different value") - val failure = assertThrows(AssertionError::class) { assertThat(result1).hasSameEffectiveValueAs(result2) } + val failure = assertThrows(AssertionError::class) { + assertThat(result1).hasSameEffectiveValueAs(result2) + } assertThat(failure).hasMessageThat().contains("expected to be true") } From 8b98691a4dd9e5b547896790554ef78b8a55b6d3 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Mon, 27 Jan 2025 04:05:28 +0530 Subject: [PATCH 03/12] Update --- testing/build.gradle | 1 - 1 file changed, 1 deletion(-) diff --git a/testing/build.gradle b/testing/build.gradle index fa393b34601..ae6d8acae0a 100644 --- a/testing/build.gradle +++ b/testing/build.gradle @@ -103,7 +103,6 @@ dependencies { 'junit:junit:4.12', "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version", 'org.mockito:mockito-core:2.19.0', - 'org.robolectric:robolectric:4.5', project(":domain"), ) kapt( From 000ca2476f2385ebefe2c3e9fd590c14e6c5edd4 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Mon, 27 Jan 2025 16:12:53 +0530 Subject: [PATCH 04/12] Added New Tests --- .../testing/data/AsyncResultSubjectTest.kt | 376 ++---------------- .../oppia/android/testing/data/BUILD.bazel | 19 +- 2 files changed, 36 insertions(+), 359 deletions(-) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 42ffa2d8623..42948070ac5 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -3,389 +3,77 @@ package org.oppia.android.testing.data import com.google.common.truth.Truth.assertThat import org.junit.Test import org.junit.runner.RunWith -import org.oppia.android.testing.data.AsyncResultSubject.Companion.assertThat +import org.robolectric.RobolectricTestRunner import org.oppia.android.util.data.AsyncResult -import org.robolectric.annotation.Config -import org.robolectric.annotation.LooperMode -import org.robolectric.junit4.RobolectricTestRunner -/** Tests for [AsyncResultSubject]. */ @RunWith(RobolectricTestRunner::class) -@LooperMode(LooperMode.Mode.PAUSED) -@Config(manifest = Config.NONE) class AsyncResultSubjectTest { @Test - fun testIsPending_withPendingResult_succeeds() { - val result = AsyncResult.Pending() + fun testAsyncResultPending_isPending() { + val pendingResult: AsyncResult = AsyncResult.Pending() - assertThat(result).isPending() + AsyncResultSubject.assertThat(pendingResult).isPending() } @Test - fun testIsPending_withNonPendingResult_fails() { - val result = AsyncResult.Success("value") + fun testAsyncResultPending_isNotSuccess() { + val pendingResult: AsyncResult = AsyncResult.Pending() - val failure = assertThrows(AssertionError::class) { assertThat(result).isPending() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsNotPending_withPendingResult_fails() { - val result = AsyncResult.Pending() - - val failure = assertThrows(AssertionError::class) { assertThat(result).isNotPending() } - - assertThat(failure).hasMessageThat().contains("expected not to be an instance of") - } - - @Test - fun testIsNotPending_withNonPendingResult_succeeds() { - val result = AsyncResult.Success("value") - - assertThat(result).isNotPending() - } - - @Test - fun testIsSuccess_withSuccessResult_succeeds() { - val result = AsyncResult.Success("value") - - assertThat(result).isSuccess() - } - - @Test - fun testIsSuccess_withNonSuccessResult_fails() { - val result = AsyncResult.Pending() - - val failure = assertThrows(AssertionError::class) { assertThat(result).isSuccess() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsNotSuccess_withSuccessResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result).isNotSuccess() } - - assertThat(failure).hasMessageThat().contains("expected not to be an instance of") - } - - @Test - fun testIsNotSuccess_withNonSuccessResult_succeeds() { - val result = AsyncResult.Pending() - - assertThat(result).isNotSuccess() - } - - @Test - fun testIsFailure_withFailureResult_succeeds() { - val result = AsyncResult.Failure(RuntimeException()) - - assertThat(result).isFailure() - } - - @Test - fun testIsFailure_withNonFailureResult_fails() { - val result = AsyncResult.Pending() - - val failure = assertThrows(AssertionError::class) { assertThat(result).isFailure() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsNotFailure_withFailureResult_fails() { - val result = AsyncResult.Failure(RuntimeException()) - - val failure = assertThrows(AssertionError::class) { assertThat(result).isNotFailure() } - - assertThat(failure).hasMessageThat().contains("expected not to be an instance of") + AsyncResultSubject.assertThat(pendingResult).isNotSuccess() } @Test - fun testIsNotFailure_withNonFailureResult_succeeds() { - val result = AsyncResult.Pending() + fun testAsyncResultSuccess_isSuccess() { + val successResult: AsyncResult = AsyncResult.Success("Success value") - assertThat(result).isNotFailure() + AsyncResultSubject.assertThat(successResult).isSuccess() } @Test - fun testHasSuccessValueWhere_withSuccessResult_succeeds() { - val result = AsyncResult.Success("value") + fun testAsyncResultSuccess_hasSuccessValueWhere_matchesExpected() { + val successResult: AsyncResult = AsyncResult.Success("Success value") - assertThat(result).hasSuccessValueWhere { assertThat(this).isEqualTo("value") } - } - - @Test - fun testHasSuccessValueWhere_withNonSuccessResult_fails() { - val result = AsyncResult.Pending() - - val failure = assertThrows(AssertionError::class) { - assertThat(result).hasSuccessValueWhere { assertThat(this).isEqualTo("value") } + AsyncResultSubject.assertThat(successResult).hasSuccessValueWhere { + // Here we are verifying that the value is "Success value" + assertThat(this).isEqualTo("Success value") } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsSuccessThat_withSuccessResult_succeeds() { - val result = AsyncResult.Success("value") - - assertThat(result).isSuccessThat().isEqualTo("value") - } - - @Test - fun testIsSuccessThat_withNonSuccessResult_fails() { - val result = AsyncResult.Pending() - - val failure = assertThrows(AssertionError::class) { assertThat(result).isSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsStringSuccessThat_withStringSuccessResult_succeeds() { - val result = AsyncResult.Success("value") - - assertThat(result).isStringSuccessThat().isEqualTo("value") - } - - @Test - fun testIsStringSuccessThat_withNonStringSuccessResult_fails() { - val result = AsyncResult.Success(123) - - val failure = assertThrows(AssertionError::class) { assertThat(result).isStringSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") } @Test - fun testIsBooleanSuccessThat_withBooleanSuccessResult_succeeds() { - val result = AsyncResult.Success(true) + fun testAsyncResultSuccess_isStringSuccessThat() { + val successResult: AsyncResult = AsyncResult.Success("Success value") - assertThat(result).isBooleanSuccessThat().isTrue() + AsyncResultSubject.assertThat(successResult).isStringSuccessThat().isEqualTo("Success value") } @Test - fun testIsBooleanSuccessThat_withNonBooleanSuccessResult_fails() { - val result = AsyncResult.Success(123) - - val failure = assertThrows(AssertionError::class) { assertThat(result).isBooleanSuccessThat() } + fun testAsyncResultFailure_isFailure() { + val failureResult: AsyncResult = AsyncResult.Failure(Throwable("Error")) - assertThat(failure).hasMessageThat().contains("expected to be an instance of") + AsyncResultSubject.assertThat(failureResult).isFailure() } @Test - fun testIsIntSuccessThat_withIntSuccessResult_succeeds() { - val result = AsyncResult.Success(123) + fun testAsyncResultFailure_isFailureThat_matchesExpectedError() { + val failureResult: AsyncResult = AsyncResult.Failure(Throwable("Error")) - assertThat(result).isIntSuccessThat().isEqualTo(123) + AsyncResultSubject.assertThat(failureResult).isFailureThat().hasMessageThat().contains("Error") } @Test - fun testIsIntSuccessThat_withNonIntSuccessResult_fails() { - val result = AsyncResult.Success("value") + fun testAsyncResultSuccess_isNewerOrSameAgeAs() { + val successResult1: AsyncResult = AsyncResult.Success("First") + val successResult2: AsyncResult = AsyncResult.Success("Second") - val failure = assertThrows(AssertionError::class) { assertThat(result).isIntSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") + AsyncResultSubject.assertThat(successResult1).isNewerOrSameAgeAs(successResult2) } @Test - fun testIsLongSuccessThat_withLongSuccessResult_succeeds() { - val result = AsyncResult.Success(123L) - - assertThat(result).isLongSuccessThat().isEqualTo(123L) - } - - @Test - fun testIsLongSuccessThat_withNonLongSuccessResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result).isLongSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsFloatSuccessThat_withFloatSuccessResult_succeeds() { - val result = AsyncResult.Success(123.0f) - - assertThat(result).isFloatSuccessThat().isEqualTo(123.0f) - } - - @Test - fun testIsFloatSuccessThat_withNonFloatSuccessResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result).isFloatSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsDoubleSuccessThat_withDoubleSuccessResult_succeeds() { - val result = AsyncResult.Success(123.0) - - assertThat(result).isDoubleSuccessThat().isEqualTo(123.0) - } - - @Test - fun testIsDoubleSuccessThat_withNonDoubleSuccessResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result).isDoubleSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsProtoSuccessThat_withProtoSuccessResult_succeeds() { - val result = AsyncResult.Success(TestProto.getDefaultInstance()) - - assertThat(result).isProtoSuccessThat().isEqualTo(TestProto.getDefaultInstance()) - } - - @Test - fun testIsProtoSuccessThat_withNonProtoSuccessResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result).isProtoSuccessThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsIterableSuccessThat_withIterableSuccessResult_succeeds() { - val result = AsyncResult.Success(listOf("value")) - - assertThat(result).isIterableSuccessThat().containsExactly("value") - } - - @Test - fun testIsIterable_withNonIterableResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { - assertThat(result).isIterableSuccessThat() - } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testAsMapSuccessThat_withMapSuccessResult_succeeds() { - val result = AsyncResult.Success(mapOf("key" to "value")) - - assertThat(result).asMapSuccessThat().containsExactly("key", "value") - } - - @Test - fun testAsMapSuccessThat_withNonMapSuccessResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { - assertThat(result).asMapSuccessThat() - } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testAsThrowableSuccessThat_withThrowableSuccessResult_succeeds() { - val result = AsyncResult.Success(RuntimeException("error")) - - assertThat(result).asThrowableSuccessThat().hasMessageThat().contains("error") - } - - @Test - fun testIsIterable_withNonIterableResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { - assertThat(result).asThrowableSuccessThat() - } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsFailureThat_withFailureResult_succeeds() { - val result = AsyncResult.Failure(RuntimeException("error")) - - assertThat(result).isFailureThat().hasMessageThat().contains("error") - } - - @Test - fun testIsFailureThat_withNonFailureResult_fails() { - val result = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result).isFailureThat() } - - assertThat(failure).hasMessageThat().contains("expected to be an instance of") - } - - @Test - fun testIsNewerOrSameAgeAs_withNewerResult_succeeds() { - val result1 = AsyncResult.Success("value") - Thread.sleep(10) - val result2 = AsyncResult.Success("value") - - assertThat(result2).isNewerOrSameAgeAs(result1) - } - - @Test - fun testIsNewerOrSameAgeAs_withOlderResult_fails() { - val result1 = AsyncResult.Success("value") - Thread.sleep(10) - val result2 = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { - assertThat(result1).isNewerOrSameAgeAs(result2) - } - - assertThat(failure).hasMessageThat().contains("expected to be true") - } - - @Test - fun testIsOlderThan_withOlderResult_succeeds() { - val result1 = AsyncResult.Success("value") - Thread.sleep(10) - val result2 = AsyncResult.Success("value") - - assertThat(result1).isOlderThan(result2) - } - - @Test - fun testIsOlderThan_withNewerResult_fails() { - val result1 = AsyncResult.Success("value") - Thread.sleep(10) - val result2 = AsyncResult.Success("value") - - val failure = assertThrows(AssertionError::class) { assertThat(result2).isOlderThan(result1) } - - assertThat(failure).hasMessageThat().contains("expected to be false") - } - - @Test - fun testHasSameEffectiveValueAs_withSameEffectiveValue_succeeds() { - val result1 = AsyncResult.Success("value") - val result2 = AsyncResult.Success("value") - - assertThat(result1).hasSameEffectiveValueAs(result2) - } - - @Test - fun testHasSameEffectiveValueAs_withDifferentEffectiveValue_fails() { - val result1 = AsyncResult.Success("value") - val result2 = AsyncResult.Success("different value") - - val failure = assertThrows(AssertionError::class) { - assertThat(result1).hasSameEffectiveValueAs(result2) - } + fun testAsyncResultFailure_hasSameEffectiveValueAs_differentError() { + val failureResult1: AsyncResult = AsyncResult.Failure(Throwable("Error")) + val failureResult2: AsyncResult = AsyncResult.Failure(Throwable("Different Error")) - assertThat(failure).hasMessageThat().contains("expected to be true") + AsyncResultSubject.assertThat(failureResult1).hasSameEffectiveValueAs(failureResult2).isFalse() } } diff --git a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel index ef5cada019b..f807ed4e527 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel +++ b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel @@ -34,6 +34,7 @@ oppia_android_test( ], ) +# Adding test for AsyncResultSubject oppia_android_test( name = "AsyncResultSubjectTest", srcs = ["AsyncResultSubjectTest.kt"], @@ -41,24 +42,12 @@ oppia_android_test( test_class = "org.oppia.android.testing.data.AsyncResultSubjectTest", test_manifest = "//testing:test_manifest", deps = [ - "//:dagger", - "//domain/src/main/java/org/oppia/android/domain/locale:locale_controller", - "//domain/src/main/java/org/oppia/android/domain/translation:translation_controller", - "//model/src/main/proto:languages_java_proto_lite", - "//testing", "//testing/src/main/java/org/oppia/android/testing/data:async_result_subject", - "//testing/src/main/java/org/oppia/android/testing/data:data_provider_test_monitor", "//testing/src/main/java/org/oppia/android/testing/robolectric:test_module", - "//testing/src/main/java/org/oppia/android/testing/threading:test_coroutine_dispatchers", - "//testing/src/main/java/org/oppia/android/testing/threading:test_module", - "//testing/src/main/java/org/oppia/android/testing/time:test_module", - "//third_party:androidx_test_ext_junit", "//third_party:com_google_truth_truth", "//third_party:junit_junit", - "//third_party:org_robolectric_robolectric", "//third_party:robolectric_android-all", - "//utility/src/main/java/org/oppia/android/util/data:data_providers", - "//utility/src/main/java/org/oppia/android/util/locale:prod_module", - "//utility/src/main/java/org/oppia/android/util/networking:debug_module", - ], + "//third_party:org_robolectric_robolectric", + "//third_party:androidx_test_ext_junit", + ] ) From 6ab4e6d1858c79871df53165c7128a5a56e7e943 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Mon, 27 Jan 2025 16:13:47 +0530 Subject: [PATCH 05/12] Reformatting --- .../org/oppia/android/testing/data/AsyncResultSubjectTest.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 42948070ac5..78e5c734a03 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -3,8 +3,8 @@ package org.oppia.android.testing.data import com.google.common.truth.Truth.assertThat import org.junit.Test import org.junit.runner.RunWith -import org.robolectric.RobolectricTestRunner import org.oppia.android.util.data.AsyncResult +import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class AsyncResultSubjectTest { From ae62e8863b98fbd6308704f7b3440a25431dd9c2 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Mon, 27 Jan 2025 18:42:47 +0530 Subject: [PATCH 06/12] Resolved Klint Issue --- .../test/java/org/oppia/android/testing/data/BUILD.bazel | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel index f807ed4e527..f9494517429 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel +++ b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel @@ -44,10 +44,10 @@ oppia_android_test( deps = [ "//testing/src/main/java/org/oppia/android/testing/data:async_result_subject", "//testing/src/main/java/org/oppia/android/testing/robolectric:test_module", + "//third_party:androidx_test_ext_junit", "//third_party:com_google_truth_truth", "//third_party:junit_junit", - "//third_party:robolectric_android-all", "//third_party:org_robolectric_robolectric", - "//third_party:androidx_test_ext_junit", - ] + "//third_party:robolectric_android-all", + ], ) From aa623bc074bc43cd2ae249f0513e87acc5ff02d0 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Thu, 30 Jan 2025 19:33:20 +0530 Subject: [PATCH 07/12] Added More Tests --- scripts/assets/test_file_exemptions.textproto | 4 - .../testing/data/AsyncResultSubjectTest.kt | 111 +++++++++++++----- .../oppia/android/testing/data/BUILD.bazel | 1 - 3 files changed, 83 insertions(+), 33 deletions(-) diff --git a/scripts/assets/test_file_exemptions.textproto b/scripts/assets/test_file_exemptions.textproto index 8529317da0b..aef50d2a10b 100644 --- a/scripts/assets/test_file_exemptions.textproto +++ b/scripts/assets/test_file_exemptions.textproto @@ -4010,10 +4010,6 @@ test_file_exemption { exempted_file_path: "testing/src/main/java/org/oppia/android/testing/TextInputActionTestActivity.kt" test_file_not_required: true } -test_file_exemption { - exempted_file_path: "testing/src/main/java/org/oppia/android/testing/data/AsyncResultSubject.kt" - test_file_not_required: true -} test_file_exemption { exempted_file_path: "testing/src/main/java/org/oppia/android/testing/environment/TestEnvironmentConfig.kt" test_file_not_required: true diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 78e5c734a03..752ce836792 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -5,75 +5,130 @@ import org.junit.Test import org.junit.runner.RunWith import org.oppia.android.util.data.AsyncResult import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSystemClock @RunWith(RobolectricTestRunner::class) +@Config(shadows = [ShadowSystemClock::class]) class AsyncResultSubjectTest { + private val pendingResult: AsyncResult = AsyncResult.Pending() + private val successResult: AsyncResult = AsyncResult.Success("Some string") + private val failureResult: AsyncResult = AsyncResult.Failure(RuntimeException("Error message")) @Test - fun testAsyncResultPending_isPending() { - val pendingResult: AsyncResult = AsyncResult.Pending() - + fun testAsyncResultSubject_pendingResult_checkIsPending() { AsyncResultSubject.assertThat(pendingResult).isPending() } @Test - fun testAsyncResultPending_isNotSuccess() { - val pendingResult: AsyncResult = AsyncResult.Pending() - + fun testAsyncResultSubject_pendingResult_checkIsNotSuccess() { AsyncResultSubject.assertThat(pendingResult).isNotSuccess() } @Test - fun testAsyncResultSuccess_isSuccess() { - val successResult: AsyncResult = AsyncResult.Success("Success value") + fun testAsyncResultSubject_pendingResult_checkIsNotFailure() { + AsyncResultSubject.assertThat(pendingResult).isNotFailure() + } + @Test + fun testAsyncResultSubject_successResult_checkIsNotPending() { + AsyncResultSubject.assertThat(successResult).isNotPending() + } + + @Test + fun testAsyncResultSubject_successResult_checkIsSuccess() { AsyncResultSubject.assertThat(successResult).isSuccess() } @Test - fun testAsyncResultSuccess_hasSuccessValueWhere_matchesExpected() { - val successResult: AsyncResult = AsyncResult.Success("Success value") + fun testAsyncResultSubject_successResult_checkIsNotFailure() { + AsyncResultSubject.assertThat(successResult).isNotFailure() + } + @Test + fun testAsyncResultSubject_successResult_checkSuccessValueMatches() { AsyncResultSubject.assertThat(successResult).hasSuccessValueWhere { - // Here we are verifying that the value is "Success value" - assertThat(this).isEqualTo("Success value") + assertThat(this).isEqualTo("Some string") } } @Test - fun testAsyncResultSuccess_isStringSuccessThat() { - val successResult: AsyncResult = AsyncResult.Success("Success value") - - AsyncResultSubject.assertThat(successResult).isStringSuccessThat().isEqualTo("Success value") + fun testAsyncResultSubject_successResult_checkIsStringSuccessThat() { + AsyncResultSubject.assertThat(successResult) + .isStringSuccessThat() + .isEqualTo("Some string") } @Test - fun testAsyncResultFailure_isFailure() { - val failureResult: AsyncResult = AsyncResult.Failure(Throwable("Error")) - + fun testAsyncResultSubject_failureResult_checkIsFailure() { AsyncResultSubject.assertThat(failureResult).isFailure() } @Test - fun testAsyncResultFailure_isFailureThat_matchesExpectedError() { - val failureResult: AsyncResult = AsyncResult.Failure(Throwable("Error")) + fun testAsyncResultSubject_failureResult_checkIsNotSuccess() { + AsyncResultSubject.assertThat(failureResult).isNotSuccess() + } + + @Test + fun testAsyncResultSubject_failureResult_checkIsNotPending() { + AsyncResultSubject.assertThat(failureResult).isNotPending() + } - AsyncResultSubject.assertThat(failureResult).isFailureThat().hasMessageThat().contains("Error") + @Test + fun testAsyncResultSubject_failureResult_checkErrorMessageMatches() { + AsyncResultSubject.assertThat(failureResult) + .isFailureThat() + .hasMessageThat() + .contains("Error message") } @Test - fun testAsyncResultSuccess_isNewerOrSameAgeAs() { + fun testAsyncResultSubject_twoSuccessResults_checkNewerOrSameAge() { val successResult1: AsyncResult = AsyncResult.Success("First") val successResult2: AsyncResult = AsyncResult.Success("Second") - AsyncResultSubject.assertThat(successResult1).isNewerOrSameAgeAs(successResult2) } @Test - fun testAsyncResultFailure_hasSameEffectiveValueAs_differentError() { - val failureResult1: AsyncResult = AsyncResult.Failure(Throwable("Error")) - val failureResult2: AsyncResult = AsyncResult.Failure(Throwable("Different Error")) + fun testAsyncResultSubject_sameSuccessValue_checkHasSameEffectiveValue() { + val successResult1: AsyncResult = AsyncResult.Success("Same value") + val successResult2: AsyncResult = AsyncResult.Success("Same value") + AsyncResultSubject.assertThat(successResult1) + .hasSameEffectiveValueAs(successResult2) + .isTrue() + } + + @Test + fun testAsyncResultSubject_differentSuccessValues_checkHasDifferentEffectiveValue() { + val successResult1: AsyncResult = AsyncResult.Success("First value") + val successResult2: AsyncResult = AsyncResult.Success("Second value") + AsyncResultSubject.assertThat(successResult1) + .hasSameEffectiveValueAs(successResult2) + .isFalse() + } + + @Test + fun testAsyncResultSubject_intSuccess_checkIsIntSuccessThat() { + val intResult: AsyncResult = AsyncResult.Success(42) + AsyncResultSubject.assertThat(intResult) + .isIntSuccessThat() + .isEqualTo(42) + } - AsyncResultSubject.assertThat(failureResult1).hasSameEffectiveValueAs(failureResult2).isFalse() + @Test + fun testAsyncResultSubject_booleanSuccess_checkIsBooleanSuccessThat() { + val boolResult: AsyncResult = AsyncResult.Success(true) + AsyncResultSubject.assertThat(boolResult) + .isBooleanSuccessThat() + .isTrue() + } + + @Test + fun testAsyncResultSubject_differentFailureMessages_checkHasDifferentEffectiveValue() { + val failureResult1: AsyncResult = AsyncResult.Failure(RuntimeException("Error 1")) + val failureResult2: AsyncResult = AsyncResult.Failure(RuntimeException("Error 2")) + AsyncResultSubject.assertThat(failureResult1) + .hasSameEffectiveValueAs(failureResult2) + .isFalse() } } diff --git a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel index f9494517429..c228eb78f72 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel +++ b/testing/src/test/java/org/oppia/android/testing/data/BUILD.bazel @@ -34,7 +34,6 @@ oppia_android_test( ], ) -# Adding test for AsyncResultSubject oppia_android_test( name = "AsyncResultSubjectTest", srcs = ["AsyncResultSubjectTest.kt"], From 200f7e0f265bfab90b14492597b7416c1c132ef8 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Thu, 30 Jan 2025 19:34:51 +0530 Subject: [PATCH 08/12] Format --- .../org/oppia/android/testing/data/AsyncResultSubjectTest.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 752ce836792..e9bac9e81a2 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -13,7 +13,8 @@ import org.robolectric.shadows.ShadowSystemClock class AsyncResultSubjectTest { private val pendingResult: AsyncResult = AsyncResult.Pending() private val successResult: AsyncResult = AsyncResult.Success("Some string") - private val failureResult: AsyncResult = AsyncResult.Failure(RuntimeException("Error message")) + private val failureResult: AsyncResult = + AsyncResult.Failure(RuntimeException("Error message")) @Test fun testAsyncResultSubject_pendingResult_checkIsPending() { From 36195e7748e7914d8a6883962e78d1d842c24d76 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Thu, 30 Jan 2025 20:09:20 +0530 Subject: [PATCH 09/12] All Test --- .../testing/data/AsyncResultSubjectTest.kt | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index e9bac9e81a2..99edd6bd0d3 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -132,4 +132,52 @@ class AsyncResultSubjectTest { .hasSameEffectiveValueAs(failureResult2) .isFalse() } + + @Test + fun testAsyncResultSubject_pendingResult_checkIsNotSuccessOrFailure() { + AsyncResultSubject.assertThat(pendingResult).isNotSuccess() + AsyncResultSubject.assertThat(pendingResult).isNotFailure() + } + + @Test + fun testAsyncResultSubject_successResult_checkIsSuccessThat() { + AsyncResultSubject.assertThat(successResult).isSuccessThat().isEqualTo("Some string") + } + + @Test + fun testAsyncResultSubject_failureResult_checkIsFailureThatError() { + AsyncResultSubject.assertThat(failureResult) + .isFailureThat() + .hasMessageThat() + .contains("Error message") + } + + @Test + fun testAsyncResultSubject_pendingResult_checkHasSameEffectiveValueAs() { + val anotherPending: AsyncResult = AsyncResult.Pending() + AsyncResultSubject.assertThat(pendingResult).hasSameEffectiveValueAs(anotherPending) + } + + @Test + fun testAsyncResultSubject_pendingResult_checkHasDifferentEffectiveValue() { + val successResult: AsyncResult = AsyncResult.Success("Some string") + AsyncResultSubject.assertThat(pendingResult) + .hasSameEffectiveValueAs(successResult) + .isFalse() + } + + @Test + fun testAsyncResultSubject_isComparableSuccessThat_checkIntValue() { + val intResult: AsyncResult = AsyncResult.Success(100) + AsyncResultSubject.assertThat(intResult) + .isComparableSuccessThat() + .isEqualTo(100) + } + + @Test + fun testAsyncResultSubject_successResult_checkStringSuccessValue() { + AsyncResultSubject.assertThat(successResult) + .isSuccessThat() + .isEqualTo("Some string") + } } From e38706600df67358758455a0fd14ef3ea414fa5e Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Thu, 30 Jan 2025 23:18:20 +0530 Subject: [PATCH 10/12] Rerun CI Checks --- .../org/oppia/android/testing/data/AsyncResultSubjectTest.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 99edd6bd0d3..728bb58164b 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -31,6 +31,7 @@ class AsyncResultSubjectTest { AsyncResultSubject.assertThat(pendingResult).isNotFailure() } + @Test fun testAsyncResultSubject_successResult_checkIsNotPending() { AsyncResultSubject.assertThat(successResult).isNotPending() From a4ae9d8895d521445899f368bd110038b166d213 Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Thu, 30 Jan 2025 23:19:12 +0530 Subject: [PATCH 11/12] Klint --- .../org/oppia/android/testing/data/AsyncResultSubjectTest.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 728bb58164b..99edd6bd0d3 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -31,7 +31,6 @@ class AsyncResultSubjectTest { AsyncResultSubject.assertThat(pendingResult).isNotFailure() } - @Test fun testAsyncResultSubject_successResult_checkIsNotPending() { AsyncResultSubject.assertThat(successResult).isNotPending() From c1f15219720f8bcb20c90b632a1e4a49af5278ed Mon Sep 17 00:00:00 2001 From: TanishMoral11 Date: Fri, 31 Jan 2025 00:33:37 +0530 Subject: [PATCH 12/12] All Tests --- .../testing/data/AsyncResultSubjectTest.kt | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt index 99edd6bd0d3..5fe8dd132c8 100644 --- a/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt +++ b/testing/src/test/java/org/oppia/android/testing/data/AsyncResultSubjectTest.kt @@ -180,4 +180,29 @@ class AsyncResultSubjectTest { .isSuccessThat() .isEqualTo("Some string") } + + @Test + fun testAsyncResultSubject_failureResult_checkErrorMessageMatchesExact() { + AsyncResultSubject.assertThat(failureResult) + .isFailureThat() + .hasMessageThat() + .isEqualTo("Error message") + } + + @Test + fun testAsyncResultSubject_pendingResult_checkHasNullEffectiveValue() { + val nullPending: AsyncResult = AsyncResult.Pending() + AsyncResultSubject.assertThat(pendingResult) + .hasSameEffectiveValueAs(nullPending) + .isTrue() + } + + @Test + fun testAsyncResultSubject_pendingResult_checkIsNotSameEffectiveValue() { + val pending1: AsyncResult = AsyncResult.Pending() + val pending2: AsyncResult = AsyncResult.Pending() + AsyncResultSubject.assertThat(pending1) + .hasSameEffectiveValueAs(pending2) + .isTrue() + } }