So verwalten Sie Berechtigungen für die Laufzeit android marshmallow-espresso-tests

UPDATE! Jetzt können Sie Regel aus dem Android-Testing-Support-Bibliothek

Ist es mehr angemessen, die Verwendung als benutzerdefinierte Regeln.

Veraltete Antwort:

Können Sie fügen Sie test-Regel zur Wiederverwendung von code und fügen Sie mehr Flexibilität:

/**
 * 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);
            }
        }
    }
}

Danach können Sie diese Regel verwenden, die in den test-Klassen:

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

Beachten Sie:

1. Regel keinen Einfluss auf die @Before-Methoden, da sind alle Regeln
   ausgeführt nach, dass
2. executeShellCommand asynchron ist und wenn Sie brauchen, akzeptiert die Berechtigungen direkt nach dem test startete betrachten Sie das hinzufügen einiger Verzögerung

Können Sie GrantPermissionRule. Diese Regel gewähren alle angeforderten Berechtigungen für die Laufzeit für alle test-Methoden, test-Klasse.

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

Es ist GrantPermissionRule in Android-Testing-Support-Bibliothek, dass Sie in Ihren tests verwenden können, um die Erteilung einer Genehmigung vor Beginn eines jeden tests.

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

Nur ein paar kleinere UPDATEs für die oben genannten snippet ( Requisiten, um riwnodennyk ) -- die sehr gut funktioniert für mich, wenn Gebäude gegen SDK-24 und mit tools 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);
    }
}

Ich habe implementiert eine Lösung, die nutzt wrapper-Klassen, überschreiben und Aufbau der Variantenkonfiguration. Die Lösung ist ziemlich lange zu erklären, und findet sich hier: https://github.com/ahasbini/AndroidTestMockPermissionUtils. Es braucht keine Skript Hinzugefügt werden in das build-system oder ausgeführt, bevor die tests durchgeführt werden.

Es ist noch nicht verpackt in ein sdk, aber die Haupt Idee ist das überschreiben der Funktionen ContextWrapper.checkSelfPermission() und ActivityCompat.requestPermissions() manipuliert zu werden und zurück verspottet Ergebnisse trickst die app in den verschiedenen Szenarien getestet werden wie: wurde die Erlaubnis verweigert, damit die app angefordert und endete mit Berechtigung erteilt. Dieses Szenario kann auftreten, selbst wenn die app hatte die Erlaubnis, alle zusammen aber die Idee ist, dass es wurde betrogen, indem die verspotteten, die Ergebnisse aus der vorrangigen Umsetzung.

Darüber hinaus die Umsetzung hat ein TestRule genannt PermissionRule Klasse, die verwendet werden können, in den test-Klassen, um einfach simulieren, alle Bedingungen zu testen, die Berechtigungen nahtlos. Auch Aussagen gemacht werden können, wie die Sicherstellung der app aufgerufen hat requestPermissions() zum Beispiel.