Cannot create Test component as subclass of Main component when contributed subcomponents are present

So I have my main app component:

@MergeComponent(AppScope::class)
@AppScope
interface AppComponent {
    @Component.Factory
    interface Factory {
        fun create(@BindsInstance application: Application): AppComponent
    }
}

And a subclass in my androidTest folder:

@MergeComponent(AppScope::class)
@AppScope
interface TestAppComponent: AppComponent {
    @Component.Factory
    interface Factory {
        fun create(
            @BindsInstance application: Application,
            @BindsInstance mockInterceptor: MockInterceptor
        ): TestAppComponent
    }
}

This works relatively well, except when i introduce a contributed subcomponent:

@ContributesSubcomponent(
    parentScope = AppScope::class,
    scope = PodOnboardingScope::class
)
@PodOnboardingScope
interface PodOnboardingComponent {
    fun activityComponentFactory(): PodOnboardingActivityComponent.Factory

    @ContributesSubcomponent.Factory
    interface Factory {
        fun create(): PodOnboardingComponent
    }

    @ContributesTo(AppScope::class)
    interface FactoryCreator {
        fun podOnboardingComponentFactory(): Factory
    }
}

This leads to this error:

TestAppComponent.java:9: error: conflicting entry point declarations:
public abstract interface TestAppComponent extends com.xfinity.dh.pods.app.di.AppComponent, com.xfinity.dh.pods.di.PodOnboardingComponent.FactoryCreator, com.xfinity.dh.pods.app.di.AppInjectors, anvil.component.com.xfinity.dh.app.di.testappcomponent.PodOnboardingComponentA.ParentComponent {
                ^
      @org.jetbrains.annotations.NotNull @Override anvil.component.com.xfinity.dh.app.di.testappcomponent.PodOnboardingComponentA.SubcomponentFactory anvil.component.com.xfinity.dh.app.di.testappcomponent.PodOnboardingComponentA.ParentComponent.podOnboardingComponentFactory()
      @org.jetbrains.annotations.NotNull anvil.component.com.xfinity.dh.pods.app.di.appcomponent.PodOnboardingComponentA.SubcomponentFactory anvil.component.com.xfinity.dh.pods.app.di.appcomponent.PodOnboardingComponentA.ParentComponent.podOnboardingComponentFactory()

I have a temporary workaround which is to move my injectors/accessors to their own interfaces in the main app, and look those up in my component registry by their interfaces. Once i do that, i can remove the inheritance, and i generally don’t ever refer to the AppComponent directly unless i’m actually creating it. It works, but it seems odd to have to do this.

[mattinger]

Yeah, that’s what i’ve done is to move the injectors to a different interface. However, traditional testing in dagger usually extends the main component to produce the app component, and it works. That’s the only reason I bring this up as an issue is that it’s something i see done a lot in non anvil based dagger.

[PaulWoitaschek]

To help others here, the solution suggested by @vRallev is good. The key here is that you can still have some form of inheritance if you need it. For example if you swap out an injected Component by a test component.

So if you previously have a component like this:

@AppScope
@MergeComponent(
  scope = AppScope::class,
  dependencies = [DatabaseComponent::class],
)
interface AppComponent {

  fun inject(target: App)

  @Component.Factory
  interface Factory {
    fun create(
      @BindsInstance application: Application,
      databaseComponent: DatabaseComponent,
      networkModule: NetworkModule
    ): AppComponent

    companion object {
      operator fun invoke(): Factory {
        return DaggerAppComponent.factory()
      }
    }
  }
}

And a test component like this:

@AppScope
@MergeComponent(
  scope = AppScope::class,
  dependencies = [DatabaseComponent::class],
)
interface TestComponent : AppComponent {

  val loginUser: LoginUser

  @Component.Factory
  interface Factory {
    fun create(
      @BindsInstance application: Application,
      databaseComponent: DatabaseComponent,
      networkModule: NetworkModule,
    ): TestComponent

    companion object {
      operator fun invoke(): Factory {
        return DaggerTestComponent.factory()
      }
    }
  }
}

You can now extract out an interface:

interface AppComponent {

  fun inject(target: App)
}

And for the production and the test component you extend from that interface:

@AppScope
@MergeComponent(
  scope = AppScope::class,
  dependencies = [DatabaseComponent::class],
  modules = [MobileSharedModule::class]
)
interface ProductionAppComponent : AppComponent {

  @Component.Factory
  interface Factory {
    fun create(
      @BindsInstance application: Application,
      databaseComponent: DatabaseComponent,
      networkModule: NetworkModule
    ): ProductionAppComponent

    companion object {
      operator fun invoke(): Factory {
        return DaggerProductionAppComponent.factory()
      }
    }
  }
}

@AppScope
@MergeComponent(
  scope = AppScope::class,
  dependencies = [DatabaseComponent::class],
  modules = [MobileSharedModule::class]
)
interface TestComponent : AppComponent {

  val loginUser: LoginUser

  @Component.Factory
  interface Factory {
    fun create(
      @BindsInstance application: Application,
      databaseComponent: DatabaseComponent,
      networkModule: NetworkModule,
    ): TestComponent

    companion object {
      operator fun invoke(): Factory {
        return DaggerTestComponent.factory()
      }
    }
  }
}