Merge pull request #18 from picimako/v040

Changes for v.0.4.0

Author: picimako

.github/workflows/build.yml

@@ -92,8 +92,8 @@ jobs:
           path: ${{ github.workspace }}/build/reports/pluginVerifier
 
       # Run Qodana inspections
-      - name: Qodana - Code Inspection
-        uses: JetBrains/[email protected]
+#      - name: Qodana - Code Inspection
+#        uses: JetBrains/[email protected]
 
       # Prepare plugin archive content for creating artifact
       - name: Prepare Plugin Artifact

CHANGELOG.md

@@ -4,20 +4,35 @@
 
 ## [Unreleased]
 
+## [0.4.0]
+### Added
+- [#4](https://github.com/picimako/mockitools/issues/4): Added an intention action that can convert `Mockito.mock()` calls to `@Mock` annotated fields.
+- [#8](https://github.com/picimako/mockitools/issues/8): Added a new inspection that reports multiple consecutive calls on `*Throw()` stubbing calls.
+They can be merged into a single such call.
+- [#8](https://github.com/picimako/mockitools/issues/8): Merging of consecutive `*Return()` and `*Throw()` stubbing calls can happen separately if
+there are multiple such sections within a stubbing call chain. They, from now on, also keep line wrapping and indentation after applying the quick fix.
+- [#12](https://github.com/picimako/mockitools/issues/12): Added a new intention action that can convert arguments of `*Throw()` stubbing methods
+from `Type.class` expressions to `new Type()` expressions and vice versa.
+- [#13](https://github.com/picimako/mockitools/issues/13): Added 4 new intention actions that can convert between the various stubbing approaches.
+- [#15](https://github.com/picimako/mockitools/issues/15): Added 2 new intention actions that can convert between the `Mockito.verify()`
+and `BDDMockito.then()` approaches, and vice versa.
+- [#16](https://github.com/picimako/mockitools/issues/16): Added a new inspection that can enforce `org.mockito.Mockito` or `org.mockito.BDDMockito` based
+stubbing and verification.
+
 ## [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).
+- [#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-and-throw-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.
@@ -27,7 +42,7 @@ See [documentation](docs/stubbing.md#consecutive-return-calls-can-be-merged).
     - [Mockito pull request: Add annotation to mark a type as DoNotMock](https://github.com/mockito/mockito/pull/1833/files)
 - Extended `MockTypeInspection` to validate new expressions (i.e. `new Clazz()`) against non-mockable types.
 - [#4](https://github.com/picimako/mockitools/issues/4): Added intention to convert `Mockito.spy()` calls to `@Spy` annotated fields.
-See [documentation](docs/mock_creation.md#convert-mockitospy-calls-to-spy-fields).
+See [documentation](docs/mock_creation.md#convert-mockitomockspy-calls-to-mockspy-fields).
 - [#4](https://github.com/picimako/mockitools/issues/4): Added intention to convert `@Mock` and `@Spy` annotated fields to `Mockito.mock`  and `Mockito.spy()`
 calls, respectively. See [documentation](docs/mock_creation.md#convert-mockspy-fields-to-mockitomockspy-calls).
 

README.md

@@ -1,11 +1,13 @@
 # Mockitools IntelliJ plugin
 
-![Build](https://github.com/picimako/mockitools/workflows/Build/badge.svg)
 [![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.1-blue)
+[![Donate](https://img.shields.io/badge/donate-paypal-yellow.svg)](https://www.paypal.com/donate/?hosted_button_id=VVLWNZWPBRUDL)
 
 <!-- Plugin description -->
-This is an IntelliJ-based plugin for [Mockito](https://site.mockito.org), one of the (if not the) most popular mocking framework for unit tests in Java.
+Mockitools is a plugin for IntelliJ-based IDEs that provides framework integration for [Mockito](https://site.mockito.org), one of the (if not the) most popular mocking frameworks for unit testing in Java.
 <!-- Plugin description end -->
 
 It is available for IntelliJ Community Edition as well as IntelliJ IDEA Ultimate Edition.
@@ -14,32 +16,31 @@ It is available for IntelliJ Community Edition as well as IntelliJ IDEA Ultimate
 
 ### Mockito 4 migration aids
 
-There is a handful of inspections available to help to migrate users from Mockito 2.x/3.x to 4.x.
-
-Since Mockito 4 has been released only recently, they are enabled by default. But, if you are already
-using Mockito 4, it is recommended to disable them, so that IntelliJ doesn't execute inspection that don't make sense
-in terms of your project(s). See <kbd>Java</kbd> > <kbd>Mockito</kbd> > <kbd>Migration aids (v4)</kbd> in Inspection settings.
+There is a handful of inspections available to help migrate users from Mockito 2.x/3.x to 4.x.
 
-Eventually, when a good amount of time passed and many users potentially moved to v4, these inspections will be disabled by default.
+Since Mockito 4 has been released only recently, they are enabled by default, but if you are already
+using Mockito 4, it is recommended to disable them in <kbd>Java</kbd> > <kbd>Mockito</kbd> > <kbd>Migration aids (v4)</kbd> in Inspection settings,
+so they are not executed for your project. As users move to v4, eventually they will get disabled by default.
 
-The list and details of those inspections can be found in [Mockito v4 migration aids](docs/migration_aids_v4.md).
+See the list of those inspections in [Mockito v4 migration aids](docs/migration_aids_v4.md).
 
 ### SonarLint
 
-SonarLint also have a few inspections for Mockito, you can find them under the [Java category](https://rules.sonarsource.com/java?search=mockito).
+SonarLint also has a few inspections for Mockito that you can find under the [Java category](https://rules.sonarsource.com/java?search=mockito) of their rules.
 
-If you use SonarLint or any other plugin that has checks for things provided by the Mockitools plugin, it is advised adjusting your settings,
-so that only those versions of the inspections are enabled that you feel comfortable working with.
+If you use SonarLint to validate things that are available in Mockitools too, it is advised to adjust your settings,
+and have only those ones enabled that you feel comfortable working with. Be it in SonarLint or in Mockitools.
 This will help declutter your editor from duplicate highlights for the same problems, and will also improve the analysis performance in the IDE.
 
-You can find the list of those inspections in the [Mockitools/SonarLint rules](docs/mockitools_sonarlint_rules.md) document.
+You can find the list of those inspections in the [Mockitools/SonarLint rules](docs/sonarlint_rules.md) document.
 
 ## 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.
 
 - [Mock creation](docs/mock_creation.md)
-- [Mockito verifications](docs/mockito_verifications.md)
+- [Stubbing](docs/stubbing.md)
+- [Mockito verifications](docs/verifications.md)
 - [Argument matching and capturing](docs/argument_matching_capture.md)
 - [Version migration aids](docs/migration_aids_v4.md)
 - [Framework integration](docs/framework_integration.md)

build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
     // Kotlin support
 //    id("org.jetbrains.kotlin.jvm") version "1.6.10"
     // Gradle IntelliJ Plugin
-    id("org.jetbrains.intellij") version "1.4.0"
+    id("org.jetbrains.intellij") version "1.5.3"
     // Gradle Changelog Plugin
     id("org.jetbrains.changelog") version "1.3.1"
     // Gradle Qodana Plugin

docs/argument_matching_capture.md

@@ -8,14 +8,13 @@ Argument matchers are used inconsistently (and incorrectly) when, during stubbin
 mixed manner. That is not permitted by Mockito, and test execution fails when it encounters this problem. As per Mockito documentation:
 > If you are using argument matchers, all arguments have to be provided by matchers.
 
-For example:
+For example, the followings are invalid, and would block test execution.
 
 ```java
 Mockito.when(mock.method(eq("some string"), 25)).thenReturn(10);
 //or
 Mockito.when(mock.method("some string", geq(25))).thenReturn(10);
 ```
-are invalid, and would block test execution.
 
 The following ways of stubbing are supported by this inspection:
 - `Mockito.when()`
@@ -38,7 +37,7 @@ SonarLint also have a rule for this validation: [Mockito argument matchers shoul
 ![](https://img.shields.io/badge/since-0.1.0-blue) [![](https://img.shields.io/badge/implementation-CaptorFieldInitializationInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/CaptorFieldInitializationInspection.java)
 
 Since `@Captor` annotated fields are initialized automagically by Mockito via `MockitoJUnitRunner`, `MockitoJUnit.rule()` or
-`MockitoAnnotations.initMocks()` / `MockitoAnnotations.openMocks()`, there is no need to explicitly initialize them.
+`MockitoAnnotations.initMocks()/openMocks()`, there is no need to explicitly initialize them.
 
 This inspection reports `ArgumentCaptor` type `@Captor` fields that have an initializer specified.
 
@@ -70,27 +69,25 @@ Fields that are annotated as `@Captor` must have `ArgumentCaptor` as their type,
 This inspection reports fields that are annotated as `@Captor` but their types are not `ArgumentCaptor`.
 It also provides a quick fix (*Convert field type to ArgumentCaptor<>*) to convert the field type to ArgumentCaptor with the appropriate generic type.
 
-See some examples below (with the before-after states):
-
 ```java
 //-- arrays --
 
 @Captor
-String[] captor;
+String[] captor; //before
 @Captor
-ArgumentCaptor<String[]> captor;
+ArgumentCaptor<String[]> captor; //after
 
 //-- primitive types --
 
 @Captor
-char captor;
+char captor; //before
 @Captor
-ArgumentCaptor<Character> captor; //field type is replaced with its boxed type
+ArgumentCaptor<Character> captor; //after: field type is replaced with its boxed type
 
 //-- types with generic types --
 
 @Captor
-List<List<String>> captor;
+List<List<String>> captor; //before
 @Captor
-ArgumentCaptor<List<List<String>>> captor;
+ArgumentCaptor<List<List<String>>> captor; //after
 ```

docs/conventions.md

@@ -0,0 +1,39 @@
+# Project Conventions
+
+### Enforce org.mockito.Mockito over org.mockito.BDDMockito and vice versa
+
+![](https://img.shields.io/badge/inspection-orange) ![](https://img.shields.io/badge/since-0.4.0-blue)
+[![](https://img.shields.io/badge/implementation-EnforceConventionInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/EnforceConventionInspection.java)
+
+Projects might want to enforce certain coding conventions for Mockito. This inspection helps with that.
+
+It reports calls to static stubbing and verification methods of `org.mockito.Mockito`, if `org.mockito.BDDMockito`
+based stubbing and verification must be used, and vice versa.
+Whether to enforce one or the other can be configured in the inspection settings.
+
+Notes:
+- It is not enabled by default since a project might not want to enforce these conventions.
+- There are no dedicated quick fixes, since separate intention actions are available to convert between these approaches:
+  - [conversion of stubbing](stubbing.md#convert-between-various-stubbing-approaches)
+  - [conversion of verification](verifications.md#convert-between-various-verification-approaches)
+- It doesn't support `InOrder` verification at the moment.
+
+**Example:**
+
+Let's say we want to enforce `org.mockito.BDDMockito` based calls, then the following calls would all be reported: 
+
+```java
+//stubbing
+Mockito.when(mockObject.doSomething()).thenReturn(10);
+Mockito.doReturn(10).when(mockObject).doSomething();
+Mockito.doThrow(IllegalArgumentException.class).when(mockObject).doSomething();
+Mockito.doAnswer(Answers.CALLS_REAL_METHODS).when(mockObject).doSomething();
+Mockito.doCallRealMethod().when(mockObject).doSomething();
+Mockito.doNothing().when(mockObject).voidMethod();
+
+//verification
+Mockito.verify(mockObject, Mockito.times(2)).doSomething();
+Mockito.verifyNoMoreInteractions(mockObject);
+Mockito.verifyNoInteractions(mockObject);
+Mockito.verifyZeroInteractions(mockObject); //only in Mockito 3
+```

docs/framework_integration.md

@@ -13,6 +13,8 @@ According to the javadoc of the [`@NotExtensible`](https://javadoc.io/doc/org.mo
 
 > Indicates to the user that she should not provide custom implementations of given type.
 
+The inspection is applied to interfaces and named classes that can inherit from other types.
+
 ```java
 import org.mockito.MockSettings;
 import java.util.List;
@@ -21,5 +23,3 @@ import java.util.List;
 interface SomeInterface extends MockSettings, List<String> {
 }
 ```
-
-The inspection is applied to interfaces and named classes that can inherit from other types.

docs/migration_aids_v4.md

@@ -5,7 +5,14 @@ some inspections to help migrate from one version to another; in the context of
 
 Check out the [Mockito 4.0.0 release notes](https://github.com/mockito/mockito/releases/tag/v4.0.0) for details.
 
-### Argument matchers are called via org.mockito.Matchers instead of org.mockito.ArgumentMatchers 
+- [Argument matchers are called via org.mockito.Matchers instead of org.mockito.ArgumentMatchers](#argument-matchers-are-called-via-orgmockitomatchers-instead-of-orgmockitoargumentmatchers)
+- [Usage of deprecated anyX() matchers](#usage-of-deprecated-anyx-matchers)
+- [Usage of parameterized variants of isNull(), isNotNull() and notNull()](#usage-of-parameterized-variants-of-isnull-isnotnull-and-notnull)
+- [Usage of deprecated verify methods](#usage-of-deprecated-verify-methods)
+- [Usage of deprecated plugins classes](#usage-of-deprecated-plugins-classes)
+- [Usage of deprecated JUnit runners](#usage-of-deprecated-junit-runners)
+
+### Argument matchers are called via org.mockito.Matchers instead of org.mockito.ArgumentMatchers
 
 ![](https://img.shields.io/badge/since-0.1.0-blue) [![](https://img.shields.io/badge/implementation-ArgumentMatchersCalledViaMatchersInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/migrationaids/v4/ArgumentMatchersCalledViaMatchersInspection.java)
 ![](https://img.shields.io/badge/mockito-2.x-orange) ![](https://img.shields.io/badge/mockito-3.x-orange)
@@ -65,7 +72,7 @@ Mockito.when(mock.method(ArgumentMatchers.anyCollection())).thenReturn(10);
 #### Notes
 
 If a matcher is not used with static import and referenced via `org.mockito.Matchers`, it is also replaced
-with the `org.mockito.ArgumentMatchers` qualifier. See the corresponding logic in [ReplaceMatchersWithArgumentMatchersQuickFix](../src/main/java/com/picimako/mockitools/inspection/migrationaids/v4/UseArgumentMatchersInsteadOfMatchersInspection.java).
+with the `org.mockito.ArgumentMatchers` qualifier. See the corresponding logic in [ReplaceAnyXOfWithAnyXQuickFix](../src/main/java/com/picimako/mockitools/inspection/migrationaids/v4/UsageOfAnyMatchersInspection.java).
 
 ### Usage of parameterized variants of isNull(), isNotNull() and notNull()
 
@@ -89,7 +96,7 @@ Mockito.when(mock.method(ArgumentMatchers.notNull())).thenReturn(10);
 
 ### Usage of deprecated verify methods
 
-![](https://img.shields.io/badge/since-0.1.0-blue) [![](https://img.shields.io/badge/implementation-DeprecatedMockedStaticVerifyInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/migrationaids/v4/DeprecatedMockedStaticVerifyInspection.java)
+![](https://img.shields.io/badge/since-0.1.0-blue) [![](https://img.shields.io/badge/implementation-UsageOfDeprecatedVerifyInspection-blue)](../src/main/java/com/picimako/mockitools/inspection/migrationaids/v4/UsageOfDeprecatedVerifyInspection.java)
 ![](https://img.shields.io/badge/mockito-3.x-orange)
 
 #### MockedStatic.verify()