Add domain use case unit tests

app/src/test/java/com/d4rk/androidtutorials/java/domain/about/GetCurrentYearUseCaseTest.java

@@ -1,6 +1,8 @@
 package com.d4rk.androidtutorials.java.domain.about;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -22,4 +24,26 @@ public void invokeReturnsRepositoryCurrentYear() {
         assertEquals("2030", result);
         verify(repository).getCurrentYear();
     }
+
+    @Test
+    public void invokeAllowsNullYear() {
+        AboutRepository repository = mock(AboutRepository.class);
+        when(repository.getCurrentYear()).thenReturn(null);
+        GetCurrentYearUseCase useCase = new GetCurrentYearUseCase(repository);
+
+        String result = useCase.invoke();
+
+        assertNull(result);
+        verify(repository).getCurrentYear();
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        AboutRepository repository = mock(AboutRepository.class);
+        when(repository.getCurrentYear()).thenThrow(new IllegalStateException("boom"));
+        GetCurrentYearUseCase useCase = new GetCurrentYearUseCase(repository);
+
+        assertThrows(IllegalStateException.class, useCase::invoke);
+        verify(repository).getCurrentYear();
+    }
 }

app/src/test/java/com/d4rk/androidtutorials/java/domain/about/GetVersionStringUseCaseTest.java

@@ -1,6 +1,8 @@
 package com.d4rk.androidtutorials.java.domain.about;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -22,4 +24,26 @@ public void invokeReturnsRepositoryVersionString() {
         assertEquals("v9.9.9", result);
         verify(repository).getVersionString();
     }
+
+    @Test
+    public void invokeAllowsNullVersionString() {
+        AboutRepository repository = mock(AboutRepository.class);
+        when(repository.getVersionString()).thenReturn(null);
+        GetVersionStringUseCase useCase = new GetVersionStringUseCase(repository);
+
+        String result = useCase.invoke();
+
+        assertNull(result);
+        verify(repository).getVersionString();
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        AboutRepository repository = mock(AboutRepository.class);
+        when(repository.getVersionString()).thenThrow(new IllegalArgumentException("error"));
+        GetVersionStringUseCase useCase = new GetVersionStringUseCase(repository);
+
+        assertThrows(IllegalArgumentException.class, useCase::invoke);
+        verify(repository).getVersionString();
+    }
 }

app/src/test/java/com/d4rk/androidtutorials/java/domain/android/GetLessonUseCaseTest.java

@@ -1,6 +1,8 @@
 package com.d4rk.androidtutorials.java.domain.android;
 
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -23,5 +25,27 @@ public void invokeReturnsLesson() {
         assertSame(lesson, result);
         verify(repository).getLesson("intro");
     }
+
+    @Test
+    public void invokeReturnsNullWhenRepositoryReturnsNull() {
+        LessonRepository repository = mock(LessonRepository.class);
+        when(repository.getLesson("advanced")).thenReturn(null);
+        GetLessonUseCase useCase = new GetLessonUseCase(repository);
+
+        LessonRepository.Lesson result = useCase.invoke("advanced");
+
+        assertNull(result);
+        verify(repository).getLesson("advanced");
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        LessonRepository repository = mock(LessonRepository.class);
+        when(repository.getLesson("intro")).thenThrow(new IllegalStateException("failure"));
+        GetLessonUseCase useCase = new GetLessonUseCase(repository);
+
+        assertThrows(IllegalStateException.class, () -> useCase.invoke("intro"));
+        verify(repository).getLesson("intro");
+    }
 }
 

app/src/test/java/com/d4rk/androidtutorials/java/domain/help/LaunchReviewFlowUseCaseTest.java

@@ -0,0 +1,63 @@
+package com.d4rk.androidtutorials.java.domain.help;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.app.Activity;
+
+import com.d4rk.androidtutorials.java.data.repository.HelpRepository;
+import com.google.android.play.core.review.ReviewInfo;
+
+import org.junit.Test;
+
+public class LaunchReviewFlowUseCaseTest {
+
+    @Test
+    public void invokeDelegatesToRepository() {
+        HelpRepository repository = mock(HelpRepository.class);
+        Activity activity = mock(Activity.class);
+        ReviewInfo info = mock(ReviewInfo.class);
+        LaunchReviewFlowUseCase useCase = new LaunchReviewFlowUseCase(repository);
+
+        useCase.invoke(activity, info);
+
+        verify(repository).launchReviewFlow(activity, info);
+    }
+
+    @Test
+    public void invokeAllowsNullActivity() {
+        HelpRepository repository = mock(HelpRepository.class);
+        ReviewInfo info = mock(ReviewInfo.class);
+        LaunchReviewFlowUseCase useCase = new LaunchReviewFlowUseCase(repository);
+
+        useCase.invoke(null, info);
+
+        verify(repository).launchReviewFlow(null, info);
+    }
+
+    @Test
+    public void invokeAllowsNullReviewInfo() {
+        HelpRepository repository = mock(HelpRepository.class);
+        Activity activity = mock(Activity.class);
+        LaunchReviewFlowUseCase useCase = new LaunchReviewFlowUseCase(repository);
+
+        useCase.invoke(activity, null);
+
+        verify(repository).launchReviewFlow(activity, null);
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        HelpRepository repository = mock(HelpRepository.class);
+        Activity activity = mock(Activity.class);
+        ReviewInfo info = mock(ReviewInfo.class);
+        LaunchReviewFlowUseCase useCase = new LaunchReviewFlowUseCase(repository);
+        doThrow(new IllegalArgumentException("failure"))
+                .when(repository).launchReviewFlow(activity, info);
+
+        assertThrows(IllegalArgumentException.class, () -> useCase.invoke(activity, info));
+        verify(repository).launchReviewFlow(activity, info);
+    }
+}

app/src/test/java/com/d4rk/androidtutorials/java/domain/help/RequestReviewFlowUseCaseTest.java

@@ -0,0 +1,46 @@
+package com.d4rk.androidtutorials.java.domain.help;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.d4rk.androidtutorials.java.data.repository.HelpRepository;
+
+import org.junit.Test;
+
+public class RequestReviewFlowUseCaseTest {
+
+    @Test
+    public void invokeDelegatesToRepository() {
+        HelpRepository repository = mock(HelpRepository.class);
+        HelpRepository.OnReviewInfoListener listener = mock(HelpRepository.OnReviewInfoListener.class);
+        RequestReviewFlowUseCase useCase = new RequestReviewFlowUseCase(repository);
+
+        useCase.invoke(listener);
+
+        verify(repository).requestReviewFlow(listener);
+    }
+
+    @Test
+    public void invokeAcceptsNullListener() {
+        HelpRepository repository = mock(HelpRepository.class);
+        RequestReviewFlowUseCase useCase = new RequestReviewFlowUseCase(repository);
+
+        useCase.invoke(null);
+
+        verify(repository).requestReviewFlow(null);
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        HelpRepository repository = mock(HelpRepository.class);
+        HelpRepository.OnReviewInfoListener listener = mock(HelpRepository.OnReviewInfoListener.class);
+        RequestReviewFlowUseCase useCase = new RequestReviewFlowUseCase(repository);
+        doThrow(new IllegalStateException("error"))
+                .when(repository).requestReviewFlow(listener);
+
+        assertThrows(IllegalStateException.class, () -> useCase.invoke(listener));
+        verify(repository).requestReviewFlow(listener);
+    }
+}

app/src/test/java/com/d4rk/androidtutorials/java/domain/home/GetAppPlayStoreUrlUseCaseTest.java

@@ -1,6 +1,8 @@
 package com.d4rk.androidtutorials.java.domain.home;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -22,4 +24,38 @@ public void invokeReturnsAppUrl() {
         assertEquals("url", result);
         verify(repository).getAppPlayStoreUrl("pkg");
     }
+
+    @Test
+    public void invokeDelegatesNullPackageName() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.getAppPlayStoreUrl(null)).thenReturn("fallback");
+        GetAppPlayStoreUrlUseCase useCase = new GetAppPlayStoreUrlUseCase(repository);
+
+        String result = useCase.invoke(null);
+
+        assertEquals("fallback", result);
+        verify(repository).getAppPlayStoreUrl(null);
+    }
+
+    @Test
+    public void invokeReturnsNullWhenRepositoryReturnsNull() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.getAppPlayStoreUrl("pkg")).thenReturn(null);
+        GetAppPlayStoreUrlUseCase useCase = new GetAppPlayStoreUrlUseCase(repository);
+
+        String result = useCase.invoke("pkg");
+
+        assertNull(result);
+        verify(repository).getAppPlayStoreUrl("pkg");
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.getAppPlayStoreUrl("pkg")).thenThrow(new IllegalStateException("err"));
+        GetAppPlayStoreUrlUseCase useCase = new GetAppPlayStoreUrlUseCase(repository);
+
+        assertThrows(IllegalStateException.class, () -> useCase.invoke("pkg"));
+        verify(repository).getAppPlayStoreUrl("pkg");
+    }
 }

app/src/test/java/com/d4rk/androidtutorials/java/domain/home/GetDailyTipUseCaseTest.java

@@ -1,6 +1,7 @@
 package com.d4rk.androidtutorials.java.domain.home;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -22,4 +23,26 @@ public void invokeReturnsDailyTip() {
         assertEquals("tip", result);
         verify(repository).dailyTip();
     }
+
+    @Test
+    public void invokeHandlesEmptyTip() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.dailyTip()).thenReturn("");
+        GetDailyTipUseCase useCase = new GetDailyTipUseCase(repository);
+
+        String result = useCase.invoke();
+
+        assertEquals("", result);
+        verify(repository).dailyTip();
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.dailyTip()).thenThrow(new IllegalArgumentException("bad"));
+        GetDailyTipUseCase useCase = new GetDailyTipUseCase(repository);
+
+        assertThrows(IllegalArgumentException.class, useCase::invoke);
+        verify(repository).dailyTip();
+    }
 }

app/src/test/java/com/d4rk/androidtutorials/java/domain/home/GetPlayStoreUrlUseCaseTest.java

@@ -1,6 +1,8 @@
 package com.d4rk.androidtutorials.java.domain.home;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -22,4 +24,26 @@ public void invokeReturnsUrl() {
         assertEquals("url", result);
         verify(repository).getPlayStoreUrl();
     }
+
+    @Test
+    public void invokeReturnsNullWhenRepositoryReturnsNull() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.getPlayStoreUrl()).thenReturn(null);
+        GetPlayStoreUrlUseCase useCase = new GetPlayStoreUrlUseCase(repository);
+
+        String result = useCase.invoke();
+
+        assertNull(result);
+        verify(repository).getPlayStoreUrl();
+    }
+
+    @Test
+    public void invokePropagatesRepositoryException() {
+        HomeRepository repository = mock(HomeRepository.class);
+        when(repository.getPlayStoreUrl()).thenThrow(new RuntimeException("fail"));
+        GetPlayStoreUrlUseCase useCase = new GetPlayStoreUrlUseCase(repository);
+
+        assertThrows(RuntimeException.class, useCase::invoke);
+        verify(repository).getPlayStoreUrl();
+    }
 }