Give both screens somewhere for a state to come from

`ConverterScreen` and `JoinScreen` each inlined their whole `when (state)`
inside the public entry point, and state arrived only as `viewModel.state`.
That left four of the twelve state branches across the two screens with no
test that could ever reach them: driving a real ViewModel needs a WorkManager
and a media probe in the constructor, and even then `Waiting` follows a denied
foreground start and `Converted`/`Joined` follow a worker run that has already
succeeded.

So the `when` moves into `ConverterScreenContent` and `JoinScreenContent`,
which take the state, the settings, the validation and an actions holder. The
entry points keep the three launchers and `collectAsStateWithLifecycle` and
nothing else.

The callbacks travel in `ConverterActions` / `JoinActions` rather than as loose
parameters because detekt's `LongParameterList` sits at its default threshold
of six and `config/detekt/detekt.yml` does not relax it for `@Composable` --
`AdvancedPicker` already sits exactly on it. Twelve flat parameters would turn
a clean detekt run red; data classes are exempt from the rule.

Nothing else changed. The body was cut and pasted rather than retyped, so the
U+2026, U+2014 and U+00B7 characters the leaf tests match on are the same
bytes, and `is Idle -> Unit` in the nested `when` -- permanently unreachable,
and deliberately kept -- survives the move. The diff stops above `FormatPicker`
in one file and above `FileRow` in the other, which is why the leaf suites
#57-#60 landed pass unedited: every one of them composes a leaf directly and
none references either entry point.

The two new tests are the bite, one per screen and one per direction of the
seam: a `Converted` / `Joined` state renders Save, and tapping Save hands back
the name the finished job chose. The state matrix itself is #62 and #63.
This commit is contained in:
2026-08-24 19:06:26 -05:00
parent e968deb5a2
commit 46ad95350b
4 changed files with 346 additions and 27 deletions
@@ -0,0 +1,115 @@
package org.libremediaconverter.convert
import android.net.Uri
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.performClick
import androidx.compose.ui.test.performScrollTo
import androidx.media3.common.util.UnstableApi
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.libremediaconverter.createDrainedComposeRule
import org.libremediaconverter.model.Validation
import org.libremediaconverter.ui.TestTags
import org.robolectric.RobolectricTestRunner
import java.io.File
/**
* The seam carries a `ConversionState` in and an action back out.
*
* The defect this bites on is the extraction having quietly stopped being an extraction: a
* `ConverterScreenContent` that ignores the `state` it was handed, or renders the finished job's
* affordances without wiring them to the callbacks the entry point supplies. Neither shows up at
* compile time -- an unread parameter compiles, and a `Button` whose `onClick` does nothing is a
* valid `Button` -- and neither is visible from the leaf tests, which compose `FileCard`,
* `AdvancedPicker` and the pickers directly and never see a state at all.
*
* **Both assertions were unreachable before R38.5**, which is the point of the ticket rather than
* a remark about it. `ConversionState.Converted` is produced only by a `ConversionWorker` run that
* has already succeeded, so no test can drive a real `ConversionViewModel` into it: it would need
* a `WorkManager`, a media probe, a staged output file and a completed job. Handing the state in
* is the only way to ask what the screen does with it.
*
* Deliberately not the state matrix. Which affordances each of the six `ConversionState`s renders
* is R38.6 (#62); this file asserts only that the injection point exists and works in both
* directions, so the two PRs cannot collide over the same cases.
*/
@UnstableApi
@RunWith(RobolectricTestRunner::class)
class ConverterScreenContentTest {
// Not `createComposeRule()` directly: see [org.libremediaconverter.drainEscapedCoroutineErrors].
@get:Rule
val composeRule = createDrainedComposeRule()
/** What the screen asked to save, in the order it asked. Empty until Save is tapped. */
private val savedAs = mutableListOf<String>()
@Test
fun `a converted job renders the save button`() {
setContent(converted())
composeRule.onNodeWithTag(TestTags.SAVE_FILE).assertExists()
}
/**
* The direction that did not exist before this change.
*
* Asserting the *name* rather than just that something was called: the suggested name comes
* from the job -- `ConversionWorker.KEY_SUGGESTED_NAME` -- and is what the save dialog opens
* with, so a Save button wired to the wrong branch's state would hand over the wrong one and
* a bare "was called" check would stay green.
*/
@Test
fun `tapping save hands back the name the finished job chose`() {
setContent(converted())
composeRule.onNodeWithTag(TestTags.SAVE_FILE).performScrollTo().performClick()
assertEquals(listOf("holiday.mp4"), savedAs)
}
/**
* `staged` names a file that does not exist, on purpose.
*
* The branch renders `formatBytes(s.staged.length())`, and `length()` answers `0L` for a
* missing path rather than throwing, so the size line reads `0 B` and no temporary folder is
* needed. `routeReason` stays blank, which is what keeps the routing chip out of the tree --
* that chip is R38.6's case, not this file's.
*/
private fun converted() = ConversionState.Converted(
input = InputFile(
uri = Uri.parse("content://test/holiday.mkv"),
displayName = "holiday.mkv",
sizeBytes = 12_345_678L,
),
staged = File("no-such-staged-output.mp4"),
suggestedName = "holiday.mp4",
mimeType = "video/mp4",
)
private fun setContent(state: ConversionState) {
composeRule.setContent {
ConverterScreenContent(
state = state,
settings = ConversionSettings(),
validation = Validation.Valid,
actions = ConverterActions(
onPickInput = {},
onPreset = {},
onContainer = {},
onVideoCodec = {},
onAudioCodec = {},
onSuggestion = {},
onQuality = {},
onEnginePreference = {},
onConvert = {},
onCancel = {},
onSave = { suggestedName -> savedAs += suggestedName },
onReset = {},
),
)
}
}
}
@@ -0,0 +1,83 @@
package org.libremediaconverter.join
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.performClick
import androidx.compose.ui.test.performScrollTo
import androidx.media3.common.util.UnstableApi
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.libremediaconverter.createDrainedComposeRule
import org.libremediaconverter.model.ConcatStrategy
import org.libremediaconverter.ui.TestTags
import org.robolectric.RobolectricTestRunner
import java.io.File
/**
* The join screen's half of the same seam, and the same two directions.
*
* The defect is the one `ConverterScreenContentTest` describes -- a content composable that
* ignores the state handed to it, or renders the finished job's affordances unwired -- and it has
* to be asked separately here because the two screens share no code. `JoinScreen` and
* `ConverterScreen` were extracted in the same commit by the same hand, which is exactly the
* circumstance in which one of them gets the wiring right and the other does not.
*
* `JoinState.Joined` is unreachable through a real `JoinViewModel` for the same reason
* `ConversionState.Converted` is: only a `ConcatWorker` run that has already succeeded produces
* one, carrying the strategy it chose and the name it picked.
*
* `JoinScreenKt` is the honest remaining coverage gap on this repo, and closing it is R38.7 (#63),
* not this file. Which affordances each `JoinState` renders belongs there; this asserts only that
* the injection point exists.
*/
@UnstableApi
@RunWith(RobolectricTestRunner::class)
class JoinScreenContentTest {
// Not `createComposeRule()` directly: see [org.libremediaconverter.drainEscapedCoroutineErrors].
@get:Rule
val composeRule = createDrainedComposeRule()
/** What the screen asked to save, in the order it asked. Empty until Save is tapped. */
private val savedAs = mutableListOf<String>()
@Test
fun `a finished join renders the save button`() {
setContent(joined())
composeRule.onNodeWithTag(TestTags.SAVE_FILE).assertExists()
}
@Test
fun `tapping save hands back the name the finished join chose`() {
setContent(joined())
composeRule.onNodeWithTag(TestTags.SAVE_FILE).performScrollTo().performClick()
assertEquals(listOf("joined.mp4"), savedAs)
}
/** `staged` names a missing file deliberately -- see the same helper on the converter side. */
private fun joined() = JoinState.Joined(
staged = File("no-such-staged-output.mp4"),
strategy = ConcatStrategy.STREAM_COPY,
suggestedName = "joined.mp4",
mimeType = "video/mp4",
)
private fun setContent(state: JoinState) {
composeRule.setContent {
JoinScreenContent(
state = state,
actions = JoinActions(
onPickInputs = {},
onJoin = {},
onCancel = {},
onSave = { suggestedName -> savedAs += suggestedName },
onReset = {},
),
)
}
}
}