diff --git a/blokk-api/build.gradle.kts b/blokk-api/build.gradle.kts index ec2c846..ff428fa 100644 --- a/blokk-api/build.gradle.kts +++ b/blokk-api/build.gradle.kts @@ -34,8 +34,8 @@ dependencies { // Testing testImplementation("io.strikt:strikt-core:0.26.1") - testImplementation("org.spekframework.spek2:spek-dsl-jvm:$spekVersion") - testRuntimeOnly("org.spekframework.spek2:spek-runner-junit5:$spekVersion") + testImplementation("org.junit.jupiter:junit-jupiter-api:5.6.2") + testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.6.2") } tasks { @@ -51,8 +51,6 @@ tasks { } test { - useJUnitPlatform { - includeEngines("spek2") - } + useJUnitPlatform() } } diff --git a/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt b/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt index 9acadef..b8af762 100644 --- a/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt +++ b/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt @@ -1,18 +1,17 @@ package space.blokk.chat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Test import strikt.api.expectThat import strikt.assertions.isEqualTo -object FormattingCodeTest : Spek({ - describe("FormattingCode") { - it("correctly translates to a string") { - expectThat("${FormattingCode.AQUA}").isEqualTo("§b") - } - - it("can be appended to another FormattingCode using the + operator") { - expectThat(FormattingCode.AQUA + FormattingCode.BLACK).isEqualTo("§b§0") - } +class FormattingCodeTest { + @Test + fun `correctly translates to a string`() { + expectThat("${FormattingCode.AQUA}").isEqualTo("§b") } -}) + + @Test + fun `can be appended to another FormattingCode using the + operator`() { + expectThat(FormattingCode.AQUA + FormattingCode.BLACK).isEqualTo("§b§0") + } +} diff --git a/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt b/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt index d128755..24b28b9 100644 --- a/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt +++ b/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt @@ -4,199 +4,202 @@ import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Test import strikt.api.expectThat import strikt.api.expectThrows import strikt.assertions.* import kotlin.system.measureTimeMillis -private abstract class TestEvent : Event() +abstract class TestEvent : Event() private class FirstEvent : TestEvent() private class SecondEvent : TestEvent() -object EventBusTest : Spek({ - describe("EventBus") { - val eventBus by memoized { EventBus(TestEvent::class, CoroutineScope(Dispatchers.Default)) } +class EventBusTest { + val eventBus = EventBus(TestEvent::class, CoroutineScope(Dispatchers.Default)) - it("calls the handler exactly 1 time when the event is emitted 1 time") { - var calledCount = 0 - eventBus.register(object : Listener { - @EventHandler - fun onFirstEvent(event: FirstEvent) { - calledCount++ - } - }) + @Test + fun `calls the handler exactly 1 time when the event is emitted 1 time`() { + var calledCount = 0 + eventBus.register(object : Listener { + @EventHandler + fun onFirstEvent(event: FirstEvent) { + calledCount++ + } + }) - runBlocking { eventBus.emit(FirstEvent()) } - expectThat(calledCount).isEqualTo(1) + runBlocking { eventBus.emit(FirstEvent()) } + expectThat(calledCount).isEqualTo(1) + } + + @Test + fun `calls the handler exactly 3 times when the event is emitted 3 times`() { + var calledCount = 0 + eventBus.register(object : Listener { + @EventHandler + fun onFirstEvent(event: FirstEvent) { + calledCount++ + } + }) + + + runBlocking { + eventBus.emit(FirstEvent()) + eventBus.emit(FirstEvent()) + eventBus.emit(FirstEvent()) } - it("calls the handler exactly 3 times when the event is emitted 3 times") { - var calledCount = 0 - eventBus.register(object : Listener { - @EventHandler - fun onFirstEvent(event: FirstEvent) { - calledCount++ - } - }) + expectThat(calledCount).isEqualTo(3) + } - - runBlocking { - eventBus.emit(FirstEvent()) - eventBus.emit(FirstEvent()) - eventBus.emit(FirstEvent()) + @Test + fun `calls no handlers if no event is emitted`() { + var onFirstEventCalled = false + var onSecondEventCalled = false + eventBus.register(object : Listener { + @EventHandler + fun onFirstEvent(event: FirstEvent) { + onFirstEventCalled = true } - expectThat(calledCount).isEqualTo(3) - } + @EventHandler + fun onSecondEvent(event: SecondEvent) { + onSecondEventCalled = true + } + }) - it("calls no handlers if no event is emitted") { - var onFirstEventCalled = false - var onSecondEventCalled = false - eventBus.register(object : Listener { - @EventHandler - fun onFirstEvent(event: FirstEvent) { - onFirstEventCalled = true - } + // No emit - @EventHandler - fun onSecondEvent(event: SecondEvent) { - onSecondEventCalled = true - } - }) + expectThat(onFirstEventCalled).isFalse() + expectThat(onSecondEventCalled).isFalse() + } - // No emit - - expectThat(onFirstEventCalled).isFalse() - expectThat(onSecondEventCalled).isFalse() - } - - it("calls handlers for supertypes of the emitted event") { - var onTestEventCalled = false - var onFirstEventCalled = false - eventBus.register(object : Listener { - @EventHandler - fun onTestEvent(event: TestEvent) { - onTestEventCalled = true - } - - @EventHandler - fun onFirstEvent(event: FirstEvent) { - onFirstEventCalled = true - } - }) - - runBlocking { eventBus.emit(FirstEvent()) } - - expectThat(onTestEventCalled).isTrue() - expectThat(onFirstEventCalled).isTrue() - } - - it("stops calling handlers after they were unregistered") { - var called = false - val listener = eventBus.register(object : Listener { - @EventHandler - fun onFirstEvent(event: FirstEvent) { - called = true - } - }) - - eventBus.unregister(listener) - - runBlocking { eventBus.emit(FirstEvent()) } - - expectThat(called).isFalse() - } - - it("throws an error if an event handler function has an invalid signature") { - expectThrows { - eventBus.register(object : Listener { - @EventHandler - fun onEvent(coolParam: String) { - } - }) + @Test + fun `calls handlers for supertypes of the emitted event`() { + var onTestEventCalled = false + var onFirstEventCalled = false + eventBus.register(object : Listener { + @EventHandler + fun onTestEvent(event: TestEvent) { + onTestEventCalled = true } - expectThrows { - eventBus.register(object : Listener { - @EventHandler - fun onFirstEvent(coolParam: String, event: FirstEvent) { - } - }) + @EventHandler + fun onFirstEvent(event: FirstEvent) { + onFirstEventCalled = true } + }) - expectThrows { - eventBus.register(object : Listener { - @EventHandler - fun onFirstEvent(event: FirstEvent, coolParam: String) { - } - }) + runBlocking { eventBus.emit(FirstEvent()) } + + expectThat(onTestEventCalled).isTrue() + expectThat(onFirstEventCalled).isTrue() + } + + @Test + fun `stops calling handlers after they were unregistered`() { + var called = false + val listener = eventBus.register(object : Listener { + @EventHandler + fun onFirstEvent(event: FirstEvent) { + called = true } - } + }) - it("calls handlers in the right order, sorted by priority") { - val order = mutableListOf() + eventBus.unregister(listener) - eventBus.register(object : Listener { - @EventHandler(EventPriority.HIGHEST) - fun onFirstEventHighest(event: FirstEvent) { - order.add(EventPriority.HIGHEST) - } + runBlocking { eventBus.emit(FirstEvent()) } + expectThat(called).isFalse() + } - @EventHandler(EventPriority.LOW) - fun onFirstEventLow(event: FirstEvent) { - order.add(EventPriority.LOW) - } - - @EventHandler(EventPriority.HIGHER) - fun onFirstEventHigher(event: FirstEvent) { - order.add(EventPriority.HIGHER) - } - - @EventHandler(EventPriority.LOWEST) - fun onFirstEventLowest(event: FirstEvent) { - order.add(EventPriority.LOWEST) - } - - @EventHandler(EventPriority.MONITOR) - fun onFirstEventMonitor(event: FirstEvent) { - order.add(EventPriority.MONITOR) - } - - @EventHandler(EventPriority.LOWER) - fun onFirstEventLower(event: FirstEvent) { - order.add(EventPriority.LOWER) - } - - @EventHandler(EventPriority.NORMAL) - fun onFirstEventNormal(event: FirstEvent) { - order.add(EventPriority.NORMAL) - } - - @EventHandler(EventPriority.HIGH) - fun onFirstEventHigh(event: FirstEvent) { - order.add(EventPriority.HIGH) - } - }) - - runBlocking { eventBus.emit(FirstEvent()) } - - expectThat(order).isSorted(Comparator.comparing { it.ordinal }) - } - - it("suspends until all handlers ran") { - val delay = 2000L + @Test + fun `throws an error if an event handler function has an invalid signature`() { + expectThrows { eventBus.register(object : Listener { @EventHandler - suspend fun onFirstEvent(event: FirstEvent) { - // Simulate long running operation - delay(2000) + fun onEvent(coolParam: String) { } }) + } - val duration = measureTimeMillis { runBlocking { eventBus.emit(FirstEvent()) } } - expectThat(duration).isGreaterThanOrEqualTo(delay) + expectThrows { + eventBus.register(object : Listener { + @EventHandler + fun onFirstEvent(coolParam: String, event: FirstEvent) { + } + }) + } + + expectThrows { + eventBus.register(object : Listener { + @EventHandler + fun onFirstEvent(event: FirstEvent, coolParam: String) { + } + }) } } -}) + + @Test + fun `calls handlers in the right order, sorted by priority`() { + val order = mutableListOf() + + eventBus.register(object : Listener { + @EventHandler(EventPriority.HIGHEST) + fun onFirstEventHighest(event: FirstEvent) { + order.add(EventPriority.HIGHEST) + } + + @EventHandler(EventPriority.LOW) + fun onFirstEventLow(event: FirstEvent) { + order.add(EventPriority.LOW) + } + + @EventHandler(EventPriority.HIGHER) + fun onFirstEventHigher(event: FirstEvent) { + order.add(EventPriority.HIGHER) + } + + @EventHandler(EventPriority.LOWEST) + fun onFirstEventLowest(event: FirstEvent) { + order.add(EventPriority.LOWEST) + } + + @EventHandler(EventPriority.MONITOR) + fun onFirstEventMonitor(event: FirstEvent) { + order.add(EventPriority.MONITOR) + } + + @EventHandler(EventPriority.LOWER) + fun onFirstEventLower(event: FirstEvent) { + order.add(EventPriority.LOWER) + } + + @EventHandler(EventPriority.NORMAL) + fun onFirstEventNormal(event: FirstEvent) { + order.add(EventPriority.NORMAL) + } + + @EventHandler(EventPriority.HIGH) + fun onFirstEventHigh(event: FirstEvent) { + order.add(EventPriority.HIGH) + } + }) + + runBlocking { eventBus.emit(FirstEvent()) } + expectThat(order).isSorted(Comparator.comparing { it.ordinal }) + } + + @Test + fun `suspends until all handlers ran`() { + val delay = 2000L + eventBus.register(object : Listener { + @EventHandler + suspend fun onFirstEvent(event: FirstEvent) { + // Simulate long running operation + delay(2000) + } + }) + + val duration = measureTimeMillis { runBlocking { eventBus.emit(FirstEvent()) } } + expectThat(duration).isGreaterThanOrEqualTo(delay) + } +}