@granite-js/video 1.0.0

package/android/src/test/java/run/granite/video/event/VideoEventListenerAdapterTest.kt

@@ -0,0 +1,319 @@
+package run.granite.video.event
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.*
+import run.granite.video.provider.GraniteVideoErrorData
+import run.granite.video.provider.GraniteVideoLoadData
+import run.granite.video.provider.GraniteVideoProgressData
+
+class VideoEventListenerAdapterTest : FunSpec({
+
+    lateinit var mockDispatcher: VideoEventDispatcher
+    lateinit var mockWritableMap: WritableMap
+    lateinit var adapter: VideoEventListenerAdapter
+    val viewId = 123
+    val surfaceId = 1
+
+    beforeTest {
+        mockDispatcher = mockk(relaxed = true)
+        mockWritableMap = mockk(relaxed = true)
+
+        // Mock static Arguments.createMap() to return our mock
+        mockkStatic(Arguments::class)
+        every { Arguments.createMap() } returns mockWritableMap
+
+        // Mock getSurfaceId() to return test surfaceId
+        every { mockDispatcher.getSurfaceId() } returns surfaceId
+
+        adapter = VideoEventListenerAdapter(
+            dispatcher = mockDispatcher,
+            viewIdProvider = { viewId }
+        )
+    }
+
+    afterTest {
+        clearAllMocks()
+        unmockkStatic(Arguments::class)
+    }
+
+    // ============================================================
+    // onLoadStart Tests
+    // ============================================================
+
+    test("onLoadStart should dispatch topVideoLoadStart event") {
+        adapter.onLoadStart(true, "mp4", "https://example.com/video.mp4")
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoLoadStartEvent> {
+                it.getEventName() == "topVideoLoadStart" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onLoad Tests
+    // ============================================================
+
+    test("onLoad should dispatch topVideoLoad event") {
+        val data = GraniteVideoLoadData(
+            currentTime = 0.0,
+            duration = 60.0,
+            naturalWidth = 1920.0,
+            naturalHeight = 1080.0,
+            orientation = "landscape"
+        )
+
+        adapter.onLoad(data)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoLoadEvent> {
+                it.getEventName() == "topVideoLoad" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onError Tests
+    // ============================================================
+
+    test("onError should dispatch topVideoError event") {
+        val error = GraniteVideoErrorData(
+            code = 1001,
+            domain = "ExoPlayer",
+            localizedDescription = "Test error",
+            errorString = "ERROR_TEST"
+        )
+
+        adapter.onError(error)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoErrorEvent> {
+                it.getEventName() == "topVideoError" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onProgress Tests
+    // ============================================================
+
+    test("onProgress should dispatch topVideoProgress event") {
+        val data = GraniteVideoProgressData(
+            currentTime = 10.0,
+            playableDuration = 20.0,
+            seekableDuration = 60.0
+        )
+
+        adapter.onProgress(data)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoProgressEvent> {
+                it.getEventName() == "topVideoProgress" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onSeek Tests
+    // ============================================================
+
+    test("onSeek should dispatch topVideoSeek event") {
+        adapter.onSeek(5.0, 10.0)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoSeekEvent> {
+                it.getEventName() == "topVideoSeek" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onEnd Tests
+    // ============================================================
+
+    test("onEnd should dispatch topVideoEnd event") {
+        adapter.onEnd()
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoEndEvent> {
+                it.getEventName() == "topVideoEnd" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onBuffer Tests
+    // ============================================================
+
+    test("onBuffer should dispatch topVideoBuffer event") {
+        adapter.onBuffer(true)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoBufferEvent> {
+                it.getEventName() == "topVideoBuffer" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onBandwidthUpdate Tests
+    // ============================================================
+
+    test("onBandwidthUpdate should dispatch topVideoBandwidthUpdate event") {
+        adapter.onBandwidthUpdate(5000000.0, 1920, 1080)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoBandwidthUpdateEvent> {
+                it.getEventName() == "topVideoBandwidthUpdate" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onPlaybackStateChanged Tests
+    // ============================================================
+
+    test("onPlaybackStateChanged should dispatch topVideoPlaybackStateChanged event") {
+        adapter.onPlaybackStateChanged(true, false, false)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoPlaybackStateChangedEvent> {
+                it.getEventName() == "topVideoPlaybackStateChanged" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onPlaybackRateChange Tests
+    // ============================================================
+
+    test("onPlaybackRateChange should dispatch topVideoPlaybackRateChange event") {
+        adapter.onPlaybackRateChange(1.5f)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoPlaybackRateChangeEvent> {
+                it.getEventName() == "topVideoPlaybackRateChange" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onVolumeChange Tests
+    // ============================================================
+
+    test("onVolumeChange should dispatch topVideoVolumeChange event") {
+        adapter.onVolumeChange(0.5f)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoVolumeChangeEvent> {
+                it.getEventName() == "topVideoVolumeChange" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onIdle Tests
+    // ============================================================
+
+    test("onIdle should dispatch topVideoIdle event") {
+        adapter.onIdle()
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoIdleEvent> {
+                it.getEventName() == "topVideoIdle" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // onReadyForDisplay Tests
+    // ============================================================
+
+    test("onReadyForDisplay should dispatch topVideoReadyForDisplay event") {
+        adapter.onReadyForDisplay()
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoReadyForDisplayEvent> {
+                it.getEventName() == "topVideoReadyForDisplay" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // Fullscreen Events Tests
+    // ============================================================
+
+    test("onFullscreenPlayerWillPresent should dispatch topVideoFullscreenPlayerWillPresent event") {
+        adapter.onFullscreenPlayerWillPresent()
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoFullscreenPlayerWillPresentEvent> {
+                it.getEventName() == "topVideoFullscreenPlayerWillPresent" && it.viewTag == viewId
+            })
+        }
+    }
+
+    test("onFullscreenPlayerDidPresent should dispatch topVideoFullscreenPlayerDidPresent event") {
+        adapter.onFullscreenPlayerDidPresent()
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoFullscreenPlayerDidPresentEvent> {
+                it.getEventName() == "topVideoFullscreenPlayerDidPresent" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // PiP Tests
+    // ============================================================
+
+    test("onPictureInPictureStatusChanged should dispatch topVideoPictureInPictureStatusChanged event") {
+        adapter.onPictureInPictureStatusChanged(true)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoPictureInPictureStatusChangedEvent> {
+                it.getEventName() == "topVideoPictureInPictureStatusChanged" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // Aspect Ratio Tests
+    // ============================================================
+
+    test("onAspectRatioChanged should dispatch topVideoAspectRatio event") {
+        adapter.onAspectRatioChanged(16.0, 9.0)
+
+        verify {
+            mockDispatcher.dispatchEvent(match<GraniteVideoAspectRatioEvent> {
+                it.getEventName() == "topVideoAspectRatio" && it.viewTag == viewId
+            })
+        }
+    }
+
+    // ============================================================
+    // Dynamic viewId Tests
+    // ============================================================
+
+    test("viewId changes dynamically should use updated viewId for each dispatch") {
+        var currentViewId = 100
+
+        val dynamicAdapter = VideoEventListenerAdapter(
+            dispatcher = mockDispatcher,
+            viewIdProvider = { currentViewId }
+        )
+
+        dynamicAdapter.onEnd()
+        currentViewId = 200
+        dynamicAdapter.onEnd()
+
+        verifyOrder {
+            mockDispatcher.dispatchEvent(match<GraniteVideoEndEvent> { it.viewTag == 100 })
+            mockDispatcher.dispatchEvent(match<GraniteVideoEndEvent> { it.viewTag == 200 })
+        }
+    }
+})

package/android/src/test/java/run/granite/video/helpers/FakeGraniteVideoProvider.kt

@@ -0,0 +1,161 @@
+package run.granite.video.helpers
+
+import android.content.Context
+import android.view.View
+import io.mockk.mockk
+import run.granite.video.provider.*
+
+class FakeGraniteVideoProvider(
+    override val providerId: String = "fake",
+    override val providerName: String = "Fake Provider"
+) : GraniteVideoProvider {
+
+    override var delegate: GraniteVideoDelegate? = null
+
+    var playCount = 0
+        private set
+    var pauseCount = 0
+        private set
+    var seekCount = 0
+        private set
+    var lastLoadedSource: GraniteVideoSource? = null
+        private set
+    var lastSeekTime: Double = 0.0
+        private set
+
+    private var _isPlaying = false
+    private var _currentTime = 0.0
+    private var _duration = 0.0
+    private var _volume = 1.0f
+    private var _muted = false
+    private var _rate = 1.0f
+    private var _repeat = false
+
+    override val currentTime: Double get() = _currentTime
+    override val duration: Double get() = _duration
+    override val isPlaying: Boolean get() = _isPlaying
+
+    override fun createPlayerView(context: Context): View = mockk(relaxed = true)
+
+    override fun loadSource(source: GraniteVideoSource) {
+        lastLoadedSource = source
+        _duration = 0.0
+        _currentTime = source.startPosition
+        delegate?.onLoadStart(
+            isNetwork = source.uri?.startsWith("http") == true,
+            type = source.type ?: "unknown",
+            uri = source.uri ?: ""
+        )
+    }
+
+    override fun unload() {
+        _isPlaying = false
+        _currentTime = 0.0
+        _duration = 0.0
+        lastLoadedSource = null
+    }
+
+    override fun play() {
+        playCount++
+        _isPlaying = true
+        delegate?.onPlaybackStateChanged(isPlaying = true, isSeeking = false, isLooping = _repeat)
+    }
+
+    override fun pause() {
+        pauseCount++
+        _isPlaying = false
+        delegate?.onPlaybackStateChanged(isPlaying = false, isSeeking = false, isLooping = _repeat)
+    }
+
+    override fun seek(time: Double, tolerance: Double) {
+        seekCount++
+        lastSeekTime = time
+        val previousTime = _currentTime
+        _currentTime = time
+        delegate?.onSeek(currentTime = previousTime, seekTime = time)
+    }
+
+    override fun setVolume(volume: Float) {
+        _volume = volume
+        delegate?.onVolumeChange(volume)
+    }
+
+    override fun setMuted(muted: Boolean) {
+        _muted = muted
+        delegate?.onVolumeChange(if (muted) 0f else _volume)
+    }
+
+    override fun setRate(rate: Float) {
+        _rate = rate
+        delegate?.onPlaybackRateChange(rate)
+    }
+
+    override fun setRepeat(shouldRepeat: Boolean) {
+        _repeat = shouldRepeat
+    }
+
+    // Test helpers
+    fun simulateLoad(duration: Double, width: Double = 1920.0, height: Double = 1080.0) {
+        _duration = duration
+        delegate?.onLoad(
+            GraniteVideoLoadData(
+                currentTime = _currentTime,
+                duration = duration,
+                naturalWidth = width,
+                naturalHeight = height,
+                orientation = if (width > height) "landscape" else "portrait"
+            )
+        )
+    }
+
+    fun simulateProgress(currentTime: Double) {
+        _currentTime = currentTime
+        delegate?.onProgress(
+            GraniteVideoProgressData(
+                currentTime = currentTime,
+                playableDuration = _duration,
+                seekableDuration = _duration
+            )
+        )
+    }
+
+    fun simulateEnd() {
+        _isPlaying = false
+        delegate?.onEnd()
+    }
+
+    fun simulateError(code: Int, message: String) {
+        delegate?.onError(
+            GraniteVideoErrorData(
+                code = code,
+                domain = "Fake",
+                localizedDescription = message,
+                errorString = message
+            )
+        )
+    }
+
+    fun simulateBuffer(isBuffering: Boolean) {
+        delegate?.onBuffer(isBuffering)
+    }
+
+    override fun release() {
+        reset()
+    }
+
+    fun reset() {
+        playCount = 0
+        pauseCount = 0
+        seekCount = 0
+        lastLoadedSource = null
+        lastSeekTime = 0.0
+        _isPlaying = false
+        _currentTime = 0.0
+        _duration = 0.0
+        _volume = 1.0f
+        _muted = false
+        _rate = 1.0f
+        _repeat = false
+        delegate = null
+    }
+}

package/android/src/test/java/run/granite/video/helpers/TestProgressScheduler.kt

@@ -0,0 +1,42 @@
+package run.granite.video.helpers
+
+import run.granite.video.provider.media3.scheduler.ProgressScheduler
+
+class TestProgressScheduler : ProgressScheduler {
+    private var action: (() -> Unit)? = null
+    private var _intervalMs: Long = 0
+
+    var scheduledCount = 0
+        private set
+    var cancelCount = 0
+        private set
+
+    val intervalMs: Long get() = _intervalMs
+    val isScheduled: Boolean get() = action != null
+
+    override fun schedule(intervalMs: Long, action: () -> Unit) {
+        this.action = action
+        this._intervalMs = intervalMs
+        scheduledCount++
+    }
+
+    override fun cancel() {
+        action = null
+        cancelCount++
+    }
+
+    fun tick() {
+        action?.invoke()
+    }
+
+    fun tick(times: Int) {
+        repeat(times) { tick() }
+    }
+
+    fun reset() {
+        action = null
+        _intervalMs = 0
+        scheduledCount = 0
+        cancelCount = 0
+    }
+}