JEP votes

Author: madhead

.deploy/lambda/lib/JProfByBotStack.ts

@@ -1,13 +1,21 @@
 import * as cdk from '@aws-cdk/core';
-import { Duration } from '@aws-cdk/core';
+import { Duration, RemovalPolicy } from '@aws-cdk/core';
 import { JProfByBotStackProps } from './JProfByBotStackProps';
-import lambda = require('@aws-cdk/aws-lambda');
-import apigateway = require('@aws-cdk/aws-apigateway');
+import * as dynamodb from '@aws-cdk/aws-dynamodb';
+import * as lambda from '@aws-cdk/aws-lambda';
+import * as apigateway from '@aws-cdk/aws-apigateway';
 
 export class JProfByBotStack extends cdk.Stack {
   constructor(scope: cdk.Construct, id: string, props: JProfByBotStackProps) {
     super(scope, id, props);
 
+    const votesTable = new dynamodb.Table(this, 'jprof-by-bot-table-votes', {
+      tableName: 'jprof-by-bot-table-votes',
+      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+      removalPolicy: RemovalPolicy.DESTROY,
+    });
+
     const lambdaWebhook = new lambda.Function(this, 'jprof-by-bot-lambda-webhook', {
       functionName: 'jprof-by-bot-lambda-webhook',
       runtime: lambda.Runtime.JAVA_11,
@@ -17,9 +25,13 @@ export class JProfByBotStack extends cdk.Stack {
       handler: 'by.jprof.telegram.bot.runners.lambda.JProf',
       environment: {
         'LOG_THRESHOLD': 'DEBUG',
+        'TABLE_VOTES': votesTable.tableName,
+        'TELEGRAM_BOT_TOKEN': props.telegramToken,
       },
     });
 
+    votesTable.grantReadWriteData(lambdaWebhook);
+
     const api = new apigateway.RestApi(this, 'jprof-by-bot-api', {
       restApiName: 'jprof-by-bot-api',
       cloudWatchRole: false,

.deploy/lambda/package-lock.json

@@ -19,6 +19,7 @@
   },
   "dependencies": {
     "@aws-cdk/aws-apigateway": "1.100.0",
+    "@aws-cdk/aws-dynamodb": "1.100.0",
     "@aws-cdk/aws-lambda": "1.100.0",
     "@aws-cdk/core": "1.100.0",
     "source-map-support": "^0.5.16"

.deploy/lambda/package.json

@@ -78,5 +78,5 @@ jobs:
       - run: ls -laR
       - uses: mikepenz/action-junit-report@v2
         with:
-          report_paths: 'test-results/**/TEST-*.xml'
+          report_paths: '**/test-results/**/TEST-*.xml'
           github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/default.yml

@@ -35,8 +35,8 @@ jobs:
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: eu-west-2
-      - run: npx cdk deploy -O cdk.out/outputs.json
+          aws-region: us-east-1
+      - run: npx cdk deploy --outputs-file=cdk.out/outputs.json --require-approval=never
         working-directory: .deploy/lambda
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}

.github/workflows/deploy.yml

@@ -5,4 +5,9 @@ plugins {
 dependencies {
     api(libs.bundles.tgbotapi)
     implementation(libs.log4j.api)
+
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.log4j.core)
 }

core/build.gradle.kts

@@ -1,15 +1,11 @@
 package by.jprof.telegram.bot.core
 
 import dev.inmo.tgbotapi.types.update.abstracts.Update
-import kotlinx.coroutines.CoroutineExceptionHandler
-import kotlinx.coroutines.joinAll
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.supervisorScope
+import kotlinx.coroutines.*
 import org.apache.logging.log4j.LogManager
 
 class UpdateProcessingPipeline(
-        private val processors: List<UpdateProcessor>
+    private val processors: List<UpdateProcessor>
 ) {
     companion object {
         private val logger = LogManager.getLogger(UpdateProcessingPipeline::class.java)!!
@@ -18,8 +14,8 @@ class UpdateProcessingPipeline(
     fun process(update: Update) = runBlocking {
         supervisorScope {
             processors
-                    .map { launch(exceptionHandler(it)) { it.process(update) } }
-                    .joinAll()
+                .map { launch(exceptionHandler(it)) { it.process(update) } }
+                .joinAll()
         }
     }
 

core/src/main/kotlin/by/jprof/telegram/bot/core/UpdateProcessingPipeline.kt

@@ -0,0 +1,65 @@
+package by.jprof.telegram.bot.core
+
+import dev.inmo.tgbotapi.types.update.abstracts.UnknownUpdate
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+import kotlinx.coroutines.delay
+import kotlinx.serialization.json.JsonNull
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+import java.time.Duration
+import java.util.concurrent.atomic.AtomicBoolean
+
+internal class UpdateProcessingPipelineTest {
+    @Test
+    fun process() {
+        val completionFlags = (1..5).map { AtomicBoolean(false) }
+        val sut = UpdateProcessingPipeline(
+            completionFlags.mapIndexed { index, atomicBoolean ->
+                Delay((index + 1) * 1000L, atomicBoolean)
+            }
+        )
+
+        Assertions.assertTimeout(Duration.ofMillis(6000)) {
+            sut.process(UnknownUpdate(1L, "", JsonNull))
+        }
+        Assertions.assertTrue(completionFlags.all { it.get() })
+    }
+
+    @Test
+    fun processWithBroken() {
+        val completionFlags = (1..5).map { AtomicBoolean(false) }
+        val sut = UpdateProcessingPipeline(
+            completionFlags.mapIndexed { index, atomicBoolean ->
+                when (index % 2) {
+                    0 -> Delay((index + 1) * 1000L, atomicBoolean)
+                    else -> Fail()
+                }
+            }
+        )
+
+        Assertions.assertTimeout(Duration.ofMillis(6000)) {
+            sut.process(UnknownUpdate(1L, "", JsonNull))
+        }
+        completionFlags.forEachIndexed { index, atomicBoolean ->
+            if (index % 2 == 0) {
+                Assertions.assertTrue(atomicBoolean.get())
+            }
+        }
+    }
+}
+
+internal class Delay(
+    private val delay: Long,
+    private val completionFlag: AtomicBoolean
+) : UpdateProcessor {
+    override suspend fun process(update: Update) {
+        delay(delay)
+        completionFlag.set(true)
+    }
+}
+
+internal class Fail : UpdateProcessor {
+    override suspend fun process(update: Update) {
+        throw IllegalArgumentException()
+    }
+}

core/src/test/kotlin/by/jprof/telegram/bot/core/UpdateProcessingPipelineTest.kt

@@ -12,10 +12,13 @@ jackson = "2.12.3"
 
 tgbotapi = "0.33.3"
 
+jsoup = "1.13.1"
+
 log4j = "2.14.1"
 
 junit5 = "5.7.1"
 aws-junit5 = "6.0.1"
+mockk = "1.11.0"
 
 [libraries]
 kotlinx-coroutines-jdk8 = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-jdk8", version.ref = "coroutines" }
@@ -30,6 +33,9 @@ koin-core = { group = "io.insert-koin", name = "koin-core", version.ref = "koin"
 jackson-databind = { group = "com.fasterxml.jackson.core", name = "jackson-databind", version.ref = "jackson" }
 
 tgbotapi-core = { group = "dev.inmo", name = "tgbotapi.core", version.ref = "tgbotapi" }
+tgbotapi-extensions-api = { group = "dev.inmo", name = "tgbotapi.extensions.api", version.ref = "tgbotapi" }
+
+jsoup = { group = "org.jsoup", name = "jsoup", version.ref = "jsoup" }
 
 log4j-api = { group = "org.apache.logging.log4j", name = "log4j-api", version.ref = "log4j" }
 log4j-core = { group = "org.apache.logging.log4j", name = "log4j-core", version.ref = "log4j" }
@@ -39,8 +45,9 @@ junit-jupiter-api = { group = "org.junit.jupiter", name = "junit-jupiter-api", v
 junit-jupiter-params = { group = "org.junit.jupiter", name = "junit-jupiter-params", version.ref = "junit5" }
 junit-jupiter-engine = { group = "org.junit.jupiter", name = "junit-jupiter-engine", version.ref = "junit5" }
 aws-junit5-dynamo-v2 = { group = "me.madhead.aws-junit5", name = "dynamo-v2", version.ref = "aws-junit5" }
+mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" }
 
 [bundles]
-tgbotapi = ["tgbotapi-core"]
+tgbotapi = ["tgbotapi-core", "tgbotapi-extensions-api"]
 log4j = ["log4j-core", "log4j-slf4j-impl"]
 aws-lambda = ["aws-lambda-java-events", "aws-lambda-java-core", "aws-lambda-java-log4j2", "jackson-databind"]

gradle/libs.versions.toml

@@ -0,0 +1,17 @@
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    api(project(":core"))
+    api(project(":votes"))
+    implementation(project(":votes:tgbotapi-extensions"))
+    implementation(libs.log4j.api)
+    implementation(libs.jsoup)
+
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+    testImplementation(libs.mockk)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.log4j.core)
+}