.github/workflows/test.yml

@@ -1,29 +0,0 @@
-name: Run Unit Tests
-
-on:
-  push:
-    branches:
-      - "**"
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          java-version: '21'
-          distribution: 'zulu'
-
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v3
-
-      - name: Make gradlew executable
-        run: chmod +x ./gradlew
-
-      - name: Run unit tests
-        run: ./gradlew test --stacktrace

src/main/kotlin/no/iktdev/eventi/events/EventDispatcher.kt

@@ -2,7 +2,6 @@ package no.iktdev.eventi.events
 
 import no.iktdev.eventi.models.DeleteEvent
 import no.iktdev.eventi.models.Event
-import no.iktdev.eventi.models.SignalEvent
 import no.iktdev.eventi.stores.EventStore
 import java.util.UUID
 
@@ -12,7 +11,6 @@ open class EventDispatcher(val eventStore: EventStore) {
         val derivedFromIds = events.mapNotNull { it.metadata.derivedFromId }.flatten().toSet()
         val deletedEventIds = events.filterIsInstance<DeleteEvent>().map { it.deletedEventId }
         val candidates = events
-            .filterNot { it is SignalEvent }
             .filter { it.eventId !in derivedFromIds }
             .filter { it.eventId !in deletedEventIds }
 

src/main/kotlin/no/iktdev/eventi/events/EventPollerImplementation.kt

@@ -8,30 +8,23 @@ import no.iktdev.eventi.stores.EventStore
 import java.time.Duration
 import java.time.Instant
 import java.util.UUID
+import kotlin.collections.iterator
 
 abstract class EventPollerImplementation(
     private val eventStore: EventStore,
     private val dispatchQueue: SequenceDispatchQueue,
     private val dispatcher: EventDispatcher
 ) {
-    private val log = KotlinLogging.logger {}
+    // Erstatter ikke lastSeenTime, men supplerer den
+    protected val refWatermark = mutableMapOf<UUID, Instant>()
 
-    /**
+    // lastSeenTime brukes kun som scan hint
-     * Per-reference watermark:
-     *  - first = last seen persistedAt
-     *  - second = last seen persistedId
-     */
-    protected val refWatermark = mutableMapOf<UUID, Pair<Instant, Long>>()
-
-    /**
-     * Global scan hint (timestamp only).
-     * Used to avoid scanning entire table every time.
-     */
     var lastSeenTime: Instant = Instant.EPOCH
 
     open var backoff = Duration.ofSeconds(2)
         protected set
     private val maxBackoff = Duration.ofMinutes(1)
+    private val log = KotlinLogging.logger {}
 
     open suspend fun start() {
         log.info { "EventPoller starting with initial backoff=$backoff" }
@@ -39,7 +32,7 @@ abstract class EventPollerImplementation(
             try {
                 pollOnce()
             } catch (e: Exception) {
-                log.error(e) { "Error in poller loop" }
+                e.printStackTrace()
                 delay(backoff.toMillis())
                 backoff = backoff.multipliedBy(2).coerceAtMost(maxBackoff)
             }
@@ -50,11 +43,11 @@ abstract class EventPollerImplementation(
         val pollStartedAt = MyTime.utcNow()
         log.debug { "🔍 Polling for new events" }
 
-        // Determine global scan start
+        // Global scan hint: kombiner refWatermark og lastSeenTime
-        val minRefTs = refWatermark.values.minOfOrNull { it.first }
+        val watermarkMin = refWatermark.values.minOrNull()
-        val scanFrom = when (minRefTs) {
+        val scanFrom = when (watermarkMin) {
             null -> lastSeenTime
-            else -> maxOf(lastSeenTime, minRefTs)
+            else -> maxOf(lastSeenTime, watermarkMin)
         }
 
         val newPersisted = eventStore.getPersistedEventsAfter(scanFrom)
@@ -66,73 +59,76 @@ abstract class EventPollerImplementation(
             return
         }
 
-        // Reset backoff
+        // Vi har sett nye events globalt – reset backoff
         backoff = Duration.ofSeconds(2)
         log.debug { "📬 Found ${newPersisted.size} new events after $scanFrom" }
 
         val grouped = newPersisted.groupBy { it.referenceId }
         var anyProcessed = false
 
-        // Track highest persistedAt seen globally this round
+        // Track høyeste persistedAt vi har sett i denne runden
         val maxPersistedThisRound = newPersisted.maxOf { it.persistedAt }
 
         for ((ref, eventsForRef) in grouped) {
-            val (refSeenAt, refSeenId) = refWatermark[ref] ?: (Instant.EPOCH to 0L)
+            val refSeen = refWatermark[ref] ?: Instant.EPOCH
-
-            // Filter new events using (timestamp, id) ordering
-            val newForRef = eventsForRef.filter { ev ->
-                ev.persistedAt > refSeenAt ||
-                        (ev.persistedAt == refSeenAt && ev.id > refSeenId)
-            }
 
+            // Finn kun nye events for denne ref’en
+            val newForRef = eventsForRef.filter { it.persistedAt > refSeen }
             if (newForRef.isEmpty()) {
-                log.debug { "🧊 No new events for $ref since ($refSeenAt, id=$refSeenId)" }
+                log.debug { "🧊 No new events for $ref since $refSeen" }
                 continue
             }
 
-            // If ref is busy, skip dispatch
+            // Hvis ref er busy → ikke oppdater watermark, ikke dispatch
             if (dispatchQueue.isProcessing(ref)) {
                 log.debug { "⏳ $ref is busy — deferring ${newForRef.size} events" }
                 continue
             }
 
-            // Fetch full sequence for dispatch
+            // Hent full sekvens for ref (Eventi-invariant)
             val fullLog = eventStore.getPersistedEventsFor(ref)
             val events = fullLog.mapNotNull { it.toEvent() }
 
             log.debug { "🚀 Dispatching ${events.size} events for $ref" }
             dispatchQueue.dispatch(ref, events, dispatcher)
 
-            // Update watermark for this reference
+            // Oppdater watermark for denne ref’en
-            val maxEvent = newForRef.maxWith(
+            val maxPersistedAtForRef = newForRef.maxOf { it.persistedAt }
-                compareBy({ it.persistedAt }, { it.id })
+            val newWatermark = minOf(pollStartedAt, maxPersistedAtForRef).plusNanos(1)
-            )
 
-            val newWatermarkAt = minOf(pollStartedAt, maxEvent.persistedAt)
+            refWatermark[ref] = newWatermark
-            val newWatermarkId = maxEvent.id
-
-            refWatermark[ref] = newWatermarkAt to newWatermarkId
             anyProcessed = true
 
-            log.debug { "⏩ Updated watermark for $ref → ($newWatermarkAt, id=$newWatermarkId)" }
+            log.debug { "⏩ Updated watermark for $ref → $newWatermark" }
         }
 
-        // Update global scan hint
+        // Oppdater global scan hint uansett – vi har sett nye events
+        // Dette hindrer livelock når alle events er <= watermark for sine refs
         val newLastSeen = maxOf(
             lastSeenTime,
             maxPersistedThisRound.plusNanos(1)
         )
 
         if (anyProcessed) {
-            val minRef = refWatermark.values.minOfOrNull { it.first }
+            // Behold intensjonen din: globalt hint basert på laveste watermark,
-            lastSeenTime = when (minRef) {
+            // men aldri gå bakover i tid ift lastSeenTime
+            val minRefWatermark = refWatermark.values.minOrNull()
+            lastSeenTime = when (minRefWatermark) {
                 null -> newLastSeen
-                else -> maxOf(newLastSeen, minRef)
+                else -> maxOf(newLastSeen, minRefWatermark)
             }
             log.debug { "📉 Global scanFrom updated → $lastSeenTime (anyProcessed=true)" }
         } else {
+            // Ingen refs prosessert, men vi vet at alle events vi så er <= watermark
+            // → trygt å flytte lastSeenTime forbi dem
             lastSeenTime = newLastSeen
             log.debug { "🔁 No refs processed — advancing global scanFrom to $lastSeenTime" }
         }
     }
+
+
+
+
+
+
 }

src/main/kotlin/no/iktdev/eventi/models/Event.kt

@@ -4,7 +4,7 @@ import java.util.UUID
 
 @Suppress("UNCHECKED_CAST")
 abstract class Event {
-    lateinit var referenceId: UUID
+    var referenceId: UUID = UUID.randomUUID()
         protected set
     var eventId: UUID = UUID.randomUUID()
         private set
@@ -43,6 +43,6 @@ abstract class DeleteEvent(
     open val deletedEventId: UUID
 ) : Event()
 
-abstract class SignalEvent(): Event()
+
 
 

src/main/kotlin/no/iktdev/eventi/tasks/TaskListener.kt

@@ -9,7 +9,6 @@ import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import no.iktdev.eventi.models.Event
 import no.iktdev.eventi.models.Task
-import no.iktdev.eventi.models.store.TaskStatus
 import org.jetbrains.annotations.VisibleForTesting
 import java.util.UUID
 import kotlin.coroutines.cancellation.CancellationException
@@ -68,7 +67,9 @@ abstract class TaskListener(val taskType: TaskType = TaskType.CPU_INTENSIVE): Ta
         currentJob = getDispatcherForTask(task).launch {
             try {
                 val result = onTask(task)
+                reporter.markCompleted(task.taskId)
                 onComplete(task, result)
+
             } catch (e: CancellationException) {
                 // Dette er en ekte kansellering
                 onCancelled(task)
@@ -87,16 +88,14 @@ abstract class TaskListener(val taskType: TaskType = TaskType.CPU_INTENSIVE): Ta
                 this@TaskListener.reporter = null
             }
         }
+
         return true
     }
 
-    abstract fun createIncompleteStateTaskEvent(task: Task, status: TaskStatus, exception: Exception? = null): Event
-
     override fun onError(task: Task, exception: Exception) {
         reporter?.log(task.taskId, "Error processing task: ${exception.message}")
         exception.printStackTrace()
         reporter?.markFailed(task.referenceId, task.taskId)
-        reporter!!.publishEvent(createIncompleteStateTaskEvent(task, TaskStatus.Failed, exception))
     }
 
     override fun onComplete(task: Task, result: Event?) {
@@ -112,7 +111,6 @@ abstract class TaskListener(val taskType: TaskType = TaskType.CPU_INTENSIVE): Ta
         currentJob?.cancel()
         heartbeatRunner?.cancel()
         currentTask = null
-        reporter!!.publishEvent(createIncompleteStateTaskEvent(task, TaskStatus.Cancelled))
     }
 }
 

src/test/kotlin/no/iktdev/eventi/EventDispatcherTest.kt

@@ -8,7 +8,6 @@ import no.iktdev.eventi.events.EventListenerRegistry
 import no.iktdev.eventi.events.EventTypeRegistry
 import no.iktdev.eventi.models.DeleteEvent
 import no.iktdev.eventi.models.Event
-import no.iktdev.eventi.models.SignalEvent
 import no.iktdev.eventi.testUtil.wipe
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Assertions.assertEquals
@@ -20,14 +19,12 @@ import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import java.util.UUID
 
-@DisplayName(
+@DisplayName("""
-    """
 EventDispatcher
 Når hendelser dispatches til lyttere
 Hvis hendelsene inneholder avledede, slettede eller nye events
 Så skal dispatcheren håndtere filtrering, replays og historikk korrekt
-"""
+""")
-)
 class EventDispatcherTest : TestBase() {
 
     val dispatcher = EventDispatcher(eventStore)
@@ -54,17 +51,15 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en TriggerEvent dispatches
     Hvis en lytter produserer én DerivedEvent
     Så skal kun én ny event produseres og prosessen stoppe
-    """
+    """)
-    )
     fun shouldProduceOneEventAndStop() {
         ProducingListener()
 
-        val trigger = TriggerEvent().newReferenceId()
+        val trigger = TriggerEvent()
         dispatcher.dispatch(trigger.referenceId, listOf(trigger))
 
         val produced = eventStore.all().firstOrNull()
@@ -77,17 +72,15 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en event allerede har avledet en DerivedEvent
     Hvis dispatcheren replays historikken
     Så skal ikke DerivedEvent produseres på nytt
-    """
+    """)
-    )
     fun shouldSkipAlreadyDerivedEvents() {
         ProducingListener()
 
-        val trigger = TriggerEvent().newReferenceId()
+        val trigger = TriggerEvent()
         val derived = DerivedEvent().derivedOf(trigger).toPersisted(1L, MyTime.utcNow())
 
         eventStore.persist(derived!!.toEvent()!!) // simulate prior production
@@ -98,37 +91,31 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når flere events dispatches
     Hvis en lytter mottar en event
     Så skal hele historikken leveres i context
-    """
+    """)
-    )
     fun shouldPassFullContextToListener() {
         val listener = ContextCapturingListener()
 
-        val e1 = TriggerEvent().newReferenceId()
+        val e1 = TriggerEvent()
-        val e2 = OtherEvent().newReferenceId()
+        val e2 = OtherEvent()
         dispatcher.dispatch(e1.referenceId, listOf(e1, e2))
 
         assertEquals(2, listener.context.size)
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en replay skjer
     Hvis en event allerede har produsert en DerivedEvent
     Så skal ikke DerivedEvent produseres på nytt
-    """
+    """)
-    )
     fun shouldBehaveDeterministicallyAcrossReplays() {
-        val referenceId = UUID.randomUUID()
-
         ProducingListener()
 
-        val trigger = TriggerEvent().usingReferenceId(referenceId)
+        val trigger = TriggerEvent()
         dispatcher.dispatch(trigger.referenceId, listOf(trigger))
         val replayContext = listOf(trigger) + eventStore.all().mapNotNull { it.toEvent() }
 
@@ -138,16 +125,12 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en DeleteEvent peker på en tidligere event
     Hvis dispatcheren filtrerer kandidater
     Så skal slettede events ikke leveres som kandidater
-    """
+    """)
-    )
     fun shouldNotDeliverDeletedEventsAsCandidates() {
-        val referenceId = UUID.randomUUID()
-
         val dispatcher = EventDispatcher(eventStore)
         val received = mutableListOf<Event>()
 
@@ -158,10 +141,11 @@ class EventDispatcherTest : TestBase() {
             }
         }
         // Original hendelse
-        val original = TriggerEvent().usingReferenceId(referenceId)
+        val original = TriggerEvent()
 
         // Slettehendelse som peker på original
-        val deleted = object : DeleteEvent(original.eventId) {}.apply { newReferenceId() }
+        val deleted = object : DeleteEvent(original.eventId) {
+        }
 
         // Dispatch med begge hendelser
         dispatcher.dispatch(original.referenceId, listOf(original, deleted))
@@ -178,17 +162,13 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en DeleteEvent dispatches alene
     Hvis en lytter reagerer på DeleteEvent
     Så skal DeleteEvent leveres som kandidat
-    """
+    """)
-    )
     fun shouldDeliverDeleteEventToListenersThatReactToIt() {
         val received = mutableListOf<Event>()
-        val referenceId = UUID.randomUUID()
-
         object : EventListener() {
             override fun onEvent(event: Event, history: List<Event>): Event? {
                 if (event is DeleteEvent) received += event
@@ -196,24 +176,22 @@ class EventDispatcherTest : TestBase() {
             }
         }
 
-        val deleted = object : DeleteEvent(UUID.randomUUID()) {}.apply { usingReferenceId(referenceId) }
+        val deleted = object : DeleteEvent(UUID.randomUUID()) {}
         dispatcher.dispatch(deleted.referenceId, listOf(deleted))
 
         assertTrue(received.contains(deleted))
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en event har avledet en ny event
     Hvis dispatcheren replays historikken
     Så skal ikke original-eventen leveres som kandidat igjen
-    """
+    """)
-    )
     fun shouldNotRedeliverEventsThatHaveProducedDerivedEvents() {
         ProducingListener()
 
-        val trigger = TriggerEvent().newReferenceId()
+        val trigger = TriggerEvent()
         // Første dispatch: trigger produserer en DerivedEvent
         dispatcher.dispatch(trigger.referenceId, listOf(trigger))
 
@@ -233,18 +211,16 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en DeleteEvent slettet en tidligere event
     Hvis dispatcheren bygger historikk
     Så skal slettede events ikke være med i history
-    """
+    """)
-    )
     fun historyShouldExcludeDeletedEvents() {
         val dispatcher = EventDispatcher(eventStore)
 
-        val original = TriggerEvent().newReferenceId()
+        val original = TriggerEvent()
-        val deleted = object : DeleteEvent(original.eventId) {}.apply { usingReferenceId(original.referenceId) }
+        val deleted = object : DeleteEvent(original.eventId) {}
 
         var receivedHistory: List<Event> = emptyList()
 
@@ -262,18 +238,16 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en DeleteEvent slettet en event
     Hvis andre events fortsatt er gyldige
     Så skal history kun inneholde de ikke-slettede events
-    """
+    """)
-    )
     fun historyShouldKeepNonDeletedEvents() {
         val dispatcher = EventDispatcher(eventStore)
-        val referenceId = UUID.randomUUID()
+
-        val e1 = TriggerEvent().usingReferenceId(referenceId)
+        val e1 = TriggerEvent()
-        val e2 = OtherEvent().usingReferenceId(referenceId)
+        val e2 = OtherEvent()
         val deleted = object : DeleteEvent(e1.eventId) {}
 
         var receivedHistory: List<Event> = emptyList()
@@ -293,18 +267,16 @@ class EventDispatcherTest : TestBase() {
     }
 
     @Test
-    @DisplayName(
+    @DisplayName("""
-        """
     Når en DeleteEvent er kandidat
     Hvis historikken kun inneholder slettede events
     Så skal history være tom
-    """
+    """)
-    )
     fun deleteEventShouldBeDeliveredButHistoryEmpty() {
         val dispatcher = EventDispatcher(eventStore)
 
-        val original = TriggerEvent().newReferenceId()
+        val original = TriggerEvent()
-        val deleted = object : DeleteEvent(original.eventId) {}.apply { newReferenceId() }
+        val deleted = object : DeleteEvent(original.eventId) {}
 
         var receivedEvent: Event? = null
         var receivedHistory: List<Event> = emptyList()
@@ -323,54 +295,6 @@ class EventDispatcherTest : TestBase() {
         assertTrue(receivedHistory.isEmpty())
     }
 
-    @Test
-    @DisplayName(
-    """
-    Når en SignalEvent dispatches
-    Hvis SignalEvent ikke skal være kandidat
-    Så skal den ikke leveres til lyttere, men fortsatt være i historikken
-    """
-    )
-    fun shouldNotDeliverSignalEventAsCandidate() {
-        // Arrange
-        class TestSignalEvent : SignalEvent()
-        EventTypeRegistry.register(listOf(TestSignalEvent::class.java,))
-
-        val received = mutableListOf<Event>()
-        var finalHistory: List<Event>? = null
-        object : EventListener() {
-            override fun onEvent(event: Event, history: List<Event>): Event? {
-                received += event
-                finalHistory = history
-                return null
-            }
-        }
-
-        val refId = UUID.randomUUID()
-        val trigger = TriggerEvent().usingReferenceId(refId)
-        val signal = TestSignalEvent().usingReferenceId(refId)
-
-        // Act
-        dispatcher.dispatch(trigger.referenceId, listOf(trigger, signal))
-
-        // Assert
-        // 1) TriggerEvent skal leveres
-        assertTrue(received.any { it is TriggerEvent }) {
-            "TriggerEvent skal leveres som kandidat"
-        }
-
-        // 2) SignalEvent skal IKKE leveres
-        assertFalse(received.any { it is TestSignalEvent }) {
-            "SignalEvent skal ikke leveres som kandidat"
-        }
-
-        assertNotNull(finalHistory)
-        assertTrue(finalHistory!!.any { it is TestSignalEvent }) {
-            "SignalEvent skal være i historikken selv om den ikke er kandidat"
-        }
-    }
-
-
     // --- Test helpers ---
 
     class ProducingListener : EventListener() {

src/test/kotlin/no/iktdev/eventi/ZDSTest.kt

@@ -39,7 +39,7 @@ class ZDSTest {
     fun scenario1() {
         EventTypeRegistry.register(EchoEvent::class.java)
 
-        val echo = EchoEvent("hello").newReferenceId()
+        val echo = EchoEvent("hello")
         val persisted = echo.toPersisted(id = 1L)
 
         val restored = persisted!!.toEvent()

src/test/kotlin/no/iktdev/eventi/events/EventPollerImplementationTest.kt

@@ -1,23 +1,19 @@
 package no.iktdev.eventi.events
 
 import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
-import kotlinx.coroutines.awaitAll
 import no.iktdev.eventi.EventDispatcherTest.DerivedEvent
 import no.iktdev.eventi.EventDispatcherTest.OtherEvent
 import no.iktdev.eventi.EventDispatcherTest.TriggerEvent
 import no.iktdev.eventi.MyTime
 import no.iktdev.eventi.TestBase
 import no.iktdev.eventi.models.Event
-import no.iktdev.eventi.testUtil.TestSequenceDispatchQueue
 import no.iktdev.eventi.testUtil.wipe
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertFalse
@@ -37,7 +33,9 @@ Så skal polleren dispatch'e riktig, oppdatere lastSeenTime og unngå duplikater
 """)
 class EventPollerImplementationTest : TestBase() {
 
-    private val dispatcher = EventDispatcher(eventStore)
+    val dispatcher = EventDispatcher(eventStore)
+    val queue = SequenceDispatchQueue(maxConcurrency = 8)
+    val poller = object : EventPollerImplementation(eventStore, queue, dispatcher) {}
 
     @BeforeEach
     fun setup() {
@@ -61,10 +59,6 @@ class EventPollerImplementationTest : TestBase() {
     Så skal alle referenceId-er dispatch'es og lastSeenTime oppdateres
     """)
     fun pollOnceDispatchesAllNewReferenceIdsAndUpdatesLastSeenTime() = runTest {
-        val testDispatcher = StandardTestDispatcher(testScheduler)
-        val queue = TestSequenceDispatchQueue(maxConcurrency = 8, dispatcher = testDispatcher)
-        val poller = object : EventPollerImplementation(eventStore, queue, dispatcher) {}
-
         val dispatched = ConcurrentHashMap.newKeySet<UUID>()
         val completionMap = mutableMapOf<UUID, CompletableDeferred<Unit>>()
 
@@ -99,9 +93,6 @@ class EventPollerImplementationTest : TestBase() {
     Så skal backoff øke, og resettes når nye events ankommer
     """)
     fun pollOnceIncreasesBackoffWhenNoEventsAndResetsWhenEventsArrive() = runTest {
-        val testDispatcher = StandardTestDispatcher(testScheduler)
-        val queue = TestSequenceDispatchQueue(maxConcurrency = 8, dispatcher = testDispatcher)
-
         val testPoller = object : EventPollerImplementation(eventStore, queue, dispatcher) {
             fun currentBackoff(): Duration = backoff
         }
@@ -130,10 +121,6 @@ class EventPollerImplementationTest : TestBase() {
     Så skal polleren gruppere og dispatch'e alle tre i én batch
     """)
     fun pollOnceGroupsAndDispatchesExactlyThreeEventsForOneReferenceId() = runTest {
-        val testDispatcher = StandardTestDispatcher(testScheduler)
-        val queue = TestSequenceDispatchQueue(maxConcurrency = 8, dispatcher = testDispatcher)
-        val poller = object : EventPollerImplementation(eventStore, queue, dispatcher) {}
-
         val refId = UUID.randomUUID()
         val received = mutableListOf<Event>()
         val done = CompletableDeferred<Unit>()
@@ -170,8 +157,8 @@ class EventPollerImplementationTest : TestBase() {
     Så skal polleren ignorere dem
     """)
     fun pollOnceIgnoresEventsBeforeLastSeenTime() = runTest {
-        val testDispatcher = StandardTestDispatcher(testScheduler)
+        val refId = UUID.randomUUID()
-        val queue = TestSequenceDispatchQueue(maxConcurrency = 8, dispatcher = testDispatcher)
+        val ignored = TriggerEvent().usingReferenceId(refId)
 
         val testPoller = object : EventPollerImplementation(eventStore, queue, dispatcher) {
             init {
@@ -179,9 +166,6 @@ class EventPollerImplementationTest : TestBase() {
             }
         }
 
-        val refId = UUID.randomUUID()
-        val ignored = TriggerEvent().usingReferenceId(refId)
-
         eventStore.persist(ignored)
         testPoller.pollOnce()
 
@@ -196,12 +180,7 @@ class EventPollerImplementationTest : TestBase() {
     Så skal begge events prosesseres, men uten å produsere duplikate derived events
     """)
     fun pollerHandlesManuallyInjectedDuplicateEvent() = runTest {
-        val testDispatcher = StandardTestDispatcher(testScheduler)
-        val queue = TestSequenceDispatchQueue(maxConcurrency = 8, dispatcher = testDispatcher)
-        val poller = object : EventPollerImplementation(eventStore, queue, dispatcher) {}
-
         EventTypeRegistry.register(listOf(MarcoEvent::class.java, EchoEvent::class.java))
-
         val channel = Channel<Event>(Channel.UNLIMITED)
         val handled = mutableListOf<Event>()
 
@@ -214,14 +193,16 @@ class EventPollerImplementationTest : TestBase() {
             }
         }
 
-        val original = EchoEvent("Hello").newReferenceId()
+        val poller = object : EventPollerImplementation(eventStore, queue, dispatcher) {}
+
+        val original = EchoEvent("Hello")
         eventStore.persist(original)
 
         poller.pollOnce()
 
-        withContext(testDispatcher) {
+        withContext(Dispatchers.Default.limitedParallelism(1)) {
-            withTimeout(60_000) {
+            withTimeout(Duration.ofMinutes(1).toMillis()) {
-                channel.receive()
+                repeat(1) { channel.receive() }
             }
         }
 
@@ -230,9 +211,9 @@ class EventPollerImplementationTest : TestBase() {
 
         poller.pollOnce()
 
-        withContext(testDispatcher) {
+        withContext(Dispatchers.Default.limitedParallelism(1)) {
-            withTimeout(60_000) {
+            withTimeout(Duration.ofMinutes(1).toMillis()) {
-                channel.receive()
+                repeat(1) { channel.receive() }
             }
         }
 

src/test/kotlin/no/iktdev/eventi/events/poller/PollerStartLoopTest.kt

@@ -60,42 +60,6 @@ class PollerStartLoopTest : TestBase() {
         store.persistAt(e, time)
     }
 
-
-    @Test
-    @DisplayName("""
-    Når to events har identisk persistedAt
-    Hvis polleren kjører
-    Så skal begge events prosesseres og ingen mistes
-    """)
-    fun `poller handles same-timestamp events without losing any`() = runTest {
-        val ref = UUID.randomUUID()
-        val ts = Instant.parse("2025-01-01T12:00:00Z")
-
-        // Two events with same timestamp but different IDs
-        val e1 = TestEvent().withReference(ref).setMetadata(Metadata())
-        val e2 = TestEvent().withReference(ref).setMetadata(Metadata())
-
-        store.persistAt(e1, ts) // id=1
-        store.persistAt(e2, ts) // id=2
-
-        poller.startFor(iterations = 1)
-
-        // Verify dispatch happened
-        assertThat(dispatcher.dispatched).hasSize(1)
-
-        val (_, events) = dispatcher.dispatched.single()
-
-        // Both events must be present
-        assertThat(events.map { it.eventId })
-            .hasSize(2)
-            .doesNotHaveDuplicates()
-
-        // Watermark must reflect highest ID
-        val wm = poller.watermarkFor(ref)
-        assertThat(wm!!.first).isEqualTo(ts)
-        assertThat(wm.second).isEqualTo(2)
-    }
-
     @Test
     @DisplayName("""
     Når polleren kjører flere iterasjoner uten events
@@ -307,15 +271,11 @@ class PollerStartLoopTest : TestBase() {
 
         poller.startFor(iterations = 1)
 
-
-
         // A skal IKKE ha flyttet watermark
         assertThat(poller.watermarkFor(refA)).isEqualTo(wmA1)
 
-        // B skal ha flyttet watermark (på timestamp-nivå)
+        // B skal ha flyttet watermark
-        val wmB2 = poller.watermarkFor(refB)
+        assertThat(poller.watermarkFor(refB)).isGreaterThan(wmB1)
-        assertThat(wmB2!!.first).isGreaterThan(wmB1!!.first)
-
     }
 
     @DisplayName("🍌 Bananastesten™ — stress-test av watermark, busy refs og dispatch-semantikk")
@@ -473,7 +433,7 @@ class PollerStartLoopTest : TestBase() {
 
         // Sett watermark høyt (polleren setter watermark selv i ekte drift,
         // men i denne testen må vi simulere det)
-        poller.setWatermarkFor(ref, t(100), id = 999)
+        poller.setWatermarkFor(ref, t(100))
 
         // Sett lastSeenTime bak eventen
         poller.lastSeenTime = t(0)

src/test/kotlin/no/iktdev/eventi/events/poller/TestablePoller.kt

@@ -17,6 +17,8 @@ class TestablePoller(
     val scope: TestScope
 ) : EventPollerImplementation(eventStore, dispatchQueue, dispatcher), WatermarkDebugView {
 
+
+
     suspend fun startFor(iterations: Int) {
         repeat(iterations) {
             try {
@@ -30,17 +32,19 @@ class TestablePoller(
         }
     }
 
-    override fun watermarkFor(ref: UUID): Pair<Instant, Long>? {
+    override fun watermarkFor(ref: UUID): Instant? {
-        return refWatermark[ref]
+        return refWatermark[ref]?.let {
-    }
+            return it
-
-    override fun setWatermarkFor(ref: UUID, time: Instant, id: Long) {
-        refWatermark[ref] = time to id
         }
     }
 
+    override fun setWatermarkFor(ref: UUID, time: Instant) {
+        refWatermark[ref] = time
+    }
+
+
+}
 interface WatermarkDebugView {
-    fun watermarkFor(ref: UUID): Pair<Instant, Long>?
+    fun watermarkFor(ref: UUID): Instant?
-    fun setWatermarkFor(ref: UUID, time: Instant, id: Long)
+    fun setWatermarkFor(ref: UUID, time: Instant)
 }
-

src/test/kotlin/no/iktdev/eventi/tasks/TaskListenerRegistryTest.kt

@@ -5,7 +5,6 @@ import no.iktdev.eventi.events.EventListener
 import no.iktdev.eventi.events.EventListenerRegistry
 import no.iktdev.eventi.models.Event
 import no.iktdev.eventi.models.Task
-import no.iktdev.eventi.models.store.TaskStatus
 import no.iktdev.eventi.testUtil.wipe
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Assertions.*
@@ -20,15 +19,6 @@ class TaskListenerRegistryTest {
         override fun getWorkerId(): String {
             TODO("Not yet implemented")
         }
-
-        override fun createIncompleteStateTaskEvent(
-            task: Task,
-            status: TaskStatus,
-            exception: Exception?
-        ): Event {
-            TODO("Not yet implemented")
-        }
-
         override fun supports(task: Task): Boolean {
             TODO("Not yet implemented")
         }
@@ -42,15 +32,6 @@ class TaskListenerRegistryTest {
         override fun getWorkerId(): String {
             TODO("Not yet implemented")
         }
-
-        override fun createIncompleteStateTaskEvent(
-            task: Task,
-            status: TaskStatus,
-            exception: Exception?
-        ): Event {
-            TODO("Not yet implemented")
-        }
-
         override fun supports(task: Task): Boolean {
             TODO("Not yet implemented")
         }
@@ -64,15 +45,6 @@ class TaskListenerRegistryTest {
         override fun getWorkerId(): String {
             TODO("Not yet implemented")
         }
-
-        override fun createIncompleteStateTaskEvent(
-            task: Task,
-            status: TaskStatus,
-            exception: Exception?
-        ): Event {
-            TODO("Not yet implemented")
-        }
-
         override fun supports(task: Task): Boolean {
             TODO("Not yet implemented")
         }
@@ -85,15 +57,6 @@ class TaskListenerRegistryTest {
         override fun getWorkerId(): String {
             TODO("Not yet implemented")
         }
-
-        override fun createIncompleteStateTaskEvent(
-            task: Task,
-            status: TaskStatus,
-            exception: Exception?
-        ): Event {
-            TODO("Not yet implemented")
-        }
-
         override fun supports(task: Task): Boolean {
             TODO("Not yet implemented")
         }

src/test/kotlin/no/iktdev/eventi/tasks/TaskListenerTest.kt

@@ -2,13 +2,13 @@ package no.iktdev.eventi.tasks
 
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.yield
 import no.iktdev.eventi.models.Event
 import no.iktdev.eventi.models.Task
-import no.iktdev.eventi.models.store.TaskStatus
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
@@ -23,29 +23,32 @@ Så skal state, heartbeat og cleanup fungere korrekt
 """)
 class TaskListenerTest {
 
+    // -------------------------
+    // Fake Task + Reporter
+    // -------------------------
+
     class FakeTask : Task()
 
     class FakeReporter : TaskReporter {
         var claimed = false
-        var completed = false
+        var consumed = false
-        var failed = false
+        var logs = mutableListOf<String>()
-        var cancelled = false
+        var events = mutableListOf<Event>()
-        val logs = mutableListOf<String>()
-        val events = mutableListOf<Event>()
 
         override fun markClaimed(taskId: UUID, workerId: String) { claimed = true }
-        override fun markCompleted(taskId: UUID) { completed = true }
+        override fun markCompleted(taskId: UUID) { consumed = true }
-        override fun markFailed(referenceId: UUID, taskId: UUID) { failed = true }
+        override fun markFailed(referenceId: UUID, taskId: UUID) { consumed = true }
-        override fun markCancelled(referenceId: UUID, taskId: UUID) { cancelled = true }
+        override fun markCancelled(referenceId: UUID, taskId: UUID) {}
         override fun updateProgress(taskId: UUID, progress: Int) {}
         override fun publishEvent(event: Event) { events.add(event) }
         override fun updateLastSeen(taskId: UUID) {}
         override fun log(taskId: UUID, message: String) { logs.add(message) }
     }
 
-    // ---------------------------------------------------------
+    // -------------------------
-    // 1 — Heartbeat starter og stopper riktig
+    // Tests
-    // ---------------------------------------------------------
+    // -------------------------
+
     @Test
     @DisplayName("""
     Når onTask starter heartbeat-runner
@@ -55,15 +58,13 @@ class TaskListenerTest {
     fun heartbeatStartsAndStopsCorrectly() = runTest {
         val listener = object : TaskListener() {
 
-            var heartbeatRan = false
+            var heartbeatStarted: Job? = null
+            var heartbeatRan: Boolean = false
+                private set
+
             var onTaskCalled = false
 
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
             override suspend fun onTask(task: Task): Event? {
@@ -71,18 +72,25 @@ class TaskListenerTest {
 
                 withHeartbeatRunner(10.milliseconds) {
                     heartbeatRan = true
-                }
+                }.also { heartbeatStarted = it }
 
+                // Gi heartbeat en sjanse til å kjøre
                 yield()
+
                 return object : Event() {}
             }
         }
 
         val reporter = FakeReporter()
-        listener.accept(FakeTask(), reporter)
+        val task = FakeTask()
 
-        listener.currentJob?.join()
+        val accepted = listener.accept(task, reporter)
+        assertTrue(accepted)
 
+        listener.currentJob!!.join()
+
+        assertNotNull(listener.heartbeatStarted)
+        assertFalse(listener.heartbeatStarted!!.isActive)
         assertTrue(listener.heartbeatRan)
         assertNull(listener.heartbeatRunner)
         assertNull(listener.currentJob)
@@ -90,9 +98,6 @@ class TaskListenerTest {
         assertNull(listener.reporter)
     }
 
-    // ---------------------------------------------------------
-    // 2 — Heartbeat blokkerer ikke annen jobb
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når heartbeat kjører i bakgrunnen
@@ -105,51 +110,62 @@ class TaskListenerTest {
 
         val listener = object : TaskListener() {
 
+            var heartbeatStarted: Job? = null
             var heartbeatRan = false
 
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
-            override suspend fun onTask(task: Task): Event {
+            override suspend fun onTask(task: Task): Event? {
+
+                // Start heartbeat
                 withHeartbeatRunner(10.milliseconds) {
                     heartbeatRan = true
-                }
+                }.also { heartbeatStarted = it }
 
+                // Simuler annen coroutine-oppgave (VideoTaskListener/Converter)
                 launch {
                     delay(30)
                     otherWorkCompleted.complete(Unit)
                 }
 
+                // ⭐ Ikke fullfør onTask før testen sier det
                 allowFinish.await()
                 return object : Event() {}
             }
         }
 
         val reporter = FakeReporter()
-        listener.accept(FakeTask(), reporter)
+        val task = FakeTask()
 
+        listener.accept(task, reporter)
+
+        // Vent på annen jobb
         otherWorkCompleted.await()
 
-        assertTrue(listener.heartbeatRan)
+        // ⭐ Nå er onTask fortsatt i live, cleanup har ikke skjedd
         assertNotNull(listener.currentJob)
         assertTrue(listener.currentJob!!.isActive)
 
-        allowFinish.complete(Unit)
+        // Heartbeat kjørte
-        listener.currentJob?.join()
+        assertNotNull(listener.heartbeatStarted)
+        assertTrue(listener.heartbeatRan)
 
+        // ⭐ Nå lar vi onTask fullføre
+        allowFinish.complete(Unit)
+
+        // Vent på listener-jobben
+        listener.currentJob!!.join()
+
+        // Heartbeat ble kansellert
+        assertFalse(listener.heartbeatStarted!!.isActive)
+
+        // Cleanup
         assertNull(listener.heartbeatRunner)
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
     }
 
-    // ---------------------------------------------------------
-    // 3 — Heartbeat + CPU + IO arbeid
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når heartbeat kjører og flere parallelle jobber startes
@@ -163,56 +179,73 @@ class TaskListenerTest {
 
         val listener = object : TaskListener() {
 
+            var heartbeatStarted: Job? = null
             var heartbeatRan = false
 
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
             override suspend fun onTask(task: Task): Event? {
+
+                // Start heartbeat
                 withHeartbeatRunner(10.milliseconds) {
                     heartbeatRan = true
-                }
+                }.also { heartbeatStarted = it }
 
+                // Simuler Converter (CPU)
                 launch(Dispatchers.Default) {
-                    repeat(1000) {}
+                    repeat(1000) { /* CPU work */ }
                     converterDone.complete(Unit)
                 }
 
+                // Simuler VideoTaskListener (IO)
                 launch(Dispatchers.IO) {
                     delay(40)
                     videoDone.complete(Unit)
                 }
 
+                // ⭐ Vent til testen sier "nå kan du fullføre"
                 allowFinish.await()
                 return object : Event() {}
             }
         }
 
         val reporter = FakeReporter()
-        listener.accept(FakeTask(), reporter)
+        val task = FakeTask()
 
+        listener.accept(task, reporter)
+
+        // Vent på begge "andre" oppgaver
         converterDone.await()
         videoDone.await()
 
-        assertTrue(listener.heartbeatRan)
+        // ⭐ Verifiser at begge faktisk ble fullført
+        assertTrue(converterDone.isCompleted)
+        assertTrue(videoDone.isCompleted)
+
+        // ⭐ Nå er onTask fortsatt i live, cleanup har ikke skjedd
         assertNotNull(listener.currentJob)
+        assertTrue(listener.currentJob!!.isActive)
 
+        // Heartbeat kjørte
+        assertNotNull(listener.heartbeatStarted)
+        assertTrue(listener.heartbeatRan)
+
+        // ⭐ Nå lar vi onTask fullføre
         allowFinish.complete(Unit)
-        listener.currentJob?.join()
 
+        // Vent på listener-jobben
+        listener.currentJob!!.join()
+
+        // Heartbeat ble kansellert
+        assertFalse(listener.heartbeatStarted!!.isActive)
+
+        // Cleanup
         assertNull(listener.heartbeatRunner)
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
     }
 
-    // ---------------------------------------------------------
-    // 4 — Arbeid fullføres, heartbeat kjører
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når onTask gjør ferdig arbeid
@@ -224,25 +257,24 @@ class TaskListenerTest {
 
         val listener = object : TaskListener() {
 
+            var heartbeatStarted: Job? = null
             var heartbeatRan = false
             var onTaskCalled = false
 
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
-            override suspend fun onTask(task: Task): Event {
+            override suspend fun onTask(task: Task): Event? {
                 onTaskCalled = true
 
                 withHeartbeatRunner(10.milliseconds) {
                     heartbeatRan = true
-                }
+                }.also { heartbeatStarted = it }
 
+                // Simuler arbeid
                 delay(20)
+
+                // ⭐ signaliser at arbeidet er ferdig
                 workCompleted.complete(Unit)
 
                 return object : Event() {}
@@ -250,23 +282,34 @@ class TaskListenerTest {
         }
 
         val reporter = FakeReporter()
-        listener.accept(FakeTask(), reporter)
+        val task = FakeTask()
 
+        val accepted = listener.accept(task, reporter)
+        assertTrue(accepted)
+
+        // ⭐ Verifiser at arbeidet faktisk ble fullført
         workCompleted.await()
-        listener.currentJob?.join()
 
+        // Vent på jobben
+        listener.currentJob!!.join()
+
+        // onTask ble kalt
         assertTrue(listener.onTaskCalled)
+
+        // Heartbeat ble startet
+        assertNotNull(listener.heartbeatStarted)
         assertTrue(listener.heartbeatRan)
 
+        // Heartbeat ble kansellert
+        assertFalse(listener.heartbeatStarted!!.isActive)
+
+        // Cleanup
         assertNull(listener.heartbeatRunner)
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
         assertNull(listener.reporter)
     }
 
-    // ---------------------------------------------------------
-    // 5 — accept() returnerer false når busy
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når listener er opptatt med en task
@@ -278,34 +321,36 @@ class TaskListenerTest {
 
         val listener = object : TaskListener() {
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
             override suspend fun onTask(task: Task): Event? {
+                // Hold jobben i live
                 allowFinish.await()
                 return object : Event() {}
             }
         }
 
         val reporter = FakeReporter()
+        val task1 = FakeTask()
+        val task2 = FakeTask()
 
-        assertTrue(listener.accept(FakeTask(), reporter))
+        // Første task aksepteres
-        assertFalse(listener.accept(FakeTask(), reporter))
+        val accepted1 = listener.accept(task1, reporter)
+        assertTrue(accepted1)
 
+        // Listener er busy → andre task skal avvises
+        val accepted2 = listener.accept(task2, reporter)
+        assertFalse(accepted2)
+
+        // Fullfør første task
         allowFinish.complete(Unit)
-        listener.currentJob?.join()
+        listener.currentJob!!.join()
 
+        // Cleanup
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
     }
 
-    // ---------------------------------------------------------
-    // 6 — accept() returnerer false når unsupported
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når supports() returnerer false
@@ -315,26 +360,21 @@ class TaskListenerTest {
     fun acceptReturnsFalseWhenUnsupported() = runTest {
         val listener = object : TaskListener() {
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = false
             override suspend fun onTask(task: Task): Event? = error("Should not be called")
         }
 
         val reporter = FakeReporter()
+        val task = FakeTask()
 
-        assertFalse(listener.accept(FakeTask(), reporter))
+        val accepted = listener.accept(task, reporter)
+
+        assertFalse(accepted)
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
         assertNull(listener.reporter)
     }
 
-    // ---------------------------------------------------------
-    // 7 — onError kalles når onTask kaster
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når onTask kaster en exception
@@ -346,11 +386,6 @@ class TaskListenerTest {
 
         val listener = object : TaskListener() {
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
             override suspend fun onTask(task: Task): Event? {
@@ -364,19 +399,22 @@ class TaskListenerTest {
         }
 
         val reporter = FakeReporter()
-        listener.accept(FakeTask().newReferenceId(), reporter)
+        val task = FakeTask().newReferenceId()
 
+        listener.accept(task, reporter)
+
+        // Vent på error-path
         errorLogged.await()
+
+        // ⭐ Vent på at cleanup i finally kjører
         listener.currentJob?.join()
 
+        // Cleanup verifisering
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
         assertNull(listener.heartbeatRunner)
     }
 
-    // ---------------------------------------------------------
-    // 8 — onCancelled kalles når jobben kanselleres
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når jobben kanselleres mens onTask kjører
@@ -389,16 +427,11 @@ class TaskListenerTest {
 
         val listener = object : TaskListener() {
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
             override suspend fun onTask(task: Task): Event? {
                 allowStart.complete(Unit)
-                delay(Long.MAX_VALUE)
+                delay(Long.MAX_VALUE) // hold jobben i live
                 return null
             }
 
@@ -409,22 +442,28 @@ class TaskListenerTest {
         }
 
         val reporter = FakeReporter()
-        listener.accept(FakeTask().newReferenceId(), reporter)
+        val task = FakeTask().newReferenceId()
 
+        listener.accept(task, reporter)
+
+        // Vent til onTask har startet
         allowStart.await()
+
+        // Kanseller jobben
         listener.currentJob!!.cancel()
 
+        // Vent til onCancelled() ble kalt
         cancelledCalled.await()
+
+        // ⭐ Vent til cleanup i finally har kjørt
         listener.currentJob?.join()
 
+        // Cleanup verifisering
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
         assertNull(listener.heartbeatRunner)
     }
 
-    // ---------------------------------------------------------
-    // 9 — Sekvensiell kjøring uten state‑lekkasje
-    // ---------------------------------------------------------
     @Test
     @DisplayName("""
     Når listener prosesserer to tasks sekvensielt
@@ -432,10 +471,7 @@ class TaskListenerTest {
     Så skal ingen state lekke mellom tasks
     """)
     fun listenerHandlesSequentialTasksWithoutLeakingState() = runTest {
-        val started1 = CompletableDeferred<Unit>()
         val finish1 = CompletableDeferred<Unit>()
-
-        val started2 = CompletableDeferred<Unit>()
         val finish2 = CompletableDeferred<Unit>()
 
         val listener = object : TaskListener() {
@@ -443,50 +479,41 @@ class TaskListenerTest {
             var callCount = 0
 
             override fun getWorkerId() = "worker"
-
-            override fun createIncompleteStateTaskEvent(
-                task: Task, status: TaskStatus, exception: Exception?
-            ) = object : Event() {}
-
             override fun supports(task: Task) = true
 
-            override suspend fun onTask(task: Task): Event {
+            override suspend fun onTask(task: Task): Event? {
                 callCount++
-
+                if (callCount == 1) finish1.await()
-                if (callCount == 1) {
+                if (callCount == 2) finish2.await()
-                    started1.complete(Unit)
-                    finish1.await()
-                }
-
-                if (callCount == 2) {
-                    started2.complete(Unit)
-                    finish2.await()
-                }
-
                 return object : Event() {}
             }
         }
 
         val reporter = FakeReporter()
 
-        listener.accept(FakeTask(), reporter)
+        // Task 1
-        started1.await()
+        val task1 = FakeTask()
+        listener.accept(task1, reporter)
         finish1.complete(Unit)
-        listener.currentJob?.join()
+        listener.currentJob!!.join()
 
+        // Verifiser cleanup
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
         assertNull(listener.heartbeatRunner)
 
-        listener.accept(FakeTask(), reporter)
+        // Task 2
-        started2.await()
+        val task2 = FakeTask()
+        listener.accept(task2, reporter)
         finish2.complete(Unit)
-        listener.currentJob?.join()
+        listener.currentJob!!.join()
 
+        // Verifiser cleanup igjen
         assertNull(listener.currentJob)
         assertNull(listener.currentTask)
         assertNull(listener.heartbeatRunner)
 
+        // onTask ble kalt to ganger
         assertEquals(2, listener.callCount)
     }
 }

src/test/kotlin/no/iktdev/eventi/tasks/TaskPollerImplementationTest.kt

@@ -10,7 +10,6 @@ import no.iktdev.eventi.TestBase
 import no.iktdev.eventi.events.EventTypeRegistry
 import no.iktdev.eventi.models.Event
 import no.iktdev.eventi.models.Task
-import no.iktdev.eventi.models.store.TaskStatus
 import no.iktdev.eventi.stores.TaskStore
 import no.iktdev.eventi.testUtil.multiply
 import no.iktdev.eventi.testUtil.wipe
@@ -73,14 +72,6 @@ class TaskPollerImplementationTest : TestBase() {
 
         fun getJob() = currentJob
         override fun getWorkerId() = this.javaClass.simpleName
-        override fun createIncompleteStateTaskEvent(
-            task: Task,
-            status: TaskStatus,
-            exception: Exception?
-        ): Event {
-            return object : Event() {}
-        }
-
         override fun supports(task: Task) = task is EchoTask
 
         override suspend fun onTask(task: Task): Event {
@@ -114,7 +105,7 @@ class TaskPollerImplementationTest : TestBase() {
         val listener = EchoListener()
         val poller = object : TaskPollerImplementation(taskStore, reporterFactory) {}
 
-        val task = EchoTask("Hello").newReferenceId().derivedOf(object : Event() {}.apply { newReferenceId() })
+        val task = EchoTask("Hello").newReferenceId().derivedOf(object : Event() {})
         taskStore.persist(task)
 
         poller.pollOnce()

src/test/kotlin/no/iktdev/eventi/testUtil/TestSequenceDispatchQueue.kt

@@ -1,14 +0,0 @@
-package no.iktdev.eventi.testUtil
-
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import no.iktdev.eventi.events.SequenceDispatchQueue
-
-class TestSequenceDispatchQueue(
-    maxConcurrency: Int,
-    dispatcher: CoroutineDispatcher
-) : SequenceDispatchQueue(
-    maxConcurrency,
-    CoroutineScope(dispatcher + SupervisorJob())
-)