Add tests for EasyPermissions.requestPermissions()

Author: Henrique Faria

easypermissions/build.gradle

@@ -36,6 +36,7 @@ dependencies {
     testImplementation 'junit:junit:4.12'
     testImplementation 'com.google.truth:truth:0.42'
     testImplementation 'org.robolectric:robolectric:3.8'
+    testImplementation 'org.mockito:mockito-core:2.18.0'
 }
 
 // Needed in order to process Robolectric tests when running JaCoCo

easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsTest.java

@@ -2,16 +2,33 @@
 
 import android.Manifest;
 import android.app.Application;
+import android.app.Fragment;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.Robolectric;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowApplication;
 
+import java.util.ArrayList;
+
+import pub.devrel.easypermissions.testhelper.TestActivity;
+
 import static com.google.common.truth.Truth.assertThat;
+import static junit.framework.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 /**
  * Basic Robolectric tests for {@link pub.devrel.easypermissions.EasyPermissions}.
@@ -20,33 +37,100 @@
 @Config(sdk = 23)
 public class EasyPermissionsTest {
 
+    private static final int REQUEST_CODE = 10;
+    private static final String RATIONALE = "some rationale";
     private Application app;
-    private String[] perms;
+    private String[] allPerms;
+    private String[] onePerm;
+    private TestActivity spyActivity;
+    @Captor private ArgumentCaptor<Integer> integerCaptor;
+    @Captor private ArgumentCaptor<ArrayList<String>> listCaptor;
 
     @Before
     public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
         app = RuntimeEnvironment.application;
-        perms = new String[]{
+        spyActivity = Mockito.spy(Robolectric.buildActivity(TestActivity.class).get());
+        allPerms = new String[]{
                 Manifest.permission.READ_SMS,
                 Manifest.permission.ACCESS_FINE_LOCATION
         };
+        onePerm = new String[]{
+                Manifest.permission.READ_SMS,
+        };
     }
 
     @Test
     public void shouldNotHavePermissions_whenNoPermissionsGranted() {
-        assertThat(EasyPermissions.hasPermissions(app, perms)).isFalse();
+        assertThat(EasyPermissions.hasPermissions(app, allPerms)).isFalse();
     }
 
-
     @Test
     public void shouldNotHavePermissions_whenNotAllPermissionsGranted() {
-        ShadowApplication.getInstance().grantPermissions(perms[0]);
-        assertThat(EasyPermissions.hasPermissions(app, perms)).isFalse();
+        ShadowApplication.getInstance().grantPermissions(onePerm);
+        assertThat(EasyPermissions.hasPermissions(app, allPerms)).isFalse();
     }
 
     @Test
     public void shouldHavePermissions_whenAllPermissionsGranted() {
+        ShadowApplication.getInstance().grantPermissions(allPerms);
+        assertThat(EasyPermissions.hasPermissions(app, allPerms)).isTrue();
+    }
+
+    @Test
+    public void shouldThrowException_whenHasPermissionsWithNullContext() {
+        try {
+            EasyPermissions.hasPermissions(null, allPerms);
+            fail("IllegalStateException expected because of null context.");
+        } catch (IllegalArgumentException e) {
+            assertThat(e).hasMessageThat()
+                    .isEqualTo("Can't check permissions for null context");
+        }
+    }
+
+    @Test
+    public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermission() {
+        grantPermissions(allPerms);
+
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, allPerms);
+
+        verify(spyActivity, times(1))
+                .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
+        verify(spyActivity, never()).requestPermissions(any(String[].class), anyInt());
+        assertThat(integerCaptor.getValue()).isEqualTo(REQUEST_CODE);
+        assertThat(listCaptor.getValue()).containsAllIn(allPerms);
+    }
+
+    @Test
+    public void shouldRequestPermissions_whenMissingPermissionsAndShouldNotShowRationale() {
+        grantPermissions(onePerm);
+        showRationale(onePerm, false);
+
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, allPerms);
+
+        verify(spyActivity, times(1)).requestPermissions(allPerms, REQUEST_CODE);
+    }
+
+    @Test
+    public void shouldRequestPermissions_whenMissingPermissionsAndShouldShowRationale() {
+        grantPermissions(onePerm);
+        showRationale(onePerm, true);
+
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, allPerms);
+
+        Fragment dialog = spyActivity.getFragmentManager()
+                .findFragmentByTag(RationaleDialogFragment.TAG);
+        assertThat(dialog).isInstanceOf(RationaleDialogFragment.class);
+    }
+
+    private void grantPermissions(String[] perms) {
         ShadowApplication.getInstance().grantPermissions(perms);
-        assertThat(EasyPermissions.hasPermissions(app, perms)).isTrue();
+    }
+
+    private void showRationale(String[] perms, boolean shouldShow) {
+        for (String perm : perms) {
+            when(spyActivity.shouldShowRequestPermissionRationale(perm)).thenReturn(shouldShow);
+        }
     }
 }

easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestActivity.java

@@ -0,0 +1,22 @@
+package pub.devrel.easypermissions.testhelper;
+
+import android.app.Activity;
+import android.support.annotation.NonNull;
+
+import java.util.List;
+
+import pub.devrel.easypermissions.EasyPermissions;
+
+public class TestActivity extends Activity implements EasyPermissions.PermissionCallbacks {
+
+
+    @Override
+    public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
+
+    }
+
+    @Override
+    public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
+
+    }
+}