kotlinsrc/nullables/NullabilityTest.kt

/*
 * Copyright (C) 2023 The Dagger 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
 *
 * http://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 dagger.functional.kotlinsrc.nullables

import com.google.common.truth.Truth.assertThat
import dagger.Component
import dagger.Module
import dagger.Provides
import dagger.Reusable
import dagger.multibindings.IntoSet
import java.lang.NullPointerException
import javax.inject.Inject
import javax.inject.Provider
import javax.inject.Singleton
import org.junit.Assert.fail
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4

@RunWith(JUnit4::class)
class NullabilityTest {
  @Component(dependencies = [NullComponent::class])
  internal interface NullComponentWithDependency {
    fun string(): String?

    fun number(): Number

    fun stringProvider(): Provider<String>

    fun numberProvider(): Provider<Number>
  }

  interface Bar<T> {}

  class BarNoNull : Bar<String>

  class BarWithNull : Bar<String?>

  @Component(modules = [NullModule::class])
  internal interface NullComponent {
    fun string(): String?

    fun integer(): Int?

    fun nullFoo(): NullFoo

    fun number(): Number

    fun stringProvider(): Provider<String>

    fun numberProvider(): Provider<Number>

    fun setOfBar(): Set<Bar<String>>

    fun setOfBarWithNullableArg(): Set<Bar<String?>>
  }

  @Module
  internal class NullModule {
    var numberValue: Number? = null
    var integerCallCount = 0

    @IntoSet @Provides fun providesNullableStringInToSet(): Bar<String?> = BarWithNull()

    @IntoSet @Provides fun providesNonNullStringIntoSet(): Bar<String> = BarNoNull()

    @Provides fun provideNullableString(): String? = null

    @Provides fun provideNumber(): Number = numberValue!!

    @Provides
    @Reusable
    fun provideNullReusableInteger(): Int? {
      integerCallCount++
      return null
    }
  }

  @Suppress("BadInject") // This is just for testing purposes.
  internal class NullFoo
  @Inject
  constructor(
    val string: String?,
    val number: Number,
    val stringProvider: Provider<String>,
    val numberProvider: Provider<Number>,
  ) {
    var methodInjectedString: String? = null
    lateinit var methodInjectedNumber: Number
    lateinit var methodInjectedStringProvider: Provider<String>
    lateinit var methodInjectedNumberProvider: Provider<Number>

    @Inject
    fun inject(
      string: String?,
      number: Number,
      stringProvider: Provider<String>,
      numberProvider: Provider<Number>,
    ) {
      methodInjectedString = string
      methodInjectedNumber = number
      methodInjectedStringProvider = stringProvider
      methodInjectedNumberProvider = numberProvider
    }

    @JvmField @Inject var fieldInjectedString: String? = null
    @Inject lateinit var fieldInjectedNumber: Number
    @Inject lateinit var fieldInjectedStringProvider: Provider<String>
    @Inject lateinit var fieldInjectedNumberProvider: Provider<Number>
  }

  @Test
  fun testNullability_provides() {
    val module = NullModule()
    val component = DaggerNullabilityTest_NullComponent.builder().nullModule(module).build()

    // Can't construct NullFoo because it depends on Number, and Number was null.
    try {
      component.nullFoo()
      fail()
    } catch (npe: NullPointerException) {
      // NOTE: In Java we would check that the Dagger error message is something like:
      //   "Cannot return null from a non-@Nullable @Provides method"
      // However, in Kotlin there's no way to return a null value from a non-null return type
      // without explicitly using `!!`, which results in an error before Dagger's runtime
      // checkNotNull has a chance to run.
    }

    // set number to non-null so we can create
    module.numberValue = 1
    val nullFoo = component.nullFoo()

    // Then set it back to null so we can test its providers.
    module.numberValue = null
    validate(nullFoo.string, nullFoo.stringProvider, nullFoo.numberProvider)
    validate(
      nullFoo.methodInjectedString,
      nullFoo.methodInjectedStringProvider,
      nullFoo.methodInjectedNumberProvider,
    )
    validate(
      nullFoo.fieldInjectedString,
      nullFoo.fieldInjectedStringProvider,
      nullFoo.fieldInjectedNumberProvider,
    )
  }

  @Test
  fun testNullability_reusuable() {
    val module = NullModule()
    val component = DaggerNullabilityTest_NullComponent.builder().nullModule(module).build()

    // Test that the @Nullable @Reusuable binding is cached properly even when the value is null.
    assertThat(module.integerCallCount).isEqualTo(0)
    assertThat(component.integer()).isNull()
    assertThat(module.integerCallCount).isEqualTo(1)
    assertThat(component.integer()).isNull()
    assertThat(module.integerCallCount).isEqualTo(1)
    assertThat(component.setOfBar().size).isEqualTo(2)
    assertThat(component.setOfBarWithNullableArg().size).isEqualTo(2)
  }

  @Test
  fun testNullability_components() {
    val nullComponent: NullComponent =
      object : NullComponent {
        override fun string(): String? = null

        override fun integer(): Int? = null

        override fun stringProvider(): Provider<String> = Provider { null!! }

        override fun numberProvider(): Provider<Number> = Provider { null!! }

        override fun number(): Number = null!!

        override fun nullFoo(): NullFoo = null!!

        override fun setOfBar(): Set<Bar<String>> = emptySet()

        override fun setOfBarWithNullableArg(): Set<Bar<String?>> = emptySet()
      }
    val component =
      DaggerNullabilityTest_NullComponentWithDependency.builder()
        .nullComponent(nullComponent)
        .build()
    validate(component.string(), component.stringProvider(), component.numberProvider())

    // Also validate that the component's number() method fails
    try {
      component.number()
      fail()
    } catch (npe: NullPointerException) {
      // NOTE: In Java we would check that the Dagger error message is something like:
      //   "Cannot return null from a non-@Nullable @Provides method"
      // However, in Kotlin there's no way to return a null value from a non-null return type
      // without explicitly using `!!`, which results in an error before Dagger's runtime
      // checkNotNull has a chance to run.
    }
  }

  private fun validate(
    string: String?,
    stringProvider: Provider<String>,
    numberProvider: Provider<Number>,
  ) {
    assertThat(string).isNull()
    assertThat(numberProvider).isNotNull()
    try {
      numberProvider.get()
      fail()
    } catch (npe: NullPointerException) {
      // NOTE: In Java we would check that the Dagger error message is something like:
      //   "Cannot return null from a non-@Nullable @Provides method"
      // However, in Kotlin there's no way to return a null value from a non-null return type
      // without explicitly using `!!`, which results in an error before Dagger's runtime
      // checkNotNull has a chance to run.
    }
    assertThat(stringProvider.get()).isNull()
  }
}