Credit from repo: https://github.com/SabagRonen/dagger-activity-test-sample/blob/ActivitySample/app/src/androidTest/java/com/example/ronensabag/daggeractivitytestsample/MainViewTests.kt

FakeDependencyActivity.kt

@RunWith(AndroidJUnit4::class)
class MainViewTests {
  val mockUserAction = mock(MainContract.UserAction::class.java)

  @get:Rule
  val activityTestRule = object : ActivityTestRule<MainActivity>(MainActivity::class.java, true, true) {
    override fun beforeActivityLaunched() {
      super.beforeActivityLaunched()
      val myApp = InstrumentationRegistry.getTargetContext().applicationContext as MyApp
      myApp.dispatchingActivityInjector = createFakeActivityInjector<MainActivity> {
        userAction = mockUserAction
      }
    }
  }

  @Test
  fun clickOnFabCallToCreateTopic() {
    onView(withId(R.id.fab)).perform(click())

    verify(mockUserAction).createTopic(view = activityTestRule.activity)
  }
}

inline fun <reified T : Activity> createFakeActivityInjector(crossinline block : T.() -> Unit)
    : DispatchingAndroidInjector<Activity> {
  val injector = AndroidInjector<Activity> { instance ->
    if (instance is T) {
      instance.block()
    }
  }
  val factory = AndroidInjector.Factory<Activity> { injector }
  val map = mapOf(Pair<Class <out Activity>, Provider<Factory<out Activity>>>(T::class.java, Provider { factory }))
  return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(map)
}

FakeDependencyFragment.kt

inline fun <reified F : Fragment> createFakeFragmentInjector(crossinline block : F.() -> Unit)
    : DispatchingAndroidInjector<Activity> {
  val myApp = InstrumentationRegistry.getTargetContext().applicationContext as MyApp
  val originalDispatchingActivityInjector = myApp.dispatchingActivityInjector
  var originalFragmentInjector: AndroidInjector<Fragment>? = null
  val fragmentInjector = AndroidInjector<Fragment> { fragment ->
    originalFragmentInjector?.inject(fragment)
    if (fragment is F) {
      fragment.block()
    }
  }
  val fragmentFactory = AndroidInjector.Factory<Fragment> { fragmentInjector }
  val fragmentMap = mapOf(Pair<Class <out Fragment>, Provider<Factory<out Fragment>>>(F::class.java, Provider { fragmentFactory }))
  val activityInjector = AndroidInjector<Activity> { activity ->
    originalDispatchingActivityInjector.inject(activity)
    if (activity is MainActivity) {
      originalFragmentInjector = activity.fragmentInjector
      activity.fragmentInjector = DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(fragmentMap)
    }
  }
  val activityFactory = AndroidInjector.Factory<Activity> { activityInjector }
  val activityMap = mapOf(Pair<Class <out Activity>, Provider<Factory<out Activity>>>(MainActivity::class.java, Provider { activityFactory }))
  return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(activityMap)
}