Added a failure handler for the NoMatchingViewException. It dumps the full view hierarchy to a file, when the test storage service is installed on the device.

copybara-androidxtest · copybara-androidxtest · commit e25a980edfd3 · 2021-05-25T18:49:28.000-07:00
PiperOrigin-RevId: 375843010
diff --git a/espresso/core/java/androidx/test/espresso/NoMatchingViewException.java b/espresso/core/java/androidx/test/espresso/NoMatchingViewException.java
@@ -70,6 +70,11 @@ public String getViewMatcherDescription() {
     return viewMatcherDescription;
   }
 
+  /** Returns the root view where this exception is thrown. */
+  public View getRootView() {
+    return rootView;
+  }
+
   private static String getErrorMessage(Builder builder) {
     String errorMessage = "";
     if (builder.includeViewHierarchy) {
diff --git a/espresso/core/java/androidx/test/espresso/base/BUILD.bazel b/espresso/core/java/androidx/test/espresso/base/BUILD.bazel
@@ -18,6 +18,7 @@ android_library(
             "IdlingUiController.java",
             "IdlingResourceRegistry.java",
             "LooperIdlingResourceInterrogationHandler.java",
+            "NoMatchingViewExceptionHandler.java",
         ],
     ),
     plugins = ["//opensource/dagger:dagger_plugin"],
@@ -80,13 +81,15 @@ android_library(
         "AssertionErrorHandler.java",
         "DefaultFailureHandler.java",
         "EspressoExceptionHandler.java",
+        "NoMatchingViewExceptionHandler.java",
         "PerformExceptionHandler.java",
         "ThrowableHandler.java",
     ],
     visibility = ["//visibility:public"],
     deps = [
         "//espresso/core/java/androidx/test/espresso:interface",
         "//espresso/core/java/androidx/test/espresso/internal/inject",
+        "//espresso/core/java/androidx/test/espresso/util",
         "//runner/monitor/java/androidx/test:monitor",
         "@maven//:com_google_dagger_dagger",
         "@maven//:com_google_guava_guava",
diff --git a/espresso/core/java/androidx/test/espresso/base/BaseLayerModule.java b/espresso/core/java/androidx/test/espresso/base/BaseLayerModule.java
@@ -189,8 +189,9 @@ FailureHandler provideFailureHander(DefaultFailureHandler impl) {
   }
 
   @Provides
-  DefaultFailureHandler provideDefaultFailureHander(@TargetContext Context context) {
-    return new DefaultFailureHandler(context);
+  DefaultFailureHandler provideDefaultFailureHander(
+      @TargetContext Context context, PlatformTestStorage testStorage) {
+    return new DefaultFailureHandler(context, testStorage);
   }
 
   @Provides
diff --git a/espresso/core/java/androidx/test/espresso/base/DefaultFailureHandler.java b/espresso/core/java/androidx/test/espresso/base/DefaultFailureHandler.java
@@ -22,9 +22,11 @@
 import android.view.View;
 import androidx.test.espresso.EspressoException;
 import androidx.test.espresso.FailureHandler;
+import androidx.test.espresso.NoMatchingViewException;
 import androidx.test.espresso.PerformException;
 import androidx.test.espresso.internal.inject.TargetContext;
 import androidx.test.internal.platform.util.TestOutputEmitter;
+import androidx.test.platform.io.PlatformTestStorage;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -43,17 +45,20 @@ public final class DefaultFailureHandler implements FailureHandler {
   private final List<FailureHandler> handlers = new ArrayList<>();
 
   @Inject
-  public DefaultFailureHandler(@TargetContext Context appContext) {
+  public DefaultFailureHandler(@TargetContext Context appContext, PlatformTestStorage testStorage) {
     // Adds a chain of exception handlers.
     // Order matters and a matching failure handler in the chain will throw after the exception is
     // handled. Always adds the handler of the child class ahead of its superclasses to make sure
     // the exception is handled by its corresponding handler.
     //
     // The hierarchy of the exception types handled is:
-    //
-    // PerformException --> EspressoException
-    //                  --> Throwable
-    // AssertionError ---->
+    // NoMatchingViewException -->
+    // PerformException ---------> EspressoException
+    //                  ---------> Throwable
+    // AssertionError ----------->
+    handlers.add(
+        new NoMatchingViewExceptionHandler(
+            testStorage, failureCount, NoMatchingViewException.class));
     handlers.add(new PerformExceptionHandler(checkNotNull(appContext), PerformException.class));
     // On API 15, junit.framework.AssertionFailedError is not a subclass of AssertionError.
     handlers.add(new AssertionErrorHandler(AssertionFailedError.class, AssertionError.class));
diff --git a/espresso/core/java/androidx/test/espresso/base/NoMatchingViewExceptionHandler.java b/espresso/core/java/androidx/test/espresso/base/NoMatchingViewExceptionHandler.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.test.espresso.base;
+
+import static androidx.test.internal.util.Checks.checkNotNull;
+import static com.google.common.base.Throwables.throwIfUnchecked;
+
+import android.util.Log;
+import android.view.View;
+import androidx.test.espresso.NoMatchingViewException;
+import androidx.test.espresso.base.DefaultFailureHandler.TypedFailureHandler;
+import androidx.test.espresso.util.HumanReadables;
+import androidx.test.platform.io.PlatformTestStorage;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.hamcrest.Matcher;
+
+/** An Espresso failure handler that handles an {@link NoMatchingViewException}. */
+class NoMatchingViewExceptionHandler extends TypedFailureHandler<NoMatchingViewException> {
+  private static final String TAG = NoMatchingViewExceptionHandler.class.getSimpleName();
+
+  private final PlatformTestStorage testStorage;
+  private final AtomicInteger failureCount;
+
+  public NoMatchingViewExceptionHandler(
+      PlatformTestStorage testStorage,
+      AtomicInteger failureCount,
+      Class<NoMatchingViewException> expectedType) {
+    super(expectedType);
+    this.testStorage = checkNotNull(testStorage);
+    this.failureCount = failureCount;
+  }
+
+  @Override
+  public void handleSafely(NoMatchingViewException error, Matcher<View> viewMatcher) {
+    dumpFullViewHierarchyToFile(error);
+    error.setStackTrace(Thread.currentThread().getStackTrace());
+    throwIfUnchecked(error);
+    throw new RuntimeException(error);
+  }
+
+  private void dumpFullViewHierarchyToFile(NoMatchingViewException error) {
+    String viewHierarchyMsg =
+        HumanReadables.getViewHierarchyErrorMessage(error.getRootView(), null, "", null);
+    String viewHierarchyFile = "view-hierarchy-" + failureCount + ".txt";
+    try {
+      addOutputFile(viewHierarchyFile, viewHierarchyMsg);
+    } catch (IOException e) {
+      // Log and ignore.
+      Log.w(TAG, "Failed to save the view hierarchy to file " + viewHierarchyFile, e);
+    }
+  }
+
+  private void addOutputFile(String filename, String content) throws IOException {
+    try (OutputStream out = testStorage.openOutputFile(filename)) {
+      out.write(content.getBytes());
+    }
+  }
+}
diff --git a/espresso/core/javatests/androidx/test/espresso/base/NoMatchingViewExceptionHandlerTest.java b/espresso/core/javatests/androidx/test/espresso/base/NoMatchingViewExceptionHandlerTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.test.espresso.base;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.view.View;
+import android.widget.TextView;
+import androidx.test.espresso.NoMatchingViewException;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.platform.io.PlatformTestStorage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(AndroidJUnit4.class)
+public class NoMatchingViewExceptionHandlerTest {
+
+  @Rule public final MockitoRule mockito = MockitoJUnit.rule();
+
+  private final AtomicInteger failureCount = new AtomicInteger();
+  private NoMatchingViewExceptionHandler handler;
+  private Matcher<View> viewMatcher;
+  @Mock private PlatformTestStorage testStorage;
+
+  @Before
+  public void setUp() throws IOException {
+    when(testStorage.openOutputFile("view-hierarchy-1.txt"))
+        .thenReturn(new ByteArrayOutputStream());
+    handler =
+        new NoMatchingViewExceptionHandler(
+            testStorage, failureCount, NoMatchingViewException.class);
+    viewMatcher =
+        new BaseMatcher<View>() {
+          @Override
+          public boolean matches(Object o) {
+            return false;
+          }
+
+          @Override
+          public void describeTo(Description description) {
+            description.appendText("A view matcher");
+          }
+        };
+  }
+
+  @Test
+  public void handle_noMatchingViewException() throws IOException {
+    NoMatchingViewException noMatchingViewException =
+        new NoMatchingViewException.Builder()
+            .withViewMatcher(viewMatcher)
+            .withRootView(
+                new TextView(InstrumentationRegistry.getInstrumentation().getTargetContext()))
+            .build();
+    String viewHierarchyMsg =
+        "\n\nView Hierarchy:\n"
+            + "+>TextView{id=-1, visibility=VISIBLE, width=0, height=0, has-focus=false,"
+            + " has-focusable=false, has-window-focus=false, is-clickable=false, is-enabled=true,"
+            + " is-focused=false, is-focusable=false, is-layout-requested=true, is-selected=false,"
+            + " layout-params=null, tag=null, root-is-layout-requested=true,"
+            + " has-input-connection=false, x=0.0, y=0.0, text=, input-type=0, ime-target=false,"
+            + " has-links=false} ";
+
+    failureCount.incrementAndGet();
+    NoMatchingViewException thrown =
+        assertThrows(
+            NoMatchingViewException.class,
+            () -> handler.handle(noMatchingViewException, viewMatcher));
+
+    assertThat(thrown)
+        .hasMessageThat()
+        .contains("No views in hierarchy found matching: A view matcher" + viewHierarchyMsg);
+    verify(testStorage).openOutputFile(eq("view-hierarchy-1.txt"));
+  }
+
+  @Test
+  public void handle_nonNoMatchingViewException() {
+    // No-op. No exception should be thrown.
+    handler.handle(new Throwable("A random error"), viewMatcher);
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -189,8 +189,9 @@ FailureHandler provideFailureHander(DefaultFailureHandler impl) {`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`@Provides`
`192`		`- DefaultFailureHandler provideDefaultFailureHander(@TargetContext Context context) {`
`193`		`- return new DefaultFailureHandler(context);`
	`192`	`+ DefaultFailureHandler provideDefaultFailureHander(`
	`193`	`+ @TargetContext Context context, PlatformTestStorage testStorage) {`
	`194`	`+ return new DefaultFailureHandler(context, testStorage);`
`194`	`195`	`}`
`195`	`196`
`196`	`197`	`@Provides`