Merge pull request #10 from picimako/release-030

Changes for release v0.3.0

Author: picimako

CHANGELOG.md

@@ -4,6 +4,20 @@
 
 ## [Unreleased]
 
+## [0.3.0]
+- **IntelliJ version support: versions prior to 2021.1 are no longer supported.**
+
+### Added
+- Added a new inspection to report checked exceptions in `*Throw()` stubbing calls that are not specified in the stubbed method's `throws` clause.
+See [documentation](/docs/stubbing.md#invalid-checked-exception-is-passed-into-throw-methods).
+- [#8](https://github.com/picimako/mockitools/issues/8): Added a new inspection that reports multiple consecutive calls on `*Return()` stubbing calls. These can be merged into a single such call.
+See [documentation](docs/stubbing.md#consecutive-return-calls-can-be-merged).
+
+### Changed
+- Updated Gradle IntelliJ plugin to 1.4.0, gradle to 7.4, and qodana-action to 4.2.5.
+- Replaced unit test file checks with a less restrictive, test source root content check, because unit test file names don't necessarily end with the word *Test*.
+  This will allow certain functionality to run in files whose names don't end with *Test*.
+ 
 ## [0.2.0]
 ### Added
 - [#2](https://github.com/picimako/mockitools/issues/2): Extended `MockTypeInspection` to validate and report types annotated with `@DoNotMock` annotation.

docs/assets/consecutive_return_calls.png

@@ -0,0 +1,65 @@
+# Stubbing
+
+## Invalid checked exception is passed into *Throw() methods
+
+![](https://img.shields.io/badge/inspection-orange) ![](https://img.shields.io/badge/since-0.3.0-blue) [![](https://img.shields.io/badge/implementation-ThrowsCheckedExceptionStubbingInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/ThrowsCheckedExceptionStubbingInspection.java)
+
+Reports exception references in <code>*Throw()</code> stubbing methods based on Mockito's rule on checked exceptions.
+*If [the specified exception types] contain a checked exception then it has to match one of the checked exceptions of method signature.*
+   
+The following constructs are supported:
+- `Mockito.when().thenThrow(...)`
+- `BDDMockito.given().willThrow(...)`
+- `Mockito.doThrow(...).when()`
+- `BDDMockito.willThrow(...).given()`
+   
+In case of each way of stubbing, further chained <code>*Throw()</code> calls are supported too. In case of an empty list, no problem is reported.
+
+**Example:**
+
+```java
+void testMethod() {
+    MockObject mock = new MockObject();
+    // IOException is NOT reported because it is in MockObject#doSomething()'s throws list
+    // IllegalArgumentException is NOT reported because it is not a checked exception
+    // SqlException IS reported because it is not is in the throws list
+    Mockito.doThrow(IOException.class, IllegalArgumentException.class, SqlException.class).when(mock).doSomething();
+}
+
+class MockObject {
+    void doSomething() throws IOException, ClassNotFoundException {
+    }
+}
+```
+
+## Consecutive `*Return()` calls can be merged
+
+![](https://img.shields.io/badge/inspection-orange) ![](https://img.shields.io/badge/since-0.3.0-blue) [![](https://img.shields.io/badge/implementation-SimplifyConsecutiveStubbingCallsInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/SimplifyConsecutiveStubbingCallsInspection.java)
+
+Reports multiple consecutive calls to `*Return()` methods, so that they may be merge into a single call.
+   
+Both `org.mockito.Mockito` and `org.mockito.BDDMockito` based stubbing chains are supported, including calls to `doReturn()`, `thenReturn()` and `willReturn()`.
+
+If there are multiple sections of consecutive calls within the same call chain, they are reported separately for better notification,
+but upon invoking the quick fix, all sections are merged respectively. It is always the last consecutive call that is registered.
+
+![consecutive_return_calls](assets/consecutive_return_calls.png)
+
+**Examples:**
+
+```java
+From: Mockito.when(mockObject.invoke()).thenReturn(1).thenReturn(2)
+  to: Mockito.when(mockObject.invoke()).thenReturn(1, 2);
+
+From: Mockito.when(mockObject.invoke()).thenReturn(1).thenCallRealMethod().thenReturn(2).thenReturn(3);
+  to: Mockito.when(mockObject.invoke()).thenReturn(1).thenCallRealMethod().thenReturn(2, 3);
+
+From: Mockito.when(mockObject.invoke()).thenReturn(1).thenReturn(2).thenCallRealMethod().thenReturn(3);
+  to: Mockito.when(mockObject.invoke()).thenReturn(1, 2).thenCallRealMethod().thenReturn(3);
+
+From: Mockito.when(mockObject.invoke()).thenReturn(1).thenReturn(2).thenCallRealMethod().thenReturn(3).thenReturn(4);
+  to: Mockito.when(mockObject.invoke()).thenReturn(1, 2).thenCallRealMethod().thenReturn(3, 4);
+
+From: Mockito.when(mockObject.invoke()).thenReturn(1, 2, 3).thenReturn(4).thenCallRealMethod().thenReturn(5).thenReturn(6, 7);
+  to: Mockito.when(mockObject.invoke()).thenReturn(1, 2, 3, 4).thenCallRealMethod().thenReturn(5, 6, 7);
+```

docs/stubbing.md

@@ -0,0 +1,39 @@
+//Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+
+package com.picimako.mockitools;
+
+import com.intellij.psi.CommonClassNames;
+import com.intellij.psi.PsiClassObjectAccessExpression;
+import com.intellij.psi.PsiExpression;
+import com.intellij.psi.PsiType;
+import com.intellij.psi.util.InheritanceUtil;
+import org.jetbrains.annotations.Nullable;
+
+import com.picimako.mockitools.inspection.ClassObjectAccessUtil;
+
+/**
+ * Utility for exceptions.
+ */
+public final class ExceptionUtil {
+
+    /**
+     * Returns whether the exception class referenced by the argument expression is a checked exception.
+     */
+    public static boolean isCheckedException(PsiExpression expression) {
+        return expression instanceof PsiClassObjectAccessExpression
+            ? isCheckedException(ClassObjectAccessUtil.getOperandType(expression))
+            : isCheckedException(expression.getType());
+    }
+
+    /**
+     * Returns whether the argument type is a checked exception.
+     */
+    private static boolean isCheckedException(@Nullable PsiType type) {
+        return !InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION)
+            && !InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_ERROR);
+    }
+
+    private ExceptionUtil() {
+        //Utility class
+    }
+}

src/main/java/com/picimako/mockitools/ExceptionUtil.java

@@ -0,0 +1,27 @@
+//Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+
+package com.picimako.mockitools;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.codeStyle.JavaCodeStyleManager;
+
+/**
+ * Utility for shortening create expression logic.
+ */
+public final class ExpressionCreationHelper {
+
+    /**
+     * Creates an expression from the provided expression text.
+     */
+    public static PsiElement createExpressionFromText(String expressionText, PsiElement context, Project project) {
+        return JavaCodeStyleManager.getInstance(project)
+            .shortenClassReferences(JavaPsiFacade.getElementFactory(project)
+                .createExpressionFromText(expressionText, context));
+    }
+
+    private ExpressionCreationHelper() {
+        //Utility class
+    }
+}

src/main/java/com/picimako/mockitools/ExpressionCreationHelper.java

@@ -1,6 +1,4 @@
-/*
- * Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
- */
+//Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 
 package com.picimako.mockitools;
 

src/main/java/com/picimako/mockitools/ListPopupHelper.java

@@ -10,9 +10,13 @@ public final class MockitoQualifiedNames {
     //Classes
     public static final String ORG_MOCKITO_MOCKITO = "org.mockito.Mockito";
     public static final String ORG_MOCKITO_BDDMOCKITO = "org.mockito.BDDMockito";
+    public static final String ORG_MOCKITO_BDD_MY_ONGOING_STUBBING = "org.mockito.BDDMockito.BDDMyOngoingStubbing";
+    public static final String ORG_MOCKITO_BDD_STUBBER = "org.mockito.BDDMockito.BDDStubber";
     public static final String ORG_MOCKITO_ARGUMENT_MATCHERS = "org.mockito.ArgumentMatchers";
     public static final String ORG_MOCKITO_ADDITIONAL_MATCHERS = "org.mockito.AdditionalMatchers";
     public static final String ORG_MOCKITO_STUBBING_STUBBER = "org.mockito.stubbing.Stubber";
+    public static final String ORG_MOCKITO_STUBBING_BASESTUBBER = "org.mockito.stubbing.BaseStubber";
+    public static final String ORG_MOCKITO_ONGOING_STUBBING = "org.mockito.stubbing.OngoingStubbing";
     public static final String ORG_MOCKITO_ARGUMENT_CAPTOR = "org.mockito.ArgumentCaptor";
     public static final String ORG_MOCKITO_MOCK_SETTINGS = "org.mockito.MockSettings";
     public static final String ORG_MOCKITO_MATCHERS = "org.mockito.Matchers";
@@ -68,6 +72,13 @@ public final class MockitoQualifiedNames {
     public static final String IGNORE_STUBS = "ignoreStubs";
     public static final String VERIFY = "verify";
 
+    public static final String THEN_THROW = "thenThrow";
+    public static final String DO_THROW = "doThrow";
+    public static final String WILL_THROW = "willThrow";
+    public static final String THEN_RETURN = "thenReturn";
+    public static final String DO_RETURN = "doReturn";
+    public static final String WILL_RETURN = "willReturn";
+
     //MockSettings
     public static final String EXTRA_INTERFACES = "extraInterfaces";
 

src/main/java/com/picimako/mockitools/MockitoQualifiedNames.java

@@ -0,0 +1,31 @@
+//Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+
+package com.picimako.mockitools;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.List;
+
+import com.intellij.psi.PsiMethodCallExpression;
+import com.intellij.psi.SmartPointerManager;
+import com.intellij.psi.SmartPsiElementPointer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Utility for {@link SmartPsiElementPointer}s.
+ */
+public final class PointersUtil {
+
+    public static List<SmartPsiElementPointer<PsiMethodCallExpression>> toPointers(List<PsiMethodCallExpression> calls) {
+        return calls.stream().map(PointersUtil::toPointer).collect(toList());
+    }
+
+    @NotNull
+    public static SmartPsiElementPointer<PsiMethodCallExpression> toPointer(PsiMethodCallExpression element) {
+        return SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element, element.getContainingFile());
+    }
+
+    private PointersUtil() {
+        //Utility class
+    }
+}

src/main/java/com/picimako/mockitools/PointersUtil.java

@@ -1,6 +1,4 @@
-/*
- * Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
- */
+//Copyright 2021 Tamás Balog. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 
 package com.picimako.mockitools;
 

src/main/java/com/picimako/mockitools/PsiClassUtil.java

@@ -2,12 +2,21 @@
 
 package com.picimako.mockitools;
 
+import static com.siyeh.ig.psiutils.MethodCallUtils.getMethodName;
+import static java.util.stream.Collectors.toList;
+
+import java.util.List;
+import java.util.Optional;
+
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiExpression;
+import com.intellij.psi.PsiExpressionList;
 import com.intellij.psi.PsiIdentifier;
 import com.intellij.psi.PsiMethodCallExpression;
 import com.intellij.psi.PsiReferenceExpression;
+import com.intellij.psi.PsiStatement;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -16,6 +25,10 @@
  */
 public final class PsiMethodUtil {
 
+    public static boolean isMethodCall(PsiElement call) {
+        return call instanceof PsiMethodCallExpression;
+    }
+
     /**
      * Returns whether the argument method call has only one argument.
      */
@@ -46,6 +59,26 @@ public static boolean hasSubsequentMethodCall(@NotNull PsiMethodCallExpression m
         return methodCall.getParent() instanceof PsiReferenceExpression && methodCall.getParent().getParent() instanceof PsiMethodCallExpression;
     }
 
+    /**
+     * Returns the next method call in the chain the argument method call is located.
+     * <p>
+     * In the chain {@code variable.doFirst().doSecond()}, for {@code doFirst()} the subsequent call is {@code doSecond()}.
+     *
+     * @param methodCall the call to get the next call of.
+     * @return the next method call, or null if the starting call is null, or if it has no subsequent call
+     * @since 0.3.0
+     */
+    @Nullable
+    public static PsiMethodCallExpression getSubsequentMethodCall(@Nullable PsiMethodCallExpression methodCall) {
+        if (methodCall == null) return null;
+        PsiElement parent = methodCall.getParent();
+        if (parent instanceof PsiReferenceExpression) {
+            PsiElement grandParent = parent.getParent();
+            if (grandParent instanceof PsiMethodCallExpression) return (PsiMethodCallExpression) grandParent;
+        }
+        return null;
+    }
+
     /**
      * Gets the arguments of the provided method call, given that the argument list exists and is not null.
      */
@@ -67,6 +100,11 @@ public static PsiExpression getFirstArgument(@NotNull PsiMethodCallExpression me
     public static PsiExpression getQualifier(@NotNull PsiMethodCallExpression methodCall) {
         return methodCall.getMethodExpression().getQualifierExpression();
     }
+    
+    @Nullable
+    public static PsiElement getReferenceNameElement(PsiMethodCallExpression methodCall) {
+        return methodCall.getMethodExpression().getReferenceNameElement();
+    }
 
     /**
      * Deletes the arguments of the provided method call.
@@ -96,6 +134,78 @@ public static boolean isIdentifierOfMethodCall(PsiElement element) {
             && element.getParent().getParent() instanceof PsiMethodCallExpression;
     }
 
+    /**
+     * Finds the method call in a chain named by the argument {@code methodNameToFind}, upwards from {@code aCallInChain}.
+     * <p>
+     * For a chain {@code variable.doFirst().doSecond().doThird().doFourth()}, if the method is called with {@code PsiExpression[doThird()], "doFirst"}
+     * arguments, it will find the first call, but would not find e.g. {@code doFourth()}.
+     *
+     * @param aCallInChain     the starting point in the chain
+     * @param methodNameToFind the method name to find
+     * @return the found method call, or empty optional if none found
+     * @since 0.3.0
+     */
+    public static Optional<PsiMethodCallExpression> findCallUpwardsInChain(@NotNull PsiExpression aCallInChain, String methodNameToFind) {
+        PsiElement current = aCallInChain;
+        while (current.getFirstChild() instanceof PsiReferenceExpression) {
+            PsiElement previousCall = current.getFirstChild().getFirstChild();
+            if (isMethodCall(previousCall)) {
+                var prevCall = (PsiMethodCallExpression) previousCall;
+                if (methodNameToFind.equals(getMethodName(prevCall))) {
+                    return Optional.of(prevCall);
+                }
+                current = previousCall;
+            } else break;
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Finds the method call in a chain named by the argument {@code methodNameToFind}, downwards from {@code aCallInChain}.
+     * <p>
+     * For a chain {@code variable.doFirst().doSecond().doThird().doFourth()}, if the method is called with {@code PsiExpression[doSecond()], "doFourth"}
+     * arguments, it will find the last call, but would not find e.g. {@code doSecond()}.
+     *
+     * @param aCallInChain     the starting point in the chain
+     * @param methodNameToFind the method name to find
+     * @return the found method call, or empty optional if none found
+     * @since 0.3.0
+     */
+    public static Optional<PsiMethodCallExpression> findCallDownwardsInChain(@NotNull PsiExpression aCallInChain, String methodNameToFind) {
+        var callsInChain = PsiTreeUtil.collectParents(aCallInChain,
+            PsiMethodCallExpression.class, false, e -> e instanceof PsiExpressionList || e instanceof PsiStatement);
+        return callsInChain.stream()
+            .filter(call -> methodNameToFind.equals(getMethodName(call)))
+            .findFirst();
+    }
+
+//    /**
+//     * Collects the method calls from the call chain in which the provided call is the last one.
+//     * <p>
+//     * Thus, the calls will be in a reverse order compared to the order they are actually called.
+//     */
+//    public static List<PsiMethodCallExpression> collectCallsInChain(@NotNull PsiExpression lastCallInChain) {
+//        var calls = new SmartList<PsiElement>(lastCallInChain);
+//        PsiElement current = lastCallInChain;
+//        while (current.getFirstChild() instanceof PsiReferenceExpression) {
+//            PsiElement previousCall = current.getFirstChild().getFirstChild();
+//            if (previousCall instanceof PsiMethodCallExpression) {
+//                calls.add(previousCall);
+//                current = previousCall;
+//            } else break;
+//        }
+//        return calls.stream().map(PsiMethodCallExpression.class::cast).collect(toList());
+//    }
+    
+    public static List<PsiMethodCallExpression> collectCallsInChainFromFirst(PsiMethodCallExpression expression, boolean includeMySelf) {
+        return PsiTreeUtil.collectParents(expression,
+            PsiMethodCallExpression.class, includeMySelf, e -> e instanceof PsiExpressionList || e instanceof PsiStatement);
+    }
+
+    public static List<PsiMethodCallExpression> collectCallsInChainFromFirst(PsiMethodCallExpression expression) {
+        return collectCallsInChainFromFirst(expression, false);
+    }
+
     private PsiMethodUtil() {
         //Utility class
     }