From 9ddac98e0c4d792536ed617cc586ffd9d04d1f41 Mon Sep 17 00:00:00 2001 From: Michael Bull Date: Sat, 16 Dec 2017 19:30:54 +0000 Subject: [PATCH] Add multi-platform support Converts the unit tests to use kotlin-test, allowing them to target both the jvm and js platforms. --- build.gradle | 39 +- gradle.properties | 3 +- js/build.gradle | 11 + jvm/build.gradle | 35 ++ settings.gradle | 1 + .../com/github/michaelbull/result/AndTest.kt | 57 ++- .../com/github/michaelbull/result/GetTest.kt | 154 ++++--- .../github/michaelbull/result/IterableTest.kt | 397 ++++++++++++------ .../com/github/michaelbull/result/MapTest.kt | 178 ++++---- .../com/github/michaelbull/result/OnTest.kt | 73 ++-- .../com/github/michaelbull/result/OrTest.kt | 55 ++- .../michaelbull/result/ResultIteratorTest.kt | 96 ++--- .../github/michaelbull/result/ResultTest.kt | 42 +- .../github/michaelbull/result/UnwrapTest.kt | 113 ++--- 14 files changed, 754 insertions(+), 500 deletions(-) create mode 100644 js/build.gradle create mode 100644 jvm/build.gradle diff --git a/build.gradle b/build.gradle index aaf421f..5be0295 100644 --- a/build.gradle +++ b/build.gradle @@ -7,15 +7,16 @@ buildscript { dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokkaVersion" - classpath "org.junit.platform:junit-platform-gradle-plugin:$junitPlatformVersion" classpath "net.researchgate:gradle-release:$gradleReleaseVersion" } } -apply plugin: 'kotlin' +plugins { + id 'com.github.ben-manes.versions' version '0.17.0' +} + +apply plugin: 'kotlin-platform-common' apply plugin: 'maven-publish' -apply plugin: 'org.jetbrains.dokka' -apply plugin: 'org.junit.platform.gradle.plugin' apply plugin: 'net.researchgate.release' description = 'A Result monad for modelling success or failure operations.' @@ -25,31 +26,9 @@ repositories { } dependencies { - compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlinVersion" - testCompile "com.natpryce:hamkrest:$hamkrestVersion" - testCompile "org.junit.jupiter:junit-jupiter-params:$junitVersion" - testCompile "org.junit.jupiter:junit-jupiter-api:$junitVersion" - testRuntime "org.junit.jupiter:junit-jupiter-engine:$junitVersion" -} - -compileKotlin { - kotlinOptions.jvmTarget = "1.8" -} - -compileTestKotlin { - kotlinOptions.jvmTarget = "1.8" -} - -dokka { - outputFormat = 'javadoc' - outputDirectory = "$buildDir/docs" -} - -task javadocJar(type: Jar, dependsOn: dokka) { - group = LifecycleBasePlugin.BUILD_GROUP - description = 'Assembles a jar archive containing the Javadoc API documentation.' - classifier = 'javadoc' - from dokka.outputDirectory + compile "org.jetbrains.kotlin:kotlin-stdlib-common:$kotlinVersion" + testCompile "org.jetbrains.kotlin:kotlin-test-annotations-common:$kotlinVersion" + testCompile "org.jetbrains.kotlin:kotlin-test-common:$kotlinVersion" } task sourcesJar(type: Jar) { @@ -62,8 +41,6 @@ task sourcesJar(type: Jar) { publishing { publications { mavenJava(MavenPublication) { - from components.java - artifact javadocJar artifact sourcesJar } } diff --git a/gradle.properties b/gradle.properties index b6391a5..bc8b440 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,6 +4,5 @@ version=1.0.3-SNAPSHOT dokkaVersion=0.9.15 gradleReleaseVersion=2.6.0 hamkrestVersion=1.4.2.0 -junitVersion=5.0.1 -junitPlatformVersion=1.0.0 +junitVersion=4.12 kotlinVersion=1.2.10 diff --git a/js/build.gradle b/js/build.gradle new file mode 100644 index 0000000..e2aea25 --- /dev/null +++ b/js/build.gradle @@ -0,0 +1,11 @@ +apply plugin: 'kotlin-platform-js' + +repositories { + mavenCentral() +} + +dependencies { + compile "org.jetbrains.kotlin:kotlin-stdlib-js:$kotlinVersion" + expectedBy project(":") + testCompile "org.jetbrains.kotlin:kotlin-test-js:$kotlinVersion" +} diff --git a/jvm/build.gradle b/jvm/build.gradle new file mode 100644 index 0000000..d9bdcd7 --- /dev/null +++ b/jvm/build.gradle @@ -0,0 +1,35 @@ +apply plugin: 'kotlin-platform-jvm' +apply plugin: 'org.jetbrains.dokka' + +repositories { + mavenCentral() +} + +dependencies { + compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion" + expectedBy project(":") + testCompile "junit:junit:$junitVersion" + testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlinVersion" + testCompile "org.jetbrains.kotlin:kotlin-test:$kotlinVersion" +} + +dokka { + outputFormat = 'javadoc' + outputDirectory = "$buildDir/docs" +} + +task javadocJar(type: Jar, dependsOn: dokka) { + group = LifecycleBasePlugin.BUILD_GROUP + description = 'Assembles a jar archive containing the Javadoc API documentation.' + classifier = 'javadoc' + from dokka.outputDirectory +} + +publishing { + publications { + mavenJava(MavenPublication) { + from components.java + artifact javadocJar + } + } +} diff --git a/settings.gradle b/settings.gradle index 6e074d7..aceb36f 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,3 @@ rootProject.name = 'kotlin-result' +include 'js', 'jvm' diff --git a/src/test/kotlin/com/github/michaelbull/result/AndTest.kt b/src/test/kotlin/com/github/michaelbull/result/AndTest.kt index b556335..1ecd845 100644 --- a/src/test/kotlin/com/github/michaelbull/result/AndTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/AndTest.kt @@ -1,34 +1,45 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import com.natpryce.hamkrest.sameInstance -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertSame internal class AndTest { private object AndError - @Test - internal fun `and should return the result value if ok`() { - val value = Ok(230).and(Ok(500)).get() - assertThat(value, equalTo(500)) + internal class `and` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = 500, + actual = Ok(230).and(Ok(500)).get() + ) + } + + @Test + internal fun returnsValueIfErr() { + assertEquals( + expected = "hello world", + actual = Ok(300).and(Err("hello world")).getError() + ) + } } - @Test - internal fun `and should return the result value if not ok`() { - val error = Ok(300).and(Err("hello world")).getError() - assertThat(error, equalTo("hello world")) - } + internal class `andThen` { + @Test + internal fun returnsTransformedValueIfOk() { + assertEquals( + expected = 12, + actual = Ok(5).andThen { Ok(it + 7) }.get() + ) + } - @Test - internal fun `andThen should return the transformed result value if ok`() { - val value = Ok(5).andThen { Ok(it + 7) }.get() - assertThat(value, equalTo(12)) - } - - @Test - internal fun `andThen should return the result error if not ok`() { - val error = Ok(20).andThen { Ok(it + 43) }.andThen { Err(AndError) }.getError()!! - assertThat(error, sameInstance(AndError)) + @Test + internal fun returnsErrorIfErr() { + assertSame( + expected = AndError, + actual = Ok(20).andThen { Ok(it + 43) }.andThen { Err(AndError) }.getError()!! + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/GetTest.kt b/src/test/kotlin/com/github/michaelbull/result/GetTest.kt index 0d89150..d8e6a46 100644 --- a/src/test/kotlin/com/github/michaelbull/result/GetTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/GetTest.kt @@ -1,79 +1,109 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull internal class GetTest { - @Test - internal fun `get should return the result value if ok`() { - val value = Ok(12).get() - assertThat(value, equalTo(12)) + internal class `get` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = 12, + actual = Ok(12).get() + ) + } + + @Test + internal fun returnsNullIfErr() { + assertNull(Err("error").get()) + } } - @Test - internal fun `get should return null if not ok`() { - val value = Err("error").get() - assertThat(value, equalTo(null)) + internal class `getError` { + @Test + internal fun returnsNullIfOk() { + assertNull(Ok("example").getError()) + } + + @Test + internal fun returnsErrorIfErr() { + assertEquals( + expected = "example", + actual = Err("example").getError() + ) + } } - @Test - internal fun `getError should return null if ok`() { - val error = Ok("example").getError() - assertThat(error, equalTo(null)) + internal class `getOr` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = "hello", + actual = Ok("hello").getOr("world") + ) + } + + @Test + internal fun returnsDefaultValueIfErr() { + assertEquals( + expected = "default", + actual = Err("error").getOr("default") + ) + } } - @Test - internal fun `getError should return the result error if not ok`() { - val error = Err("example").getError() - assertThat(error, equalTo("example")) + internal class `getErrorOr` { + @Test + internal fun returnsDefaultValueIfOk() { + assertEquals( + expected = "world", + actual = Ok("hello").getErrorOr("world") + ) + } + + @Test + internal fun returnsErrorIfErr() { + assertEquals( + expected = "hello", + actual = Err("hello").getErrorOr("world") + ) + } } - @Test - internal fun `getOr should return the result value if ok`() { - val value = Ok("hello").getOr("world") - assertThat(value, equalTo("hello")) + internal class `getOrElse` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = "hello", + actual = Ok("hello").getOrElse { "world" } + ) + } + + @Test + internal fun returnsTransformedErrorIfErr() { + assertEquals( + expected = "world", + actual = Err("hello").getOrElse { "world" } + ) + } } - @Test - internal fun `getOr should return default value if not ok`() { - val value = Err("error").getOr("default") - assertThat(value, equalTo("default")) - } + internal class `getErrorOrElse` { + @Test + internal fun returnsTransformedValueIfOk() { + assertEquals( + expected = "world", + actual = Ok("hello").getErrorOrElse { "world" } + ) + } - @Test - internal fun `getErrorOr should return the default value if ok`() { - val error = Ok("hello").getErrorOr("world") - assertThat(error, equalTo("world")) - } - - @Test - internal fun `getErrorOr should return the result error if not ok`() { - val error = Err("hello").getErrorOr("world") - assertThat(error, equalTo("hello")) - } - - @Test - internal fun `getOrElse should return the result value if ok`() { - val value = Ok("hello").getOrElse { "world" } - assertThat(value, equalTo("hello")) - } - - @Test - internal fun `getOrElse should return the transformed result error if ok`() { - val value = Err("hello").getOrElse { "world" } - assertThat(value, equalTo("world")) - } - - @Test - internal fun `getErrorOrElse should return the transformed result value if ok`() { - val error = Ok("hello").getErrorOrElse { "world" } - assertThat(error, equalTo("world")) - } - - @Test - internal fun `getErrorOrElse should return the result error if not ok`() { - val error = Err("hello").getErrorOrElse { "world" } - assertThat(error, equalTo("hello")) + @Test + internal fun returnsErrorIfErr() { + assertEquals( + expected = "hello", + actual = Err("hello").getErrorOrElse { "world" } + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/IterableTest.kt b/src/test/kotlin/com/github/michaelbull/result/IterableTest.kt index 804cb93..4511797 100644 --- a/src/test/kotlin/com/github/michaelbull/result/IterableTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/IterableTest.kt @@ -1,10 +1,8 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.Matcher -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import com.natpryce.hamkrest.sameInstance -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertSame internal class IterableTest { private sealed class IterableError { @@ -12,168 +10,291 @@ internal class IterableTest { object IterableError2 : IterableError() } - private fun sameError(error: IterableError): Matcher { - return sameInstance(error) - } + internal class `fold` { + @Test + internal fun returnAccumulatedValueIfOk() { + val result = listOf(20, 30, 40, 50).fold( + initial = 10, + operation = { a, b -> Ok(a + b) } + ) - @Test - internal fun `fold should return the accumulated value if ok`() { - val result = listOf(20, 30, 40, 50).fold( - initial = 10, - operation = { a, b -> Ok(a + b) } - ) + result as Ok - result as Ok + assertEquals( + expected = 150, + actual = result.value + ) + } - assertThat(result.value, equalTo(150)) - } - - @Test - internal fun `fold should return the first error if not ok`() { - val result: Result = listOf(5, 10, 15, 20, 25).fold( - initial = 1, - operation = { a, b -> - when (b) { - (5 + 10) -> Err(IterableError.IterableError1) - (5 + 10 + 15 + 20) -> Err(IterableError.IterableError2) - else -> Ok(a * b) + @Test + internal fun returnsFirstErrorIfErr() { + val result: Result = listOf(5, 10, 15, 20, 25).fold( + initial = 1, + operation = { a, b -> + when (b) { + (5 + 10) -> Err(IterableError.IterableError1) + (5 + 10 + 15 + 20) -> Err(IterableError.IterableError2) + else -> Ok(a * b) + } } - } - ) + ) - result as Err + result as Err - val matcher: Matcher = sameInstance(IterableError.IterableError1) - assertThat(result.error, matcher) + assertSame( + expected = IterableError.IterableError1, + actual = result.error + ) + } } - @Test - internal fun `foldRight should return the accumulated value if ok`() { - val result = listOf(2, 5, 10, 20).foldRight( - initial = 100, - operation = { a, b -> Ok(b - a) } - ) + internal class `foldRight` { + @Test + internal fun returnsAccumulatedValueIfOk() { + val result = listOf(2, 5, 10, 20).foldRight( + initial = 100, + operation = { a, b -> Ok(b - a) } + ) - result as Ok + result as Ok - assertThat(result.value, equalTo(63)) - } + assertEquals( + expected = 63, + actual = result.value + ) + } - @Test - internal fun `foldRight should return the last error if not ok`() { - val result = listOf(2, 5, 10, 20, 40).foldRight( - initial = 38500, - operation = { a, b -> - when (b) { - (((38500 / 40) / 20) / 10) -> Err(IterableError.IterableError1) - ((38500 / 40) / 20) -> Err(IterableError.IterableError2) - else -> Ok(b / a) + @Test + internal fun returnsLastErrorIfErr() { + val result = listOf(2, 5, 10, 20, 40).foldRight( + initial = 38500, + operation = { a, b -> + when (b) { + (((38500 / 40) / 20) / 10) -> Err(IterableError.IterableError1) + ((38500 / 40) / 20) -> Err(IterableError.IterableError2) + else -> Ok(b / a) + } } - } - ) + ) - result as Err + result as Err - assertThat(result.error, sameError(IterableError.IterableError2)) + assertSame( + expected = IterableError.IterableError2, + actual = result.error + ) + } } - @Test - internal fun `combine should return the combined list of values if results are ok`() { - val values = combine( - Ok(10), - Ok(20), - Ok(30) - ).get()!! + internal class `combine` { + @Test + internal fun returnsValuesIfAllOk() { + val values = combine( + Ok(10), + Ok(20), + Ok(30) + ).get()!! - assertThat(values.size, equalTo(3)) - assertThat(values[0], equalTo(10)) - assertThat(values[1], equalTo(20)) - assertThat(values[2], equalTo(30)) + assertEquals( + expected = 3, + actual = values.size + ) + + assertEquals( + expected = 10, + actual = values[0] + ) + + assertEquals( + expected = 20, + actual = values[1] + ) + + assertEquals( + expected = 30, + actual = values[2] + ) + } + + @Test + internal fun returnsFirstErrorIfErr() { + val result = combine( + Ok(20), + Ok(40), + Err(IterableError.IterableError1), + Ok(60), + Err(IterableError.IterableError2), + Ok(80) + ) + + result as Err + + assertSame( + expected = IterableError.IterableError1, + actual = result.error + ) + } } - @Test - internal fun `combine should return the first error if results are not ok`() { - val result = combine( - Ok(20), - Ok(40), - Err(IterableError.IterableError1), - Ok(60), - Err(IterableError.IterableError2), - Ok(80) - ) + internal class `getAll` { + @Test + internal fun returnsAllValues() { + val values = getAll( + Ok("hello"), + Ok("big"), + Err(IterableError.IterableError2), + Ok("wide"), + Err(IterableError.IterableError1), + Ok("world") + ) - result as Err + assertEquals( + expected = 4, + actual = values.size + ) - assertThat(result.error, sameError(IterableError.IterableError1)) + assertEquals( + expected = "hello", + actual = values[0] + ) + + assertEquals( + expected = "big", + actual = values[1] + ) + + assertEquals( + expected = "wide", + actual = values[2] + ) + + assertEquals( + expected = "world", + actual = values[3] + ) + } } - @Test - internal fun `getAll should return all of the result values`() { - val values = getAll( - Ok("hello"), - Ok("big"), - Err(IterableError.IterableError2), - Ok("wide"), - Err(IterableError.IterableError1), - Ok("world") - ) + internal class `getAllErrors` { + @Test + internal fun returnsAllErrors() { + val errors = getAllErrors( + Err(IterableError.IterableError2), + Ok("haskell"), + Err(IterableError.IterableError2), + Ok("f#"), + Err(IterableError.IterableError1), + Ok("elm"), + Err(IterableError.IterableError1), + Ok("clojure"), + Err(IterableError.IterableError2) + ) - assertThat(values.size, equalTo(4)) - assertThat(values[0], equalTo("hello")) - assertThat(values[1], equalTo("big")) - assertThat(values[2], equalTo("wide")) - assertThat(values[3], equalTo("world")) + assertEquals( + expected = 5, + actual = errors.size + ) + + assertSame( + expected = IterableError.IterableError2, + actual = errors[0] + ) + + assertSame( + expected = IterableError.IterableError2, + actual = errors[1] + ) + + assertSame( + expected = IterableError.IterableError1, + actual = errors[2] + ) + + assertSame( + expected = IterableError.IterableError1, + actual = errors[3] + ) + + assertSame( + expected = IterableError.IterableError2, + actual = errors[4] + ) + } } - @Test - internal fun `getAllErrors should return all of the result errors`() { - val errors = getAllErrors( - Err(IterableError.IterableError2), - Ok("haskell"), - Err(IterableError.IterableError2), - Ok("f#"), - Err(IterableError.IterableError1), - Ok("elm"), - Err(IterableError.IterableError1), - Ok("clojure"), - Err(IterableError.IterableError2) - ) + internal class `partition` { + @Test + internal fun returnsPairOfValuesAndErrors() { + val pairs = partition( + Err(IterableError.IterableError2), + Ok("haskell"), + Err(IterableError.IterableError2), + Ok("f#"), + Err(IterableError.IterableError1), + Ok("elm"), + Err(IterableError.IterableError1), + Ok("clojure"), + Err(IterableError.IterableError2) + ) - assertThat(errors.size, equalTo(5)) - assertThat(errors[0], sameError(IterableError.IterableError2)) - assertThat(errors[1], sameError(IterableError.IterableError2)) - assertThat(errors[2], sameError(IterableError.IterableError1)) - assertThat(errors[3], sameError(IterableError.IterableError1)) - assertThat(errors[4], sameError(IterableError.IterableError2)) - } + val values = pairs.first - @Test - internal fun `partition should return a pair of all the result values and errors`() { - val pairs = partition( - Err(IterableError.IterableError2), - Ok("haskell"), - Err(IterableError.IterableError2), - Ok("f#"), - Err(IterableError.IterableError1), - Ok("elm"), - Err(IterableError.IterableError1), - Ok("clojure"), - Err(IterableError.IterableError2) - ) + assertEquals( + expected = 4, + actual = values.size + ) - val values = pairs.first - assertThat(values.size, equalTo(4)) - assertThat(values[0], equalTo("haskell")) - assertThat(values[1], equalTo("f#")) - assertThat(values[2], equalTo("elm")) - assertThat(values[3], equalTo("clojure")) + assertEquals( + expected = "haskell", + actual = values[0] + ) - val errors = pairs.second - assertThat(errors.size, equalTo(5)) - assertThat(errors[0], sameError(IterableError.IterableError2)) - assertThat(errors[1], sameError(IterableError.IterableError2)) - assertThat(errors[2], sameError(IterableError.IterableError1)) - assertThat(errors[3], sameError(IterableError.IterableError1)) - assertThat(errors[4], sameError(IterableError.IterableError2)) + assertEquals( + expected = "f#", + actual = values[1] + ) + + assertEquals( + expected = "elm", + actual = values[2] + ) + + assertEquals( + expected = "clojure", + actual = values[3] + ) + + val errors = pairs.second + + assertEquals( + expected = 5, + actual = errors.size + ) + + assertSame( + expected = IterableError.IterableError2, + actual = errors[0] + ) + + assertSame( + expected = IterableError.IterableError2, + actual = errors[1] + ) + + assertSame( + expected = IterableError.IterableError1, + actual = errors[2] + ) + + assertSame( + expected = IterableError.IterableError1, + actual = errors[3] + ) + + assertSame( + expected = IterableError.IterableError2, + actual = errors[4] + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/MapTest.kt b/src/test/kotlin/com/github/michaelbull/result/MapTest.kt index f6495ae..970c9c5 100644 --- a/src/test/kotlin/com/github/michaelbull/result/MapTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/MapTest.kt @@ -1,10 +1,8 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.Matcher -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import com.natpryce.hamkrest.sameInstance -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertSame internal class MapTest { private sealed class MapError(val reason: String) { @@ -13,93 +11,121 @@ internal class MapTest { class CustomError(reason: String) : MapError(reason) } - private fun sameError(error: MapError): Matcher { - return sameInstance(error) + internal class `map` { + @Test + internal fun returnsTransformedValueIfOk() { + assertEquals( + expected = 30, + actual = Ok(10).map { it + 20 }.get() + ) + } + + @Test + @Suppress("UNREACHABLE_CODE") + internal fun returnsErrorIfErr() { + val result = Err(MapError.HelloError).map { "hello $it" } + + result as Err + + assertSame( + expected = MapError.HelloError, + actual = result.error + ) + } } - @Test - internal fun `map should return the transformed result value if ok`() { - val value = Ok(10).map { it + 20 }.get() - assertThat(value, equalTo(30)) - } + internal class `mapError` { + @Test + internal fun returnsValueIfOk() { + val value = Ok(55).map { it + 15 }.mapError { MapError.WorldError }.get() - @Test - @Suppress("UNREACHABLE_CODE") - internal fun `map should return the result error if not ok`() { - val result = Err(MapError.HelloError).map { "hello $it" } + assertEquals( + expected = 70, + actual = value + ) + } - result as Err - - assertThat(result.error, sameError(MapError.HelloError)) - } - - @Test - internal fun `mapError should return the result value if ok`() { - val value = Ok(55).map { it + 15 }.mapError { MapError.WorldError }.get() - assertThat(value, equalTo(70)) - } - - @Test - internal fun `mapError should return the transformed result error if not ok`() { - val result: Result = Ok("let") - .map { "$it me" } - .andThen { - when (it) { - "let me" -> Err(MapError.CustomError("$it $it")) - else -> Ok("$it get") + @Test + internal fun returnsErrorIfErr() { + val result: Result = Ok("let") + .map { "$it me" } + .andThen { + when (it) { + "let me" -> Err(MapError.CustomError("$it $it")) + else -> Ok("$it get") + } } - } - .mapError { MapError.CustomError("${it.reason} get what i want") } + .mapError { MapError.CustomError("${it.reason} get what i want") } - result as Err + result as Err - assertThat(result.error.reason, equalTo("let me let me get what i want")) + assertEquals( + expected = "let me let me get what i want", + actual = result.error.reason + ) + } } - @Test - @Suppress("UNREACHABLE_CODE") - internal fun `mapBoth should return the transformed result value if ok`() { - val value = Ok("there is").mapBoth( - success = { "$it a light" }, - failure = { "$it that never" } - ) + internal class `mapBoth` { + @Test + @Suppress("UNREACHABLE_CODE") + internal fun returnsTransformedValueIfOk() { + val value = Ok("there is").mapBoth( + success = { "$it a light" }, + failure = { "$it that never" } + ) - assertThat(value, equalTo("there is a light")) + assertEquals( + expected = "there is a light", + actual = value + ) + } + + @Test + @Suppress("UNREACHABLE_CODE") + internal fun returnsTransformedErrorIfErr() { + val error = Err(MapError.CustomError("this")).mapBoth( + success = { "$it charming" }, + failure = { "${it.reason} man" } + ) + + assertEquals( + expected = "this man", + actual = error + ) + } } - @Test - @Suppress("UNREACHABLE_CODE") - internal fun `mapBoth should return the transformed result error if not ok`() { - val error = Err(MapError.CustomError("this")).mapBoth( - success = { "$it charming" }, - failure = { "${it.reason} man" } - ) + internal class `mapEither` { + @Test + @Suppress("UNREACHABLE_CODE") + internal fun returnsTransformedValueIfOk() { + val result = Ok(500).mapEither( + success = { it + 500 }, + failure = { MapError.CustomError("$it") } + ) - assertThat(error, equalTo("this man")) - } + result as Ok - @Test - @Suppress("UNREACHABLE_CODE") - internal fun `mapEither should return the transformed result value if ok`() { - val result = Ok(500).mapEither( - success = { it + 500 }, - failure = { MapError.CustomError("$it") } - ) + assertEquals( + expected = 1000, + actual = result.value + ) + } - result as Ok + @Test + internal fun returnsTransformedErrorIfErr() { + val result = Err("the reckless").mapEither( + success = { "the wild youth" }, + failure = { MapError.CustomError("the truth") } + ) - assertThat(result.value, equalTo(1000)) - } + result as Err - @Test - internal fun `mapEither should return the transformed result error if not ok`() { - val result = Err("the reckless").mapEither( - success = { "the wild youth" }, - failure = { MapError.CustomError("the truth") } - ) - - result as Err - - assertThat(result.error.reason, equalTo("the truth")) + assertEquals( + expected = "the truth", + actual = result.error.reason + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/OnTest.kt b/src/test/kotlin/com/github/michaelbull/result/OnTest.kt index 086eedd..005b2a4 100644 --- a/src/test/kotlin/com/github/michaelbull/result/OnTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/OnTest.kt @@ -1,38 +1,61 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals internal class OnTest { object CounterError class Counter(var count: Int) - @Test - internal fun `onSuccess should invoke the callback when result is ok`() { - val counter = Counter(50) - Ok(counter).onSuccess { it.count += 50 } - assertThat(counter.count, equalTo(100)) + internal class `onSuccess` { + @Test + internal fun invokesCallbackIfOk() { + val counter = Counter(50) + + Ok(counter).onSuccess { it.count += 50 } + + assertEquals( + expected = 100, + actual = counter.count + ) + } + + @Test + internal fun invokesNothingIfErr() { + val counter = Counter(200) + + Err(CounterError).onSuccess { counter.count -= 50 } + + assertEquals( + expected = 200, + actual = counter.count + ) + } } - @Test - internal fun `onSuccess should not invoke the callback when result is not ok`() { - val counter = Counter(200) - Err(CounterError).onSuccess { counter.count -= 50 } - assertThat(counter.count, equalTo(200)) - } + internal class `onFailure` { + @Test + internal fun invokesCallbackIfErr() { + val counter = Counter(555) - @Test - internal fun `onFailure should invoke the callback when result is not ok`() { - val counter = Counter(555) - Err(CounterError).onFailure { counter.count += 100 } - assertThat(counter.count, equalTo(655)) - } + Err(CounterError).onFailure { counter.count += 100 } - @Test - internal fun `onFailure should not invoke the callback when result is ok`() { - val counter = Counter(1020) - Ok("hello").onFailure { counter.count = 1030 } - assertThat(counter.count, equalTo(1020)) + assertEquals( + expected = 655, + actual = counter.count + ) + } + + @Test + internal fun invokesNothingIfOk() { + val counter = Counter(1020) + + Ok("hello").onFailure { counter.count = 1030 } + + assertEquals( + expected = 1020, + actual = counter.count + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/OrTest.kt b/src/test/kotlin/com/github/michaelbull/result/OrTest.kt index d8ce59e..c0ad1b1 100644 --- a/src/test/kotlin/com/github/michaelbull/result/OrTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/OrTest.kt @@ -1,33 +1,44 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals internal class OrTest { private object OrError - @Test - internal fun `or should return the result value if ok`() { - val value = Ok(500).or(Ok(1000)).get() - assertThat(value, equalTo(500)) + internal class `or` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = 500, + actual = Ok(500).or(Ok(1000)).get() + ) + } + + @Test + internal fun returnsDefaultValueIfErr() { + assertEquals( + expected = 5000, + actual = Err(OrError).or(Ok(5000)).get() + ) + } } - @Test - internal fun `or should return the default value if not ok`() { - val value = Err(OrError).or(Ok(5000)).get() - assertThat(value, equalTo(5000)) - } + internal class `orElse` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = 3000, + actual = Ok(3000).orElse { Ok(4000) }.get() + ) + } - @Test - internal fun `orElse should return the result value if ok`() { - val value = Ok(3000).orElse { Ok(4000) }.get() - assertThat(value, equalTo(3000)) - } - - @Test - internal fun `orElse should return the transformed value if not ok`() { - val value = Err(4000).orElse { Ok(2000) }.get() - assertThat(value, equalTo(2000)) + @Test + internal fun returnsTransformedValueIfErr() { + assertEquals( + expected = 2000, + actual = Err(4000).orElse { Ok(2000) }.get() + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/ResultIteratorTest.kt b/src/test/kotlin/com/github/michaelbull/result/ResultIteratorTest.kt index bdf23f8..0a3e791 100644 --- a/src/test/kotlin/com/github/michaelbull/result/ResultIteratorTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/ResultIteratorTest.kt @@ -1,69 +1,65 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import org.junit.jupiter.api.Assertions.assertThrows -import org.junit.jupiter.api.Test +import kotlin.test.* internal class ResultIteratorTest { - @Test - internal fun `hasNext should return true if unyielded and result is ok`() { - val iterator = Ok("hello").iterator() - assertThat(iterator.hasNext(), equalTo(true)) - } + internal class `hasNext` { + @Test + internal fun returnsTrueIfUnyieldedAndOk() { + val iterator = Ok("hello").iterator() + assertTrue { iterator.hasNext() } + } - @Test - internal fun `hasNext should return false if result is not ok`() { - val iterator = Err("hello").iterator() - assertThat(iterator.hasNext(), equalTo(false)) - } + @Test + internal fun returnsFalseIfErr() { + val iterator = Err("hello").iterator() + assertFalse { iterator.hasNext() } + } - @Test - internal fun `hasNext should return false if yielded`() { - val iterator = Ok("hello").iterator() - iterator.next() - assertThat(iterator.hasNext(), equalTo(false)) - } - - @Test - internal fun `next should return the result value if unyielded and result is ok`() { - val value = Ok("hello").iterator().next() - assertThat(value, equalTo("hello")) - } - - @Test - internal fun `next should throw NoSuchElementException if unyielded and result is not ok`() { - val iterator = Err("hello").iterator() - - assertThrows(NoSuchElementException::class.java) { + @Test + internal fun returnsFalseIfYielded() { + val iterator = Ok("hello").iterator() iterator.next() + assertFalse { iterator.hasNext() } } } - @Test - internal fun `next should throw NoSuchElementException if yielded and result is ok`() { - val iterator = Ok("hello").iterator() - iterator.next() + internal class `next` { + @Test + internal fun returnsValueIfUnyieldedAndOk() { + assertEquals( + expected = "hello", + actual = Ok("hello").iterator().next() + ) + } - assertThrows(NoSuchElementException::class.java) { + @Test + internal fun throwsExceptionIfUnyieldedAndErr() { + val iterator = Err("hello").iterator() + assertFailsWith { iterator.next() } + } + + @Test + internal fun throwsExceptionIfYieldedAndOk() { + val iterator = Ok("hello").iterator() iterator.next() + assertFailsWith { iterator.next() } } } - @Test - internal fun `remove should make hasNext return false`() { - val iterator = Ok("hello").mutableIterator() - iterator.remove() - assertThat(iterator.hasNext(), equalTo(false)) - } + internal class `remove` { + @Test + internal fun makesHasNextReturnFalse() { + val iterator = Ok("hello").mutableIterator() + iterator.remove() + assertFalse { iterator.hasNext() } + } - @Test - internal fun `remove should make next throw NoSuchElementException`() { - val iterator = Ok("hello").mutableIterator() - iterator.remove() - - assertThrows(NoSuchElementException::class.java) { - iterator.next() + @Test + internal fun makesNextThrowException() { + val iterator = Ok("hello").mutableIterator() + iterator.remove() + assertFailsWith { iterator.next() } } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/ResultTest.kt b/src/test/kotlin/com/github/michaelbull/result/ResultTest.kt index eafc022..dcd574c 100644 --- a/src/test/kotlin/com/github/michaelbull/result/ResultTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/ResultTest.kt @@ -1,25 +1,31 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.Matcher -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import com.natpryce.hamkrest.sameInstance -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertSame internal class ResultTest { - @Test - internal fun `of should return ok if invocation did not throw anything`() { - val callback = { "example" } - val value = Result.of(callback).get() - assertThat(value, equalTo("example")) - } + internal class `of` { + @Test + internal fun returnsOkIfInvocationSuccessful() { + val callback = { "example" } - @Test - internal fun `of should return error if invocation threw something`() { - val throwable = IllegalArgumentException("throw me") - val callback = { throw throwable } - val error = Result.of(callback).getError()!! - val matcher: Matcher = sameInstance(throwable) - assertThat(error, matcher) + assertEquals( + expected = "example", + actual = Result.of(callback).get() + ) + } + + @Test + internal fun returnsErrIfInvocationFails() { + val throwable = IllegalArgumentException("throw me") + val callback = { throw throwable } + val error = Result.of(callback).getError()!! + + assertSame( + expected = throwable, + actual = error + ) + } } } diff --git a/src/test/kotlin/com/github/michaelbull/result/UnwrapTest.kt b/src/test/kotlin/com/github/michaelbull/result/UnwrapTest.kt index 6575790..83cee6c 100644 --- a/src/test/kotlin/com/github/michaelbull/result/UnwrapTest.kt +++ b/src/test/kotlin/com/github/michaelbull/result/UnwrapTest.kt @@ -1,76 +1,83 @@ package com.github.michaelbull.result -import com.natpryce.hamkrest.assertion.assertThat -import com.natpryce.hamkrest.equalTo -import org.junit.jupiter.api.Assertions.assertThrows -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith internal class UnwrapTest { - @Test - internal fun `unwrap should return the result value if ok`() { - val value = Ok(5000).unwrap() - assertThat(value, equalTo(5000)) - } - - @Test - internal fun `unwrap should throw an UnwrapException if not ok`() { - val throwable = assertThrows(UnwrapException::class.java) { - Err(5000).unwrap() + internal class `unwrap` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = 5000, + actual = Ok(5000).unwrap() + ) } - assertThat(throwable.message, equalTo("called Result.wrap on an Err value 5000")) + @Test + internal fun throwsExceptionIfErr() { + assertFailsWith("called Result.wrap on an Err value 5000") { + Err(5000).unwrap() + } + } } - @Test - internal fun `expect should return the result value if ok`() { - val value = Ok(1994).expect { "the year should be" } - assertThat(value, equalTo(1994)) - } - - @Test - internal fun `expect should throw an UnwrapException with a specified message if not ok`() { - val message = object { - override fun toString() = "the year should be" + internal class `expect` { + @Test + internal fun returnsValueIfOk() { + assertEquals( + expected = 1994, + actual = Ok(1994).expect { "the year should be" } + ) } - val throwable = assertThrows(UnwrapException::class.java) { - Err(1994).expect { message } - } + @Test + internal fun throwsExceptionIfErr() { + val message = object { + override fun toString() = "the year should be" + } - assertThat(throwable.message, equalTo("the year should be 1994")) + assertFailsWith("the year should be 1994") { + Err(1994).expect { message } + } + } } - @Test - internal fun `unwrapError should throw an UnwrapException if ok`() { - val throwable = assertThrows(UnwrapException::class.java) { - Ok("example").unwrapError() + internal class `unwrapError` { + @Test + internal fun throwsExceptionIfOk() { + assertFailsWith("called Result.unwrapError on an Ok value example") { + Ok("example").unwrapError() + } } - assertThat(throwable.message, equalTo("called Result.unwrapError on an Ok value example")) + @Test + internal fun returnsErrorIfErr() { + assertEquals( + expected = "example", + actual = Err("example").unwrapError() + ) + } } - @Test - internal fun `unwrapError should return the result error if not ok`() { - val error = Err("example").unwrapError() - assertThat(error, equalTo("example")) - } + internal class `expectError` { + @Test + internal fun throwsExceptionIfOk() { + val message = object { + override fun toString() = "the year should be" + } - @Test - internal fun `expectError should throw an UnwrapException with a specified message if ok`() { - val message = object { - override fun toString() = "the year should be" + assertFailsWith("the year should be 2010") { + Ok(2010).expectError { message } + } } - val throwable = assertThrows(UnwrapException::class.java) { - Ok(2010).expectError { message } + @Test + internal fun returnsErrorIfErr() { + assertEquals( + expected = 2010, + actual = Err(2010).expectError { "the year should be" } + ) } - - assertThat(throwable.message, equalTo("the year should be 2010")) - } - - @Test - internal fun `expectError should return the result error if not ok`() { - val error = Err(2010).expectError { "the year should be" } - assertThat(error, equalTo(2010)) } }