@Repository tests reinforced

database/database-annotation-processor/src/test/java/ru/tinkoff/kora/database/common/annotation/processor/AbstractRepositoryTest.java

@@ -23,9 +23,10 @@ protected TestRepository(Class<?> repositoryClass, Object repositoryObject) {
 
         @SuppressWarnings("unchecked")
         public <T> T invoke(String method, Object... args) {
-            for (var repositoryClassMethod : repositoryClass.getMethods()) {
+            for (var repositoryClassMethod : repositoryClass.getDeclaredMethods()) {
                 if (repositoryClassMethod.getName().equals(method) && repositoryClassMethod.getParameters().length == args.length) {
                     try {
+                        repositoryClassMethod.setAccessible(true);
                         var result = repositoryClassMethod.invoke(this.repositoryObject, args);
                         if (result instanceof Mono<?> mono) {
                             return (T) mono.block();
@@ -81,4 +82,22 @@ protected TestRepository compile(Object connectionFactory, List<?> arguments, @L
             throw new RuntimeException(e);
         }
     }
+
+    protected TestRepository compileForArgs(List<?> arguments, @Language("java") String... sources) {
+        var compileResult = compile(List.of(new RepositoryAnnotationProcessor()), sources);
+        if (compileResult.isFailed()) {
+            throw compileResult.compilationException();
+        }
+
+        Assertions.assertThat(compileResult.warnings()).hasSize(0);
+
+        try {
+            var repositoryClass = compileResult.loadClass("$TestRepository_Impl");
+            var realArgs = arguments.toArray();
+            var repository = repositoryClass.getConstructors()[0].newInstance(realArgs);
+            return new TestRepository(repositoryClass, repository);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
 }

database/database-annotation-processor/src/test/java/ru/tinkoff/kora/database/common/annotation/processor/jdbc/JdbcParametersTest.java

@@ -10,6 +10,7 @@
 import ru.tinkoff.kora.database.common.annotation.processor.entity.TestEntityRecord;
 import ru.tinkoff.kora.database.common.annotation.processor.jdbc.repository.AllowedParametersRepository;
 import ru.tinkoff.kora.database.jdbc.JdbcConnectionFactory;
+import ru.tinkoff.kora.database.jdbc.JdbcDatabaseConfig;
 import ru.tinkoff.kora.database.jdbc.mapper.parameter.JdbcParameterColumnMapper;
 import ru.tinkoff.kora.json.common.annotation.Json;
 
@@ -114,6 +115,32 @@ public interface TestRepository extends JdbcRepository {
         verify(executor.preparedStatement).execute();
     }
 
+    @Test
+    public void testAbstractClassRepository() throws SQLException {
+        var config = new JdbcDatabaseConfig("1", "2", "3", "4",
+            null, null, null, null, null, null, null, null, null);
+        var repository = compileForArgs(List.of(config, executor), """
+            import ru.tinkoff.kora.database.jdbc.JdbcDatabaseConfig;
+            @Repository
+            public abstract class TestRepository implements JdbcRepository {
+
+                private final JdbcDatabaseConfig config;
+
+                public TestRepository(JdbcDatabaseConfig config) {
+                    this.config = config;
+                }
+
+                @Query("INSERT INTO test(test) VALUES ('test')")
+                abstract void testConnection(Connection connection);
+            }
+            """);
+
+        repository.invoke("testConnection", executor.mockConnection);
+
+        verify(executor.mockConnection).prepareStatement("INSERT INTO test(test) VALUES ('test')");
+        verify(executor.preparedStatement).execute();
+    }
+
     @Test
     public void testNativeParameter() throws SQLException {
         var repository = compileJdbc(List.of(), """

database/database-symbol-processor/src/test/kotlin/ru/tinkoff/kora/database/symbol/processor/AbstractRepositoryTest.kt

@@ -56,7 +56,6 @@ abstract class AbstractRepositoryTest : AbstractSymbolProcessorTest() {
             throw compileResult.compilationException()
         }
 
-        val repositoryClass = compileResult.loadClass("\$TestRepository_Impl")
         val realArgs = arrayOfNulls<Any>(arguments.size + 1)
         realArgs[0] = connectionFactory
         System.arraycopy(arguments.toTypedArray(), 0, realArgs, 1, arguments.size)
@@ -65,7 +64,20 @@ abstract class AbstractRepositoryTest : AbstractSymbolProcessorTest() {
                 realArgs[i] = arg.invoke()
             }
         }
+
+        val repositoryClass = compileResult.loadClass("\$TestRepository_Impl")
         val repository = repositoryClass.constructors[0].newInstance(*realArgs)
         return TestRepository(repositoryClass.kotlin, repository)
     }
+
+    protected fun compileForArgs(arguments: Array<Any?>, @Language("kotlin") vararg sources: String): TestRepository {
+        val compileResult = compile(listOf(RepositorySymbolProcessorProvider()), *sources)
+        if (compileResult.isFailed()) {
+            throw compileResult.compilationException()
+        }
+
+        val repositoryClass = compileResult.loadClass("\$TestRepository_Impl")
+        val repository = repositoryClass.constructors[0].newInstance(*arguments)
+        return TestRepository(repositoryClass.kotlin, repository)
+    }
 }

database/database-symbol-processor/src/test/kotlin/ru/tinkoff/kora/database/symbol/processor/jdbc/JdbcParametersTest.kt

@@ -6,7 +6,10 @@ import org.mockito.ArgumentMatchers
 import org.mockito.Mockito
 import org.mockito.kotlin.verify
 import ru.tinkoff.kora.common.Tag
+import ru.tinkoff.kora.database.cassandra.CassandraConfig.Advanced.MetricsConfig.Config
+import ru.tinkoff.kora.database.jdbc.JdbcDatabaseConfig
 import ru.tinkoff.kora.database.jdbc.mapper.parameter.JdbcParameterColumnMapper
+import java.time.Duration
 import kotlin.reflect.full.findAnnotations
 import kotlin.reflect.jvm.jvmErasure
 
@@ -29,6 +32,27 @@ class JdbcParametersTest : AbstractJdbcRepositoryTest() {
         verify(executor.preparedStatement).updateCount
     }
 
+    @Test
+    fun testAbstractClassRepository() {
+        val config = JdbcDatabaseConfig("1", "2", "3", "4",
+            null, null, null, null, null, null, null, null, null)
+        val repository = compileForArgs(
+            arrayOf(config, executor),
+            """
+            @Repository
+            abstract class TestRepository(val config: JdbcDatabaseConfig) : JdbcRepository {
+                @Query("INSERT INTO test(test) VALUES ('test')")
+                abstract fun test(connection: Connection)
+            }
+            """.trimIndent()
+        )
+
+        repository.invoke<Any>("test", executor.mockConnection)
+
+        verify(executor.preparedStatement).execute()
+        verify(executor.preparedStatement).updateCount
+    }
+
     @Test
     fun testNativeParameter() {
         val repository = compile(