Add integration test cases for checking the behavior of generated code

This test cases are useful for when we are integrating Kotlin base
dispatcher. Does test cases make sure the code we generated are
correctly working. The test cases doesn't care what kind of code we
generate.

gradle.properties

@@ -26,6 +26,7 @@ POWERMOCK_VERSION=1.6.4
 COMPILE_TESTING_VERSION=0.6
 GOOGLE_ANDROID_VERSION=4.1.1.4
 LINT_VERSION=25.2.0
+ROBOLECTRIC_VERSION=3.3.2
 
 # Android configuration
 COMPILE_SDK_VERSION=android-25

settings.gradle

@@ -1 +1 @@
-include ':library', ':processor', ':sample', ':lint', ':sample-kotlin'
+include ':library', ':processor', ':sample', ':lint', ':sample-kotlin', ':test', ':test-v13'

test-v13/.gitignore

@@ -0,0 +1 @@
+/build

test-v13/build.gradle

@@ -0,0 +1,46 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+
+android {
+    compileSdkVersion COMPILE_SDK_VERSION
+    buildToolsVersion BUILD_TOOLS_VERSION
+    defaultConfig {
+        applicationId "permissions.dispatcher.test_v13"
+        targetSdkVersion TARGET_SDK_VERSION
+        minSdkVersion 18
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+    lintOptions {
+        abortOnError false
+    }
+    sourceSets {
+        main.java.srcDirs += "src/main/kotlin"
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+
+    compile(project(':library'))
+    provided project(':processor')
+    kapt project(':processor')
+
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$KOTLIN_VERSION"
+    compile "com.android.support:appcompat-v7:$SUPPORT_LIBRARY_VERSION"
+
+    testCompile "junit:junit:$JUNIT_VERSION"
+    testCompile "org.mockito:mockito-core:$MOCKITO_VERSION"
+    testCompile "org.powermock:powermock-api-mockito:$POWERMOCK_VERSION"
+    testCompile "org.powermock:powermock-module-junit4:$POWERMOCK_VERSION"
+    testCompile "org.powermock:powermock-module-junit4-rule:$POWERMOCK_VERSION"
+    testCompile "org.powermock:powermock-classloading-xstream:$POWERMOCK_VERSION"
+    testCompile "org.robolectric:robolectric:$ROBOLECTRIC_VERSION"
+}

test-v13/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="permissions.dispatcher.test_v13">
+
+</manifest>

test-v13/src/main/java/permissions/dispatcher/test_v13/FragmentWithAllAnnotations.java

@@ -0,0 +1,39 @@
+package permissions.dispatcher.test_v13;
+
+import android.Manifest;
+import android.app.Fragment;
+import android.support.annotation.NonNull;
+
+import permissions.dispatcher.NeedsPermission;
+import permissions.dispatcher.OnNeverAskAgain;
+import permissions.dispatcher.OnPermissionDenied;
+import permissions.dispatcher.OnShowRationale;
+import permissions.dispatcher.PermissionRequest;
+import permissions.dispatcher.RuntimePermissions;
+
+@RuntimePermissions
+public class FragmentWithAllAnnotations extends Fragment {
+
+    @NeedsPermission(Manifest.permission.CAMERA)
+    void showCamera() {
+    }
+
+    @OnShowRationale(Manifest.permission.CAMERA)
+    void showRationaleForCamera(final PermissionRequest request) {
+    }
+
+    @OnPermissionDenied(Manifest.permission.CAMERA)
+    void showDeniedForCamera() {
+    }
+
+    @OnNeverAskAgain(Manifest.permission.CAMERA)
+    void showNeverAskForCamera() {
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        FragmentWithAllAnnotationsPermissionsDispatcher.onRequestPermissionsResult(this, requestCode, grantResults);
+    }
+
+}

test-v13/src/main/java/permissions/dispatcher/test_v13/FragmentWithAllAnnotationsKt.kt

@@ -0,0 +1,37 @@
+package permissions.dispatcher.test_v13
+
+import android.Manifest
+import android.app.Fragment
+
+import permissions.dispatcher.NeedsPermission
+import permissions.dispatcher.OnNeverAskAgain
+import permissions.dispatcher.OnPermissionDenied
+import permissions.dispatcher.OnShowRationale
+import permissions.dispatcher.PermissionRequest
+import permissions.dispatcher.RuntimePermissions
+
+@RuntimePermissions
+open class FragmentWithAllAnnotationsKt : Fragment() {
+
+    @NeedsPermission(Manifest.permission.CAMERA)
+    fun showCamera() {
+    }
+
+    @OnShowRationale(Manifest.permission.CAMERA)
+    fun showRationaleForCamera(request: PermissionRequest?) {
+    }
+
+    @OnPermissionDenied(Manifest.permission.CAMERA)
+    fun showDeniedForCamera() {
+    }
+
+    @OnNeverAskAgain(Manifest.permission.CAMERA)
+    fun showNeverAskForCamera() {
+    }
+
+    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(this, requestCode, grantResults)
+    }
+
+}

test-v13/src/test/java/permissions/dispatcher/test_v13/Extensions.kt

@@ -0,0 +1,33 @@
+package permissions.dispatcher.test
+
+import android.annotation.SuppressLint
+import android.app.Fragment
+import android.content.Context
+import android.content.pm.PackageManager
+import android.support.v13.app.FragmentCompat
+import android.support.v4.content.PermissionChecker
+import org.mockito.Matchers.any
+import org.mockito.Matchers.anyString
+import org.powermock.api.mockito.PowerMockito
+
+fun mockCheckSelfPermission(result: Boolean) {
+    val value = if (result) PackageManager.PERMISSION_GRANTED else PackageManager.PERMISSION_DENIED
+    PowerMockito.`when`(PermissionChecker.checkSelfPermission(any(Context::class.java), anyString())).thenReturn(value)
+}
+
+@SuppressLint("NewApi")
+fun mockShouldShowRequestPermissionRationaleFragment(result: Boolean) {
+    PowerMockito.`when`(FragmentCompat.shouldShowRequestPermissionRationale(any(Fragment::class.java), anyString())).thenReturn(result)
+}
+
+fun getRequestCameraConstant(clazz: Class<*>): Int {
+    val field = clazz.getDeclaredField("REQUEST_SHOWCAMERA")
+    field.isAccessible = true
+    return field.getInt(null)
+}
+
+fun getPermissionRequestConstant(clazz: Class<*>): Array<String> {
+    val field = clazz.getDeclaredField("PERMISSION_SHOWCAMERA")
+    field.isAccessible = true
+    return field.get(null) as Array<String>
+}

test-v13/src/test/java/permissions/dispatcher/test_v13/FragmentWithAllAnnotationsKtPermissionsDispatcherTest.kt

@@ -0,0 +1,148 @@
+package permissions.dispatcher.test_v13
+
+
+import android.content.pm.PackageManager
+import android.support.v13.app.FragmentCompat
+import android.support.v4.content.PermissionChecker
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Matchers.any
+import org.mockito.Mockito
+import org.powermock.api.mockito.PowerMockito
+import org.powermock.core.classloader.annotations.PowerMockIgnore
+import org.powermock.core.classloader.annotations.PrepareForTest
+import org.powermock.modules.junit4.rule.PowerMockRule
+import org.robolectric.RobolectricTestRunner
+import permissions.dispatcher.PermissionRequest
+import permissions.dispatcher.test.getPermissionRequestConstant
+import permissions.dispatcher.test.getRequestCameraConstant
+import permissions.dispatcher.test.mockCheckSelfPermission
+import permissions.dispatcher.test.mockShouldShowRequestPermissionRationaleFragment
+
+
+@Suppress("IllegalIdentifier")
+@RunWith(RobolectricTestRunner::class)
+@PowerMockIgnore("org.mockito.*", "org.robolectric.*", "android.*")
+@PrepareForTest(PermissionChecker::class, FragmentCompat::class)
+class FragmentWithAllAnnotationsKtPermissionsDispatcherTest {
+
+    private lateinit var fragment: FragmentWithAllAnnotationsKt
+
+    @get:Rule val rule = PowerMockRule()
+
+    companion object {
+        private var requestCode = 0
+        lateinit private var requestPermissions: Array<String>
+
+        @BeforeClass
+        @JvmStatic
+        fun setUpForClass() {
+            requestCode = getRequestCameraConstant(FragmentWithAllAnnotationsKtPermissionsDispatcher::class.java)
+            requestPermissions = getPermissionRequestConstant(FragmentWithAllAnnotationsKtPermissionsDispatcher::class.java)
+        }
+    }
+
+    @Before
+    fun setUp() {
+        fragment = Mockito.spy(FragmentWithAllAnnotationsKt())
+
+        PowerMockito.mockStatic(PermissionChecker::class.java)
+        PowerMockito.mockStatic(FragmentCompat::class.java)
+    }
+
+    @Test
+    fun `already granted call the method`() {
+        mockCheckSelfPermission(true)
+
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.showCameraWithCheck(fragment)
+
+        Mockito.verify(fragment, Mockito.times(1)).showCamera()
+    }
+
+    @Test
+    fun `not granted does not call the method`() {
+        mockCheckSelfPermission(false)
+        mockShouldShowRequestPermissionRationaleFragment(true)
+
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.showCameraWithCheck(fragment)
+
+        Mockito.verify(fragment, Mockito.times(0)).showCamera()
+    }
+
+    @Test
+    fun `not granted permission and show rationale is true then call the rationale method`() {
+        mockCheckSelfPermission(false)
+        mockShouldShowRequestPermissionRationaleFragment(true)
+
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.showCameraWithCheck(fragment)
+
+        Mockito.verify(fragment, Mockito.times(1)).showRationaleForCamera(any(PermissionRequest::class.java))
+    }
+
+    @Test
+    fun `not granted permission and show rationale is false then does not call the rationale method`() {
+        mockCheckSelfPermission(false)
+        mockShouldShowRequestPermissionRationaleFragment(false)
+
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.showCameraWithCheck(fragment)
+
+        Mockito.verify(fragment, Mockito.times(0)).showRationaleForCamera(any(PermissionRequest::class.java))
+    }
+
+    @Test
+    fun `the method is called if verifyPermission is true`() {
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode, intArrayOf(PackageManager.PERMISSION_GRANTED))
+
+        Mockito.verify(fragment, Mockito.times(1)).showCamera()
+    }
+
+    @Test
+    fun `the method is not called if verifyPermission is false`() {
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode, intArrayOf(PackageManager.PERMISSION_DENIED))
+
+        Mockito.verify(fragment, Mockito.times(0)).showCamera()
+    }
+
+    @Test
+    fun `show never ask method is call if verifyPermission is false and shouldShowRequestPermissionRationale is false`() {
+        mockShouldShowRequestPermissionRationaleFragment(false)
+
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode, intArrayOf(PackageManager.PERMISSION_DENIED))
+
+        Mockito.verify(fragment, Mockito.times(1)).showNeverAskForCamera()
+    }
+
+    @Test
+    fun `show deny method is call if verifyPermission is false and shouldShowRequestPermissionRationale is true`() {
+        mockShouldShowRequestPermissionRationaleFragment(true)
+
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode, intArrayOf(PackageManager.PERMISSION_DENIED))
+
+        Mockito.verify(fragment, Mockito.times(1)).showDeniedForCamera()
+    }
+
+    @Test
+    fun `no the method call if request code is not related to the library`() {
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode + 1000, null)
+
+        Mockito.verify(fragment, Mockito.times(0)).showCamera()
+    }
+
+    @Test
+    fun `no denied method call if request code is not related to the library`() {
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode + 1000, null)
+
+        Mockito.verify(fragment, Mockito.times(0)).showDeniedForCamera()
+    }
+
+    @Test
+    fun `no never ask method call if request code is not related to the library`() {
+        FragmentWithAllAnnotationsKtPermissionsDispatcher.onRequestPermissionsResult(fragment, requestCode + 1000, null)
+
+        Mockito.verify(fragment, Mockito.times(0)).showNeverAskForCamera()
+    }
+
+}