I am stuck in user authentication with micronaut application
authenticate function not accepting httpRequest param
I'm getting an error
Class 'AuthenticationProviderUserPassword' is not abstract and does not implement abstract member public abstract fun authenticate(authenticationRequest: AuthenticationRequest<(raw) Any!, (raw) Any!>!): Publisher! defined in io.micronaut.security.authentication.Authenticatio
Service:
package example.micronaut.services
import io.micronaut.http.HttpRequest
import io.micronaut.security.authentication.AuthenticationFailed
import io.micronaut.security.authentication.AuthenticationProvider
import io.micronaut.security.authentication.AuthenticationRequest
import io.micronaut.security.authentication.AuthenticationResponse
import io.micronaut.security.authentication.UserDetails
import io.reactivex.Flowable
import org.reactivestreams.Publisher
import java.util.*
import javax.inject.Singleton
#Singleton // <1>
class AuthenticationProviderUserPassword : AuthenticationProvider { // <2>
override fun authenticate(httpRequest: HttpRequest<*>?, authenticationRequest: AuthenticationRequest<*, *>?): Publisher<AuthenticationResponse> {
if (authenticationRequest != null && authenticationRequest.identity != null && authenticationRequest.secret != null) {
if (authenticationRequest.identity == "sherlock" && authenticationRequest.secret == "password") {
return Flowable.just<AuthenticationResponse>(UserDetails(authenticationRequest.identity as String, ArrayList()))
}
}
return Flowable.just<AuthenticationResponse>(AuthenticationFailed())
}
}
My build.gradle
plugins {
id "org.jetbrains.kotlin.jvm" version "1.3.50"
id "org.jetbrains.kotlin.kapt" version "1.3.50"
id "org.jetbrains.kotlin.plugin.allopen" version "1.3.50"
id "com.github.johnrengelman.shadow" version "5.2.0"
id "application"
}
version "0.1"
group "example.micronaut"
repositories {
mavenCentral()
maven { url "https://jcenter.bintray.com" }
}
configurations {
// for dependencies that are needed for development only
developmentOnly
}
dependencies {
implementation platform("io.micronaut:micronaut-bom:$micronautVersion")
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}"
implementation "org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}"
implementation "io.micronaut:micronaut-runtime"
implementation "javax.annotation:javax.annotation-api"
implementation "io.micronaut:micronaut-http-server-netty"
implementation "io.micronaut:micronaut-http-client"
implementation "io.micronaut:micronaut-security-session"
kapt platform("io.micronaut:micronaut-bom:$micronautVersion")
kapt "io.micronaut:micronaut-inject-java"
kapt "io.micronaut:micronaut-validation"
kaptTest platform("io.micronaut:micronaut-bom:$micronautVersion")
kaptTest "io.micronaut:micronaut-inject-java"
runtimeOnly "com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8"
runtimeOnly "ch.qos.logback:logback-classic:1.2.3"
testImplementation platform("io.micronaut:micronaut-bom:$micronautVersion")
testImplementation "io.micronaut.test:micronaut-test-kotlintest"
testImplementation "io.mockk:mockk:1.9.3"
testImplementation "io.kotlintest:kotlintest-runner-junit5:3.3.2"
implementation 'junit:junit:4.12'
compile "io.micronaut.configuration:micronaut-hibernate-jpa"
compile "io.micronaut.configuration:micronaut-hibernate-validator"
compileOnly "jakarta.persistence:jakarta.persistence-api:2.2.2"
annotationProcessor "io.micronaut.data:micronaut-data-processor:1.0.2"
runtime "com.h2database:h2"
runtime "io.micronaut.configuration:micronaut-jdbc-tomcat"
}
test.classpath += configurations.developmentOnly
mainClassName = "example.micronaut.Application"
test {
useJUnitPlatform()
}
allOpen {
annotation("io.micronaut.aop.Around")
}
compileKotlin {
kotlinOptions {
jvmTarget = '1.8'
//Will retain parameter names for Java reflection
javaParameters = true
}
}
compileTestKotlin {
kotlinOptions {
jvmTarget = '1.8'
javaParameters = true
}
}
shadowJar {
mergeServiceFiles()
}
tasks.withType(JavaExec) {
classpath += configurations.developmentOnly
jvmArgs('-noverify', '-XX:TieredStopAtLevel=1', '-Dcom.sun.management.jmxremote')
}
The docs you are looking at are compatible with more recent versions of the interface than you are using. You appear to be using the one at https://github.com/micronaut-projects/micronaut-security/blob/78169cb6927d10dcc6ebc2f6ecb96efb26b9585b/security/src/main/java/io/micronaut/security/authentication/AuthenticationProvider.java#L39 which is why your code won't compile. 2.0RC1 looks like https://github.com/micronaut-projects/micronaut-security/blob/d5ecfc200cf27bd92ec7ce7b3760f5c264ec2647/security/src/main/java/io/micronaut/security/authentication/AuthenticationProvider.java#L44.
Related
I'm currently trying to create a parent class that can be serialized but has no own attributes. (They will be added in the inheriting classes)
For some reason there is no serializer()-method being generated.
I checked the following things:
The companion-object-class is available in the jar but is empty. No class header or anything. Just an empty file.
I have the serialization-plugin from JetBrains added to my build.gradle-file.
My class is annotated with the kotlinx.serialization.serializable-annotation.
Thank you for reading my question.
This is the exception:
java.lang.NullPointerException: Cannot invoke "me.trqhxrd.grapesrpg.impl.world.predefined.Void$Companion.serializer()" because "me.trqhxrd.grapesrpg.impl.world.predefined.Void.Companion" is null
at me.trqhxrd.grapesrpg.impl.world.BlockData.<clinit>(BlockData.kt:24) ~[GrapesRPG-1.0-SNAPSHOT-all.jar:?]
... 37 more
These code-snippets might be relevant:
build.gradle
plugins {
id 'org.jetbrains.kotlin.jvm' version '1.6.21'
id 'org.jetbrains.kotlin.plugin.serialization' version '1.6.21'
id 'com.github.johnrengelman.shadow' version '7.1.2'
id 'java'
}
group = 'me.trqhxrd'
version = '1.0-SNAPSHOT'
repositories {
mavenCentral()
maven {
url 'https://hub.spigotmc.org/nexus/content/repositories/snapshots/'
}
maven {
url 'https://repo.codemc.org/repository/maven-public/'
}
maven {
url 'https://maven.wolfyscript.com/repository/public/'
}
maven {
url 'https://mvn.trqhxrd.de/releases'
}
}
dependencies {
testImplementation 'org.jetbrains.kotlin:kotlin-test'
testImplementation 'com.github.seeseemelk:MockBukkit-v1.18:1.24.1'
compileOnly 'org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT'
compileOnly 'org.eclipse.aether:aether-api:1.1.0'
compileOnly 'org.eclipse.aether:aether-spi:1.1.0'
compileOnly 'org.eclipse.aether:aether-connector-basic:1.1.0'
compileOnly 'org.eclipse.aether:aether-transport-file:1.1.0'
compileOnly 'org.eclipse.aether:aether-transport-http:1.1.0'
compileOnly 'org.apache.maven:maven-aether-provider:3.3.9'
compileOnly 'org.apache.maven.resolver:maven-resolver-connector-basic:1.8.0'
compileOnly 'org.jetbrains.exposed:exposed-core:0.38.2'
compileOnly 'org.jetbrains.exposed:exposed-jdbc:0.38.2'
compileOnly 'org.jetbrains.exposed:exposed-dao:0.38.2'
compileOnly 'org.xerial:sqlite-jdbc:3.36.0.3'
compileOnly 'com.zaxxer:HikariCP:5.0.1'
compileOnly 'org.slf4j:slf4j-nop:2.0.0-alpha7'
compileOnly 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.6.21'
compileOnly 'org.jetbrains.kotlinx:kotlinx-serialization-json-jvm:1.3.2'
compileOnly 'org.jetbrains.kotlin:kotlin-reflect:1.6.21'
compileOnly 'com.google.guava:guava:31.1-jre'
shadow 'org.bstats:bstats-bukkit:3.0.0'
shadow 'me.trqhxrd:menus:1.2.1'
shadow 'com.wolfyscript.wolfyutils.spigot:wolfyutils-spigot:4.16.1.0'
shadow 'de.tr7zw:item-nbt-api:2.9.2'
shadow 'de.tr7zw:nbt-injector:2.9.2'
}
test {
useJUnitPlatform()
}
compileKotlin {
kotlinOptions.jvmTarget = '1.8'
}
compileTestKotlin {
kotlinOptions.jvmTarget = '1.8'
}
tasks.register('installPlugin', Copy) {
dependsOn 'shadowJar'
from layout.buildDirectory.dir("$buildDir/libs/GrapesRPG-1.0-SNAPSHOT-all.jar")
into layout.buildDirectory.dir("$projectDir/Server/plugins")
}
configurations {
shadow
compile.extendsFrom provided
provided.extendsFrom shadow
}
shadowJar {
relocate 'org.bstats', 'me.trqhxrd.shade.bstats'
configurations = [project.configurations.shadow]
from(project.sourceSets.main.output)
}
The parent class
package me.trqhxrd.grapesrpg.impl.world
import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializable
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.decodeFromJsonElement
import kotlinx.serialization.json.jsonObject
import me.trqhxrd.grapesrpg.impl.world.predefined.Void
import me.trqhxrd.grapesrpg.util.ModuleKey
import me.trqhxrd.grapesrpg.api.world.BlockData as BlockDataAPI
#Serializable
abstract class BlockData(override val id: ModuleKey) : BlockDataAPI {
companion object {
val registry = mutableMapOf<ModuleKey, Pair<Class<out BlockData>, KSerializer<out BlockData>>>()
val KEY_VOID = ModuleKey("grapes", "void")
init {
registry[KEY_VOID] = Void::class.java to Void.serializer()
}
}
override fun save() = Json.encodeToString(this)
#Suppress("UNCHECKED_CAST")
override fun load(serialized: String) {
val key = Json.decodeFromJsonElement<ModuleKey>(
Json.decodeFromString<JsonObject>(serialized)["id"]!!.jsonObject
)
val serializer = registry[key]!!.second
val d = serializer.deserialize(Json.decodeFromString(serialized))
if (this::class.java.isAssignableFrom(d::class.java)) this.apply(d)
}
override fun apply(data: BlockDataAPI) {
if (!this::class.java.isAssignableFrom(data::class.java))
throw IllegalArgumentException(
"Can't load data from a class isn't assignable from the loading class. " +
"(Required: ${this::class.qualifiedName}, Received: ${data::class.qualifiedName})"
)
}
}
The child class
package me.trqhxrd.grapesrpg.impl.world.predefined
import kotlinx.serialization.Serializable
import me.trqhxrd.grapesrpg.impl.world.BlockData
import org.bukkit.event.block.BlockBreakEvent
import org.bukkit.event.block.BlockPlaceEvent
import org.bukkit.event.player.PlayerInteractEvent
#Serializable
class Void : BlockData(KEY_VOID) {
override fun onClick(event: PlayerInteractEvent) {}
override fun onBreak(event: BlockBreakEvent) {}
override fun onPlace(event: BlockPlaceEvent) {}
}
EDIT 1:
I try to create a new object of the Void-class via the empty constructor.
EDIT 2:
All the dependencies are compileOnly because this is a Minecraft-Plugin and most of the dependencies will be downloaded automatically by the Minecraft-Server. That way my Uber-Jar is smaller...
Well I just gave up and used Gson. If anyone finds an answer that doesn't just avoid the problem by removing the library feel free to post it here and I'll mark it as correct.
Thank you for reading...
I have a ToolWindowFactory class like this
class MyToolWindowFactory : ToolWindowFactory {
private val sharedFlow = MutableSharedFlow<String>(replay = 1)
override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
CoroutineScope(Dispatchers.IO).launch {
sharedFlow.emit("VALUE")
}
CoroutineScope(Dispatchers.IO).launch {
sharedFlow.collectLatest {
println("$it")
}
}
}
}
I use SharedFlow for variables, but I get this error after run.
Exception in thread "DefaultDispatcher-worker-3" java.lang.NoClassDefFoundError: Could not initialize class kotlinx.coroutines.CoroutineExceptionHandlerImplKt
at kotlinx.coroutines.CoroutineExceptionHandlerKt.handleCoroutineException(CoroutineExceptionHandler.kt:33)
at kotlinx.coroutines.DispatchedTask.handleFatalException$kotlinx_coroutines_core(DispatchedTask.kt:95)
at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:64)
at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)
at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:738)
at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)
at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)
Does ShareStateFlow work in Intelji Plugin?
build.gradle
plugins {
id 'org.jetbrains.intellij' version '1.5.2'
id 'org.jetbrains.kotlin.jvm' version '1.6.10'
id 'java'
}
group 'org.example'
version '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.6.10"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:1.3.9"
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
// See https://github.com/JetBrains/gradle-intellij-plugin/
intellij {
version = '2021.3.3'
}
patchPluginXml {
changeNotes = """
Add change notes here.<br>
<em>most HTML tags may be used</em>"""
}
test {
useJUnitPlatform()
}
I am creating a spring boot application, and using doma for O/R mapper.
I could not start application because repositoryimpl can not find dao class , but i can see them in the build/classes . so build is successful but the application fail to start.
How can I fix it?
Package
Build class
dao class
package com.event.app.backend.infrastructure.dao
import com.event.app.backend.infrastructure.table.EventsTableRecord
import org.seasar.doma.Dao
import org.seasar.doma.Select
import org.seasar.doma.Update
import org.seasar.doma.boot.ConfigAutowireable
#ConfigAutowireable
#Dao
interface EventDao {
#Select
fun getEvents():List<EventsTableRecord>
#Select
fun getEventById(eventId:String):EventsTableRecord
#Update(sqlFile = true)
fun updateTicketCnt(eventId:String,bookTicketCnt:Int):Int
#Update(sqlFile = true)
fun subtractTicketCnt(eventId:String,subtractCount:Int):Int
}
impl class
#Repository
class EventRepositoryImpl(
private val eventDao: EventDao,
private val userDao: UserDao,
) : EventRepository {
/**
* get Events
*/
override fun getEvents(): List<Event> {
// return convertToEvent(eventDao.getEvents())
return listOf(Event(
name = "event1",
description = "description1",
date = LocalDate.now(),
availableTickets = 1
))
}
-omit the details-
build.gradle
buildscript{
repositories{
mavenCentral()
}
dependencies {
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.10")
classpath("org.springframework.boot:spring-boot-gradle-plugin:2.6.2")
}
}
plugins{
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}
apply plugin: "java"
apply plugin: "kotlin"
repositories {
mavenCentral()
}
// テンポラリディレクトリのパスを定義する
ext.domaResourcesDir = "${buildDir}/tmp/doma-resources"
// domaが注釈処理で参照するリソースをテンポラリディレクトリに抽出
task extractDomaResources(type: Copy) {
dependsOn processResources
from processResources.destinationDir
include 'doma.compile.config'
include 'META-INF/**/*.sql'
include 'META-INF/**/*.script'
into domaResourcesDir
}
// テンポラリディレクトリ内のリソースをcompileJavaタスクの出力先ディレクトリにコピーする
task copyDomaResources(type: Copy, dependsOn: extractDomaResources) {
dependsOn extractDomaResources
from domaResourcesDir
into compileJava.destinationDir
}
compileJava {
// 上述のタスクに依存させる
dependsOn copyDomaResources
// テンポラリディレクトリをcompileJavaタスクの入力ディレクトリに設定する
inputs.dir domaResourcesDir
options.encoding = 'UTF-8'
}
compileTestJava {
options.encoding = 'UTF-8'
// テストの実行時は注釈処理を無効にする
options.compilerArgs = ['-proc:none']
}
dependencies {
// spring starter web
implementation ("org.springframework.boot:spring-boot-starter-web")
// doma sprig boot starter
implementation ("org.seasar.doma.boot:doma-spring-boot-starter:1.5.0")
// domaの注釈処理を実行することを示す
annotationProcessor 'org.seasar.doma:doma:2.29.0'
// domaへの依存を示す
implementation 'org.seasar.doma:doma:2.29.0'
}
repositories {
mavenCentral()
}
dependencyManagement{
imports{
mavenBom "org.springframework.boot:spring-boot-dependencies:2.6.2"
}
}
tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
kotlinOptions {
jvmTarget = '11'
}
}
added UserDao.kt
package com.event.app.backend.infrastructure.dao
import com.event.app.backend.infrastructure.table.UsersTicketsTableRecord
import org.seasar.doma.Dao
import org.seasar.doma.Insert
import org.seasar.doma.Select
import org.seasar.doma.boot.ConfigAutowireable
#ConfigAutowireable
#Dao
interface UserDao {
#Insert
fun insertUsersTickets(usersTicketsTableRecord: UsersTicketsTableRecord):Result<UsersTicketsTableRecord>
#Select
fun getTicketCntByEventUserId(eventId:String,userId:String):Int
}
You'd need to use kapt instead of annotationProcessor in build.gradle when you use Doma with Kotlin.
The code generated by kapt can be found under build/generated/source/kapt.
The following sample repository may be helpful.
https://github.com/domaframework/kotlin-sample
In the case of Spring Boot, you'd need to define the Dao's in a BeanConfig. I guess it's something similiar in this case.
import org.jdbi.v3.core.Jdbi;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import se.xxx.dao.*;
#Configuration
public class BeanConfig {
#Bean
public SwingPositionDao swingPositionDao(#Qualifier("jdbi.manager") Jdbi jdbi) {
return jdbi.onDemand(SwingPositionDao.class);
}
}
Recently I've been trying to make a annotation processor through Kotlin but I can't seem to get it to work. Everything compiles and I don't get any errors but when I check the contents of my jar file I don't see the resource I'm trying to create.
I've tried everything for hours and I'm really stuck so just looking for help :/ I do have one random class annotated to see if it would work but no luck.
The annotation class
#Retention(AnnotationRetention.RUNTIME)
#Target(AnnotationTarget.CLASS)
annotation class TestAnnotation
The processor class
#AutoService(TestAnnotation::class)
class TestAnnotationProcessor : AbstractProcessor() {
override fun process(annotations: MutableSet<out TypeElement>, environment: RoundEnvironment): Boolean {
this.processingEnv.filer.createResource(StandardLocation.CLASS_OUTPUT, "", "test.txt")
return true
}
override fun getSupportedSourceVersion() = SourceVersion.RELEASE_8
override fun getSupportedAnnotationTypes() = setOf(TestAnnotation::class.java.canonicalName)
}
My build.gradle.kts
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
plugins {
java
kotlin("jvm") version "1.3.50"
kotlin("kapt") version "1.3.50"
id("com.github.johnrengelman.shadow") version "5.1.0"
}
group = "com.example.test"
version = "1.0"
repositories {
mavenCentral()
}
dependencies {
implementation(kotlin("stdlib-jdk8"))
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.1")
implementation("com.google.auto.service:auto-service:1.0-rc6")
kapt("com.google.auto.service:auto-service:1.0-rc6")
}
configure<JavaPluginConvention> {
sourceCompatibility = JavaVersion.VERSION_1_8
}
tasks.withType<KotlinCompile> {
kotlinOptions.jvmTarget = "1.8"
}
tasks.withType<ShadowJar> {
dependencies {
exclude(dependency("com.google.auto.service:auto-service:1.0-rc6"))
}
}
In order for your custom annotation processor to work, you will have to use it in your build script dependencies
dependencies {
kapt project(':processor-module') // or what ever your processor's module is named.
//OR
kapt 'gourp:artifact:version' // if your processor is published into a maven repository.
}
I have created sample micronaut project with simple testNG test based on this instruction.
The test works perfectly when I run it via gradle from command line, but fails when I try to run it from IDEA.
For successful gradle run in logs I see routing for my controller:
13:40:44.314 [Test worker] DEBUG i.m.web.router.DefaultRouteBuilder - Created Route: GET /hello -> HelloController#String index() (application/json )
which is missing for IDEA run.
QUESTION: What do I need to configure to make the test also pass in IDEA?
sources
src/main/kotlin/example/micronaut/Application.kt:
package example.micronaut
import io.micronaut.runtime.Micronaut
object Application {
#JvmStatic
fun main(args: Array<String>) {
Micronaut.build()
.packages("example.micronaut")
.mainClass(Application.javaClass)
.start()
}
}
src/main/kotlin/example/micronaut/HelloController.kt:
package example.micronaut
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
#Controller("/hello")
class HelloController {
#Get("/")
fun index(): String {
return "Hello World"
}
}
src/test/kotlin/example/micronaut/HelloTest.kt:
package example.micronaut
import io.micronaut.context.ApplicationContext
import io.micronaut.http.client.HttpClient
import io.micronaut.runtime.server.EmbeddedServer
import org.testng.annotations.AfterMethod
import org.testng.annotations.BeforeMethod
import org.testng.annotations.Test
class HelloTest {
lateinit var embeddedServer: EmbeddedServer
lateinit var client: HttpClient
#BeforeMethod
fun init() {
embeddedServer = ApplicationContext.run(EmbeddedServer::class.java)
client = HttpClient.create(embeddedServer.url)
}
#Test
fun check() {
val response: String = client.toBlocking().retrieve("/hello")
assert(response == "Hello World")
}
#AfterMethod
fun cleanup() {
client.close()
embeddedServer.close()
}
}
build.gradle:
buildscript {
repositories {
mavenCentral()
maven { url "https://plugins.gradle.org/m2/" }
}
dependencies {
classpath "com.github.jengelman.gradle.plugins:shadow:2.0.4"
classpath "io.spring.gradle:dependency-management-plugin:1.0.5.RELEASE"
classpath "net.ltgt.gradle:gradle-apt-plugin:0.15"
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.2.31"
}
}
version "0.1"
group "example"
apply plugin:"io.spring.dependency-management"
apply plugin:"com.github.johnrengelman.shadow"
apply plugin:"application"
apply plugin:"java"
apply plugin:"net.ltgt.apt-eclipse"
apply plugin:"net.ltgt.apt-idea"
apply plugin:"kotlin"
apply plugin:"kotlin-kapt"
repositories {
mavenLocal()
mavenCentral()
maven { url "https://jcenter.bintray.com" }
}
dependencyManagement {
imports {
mavenBom 'io.micronaut:bom:1.0.0.M1'
}
}
dependencies {
annotationProcessor "io.micronaut:inject-java"
compile "io.micronaut:http-client"
compile "io.micronaut:http-server-netty"
compile "io.micronaut:inject"
compile "io.micronaut:runtime"
compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.2.31"
compile "org.jetbrains.kotlin:kotlin-reflect:1.2.31"
compileOnly "io.micronaut:inject-java"
kapt "io.micronaut:inject-java"
runtime "ch.qos.logback:logback-classic:1.2.3"
testCompile "io.micronaut:inject-java"
testImplementation("org.testng:testng:6.13.1")
}
shadowJar {
mergeServiceFiles()
}
mainClassName = "example.micronaut.Application"
compileJava.options.compilerArgs += '-parameters'
compileTestJava.options.compilerArgs += '-parameters'
test {
useTestNG()
}
compileKotlin {
kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
kotlinOptions.jvmTarget = "1.8"
}
Solved
fixed by setting gradle as test runner as described in http://mrhaki.blogspot.com/2016/03/gradle-goodness-configure-intellij-idea.html
Currently a build tool is required to build Kotlin + Micronaut applications until IntelliJ brings native support for Kapt. This is explained here https://docs.micronaut.io/latest/guide/index.html#kotlin in the section "Kotlin, Kapt and IntelliJ"