Closes mozilla-mobile#1058: Lint Log check leaks into embedding applications

Author: csadilek

components/tooling/lint/src/main/java/mozilla/components/tooling/lint/LintLogChecks.kt

@@ -13,28 +13,38 @@ import com.android.tools.lint.detector.api.Scope
 import com.android.tools.lint.detector.api.Severity
 import com.intellij.psi.PsiMethod
 import org.jetbrains.uast.UCallExpression
+import org.jetbrains.uast.getContainingUClass
 import java.util.EnumSet
 
-private const val ANDROID_LOG_CLASS = "android.util.Log"
+internal const val ANDROID_LOG_CLASS = "android.util.Log"
+internal const val ERROR_MESSAGE = "Using Android Log instead of base component"
 
 /**
  * Custom lint checks related to logging.
  */
 class LintLogChecks : Detector(), Detector.UastScanner {
+    private val componentPackages = listOf("mozilla.components", "org.mozilla.telemetry", "org.mozilla.samples")
+
     override fun getApplicableMethodNames() = listOf("v", "d", "i", "w", "e")
 
     override fun visitMethod(context: JavaContext, node: UCallExpression, method: PsiMethod) {
         if (context.evaluator.isMemberInClass(method, ANDROID_LOG_CLASS)) {
-            context.report(
-                ISSUE_LOG_USAGE,
-                node,
-                context.getLocation(node),
-                "Using Android Log instead of base component")
+            val inComponentPackage = componentPackages.any {
+                node.methodIdentifier?.getContainingUClass()?.qualifiedName?.startsWith(it) == true
+            }
+
+            if (inComponentPackage) {
+                context.report(
+                        ISSUE_LOG_USAGE,
+                        node,
+                        context.getLocation(node),
+                        ERROR_MESSAGE)
+            }
         }
     }
 
     companion object {
-        private val ISSUE_LOG_USAGE = Issue.create(
+        internal val ISSUE_LOG_USAGE = Issue.create(
             "LogUsage",
             "Log/Logger from base component should be used.",
             """The Log or Logger class from the base component should be used for logging instead of

components/tooling/lint/src/test/java/mozilla/components/tooling/lint/LintLogChecksTest.kt

@@ -0,0 +1,56 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package mozilla.components.tooling.lint
+
+import com.android.tools.lint.client.api.JavaEvaluator
+import com.android.tools.lint.detector.api.JavaContext
+import com.intellij.psi.PsiMethod
+import mozilla.components.tooling.lint.LintLogChecks.Companion.ISSUE_LOG_USAGE
+import org.jetbrains.uast.UCallExpression
+import org.jetbrains.uast.UClass
+import org.jetbrains.uast.UIdentifier
+import org.jetbrains.uast.getContainingUClass
+import org.junit.Test
+import org.mockito.Mockito.`when`
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.never
+import org.mockito.Mockito.times
+import org.mockito.Mockito.verify
+
+class LintLogChecksTest {
+
+    @Test
+    fun `report log error in components code only`() {
+        val evaluator = mock(JavaEvaluator::class.java)
+        val context = mock(JavaContext::class.java)
+        val node = mock(UCallExpression::class.java)
+        val method = mock(PsiMethod::class.java)
+        val methodIdentifier = mock(UIdentifier::class.java)
+        val clazz = mock(UClass::class.java)
+
+        `when`(evaluator.isMemberInClass(method, ANDROID_LOG_CLASS)).thenReturn(true)
+        `when`(context.evaluator).thenReturn(evaluator)
+
+        val logCheck = LintLogChecks()
+        logCheck.visitMethod(context, node, method)
+        verify(context, never()).report(ISSUE_LOG_USAGE, node, context.getLocation(node), ERROR_MESSAGE)
+
+        `when`(node.methodIdentifier).thenReturn(methodIdentifier)
+        logCheck.visitMethod(context, node, method)
+        verify(context, never()).report(ISSUE_LOG_USAGE, node, context.getLocation(node), ERROR_MESSAGE)
+
+        `when`(methodIdentifier.getContainingUClass()).thenReturn(clazz)
+        logCheck.visitMethod(context, node, method)
+        verify(context, never()).report(ISSUE_LOG_USAGE, node, context.getLocation(node), ERROR_MESSAGE)
+
+        `when`(clazz.qualifiedName).thenReturn("com.some.app.Class")
+        logCheck.visitMethod(context, node, method)
+        verify(context, never()).report(ISSUE_LOG_USAGE, node, context.getLocation(node), ERROR_MESSAGE)
+
+        `when`(clazz.qualifiedName).thenReturn("mozilla.components.some.Class")
+        logCheck.visitMethod(context, node, method)
+        verify(context, times(1)).report(ISSUE_LOG_USAGE, node, context.getLocation(node), ERROR_MESSAGE)
+    }
+}

components/tooling/lint/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

@@ -0,0 +1,2 @@
+mock-maker-inline
+// This allows mocking final classes (classes are final by default in Kotlin)