Merge pull request #28 from picimako/v050

Changes for v0.5.0

Author: picimako

CHANGELOG.md

@@ -4,6 +4,29 @@
 
 ## [Unreleased]
 
+## [0.5.0]
+### Added
+- [#19](https://github.com/picimako/mockitools/issues/19): Added bulk options to convert verifications from `BDDMockito.then()` and `Mockito.verify()` by selecting one or more
+  verifications in the editor.
+- [#20](https://github.com/picimako/mockitools/issues/20): Extended the conversion of `InOrder.verify()` call chains with a bulk mode,
+so that if multiple (or just a single) such call chain is selected/highlighted in the editor, they all can be converted to the same approach at once.
+- [#21](https://github.com/picimako/mockitools/issues/21): Added an inspection to report InOrder local variables that are used in only one verification call.
+Besides `MockedStatic`, it can report for both `InOrder.verify()` and `BDDMockito.then().should(InOrder)` verifications.
+- [#22](https://github.com/picimako/mockitools/issues/22): Added a new action to convert from and to `InOrder.verify()` based verification.
+Along with it, extended the possible conversion options from and to `Mockito.verify()` and `BDDMockito.then()` as well.
+Details are available in the [Verifications](https://github.com/picimako/mockitools/blob/main/docs/verifications.md) document.
+- [#23](https://github.com/picimako/mockitools/issues/23): Added a quick fix, so that checked exceptions can be added to the stubbed method's `throws` clause 
+when they are specified in the stubbing, but not in the mentioned `throws` clause.
+- [#24](https://github.com/picimako/mockitools/issues/24): Strictness configuration is now supported by the conversion between `@Mock` and `Mockito.mock(Class, MockSettings)` in both directions.
+- `EnforceConventionInspection` can now report `InOrder.verify()` calls too, as part of enforcing `BDDMockito.then()` verification.
+- [#27](https://github.com/picimako/mockitools/issues/27): Added an inspection that can report mock objects used in misconfigured `InOrder` verifications.
+
+### Changed
+- Removed support for IJ2021.1. From now on 2021.2 is the earliest version supported.
+
+### Fixed
+- Fixed an issue that when converting from `BDDMockito.then().should(InOrder)` to `Mockito.verify()` the InOrder variable remained.
+
 ## [0.4.1]
 ### Changed
 - Added support for IJ2022.2.

README.md

@@ -3,7 +3,7 @@
 [![Version](https://img.shields.io/jetbrains/plugin/v/18117-mockitools.svg)](https://plugins.jetbrains.com/plugin/18117-mockitools)
 ![Build](https://github.com/picimako/mockitools/workflows/Build/badge.svg)
 [![Downloads](https://img.shields.io/jetbrains/plugin/d/18117-mockitools.svg)](https://plugins.jetbrains.com/plugin/18117-mockitools)
-![](https://img.shields.io/badge/since-IJ2021.1-blue) ![](https://img.shields.io/badge/until-IJ2022.2-blue)
+![](https://img.shields.io/badge/since-IJ2021.2-blue) ![](https://img.shields.io/badge/until-IJ2022.2-blue)
 [![PayPal](https://img.shields.io/badge/donate-paypal-yellow.svg)](https://www.paypal.com/donate/?hosted_button_id=VVLWNZWPBRUDL)
 [![BuyMeACoffee](https://img.shields.io/badge/donate-buymeacoffee-yellow.svg)](https://www.buymeacoffee.com/picimako)
 
@@ -37,7 +37,8 @@ You can find the list of those inspections in the [Mockitools/SonarLint rules](d
 
 ## Why Mockitools is tasty
 
-If [*"Mockito ... tastes really good"* and *"doesn’t give you hangover"*](https://site.mockito.org/#why), this IDE plugin will only make it better. You can find out why, in the dedicated documentation below.
+If [*"Mockito ... tastes really good"* and *"doesn’t give you hangover"*](https://site.mockito.org/#why),
+this IDE plugin will only make it better. You can find out why, in the dedicated documentation below.
 
 - [Mock creation](docs/mock_creation.md)
 - [Stubbing](docs/stubbing.md)

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
     // Java support
     id("java")
     // Kotlin support
-    id("org.jetbrains.kotlin.jvm") version "1.6.21"
+    id("org.jetbrains.kotlin.jvm") version "1.7.0"
     // Gradle IntelliJ Plugin
     id("org.jetbrains.intellij") version "1.5.3"
     // Gradle Changelog Plugin
@@ -26,7 +26,7 @@ repositories {
 // Set the JVM language level used to compile sources and generate files - Java 11 is required since 2020.3
 kotlin {
     jvmToolchain {
-        (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(11))
+        languageVersion.set(JavaLanguageVersion.of(11))
     }
 }
 

docs/mock_creation.md

@@ -318,6 +318,9 @@ to:   @Mock Clazz clazz;
 
 from: mock(Clazz.class, Mockito.withSettings().extraInterfaces(List.class))
 to:   @Mock(extraInterfaces = List.class) Clazz clazz;
+
+from: mock(Clazz.class, Mockito.withSettings().strictness(Strictness.WARN))
+to:   @Mock(strictness = Mock.Strictness.WARN) Clazz clazz;
 ```
 
 Furthermore, the type that is being mocked should be mockable either by Mockito's rules or not being annotated with `@DoNotMock`.

docs/stubbing.md

@@ -4,7 +4,7 @@
 
 ![](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
+Reports exception references in `*Throw()` stubbing methods based on Mockito's rule on checked exceptions
 
 > If [the specified exception types] contain checked exceptions then they have to match one of the checked exceptions in the method signature.
    
@@ -14,17 +14,20 @@ The following constructs are supported:
 - `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.
+In case of each way of stubbing, further chained `*Throw()` calls are supported too. In case of an empty list, no problem is reported.
+
+A quick fix is also available that adds the reported exception to the `throws` clause of the stubbed method.
 
 **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();
+    Mockito.doThrow(
+        IOException.class, //NOT reported because it is in MockObject#doSomething()'s throws list
+        IllegalArgumentException.class, //NOT reported because it is not a checked exception
+        SqlException.class) //reported because it is not in the throws list
+    .when(mock).doSomething();
 }
 
 class MockObject {

docs/verifications.md

@@ -81,23 +81,72 @@ void testMethod() {
 }
 ```
 
+## InOrder with a single verification
+
+![](https://img.shields.io/badge/inspection-orange) ![](https://img.shields.io/badge/since-0.5.0-blue)
+[![](https://img.shields.io/badge/impl-SingleInOrderVerificationInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/verification/SingleInOrderVerificationInspection.java)
+
+This inspection reports `InOrder` local variables on which only one verification is called in the form of either
+an `InOrder.verify()` or a `BDDMockito.then().should(InOrder)` call.
+
+The report can be useful when someone starts implementing an `InOrder` verification to remind them that further verifications need to be implemented,
+and also cases when:
+- the user forgot to add further verification calls,
+- a verification started out as `InOrder` but was forgotten to be converted to simple verification when he/she changed his/her mind
+
+```java
+InOrder inOrder = Mockito.inOrder(mock); //the variable name is highlighted
+inOrder.verify(mock).doSomething();
+```
+
+## Misconfigured InOrder verifications
+
+![](https://img.shields.io/badge/inspection-orange) ![](https://img.shields.io/badge/since-0.5.0-blue)
+[![](https://img.shields.io/badge/impl-UnusedOrUnconfiguredMockInInOrderVerificationInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/verification/UnusedOrUnconfiguredMockInInOrderVerificationInspection.java)
+
+This inspection reports mock objects in `InOrder` verifications in the following cases:
+
+- The mock is added to the arguments of `Mockito.inOrder()` but is not used in any verification performed via that `InOrder` object.
+- The mock is used in an `InOrder` verification, but it is not added to the arguments of `Mockito.inOrder()`.
+
+It can report mocks both in `InOrder.verify()` and `BDDMockito.then().should(InOrder)`.
+
+```java
+InOrder unusedMock = Mockito.inOrder(mock, mock2); //mock2 is reported since it is not used in any of the verifications
+unusedMock.verify(mock).doSomething();
+unusedMock.verify(mock, Mockito.times(2)).doSomething();
+
+InOrder unconfiguredMock = Mockito.inOrder(mock);
+unconfiguredMock.verify(mock).doSomething();
+unconfiguredMock.verify(mock2).doSomething(); //mock2 is reported since it is not added to 'Mockito.inOrder()'
+```
+
 ## Convert between various verification approaches
 
-![](https://img.shields.io/badge/intention-orange) ![](https://img.shields.io/badge/since-0.4.0-blue)
-[![](https://img.shields.io/badge/impl-ConvertMockitoVerifyToBDDMockitoThenIntention-blue)](../src/main/java/com/picimako/mockitools/intention/convert/verification/ConvertMockitoVerifyToBDDMockitoThenIntention.java)
-[![](https://img.shields.io/badge/impl-ConvertBDDMockitoThenToMockitoVerifyIntention-blue)](../src/main/java/com/picimako/mockitools/intention/convert/verification/ConvertBDDMockitoThenToMockitoVerifyIntention.java)
+![](https://img.shields.io/badge/intention-orange) ![](https://img.shields.io/badge/since-0.4.0-blue) ![](https://img.shields.io/badge/since-0.5.0-blue)
+[![](https://img.shields.io/badge/impl-ConvertMockitoVerifyToBDDMockitoThenIntention-blue)](../src/main/java/com/picimako/mockitools/intention/convert/verification/mockitoverify/ConvertFromMockitoVerifyIntention.java)
+[![](https://img.shields.io/badge/impl-ConvertBDDMockitoThenToMockitoVerifyIntention-blue)](../src/main/java/com/picimako/mockitools/intention/convert/verification/bddmockitothen/ConvertFromBDDMockitoIntention.java)
+[![](https://img.shields.io/badge/impl-ConvertBDDMockitoThenToMockitoVerifyIntention-blue)](../src/main/java/com/picimako/mockitools/intention/convert/verification/inorderverify/ConvertFromInOrderVerifyIntention.java)
 
-There are a couple of ways one can approach verification in Mockito: via `org.mockito.Mockito` and `org.mockito.BDDMockito`.
+There are a couple of ways one can approach verification in Mockito: via `org.mockito.Mockito`, `org.mockito.BDDMockito`, `org.mockito.InOrder`.
 
-These intentions can convert between the `Mockito.verify()` and `BDDMockito.then()` call chains if they satisfy the following criteria:
-- if the ['Enforce conventions' inspection](conventions.md#enforce-orgmockitomockito-over-orgmockitobddmockito-and-vice-versa) doesn't enforce
-the verification the user converts from,
-- in case of `Mockito.verify()`, a call on the mock object after `verify()` must be present,
+These intentions can convert between those approaches if they satisfy some preconditions:
+- in case of `Mockito.verify()` and `InOrder.verify()`, a call must be present on the mock object after `verify()` ,
 - while in case of `BDDMockito.then()`, both the `should()` call and a call on the mock object after that must be present.
 
-Conversion of `InOrder` verification is not supported at the moment.
+Below you can see the details of the conversion directions when converting single verifications. Bulk conversions are handled and detailed separately.
+
+Also, reusing an existing `InOrder` instance is not possible when converting to an `InOrder` specific approach,
+it always creates a new `InOrder` local variable.
+
+| Conversion from                     | Options by default                                                                 | Options when `org.mockito.Mockito` is enforced | Options when `org.mockito.BDDMockito` is enforced           |
+|-------------------------------------|------------------------------------------------------------------------------------|------------------------------------------------|-------------------------------------------------------------|
+| `Mockito.verify()`                  | `InOrder.verify()`<br/>`BDDMockito.then()`<br/>`BDDMockito.then().should(InOrder)` | `InOrder.verify()`                             | `BDDMockito.then()`<br/>`BDDMockito.then().should(InOrder)` |
+| `BDDMockito.then()`                 | `Mockito.verify()`<br/>`InOrder.verify()`<br/>`BDDMockito.then().should(InOrder)`  | `Mockito.verify()`<br/>`InOrder.verify()`      | `BDDMockito.then().should(InOrder)`                         |
+| `BDDMockito.then().should(InOrder)` | `Mockito.verify()`<br/>`InOrder.verify()`                                          | `Mockito.verify()`<br/>`InOrder.verify()`      | No action is available.                                     |
+| `InOrder.verify()`                  | `Mockito.verify()`<br/>`BDDMockito.then()`<br/>`BDDMockito.then().should(InOrder)` | `Mockito.verify()`                             | `BDDMockito.then()`<br/>`BDDMockito.then().should(InOrder)` |
 
-**Examples for Mockito.verify() -> BDDMockito.then() direction:**
+**Example (Mockito.verify() -> BDDMockito.then()):**
 
 ```java
 //Without verification mode
@@ -108,3 +157,55 @@ From: Mockito.verify(mock).doSomething();
 From: Mockito.verify(mock, times(2)).doSomething();
   to: BDDMockito.then(mock).should(times(2)).doSomething();
 ```
+
+**Example (BDDMockito.then() -> InOrder.verify()):**
+
+```java
+From: BDDMockito.then(mock).should().doSomething();
+to:
+      InOrder inOrder = Mockito.inOrder(mock);
+      inOrder.verify(mock).doSomething();
+```
+
+### Selection based conversion
+
+![](https://img.shields.io/badge/since-0.5.0-blue)
+
+Conversion of one or more verification call chains is also available via selection in the editor.
+It can convert between `org.mockito.Mockito`, `org.mockito.BDDMockito` and `org.mockito.InOrder` in any direction, with some nuances that should be taken into consideration.
+
+The availability is the same, while the conversion logic is mostly the same, as for the single conversion options:
+- when converting from `BDDMockito.then()`
+  - `InOrder.verify()` as a target is available only when **all** `BDDMockito.then()` chains in the selection use an `InOrder` variable, and they use the same one,
+  - adding an `InOrder` to the `should()` call is available only when **none** of the `BDDMockito.then()` chains use an `InOrder` variable.
+- when a new `InOrder` local variable is created, it is used in all selected and converted verifications. If you want to use different ones for different verifications,
+you can convert them one by one.
+
+#### Examples
+
+Selections are between [\[ and ]].
+
+**InOrder.verify() -> BDDMockito.then()**
+
+```java
+From:
+      InOrder inOrder = Mockito.inOrder(mock, mock2);
+      [[inOrder.verify(mock).doSomething();
+      inOrder.verify(mock2, times(2)).doSomething();]]
+to:
+      InOrder inOrder = Mockito.inOrder(mock, mock2);
+      BDDMockito.then(mock).should().doSomething();
+      BDDMockito.then(mock2).should(times(2)).doSomething();
+```
+
+**Mockito.verify() -> InOrder.verify()**
+
+```java
+From:
+      [[Mockito.verify(mock).doSomething();
+      Mockito.verify(mock2, times(2)).doSomething();]]
+to:
+      InOrder inOrder = Mockito.inOrder(mock, mock2);
+      inOrder.verify(mock).doSomething();
+      inOrder.verify(mock2, times(2)).doSomething();
+```

gradle.properties

@@ -3,23 +3,23 @@
 
 pluginGroup = com.picimako.mockitools
 pluginName = Mockitools
-pluginVersion = 0.4.1
+pluginVersion = 0.5.0
 
 # See https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 # for insight into build numbers and IntelliJ Platform versions.
-pluginSinceBuild = 211
+pluginSinceBuild = 212
 pluginUntilBuild = 222.*
 
 # IntelliJ Platform Properties -> https://github.com/JetBrains/gradle-intellij-plugin#intellij-platform-properties
 platformType = IC
-platformVersion = 2021.1.3
+platformVersion = 2021.2
 
 # Plugin Dependencies -> https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
 # Example: platformPlugins = com.intellij.java, com.jetbrains.php:203.4449.22
 platformPlugins = java
 
 # Gradle Releases -> https://github.com/gradle/gradle/releases
-gradleVersion = 7.4
+gradleVersion = 7.4.2
 
 # Opt-out flag for bundling Kotlin standard library.
 # See https://plugins.jetbrains.com/docs/intellij/kotlin.html#kotlin-standard-library for details.

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

lib/mockito-core-4.2.0.jar renamed to lib/mockito-core-4.6.1.jar

@@ -1,6 +1,6 @@
 //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.inspection;
+package com.picimako.mockitools;
 
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassObjectAccessExpression;