Urban Dictionary HTTP client

Author: madhead

.github/workflows/default.yml

@@ -70,6 +70,27 @@ jobs:
             **/build/test-results
             **/build/reports
 
+  integration-test:
+    name: Integration test
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          java-version: 11
+          distribution: adopt
+      - uses: gradle/gradle-build-action@v2
+        with:
+          arguments: clean integrationTest
+          cache-read-only: ${{ github.ref != 'refs/heads/master' }}
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: test-results
+          path: |
+            **/build/test-results
+            **/build/reports
+
   cdk-test:
     name: CDK test
     runs-on: ubuntu-20.04
@@ -106,6 +127,7 @@ jobs:
     needs:
       - test
       - db-test
+      - integration-test
       - cdk-test
     if: always()
     steps:
@@ -117,10 +139,12 @@ jobs:
           report_paths: |-
             **/test-results/test/TEST-*.xml
             **/test-results/dbTest/TEST-*.xml
+            **/test-results/integrationTest/TEST-*.xml
             **/junit.xml
           check_name: |-
             Test reports
             DB test reports
+            Integration test reports
             CDK test reports
           include_passed: true
           github_token: ${{ secrets.GITHUB_TOKEN }}

build.gradle.kts

@@ -32,7 +32,7 @@ subprojects {
         }
         withType<Test> {
             useJUnitPlatform {
-                excludeTags("db")
+                excludeTags("db", "it")
             }
             testLogging {
                 showStandardStreams = true

english/urban-dictionary/README.adoc

@@ -0,0 +1,3 @@
+= English / Urban Dictionary
+
+https://urbandictionary.com[Urban Dictionary] client.

english/urban-dictionary/build.gradle.kts

@@ -0,0 +1,31 @@
+plugins {
+    kotlin("jvm")
+    kotlin("plugin.serialization")
+}
+
+dependencies {
+    implementation(platform(libs.ktor.bom))
+
+    implementation(libs.ktor.client.apache)
+    implementation(libs.ktor.client.content.negotiation)
+    implementation(libs.ktor.serialization.kotlinx.json)
+    implementation(libs.log4j.api)
+
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+    testImplementation(libs.mockk)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.log4j.core)
+}
+
+tasks {
+    val integrationTest by registering(Test::class) {
+        group = LifecycleBasePlugin.VERIFICATION_GROUP
+        description = "Runs the integration tests."
+        shouldRunAfter("test")
+        outputs.upToDateWhen { false }
+        useJUnitPlatform {
+            includeTags("it")
+        }
+    }
+}

english/urban-dictionary/src/main/kotlin/by/jprof/telegram/bot/english/urban_dictionary/Definition.kt

@@ -0,0 +1,17 @@
+package by.jprof.telegram.bot.english.urban_dictionary
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Definition(
+    val definition: String,
+    val permalink: String,
+    val author: String,
+    val word: String,
+    val example: String,
+    @SerialName("thumbs_up")
+    val thumbsUp: Int,
+    @SerialName("thumbs_down")
+    val thumbsDown: Int,
+)

english/urban-dictionary/src/main/kotlin/by/jprof/telegram/bot/english/urban_dictionary/KtorUrbanDictionaryClient.kt

@@ -0,0 +1,47 @@
+package by.jprof.telegram.bot.english.urban_dictionary
+
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.engine.apache.Apache
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.request.get
+import io.ktor.client.request.parameter
+import io.ktor.client.request.url
+import io.ktor.serialization.kotlinx.json.json
+import java.io.Closeable
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+class KtorUrbanDictionaryClient(
+    private val baseUrl: String = "https://api.urbandictionary.com/v0"
+) : UrbanDictionaryClient, Closeable {
+    private val client = HttpClient(Apache) {
+        install(ContentNegotiation) {
+            json(
+                Json {
+                    ignoreUnknownKeys = true
+                }
+            )
+        }
+    }
+
+    override suspend fun define(term: String): Collection<Definition> =
+        client.get {
+            url("$baseUrl/define")
+            parameter("term", term)
+        }.body<UrbanDictionaryResponse>().list
+
+    override suspend fun random(): Collection<Definition> =
+        client.get {
+            url("$baseUrl/random")
+        }.body<UrbanDictionaryResponse>().list
+
+    override fun close() {
+        client.close()
+    }
+
+    @Serializable
+    private data class UrbanDictionaryResponse(
+        val list: List<Definition>
+    )
+}

english/urban-dictionary/src/main/kotlin/by/jprof/telegram/bot/english/urban_dictionary/UrbanDictionaryClient.kt

@@ -0,0 +1,7 @@
+package by.jprof.telegram.bot.english.urban_dictionary
+
+interface UrbanDictionaryClient {
+    suspend fun define(term: String): Collection<Definition>
+
+    suspend fun random(): Collection<Definition>
+}

english/urban-dictionary/src/test/kotlin/by/jprof/telegram/bot/english/urban_dictionary/KtorUrbanDictionaryClientIntegrationTest.kt

@@ -0,0 +1,33 @@
+package by.jprof.telegram.bot.english.urban_dictionary
+
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+
+@Tag("it")
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+internal class KtorUrbanDictionaryClientIntegrationTest {
+    private lateinit var sut: KtorUrbanDictionaryClient
+
+    @BeforeAll
+    internal fun setup() {
+        sut = KtorUrbanDictionaryClient()
+    }
+
+    @Test
+    fun define() = runBlocking {
+        val definitions = sut.define("motherfucker")
+
+        assertTrue(definitions.isNotEmpty())
+    }
+
+    @Test
+    fun random() = runBlocking {
+        val definitions = sut.random()
+
+        assertTrue(definitions.isNotEmpty())
+    }
+}

settings.gradle.kts

@@ -36,4 +36,5 @@ include(":times")
 include(":english")
 include(":english:language-rooms")
 include(":english:language-rooms:dynamodb")
+include(":english:urban-dictionary")
 include(":launchers:lambda")