Initial tests and formatting

Author: stoyicker

.circleci/config.yml

@@ -47,7 +47,7 @@ jobs:
       - image: circleci/openjdk:8u222-stretch
     steps:
       - checkout
-      - run: 
+      - run:
           name: Upload annotations to Bintray
           command: ./gradlew :annotations:bintrayUpload --no-daemon --no-build-cache --refresh-dependencies
           when: always

annotations/src/main/kotlin/com/google/auto/factory/AutoFactory.kt

@@ -14,28 +14,28 @@ import kotlin.reflect.KClass
 @Retention(AnnotationRetention.BINARY)
 @Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.TYPE, AnnotationTarget.FUNCTION)
 annotation class AutoFactory(
-  /**
-   * The <i>simple</i> name of the generated factory; the factory is always generated in the same
-   * package as the annotated type. The default value (the empty string) will result in a factory
-   * with the name of the type being created with {@code Factory} appended to the end. For example,
-   * the default name for a factory for {@code MyType} will be {@code MyTypeFactory}.
-   *
-   * <p>If the annotated type is nested, then the generated factory's name will start with the
-   * enclosing type names, separated by underscores. For example, the default name for a factory for
-   * {@code Outer.Inner.ReallyInner} is {@code Outer_Inner_ReallyInnerFactory}. If {@code className}
-   * is {@code Foo}, then the factory name is {@code Outer_Inner_Foo}.
-   */
-  val name: String = "",
-  /**
-   * An array of interfaces that the generated factory is required to implement.
-   */
-  val implementing: Array<KClass<out Any>>,
-  /**
-   * The type that the generated factory is require to extend.
-   */
-  val extending: KClass<out Any> = Any::class,
-  /**
-   * Whether or not the generated factory should be final.
-   * Defaults to disallowing subclasses (generating the factory as final).
-   */
-  val allowSubclasses: Boolean = false)
+    /**
+     * The <i>simple</i> name of the generated factory; the factory is always generated in the same
+     * package as the annotated type. The default value (the empty string) will result in a factory
+     * with the name of the type being created with {@code Factory} appended to the end. For example,
+     * the default name for a factory for {@code MyType} will be {@code MyTypeFactory}.
+     *
+     * <p>If the annotated type is nested, then the generated factory's name will start with the
+     * enclosing type names, separated by underscores. For example, the default name for a factory for
+     * {@code Outer.Inner.ReallyInner} is {@code Outer_Inner_ReallyInnerFactory}. If {@code className}
+     * is {@code Foo}, then the factory name is {@code Outer_Inner_Foo}.
+     */
+    val name: String = "",
+    /**
+     * An array of interfaces that the generated factory is required to implement.
+     */
+    val implementing: Array<KClass<out Any>>,
+    /**
+     * The type that the generated factory is require to extend.
+     */
+    val extending: KClass<out Any> = Any::class,
+    /**
+     * Whether or not the generated factory should be final.
+     * Defaults to disallowing subclasses (generating the factory as final).
+     */
+    val allowSubclasses: Boolean = false)

gradle.properties

@@ -1,5 +1,5 @@
 versions.dependencies.javax.inject=1
 versions.dependencies.jsr250-api=1.0
 versions.dependencies.junit=5.5.2
-versions.dependencies.mockito=3.1.0
+versions.dependencies.mockito-kotlin=2.2.0
 versions.dependencies.kotlinpoet=1.4.1

processor/build.gradle

@@ -17,5 +17,14 @@ repositories {
 dependencies {
   implementation project(":annotations")
   api "com.squareup:kotlinpoet:${rootProject."versions.dependencies.kotlinpoet"}"
+  testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:${rootProject."versions.dependencies.mockito-kotlin"}"
+  testImplementation "org.junit.jupiter:junit-jupiter-api:${rootProject."versions.dependencies.junit"}"
+  testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${rootProject."versions.dependencies.junit"}"
+}
+test {
+  testLogging {
+    showStandardStreams = true
+  }
+  useJUnitPlatform()
 }
 apply from: Paths.get(rootDir.absolutePath, ".circleci", "publish.gradle")

processor/src/main/kotlin/org/github/stoyicker/auto/factory/kotlin/processor/AutoFactoryKotlinProcessor.kt

@@ -1,6 +1,8 @@
 package org.github.stoyicker.auto.factory.kotlin.processor
 
+import com.google.auto.factory.AutoFactory
 import javax.annotation.processing.AbstractProcessor
+import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.annotation.processing.SupportedOptions
 import javax.annotation.processing.SupportedSourceVersion
@@ -9,10 +11,20 @@ import javax.lang.model.element.TypeElement
 
 @SupportedSourceVersion(SourceVersion.RELEASE_8)
 @SupportedOptions(OPTION_KEY_KAPT_KOTLIN_GENERATED)
-class AutoFactoryKotlinProcessor : AbstractProcessor() {
+internal class AutoFactoryKotlinProcessor constructor(
+    private val supportedAnnotationTypes: Set<String>) : AbstractProcessor() {
+  @Suppress("unused") // Actual constructor used in production
+  constructor() : this(setOf(AutoFactory::javaClass.name))
+
+  override fun init(processingEnv: ProcessingEnvironment?) {
+    super.init(processingEnv)
+  }
+
   override fun process(p0: MutableSet<out TypeElement>?, p1: RoundEnvironment?): Boolean {
     TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
   }
+
+  override fun getSupportedAnnotationTypes() = supportedAnnotationTypes
 }
 
 private const val OPTION_KEY_KAPT_KOTLIN_GENERATED = "kapt.kotlin.generated"

processor/src/test/kotlin/org.github.stoyicker.auto.factory.kotlin.processor/AutoFactoryKotlinProcessorTest.kt

@@ -0,0 +1,22 @@
+package org.github.stoyicker.auto.factory.kotlin.processor
+
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verifyNoMoreInteractions
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertSame
+import org.junit.jupiter.api.Test
+
+internal class AutoFactoryKotlinProcessorTest {
+  private val supportedAnnotationTypes = mock<Set<String>>()
+  private val subject = AutoFactoryKotlinProcessor(supportedAnnotationTypes)
+
+  @AfterEach
+  fun afterEach() {
+    verifyNoMoreInteractions(supportedAnnotationTypes)
+  }
+
+  @Test
+  fun getSupportedAnnotationTypes() {
+    assertSame(supportedAnnotationTypes, subject.supportedAnnotationTypes)
+  }
+}

sample/build.gradle

@@ -13,7 +13,7 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
   compileOnly project(":annotations")
   kapt project(":processor")
-  testImplementation "org.mockito:mockito-core:${rootProject."versions.dependencies.mockito"}"
+  testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:${rootProject."versions.dependencies.mockito-kotlin"}"
   testImplementation "org.junit.jupiter:junit-jupiter-api:${rootProject."versions.dependencies.junit"}"
   testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${rootProject."versions.dependencies.junit"}"
 }