diff --git a/core/src/test/java/org/fnives/test/showcase/core/content/AddContentToFavouriteUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/content/AddContentToFavouriteUseCaseTest.kt index f146004..e930064 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/content/AddContentToFavouriteUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/content/AddContentToFavouriteUseCaseTest.kt @@ -6,6 +6,7 @@ import org.fnives.test.showcase.core.storage.content.FavouriteContentLocalStorag import org.fnives.test.showcase.model.content.ContentId import org.junit.jupiter.api.Assertions.assertThrows import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.doThrow import org.mockito.kotlin.mock @@ -27,22 +28,27 @@ internal class AddContentToFavouriteUseCaseTest { sut = AddContentToFavouriteUseCase(mockFavouriteContentLocalStorage) } + @DisplayName("WHEN_nothing_happens_THEN_the_storage_is_not_touched") @Test - fun WHEN_nothing_happens_THEN_the_storage_is_not_touched() { + fun initializationDoesntAffectStorage() { verifyZeroInteractions(mockFavouriteContentLocalStorage) } + @DisplayName("GIVEN_contentId_WHEN_called_THEN_storage_is_called") @Test - fun GIVEN_contentId_WHEN_called_THEN_storage_is_called() = runBlockingTest { + fun contentIdIsDelegatedToStorage() = runBlockingTest { sut.invoke(ContentId("a")) verify(mockFavouriteContentLocalStorage, times(1)).markAsFavourite(ContentId("a")) verifyNoMoreInteractions(mockFavouriteContentLocalStorage) } + @DisplayName("GIVEN_throwing_local_storage_WHEN_thrown_THEN_its_propagated") @Test - fun GIVEN_throwing_local_storage_WHEN_thrown_THEN_its_thrown() = runBlockingTest { - whenever(mockFavouriteContentLocalStorage.markAsFavourite(ContentId("a"))).doThrow(RuntimeException()) + fun storageThrowingIsPropagated() = runBlockingTest { + whenever(mockFavouriteContentLocalStorage.markAsFavourite(ContentId("a"))).doThrow( + RuntimeException() + ) assertThrows(RuntimeException::class.java) { runBlocking { sut.invoke(ContentId("a")) } diff --git a/core/src/test/java/org/fnives/test/showcase/core/content/FetchContentUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/content/FetchContentUseCaseTest.kt index 8256cfd..2490ec1 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/content/FetchContentUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/content/FetchContentUseCaseTest.kt @@ -4,6 +4,7 @@ import kotlinx.coroutines.runBlocking import kotlinx.coroutines.test.runBlockingTest import org.junit.jupiter.api.Assertions.assertThrows import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.doThrow import org.mockito.kotlin.mock @@ -25,21 +26,24 @@ internal class FetchContentUseCaseTest { sut = FetchContentUseCase(mockContentRepository) } + @DisplayName("WHEN nothing happens THEN the storage is not touched") @Test - fun WHEN_nothing_happens_THEN_the_storage_is_not_touched() { + fun initializationDoesntAffectRepository() { verifyZeroInteractions(mockContentRepository) } + @DisplayName("WHEN called THEN repository is called") @Test - fun WHEN_called_THEN_repository_is_called() = runBlockingTest { + fun whenCalledRepositoryIsFetched() = runBlockingTest { sut.invoke() verify(mockContentRepository, times(1)).fetch() verifyNoMoreInteractions(mockContentRepository) } + @DisplayName("GIVEN throwing local storage WHEN thrown THEN its thrown") @Test - fun GIVEN_throwing_local_storage_WHEN_thrown_THEN_its_thrown() = runBlockingTest { + fun whenRepositoryThrowsUseCaseAlsoThrows() = runBlockingTest { whenever(mockContentRepository.fetch()).doThrow(RuntimeException()) assertThrows(RuntimeException::class.java) { diff --git a/core/src/test/java/org/fnives/test/showcase/core/content/GetAllContentUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/content/GetAllContentUseCaseTest.kt index 5e36cd8..c673592 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/content/GetAllContentUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/content/GetAllContentUseCaseTest.kt @@ -15,6 +15,7 @@ import org.fnives.test.showcase.model.content.ImageUrl import org.fnives.test.showcase.model.shared.Resource import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.doReturn import org.mockito.kotlin.mock @@ -45,8 +46,9 @@ internal class GetAllContentUseCaseTest { sut = GetAllContentUseCase(mockContentRepository, mockFavouriteContentLocalStorage) } + @DisplayName("GIVEN loading AND empty favourite WHEN observed THEN loading is shown") @Test - fun GIVEN_loading_AND_empty_favourite_WHEN_observed_THEN_loading_is_shown() = + fun loadingResourceWithNoFavouritesResultsInLoadingResource() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = emptyList() contentFlow.value = Resource.Loading() @@ -57,8 +59,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN loading AND listOfFavourite WHEN observed THEN loading is shown") @Test - fun GIVEN_loading_AND_listOfFavourite_WHEN_observed_THEN_loading_is_shown() = + fun loadingResourceWithFavouritesResultsInLoadingResource() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = listOf(ContentId("a")) contentFlow.value = Resource.Loading() @@ -69,8 +72,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN error AND empty favourite WHEN observed THEN error is shown") @Test - fun GIVEN_error_AND_empty_favourite_WHEN_observed_THEN_error_is_shown() = + fun errorResourceWithNoFavouritesResultsInErrorResource() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = emptyList() val exception = Throwable() @@ -82,8 +86,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN error AND listOfFavourite WHEN observed THEN error is shown") @Test - fun GIVEN_error_AND_listOfFavourite_WHEN_observed_THEN_error_is_shown() = + fun errorResourceWithFavouritesResultsInErrorResource() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = listOf(ContentId("b")) val exception = Throwable() @@ -95,8 +100,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN listOfContent AND empty favourite WHEN observed THEN favourites are returned") @Test - fun GIVEN_listOfContent_AND_empty_favourite_WHEN_observed_THEN_favourites_are_returned() = + fun successResourceWithNoFavouritesResultsInNoFavouritedItems() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = emptyList() val content = Content(ContentId("a"), "b", "c", ImageUrl("d")) @@ -111,8 +117,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN listOfContent AND other favourite id WHEN observed THEN favourites are returned") @Test - fun GIVEN_listOfContent_AND_other_favourite_id_WHEN_observed_THEN_favourites_are_returned() = + fun successResourceWithDifferentFavouritesResultsInNoFavouritedItems() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = listOf(ContentId("x")) val content = Content(ContentId("a"), "b", "c", ImageUrl("d")) @@ -127,8 +134,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN listOfContent AND same favourite id WHEN observed THEN favourites are returned") @Test - fun GIVEN_listOfContent_AND_same_favourite_id_WHEN_observed_THEN_favourites_are_returned() = + fun successResourceWithSameFavouritesResultsInFavouritedItems() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = listOf(ContentId("a")) val content = Content(ContentId("a"), "b", "c", ImageUrl("d")) @@ -143,8 +151,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(listOf(expected), actual) } + @DisplayName("GIVEN loading then data then added favourite WHEN observed THEN loading then correct favourites are returned") @Test - fun GIVEN_loading_then_data_then_added_favourite_WHEN_observed_THEN_loading_then_correct_favourites_are_returned() = + fun whileLoadingAndAddingItemsReactsProperly() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = emptyList() val content = Content(ContentId("a"), "b", "c", ImageUrl("d")) @@ -169,8 +178,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(expected, actual.await()) } + @DisplayName("GIVEN loading then data then removed favourite WHEN observed THEN loading then correct favourites are returned") @Test - fun GIVEN_loading_then_data_then_removed_favourite_WHEN_observed_THEN_loading_then_correct_favourites_are_returned() = + fun whileLoadingAndRemovingItemsReactsProperly() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = listOf(ContentId("a")) val content = Content(ContentId("a"), "b", "c", ImageUrl("d")) @@ -195,8 +205,9 @@ internal class GetAllContentUseCaseTest { Assertions.assertEquals(expected, actual.await()) } + @DisplayName("GIVEN loading then data then loading WHEN observed THEN loading then correct favourites then loading are returned") @Test - fun GIVEN_loading_then_data_then_loading_WHEN_observed_THEN_loading_then_correct_favourites_then_loadingare_returned() = + fun loadingThenDataThenLoadingReactsProperly() = runBlockingTest(testDispatcher) { favouriteContentIdFlow.value = listOf(ContentId("a")) val content = Content(ContentId("a"), "b", "c", ImageUrl("d")) diff --git a/core/src/test/java/org/fnives/test/showcase/core/content/RemoveContentFromFavouritesUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/content/RemoveContentFromFavouritesUseCaseTest.kt index c3d18da..3b896ce 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/content/RemoveContentFromFavouritesUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/content/RemoveContentFromFavouritesUseCaseTest.kt @@ -6,6 +6,7 @@ import org.fnives.test.showcase.core.storage.content.FavouriteContentLocalStorag import org.fnives.test.showcase.model.content.ContentId import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.doThrow import org.mockito.kotlin.mock @@ -27,21 +28,24 @@ internal class RemoveContentFromFavouritesUseCaseTest { sut = RemoveContentFromFavouritesUseCase(mockFavouriteContentLocalStorage) } + @DisplayName("WHEN nothing happens THEN the storage is not touched") @Test - fun WHEN_nothing_happens_THEN_the_storage_is_not_touched() { + fun initializationDoesntAffectStorage() { verifyZeroInteractions(mockFavouriteContentLocalStorage) } + @DisplayName("GIVEN contentId WHEN called THEN storage is called") @Test - fun GIVEN_contentId_WHEN_called_THEN_storage_is_called() = runBlockingTest { + fun givenContentIdCallsStorage() = runBlockingTest { sut.invoke(ContentId("a")) verify(mockFavouriteContentLocalStorage, times(1)).deleteAsFavourite(ContentId("a")) verifyNoMoreInteractions(mockFavouriteContentLocalStorage) } + @DisplayName("GIVEN throwing local storage WHEN thrown THEN its propogated") @Test - fun GIVEN_throwing_local_storage_WHEN_thrown_THEN_its_thrown() = runBlockingTest { + fun storageExceptionThrowingIsPropogated() = runBlockingTest { whenever(mockFavouriteContentLocalStorage.deleteAsFavourite(ContentId("a"))).doThrow(RuntimeException()) Assertions.assertThrows(RuntimeException::class.java) { diff --git a/core/src/test/java/org/fnives/test/showcase/core/login/IsUserLoggedInUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/login/IsUserLoggedInUseCaseTest.kt index 3b9d0a0..1fbaaa2 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/login/IsUserLoggedInUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/login/IsUserLoggedInUseCaseTest.kt @@ -4,6 +4,7 @@ import org.fnives.test.showcase.core.storage.UserDataLocalStorage import org.fnives.test.showcase.model.session.Session import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.doReturn import org.mockito.kotlin.mock @@ -22,13 +23,15 @@ internal class IsUserLoggedInUseCaseTest { sut = IsUserLoggedInUseCase(mockUserDataLocalStorage) } + @DisplayName("WHEN nothing is called THEN storage is not called") @Test - fun WHEN_nothing_is_called_THEN_storage_is_not_called() { + fun creatingDoesntAffectStorage() { verifyZeroInteractions(mockUserDataLocalStorage) } + @DisplayName("GIVEN session data saved WHEN is user logged in checked THEN true is returned") @Test - fun GIVEN_session_data_saved_WHEN_is_user_logged_in_checked_THEN_true_is_returned() { + fun sessionInStorageResultsInLoggedIn() { whenever(mockUserDataLocalStorage.session).doReturn(Session("a", "b")) val actual = sut.invoke() @@ -36,8 +39,9 @@ internal class IsUserLoggedInUseCaseTest { Assertions.assertEquals(true, actual) } + @DisplayName("GIVEN no session data saved WHEN is user logged in checked THEN false is returned") @Test - fun GIVEN_no_session_data_saved_WHEN_is_user_logged_in_checked_THEN_false_is_returned() { + fun noSessionInStorageResultsInLoggedOut() { whenever(mockUserDataLocalStorage.session).doReturn(null) val actual = sut.invoke() @@ -45,8 +49,9 @@ internal class IsUserLoggedInUseCaseTest { Assertions.assertEquals(false, actual) } + @DisplayName("GIVEN no session THEN session THEN no session WHEN is user logged in checked over again THEN every return is correct") @Test - fun GIVEN_no_session_THEN_session_THEN_no_session_WHEN_is_user_logged_in_checked_over_again_THEN_every_return_is_correct() { + fun multipleSessionSettingsResultsInCorrectResponses() { whenever(mockUserDataLocalStorage.session).doReturn(null) val actual1 = sut.invoke() whenever(mockUserDataLocalStorage.session).doReturn(Session("", "")) diff --git a/core/src/test/java/org/fnives/test/showcase/core/login/hilt/LogoutUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/login/hilt/LogoutUseCaseTest.kt index 20ea451..c4fff8c 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/login/hilt/LogoutUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/login/hilt/LogoutUseCaseTest.kt @@ -6,6 +6,7 @@ import org.fnives.test.showcase.core.login.LogoutUseCase import org.fnives.test.showcase.core.storage.UserDataLocalStorage import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.mock import org.mockito.kotlin.times @@ -36,13 +37,15 @@ internal class LogoutUseCaseTest { testCoreComponent.inject(this) } + @DisplayName("WHEN no call THEN storage is not interacted") @Test - fun WHEN_no_call_THEN_storage_is_not_interacted() { + fun initializedDoesntAffectStorage() { verifyZeroInteractions(mockUserDataLocalStorage) } + @DisplayName("WHEN logout invoked THEN storage is cleared") @Test - fun WHEN_logout_invoked_THEN_storage_is_cleared() = runBlockingTest { + fun logoutResultsInStorageCleaning() = runBlockingTest { val repositoryBefore = contentRepository sut.invoke() diff --git a/core/src/test/java/org/fnives/test/showcase/core/login/koin/LogoutUseCaseTest.kt b/core/src/test/java/org/fnives/test/showcase/core/login/koin/LogoutUseCaseTest.kt index 78574fe..62a8aba 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/login/koin/LogoutUseCaseTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/login/koin/LogoutUseCaseTest.kt @@ -9,6 +9,7 @@ import org.fnives.test.showcase.model.network.BaseUrl import org.junit.jupiter.api.AfterEach import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.koin.core.context.startKoin import org.koin.core.context.stopKoin @@ -47,13 +48,15 @@ internal class LogoutUseCaseTest : KoinTest { stopKoin() } + @DisplayName("WHEN no call THEN storage is not interacted") @Test - fun WHEN_no_call_THEN_storage_is_not_interacted() { + fun initializedDoesntAffectStorage() { verifyZeroInteractions(mockUserDataLocalStorage) } + @DisplayName("WHEN logout invoked THEN storage is cleared") @Test - fun WHEN_logout_invoked_THEN_storage_is_cleared() = runBlockingTest { + fun logoutResultsInStorageCleaning() = runBlockingTest { val repositoryBefore = getKoin().get() sut.invoke() diff --git a/core/src/test/java/org/fnives/test/showcase/core/shared/AnswerUtilsKtTest.kt b/core/src/test/java/org/fnives/test/showcase/core/shared/AnswerUtilsKtTest.kt index 7706bb4..f56e137 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/shared/AnswerUtilsKtTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/shared/AnswerUtilsKtTest.kt @@ -7,13 +7,15 @@ import org.fnives.test.showcase.model.shared.Resource import org.fnives.test.showcase.network.shared.exceptions.NetworkException import org.fnives.test.showcase.network.shared.exceptions.ParsingException import org.junit.jupiter.api.Assertions +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test @Suppress("TestFunctionName") internal class AnswerUtilsKtTest { + @DisplayName("GIVEN network exception thrown WHEN wrapped into answer THEN answer error is returned") @Test - fun GIVEN_network_exception_thrown_WHEN_wrapped_into_answer_THEN_answer_error_is_returned() = runBlocking { + fun networkExceptionThrownResultsInError() = runBlocking { val exception = NetworkException(Throwable()) val expected = Answer.Error(exception) @@ -22,8 +24,9 @@ internal class AnswerUtilsKtTest { Assertions.assertEquals(expected, actual) } + @DisplayName("GIVEN parsing exception thrown WHEN wrapped into answer THEN answer error is returned") @Test - fun GIVEN_parsing_exception_thrown_WHEN_wrapped_into_answer_THEN_answer_error_is_returned() = runBlocking { + fun parsingExceptionThrownResultsInError() = runBlocking { val exception = ParsingException(Throwable()) val expected = Answer.Error(exception) @@ -32,8 +35,9 @@ internal class AnswerUtilsKtTest { Assertions.assertEquals(expected, actual) } + @DisplayName("GIVEN unexpected throwable thrown WHEN wrapped into answer THEN answer error is returned") @Test - fun GIVEN_parsing_throwable_thrown_WHEN_wrapped_into_answer_THEN_answer_error_is_returned() = runBlocking { + fun unexpectedExceptionThrownResultsInError() = runBlocking { val exception = Throwable() val expected = Answer.Error(UnexpectedException(exception)) @@ -42,8 +46,9 @@ internal class AnswerUtilsKtTest { Assertions.assertEquals(expected, actual) } + @DisplayName("GIVEN string WHEN wrapped into answer THEN string answer is returned") @Test - fun GIVEN_string_WHEN_wrapped_into_answer_THEN_string_answer_is_returned() = runBlocking { + fun stringIsReturnedWrappedIntoSuccess() = runBlocking { val expected = Answer.Success("banan") val actual = wrapIntoAnswer { "banan" } @@ -51,15 +56,17 @@ internal class AnswerUtilsKtTest { Assertions.assertEquals(expected, actual) } + @DisplayName("GIVEN cancellation exception WHEN wrapped into answer THEN cancellation exception is thrown") @Test - fun GIVEN_cancellation_exception_WHEN_wrapped_into_answer_THEN_cancellation_exception_is_thrown() { + fun cancellationExceptionResultsInThrowingIt() { Assertions.assertThrows(CancellationException::class.java) { runBlocking { wrapIntoAnswer { throw CancellationException() } } } } + @DisplayName("GIVEN success answer WHEN converted into resource THEN Resource success is returned") @Test - fun GIVEN_success_answer_WHEN_converted_into_resource_THEN_Resource_success_is_returned() { + fun successAnswerConvertsToSuccessResource() { val expected = Resource.Success("alma") val actual = Answer.Success("alma").mapIntoResource() @@ -67,8 +74,9 @@ internal class AnswerUtilsKtTest { Assertions.assertEquals(expected, actual) } + @DisplayName("GIVEN error answer WHEN converted into resource THEN Resource error is returned") @Test - fun GIVEN_error_answer_WHEN_converted_into_resource_THEN_Resource_error_is_returned() { + fun errorAnswerConvertsToErrorResource() { val exception = Throwable() val expected = Resource.Error(exception) diff --git a/core/src/test/java/org/fnives/test/showcase/core/storage/NetworkSessionLocalStorageAdapterTest.kt b/core/src/test/java/org/fnives/test/showcase/core/storage/NetworkSessionLocalStorageAdapterTest.kt index 6202975..df53553 100644 --- a/core/src/test/java/org/fnives/test/showcase/core/storage/NetworkSessionLocalStorageAdapterTest.kt +++ b/core/src/test/java/org/fnives/test/showcase/core/storage/NetworkSessionLocalStorageAdapterTest.kt @@ -3,6 +3,7 @@ package org.fnives.test.showcase.core.storage import org.fnives.test.showcase.model.session.Session import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.kotlin.doReturn import org.mockito.kotlin.mock @@ -23,16 +24,18 @@ internal class NetworkSessionLocalStorageAdapterTest { sut = NetworkSessionLocalStorageAdapter(mockUserDataLocalStorage) } + @DisplayName("GIVEN null as session WHEN saved THEN its delegated") @Test - fun GIVEN_null_as_session_WHEN_saved_THEN_its_delegated() { + fun settingNullSessionIsDelegated() { sut.session = null verify(mockUserDataLocalStorage, times(1)).session = null verifyNoMoreInteractions(mockUserDataLocalStorage) } + @DisplayName("GIVEN session WHEN saved THEN its delegated") @Test - fun GIVEN_session_WHEN_saved_THEN_its_delegated() { + fun settingDataAsSessionIsDelegated() { val expected = Session("a", "b") sut.session = Session("a", "b") @@ -41,8 +44,9 @@ internal class NetworkSessionLocalStorageAdapterTest { verifyNoMoreInteractions(mockUserDataLocalStorage) } + @DisplayName("WHEN session requested THEN its returned from delegated") @Test - fun WHEN_session_requested_THEN_its_returned_from_delegated() { + fun gettingSessionReturnsFromDelegate() { val expected = Session("a", "b") whenever(mockUserDataLocalStorage.session).doReturn(expected)