Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 chrisly42
|
ce0b5ce872 | ||
|
chrisly42
|
d48c71d4ea | ||
|
chrisly42
|
1340a34782 | ||
|
chrisly42
|
fbde6b3387 | ||
|
chrisly42
|
b9110d226e |
+1
-1
@@ -1,6 +1,6 @@
|
||||
language: java
|
||||
jdk:
|
||||
- openjdk8
|
||||
- openjdk11
|
||||
|
||||
before_script:
|
||||
- chmod +x gradlew
|
||||
|
||||
@@ -46,12 +46,18 @@ Using strings is not safe for refactoring (and before Java 8 Lambdas were availa
|
||||
creating extractor functions just for testing purpose was a bit too tedious).
|
||||
|
||||
This plugin adds support for referencing these fields (so you can ctrl(/cmd)-click on the
|
||||
string to go to the definition) and also allows safe refactoring on the
|
||||
string to go to the definition) and allows safe refactoring on the
|
||||
fields (refactoring a getter method without a corresponding field will not work
|
||||
correctly right now).
|
||||
correctly right now) too.
|
||||
|
||||
## Usage
|
||||
|
||||
Cajon (though written in Kotlin) *only works with Java projects*.
|
||||
There does not seem too much demand for AssertJ within Kotlin projects
|
||||
and although possible, it would require a complete rewrite as the PSI
|
||||
stuff in IntelliJ is very Java focused. Almost zero feedback is also not helping.
|
||||
Enough bickering.
|
||||
|
||||
The plugin will report inspections in your opened editor file as warnings.
|
||||
You can then quick-fix these with your quick-fix hotkey (usually Alt-Return or Opt-Return).
|
||||
|
||||
@@ -87,7 +93,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
.anotherCondition();
|
||||
```
|
||||
Joining will work on actual expressions inside ```assertThat()``` that are equivalent expressions,
|
||||
except for method calls with known side-effect methods such as ```Iterator.next()``` and
|
||||
except for method calls with known side effect methods such as ```Iterator.next()``` and
|
||||
pre/post-increment/decrement operations -- please notify me about others.
|
||||
|
||||
The comments of the statements will be preserved. When using ```extracting()``` or similar,
|
||||
@@ -136,12 +142,19 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
- AssertThatInvertedBooleanCondition
|
||||
|
||||
Inverts the boolean condition to make it more readable.
|
||||
Inverts the boolean condition in either ```assertThat()``` or ```isEqualTo()```/```isNotEqualTo()```
|
||||
to make it more readable.
|
||||
|
||||
```
|
||||
from: assertThat(!booleanValue).isEqualTo(true/false/Boolean.TRUE/Boolean.FALSE);
|
||||
from: assertThat(!booleanValue).isTrue()/isFalse();
|
||||
to: assertThat(booleanValue).isFalse()/isTrue();
|
||||
|
||||
from: assertThat(booleanValue).isEqualTo(!primitiveBooleanExpression);
|
||||
to: assertThat(booleanValue).isNotEqualTo(primitiveBooleanExpression);
|
||||
|
||||
from: assertThat(booleanValue).isNotEqualTo(!primitiveBooleanExpression);
|
||||
to: assertThat(booleanValue).isEqualTo(primitiveBooleanExpression);
|
||||
```
|
||||
|
||||
- AssertThatInstanceOf
|
||||
@@ -308,10 +321,10 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
to: assertThat(map).doesNotContainKey(key);
|
||||
```
|
||||
|
||||
The last transformation is the default, but may not be 100% equivalent depending whether the map
|
||||
is a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
|
||||
The last transformation is the default, but may not be 100% equivalent depending upon the map
|
||||
being a degenerated case with ```null``` values, where ```map.get(key)``` returns ```null```,
|
||||
but ```containsKey(key)``` is ```true```.
|
||||
For that special case (which usually is the result of a bad design decision!)
|
||||
For that special case (which is usually the result of a bad design decision!)
|
||||
the quickfix should rather generate ```assertThat(map).containsEntry(key, null)```.
|
||||
Therefore, the behavior can be configured in the settings for this inspection to either
|
||||
create the default case (```doesNotContainKey```), the degenerated case (```containsEntry```),
|
||||
@@ -409,11 +422,21 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
- AssertThatEnumerableIsEmpty
|
||||
|
||||
Uses ```isEmpty()``` for ```hasSize(0)``` iterable assertions instead.
|
||||
Uses ```isEmpty()``` for ```hasSize(0)```, ```hasSizeLessThanOrEqualTo(0)```, and
|
||||
```hasSizeLessThan(1)``` iterable (enumerable) assertions instead.
|
||||
|
||||
Also suggests ```isNotEmpty()``` for ```hasSizeGreaterThan(0)``` and
|
||||
```hasSizeGreaterThanOrEqualTo(1)```.
|
||||
|
||||
```
|
||||
from: assertThat(enumerable).hasSize(0);
|
||||
from: assertThat(enumerable).hasSizeLessThanOrEqualTo(0);
|
||||
from: assertThat(enumerable).hasSizeLessThan(1);
|
||||
to: assertThat(enumerable).isEmpty();
|
||||
|
||||
from: assertThat(enumerable).hasSizeGreaterThan(0);
|
||||
from: assertThat(enumerable).hasSizeGreaterThanOrEqualTo(1);
|
||||
to: assertThat(enumerable).isNotEmpty();
|
||||
```
|
||||
|
||||
- AssertThatSize
|
||||
@@ -563,7 +586,7 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
If the assertions is either ```isEqualTo()``` or ```hasSameHashCodeAs()``` it may be checking custom
|
||||
```equals()``` or ```hashCode()``` behavior. If the test method name containing the statement has a
|
||||
name that contains 'equal' or 'hashcode' (case insensitive), the warning will be weakened to information
|
||||
name that contains 'equal' or 'hashcode' (case-insensitive), the warning will be weakened to information
|
||||
level.
|
||||
|
||||
- ImplicitAssertion
|
||||
@@ -777,13 +800,14 @@ You can toggle the various inspections in the Settings/Editor/Inspections in the
|
||||
|
||||
Cajon is written in Kotlin 1.3.
|
||||
|
||||
Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one that I'm aware of ;) ).
|
||||
The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing and it took me quite a while to make it work with JUnit 5.
|
||||
Cajon is probably the only plugin that uses JUnit 5 Jupiter for unit testing so far (or at least the only one I'm aware of ;) ).
|
||||
The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to make it work with JUnit 5.
|
||||
Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
|
||||
|
||||
## Planned features
|
||||
- More Optional fixes such as ```opt1.get() == opt2.get()``` etc.
|
||||
- More moving out of methods for LocalDate/Time etc.
|
||||
- assertThat(foo.toLowerCase()/toUpperCase()).isEqualTo("foo") -> assertThat(foo).isEqualToIgnoringCase()
|
||||
- Extraction with property names to lambda/method reference with Java 8
|
||||
|
||||
```
|
||||
@@ -793,9 +817,17 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
|
||||
## Changelog
|
||||
|
||||
#### V1.11 (03-Oct-20) Day of German Unity Edition
|
||||
- Now is being built with JDK 11 (with Java 8 target).
|
||||
- Updated various dependencies (Kotlin 1.40.10) and AssertJ 3.17.2.
|
||||
- Fixed the ImplicitAssertion inspection that broke the plugin with IntelliJ 2020.3 EAP as reported by Frédéric Thomas. Thanks!
|
||||
- Added new singleElement() from AssertJ >= 3.17.0 to ImplicitAssertionInspection.
|
||||
- Added several cases for ```hasSizeGreaterThan/LessThan/OrEqualTo()``` for EnumerablesEmpty inspection.
|
||||
- Added inversion of boolean conditions inside ```isEqualTo()``` and ```isNotEqualTo()``` for InvertedBooleanCondition inspection.
|
||||
|
||||
#### V1.10 (31-Jul-20) Friday the 31st Edition
|
||||
- Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
|
||||
- Fixed two possible index out of bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
|
||||
- Fixed two possible index out-of-bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
|
||||
|
||||
#### V1.9 (25-Feb-20) Mardi Gras Edition
|
||||
- TwistedAssertion inspection will no longer warn for ```.matches()``` and ```doesNotMatch()``` for regular expressions.
|
||||
@@ -831,10 +863,10 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
Specifically, uses of ```matches()```, ```compareToIgnoreCase()```, ```indexOf()```, and ```trim()```.
|
||||
|
||||
#### V1.5 (24-Sep-19)
|
||||
- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out of bounds exception.
|
||||
- Fix for AssertThatCollectionOrMap inspection sometimes causing an index out-of-bounds exception.
|
||||
- AssertThatGuavaOptional inspections will now avoid conversions from ```.get()``` to ```.contains()```
|
||||
for array types (currently not correctly supported by ```contains()``` in AssertJ-Guava).
|
||||
- Added an settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with ```null``` values.
|
||||
- Added a settings option for AssertThatCollectionOrMap inspection respecting the degenerated case of maps with ```null``` values.
|
||||
It is now possible to change the behavior for ```map.get(key) == null```, so it can offer either ```.doesNotContainKey()``` (default)
|
||||
or ```.containsEntry(key, null)```, or even both.
|
||||
- Fixes to AssertThatSize inspection after extending it for Maps in previous release as not all
|
||||
@@ -920,7 +952,7 @@ Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for yo
|
||||
|
||||
#### V0.2 (01-Apr-19)
|
||||
- Fixed descriptions and quick fix texts.
|
||||
- Fixed highlighting of found problems and also 'Run inspection by Name' returning nothing.
|
||||
- Fixed highlighting of found problems and 'Run inspection by Name' returning nothing, too.
|
||||
|
||||
#### V0.1 (31-Mar-19)
|
||||
- Initial release.
|
||||
+20
-12
@@ -1,13 +1,15 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'org.jetbrains.intellij' version '0.4.21'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.4.0-rc'
|
||||
id 'org.jetbrains.intellij' version '0.4.26'
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.4.10'
|
||||
id 'jacoco'
|
||||
id 'com.github.kt3k.coveralls' version '2.10.1'
|
||||
id 'com.github.kt3k.coveralls' version '2.10.2'
|
||||
}
|
||||
|
||||
group 'de.platon42'
|
||||
version '1.10'
|
||||
version '1.11'
|
||||
sourceCompatibility = "1.8"
|
||||
targetCompatibility = "1.8"
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
@@ -20,10 +22,10 @@ repositories {
|
||||
|
||||
dependencies {
|
||||
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
testImplementation "org.assertj:assertj-core:3.16.1"
|
||||
testImplementation "org.assertj:assertj-core:3.17.2"
|
||||
testImplementation "org.assertj:assertj-guava:3.4.0"
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
|
||||
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
|
||||
testImplementation "org.jetbrains.kotlin:kotlin-test"
|
||||
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
|
||||
}
|
||||
@@ -31,11 +33,13 @@ dependencies {
|
||||
compileKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
|
||||
compileTestKotlin {
|
||||
kotlinOptions.jvmTarget = "1.8"
|
||||
}
|
||||
|
||||
intellij {
|
||||
version '2020.2'
|
||||
version '2020.2.2' // LATEST-EAP-SNAPSHOT
|
||||
// pluginName 'Concise AssertJ Optimizing Nitpicker (Cajon)'
|
||||
updateSinceUntilBuild false
|
||||
plugins = ['java']
|
||||
@@ -43,10 +47,14 @@ intellij {
|
||||
|
||||
patchPluginXml {
|
||||
changeNotes """
|
||||
<h4>V1.10 (31-Jul-20) Friday the 31st Edition</h4>
|
||||
<h4>V1.11 (03-Oct-20) Day of German Unity Edition</h4>
|
||||
<ul>
|
||||
<li>Updated libraries to the latest versions (including AssertJ 3.16.1 and Kotlin 1.40-rc).
|
||||
<li>Fixed two possible index out of bounds exceptions in ExtractorReferenceContributor and BogusAssertionInspection.
|
||||
<li>Now is being built with JDK 11 (with Java 8 target).
|
||||
<li>Updated various dependencies (Kotlin 1.40.10) and AssertJ 3.17.2.
|
||||
<li>Fixed the ImplicitAssertion inspection that broke the plugin with IntelliJ 2020.3 EAP as reported by Frédéric Thomas. Thanks!
|
||||
<li>Added new singleElement() from AssertJ >= 3.17.0 to ImplicitAssertionInspection.
|
||||
<li>Added several cases for hasSizeGreaterThan/LessThan/OrEqualTo() for EnumerablesEmpty inspection.
|
||||
<li>Added inversion of boolean conditions inside isEqualTo() and isNotEqualTo() for InvertedBooleanCondition inspection.
|
||||
</ul>
|
||||
<p>Full changelog available at <a href="https://github.com/chrisly42/cajon-plugin#changelog">Github project site</a>.</p>
|
||||
"""
|
||||
@@ -60,7 +68,7 @@ test {
|
||||
}
|
||||
|
||||
jacoco {
|
||||
toolVersion = '0.8.5'
|
||||
toolVersion = '0.8.6'
|
||||
}
|
||||
|
||||
jacocoTestReport {
|
||||
|
||||
+1
-1
@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-all.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-all.zip
|
||||
|
||||
@@ -33,7 +33,7 @@ val MORE_EXTENSION_POINTS = CallMatcher.instanceCall(
|
||||
"are", "areNot", "have", "doNotHave",
|
||||
"areAtLeast", "areAtLeastOne", "areAtMost", "areExactly",
|
||||
"haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
|
||||
"hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
|
||||
"singleElement", "hasOnlyOneElementSatisfying", "anyMatch", "noneMatch", "anySatisfy", "noneSatisfy"
|
||||
)!!
|
||||
|
||||
val COMPLEX_CALLS_THAT_MAKES_STUFF_TRICKY = CallMatcher.anyOf(
|
||||
|
||||
+10
@@ -72,6 +72,8 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
|
||||
val ASSERT_THAT_BOOLEAN = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
|
||||
.parameterTypes("boolean")!!
|
||||
val ASSERT_THAT_BOOLEAN_OBJ = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
|
||||
.parameterTypes(CommonClassNames.JAVA_LANG_BOOLEAN)!!
|
||||
|
||||
val ASSERT_THAT_ANY = CallMatcher.staticCall(ASSERTIONS_CLASSNAME, MethodNames.ASSERT_THAT)
|
||||
.parameterCount(1)!!
|
||||
@@ -126,6 +128,14 @@ abstract class AbstractAssertJInspection : AbstractBaseJavaLocalInspectionTool()
|
||||
.parameterCount(0)!!
|
||||
val HAS_SIZE = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE)
|
||||
.parameterTypes("int")!!
|
||||
val HAS_SIZE_GREATER_THAN_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_GREATER_THAN)
|
||||
.parameterTypes("int")!!
|
||||
val HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_GREATER_THAN_OR_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
val HAS_SIZE_LESS_THAN_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_LESS_THAN)
|
||||
.parameterTypes("int")!!
|
||||
val HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT = CallMatcher.instanceCall(ENUMERABLE_ASSERT_INTERFACE, MethodNames.HAS_SIZE_LESS_THAN_OR_EQUAL_TO)
|
||||
.parameterTypes("int")!!
|
||||
|
||||
val IS_GREATER_THAN_INT = CallMatcher.instanceCall(ABSTRACT_COMPARABLE_ASSERT_CLASSNAME, MethodNames.IS_GREATER_THAN)
|
||||
.parameterTypes("int")!!
|
||||
|
||||
+7
-6
@@ -21,18 +21,19 @@ class AssertThatBooleanConditionInspection : AbstractAssertJInspection() {
|
||||
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
|
||||
super.visitMethodCallExpression(expression)
|
||||
if (!expression.hasAssertThat()) return
|
||||
val matchingCalls = listOf(
|
||||
IS_EQUAL_TO_OBJECT, IS_EQUAL_TO_BOOLEAN,
|
||||
IS_NOT_EQUAL_TO_OBJECT, IS_NOT_EQUAL_TO_BOOLEAN
|
||||
).map { it.test(expression) }
|
||||
if (matchingCalls.none { it }) return
|
||||
val isEqualToObject = IS_EQUAL_TO_OBJECT.test(expression)
|
||||
val isEqualToPrimitive = IS_EQUAL_TO_BOOLEAN.test(expression)
|
||||
val isNotEqualToObject = IS_NOT_EQUAL_TO_OBJECT.test(expression)
|
||||
val isNotEqualToPrimitive = IS_NOT_EQUAL_TO_BOOLEAN.test(expression)
|
||||
|
||||
if (!(isEqualToObject || isEqualToPrimitive || isNotEqualToObject || isNotEqualToPrimitive)) return
|
||||
if (!checkAssertedType(expression, ABSTRACT_BOOLEAN_ASSERT_CLASSNAME)) return
|
||||
|
||||
val expectedExpression = expression.firstArg
|
||||
if (!TypeConversionUtil.isBooleanType(expectedExpression.type)) return
|
||||
|
||||
val expectedResult = expression.calculateConstantParameterValue(0) as? Boolean ?: return
|
||||
val flippedBooleanTest = matchingCalls.drop(2).any { it }
|
||||
val flippedBooleanTest = isNotEqualToObject || isNotEqualToPrimitive
|
||||
|
||||
val replacementMethod = (expectedResult xor flippedBooleanTest).map(MethodNames.IS_TRUE, MethodNames.IS_FALSE)
|
||||
registerSimplifyMethod(holder, expression, replacementMethod)
|
||||
|
||||
+11
-4
@@ -5,6 +5,7 @@ import com.intellij.psi.JavaElementVisitor
|
||||
import com.intellij.psi.PsiElementVisitor
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import com.intellij.psi.PsiStatement
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.MethodNames
|
||||
import de.platon42.intellij.plugins.cajon.calculateConstantParameterValue
|
||||
import de.platon42.intellij.plugins.cajon.hasAssertThat
|
||||
@@ -12,7 +13,7 @@ import de.platon42.intellij.plugins.cajon.hasAssertThat
|
||||
class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
|
||||
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting an empty enumerable"
|
||||
private const val DISPLAY_NAME = "Asserting an empty or not empty enumerable"
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
@@ -23,11 +24,17 @@ class AssertThatEnumerableIsEmptyInspection : AbstractAssertJInspection() {
|
||||
super.visitMethodCallExpression(expression)
|
||||
if (!expression.hasAssertThat()) return
|
||||
val isLastExpression = expression.parent is PsiStatement
|
||||
if (!(HAS_SIZE.test(expression) && isLastExpression)) return
|
||||
|
||||
val value = expression.calculateConstantParameterValue(0) ?: return
|
||||
if (value == 0) {
|
||||
|
||||
val isEmpty = (CallMatcher.anyOf(HAS_SIZE, HAS_SIZE_LESS_THAN_OR_EQUAL_TO_INT).test(expression) && (value == 0)) ||
|
||||
(HAS_SIZE_LESS_THAN_INT.test(expression) && (value == 1));
|
||||
val isNotEmpty = (HAS_SIZE_GREATER_THAN_INT.test(expression) && (value == 0)) ||
|
||||
(HAS_SIZE_GREATER_THAN_OR_EQUAL_TO_INT.test(expression) && (value == 1));
|
||||
|
||||
if (isEmpty && isLastExpression) {
|
||||
registerSimplifyMethod(holder, expression, MethodNames.IS_EMPTY)
|
||||
} else if (isNotEmpty) {
|
||||
registerSimplifyMethod(holder, expression, MethodNames.IS_NOT_EMPTY)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+27
-6
@@ -1,8 +1,13 @@
|
||||
package de.platon42.intellij.plugins.cajon.inspections
|
||||
|
||||
import com.intellij.codeInspection.ProblemsHolder
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.*
|
||||
import com.intellij.psi.util.PsiUtil
|
||||
import com.intellij.psi.util.TypeConversionUtil
|
||||
import com.siyeh.ig.callMatcher.CallMatcher
|
||||
import de.platon42.intellij.plugins.cajon.*
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryExpressionQuickFix
|
||||
import de.platon42.intellij.plugins.cajon.quickfixes.InvertUnaryStatementQuickFix
|
||||
|
||||
class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection() {
|
||||
@@ -10,6 +15,8 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
|
||||
companion object {
|
||||
private const val DISPLAY_NAME = "Asserting an inverted boolean condition"
|
||||
private const val INVERT_CONDITION_MESSAGE = "Condition inside assertThat() could be inverted"
|
||||
private const val REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE = "Invert condition in %s() and use %s() instead"
|
||||
private const val INVERT_OUTSIDE_CONDITION_MESSAGE = "Condition outside assertThat() could be inverted"
|
||||
}
|
||||
|
||||
override fun getDisplayName() = DISPLAY_NAME
|
||||
@@ -20,13 +27,27 @@ class AssertThatInvertedBooleanConditionInspection : AbstractAssertJInspection()
|
||||
super.visitMethodCallExpression(expression)
|
||||
if (!expression.hasAssertThat()) return
|
||||
val staticMethodCall = expression.findStaticMethodCall() ?: return
|
||||
if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
|
||||
expression.getExpectedBooleanResult() ?: return
|
||||
if (expression.getExpectedBooleanResult() != null) {
|
||||
if (!ASSERT_THAT_BOOLEAN.test(staticMethodCall)) return
|
||||
val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
|
||||
if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
|
||||
val outmostMethodCall = expression.findOutmostMethodCall() ?: return
|
||||
holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
|
||||
}
|
||||
} else {
|
||||
if (!CallMatcher.anyOf(ASSERT_THAT_BOOLEAN, ASSERT_THAT_BOOLEAN_OBJ).test(staticMethodCall)) return
|
||||
val isEqualTo = CallMatcher.anyOf(IS_EQUAL_TO_BOOLEAN, IS_EQUAL_TO_OBJECT).test(expression)
|
||||
val isNotEqualTo = CallMatcher.anyOf(IS_NOT_EQUAL_TO_BOOLEAN, IS_NOT_EQUAL_TO_OBJECT).test(expression)
|
||||
if (!(isEqualTo || isNotEqualTo)) return
|
||||
val prefixExpression = expression.firstArg as? PsiPrefixExpression ?: return
|
||||
val operand = PsiUtil.skipParenthesizedExprDown(prefixExpression.operand) ?: return
|
||||
if (!TypeConversionUtil.isPrimitiveAndNotNull(operand.type)) return
|
||||
val originalMethod = getOriginalMethodName(expression) ?: return
|
||||
|
||||
val prefixExpression = staticMethodCall.firstArg as? PsiPrefixExpression ?: return
|
||||
if (prefixExpression.operationTokenType == JavaTokenType.EXCL) {
|
||||
val outmostMethodCall = expression.findOutmostMethodCall() ?: return
|
||||
holder.registerProblem(outmostMethodCall, INVERT_CONDITION_MESSAGE, InvertUnaryStatementQuickFix())
|
||||
val replacementMethod = isEqualTo.map(MethodNames.IS_NOT_EQUAL_TO, MethodNames.IS_EQUAL_TO)
|
||||
val description = REMOVE_INSTANCEOF_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
|
||||
val textRange = TextRange(staticMethodCall.textLength, expression.textLength)
|
||||
holder.registerProblem(expression, textRange, INVERT_OUTSIDE_CONDITION_MESSAGE, InvertUnaryExpressionQuickFix(description, replacementMethod))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+1
-2
@@ -39,11 +39,10 @@ class ImplicitAssertionInspection : AbstractAssertJInspection() {
|
||||
"startsWith", "endsWith", "containsNull", "doesNotContainNull",
|
||||
"are", "areNot", "have", "doNotHave", "areAtLeastOne", "areAtLeast", "areAtMost", "areExactly",
|
||||
"haveAtLeastOne", "haveAtLeast", "haveAtMost", "haveExactly",
|
||||
"doesNotHave", "doesNotHaveSameClassAs",
|
||||
"hasAtLeastOneElementOfType", "hasOnlyElementsOfType", "hasOnlyElementsOfTypes",
|
||||
"doesNotHaveAnyElementsOfTypes",
|
||||
"has", "doesNotHave",
|
||||
"hasOnlyOneElementSatisfying", "hasSameElementsAs",
|
||||
"singleElement", "hasOnlyOneElementSatisfying", "hasSameElementsAs",
|
||||
"allMatch", "allSatisfy", "anyMatch", "anySatisfy", "noneMatch", "noneSatisfy"
|
||||
)!!
|
||||
|
||||
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
package de.platon42.intellij.plugins.cajon.quickfixes
|
||||
|
||||
import com.intellij.codeInspection.ProblemDescriptor
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.psi.PsiMethodCallExpression
|
||||
import com.intellij.psi.PsiUnaryExpression
|
||||
import com.intellij.psi.util.PsiUtil
|
||||
import de.platon42.intellij.plugins.cajon.createExpectedMethodCall
|
||||
import de.platon42.intellij.plugins.cajon.firstArg
|
||||
import de.platon42.intellij.plugins.cajon.replaceQualifierFromMethodCall
|
||||
|
||||
class InvertUnaryExpressionQuickFix(description: String, private val replacementMethod: String) : AbstractCommonQuickFix(description) {
|
||||
|
||||
companion object {
|
||||
private const val INVERT_CONDITION_DESCRIPTION = "Invert condition in isEqualTo()/isNotEqualTo() expressions"
|
||||
}
|
||||
|
||||
override fun getFamilyName(): String {
|
||||
return INVERT_CONDITION_DESCRIPTION
|
||||
}
|
||||
|
||||
override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
|
||||
val methodCall = descriptor.startElement as? PsiMethodCallExpression ?: return
|
||||
val assertExpression = methodCall.firstArg as? PsiUnaryExpression ?: return
|
||||
val operand = PsiUtil.skipParenthesizedExprDown(assertExpression.operand) ?: return
|
||||
|
||||
val expectedExpression = createExpectedMethodCall(assertExpression, replacementMethod, operand)
|
||||
expectedExpression.replaceQualifierFromMethodCall(methodCall)
|
||||
methodCall.replace(expectedExpression)
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
<html>
|
||||
<body>
|
||||
Turns assertThat(enumerable).hasSize(0) into assertThat(enumerable).isEmpty().
|
||||
Turns assertThat(enumerable).hasSize(0) and similar into assertThat(enumerable).isEmpty() or .isNotEmpty().
|
||||
<!-- tooltip end -->
|
||||
<br>Works with anything that is enumerable such as arrays, iterables, collections, etc.
|
||||
</body>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<html>
|
||||
<body>
|
||||
Turns assertThat(!condition).isEqualTo(true/false) into assertThat(condition).isFalse()/isTrue().
|
||||
Turns assertThat(!condition).isEqualTo(true/false) into assertThat(condition).isFalse()/isTrue() and negates .is(Not)EqualTo(!var).
|
||||
<!-- tooltip end -->
|
||||
<br>Also works with constant expressions and Boolean.TRUE/FALSE.
|
||||
</body>
|
||||
|
||||
+5
-1
@@ -10,10 +10,14 @@ internal class AssertThatEnumerableIsEmptyInspectionTest : AbstractCajonTest() {
|
||||
|
||||
@Test
|
||||
@TestDataSubPath("inspections/EnumerableIsEmpty")
|
||||
internal fun assertThat_with_hasSize_zero_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
internal fun assertThat_with_hasSize_zero_and_similar_can_use_isEmpty(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(AssertThatEnumerableIsEmptyInspection::class.java)
|
||||
myFixture.configureByFile("EnumerableIsEmptyBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSize() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThan() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeLessThanOrEqualTo() with isEmpty()"), 5)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThan() with isNotEmpty()"), 6)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Replace hasSizeGreaterThanOrEqualTo() with isNotEmpty()"), 6)
|
||||
myFixture.checkResultByFile("EnumerableIsEmptyAfter.java")
|
||||
}
|
||||
}
|
||||
+2
@@ -14,6 +14,8 @@ internal class AssertThatInvertedBooleanConditionInspectionTest : AbstractCajonT
|
||||
myFixture.enableInspections(AssertThatInvertedBooleanConditionInspection::class.java)
|
||||
myFixture.configureByFile("InvertedBooleanConditionBefore.java")
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in assertThat()"), 25)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isEqualTo() and use isNotEqualTo() instead"), 4)
|
||||
executeQuickFixes(myFixture, Regex.fromLiteral("Invert condition in isNotEqualTo() and use isEqualTo() instead"), 2)
|
||||
myFixture.checkResultByFile("InvertedBooleanConditionAfter.java")
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -16,7 +16,7 @@ internal class ImplicitAssertionInspectionTest : AbstractCajonTest() {
|
||||
internal fun implicit_assertions_can_be_removed(@MyFixture myFixture: JavaCodeInsightTestFixture) {
|
||||
myFixture.enableInspections(ImplicitAssertionInspection::class.java)
|
||||
myFixture.configureByFile("ImplicitAssertionBefore.java")
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 101)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotNull\\(\\) covered by .*"), 102)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isNotEmpty\\(\\) covered by .*"), 17)
|
||||
executeQuickFixesNoFamilyNameCheck(myFixture, Regex("Delete implicit isPresent\\(\\) covered by .*"), 8)
|
||||
myFixture.checkResultByFile("ImplicitAssertionAfter.java")
|
||||
|
||||
@@ -16,7 +16,32 @@ public class EnumerableIsEmpty {
|
||||
assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
|
||||
assertThat(new Long[1]).as("etc").hasSize(1);
|
||||
|
||||
assertThat("string").as("foo").isEmpty();
|
||||
assertThat(new StringBuilder()).as("bar").isEmpty();
|
||||
assertThat(new ArrayList<Long>()).as("etc").isEmpty();
|
||||
assertThat(new Long[1]).as("etc").isEmpty();
|
||||
|
||||
assertThat("string").as("foo").isEmpty();
|
||||
assertThat(new StringBuilder()).as("bar").isEmpty();
|
||||
assertThat(new ArrayList<Long>()).as("etc").isEmpty();
|
||||
assertThat(new Long[1]).as("etc").isEmpty();
|
||||
|
||||
assertThat("string").as("foo").isNotEmpty();
|
||||
assertThat(new StringBuilder()).as("bar").isNotEmpty();
|
||||
assertThat(new ArrayList<Long>()).as("etc").isNotEmpty();
|
||||
assertThat(new Long[1]).as("etc").isNotEmpty();
|
||||
|
||||
assertThat("string").as("foo").isNotEmpty();
|
||||
assertThat(new StringBuilder()).as("bar").isNotEmpty();
|
||||
assertThat(new ArrayList<Long>()).as("etc").isNotEmpty();
|
||||
assertThat(new Long[1]).as("etc").isNotEmpty();
|
||||
|
||||
assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").isEmpty();
|
||||
assertThat("string").as("foo").hasSizeLessThanOrEqualTo(0).hasSameSizeAs("foo").isEmpty();
|
||||
assertThat("string").as("foo").hasSizeLessThan(1).hasSameSizeAs("foo").isEmpty();
|
||||
|
||||
assertThat("string").as("foo").isNotEmpty().hasSameSizeAs("foo").isNotEmpty();
|
||||
assertThat("string").as("foo").isNotEmpty().hasSameSizeAs("foo").isNotEmpty();
|
||||
|
||||
org.junit.Assert.assertThat("foo", null);
|
||||
fail("oh no!");
|
||||
|
||||
@@ -16,7 +16,32 @@ public class EnumerableIsEmpty {
|
||||
assertThat(new ArrayList<Long>()).as("etc").hasSize(1);
|
||||
assertThat(new Long[1]).as("etc").hasSize(1);
|
||||
|
||||
assertThat("string").as("foo").hasSizeLessThanOrEqualTo(0);
|
||||
assertThat(new StringBuilder()).as("bar").hasSizeLessThanOrEqualTo(0 + 0);
|
||||
assertThat(new ArrayList<Long>()).as("etc").hasSizeLessThanOrEqualTo(10 / 100);
|
||||
assertThat(new Long[1]).as("etc").hasSizeLessThanOrEqualTo(1 - 1);
|
||||
|
||||
assertThat("string").as("foo").hasSizeLessThan(1);
|
||||
assertThat(new StringBuilder()).as("bar").hasSizeLessThan(0 + 1);
|
||||
assertThat(new ArrayList<Long>()).as("etc").hasSizeLessThan(10 / 10);
|
||||
assertThat(new Long[1]).as("etc").hasSizeLessThan(1 - 0);
|
||||
|
||||
assertThat("string").as("foo").hasSizeGreaterThan(0);
|
||||
assertThat(new StringBuilder()).as("bar").hasSizeGreaterThan(0 + 0);
|
||||
assertThat(new ArrayList<Long>()).as("etc").hasSizeGreaterThan(10 / 100);
|
||||
assertThat(new Long[1]).as("etc").hasSizeGreaterThan(1 - 1);
|
||||
|
||||
assertThat("string").as("foo").hasSizeGreaterThanOrEqualTo(1);
|
||||
assertThat(new StringBuilder()).as("bar").hasSizeGreaterThanOrEqualTo(0 + 1);
|
||||
assertThat(new ArrayList<Long>()).as("etc").hasSizeGreaterThanOrEqualTo(10 / 10);
|
||||
assertThat(new Long[1]).as("etc").hasSizeGreaterThanOrEqualTo(1 - 0);
|
||||
|
||||
assertThat("string").as("foo").hasSize(0).hasSameSizeAs("foo").hasSize(0);
|
||||
assertThat("string").as("foo").hasSizeLessThanOrEqualTo(0).hasSameSizeAs("foo").hasSizeLessThanOrEqualTo(0);
|
||||
assertThat("string").as("foo").hasSizeLessThan(1).hasSameSizeAs("foo").hasSizeLessThan(1);
|
||||
|
||||
assertThat("string").as("foo").hasSizeGreaterThan(0).hasSameSizeAs("foo").hasSizeGreaterThan(0);
|
||||
assertThat("string").as("foo").hasSizeGreaterThanOrEqualTo(1).hasSameSizeAs("foo").hasSizeGreaterThanOrEqualTo(1);
|
||||
|
||||
org.junit.Assert.assertThat("foo", null);
|
||||
fail("oh no!");
|
||||
|
||||
@@ -153,6 +153,7 @@ public class ImplicitAssertion {
|
||||
assertThat(list).areAtMost(1, stringCondition);
|
||||
assertThat(list).areExactly(1, stringCondition);
|
||||
assertThat(list).hasOnlyOneElementSatisfying(stringConsumer);
|
||||
assertThat(list).singleElement(as(STRING)).isEqualTo(stringConsumer);
|
||||
assertThat(list).haveAtLeastOne(stringCondition);
|
||||
assertThat(list).haveAtLeast(1, stringCondition);
|
||||
assertThat(list).haveAtMost(1, stringCondition);
|
||||
@@ -229,6 +230,7 @@ public class ImplicitAssertion {
|
||||
assertThat(list).isNotEmpty().areAtMost(1, stringCondition);
|
||||
assertThat(list).isNotEmpty().areExactly(1, stringCondition);
|
||||
assertThat(list).isNotEmpty().hasOnlyOneElementSatisfying(stringConsumer);
|
||||
assertThat(list).isNotEmpty().singleElement(as(STRING)).isEqualTo(stringConsumer);
|
||||
assertThat(list).haveAtLeastOne(stringCondition);
|
||||
assertThat(list).isNotEmpty().haveAtLeast(1, stringCondition);
|
||||
assertThat(list).isNotEmpty().haveAtMost(1, stringCondition);
|
||||
|
||||
@@ -153,6 +153,7 @@ public class ImplicitAssertion {
|
||||
assertThat(list).isNotNull().areAtMost(1, stringCondition);
|
||||
assertThat(list).isNotNull().areExactly(1, stringCondition);
|
||||
assertThat(list).isNotNull().hasOnlyOneElementSatisfying(stringConsumer);
|
||||
assertThat(list).isNotNull().singleElement(as(STRING)).isEqualTo(stringConsumer);
|
||||
assertThat(list).isNotNull().haveAtLeastOne(stringCondition);
|
||||
assertThat(list).isNotNull().haveAtLeast(1, stringCondition);
|
||||
assertThat(list).isNotNull().haveAtMost(1, stringCondition);
|
||||
@@ -229,6 +230,7 @@ public class ImplicitAssertion {
|
||||
assertThat(list).isNotEmpty().areAtMost(1, stringCondition);
|
||||
assertThat(list).isNotEmpty().areExactly(1, stringCondition);
|
||||
assertThat(list).isNotEmpty().hasOnlyOneElementSatisfying(stringConsumer);
|
||||
assertThat(list).isNotEmpty().singleElement(as(STRING)).isEqualTo(stringConsumer);
|
||||
assertThat(list).isNotEmpty().haveAtLeastOne(stringCondition);
|
||||
assertThat(list).isNotEmpty().haveAtLeast(1, stringCondition);
|
||||
assertThat(list).isNotEmpty().haveAtMost(1, stringCondition);
|
||||
|
||||
+18
-1
@@ -3,7 +3,7 @@ import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class InvertedBooleanCondition {
|
||||
|
||||
private void invertedBooleanCondition() {
|
||||
private void invertedBooleanCondition(boolean primitiveVariable, Boolean objectVariable) {
|
||||
boolean primitive = false;
|
||||
Boolean object = Boolean.TRUE;
|
||||
|
||||
@@ -37,6 +37,23 @@ public class InvertedBooleanCondition {
|
||||
assertThat(primitive).as("foo").isFalse().as("bar").isFalse();
|
||||
assertThat(primitive).as("foo").isFalse().as("bar").isTrue();
|
||||
|
||||
assertThat(primitive).isNotEqualTo(primitiveVariable);
|
||||
assertThat(primitive).isEqualTo(primitiveVariable);
|
||||
|
||||
assertThat(object).isNotEqualTo(primitiveVariable);
|
||||
assertThat(object).isEqualTo(primitiveVariable);
|
||||
|
||||
assertThat(primitive).isEqualTo(!objectVariable); // not safe for null value
|
||||
assertThat(primitive).isNotEqualTo(!objectVariable); // not safe for null value
|
||||
|
||||
assertThat(object).isEqualTo(!objectVariable); // not safe for null value
|
||||
assertThat(object).isNotEqualTo(!objectVariable); // not safe for null value
|
||||
|
||||
assertThat(primitive).isNotEqualTo(primitiveVariable);
|
||||
assertThat(primitive).isNotEqualTo(primitiveVariable);
|
||||
|
||||
assertThat(primitive).isEqualTo(!primitiveVariable && objectVariable);
|
||||
|
||||
org.junit.Assert.assertThat(object, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
+18
-1
@@ -3,7 +3,7 @@ import static org.assertj.core.api.Assertions.fail;
|
||||
|
||||
public class InvertedBooleanCondition {
|
||||
|
||||
private void invertedBooleanCondition() {
|
||||
private void invertedBooleanCondition(boolean primitiveVariable, Boolean objectVariable) {
|
||||
boolean primitive = false;
|
||||
Boolean object = Boolean.TRUE;
|
||||
|
||||
@@ -37,6 +37,23 @@ public class InvertedBooleanCondition {
|
||||
assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(false);
|
||||
assertThat(!primitive).as("foo").isEqualTo(Boolean.TRUE).as("bar").isNotEqualTo(true);
|
||||
|
||||
assertThat(primitive).isEqualTo(!primitiveVariable);
|
||||
assertThat(primitive).isNotEqualTo(!primitiveVariable);
|
||||
|
||||
assertThat(object).isEqualTo(!primitiveVariable);
|
||||
assertThat(object).isNotEqualTo(!primitiveVariable);
|
||||
|
||||
assertThat(primitive).isEqualTo(!objectVariable); // not safe for null value
|
||||
assertThat(primitive).isNotEqualTo(!objectVariable); // not safe for null value
|
||||
|
||||
assertThat(object).isEqualTo(!objectVariable); // not safe for null value
|
||||
assertThat(object).isNotEqualTo(!objectVariable); // not safe for null value
|
||||
|
||||
assertThat(primitive).isEqualTo((!primitiveVariable));
|
||||
assertThat(primitive).isEqualTo(!(primitiveVariable));
|
||||
|
||||
assertThat(primitive).isEqualTo(!primitiveVariable && objectVariable);
|
||||
|
||||
org.junit.Assert.assertThat(object, null);
|
||||
fail("oh no!");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user