IssueTracker

Actually, createAndroidComposeRule does not seem to allow for the situation where an Activity needs input. I can only find a version where you pass the activity class name, and it gets constructed for you without inputs.

What kind of input do you mean? Do you mean input for Activity or ActivityScenarioRule?

Input for the Activity. In the scenario that I linked, the Activity needs a string passed in its intent:

    val intent = Intent(context, DetailsActivity::class.java)
    intent.putExtra(KEY_ARG_DETAILS_CITY_NAME, item.city.name)
    return intent

If I use createAndroidComposeRule, how would I pass that city name?

Our API is not very friendly to accommodate this scenario (because we didn't think of this use when designing it), but it is possible to achieve with public API:

@LargeTest
@RunWith(AndroidJUnit4::class)
class LateActivityLaunchTest {

    private lateinit var activityScenario: ActivityScenario<CustomActivity>

    @get:Rule
    val rule = AndroidComposeTestRule(EmptyTestRule()) {
        var activity: CustomActivity? = null
        activityScenario.onActivity { activity = it }
        checkNotNull(activity) { "Activity didn't launch" }
    }

    class EmptyTestRule : TestRule {
        override fun apply(base: Statement, description: Description) = base
    }

    @Test
    fun test() {
        setupSomethingFirst()

        ActivityScenario.launch<CustomActivity>(
            Intent(ApplicationProvider.getApplicationContext(), CustomActivity::class.java)
        ).use {
            activityScenario = it
            rule.onNode(hasText("Hello")).assertExists()
        }
    }

    private fun setupSomethingFirst() {
    }
}

class CustomActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Text("Hello")
        }
    }
}

We should provide more accessible support in our API for this though

Current thoughts are to split the ComposeTestRule interface and add fun createComposeRuleNoLauncher. Roughly something like this:

// commonMain
interface ComposeTestRule {
  // same as now, but without `fun setContent`
}

// commonMain
interface ComposeContentTestRule : ComposeTestRule {
  fun setContent(content: @Composable () -> Unit)
}

// androidMain
class AndroidComposeTestRule : ComposeContentTestRule

// commonMain
expect fun createComposeRule() : ComposeContentTestRule

// androidMain
actual fun createComposeRule() = createAndroidComposeRule()

// androidMain
fun createAndroidComposeRule() : AndroidComposeTestRule

// androidMain
fun createComposeRuleNoLauncher() : ComposeTestRule = AndroidComposeTestRule(activityRule = null)

A few things still have to be worked out, but the main bit I wanted to share is the new factory method and the interface split.

Things still to be worked out:

1. Will we keep supporting AndroidComposeTestRule with a generic activityRule + activityProvider, or do we direct devs to use createComposeRuleNoLauncher and do the wiring themselves?
2. AndroidComposeTestRule constructor to be used by createComposeRuleNoLauncher. Depends on answer to 1.