Add test case of dao method to check parameters

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/TypeCheckerProcessor.kt

@@ -1,3 +1,18 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.domaframework.doma.intellij.inspection.dao.processor
 
 import com.intellij.psi.PsiAnnotation

src/test/kotlin/org/domaframework/doma/intellij/DomaSqlTest.kt

@@ -205,7 +205,8 @@ open class DomaSqlTest : LightJavaCodeInsightFixtureTestCase() {
     }
 
     fun findDaoClass(testDaoName: String): PsiClass {
-        val dao = myFixture.findClass("doma.example.dao.$testDaoName")
+        val daoName = testDaoName.replace("/", ".")
+        val dao = myFixture.findClass("doma.example.dao.$daoName")
         assertNotNull("Not Found [$testDaoName]", dao)
         return dao
     }

src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/AnnotationParamTypeCheckInspectionTest.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.inspection.dao
+
+import org.domaframework.doma.intellij.DomaSqlTest
+import org.domaframework.doma.intellij.inspection.dao.inspector.DaoMethodParamTypeInspection
+
+/**
+ * Test class for annotation parameter type check inspection.
+ */
+class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {
+    private val testDaoNames =
+        listOf(
+            "InsertUpdateDeleteParamTestDao",
+            "BatchInsertUpdateDeleteParamTestDao",
+            "MultiInsertParamTestDao",
+            "ProcedureParamTestDao",
+            "ScriptParamTestDao",
+            "SqlProcessorParamTestDao",
+            "SelectParamTestDao",
+        )
+    private val daoPackage = "inspection/paramtype"
+
+    override fun setUp() {
+        super.setUp()
+        myFixture.enableInspections(DaoMethodParamTypeInspection())
+        addEntityJavaFile("Pckt.java")
+        addEntityJavaFile("Packet.java")
+        testDaoNames.forEach { daoName ->
+            addDaoJavaFile("$daoPackage/$daoName.java")
+        }
+    }
+
+    fun testInsertUpdateDeleteParam() {
+        val dao = findDaoClass("$daoPackage.InsertUpdateDeleteParamTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
+
+    fun testBatchInsertUpdateDeleteParam() {
+        val dao = findDaoClass("$daoPackage.BatchInsertUpdateDeleteParamTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
+
+    fun testMultiInsertParam() {
+        val dao = findDaoClass("$daoPackage.MultiInsertParamTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
+
+    fun testProcedureParam() {
+        val dao = findDaoClass("$daoPackage.ProcedureParamTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
+
+    fun testScriptParam() {
+        val dao = findDaoClass("$daoPackage.ScriptParamTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
+
+    fun testSqlProcessorParam() {
+        val dao = findDaoClass("$daoPackage.SqlProcessorParamTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
+}

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/BatchInsertUpdateDeleteParamTestDao.java

@@ -0,0 +1,49 @@
+package doma.example.dao.inspection.paramtype;
+
+import doma.example.entity.*;
+import org.seasar.doma.*;
+import org.seasar.doma.jdbc.BatchResult;
+
+import java.util.List;
+import java.util.Optional;
+
+@Dao
+public interface BatchInsertUpdateDeleteParamTestDao {
+
+    @BatchInsert
+    int[] batchInsertWrapper(List<Integer> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">ids</error>);
+
+    @BatchUpdate
+    int[] batchInsertEmpNotList(Pckt <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">pckt</error>);
+
+    @BatchInsert
+    @Sql("insert into values (/*id*/0)")
+    int[] batchInsertWithSqlAnnotation(Integer <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">id</error>);
+
+    @BatchUpdate
+    int[] <error descr="The number of parameters must be one">batchInsertEmpNotList</error>(List<Pckt> pckts,String name);
+
+    @BatchUpdate
+    int[] batchInsertEmp(List<Pckt> pckts);
+
+    @BatchUpdate
+    BatchResult<Pckt> batchInsertEmpResult(List<Pckt> pckts);
+
+    @BatchUpdate
+    BatchResult<Packet> batchInsertResult(List<Packet> packets);
+
+    @BatchUpdate
+    int[] batchInsertOptional(List<Optional<Packet>> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">packets</error>);
+
+    @BatchUpdate
+    @Sql("insert into values (/*packets.id*/0, /*packets.name*/'name')")
+    BatchResult<List<Packet>> batchInsertResultWithSql(List<Optional<Packet>> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">packets</error>);
+
+    @BatchUpdate
+    @Sql("insert into values (/*packets.id*/0, /*packets.name*/'name')")
+    int[] batchInsertWithSql(List<Optional<Packet>> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">packets</error>);
+
+    @BatchUpdate
+    int[] batchInsert(List<Packet> packets);
+}
+

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/InsertUpdateDeleteParamTestDao.java

@@ -0,0 +1,29 @@
+package doma.example.dao.inspection.paramtype;
+
+import doma.example.entity.*;
+import org.seasar.doma.Dao;
+import org.seasar.doma.Delete;
+import org.seasar.doma.Insert;
+import org.seasar.doma.Update;
+import org.seasar.doma.Sql;
+
+@Dao
+public interface InsertUpdateDeleteParamTestDao {
+
+    @Insert
+    int insertEntity(Packet packet);
+
+    @Insert
+    int insertPrimitive(Integer <error descr="The parameter type must be an entity class">id</error>);
+
+    @Update
+    int <error descr="The number of parameters must be one">updateNoParams</error>();
+
+    @Delete
+    int <error descr="The number of parameters must be one">deleteMultipleParams</error>(Packet packet, String name);
+
+    @Insert
+    @Sql("insert into Packet (id, name) values (/* id */0, /* name */'test')")
+    int insertWithSqlAnnotation(Integer id, String name);
+
+}

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/MultiInsertParamTestDao.java

@@ -0,0 +1,37 @@
+package doma.example.dao.inspection.paramtype;
+
+import doma.example.entity.*;
+import org.seasar.doma.*;
+
+import java.util.List;
+
+@Dao
+public interface MultiInsertParamTestDao {
+
+    @MultiInsert
+    int multiInsertNotList(Pckt <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">Pckt</error>);
+
+    @MultiInsert
+    int <error descr="The number of parameters must be one">multiInsertAnyParams</error>(List<Packet> PcktList, String name);
+
+    @MultiInsert
+    int multiInsertNotEntityIterable(List<Integer> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">PcktList</error>);
+
+    @MultiInsert
+    int[] multiInsert(List<Pckt> PcktList);
+
+    @MultiInsert
+    MultiResult<<error descr="Cannot resolve symbol 'Prj'">Prj</error>> multiInsertNoMatchResult(List<Pckt> PcktList);
+
+    @MultiInsert
+    <error descr="Cannot resolve symbol 'MultiResult'">MultiResult</error><Pckt> multiInsertResult(List<Pckt> PcktList);
+
+    @MultiInsert
+    <error descr="Cannot resolve symbol 'MultiResult'">MultiResult</error><Packet> multiInsertPacket(List<Packet> PacketList);
+
+    @MultiInsert(returning = @Returning)
+    int[] multiInsertReturning(List<Pckt> Pckts);
+
+    @MultiInsert(returning = @Returning)
+    List<Pckt> multiInsertReturningList(List<Pckt> Pckts);
+}

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/ProcedureParamTestDao.java

@@ -0,0 +1,21 @@
+package doma.example.dao.inspection.paramtype;
+
+import org.seasar.doma.*;
+import org.seasar.doma.jdbc.Reference;
+
+import java.util.List;
+import java.util.Map;
+
+@Dao
+public interface ProcedureParamTestDao {
+
+    @Procedure
+    void executeNotAnnotation(@In Integer inParam,@InOut Reference<String> inOurPatam, @Out Reference<Integer> outParam);
+
+    @Procedure
+    void executeValidType(@In Reference<Integer> <error descr="Reference<Integer> is not supported as the type of the parameter annotated with @In">inParam</error>,@InOut Integer <error descr="The parameter type annotated with @InOut must be \"org.seasar.doma.jdbc.Reference\"">inOurPatam</error>, @Out String <error descr="The parameter type annotated with @Out must be \"org.seasar.doma.jdbc.Reference\"">outParam</error>,@ResultSet List<Optional<<error descr="Cannot resolve symbol 'Emp'">Emp</error>>> <error descr="\"Optional<Emp>\" is illegal as the type argument of \"java.util.List\"">optional</error>);
+
+    @Function
+    int executeFuncValidType(@Out Reference<<error descr="Cannot resolve symbol 'Optional'">Optional</error><String>> <error descr="\"Optional<String>\" is illegal as the type argument of \"org.seasar.doma.jdbc.Reference\"">out</error>,@ResultSet List<Optional<<error descr="Cannot resolve symbol 'Address'">Address</error>>> <error descr="\"Optional<Address>\" is illegal as the type argument of \"java.util.List\"">optional</error>);
+}
+

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/ScriptParamTestDao.java

@@ -0,0 +1,14 @@
+package doma.example.dao.inspection.paramtype;
+
+import org.seasar.doma.*;
+
+@Dao
+public interface ScriptParamTestDao {
+
+    @Script
+    void <error descr="The number of parameters must be zero">scriptString</error>(String script);
+
+    @Script
+    void <error descr="The number of parameters must be zero">scriptInt</error>(int value);
+}
+

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/SelectParamTestDao.java

@@ -0,0 +1,60 @@
+package doma.example.dao.inspection.paramtype;
+
+import org.seasar.doma.*;
+import org.seasar.doma.message.Message;
+import doma.example.entity.*;
+
+import java.math.BigDecimal;
+import java.util.Optional;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
+import java.util.function.Function;
+
+@Dao
+public interface SelectParamTestDao {
+
+  @Select
+  Pckt selectPcktById(Integer id);
+
+  @Select
+  @Sql("SELECT * FROM packet WHERE id = /* pckt.id */0")
+  Pckt selectEmp(Pckt pckt);
+
+  @Select(strategy = SelectType.STREAM)
+  @Sql("Select 10000 from user where name = /* name */'name' and salary = /* salary */0")
+  Stream<Packet> selectReturnStreamWithStreamOption(String name, BigDecimal salary);
+
+  @Select
+  @Sql("Select 10000 from user")
+  Stream<Packet> selectReturnStreamWithOutStreamOption(Function<Stream<Packet>, BigDecimal> streams);
+
+  @Select(strategy = SelectType.STREAM)
+  @Sql("Select 10000 from user")
+  Integer selectReturnStream(Function<Stream<Pckt>, BigDecimal> stream);
+
+  @Select(strategy = SelectType.STREAM)
+  @Sql("Select 10000 from user")
+  BigDecimal selectStream(Function<Stream<Pckt>, BigDecimal> stream);
+
+  @Suppress(messages = { Message.DOMA4274 })
+  @Select
+  @Sql("Select 10000 from user where name = /* name */'name' and salary = /* salary */0")
+  Stream<Package> selectReturnStream(String name, BigDecimal salary);
+
+  @Select
+  @Sql("select * from packet where salary > /* salary */0")
+  Pckt selectCollectNotOption(BigDecimal salary, Collector<Packet, BigDecimal, Pckt> collector);
+
+  @Select(strategy = SelectType.COLLECT)
+  @Sql("select * from packet where salary > /* salary */0")
+  Pckt selectCollectAccumulation(BigDecimal salary, Packet packet);
+
+  @Select(strategy = SelectType.COLLECT)
+  @Sql("select * from emp where salary > /* salary */0")
+  Optional<Packet> selectCollectInValidParamResult(BigDecimal salary,Collector<Packet, ?, Optional<Packet>> collector);
+
+  @Select(strategy = SelectType.COLLECT)
+  @Sql("select * from emp where salary > /* salary */0")
+  Pckt selectCollectAccumulation(BigDecimal salary, Collector<Packet, BigDecimal, Pckt> collector);
+}
+

src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/SqlProcessorParamTestDao.java

@@ -0,0 +1,35 @@
+package doma.example.dao.inspection.paramtype;
+
+import org.seasar.doma.*;
+import doma.example.entity.*;
+import java.util.function.BiFunction;
+import org.seasar.doma.jdbc.Config;
+import org.seasar.doma.jdbc.PreparedSql;
+
+@Dao
+public interface SqlProcessorParamTestDao {
+
+    @SqlProcessor
+    @Sql("")
+    <R> R <error descr="When you annotate the method with @SqlProcessor, the BiFunction parameter is required for the method">executeNotBiFunction</error>(Integer id);
+
+    @SqlProcessor
+    @Sql("")
+    <R> R executeBiFunctionNotConfig(BiFunction<String,PreparedSql, R> <error descr="The first type argument of BiFunction must be org.seasar.doma.jdbc.Config">func</error>);
+
+    @SqlProcessor
+    <R> R executeBiFunctionNotPreparedSql(BiFunction<Config,String, R> <error descr="The second type argument of BiFunction must be org.seasar.doma.jdbc.PreparedSql">func</error>);
+
+    @SqlProcessor
+    <R> R executeR(Integer id,BiFunction<Config, PreparedSql, Pckt> func);
+
+    @SqlProcessor
+    Integer executeInteger(Integer id,BiFunction<Config, PreparedSql, Pckt> func);
+
+    @SqlProcessor
+    Pckt executePckt(BiFunction<Config, PreparedSql, Pckt> func);
+
+    @SqlProcessor
+    <R> R execute(BiFunction<Config, PreparedSql, R> func);
+}
+