Add tests for requestPermissions methods

Henrique Faria · Henrique Faria · commit af5ab94a945c · 2018-07-18T21:26:11.000+02:00
diff --git a/easypermissions/build.gradle b/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.robolectric:shadows-supportv4:3.8'
     testImplementation 'org.mockito:mockito-core:2.18.0'
 }
 
diff --git a/easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsLowApiTest.java b/easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsLowApiTest.java
@@ -23,4 +23,6 @@ public void shouldHavePermission_whenHasPermissionsBeforeMarshmallow() {
         assertThat(EasyPermissions.hasPermissions(RuntimeEnvironment.application,
                 Manifest.permission.ACCESS_COARSE_LOCATION)).isTrue();
     }
+
+    //TODO: call all needed methods and expect IllegalStateException
 }
diff --git a/easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsTest.java b/easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsTest.java
@@ -2,7 +2,9 @@
 
 import android.Manifest;
 import android.app.Application;
+import android.app.Dialog;
 import android.app.Fragment;
+import android.widget.TextView;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -16,10 +18,13 @@
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowApplication;
+import org.robolectric.shadows.support.v4.SupportFragmentController;
 
 import java.util.ArrayList;
 
 import pub.devrel.easypermissions.testhelper.TestActivity;
+import pub.devrel.easypermissions.testhelper.TestFragment;
+import pub.devrel.easypermissions.testhelper.TestSupportFragment;
 
 import static com.google.common.truth.Truth.assertThat;
 import static junit.framework.Assert.fail;
@@ -38,50 +43,48 @@
 public class EasyPermissionsTest {
 
     private static final int REQUEST_CODE = 10;
-    private static final String RATIONALE = "some rationale";
+    private static final String RATIONALE = "RATIONALE";
+    private static final String[] ONE_PERM = new String[]{Manifest.permission.READ_SMS};
+    private static final String[] ALL_PERMS = new String[]{
+            Manifest.permission.READ_SMS, Manifest.permission.ACCESS_FINE_LOCATION};
+
     private Application app;
-    private String[] allPerms;
-    private String[] onePerm;
     private TestActivity spyActivity;
-    @Captor private ArgumentCaptor<Integer> integerCaptor;
-    @Captor private ArgumentCaptor<ArrayList<String>> listCaptor;
+    private TestFragment spyFragment;
+    private TestSupportFragment spySupportFragment;
+    @Captor
+    private ArgumentCaptor<Integer> integerCaptor;
+    @Captor
+    private ArgumentCaptor<ArrayList<String>> listCaptor;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-
+        setUpActivityAndFragment();
         app = RuntimeEnvironment.application;
-        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, allPerms)).isFalse();
+        assertThat(EasyPermissions.hasPermissions(app, ALL_PERMS)).isFalse();
     }
 
     @Test
     public void shouldNotHavePermissions_whenNotAllPermissionsGranted() {
-        ShadowApplication.getInstance().grantPermissions(onePerm);
-        assertThat(EasyPermissions.hasPermissions(app, allPerms)).isFalse();
+        ShadowApplication.getInstance().grantPermissions(ONE_PERM);
+        assertThat(EasyPermissions.hasPermissions(app, ALL_PERMS)).isFalse();
     }
 
     @Test
     public void shouldHavePermissions_whenAllPermissionsGranted() {
-        ShadowApplication.getInstance().grantPermissions(allPerms);
-        assertThat(EasyPermissions.hasPermissions(app, allPerms)).isTrue();
+        ShadowApplication.getInstance().grantPermissions(ALL_PERMS);
+        assertThat(EasyPermissions.hasPermissions(app, ALL_PERMS)).isTrue();
     }
 
     @Test
     public void shouldThrowException_whenHasPermissionsWithNullContext() {
         try {
-            EasyPermissions.hasPermissions(null, allPerms);
+            EasyPermissions.hasPermissions(null, ALL_PERMS);
             fail("IllegalStateException expected because of null context.");
         } catch (IllegalArgumentException e) {
             assertThat(e).hasMessageThat()
@@ -90,47 +93,230 @@ public void shouldThrowException_whenHasPermissionsWithNullContext() {
     }
 
     @Test
-    public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermission() {
-        grantPermissions(allPerms);
+    public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermissionFromActivity() {
+        grantPermissions(ALL_PERMS);
 
-        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, allPerms);
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, ALL_PERMS);
 
         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);
+        assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
+    }
+
+    @Test
+    public void shouldRequestPermissions_whenMissingPermissionAndNotShowRationaleFromActivity() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, false);
+
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, ALL_PERMS);
+
+        verify(spyActivity, times(1)).requestPermissions(ALL_PERMS, REQUEST_CODE);
+    }
+
+    @Test
+    public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromActivity() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
+
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, ALL_PERMS);
+
+        Fragment dialogFragment = spyActivity.getFragmentManager()
+                .findFragmentByTag(RationaleDialogFragment.TAG);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
+
+        Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
+        assertThatHasExpectedRationale(dialog, RATIONALE);
+    }
+
+    @Test
+    public void shouldShowCorrectDialogUsingDeprecated_whenMissingPermissionsAndShowRationaleFromActivity() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
+
+        EasyPermissions.requestPermissions(spyActivity, RATIONALE, android.R.string.ok,
+                android.R.string.cancel, REQUEST_CODE, ALL_PERMS);
+
+        Fragment dialogFragment = spyActivity.getFragmentManager()
+                .findFragmentByTag(RationaleDialogFragment.TAG);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
+
+        Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
+        assertThatHasExpectedButtonsAndRationale(dialog, RATIONALE,
+                android.R.string.ok, android.R.string.cancel);
+    }
+
+    @Test
+    public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermissionFromFragment() {
+        grantPermissions(ALL_PERMS);
+
+        EasyPermissions.requestPermissions(spyFragment, RATIONALE, REQUEST_CODE, ALL_PERMS);
+
+        verify(spyFragment, times(1))
+                .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
+        verify(spyFragment, never()).requestPermissions(any(String[].class), anyInt());
+        assertThat(integerCaptor.getValue()).isEqualTo(REQUEST_CODE);
+        assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
     }
 
     @Test
-    public void shouldRequestPermissions_whenMissingPermissionsAndShouldNotShowRationale() {
-        grantPermissions(onePerm);
-        showRationale(onePerm, false);
+    public void shouldRequestPermissions_whenMissingPermissionsAndNotShowRationaleFromFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, false);
 
-        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, allPerms);
+        EasyPermissions.requestPermissions(spyFragment, RATIONALE, REQUEST_CODE, ALL_PERMS);
 
-        verify(spyActivity, times(1)).requestPermissions(allPerms, REQUEST_CODE);
+        verify(spyFragment, times(1)).requestPermissions(ALL_PERMS, REQUEST_CODE);
     }
 
     @Test
-    public void shouldRequestPermissions_whenMissingPermissionsAndShouldShowRationale() {
-        grantPermissions(onePerm);
-        showRationale(onePerm, true);
+    public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
 
-        EasyPermissions.requestPermissions(spyActivity, RATIONALE, REQUEST_CODE, allPerms);
+        EasyPermissions.requestPermissions(spyFragment, RATIONALE, REQUEST_CODE, ALL_PERMS);
 
-        Fragment dialog = spyActivity.getFragmentManager()
+        Fragment dialogFragment = spyFragment.getChildFragmentManager()
                 .findFragmentByTag(RationaleDialogFragment.TAG);
-        assertThat(dialog).isInstanceOf(RationaleDialogFragment.class);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
+
+        Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
+        assertThatHasExpectedRationale(dialog, RATIONALE);
+    }
+
+    @Test
+    public void shouldShowCorrectDialogUsingDeprecated_whenMissingPermissionsAndShowRationaleFromFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
+
+        EasyPermissions.requestPermissions(spyFragment, RATIONALE, android.R.string.ok,
+                android.R.string.cancel, REQUEST_CODE, ALL_PERMS);
+
+        Fragment dialogFragment = spyFragment.getChildFragmentManager()
+                .findFragmentByTag(RationaleDialogFragment.TAG);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
+
+        Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
+        assertThatHasExpectedButtonsAndRationale(dialog, RATIONALE,
+                android.R.string.ok, android.R.string.cancel);
+    }
+
+    @Test
+    public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermissionFromSupportFragment() {
+        grantPermissions(ALL_PERMS);
+
+        EasyPermissions.requestPermissions(spySupportFragment, RATIONALE, REQUEST_CODE, ALL_PERMS);
+
+        verify(spySupportFragment, times(1))
+                .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
+        verify(spySupportFragment, never()).requestPermissions(any(String[].class), anyInt());
+        assertThat(integerCaptor.getValue()).isEqualTo(REQUEST_CODE);
+        assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
+    }
+
+    @Test
+    public void shouldRequestPermissions_whenMissingPermissionsAndNotShowRationaleFromSupportFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, false);
+
+        EasyPermissions.requestPermissions(spySupportFragment, RATIONALE, REQUEST_CODE, ALL_PERMS);
+
+        verify(spySupportFragment, times(1)).requestPermissions(ALL_PERMS, REQUEST_CODE);
+    }
+
+    @Test
+    public void shouldShowCorrectDialogUsingDeprecated_whenMissingPermissionsAndShowRationaleFromSupportFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
+
+        EasyPermissions.requestPermissions(spySupportFragment, RATIONALE, android.R.string.ok,
+                android.R.string.cancel, REQUEST_CODE, ALL_PERMS);
+
+        android.support.v4.app.Fragment dialogFragment = spySupportFragment.getChildFragmentManager()
+                .findFragmentByTag(RationaleDialogFragmentCompat.TAG);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragmentCompat.class);
+
+        Dialog dialog = ((RationaleDialogFragmentCompat) dialogFragment).getDialog();
+        assertThatHasExpectedButtonsAndRationale(dialog, RATIONALE,
+                android.R.string.ok, android.R.string.cancel);
+    }
+
+    @Test
+    public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromSupportFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
+
+        EasyPermissions.requestPermissions(spySupportFragment, RATIONALE, REQUEST_CODE, ALL_PERMS);
+
+        android.support.v4.app.Fragment dialogFragment = spySupportFragment.getChildFragmentManager()
+                .findFragmentByTag(RationaleDialogFragmentCompat.TAG);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragmentCompat.class);
+
+        Dialog dialog = ((RationaleDialogFragmentCompat) dialogFragment).getDialog();
+        assertThatHasExpectedRationale(dialog, RATIONALE);
+    }
+
+    @Test
+    public void shouldShowCorrectDialogUsingRequest_whenMissingPermissionsAndShowRationaleFromSupportFragment() {
+        grantPermissions(ONE_PERM);
+        showRationale(ONE_PERM, true);
+
+        PermissionRequest request = new PermissionRequest.Builder(spyFragment, REQUEST_CODE, ALL_PERMS)
+                .setPositiveButtonText(android.R.string.ok)
+                .setNegativeButtonText(android.R.string.cancel)
+                .setRationale(RATIONALE)
+                .setTheme(R.style.Theme_AppCompat)
+                .build();
+        EasyPermissions.requestPermissions(request);
+
+        Fragment dialogFragment = spyFragment.getChildFragmentManager()
+                .findFragmentByTag(RationaleDialogFragment.TAG);
+        assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
+
+        Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
+        assertThatHasExpectedButtonsAndRationale(dialog, RATIONALE,
+                android.R.string.ok, android.R.string.cancel);
+    }
+
+    private void assertThatHasExpectedButtonsAndRationale(Dialog dialog, String rationale,
+                                                          int positive, int negative) {
+        TextView dialogMessage = dialog.findViewById(android.R.id.message);
+        assertThat(dialogMessage.getText().toString()).isEqualTo(rationale);
+        TextView positiveMessage = dialog.findViewById(android.R.id.button1);
+        assertThat(positiveMessage.getText().toString()).isEqualTo(app.getString(positive));
+        TextView negativeMessage = dialog.findViewById(android.R.id.button2);
+        assertThat(negativeMessage.getText().toString()).isEqualTo(app.getString(negative));
+
+    }
+
+    private void assertThatHasExpectedRationale(Dialog dialog, String rationale) {
+        TextView dialogMessage = dialog.findViewById(android.R.id.message);
+        assertThat(dialogMessage.getText().toString()).isEqualTo(rationale);
+    }
+
+    private void setUpActivityAndFragment() {
+        TestActivity activity = Robolectric.buildActivity(TestActivity.class)
+                .create().start().resume().get();
+        TestFragment fragment = Robolectric.buildFragment(TestFragment.class)
+                .create().start().resume().get();
+        TestSupportFragment supportFragment = SupportFragmentController.of(new TestSupportFragment())
+                .create().start().resume().get();
+
+        spyActivity = Mockito.spy(activity);
+        spyFragment = Mockito.spy(fragment);
+        spySupportFragment = Mockito.spy(supportFragment);
     }
 
     private void grantPermissions(String[] perms) {
         ShadowApplication.getInstance().grantPermissions(perms);
     }
 
-    private void showRationale(String[] perms, boolean shouldShow) {
+    private void showRationale(String[] perms, boolean show) {
         for (String perm : perms) {
-            when(spyActivity.shouldShowRequestPermissionRationale(perm)).thenReturn(shouldShow);
+            when(spyActivity.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
+            when(spyFragment.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
+            when(spySupportFragment.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
         }
     }
 }
diff --git a/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestActivity.java b/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestActivity.java
@@ -9,7 +9,6 @@
 
 public class TestActivity extends Activity implements EasyPermissions.PermissionCallbacks {
 
-
     @Override
     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
 
diff --git a/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestFragment.java b/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestFragment.java
@@ -0,0 +1,21 @@
+package pub.devrel.easypermissions.testhelper;
+
+import android.app.Fragment;
+import android.support.annotation.NonNull;
+
+import java.util.List;
+
+import pub.devrel.easypermissions.EasyPermissions;
+
+public class TestFragment extends Fragment implements EasyPermissions.PermissionCallbacks {
+
+    @Override
+    public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
+
+    }
+
+    @Override
+    public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
+
+    }
+}
diff --git a/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestSupportFragment.java b/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestSupportFragment.java

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ dependencies {`
`36`	`36`	`testImplementation 'junit:junit:4.12'`
`37`	`37`	`testImplementation 'com.google.truth:truth:0.42'`
`38`	`38`	`testImplementation 'org.robolectric:robolectric:3.8'`
	`39`	`+ testImplementation 'org.robolectric:shadows-supportv4:3.8'`
`39`	`40`	`testImplementation 'org.mockito:mockito-core:2.18.0'`
`40`	`41`	`}`
`41`	`42`
Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,6 @@ public void shouldHavePermission_whenHasPermissionsBeforeMarshmallow() {`
`23`	`23`	`assertThat(EasyPermissions.hasPermissions(RuntimeEnvironment.application,`
`24`	`24`	`Manifest.permission.ACCESS_COARSE_LOCATION)).isTrue();`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+ //TODO: call all needed methods and expect IllegalStateException`
`26`	`28`	`}`