iktdev/MediaProcessing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Wip 3 - Added one missing TaskStore + Testing Expiry

Browse Source
This commit is contained in:
Brage Skjønborg 2026-01-02 01:48:57 +01:00
parent 2400cf0580
commit f85fbde89d
4 changed files with 238 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
apps/coordinator/src/main/kotlin/no/iktdev/mediaprocessing/coordinator/listeners/events/MediaCreateMetadataSearchTaskListener.kt
View File

@ -9,6 +9,7 @@ import no.iktdev.mediaprocessing.shared.common.event_task_contract.events.Metada
import no.iktdev.mediaprocessing.shared.common.event_task_contract.events.MetadataSearchTaskCreatedEvent
import no.iktdev.mediaprocessing.shared.common.event_task_contract.tasks.MetadataSearchTask
import no.iktdev.mediaprocessing.shared.common.stores.TaskStore
import org.jetbrains.annotations.VisibleForTesting
import org.springframework.stereotype.Component
import java.util.*
import java.util.concurrent.ConcurrentHashMap
@ -20,7 +21,8 @@ import java.util.concurrent.TimeUnit
@ListenerOrder(5)
class MediaCreateMetadataSearchTaskListener: EventListener() {
private val scheduledExpiries = ConcurrentHashMap<UUID, ScheduledFuture<*>>()
@VisibleForTesting
internal val scheduledExpiries = ConcurrentHashMap<UUID, ScheduledFuture<*>>()
private val scheduler = Executors.newScheduledThreadPool(1)
override fun onEvent(
@ -50,6 +52,7 @@ class MediaCreateMetadataSearchTaskListener: EventListener() {
collection = useEvent.data.parsedCollection
)
).derivedOf(useEvent)
TaskStore.persist(task)
val finalResult = MetadataSearchTaskCreatedEvent(task.taskId).derivedOf(useEvent)
scheduleTaskExpiry(task.taskId, finalResult.eventId, task.referenceId)
return finalResult

6
apps/coordinator/src/test/kotlin/no/iktdev/mediaprocessing/MockData.kt
View File

@ -22,7 +22,7 @@ object MockData {
)
)
fun metadataEvent(derivedFrom: Event): List<Event> {
fun metadataEvent(derivedFrom: Event, source: String = "potetland", coverUrl: String = "cover.jpg"): List<Event> {
val dummyTask = DummyTask().derivedOf(derivedFrom)
val create = MetadataSearchTaskCreatedEvent(dummyTask.taskId).derivedOf(derivedFrom)
@ -34,9 +34,9 @@ object MockData {
advancedScore = 10,
sourceWeight = 1f,
data = MetadataSearchResultEvent.SearchResult.MetadataResult(
source = "test",
source = source,
title = "MyCollection",
cover = "cover.jpg",
cover = coverUrl,
type = MediaType.Movie,
summary = listOf(
MetadataSearchResultEvent.SearchResult.MetadataResult.Summary(

35
apps/coordinator/src/test/kotlin/no/iktdev/mediaprocessing/coordinator/listeners/events/MediaCreateCoverDownloadTaskListenerTest.kt
View File

@ -1,5 +1,38 @@
package no.iktdev.mediaprocessing.coordinator.listeners.events
class MediaCreateCoverDownloadTaskListenerTest {
import io.mockk.slot
import io.mockk.verify
import no.iktdev.mediaprocessing.MockData.metadataEvent
import no.iktdev.mediaprocessing.TestBase
import no.iktdev.mediaprocessing.shared.common.event_task_contract.events.CoverDownloadTaskCreatedEvent
import no.iktdev.mediaprocessing.shared.common.event_task_contract.tasks.CoverDownloadTask
import no.iktdev.mediaprocessing.shared.common.stores.TaskStore
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
class MediaCreateCoverDownloadTaskListenerTest: TestBase() {
val listener = MediaCreateCoverDownloadTaskListener()
@Test
fun success1() {
val started = defaultStartEvent()
val metadata = metadataEvent(started, coverUrl = "http://example.com/fancy.jpg")
val history = listOf(started, *metadata.toTypedArray())
val result = listener.onEvent(metadata.last(), history)
assertThat(result is CoverDownloadTaskCreatedEvent)
val slot = slot<CoverDownloadTask>()
verify(exactly = 1) {
TaskStore.persist(capture(slot))
}
val storeTask = slot.captured
assertThat(storeTask.data.url).isEqualTo("http://example.com/fancy.jpg")
assertThat(storeTask.data.outputFileName).isEqualTo("MyCollection-potetland")
}
}

198
apps/coordinator/src/test/kotlin/no/iktdev/mediaprocessing/coordinator/listeners/events/MediaCreateMetadataSearchTaskListenerTest.kt
View File

@ -1,5 +1,201 @@
package no.iktdev.mediaprocessing.coordinator.listeners.events
class MediaCreateMetadataSearchTaskListenerTest {
import io.mockk.slot
import io.mockk.verify
import no.iktdev.eventi.models.Event
import no.iktdev.eventi.models.store.TaskStatus
import no.iktdev.mediaprocessing.MockData.mediaParsedEvent
import no.iktdev.mediaprocessing.TestBase
import no.iktdev.mediaprocessing.shared.common.event_task_contract.events.MetadataSearchResultEvent
import no.iktdev.mediaprocessing.shared.common.event_task_contract.events.MetadataSearchTaskCreatedEvent
import no.iktdev.mediaprocessing.shared.common.event_task_contract.tasks.MetadataSearchTask
import no.iktdev.mediaprocessing.shared.common.model.MediaType
import no.iktdev.mediaprocessing.shared.common.stores.TaskStore
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
class MediaCreateMetadataSearchTaskListenerTest : TestBase() {
val listener = MediaCreateMetadataSearchTaskListener()
@Test
fun success1() {
val started = defaultStartEvent()
val parsedInfo = mediaParsedEvent("Baking Bread", "Baking Bread - S01E01 - Flour", MediaType.Serie)
.derivedOf(started)
val history = listOf(started, parsedInfo)
val result = listener.onEvent(parsedInfo, history)
assertThat(result is MetadataSearchTaskCreatedEvent)
val slot = slot<MetadataSearchTask>()
verify(exactly = 1) {
TaskStore.persist(capture(slot))
}
val storeTask = slot.captured
assertThat(storeTask.data.collection).isEqualTo("Baking Bread")
assertThat(storeTask.data.searchTitles).hasSize(2)
assertThat(storeTask.data.searchTitles).isEqualTo(
listOf(
"Baking Bread",
"Baking Bread - S01E01 - Flour"
)
)
}
@DisplayName(
"""
Hvis event ikke er MediaParsedInfoEvent
Når onEvent kalles
Så:
Returneres null
"""
)
@Test
fun ignored1() {
// Hvis
val listener = MediaCreateMetadataSearchTaskListener()
val event = MetadataSearchResultEvent(
status = TaskStatus.Completed
)
val history = emptyList<Event>()
// Når
val result = listener.onEvent(event, history)
// Så
assertThat(result).isNull()
verify(exactly = 0) { TaskStore.persist(any()) }
}
@DisplayName(
"""
Hvis event ikke er MediaParsedInfoEvent
Når onEvent kalles
Så:
Returneres null
"""
)
@Test
fun `hvis event ikke er MediaParsedInfoEvent saa returneres null`() {
// Hvis
val listener = MediaCreateMetadataSearchTaskListener()
val event = MetadataSearchResultEvent(status = TaskStatus.Completed)
val history = emptyList<Event>()
// Når
val result = listener.onEvent(event, history)
// Så
verify(exactly = 0) { TaskStore.persist(any()) }
assertThat(result).isNull()
}
@DisplayName(
"""
Hvis MediaParsedInfoEvent mottas
Når onEvent kalles
Så:
Opprettes MetadataSearchTask
Og timeout planlegges
"""
)
@Test
fun `hvis parsed event saa opprettes task og timeout planlegges`() {
// Hvis
val listener = MediaCreateMetadataSearchTaskListener()
val started = defaultStartEvent()
val parsed = mediaParsedEvent(
"Baking Bread",
"Baking Bread - S01E01 - Flour",
MediaType.Serie
).derivedOf(started)
val history = listOf(started, parsed)
// Når
val result = listener.onEvent(parsed, history)
// Så
assertThat(result).isInstanceOf(MetadataSearchTaskCreatedEvent::class.java)
val slot = slot<MetadataSearchTask>()
verify(exactly = 1) { TaskStore.persist(capture(slot)) }
val taskId = slot.captured.taskId
assertThat(listener.scheduledExpiries).containsKey(taskId)
}
@DisplayName("""
Hvis MetadataSearchTaskCreatedEvent re-spilles
Og historikken inneholder MetadataSearchResultEvent for samme task
Når onEvent kalles
Så:
Skal timeout ikke planlegges
""")
@Test
fun `hvis replay og result finnes saa planlegges ikke timeout`() {
// Hvis
val listener = MediaCreateMetadataSearchTaskListener()
val started = defaultStartEvent()
val parsed = mediaParsedEvent(
"Baking Bread",
"Baking Bread - S01E01 - Flour",
MediaType.Serie
).apply { derivedOf(started) }
val task = MetadataSearchTask(
MetadataSearchTask.SearchData(
searchTitles = parsed.data.parsedSearchTitles,
collection = parsed.data.parsedCollection
)
).derivedOf(parsed)
val created = MetadataSearchTaskCreatedEvent(task.taskId).derivedOf(parsed)
val resultEvent = MetadataSearchResultEvent(
status = TaskStatus.Completed,
results = emptyList()
).producedFrom(task)
val history = listOf(started, parsed, created, resultEvent)
// Når
listener.onEvent(created, history)
// Så
assertThat(listener.scheduledExpiries).doesNotContainKey(task.taskId)
}
@DisplayName("""
Hvis flere MediaParsedInfoEvent mottas
Når onEvent kalles for hver
Så:
Opprettes én MetadataSearchTask per event
""")
@Test
fun `hvis flere parsed events saa opprettes en task per event`() {
// Hvis
val listener = MediaCreateMetadataSearchTaskListener()
val started = defaultStartEvent()
val parsed1 = mediaParsedEvent("A", "A - E01", MediaType.Serie).derivedOf(started)
val parsed2 = mediaParsedEvent("B", "B - E01", MediaType.Serie).derivedOf(started)
// Når
listener.onEvent(parsed1, listOf(started, parsed1))
listener.onEvent(parsed2, listOf(started, parsed2))
// Så
verify(exactly = 2) { TaskStore.persist(any<MetadataSearchTask>()) }
}
}