taler-android

ConfigCameraPermissionTest.kt (6198B)

---

 package net.taler.merchantpos.config
 
 import android.Manifest
 import android.app.Application
 import android.content.Context
 import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.os.Bundle
 import android.os.Looper
 import android.provider.Settings
 import android.widget.FrameLayout
 
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.ViewModelProvider
 import androidx.test.core.app.ApplicationProvider
 
 import net.taler.merchantpos.R
 
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNotSame
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertSame
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.Robolectric
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.android.controller.ActivityController
 import org.robolectric.annotation.Config
 import org.robolectric.shadows.ShadowChoreographer
 import org.robolectric.shadows.ShadowToast
 
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [28], application = Application::class)
 class ConfigCameraPermissionTest
 {
     private lateinit var controller: ActivityController<CameraTestActivity>
     private val fragment: ConfigFragment
         get() = controller.get().supportFragmentManager.findFragmentByTag("config") as ConfigFragment
 
     @Before
     fun setUp()
     {
         val app = ApplicationProvider.getApplicationContext<Application>()
         shadowOf(app).grantPermissions("${app.packageName}.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION")
         shadowOf(app).denyPermissions(Manifest.permission.CAMERA)
         app
             .getSharedPreferences("config.cameraPermission", Context.MODE_PRIVATE)
             .edit()
             .clear()
             .commit()
         ShadowChoreographer.setPaused(true)
         controller = Robolectric.buildActivity(CameraTestActivity::class.java).setup()
         ViewModelProvider(controller.get())[ConfigDraftViewModel::class.java].apply {
             initialized = true
             mode = ConfigMode.Qr
             merchantUrl = "example.invalid"
         }
         controller
             .get()
             .supportFragmentManager
             .beginTransaction()
             .add(android.R.id.content, ConfigFragment(), "config")
             .commitNow()
         idle()
     }
 
     @After
     fun tearDown()
     {
         controller.pause().stop().destroy()
         idle()
     }
 
     @Test
     fun `entering and resuming QR setup do not automatically request permission or toast`()
     {
         repeat(3) {
             controller.pause().resume()
             idle()
         }
         assertNull(shadowOf(controller.get()).lastRequestedPermission)
         assertEquals(0, ShadowToast.shownToastCount())
     }
 
     @Test
     fun `only confirmation launches permission and repeated taps cannot launch duplicates`()
     {
         confirm()
         val request = shadowOf(controller.get()).lastRequestedPermission
         assertNotNull(request)
         assertEquals(listOf(Manifest.permission.CAMERA), request.requestedPermissions.toList())
 
         confirm()
         assertSame(request, shadowOf(controller.get()).lastRequestedPermission)
     }
 
     @Test
     fun `two denials stop requesting and offer app settings without toasts`()
     {
         confirm()
         deny(canAskAgain = true)
         val first = shadowOf(controller.get()).lastRequestedPermission
         controller.pause().resume()
         idle()
         assertSame(first, shadowOf(controller.get()).lastRequestedPermission)
 
         confirm()
         val second = shadowOf(controller.get()).lastRequestedPermission
         assertNotSame(first, second)
         deny(canAskAgain = false)
 
         repeat(3) {
             controller.pause().resume()
             idle()
         }
         assertSame(second, shadowOf(controller.get()).lastRequestedPermission)
         assertEquals(0, ShadowToast.shownToastCount())
 
         confirm()
         val settings = shadowOf(controller.get()).nextStartedActivity
         assertEquals(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, settings.action)
         assertEquals("package:${controller.get().packageName}", settings.dataString)
         assertSame(second, shadowOf(controller.get()).lastRequestedPermission)
     }
 
     @Test
     fun `blocked permission still opens settings after rotation`()
     {
         confirm()
         deny(canAskAgain = false)
         controller.configurationChange(
             Configuration(controller.get().resources.configuration).apply {
                 orientation = Configuration.ORIENTATION_LANDSCAPE
             },
         )
         idle()
 
         confirm()
         assertEquals(
             Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
             shadowOf(controller.get()).nextStartedActivity.action
         )
         assertNull(shadowOf(controller.get()).lastRequestedPermission)
         assertEquals(0, ShadowToast.shownToastCount())
     }
 
     private fun confirm()
     {
         // Exercise the same action wired to the Compose dialog button without a camera backend.
         ConfigFragment::class.java
             .getDeclaredMethod("confirmCameraPermission")
             .apply {
                 isAccessible = true
             }.invoke(fragment)
         idle()
     }
 
     private fun deny(canAskAgain: Boolean)
     {
         shadowOf(controller.get().packageManager)
             .setShouldShowRequestPermissionRationale(Manifest.permission.CAMERA, canAskAgain)
         val request = shadowOf(controller.get()).lastRequestedPermission
         controller.get().onRequestPermissionsResult(
             request.requestCode,
             request.requestedPermissions,
             intArrayOf(PackageManager.PERMISSION_DENIED),
         )
         idle()
     }
 
     private fun idle() = shadowOf(Looper.getMainLooper()).idle()
 
     class CameraTestActivity : FragmentActivity()
     {
         override fun onCreate(savedInstanceState: Bundle?)
         {
             setTheme(R.style.AppTheme)
             super.onCreate(savedInstanceState)
             setContentView(FrameLayout(this))
         }
     }
 }