moritzruth/uranos
Archived
1
0
Fork 0
Code Activity

No longer use Spek

Browse source
This commit is contained in:
Moritz Ruth 2020-09-09 23:26:13 +02:00
parent 0689944d77
commit 4be30418fb
3 changed files with 180 additions and 180 deletions
Download patch file Download diff file Expand all files Collapse all files

8
blokk-api/build.gradle.kts
View file

@ -34,8 +34,8 @@ dependencies {
// Testing // Testing
testImplementation("io.strikt:strikt-core:0.26.1") testImplementation("io.strikt:strikt-core:0.26.1")
testImplementation("org.spekframework.spek2:spek-dsl-jvm:$spekVersion") testImplementation("org.junit.jupiter:junit-jupiter-api:5.6.2")
testRuntimeOnly("org.spekframework.spek2:spek-runner-junit5:$spekVersion") testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.6.2")
} }
tasks { tasks {
@ -51,8 +51,6 @@ tasks {
} }
test { test {
useJUnitPlatform { useJUnitPlatform()
includeEngines("spek2")
}
} }
} }

23
blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt
View file

@ -1,18 +1,17 @@
package space.blokk.chat package space.blokk.chat
import org.spekframework.spek2.Spek import org.junit.jupiter.api.Test
import org.spekframework.spek2.style.specification.describe
import strikt.api.expectThat import strikt.api.expectThat
import strikt.assertions.isEqualTo import strikt.assertions.isEqualTo
object FormattingCodeTest : Spek({ class FormattingCodeTest {
describe("FormattingCode") { @Test
it("correctly translates to a string") { fun `correctly translates to a string`() {
expectThat("${FormattingCode.AQUA}").isEqualTo("§b") expectThat("${FormattingCode.AQUA}").isEqualTo("§b")
}
it("can be appended to another FormattingCode using the + operator") {
expectThat(FormattingCode.AQUA + FormattingCode.BLACK).isEqualTo("§b§0")
}
} }
})
@Test
fun `can be appended to another FormattingCode using the + operator`() {
expectThat(FormattingCode.AQUA + FormattingCode.BLACK).isEqualTo("§b§0")
}
}

329
blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt
View file

@ -4,199 +4,202 @@ import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.spekframework.spek2.Spek import org.junit.jupiter.api.Test
import org.spekframework.spek2.style.specification.describe
import strikt.api.expectThat import strikt.api.expectThat
import strikt.api.expectThrows import strikt.api.expectThrows
import strikt.assertions.* import strikt.assertions.*
import kotlin.system.measureTimeMillis import kotlin.system.measureTimeMillis
private abstract class TestEvent : Event() abstract class TestEvent : Event()
private class FirstEvent : TestEvent() private class FirstEvent : TestEvent()
private class SecondEvent : TestEvent() private class SecondEvent : TestEvent()
object EventBusTest : Spek({ class EventBusTest {
describe("EventBus") { val eventBus = EventBus(TestEvent::class, CoroutineScope(Dispatchers.Default))
val eventBus by memoized { EventBus(TestEvent::class, CoroutineScope(Dispatchers.Default)) }
it("calls the handler exactly 1 time when the event is emitted 1 time") { @Test
var calledCount = 0 fun `calls the handler exactly 1 time when the event is emitted 1 time`() {
eventBus.register(object : Listener { var calledCount = 0
@EventHandler eventBus.register(object : Listener {
fun onFirstEvent(event: FirstEvent) { @EventHandler
calledCount++ fun onFirstEvent(event: FirstEvent) {
} calledCount++
}) }
})
runBlocking { eventBus.emit(FirstEvent()) } runBlocking { eventBus.emit(FirstEvent()) }
expectThat(calledCount).isEqualTo(1) 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") { expectThat(calledCount).isEqualTo(3)
var calledCount = 0 }
eventBus.register(object : Listener {
@EventHandler
fun onFirstEvent(event: FirstEvent) {
calledCount++
}
})
@Test
runBlocking { fun `calls no handlers if no event is emitted`() {
eventBus.emit(FirstEvent()) var onFirstEventCalled = false
eventBus.emit(FirstEvent()) var onSecondEventCalled = false
eventBus.emit(FirstEvent()) 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") { // No emit
var onFirstEventCalled = false
var onSecondEventCalled = false
eventBus.register(object : Listener {
@EventHandler
fun onFirstEvent(event: FirstEvent) {
onFirstEventCalled = true
}
@EventHandler expectThat(onFirstEventCalled).isFalse()
fun onSecondEvent(event: SecondEvent) { expectThat(onSecondEventCalled).isFalse()
onSecondEventCalled = true }
}
})
// No emit @Test
fun `calls handlers for supertypes of the emitted event`() {
expectThat(onFirstEventCalled).isFalse() var onTestEventCalled = false
expectThat(onSecondEventCalled).isFalse() var onFirstEventCalled = false
} eventBus.register(object : Listener {
@EventHandler
it("calls handlers for supertypes of the emitted event") { fun onTestEvent(event: TestEvent) {
var onTestEventCalled = false onTestEventCalled = true
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.InvalidEventHandlerException> {
eventBus.register(object : Listener {
@EventHandler
fun onEvent(coolParam: String) {
}
})
} }
expectThrows<EventBus.InvalidEventHandlerException> { @EventHandler
eventBus.register(object : Listener { fun onFirstEvent(event: FirstEvent) {
@EventHandler onFirstEventCalled = true
fun onFirstEvent(coolParam: String, event: FirstEvent) {
}
})
} }
})
expectThrows<EventBus.InvalidEventHandlerException> { runBlocking { eventBus.emit(FirstEvent()) }
eventBus.register(object : Listener {
@EventHandler expectThat(onTestEventCalled).isTrue()
fun onFirstEvent(event: FirstEvent, coolParam: String) { 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") { eventBus.unregister(listener)
val order = mutableListOf<EventPriority>()
eventBus.register(object : Listener { runBlocking { eventBus.emit(FirstEvent()) }
@EventHandler(EventPriority.HIGHEST) expectThat(called).isFalse()
fun onFirstEventHighest(event: FirstEvent) { }
order.add(EventPriority.HIGHEST)
}
@EventHandler(EventPriority.LOW) @Test
fun onFirstEventLow(event: FirstEvent) { fun `throws an error if an event handler function has an invalid signature`() {
order.add(EventPriority.LOW) expectThrows<EventBus.InvalidEventHandlerException> {
}
@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<EventPriority, Int> { it.ordinal })
}
it("suspends until all handlers ran") {
val delay = 2000L
eventBus.register(object : Listener { eventBus.register(object : Listener {
@EventHandler @EventHandler
suspend fun onFirstEvent(event: FirstEvent) { fun onEvent(coolParam: String) {
// Simulate long running operation
delay(2000)
} }
}) })
}
val duration = measureTimeMillis { runBlocking { eventBus.emit(FirstEvent()) } } expectThrows<EventBus.InvalidEventHandlerException> {
expectThat(duration).isGreaterThanOrEqualTo(delay) eventBus.register(object : Listener {
@EventHandler
fun onFirstEvent(coolParam: String, event: FirstEvent) {
}
})
}
expectThrows<EventBus.InvalidEventHandlerException> {
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<EventPriority>()
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<EventPriority, Int> { 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)
}
}