taler-android

AndroidTalerUsbTransportTest.kt (6320B)

---

 /*
  * This file is part of GNU Taler
  * (C) 2026 Taler Systems S.A.
  *
  * GNU Taler is free software; you can redistribute it and/or modify it under the
  * terms of the GNU General Public License as published by the Free Software
  * Foundation; either version 3, or (at your option) any later version.
  *
  * GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
  */
 
 package net.taler.merchantpos.devices
 
 import android.app.Application
 import android.content.Context
 import android.hardware.usb.UsbDevice
 import android.hardware.usb.UsbDeviceConnection
 import android.hardware.usb.UsbManager
 
 import androidx.test.core.app.ApplicationProvider
 
 import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
 import org.robolectric.annotation.Implementation
 import org.robolectric.annotation.Implements
 import org.robolectric.util.ReflectionHelpers
 
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [28], application = Application::class, shadows = [RecordingUsbConnection::class])
 class AndroidTalerUsbTransportTest
 {
     private lateinit var manager: UsbManager
     private lateinit var transport: AndroidTalerUsbTransport
 
     @Before
     fun setup()
     {
         val context = ApplicationProvider.getApplicationContext<Context>()
         manager = context.getSystemService(Context.USB_SERVICE) as UsbManager
         transport = AndroidTalerUsbTransport(manager)
         RecordingUsbConnection.calls.clear()
         RecordingUsbConnection.closed = 0
         RecordingUsbConnection.result = null
         RecordingUsbConnection.fail = false
     }
 
     @Test
     fun `enumerates only the supported device and reports actual USB permission`()
     {
         attach("taler", permitted = false)
         attach("other", vendor = 0x1234)
         assertEquals(listOf(TalerUsbDevice("taler", false)), transport.devices())
     }
 
     @Test
     fun `sends exact vendor request and UTF8 bytes then closes connection`()
     {
         attach("taler")
         val bytes = "taler://pay/example/é".toByteArray(Charsets.UTF_8)
         assertTrue(transport.write(transport.devices().single(), bytes))
         val call = RecordingUsbConnection.calls.single()
         assertEquals(listOf(0x40, 0, 0, 0, bytes.size, 1000), call.parameters)
         assertArrayEquals(bytes, call.bytes)
         assertEquals(1, RecordingUsbConnection.closed)
     }
 
     @Test
     fun `short writes and negative responses fail and close the connection`()
     {
         attach("taler")
         val device = transport.devices().single()
         RecordingUsbConnection.result = 2
         assertFalse(transport.write(device, ByteArray(5)))
         RecordingUsbConnection.result = -1
         assertFalse(transport.write(device, ByteArray(5)))
         assertEquals(2, RecordingUsbConnection.closed)
     }
 
     @Test
     fun `empty URL uses a zero length transfer without adding serial newline`()
     {
         attach("taler")
         assertTrue(transport.write(transport.devices().single(), byteArrayOf()))
         assertEquals(
             0,
             RecordingUsbConnection.calls
                 .single()
                 .bytes.size,
         )
     }
 
     @Test
     fun `permission is rechecked immediately before opening the device`()
     {
         val attached = attach("taler")
         val snapshot = transport.devices().single()
         shadowOf(manager).addOrUpdateUsbDevice(attached, false)
         assertFalse(transport.write(snapshot, byteArrayOf(1)))
         assertTrue(RecordingUsbConnection.calls.isEmpty())
     }
 
     @Test
     fun `unplugged or unsupported devices are never opened`()
     {
         val attached = attach("taler")
         val snapshot = transport.devices().single()
         shadowOf(manager).removeUsbDevice(attached)
         assertFalse(transport.write(snapshot, byteArrayOf(1)))
         attach("taler", vendor = 0x1234)
         assertFalse(transport.write(snapshot, byteArrayOf(1)))
         assertTrue(RecordingUsbConnection.calls.isEmpty())
     }
 
     @Test
     fun `connection closes when a transfer throws`()
     {
         attach("taler")
         RecordingUsbConnection.fail = true
         try
         {
             transport.write(transport.devices().single(), byteArrayOf(1))
             fail("Expected transfer failure")
         }
         catch (_: IllegalStateException)
         {
             assertEquals(1, RecordingUsbConnection.closed)
         }
     }
 
     private fun attach(
         name: String,
         vendor: Int = 0xd00d,
         permitted: Boolean = true,
     ): UsbDevice
     {
         val device = ReflectionHelpers.newInstance(UsbDevice::class.java)
         ReflectionHelpers.setField(device, "mName", name)
         ReflectionHelpers.setField(device, "mVendorId", vendor)
         ReflectionHelpers.setField(device, "mProductId", 0x8f71)
         shadowOf(manager).addOrUpdateUsbDevice(device, permitted)
         return device
     }
 }
 
 @Implements(UsbDeviceConnection::class)
 class RecordingUsbConnection
 {
     data class Call(
         val parameters: List<Int>,
         val bytes: ByteArray,
     )
 
     companion object
     {
         val calls = mutableListOf<Call>()
         var closed = 0
         var result: Int? = null
         var fail = false
     }
 
     @Implementation
     fun controlTransfer(
         type: Int,
         request: Int,
         value: Int,
         index: Int,
         buffer: ByteArray,
         length: Int,
         timeout: Int,
     ): Int
     {
         if (fail) throw IllegalStateException("USB disconnected")
         calls += Call(listOf(type, request, value, index, length, timeout), buffer.copyOf(length))
         return result ?: length
     }
 
     @Implementation
     fun close()
     {
         closed++
     }
 }