[UNTIL-12364] Manager classes test

payment-engine/src/main/java/de/tillhub/paymentengine/CardManagerImpl.kt

@@ -12,7 +12,7 @@ internal abstract class CardManagerImpl(
     )
 ) : CardManager {
 
-    protected val defaultConfig: Terminal by lazy {
+    internal val defaultConfig: Terminal by lazy {
         Terminal.ZVT()
     }
 

payment-engine/src/main/java/de/tillhub/paymentengine/ConnectionManager.kt

@@ -25,18 +25,16 @@ interface ConnectionManager : CardManager {
 internal class ConnectionManagerImpl(
     configs: MutableMap<String, Terminal>,
     terminalState: MutableStateFlow<TerminalOperationStatus>,
-    resultCaller: ActivityResultCaller
-) : CardManagerImpl(configs, terminalState), ConnectionManager {
-
+    resultCaller: ActivityResultCaller,
     private val connectContract: ActivityResultLauncher<Terminal> =
         resultCaller.registerForActivityResult(TerminalConnectContract()) { result ->
             terminalState.tryEmit(result)
-        }
-
+        },
     private val disconnectContract: ActivityResultLauncher<Terminal> =
         resultCaller.registerForActivityResult(TerminalDisconnectContract()) { result ->
             terminalState.tryEmit(result)
         }
+) : CardManagerImpl(configs, terminalState), ConnectionManager {
 
     override fun startSPOSConnect() {
         val configName = configs.values.firstOrNull()?.name.orEmpty()

payment-engine/src/main/java/de/tillhub/paymentengine/PaymentManager.kt

@@ -21,13 +21,15 @@ interface PaymentManager : CardManager {
         tip: BigDecimal = BigDecimal.ZERO,
         currency: ISOAlphaCurrency
     )
+
     fun startPaymentTransaction(
         transactionId: String,
         amount: BigDecimal,
         tip: BigDecimal = BigDecimal.ZERO,
         currency: ISOAlphaCurrency,
         configName: String
     )
+
     fun startPaymentTransaction(
         transactionId: String,
         amount: BigDecimal,
@@ -40,13 +42,12 @@ interface PaymentManager : CardManager {
 internal class PaymentManagerImpl(
     configs: MutableMap<String, Terminal>,
     terminalState: MutableStateFlow<TerminalOperationStatus>,
-    resultCaller: ActivityResultCaller
-) : CardManagerImpl(configs, terminalState), PaymentManager {
-
+    resultCaller: ActivityResultCaller,
     private val paymentResultContract: ActivityResultLauncher<PaymentRequest> =
         resultCaller.registerForActivityResult(PaymentResultContract()) { result ->
             terminalState.tryEmit(result)
         }
+) : CardManagerImpl(configs, terminalState), PaymentManager {
 
     override fun startPaymentTransaction(
         transactionId: String,

payment-engine/src/main/java/de/tillhub/paymentengine/ReconciliationManager.kt

@@ -20,13 +20,12 @@ interface ReconciliationManager : CardManager {
 internal class ReconciliationManagerImpl(
     configs: MutableMap<String, Terminal>,
     terminalState: MutableStateFlow<TerminalOperationStatus>,
-    resultCaller: ActivityResultCaller
-) : CardManagerImpl(configs, terminalState), ReconciliationManager {
-
+    resultCaller: ActivityResultCaller,
     private val reconciliationContract: ActivityResultLauncher<Terminal> =
         resultCaller.registerForActivityResult(TerminalReconciliationContract()) { result ->
             terminalState.tryEmit(result)
         }
+) : CardManagerImpl(configs, terminalState), ReconciliationManager {
 
     override fun startReconciliation() {
         val configName = configs.values.firstOrNull()?.name.orEmpty()

payment-engine/src/main/java/de/tillhub/paymentengine/ReversalManager.kt

@@ -44,14 +44,13 @@ interface ReversalManager : CardManager {
 
 internal class ReversalManagerImpl(
     configs: MutableMap<String, Terminal>,
-    transactionState: MutableStateFlow<TerminalOperationStatus>,
-    resultCaller: ActivityResultCaller
-) : CardManagerImpl(configs, transactionState), ReversalManager {
-
+    terminalState: MutableStateFlow<TerminalOperationStatus>,
+    resultCaller: ActivityResultCaller,
     private val reversalContract: ActivityResultLauncher<ReversalRequest> =
         resultCaller.registerForActivityResult(PaymentReversalContract()) { result ->
             terminalState.tryEmit(result)
         }
+) : CardManagerImpl(configs, terminalState), ReversalManager {
 
     override fun startReversalTransaction(
         transactionId: String,
@@ -66,8 +65,8 @@ internal class ReversalManagerImpl(
             amount = amount,
             tip = tip,
             currency = currency,
-            configName = receiptNo,
-            receiptNo = configName
+            configName = configName,
+            receiptNo = receiptNo
         )
     }
 
@@ -86,7 +85,7 @@ internal class ReversalManagerImpl(
             tip = tip,
             currency = currency,
             config = terminalConfig,
-            receiptNo = configName
+            receiptNo = receiptNo
         )
     }
 

payment-engine/src/test/java/de/tillhub/paymentengine/CardManagerTest.kt

@@ -0,0 +1,42 @@
+package de.tillhub.paymentengine
+
+import de.tillhub.paymentengine.data.Terminal
+import de.tillhub.paymentengine.data.TerminalOperationStatus
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.mockk
+import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+
+@ExperimentalCoroutinesApi
+class CardManagerTest : FunSpec({
+
+    lateinit var configs: MutableMap<String, Terminal>
+    lateinit var terminalState: MutableStateFlow<TerminalOperationStatus>
+    lateinit var target: CardManagerImpl
+
+    beforeAny {
+        configs = mockk(relaxed = true)
+        terminalState = spyk(MutableStateFlow(TerminalOperationStatus.Waiting))
+
+        target = object : CardManagerImpl(configs, terminalState) {}
+    }
+
+    test("putTerminalConfig should add terminal to the configs map") {
+        val terminal = Terminal.OPI()
+        target.putTerminalConfig(terminal)
+        verify { configs[terminal.name] = terminal }
+    }
+
+    test("observePaymentState should return the terminal state flow") {
+        val result = target.observePaymentState()
+        result shouldBe terminalState
+    }
+
+    test("defaultConfig should return default Terminal configuration") {
+        val defaultTerminal = target.defaultConfig
+        defaultTerminal shouldBe Terminal.ZVT()
+    }
+})

payment-engine/src/test/java/de/tillhub/paymentengine/ConnectionManagerTest.kt

@@ -0,0 +1,111 @@
+package de.tillhub.paymentengine
+
+import androidx.activity.result.ActivityResultCaller
+import androidx.activity.result.ActivityResultLauncher
+import de.tillhub.paymentengine.contract.TerminalConnectContract
+import de.tillhub.paymentengine.contract.TerminalDisconnectContract
+import de.tillhub.paymentengine.data.Terminal
+import de.tillhub.paymentengine.data.TerminalOperationStatus
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+
+@ExperimentalCoroutinesApi
+class ConnectionManagerTest : FunSpec({
+
+    lateinit var configs: MutableMap<String, Terminal>
+    lateinit var terminalState: MutableStateFlow<TerminalOperationStatus>
+    lateinit var resultCaller: ActivityResultCaller
+    lateinit var connectContract: ActivityResultLauncher<Terminal>
+    lateinit var disconnectContract: ActivityResultLauncher<Terminal>
+
+    lateinit var target: ConnectionManager
+
+    beforeAny {
+        configs = mutableMapOf()
+        terminalState = spyk(MutableStateFlow(TerminalOperationStatus.Waiting))
+        resultCaller = mockk(relaxed = true)
+        connectContract = mockk(relaxed = true)
+        disconnectContract = mockk(relaxed = true)
+
+        every {
+            resultCaller.registerForActivityResult(ofType(TerminalConnectContract::class), any())
+        } returns connectContract
+        every {
+            resultCaller.registerForActivityResult(any<TerminalDisconnectContract>(), any())
+        } returns disconnectContract
+
+        target = ConnectionManagerImpl(
+            configs = configs,
+            terminalState = terminalState,
+            resultCaller = resultCaller,
+            connectContract = connectContract,
+            disconnectContract = disconnectContract
+        )
+    }
+
+    test("startSPOSConnect by default terminal ") {
+        target.startSPOSConnect()
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Connecting
+
+        verify { terminalState.tryEmit(TerminalOperationStatus.Pending.Connecting) }
+        verify { connectContract.launch(Terminal.ZVT()) }
+    }
+
+    test("startSPOSConnect by config name") {
+        val terminal = Terminal.OPI()
+        configs["opi"] = terminal
+        target.startSPOSConnect("opi")
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Connecting
+
+        verify { terminalState.tryEmit(TerminalOperationStatus.Pending.Connecting) }
+        verify { connectContract.launch(terminal) }
+    }
+
+    test("startSPOSConnect by terminal") {
+        val terminal = Terminal.SPOS()
+        target.startSPOSConnect(terminal)
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Connecting
+
+        verify { terminalState.tryEmit(TerminalOperationStatus.Pending.Connecting) }
+        verify { connectContract.launch(terminal) }
+    }
+
+    test("startSPOSDisconnect by default terminal ") {
+        target.startSPOSDisconnect()
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Disconnecting
+
+        verify { terminalState.tryEmit(TerminalOperationStatus.Pending.Disconnecting) }
+        verify { disconnectContract.launch(Terminal.ZVT()) }
+    }
+
+    test("startSPOSDisconnect by config name") {
+        val terminal = Terminal.OPI()
+        configs["opi"] = terminal
+        target.startSPOSDisconnect("opi")
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Disconnecting
+
+        verify { terminalState.tryEmit(TerminalOperationStatus.Pending.Disconnecting) }
+        verify { disconnectContract.launch(terminal) }
+    }
+
+    test("startSPOSDisconnect by terminal") {
+        val terminal = Terminal.SPOS()
+        target.startSPOSDisconnect(terminal)
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Disconnecting
+
+        verify { terminalState.tryEmit(TerminalOperationStatus.Pending.Disconnecting) }
+        verify { disconnectContract.launch(terminal) }
+    }
+})

payment-engine/src/test/java/de/tillhub/paymentengine/PaymentManagerTest.kt

@@ -0,0 +1,119 @@
+package de.tillhub.paymentengine
+
+import androidx.activity.result.ActivityResultCaller
+import androidx.activity.result.ActivityResultLauncher
+import de.tillhub.paymentengine.contract.PaymentRequest
+import de.tillhub.paymentengine.contract.PaymentResultContract
+import de.tillhub.paymentengine.data.ISOAlphaCurrency
+import de.tillhub.paymentengine.data.Terminal
+import de.tillhub.paymentengine.data.TerminalOperationStatus
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import java.math.BigDecimal
+
+@ExperimentalCoroutinesApi
+class PaymentManagerTest : FunSpec({
+
+    lateinit var configs: MutableMap<String, Terminal>
+    lateinit var terminalState: MutableStateFlow<TerminalOperationStatus>
+    lateinit var resultCaller: ActivityResultCaller
+    lateinit var paymentResultContract: ActivityResultLauncher<PaymentRequest>
+
+    lateinit var target: PaymentManager
+
+    beforeEach {
+        configs = mutableMapOf()
+        terminalState = spyk(MutableStateFlow(TerminalOperationStatus.Waiting))
+        resultCaller = mockk(relaxed = true)
+        paymentResultContract = mockk(relaxed = true)
+
+        every {
+            resultCaller.registerForActivityResult(ofType(PaymentResultContract::class), any())
+        } returns paymentResultContract
+
+        target = PaymentManagerImpl(
+            configs = configs,
+            terminalState = terminalState,
+            resultCaller = resultCaller,
+            paymentResultContract = paymentResultContract
+        )
+    }
+
+    test("startPaymentTransaction should use default config when no configName provided") {
+        val transactionId = "tx789"
+        val amount = BigDecimal(300)
+        val tip = BigDecimal(30)
+        val currency = ISOAlphaCurrency("EUR")
+
+        target.startPaymentTransaction(transactionId, amount, tip, currency)
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Payment(amount, currency)
+
+        verify {
+            paymentResultContract.launch(
+                match {
+                    it.transactionId == transactionId &&
+                            it.amount == amount &&
+                            it.tip == tip &&
+                            it.currency == currency &&
+                            it.config == Terminal.ZVT()
+                }
+            )
+        }
+    }
+
+    test("startPaymentTransaction with configName should launch payment result contract") {
+        val transactionId = "tx456"
+        val amount = BigDecimal(200)
+        val tip = BigDecimal(20)
+        val currency = ISOAlphaCurrency("EUR")
+        val terminal = Terminal.OPI()
+        configs["opi"] = terminal
+
+        target.startPaymentTransaction(transactionId, amount, tip, currency, "opi")
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Payment(amount, currency)
+
+        verify {
+            paymentResultContract.launch(
+                match {
+                    it.transactionId == transactionId &&
+                            it.amount == amount &&
+                            it.tip == tip &&
+                            it.currency == currency &&
+                            it.config == terminal
+                }
+            )
+        }
+    }
+
+    test("startPaymentTransaction with Terminal should launch payment result contract") {
+        val transactionId = "tx123"
+        val amount = BigDecimal(100)
+        val tip = BigDecimal(10)
+        val currency = ISOAlphaCurrency("EUR")
+        val terminal = Terminal.SPOS()
+
+        target.startPaymentTransaction(transactionId, amount, tip, currency, terminal)
+
+        terminalState.value shouldBe TerminalOperationStatus.Pending.Payment(amount, currency)
+
+        verify {
+            paymentResultContract.launch(
+                match {
+                    it.transactionId == transactionId &&
+                            it.amount == amount &&
+                            it.tip == tip &&
+                            it.currency == currency &&
+                            it.config == terminal
+                }
+            )
+        }
+    }
+})