Android Guimauve: Test des autorisations avec l'Espresso?

Les nouvelles autorisations régime instauré par Android Guimauve nécessite une vérification pour les autorisations spécifiques au moment de l'exécution, ce qui implique la nécessité de fournir différents flux en fonction de si l'utilisateur refuse ou en permet l'accès.

Que nous utilisons Espresso pour exécuter automatisé de tester l'INTERFACE utilisateur de notre application, comment peut-on se moquer ou de mettre à jour l'état des autorisations afin de tester différents scénarios?

Double Possible de Comment gérer l'Exécution des autorisations android guimauve espresso tests
Essayer ce peut être vous aider:-stackoverflow.com/a/41221852/5488468

InformationsquelleAutor argenkiwi | 2015-11-26

72

Avec la nouvelle version de la Android Tests Library 1.0, il y a un GrantPermissionRule que vous pouvez utiliser dans vos tests d'accorder une autorisation avant de commencer les tests.
```
@Rule public GrantPermissionRule permissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_FINE_LOCATION);
```
Kotlin solution
```
@get:Rule var permissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_FINE_LOCATION)
```
@get:Rule doit être utilisé afin d'éviter java.lang.Exception: The @Rule 'permissionRule' must be public. Plus d'infos ici.
- Cela fonctionne dans vos tests?
- Yup sans aucun problème.
- Fonctionne comme un charme! Vérifier ce post pour plus d'infos.
- Je garde de rencontrer l'erreur suivante en dépit d'avoir déclaré l'autorisation dans le Manifeste: 12-28 14:09:35.063 7193-7215/com.blaha.test E/GrantPermissionCallable: Permission: android.la permission.SET_TIME ne peut être accordée!
- Cela devrait être accepté comme réponse correcte, car il utilise un cadre approprié et travailler les comparer à d'autres solutions.
- Pas le GrantPermissionRule ne fonctionne que pour l'exécution des autorisations de l'utilisateur peut accorder à partir de l'application.
- Ne pas oublier d'ajouter la permission sur le Manifeste, vous pouvez également créer un nouveau AndroidManifest.xml fichier chemin d'accès: /src/debug
- Si vous souhaitez accorder plusieurs autorisations en Java : @Règle public GrantPermissionRule permissionRule = GrantPermissionRule.subvention(android.Le manifeste.la permission.ACCESS_FINE_LOCATION, Manifeste.la permission.APPAREIL photo).
InformationsquelleAutor Niklas
35

Accepté la réponse ne fait pas de test de la boîte de dialogue autorisations; c'est juste que il contourne. Donc, si la boîte de dialogue autorisations échoue pour une raison quelconque, votre test donnera un faux vert. J'encourage en fait en cliquant sur le "donner" autorisations de bouton pour tester l'ensemble de l'application des comportements.

Jetez un oeil à cette solution:
```
public static void allowPermissionsIfNeeded(String permissionNeeded) {
    try { 
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !hasNeededPermission(permissionNeeded)) {
        sleep(PERMISSIONS_DIALOG_DELAY);
        UiDevice device = UiDevice.getInstance(getInstrumentation());
        UiObject allowPermissions = device.findObject(new UiSelector()
          .clickable(true) 
          .checkable(false) 
          .index(GRANT_BUTTON_INDEX));
        if (allowPermissions.exists()) {
          allowPermissions.click();
        } 
      } 
    } catch (UiObjectNotFoundException e) {
      System.out.println("There is no permissions dialog to interact with");
    } 
  } 
```
Trouver l'ensemble de la classe ici: https://gist.github.com/rocboronat/65b1187a9fca9eabfebb5121d818a3c4

Par ailleurs, que cette réponse a été un populaire, nous avons ajouté PermissionGranter à Barista, notre outil ci-dessus Espresso et UiAutomator de faire instrumental tests vert: https://github.com/SchibstedSpain/Barista le vérifier, parce que nous le maintiendrons version par version.
- Fonctionne à merveille! Aussi pour tester avec des endroits différents, ce qui est mon cas.
- Génial! Dans la plupart des réponses que les gens ne prennent pas soin de l'appareil de la langue.. Donc, bravo et merci!!
- Vous pouvez dupliquer le code, mais le changement d'index à 0 si vous voulez tester en refusant l'autorisation ainsi. Indice 2 est la case à cocher pour ne jamais me le demander.
- wep! Juste mis à jour le code pour éviter le "plus jamais me demander" case à cocher. Il n'est pas utile sur un environnement de test. BTW, merci pour les commentaires!
- Génial, comment voulez-vous tester si vous avez plusieurs méthodes de test et ils ont tous besoin d'une autorisation. Pouvez-vous gérer cela dans @BeforeTest ou avez-vous de vérifier au début de chaque méthode?
- vous devez appeler ce code chaque fois que vous savez que la boîte de dialogue autorisation peut apparaître. Donc, @ BeforeTest n'est pas un bon endroit pour le mettre, mais à l'intérieur de votre @ Test
- Que faire si mon application demande de deux autorisations à la fois? Le système d'exploitation affiche alors une boîte de dialogue dans laquelle vous devez cliquez sur autoriser deux fois. Je suppose que cela fonctionnerait si vous appelez votre allowPermissionsIfNeeded deux fois, mais seulement si vous l'appelez dans le bon ordre. Si vous inversez l'ordre et de la vérification de la deuxième permission d'abord, il va cliquer sur la première autorisation de la boîte de dialogue, puis la première vérification d'autorisation serait comme "j'ai déjà l'autorisation, pas besoin de cliquer sur autoriser" et s'arrêter à la boîte de dialogue.
- Donc, je viens de vérifier, et si l'utilisation de plusieurs autorisations dans le même temps, les indices obtenir décalé - 0 n'est rien (false), 1 est nie et 2 est de permettre à
- Merci, @knezmilos ! L'ouverture, juste une question à Barista de reproduire et de le corriger :·)
InformationsquelleAutor Roc Boronat
29

Donner un essai avec une telle méthode statique lorsque votre téléphone est sur les paramètres régionaux anglais:
```
private static void allowPermissionsIfNeeded() {
    if (Build.VERSION.SDK_INT >= 23) {
        UiDevice device = UiDevice.getInstance(getInstrumentation());
        UiObject allowPermissions = device.findObject(new UiSelector().text("Allow"));
        if (allowPermissions.exists()) {
            try {
                allowPermissions.click();
            } catch (UiObjectNotFoundException e) {
                Timber.e(e, "There is no permissions dialog to interact with ");
            }
        }
    }
}
```
Je l'ai trouvé ici
- Notez que cela ne fonctionne pas avec un non FR régionaux ou si le texte du bouton change à l'avenir. Il pourrait même échouer avec certains appareils si les fabricants de personnaliser la boîte de dialogue.
- Étrangement cela fonctionne pas sur LG Nexus 5 avec Android 6. le texte "AUTORISER" est introuvable. À l'aide de la suite cela fonctionne: de nouvelles UiSelector().cliquable(true).vérifiables(false).index(1)
- Comment faire pour l'espresso tests?
- il n'y a aucun moyen de le faire avec un Expresso. Mais vous pouvez utiliser à la fois UIAutomation et Espresso ensemble.
- Dû changer de Permettre de PERMETTRE, pour que cela fonctionne.
- Si vous voulez traiter avec la localisation (ou même possible de la chaîne de modifications dues à des fabricants), la ressource de chaîne id ils sont probablement à l'aide de est android.R.chaîne de caractères.permettre, trouvé ici: raw.githubusercontent.com/android/platform_frameworks_base/...
- désolé, mais pourquoi cela ne fonctionne pas, à la première exécution ?
InformationsquelleAutor riwnodennyk
20

Vous pouvez accorder des autorisations avant le test est exécuté avec quelque chose comme:
```
@Before
public void grantPhonePermission() {
    //In M+, trying to call a number will trigger a runtime dialog. Make sure
    //the permission is granted before running this test.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        getInstrumentation().getUiAutomation().executeShellCommand(
                "pm grant " + getTargetContext().getPackageName()
                        + " android.permission.CALL_PHONE");
    }
}
```
Mais vous ne pouvez pas annuler. Si vous essayez pm reset-permissions ou pm revoke... le processus est tué.
- J'ai trouvé un code similaire dans google test de code de l'échantillon. Il travaille pour le téléphone d'appel d'exemple d'application dans le paquet, mais il ne fonctionne pas si les autorisations sont posées dès que l'application démarre, tels que la caméra de l'autorisation. Quelqu'un a une idée de pourquoi?
- Vous pouvez essayer de @BeforeClass.
- peut-être parce que l'activité est également lancé dans un @ Avant la règle?
- Vous devriez être en mesure de révoquer des autorisations à l'aide de la même méthode, aussi longtemps que vous le faites avec la @org.junit.AfterClass ou @org.junit.BeforeClass annotations
InformationsquelleAutor Jose Alcérreca
11

En fait il y a 2 façons de le faire je sais:
1. Accorder l'autorisation à l'aide de la bad commande avant que le test ne commence (la documentation):
adb shell pm grant "com.your.package" android.permission.your_permission
1. Vous pouvez cliquer sur l'autorisation de dialogue et de définir les autorisations à l'aide de UIAutomator (la documentation). Si vos tests sont écrits avec Espresso pour android, vous pouvez combiner l'Espresso et UIAutomator étapes dans un test facilement.
- Je ne vois pas comment nous pourrions utiliser la adb shell de commande avec notre suite de test. Et de cliquer sur le dialogue, l'Espresso doit être capable de gérer lui-même. Le problème est, après l'exécution de l'essai, et l'autorisation est activée, la prochaine fois que vous exécutez le test échouera car le réglage est conservé et la boîte de dialogue de ne pas s'afficher à nouveau.
- Espresso ne peut pas gérer les interactions avec la boîte de dialogue autorisation depuis la boîte de dialogue est une instance d'une autre application - com.android.packageinstaller.
- Avez-vous tenté d'accepter la popup avec UIAutomator? Pour moi, il ne semble pas trouver le bouton "AUTORISER". Toute idée comment résoudre ce problème?
- vous devez regarder pour "Autoriser" le texte, je suppose, de ne pas "AUTORISER". Le système permet de chaîne de caractères en majuscules lors de l'exécution, mais en fait, il peut être enregistré en tant que "Autoriser".
- Merci! vous avez raison
- sauf lorsque vous utilisez une autre langue....
- sur le Nexus 6, il fonctionne à l'aide de PERMETTRE, mais sur le LG Nexus 5 cela ne fonctionne pas, ce type de disparités sont vraiment souvent embêtant.
InformationsquelleAutor denys
7

Vous pouvez atteindre facilement par l'octroi de l'autorisation avant de commencer le test. Par exemple si vous êtes censé utiliser l'appareil pendant le test, vous pouvez accorder l'autorisation comme suit
```
@Before
public void grantPermission() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        getInstrumentation().getUiAutomation().executeShellCommand(
                "pm grant " + getTargetContext().getPackageName()
                        + " android.permission.CAMERA");
    }
}
```
- Cela fonctionne pour moi! J'ai dû chercher dans le manifeste pour savoir exactement les autorisations à accorder à l'aide de cette technique.
InformationsquelleAutor Sachini Samarasinghe
3

ESPRESSO MISE À JOUR

Cette seule ligne de code accorde à tous la permission répertorié comme paramètre
dans la méthode avec effet immédiat. En d'autres termes, l'application
seront traitées comme si les autorisations ont déjà été consentis, plus
les dialogues
```
@Rule @JvmField
val grantPermissionRule: GrantPermissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_FINE_LOCATION)
```
et gradle
```
dependencies {
  ...
  testImplementation "junit:junit:4.12"
  androidTestImplementation "com.android.support.test:runner:1.0.0"
  androidTestImplementation "com.android.support.test.espresso:espresso-core:3.0.0"
  ...
}
```
référence: https://www.kotlindevelopment.com/runtime-permissions-espresso-done-right/
- Est-il une méthode similaire pour refuser une autorisation afin de tester ce cas, lors d'un test?
InformationsquelleAutor murt
0

Je sais qu'une réponse a été acceptée, cependant, au lieu de la if déclaration qui a été proposé maintes et maintes fois, l'autre, plus élégant approche serait de faire ce qui suit dans le test réel que vous voulez pour une version spécifique de l'OS:
```
@Test
fun yourTestFunction() {
    Assume.assumeTrue(Build.VERSION.SDK_INT >= 23)
    //the remaining assertions...
}
```
Si le assumeTrue fonction est appelée avec une expression correspondant à false, le test s'arrête et être ignoré, qui je suppose est ce que vous voulez dans le cas où le test est exécuté sur un dispositif de pré SDK 23.

InformationsquelleAutor Edison Spencer
0

J'ai mis en place une solution qui tire parti des classes wrapper, le remplacement et établir la variante de configuration. La solution est assez long à expliquer et se trouve ici: https://github.com/ahasbini/AndroidTestMockPermissionUtils.

Il n'est pas encore emballé dans un sdk mais l'idée principale est de remplacer les fonctionnalités de ContextWrapper.checkSelfPermission et ActivityCompat.requestPermissions être manipulés et retour moqué résultats de tromper l'application dans les différents scénarios testés comme: l'autorisation a été refusée par conséquent, l'application a demandé et s'est terminée avec la permission. Ce scénario va se produire même si l'application avait la permission de tout le long, mais l'idée est qu'il a été dupé par les raillé les résultats de la primauté de la mise en œuvre.

En outre la mise en œuvre a un TestRule appelé PermissionRule classe qui peut être utilisé dans les classes de test facilement simuler toutes les conditions de test les autorisations de façon transparente. Aussi les assertions peuvent être faites de s'assurer de l'application a appelé requestPermissions() par exemple.

InformationsquelleAutor ahasbini
0

Il est GrantPermissionRule dans Android Tests Bibliothèque de prise en charge, que vous pouvez utiliser dans vos tests d'accorder une autorisation avant de commencer les tests.
```
@Rule public GrantPermissionRule permissionRule = GrantPermissionRule.grant(android.Manifest.permission.CAMERA, android.Manifest.permission.ACCESS_FINE_LOCATION);
```
InformationsquelleAutor NSK

Merci @niklas pour la solution. Dans le cas où quelqu'un à la recherche d'accorder plusieurs autorisations en Java:

 @Rule
public GrantPermissionRule permissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_FINE_LOCATION,
        Manifest.permission.CAMERA);

InformationsquelleAutor learner

Vous devez vous connecter pour publier un commentaire.