Multiplatform

assertions/build.gradle.kts

@@ -1,10 +1,24 @@
 plugins {
-    buildsrc.convention.`kotlin-jvm`
-    buildsrc.convention.`publish-jvm`
+    buildsrc.convention.`kotlin-multiplatform`
+    buildsrc.convention.`kotlin-multiplatform-jvm`
+    buildsrc.convention.`kotlin-multiplatform-js-web`
+    buildsrc.convention.`kotlin-multiplatform-js-node`
+    buildsrc.convention.`publish-multiplatform`
 }
 
-dependencies {
-    api(projects.htmlParser)
-    api(projects.dsl)
-    api(projects.fetcher.baseFetcher)
-}
+kotlin {
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                api(projects.htmlParser)
+                api(projects.dsl)
+                api(projects.fetcher)
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(Deps.Kotest.datatest)
+            }
+        }
+    }
+}

assertions/src/main/kotlin/it/skrape/matchers/Assertions.kt → assertions/src/commonMain/kotlin/it/skrape/matchers/Assertions.kt

@@ -1,8 +1,8 @@
 package it.skrape.matchers
 
-import it.skrape.fetcher.Result
+import io.ktor.http.*
 
-public fun Result.Status.statusAssertion(value: Boolean, status: Result.Status): Result.Status {
+public fun HttpStatusCode.statusAssertion(value: Boolean, status: HttpStatusCode): HttpStatusCode {
     return this.also { generalAssertion(value, status) }
 }
 

assertions/src/commonMain/kotlin/it/skrape/matchers/ContentTypeHeaderMatchers.kt

@@ -0,0 +1,41 @@
+package it.skrape.matchers
+
+import io.ktor.http.*
+
+infix fun ContentType?.toMatch(expected: ContentType?): ContentType? =
+    this.apply {
+        generalAssertion(
+            this == expected
+                    || (this != null && expected?.match(this.withWildcardParameter()) == true)
+                    || (expected != null && this?.match(expected.withWildcardParameter()) == true)
+                , expected)
+    }
+
+infix fun ContentType?.toMatch(expected: String): ContentType? = toMatch(ContentType.parse(expected))
+
+infix fun ContentType?.toBeExactly(expected: ContentType?): ContentType? =
+    this.apply { generalAssertion(this == expected, expected) }
+
+infix fun ContentType?.toBeExactly(expected: String): ContentType? = toBeExactly(ContentType.parse(expected))
+
+infix fun ContentType?.notToMatch(expected: ContentType?): ContentType? =
+    this.apply {
+        generalAssertion(
+            (this != expected
+                    && (this != null && expected?.match(this.withWildcardParameter()) == false)) && !this.match(expected.withWildcardParameter())
+            , expected)
+    }
+
+infix fun ContentType?.notToMatch(expected: String): ContentType? = notToMatch(ContentType.parse(expected))
+
+infix fun ContentType?.notToBe(expected: ContentType?): ContentType? =
+    this.apply { generalAssertion(this != expected, expected) }
+
+infix fun ContentType?.notToBe(expected: String): ContentType? = notToBe(ContentType.parse(expected))
+
+fun ContentType.withWildcardParameter(ifEmpty: Boolean = true) =
+    if (!ifEmpty || parameters.isEmpty()) {
+        withParameter("*","*")
+    } else {
+        this
+    }

assertions/src/commonMain/kotlin/it/skrape/matchers/StatusMatchers.kt

@@ -0,0 +1,57 @@
+@file:Suppress("FunctionName", "EnumEntryName")
+
+package it.skrape.matchers
+
+import io.ktor.http.*
+import kotlin.js.JsName
+
+
+private val informationalResponse = HttpStatusCode(1, "Informational Response")
+private val successful = HttpStatusCode(2, "Successful")
+private val redirection = HttpStatusCode(3, "Redirection")
+private val clientError = HttpStatusCode(4, "Client Error")
+private val serverError = HttpStatusCode(5, "Server Error")
+private val groupStatusCodes = listOf(informationalResponse, successful, redirection, clientError, serverError)
+
+val HttpStatusCode.Companion.InformationalResponse
+    get() = informationalResponse
+val HttpStatusCode.Companion.Successful
+    get() = successful
+val HttpStatusCode.Companion.Redirection
+    get() = redirection
+val HttpStatusCode.Companion.ClientError
+    get() = clientError
+val HttpStatusCode.Companion.ServerError
+    get() = serverError
+
+val HttpStatusCode.Companion.allGroupStatusCodes
+    get() = groupStatusCodes
+
+public infix fun HttpStatusCode.toBe(expected: HttpStatusCode): HttpStatusCode {
+    @Suppress("MagicNumber")
+    if (expected.value <= 5) {
+        return statusAssertion(this.value / 100 == expected.value, expected)
+    }
+    return statusAssertion(this == expected && this.description == expected.description, expected)
+}
+
+public infix fun HttpStatusCode.toBeExactly(expected: HttpStatusCode): HttpStatusCode {
+    if (expected.value > 5) statusAssertion(description == expected.description, expected)
+    return toBe(expected)
+}
+
+public infix fun HttpStatusCode.notToBe(expected: HttpStatusCode): HttpStatusCode {
+    @Suppress("MagicNumber")
+    if (expected.value <= 5) {
+        return statusAssertion(this.value / 100 != expected.value, expected)
+    }
+    return statusAssertion(this != expected, expected)
+}
+
+public infix fun HttpStatusCode.notToBeExactly(expected: HttpStatusCode): HttpStatusCode {
+    @Suppress("MagicNumber")
+    if (expected.value <= 5) {
+        return statusAssertion(this.value / 100 != expected.value || this.description != expected.description, expected)
+    }
+    return statusAssertion(this.value != expected.value || this.description != expected.description, expected)
+}

assertions/src/commonTest/kotlin/it/skrape/matchers/ContentTypeHeaderMatchersKtTest.kt

@@ -0,0 +1,44 @@
+package it.skrape.matchers
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.datatest.withData
+import io.kotest.matchers.shouldBe
+import io.ktor.http.*
+
+class ContentTypeHeaderMatchersKtTest : FunSpec({
+
+    val contentTypeWildcards = mapOf(
+        ContentType.Application.Any to listOf(ContentType.Application.Json, ContentType.Application.GZip),
+        ContentType.Audio.Any to listOf(ContentType.Audio.MP4, ContentType.Audio.OGG)
+    ).flatMap { entry -> entry.value.map { entry.key to it } }
+
+    withData(
+        nameFn = { "can match partial wildcard type ${it.first} to ${it.second} " },
+        contentTypeWildcards
+    ) { contentType ->
+        contentType.first toMatch contentType.second
+        ContentType.Any toMatch contentType.second
+    }
+
+    test("does not match on null") {
+        null notToBe ContentType.Any
+        ContentType.Any notToBe null
+    }
+
+    test("will not match nulls") {
+        shouldThrow<AssertionError> {
+            null toBeExactly ContentType.Any
+        }
+        shouldThrow<AssertionError> {
+            null toMatch ContentType.Any
+        }
+        shouldThrow<AssertionError> {
+            ContentType.Any toBeExactly null
+        }
+        shouldThrow<AssertionError> {
+            ContentType.Any toMatch null
+        }
+    }
+
+})