Wie man screenshot an der Stelle, wo der test fehlschlagen, im Espresso?

Eine weitere Verbesserung zu den vorherigen Antworten. Ich bin mit den experimentellen Screenshot-API

public class ScreenshotTestRule extends TestWatcher {

  @Override
  protected void failed(Throwable e, Description description) {
    super.failed(e, description);

    takeScreenshot(description);
  }

  private void takeScreenshot(Description description) {
    String filename = description.getTestClass().getSimpleName() + "-" + description.getMethodName();

    ScreenCapture capture = Screenshot.capture();
    capture.setName(filename);
    capture.setFormat(CompressFormat.PNG);

    HashSet<ScreenCaptureProcessor> processors = new HashSet<>();
    processors.add(new CustomScreenCaptureProcessor());

    try {
      capture.process(processors);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Habe ich CustomScreenCaptureProcessor weil BasicScreenCaptureProcessor verwendet /sdcard/Bilder/ Ordner und ich stieß IOExceptions auf einigen Geräten beim erstellen der Ordner/Bild. Bitte beachten Sie, dass Sie benötigen, um Ihren Prozessor in der gleichen Verpackung

package android.support.test.runner.screenshot;

public class CustomScreenCaptureProcessor extends BasicScreenCaptureProcessor {    
  public CustomScreenCaptureProcessor() {
    super(
        new File(
            InstrumentationRegistry.getTargetContext().getExternalFilesDir(DIRECTORY_PICTURES),
            "espresso_screenshots"
        )
    );
  }
}

Dann in Ihrer base Espresso-test Klasse nur hinzufügen

@Rule
public ScreenshotTestRule screenshotTestRule = new ScreenshotTestRule();

Wenn Sie wollen verwenden Sie einige geschützte Ordner, dieser hat den trick auf einem emulator, tho es hat nicht funktioniert auf einem physischen Gerät

@Rule
public RuleChain screenshotRule = RuleChain
      .outerRule(GrantPermissionRule.grant(permission.WRITE_EXTERNAL_STORAGE))
      .around(new ScreenshotTestRule());

Schreiben einer benutzerdefinierten TestWatcher wie die anderen Antworten erklärt, ist der Weg zu gehen.

ABER (und es dauerte eine lange Zeit, um es zu bemerken) gibt es eine Einschränkung: Die Regel könnte Feuer zu spät, D. H. nach Ihrer Tätigkeit war bereits zerstört. Dies lässt Sie mit einem screenshot von dem Gerät home-Bildschirm und nicht von dem fehlerhaften Aktivität.

Lösen können Sie dieses mit RuleChain: Statt zu schreiben

@Rule
public final ActivityTestRule<MainActivity> _activityRule = new ActivityTestRule<>(MainActivity.class);

@Rule
public ScreenshotTestWatcher _screenshotWatcher = new ScreenshotTestWatcher();

Haben Sie zu schreiben:

private final ActivityTestRule<MainActivity> _activityRule = new ActivityTestRule<>(MainActivity.class);

@Rule
public final TestRule activityAndScreenshotRule = RuleChain
        .outerRule(_activityRule)
        .around(new ScreenshotTestWatcher());

Diese stellt sicher, dass der screenshot gemacht wird und dann die Aktivität zerstört wird

@Maragues Antwort portiert Kotlin:

Helfer-Klassen:

package utils

import android.graphics.Bitmap
import android.os.Environment.DIRECTORY_PICTURES
import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
import androidx.test.runner.screenshot.BasicScreenCaptureProcessor
import androidx.test.runner.screenshot.ScreenCaptureProcessor
import androidx.test.runner.screenshot.Screenshot
import org.junit.rules.TestWatcher
import org.junit.runner.Description
import java.io.File
import java.io.IOException

class IDTScreenCaptureProcessor : BasicScreenCaptureProcessor() {
    init {
        mTag = "IDTScreenCaptureProcessor"
        mFileNameDelimiter = "-"
        mDefaultFilenamePrefix = "Giorgos"
        mDefaultScreenshotPath = getNewFilename()
    }

    private fun getNewFilename(): File? {
        val context = getInstrumentation().getTargetContext().getApplicationContext()
        return context.getExternalFilesDir(DIRECTORY_PICTURES)
    }
}

class ScreenshotTestRule : TestWatcher() {
    override fun finished(description: Description?) {
        super.finished(description)

        val className = description?.testClass?.simpleName ?: "NullClassname"
        val methodName = description?.methodName ?: "NullMethodName"
        val filename = "$className - $methodName"

        val capture = Screenshot.capture()
        capture.name = filename
        capture.format = Bitmap.CompressFormat.PNG

        val processors = HashSet<ScreenCaptureProcessor>()
        processors.add(IDTScreenCaptureProcessor())

        try {
            capture.process(processors)
        } catch (ioException: IOException) {
            ioException.printStackTrace()
        }
    }
}

Verwendung:

import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.assertion.ViewAssertions.matches
import androidx.test.espresso.matcher.ViewMatchers.isCompletelyDisplayed
import androidx.test.espresso.matcher.ViewMatchers.withText
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import androidx.test.rule.ActivityTestRule
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import utils.ScreenshotTestRule

@RunWith(AndroidJUnit4::class)
@LargeTest
class DialogActivityTest {

    @get:Rule
    val activityRule = ActivityTestRule(DialogActivity::class.java)

    @get:Rule
    val screenshotTestRule = ScreenshotTestRule()

    @Test
    fun dialogLaunch_withTitleAndBody_displaysDialog() {
        //setup
        val title = "title"
        val body = "body"

        //assert
        onView(withText(title)).check(matches(isCompletelyDisplayed()))
        onView(withText(body)).check(matches(isCompletelyDisplayed()))
    }


}

Bibliotheken deklariert app build.gradle:

androidTestImplementation "androidx.test.espresso:espresso-core:3.1.1"
androidTestImplementation "androidx.test.espresso:espresso-intents:3.1.1"
androidTestImplementation "androidx.test.ext:junit:1.1.0"
androidTestImplementation "androidx.test:runner:1.1.1"
androidTestImplementation "androidx.test:rules:1.1.1"

Diesem setup speichert einen screenshot jedes mal einen test fertig in den Ordner: /sdcard/Android/data/your.package.name/files/Pictures
Navigieren Sie dort über den Android Studio die Geräte-Datei-Explorer (auf der rechten sidebar)

Wenn Sie gerne speichern von screenshots nur für fehlgeschlagene tests, überschreiben Sie die failed Methode der TestWatcher statt der finished