chrisly42/cajon-plugin
1
0
Fork 0
Code Issues 4 Pull Requests 1 Packages Projects Releases Wiki Activity

Extended JUnitAssertToAssertJ inspection to convert JUnit assume-Statements, too.

Browse Source 
Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.
This commit is contained in:
chrisly42
2019-05-17 12:17:01 +02:00
parent e797dc2515
commit 178b7d368a
12 changed files with 239 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/de/platon42/intellij/plugins/cajon/Extensions.kt
+6 -3
View File
@@ -117,11 +117,14 @@ fun PsiMethodCallExpression.getExpectedNullNonNullResult(): Boolean? {
fun PsiMethodCallExpression.calculateConstantParameterValue(argIndex: Int): Any? {
if (argIndex >= argumentList.expressions.size) return null
val valueExpression = getArg(argIndex)
return getArg(argIndex).calculateConstantValue()
}
fun PsiExpression.calculateConstantValue(): Any? {
val constantEvaluationHelper = JavaPsiFacade.getInstance(project).constantEvaluationHelper
val value = constantEvaluationHelper.computeConstantExpression(valueExpression)
val value = constantEvaluationHelper.computeConstantExpression(this)
if (value == null) {
val field = (valueExpression as? PsiReferenceExpression)?.resolve() as? PsiField
val field = (this as? PsiReferenceExpression)?.resolve() as? PsiField
if (field?.containingClass?.qualifiedName == CommonClassNames.JAVA_LANG_BOOLEAN) {
return when (field.name) {
"TRUE" -> true
src/main/java/de/platon42/intellij/plugins/cajon/Helper.kt
+4
View File
@@ -18,6 +18,10 @@ fun createAssertThat(context: PsiElement, baseclass: String, actualExpression: P
return createMethodCall(context, "$baseclass.${MethodNames.ASSERT_THAT}", actualExpression)
}
fun createAssumeThat(context: PsiElement, actualExpression: PsiExpression): PsiMethodCallExpression {
return createMethodCall(context, "${AssertJClassNames.ASSUMPTIONS_CLASSNAME}.${MethodNames.ASSUME_THAT}", actualExpression)
}
fun createExpectedMethodCall(context: PsiElement, methodName: String, vararg arguments: PsiElement): PsiMethodCallExpression {
return createMethodCall(context, "a.$methodName", *arguments)
}
src/main/java/de/platon42/intellij/plugins/cajon/inspections/AbstractJUnitAssertInspection.kt
+12
View File
@@ -9,6 +9,8 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
companion object {
@NonNls
const val JUNIT_ASSERT_CLASSNAME = "org.junit.Assert"
@NonNls
const val JUNIT_ASSUME_CLASSNAME = "org.junit.Assume"
@NonNls
const val ASSERT_TRUE_METHOD = "assertTrue"
@@ -28,6 +30,16 @@ open class AbstractJUnitAssertInspection : AbstractBaseJavaLocalInspectionTool()
const val ASSERT_NOT_SAME_METHOD = "assertNotSame"
@NonNls
const val ASSERT_ARRAY_EQUALS_METHOD = "assertArrayEquals"
@NonNls
const val ASSUME_TRUE_METHOD = "assumeTrue"
@NonNls
const val ASSUME_FALSE_METHOD = "assumeFalse"
@NonNls
const val ASSUME_NOT_NULL_METHOD = "assumeNotNull"
@NonNls
const val ASSUME_NO_EXCEPTION = "assumeNoException"
}
override fun getGroupDisplayName(): String {
src/main/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspection.kt
+62 -21
View File
@@ -10,43 +10,44 @@ import com.siyeh.ig.callMatcher.CallMatcher.staticCall
import de.platon42.intellij.plugins.cajon.AssertJClassNames
import de.platon42.intellij.plugins.cajon.MethodNames
import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssertMethodCallQuickFix
import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitAssumeMethodCallQuickFix
import de.platon42.intellij.plugins.cajon.quickfixes.ReplaceJUnitDeltaAssertMethodCallQuickFix
class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
companion object {
private const val DISPLAY_NAME = "Convert JUnit assertions to AssertJ"
private const val DISPLAY_NAME = "Convert JUnit assertions/assumptions to AssertJ"
private const val CONVERT_MESSAGE_TEMPLATE = "%s can be converted to AssertJ style"
private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to assertThat().%s()"
private const val CONVERT_DESCRIPTION_TEMPLATE = "Convert %s() to %s().%s()"
private val MAPPINGS = listOf(
private val ASSERT_MAPPINGS = listOf(
Mapping(
anyOf(
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_TRUE_METHOD).parameterTypes("boolean")
),
MethodNames.IS_TRUE, false
MethodNames.IS_TRUE, hasExpected = false
),
Mapping(
anyOf(
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_FALSE_METHOD).parameterTypes("boolean")
),
MethodNames.IS_FALSE, false
MethodNames.IS_FALSE, hasExpected = false
),
Mapping(
anyOf(
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
),
MethodNames.IS_NULL, false
MethodNames.IS_NULL, hasExpected = false
),
Mapping(
anyOf(
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_OBJECT),
staticCall(JUNIT_ASSERT_CLASSNAME, ASSERT_NOT_NULL_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_OBJECT)
),
MethodNames.IS_NOT_NULL, false
MethodNames.IS_NOT_NULL, hasExpected = false
),
Mapping(
anyOf(
@@ -111,6 +112,34 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
MethodNames.CONTAINS_EXACTLY
)
)
private val ASSUME_MAPPINGS = listOf(
Mapping(
anyOf(
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_TRUE_METHOD).parameterTypes("boolean")
),
MethodNames.IS_TRUE, hasExpected = false
),
Mapping(
anyOf(
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes(CommonClassNames.JAVA_LANG_STRING, "boolean"),
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_FALSE_METHOD).parameterTypes("boolean")
),
MethodNames.IS_FALSE, hasExpected = false
),
Mapping(
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NOT_NULL_METHOD).parameterCount(1),
MethodNames.IS_NOT_NULL, hasExpected = false, singleArgument = true
),
Mapping(
anyOf(
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_STRING, CommonClassNames.JAVA_LANG_THROWABLE),
staticCall(JUNIT_ASSUME_CLASSNAME, ASSUME_NO_EXCEPTION).parameterTypes(CommonClassNames.JAVA_LANG_THROWABLE)
),
"doesNotThrowAnyException", hasExpected = false
)
)
}
override fun getDisplayName() = DISPLAY_NAME
@@ -119,18 +148,28 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
return object : JavaElementVisitor() {
override fun visitMethodCallExpression(expression: PsiMethodCallExpression) {
super.visitMethodCallExpression(expression)
val isJUnitAssertCall = expression.resolveMethod()?.containingClass?.qualifiedName == JUNIT_ASSERT_CLASSNAME
if (!isJUnitAssertCall) {
return // early exit
}
JavaPsiFacade.getInstance(expression.project)
.findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
val mapping = MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
if (mapping.hasDelta) {
registerConvertMethod(holder, expression, mapping.replacement, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
} else {
registerConvertMethod(holder, expression, mapping.replacement) { desc, method ->
ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
when (expression.resolveMethod()?.containingClass?.qualifiedName) {
JUNIT_ASSERT_CLASSNAME -> {
JavaPsiFacade.getInstance(expression.project)
.findClass(AssertJClassNames.ASSERTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
val mapping = ASSERT_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
if (mapping.hasDelta) {
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT, ::ReplaceJUnitDeltaAssertMethodCallQuickFix)
} else {
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSERT_THAT) { desc, method ->
ReplaceJUnitAssertMethodCallQuickFix(desc, method, !mapping.hasExpected)
}
}
}
JUNIT_ASSUME_CLASSNAME -> {
JavaPsiFacade.getInstance(expression.project)
.findClass(AssertJClassNames.ASSUMPTIONS_CLASSNAME, GlobalSearchScope.allScope(expression.project)) ?: return
val mapping = ASSUME_MAPPINGS.firstOrNull { it.callMatcher.test(expression) } ?: return
if (!mapping.singleArgument || expression.argumentList.expressions.size == 1) {
registerConvertMethod(holder, expression, mapping.replacement, MethodNames.ASSUME_THAT) { desc, method ->
ReplaceJUnitAssumeMethodCallQuickFix(desc, method)
}
}
}
}
}
@@ -141,10 +180,11 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
holder: ProblemsHolder,
expression: PsiMethodCallExpression,
replacementMethod: String,
staticMethod: String,
quickFixSupplier: (String, String) -> LocalQuickFix
) {
val originalMethod = getOriginalMethodName(expression) ?: return
val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, replacementMethod)
val description = CONVERT_DESCRIPTION_TEMPLATE.format(originalMethod, staticMethod, replacementMethod)
val message = CONVERT_MESSAGE_TEMPLATE.format(originalMethod)
val quickfix = quickFixSupplier(description, replacementMethod)
holder.registerProblem(expression, message, quickfix)
@@ -154,6 +194,7 @@ class JUnitAssertToAssertJInspection : AbstractJUnitAssertInspection() {
val callMatcher: CallMatcher,
val replacement: String,
val hasExpected: Boolean = true,
val hasDelta: Boolean = false
val hasDelta: Boolean = false,
val singleArgument: Boolean = false
)
}
src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssertMethodCallQuickFix.kt
+10 -3
View File
@@ -24,7 +24,7 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
val args = methodCallExpression.argumentList
val count = args.expressions.size
val actualExpression = args.expressions[count - 1] ?: return
val (expectedExpression, messageExpression) = if (noExpectedExpression) {
val (expectedExpressions, messageExpression) = if (noExpectedExpression) {
val message = args.expressions.getOrNull(count - 2)
emptyArray<PsiExpression>() to message
} else {
@@ -33,8 +33,15 @@ class ReplaceJUnitAssertMethodCallQuickFix(description: String, private val repl
arrayOf(expected) to message
}
val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, *expectedExpression)
val newMethodCall = createAssertThat(element, actualExpression)
val swapActualAndExpected = ((expectedExpressions.getOrNull(0)?.calculateConstantValue() == null)
&& (actualExpression.calculateConstantValue() != null))
val (expectedMethodCall, newMethodCall) = if (swapActualAndExpected) {
createExpectedMethodCall(element, replacementMethod, actualExpression) to
createAssertThat(element, expectedExpressions.single())
} else {
createExpectedMethodCall(element, replacementMethod, *expectedExpressions) to
createAssertThat(element, actualExpression)
}
if (messageExpression != null) {
val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitAssumeMethodCallQuickFix.kt
+41
View File
@@ -0,0 +1,41 @@
package de.platon42.intellij.plugins.cajon.quickfixes
import com.intellij.codeInspection.ProblemDescriptor
import com.intellij.openapi.project.Project
import com.intellij.psi.PsiMethodCallExpression
import de.platon42.intellij.plugins.cajon.*
class ReplaceJUnitAssumeMethodCallQuickFix(description: String, private val replacementMethod: String) :
AbstractCommonQuickFix(description) {
companion object {
private const val CONVERT_DESCRIPTION = "Convert JUnit assumptions to assertJ"
}
override fun getFamilyName(): String {
return CONVERT_DESCRIPTION
}
override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
val element = descriptor.startElement
val methodCallExpression = element as? PsiMethodCallExpression ?: return
val args = methodCallExpression.argumentList
val count = args.expressions.size
val actualExpression = args.expressions[count - 1] ?: return
val messageExpression = args.expressions.getOrNull(count - 2)
val expectedMethodCall = createExpectedMethodCall(element, replacementMethod)
val newMethodCall = createAssumeThat(element, actualExpression)
if (messageExpression != null) {
val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
asExpression.replaceQualifier(newMethodCall)
expectedMethodCall.replaceQualifier(asExpression)
} else {
expectedMethodCall.replaceQualifier(newMethodCall)
}
newMethodCall.resolveMethod()?.addAsStaticImport(element)
element.replace(expectedMethodCall).shortenAndReformat()
}
}
src/main/java/de/platon42/intellij/plugins/cajon/quickfixes/ReplaceJUnitDeltaAssertMethodCallQuickFix.kt
+10 -2
View File
@@ -27,8 +27,16 @@ class ReplaceJUnitDeltaAssertMethodCallQuickFix(description: String, private val
val deltaExpression = args.expressions[count - 1] ?: return
val offsetMethodCall = createMethodCall(element, "org.assertj.core.data.Offset.offset", deltaExpression)
val expectedMethodCall = createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall)
val newMethodCall = createAssertThat(element, actualExpression)
val swapActualAndExpected = ((expectedExpression.calculateConstantValue() == null)
&& (actualExpression.calculateConstantValue() != null))
val (expectedMethodCall, newMethodCall) = if (swapActualAndExpected) {
createExpectedMethodCall(element, replacementMethod, actualExpression, offsetMethodCall) to
createAssertThat(element, expectedExpression)
} else {
createExpectedMethodCall(element, replacementMethod, expectedExpression, offsetMethodCall) to
createAssertThat(element, actualExpression)
}
if (messageExpression != null) {
val asExpression = createExpectedMethodCall(element, MethodNames.AS, messageExpression)
src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt
+2 -1
View File
@@ -18,7 +18,8 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
runTest {
myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 38)
executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
executeQuickFixes(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
}
}
src/test/resources/inspections/JUnitAssertToAssertJ/JUnitAssertToAssertJInspectionAfter.java
+36
View File
@@ -1,12 +1,18 @@
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assumptions.assumeThat;
import static org.assertj.core.data.Offset.offset;
import static org.junit.Assert.*;
import static org.junit.Assume.*;
public class JUnitAssertToAssertJ {
private void jUnitAssertToAssertJ() {
String foo = "foo";
String bar = "bar";
int someInt = 1;
double someDouble = 1.0;
float someFloat = 1.0f;
assertThat(foo == "foo").isTrue();
assertThat(foo == "foo").as("oh no!").isTrue();
assertThat(foo == "bar").isFalse();
@@ -52,5 +58,35 @@ public class JUnitAssertToAssertJ {
assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
assertThat(foo).isEqualTo("bar");
assertThat(bar).as("equals").isEqualTo("foo");
assertThat(bar).isNotEqualTo("foo");
assertThat(foo).as("equals").isNotEqualTo("bar");
assertThat(someInt).isEqualTo(2);
assertThat(someDouble).isCloseTo(2.0, offset(0.1));
assertThat(someDouble).as("equals").isEqualTo(1.0);
assertThat(someDouble).as("equals").isCloseTo(1.0, offset(0.1));
assertThat(someFloat).isEqualTo(1.0f);
assertThat(someFloat).isCloseTo(2.0f, offset(0.1f));
fail();
fail("oh no!")
}
private void jUnitAssumeToAssertJ() {
String foo = "foo";
String bar = "bar";
assumeThat(foo == "foo").isTrue();
assumeThat(foo == "foo").as("oh no!").isTrue();
assumeThat(foo == "bar").isFalse();
assumeThat(foo == "bar").as("boom!").isFalse();
assumeThat(foo).isNotNull();
assumeNotNull(foo, bar);
assumeThat(new IllegalArgumentException()).doesNotThrowAnyException();
assumeThat(new IllegalArgumentException()).as("oh no!").doesNotThrowAnyException();
}
}
src/test/resources/inspections/JUnitAssertToAssertJ/JUnitAssertToAssertJInspectionBefore.java
+35
View File
@@ -1,10 +1,15 @@
import static org.junit.Assert.*;
import static org.junit.Assume.*;
public class JUnitAssertToAssertJ {
private void jUnitAssertToAssertJ() {
String foo = "foo";
String bar = "bar";
int someInt = 1;
double someDouble = 1.0;
float someFloat = 1.0f;
assertTrue(foo == "foo");
assertTrue("oh no!", foo == "foo");
assertFalse(foo == "bar");
@@ -50,5 +55,35 @@ public class JUnitAssertToAssertJ {
assertArrayEquals("array equals", new double[2], new double[1], 1.0);
assertArrayEquals(new float[2], new float[1], 1.0f);
assertArrayEquals("array equals", new float[2], new float[1], 1.0f);
assertEquals("bar", foo);
assertEquals("equals", bar, "foo");
assertNotEquals(bar, "foo");
assertNotEquals("equals", "bar", foo);
assertEquals(someInt, 2);
assertEquals(someDouble, 2.0, 0.1);
assertEquals("equals",1.0, someDouble);
assertEquals("equals",1.0, someDouble, 0.1);
assertEquals(1.0f, someFloat);
assertEquals(someFloat, 2.0f, 0.1f);
fail();
fail("oh no!")
}
private void jUnitAssumeToAssertJ() {
String foo = "foo";
String bar = "bar";
assumeTrue(foo == "foo");
assumeTrue("oh no!", foo == "foo");
assumeFalse(foo == "bar");
assumeFalse("boom!", foo == "bar");
assumeNotNull(foo);
assumeNotNull(foo, bar);
assumeNoException(new IllegalArgumentException());
assumeNoException("oh no!", new IllegalArgumentException());
}
}