Comment gérer l'Exécution des autorisations android guimauve espresso tests

Mise à JOUR! Maintenant, vous pouvez utiliser Une règle à partir d'Android Tests Bibliothèque de prise en charge

Il est plus convenable d'utiliser que des règles personnalisées.

Réponse dépassée:

Vous pouvez ajouter le test de la règle de la réutilisation de code et ajouter plus de flexibilité:

/**
 * This rule adds selected permissions to test app
 */

public class PermissionsRule implements TestRule {

    private final String[] permissions;

    public PermissionsRule(String[] permissions) {
        this.permissions = permissions;
    }

    @Override
    public Statement apply(final Statement base, Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {

                allowPermissions();

                base.evaluate();

                revokePermissions();
            }
        };
    }

    private void allowPermissions() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            for (String permission : permissions) {
                InstrumentationRegistry.getInstrumentation().getUiAutomation().executeShellCommand(
                        "pm grant " + InstrumentationRegistry.getTargetContext().getPackageName()
                                + " " + permission);
            }
        }
    }

    private void revokePermissions() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            for (String permission : permissions) {
                InstrumentationRegistry.getInstrumentation().getUiAutomation().executeShellCommand(
                        "pm revoke " + InstrumentationRegistry.getTargetContext().getPackageName()
                                + " " + permission);
            }
        }
    }
}

Après cela, vous pouvez utiliser cette règle dans vos classes de test:

@Rule
public final PermissionsRule permissionsRule = new PermissionsRule(
new String[]{Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS});

Garder à l'esprit:

1. Règle n'a pas d'incidence sur @Avant les méthodes parce que toutes les règles sont
   exécuté après que
2. executeShellCommand est asynchrone et si vous avez besoin acceptés autorisations de droit après l'essai a commencé à envisager d'ajouter un peu de retard

Vous pouvez utiliser GrantPermissionRule. Cette règle s'accorder à tous la demande d'exécution des autorisations pour toutes les méthodes de test dans le test de la classe.

@Rule 
public GrantPermissionRule mRuntimePermissionRule
            = GrantPermissionRule.grant(Manifest.permission.READ_PHONE_STATE);

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);

Juste quelques Mises à jour mineures dans l'extrait ci-dessus ( accessoires riwnodennyk ) -- qui a très bien fonctionné pour moi lors de la construction contre SDK 24 et avec les outils de la version 24.0.0:

import com.android.ddmlib.AndroidDebugBridge
import com.android.ddmlib.IShellOutputReceiver
import com.android.ddmlib.IDevice
import java.util.concurrent.TimeUnit
android.applicationVariants.all { variant ->
def applicationId = [variant.mergedFlavor.applicationId, variant.buildType.applicationIdSuffix].findAll().join()
def grantPermissionsTask = tasks.create("grant${variant.name.capitalize()}Permissions") << {
if (!project.hasProperty('permissions')) {
throw new GradleException("Please add the comma-separated command line parameter, for example -Ppermissions=android.permission.WRITE_EXTERNAL_STORAGE")
}
AndroidDebugBridge adb = initAdb(android.getAdbExe().toString())
grantPermissionsOnAllConnectedDevice(adb, applicationId, project.properties['permissions'].split(','))
}
grantPermissionsTask.description = "Grants permissions for ${variant.name.capitalize()}."
grantPermissionsTask.dependsOn "install${variant.name.capitalize()}"
}
public static Object grantPermissionsOnAllConnectedDevice(AndroidDebugBridge adb, String applicationId, String[] permissionNames) {
return adb.getDevices().each {
device ->
int apiLevel = Integer.parseInt(device.getProperty(IDevice.PROP_BUILD_API_LEVEL))
if (0 <  apiLevel && apiLevel < 23) {
println "\nSkipping granting permissions for " + device.serialNumber + " because has API level " + device.apiLevel + " < 23"
return
}
println "\nGranting permissions for " + applicationId + " on " + device.serialNumber
permissionNames.each {
permissionName ->
def shellGrantCommand = "pm grant " + applicationId + " " + permissionName
println(shellGrantCommand)
device.executeShellCommand(shellGrantCommand, new IShellOutputReceiver() {
@Override
void addOutput(byte[] data, int offset, int length) {
println new String(data[offset..(offset + length - 1)] as byte[])
}
@Override
void flush() {
}
@Override
boolean isCancelled() {
return false
}
})
}
}
}
public static AndroidDebugBridge initAdb(String path) {
AndroidDebugBridge.initIfNeeded(false)
AndroidDebugBridge adb = AndroidDebugBridge.createBridge(path, false)
waitForAdb(adb, 15000)
return adb
}
private static void waitForAdb(AndroidDebugBridge adb, long timeOutMs) {
long sleepTimeMs = TimeUnit.SECONDS.toMillis(1);
while (!adb.hasInitialDeviceList() && timeOutMs > 0) {
try {
Thread.sleep(sleepTimeMs);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
timeOutMs -= sleepTimeMs;
}
if (timeOutMs <= 0 && !adb.hasInitialDeviceList()) {
throw new RuntimeException("Timeout getting device list.", null);
}
}

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'a pas besoin de script à ajouter dans le système de compilation ou d'exécution avant d'exécuter les tests.

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.