Adding tests for RawIdentifierUtility and MicrosoftBackupSerializer
This commit is contained in:
Logan Girvin
Родитель
527f417c75
Коммит
036bdfcee8
|
|
@ -6,6 +6,4 @@ import kotlinx.serialization.Serializable
|
|||
|
||||
@Serializable
|
||||
@SerialName("BaseVC")
|
||||
abstract class VCMetadata {
|
||||
abstract val displayContract: DisplayContract
|
||||
}
|
||||
open class VCMetadata(val displayContract: DisplayContract)
|
||||
|
|
|
|||
|
|
@ -9,8 +9,10 @@ import com.microsoft.did.sdk.credential.service.models.contracts.display.CardDes
|
|||
import com.microsoft.did.sdk.credential.service.models.contracts.display.ConsentDescriptor
|
||||
import com.microsoft.did.sdk.credential.service.models.contracts.display.DisplayContract
|
||||
import com.microsoft.did.sdk.credential.service.models.contracts.display.Logo
|
||||
import com.microsoft.did.sdk.crypto.keyStore.EncryptedKeyStore
|
||||
import com.microsoft.did.sdk.crypto.protocols.jose.jws.JwsToken
|
||||
import com.microsoft.did.sdk.datasource.file.models.RawIdentity
|
||||
import com.microsoft.did.sdk.datasource.repository.IdentifierRepository
|
||||
import com.microsoft.did.sdk.identifier.models.Identifier
|
||||
import com.nimbusds.jose.JWSAlgorithm
|
||||
import com.nimbusds.jose.JWSHeader
|
||||
|
|
@ -21,6 +23,9 @@ import com.nimbusds.jose.jwk.KeyUse
|
|||
import com.nimbusds.jose.jwk.gen.ECKeyGenerator
|
||||
import com.nimbusds.jose.jwk.gen.RSAKeyGenerator
|
||||
import com.nimbusds.jose.util.Base64URL
|
||||
import io.mockk.coEvery
|
||||
import io.mockk.every
|
||||
import io.mockk.mockk
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
|
||||
|
|
@ -54,7 +59,9 @@ object VerifiableCredentialUtil {
|
|||
)
|
||||
val testVerifiedCredential: VerifiableCredential by lazy {
|
||||
val jws = JwsToken(JWSObject(JWSHeader(JWSAlgorithm.ES256), Payload(Base64URL.encode(Json.Default.encodeToString(testVerifiableCredentialContent)))))
|
||||
jws.sign(signKey)
|
||||
jws.sign(signKey, JWSHeader.Builder(JWSAlgorithm.ES256)
|
||||
.keyID(signKey.keyID)
|
||||
.build())
|
||||
VerifiableCredential(
|
||||
jti,
|
||||
jws.serialize(),
|
||||
|
|
@ -76,4 +83,27 @@ object VerifiableCredentialUtil {
|
|||
"recover",
|
||||
"update"
|
||||
)
|
||||
|
||||
fun getMockKeyStore(): EncryptedKeyStore {
|
||||
val keyStore = mockk<EncryptedKeyStore>();
|
||||
every { keyStore.getKey(VerifiableCredentialUtil.recoverKey.keyID) } returns (VerifiableCredentialUtil.recoverKey)
|
||||
every { keyStore.containsKey(recoverKey.keyID) } returns true
|
||||
every { keyStore.getKey(VerifiableCredentialUtil.updateKey.keyID) } returns (VerifiableCredentialUtil.updateKey)
|
||||
every { keyStore.containsKey(updateKey.keyID) } returns true
|
||||
every { keyStore.getKey(VerifiableCredentialUtil.signKey.keyID) } returns (VerifiableCredentialUtil.signKey)
|
||||
every { keyStore.containsKey(signKey.keyID) } returns true
|
||||
every { keyStore.getKey(VerifiableCredentialUtil.encryptKey.keyID) } returns (VerifiableCredentialUtil.encryptKey)
|
||||
every { keyStore.containsKey(encryptKey.keyID) } returns true
|
||||
every { keyStore.storeKey(any(), any()) } returns (Unit)
|
||||
return keyStore
|
||||
}
|
||||
|
||||
fun getMockIdentifierRepository(): IdentifierRepository {
|
||||
val identifierRepository = mockk<IdentifierRepository>()
|
||||
coEvery { identifierRepository.queryByIdentifier(VerifiableCredentialUtil.testDid) } returns(VerifiableCredentialUtil.testIdentifer)
|
||||
coEvery { identifierRepository.queryAllLocal() } returns(listOf(VerifiableCredentialUtil.testIdentifer))
|
||||
coEvery { identifierRepository.queryByName(VerifiableCredentialUtil.testIdentifer.name)} returns(VerifiableCredentialUtil.testIdentifer)
|
||||
coEvery { identifierRepository.insert(any()) } returns (Unit)
|
||||
return identifierRepository
|
||||
}
|
||||
}
|
||||
|
|
@ -5,48 +5,92 @@ package com.microsoft.did.sdk.datasource.file
|
|||
import android.util.VerifiableCredentialUtil
|
||||
import com.microsoft.did.sdk.credential.models.VerifiableCredential
|
||||
import com.microsoft.did.sdk.crypto.keyStore.EncryptedKeyStore
|
||||
import com.microsoft.did.sdk.datasource.file.models.MicrosoftBackup2020Data
|
||||
import com.microsoft.did.sdk.datasource.file.models.VCMetadata
|
||||
import com.microsoft.did.sdk.datasource.file.models.WalletMetadata
|
||||
import com.microsoft.did.sdk.datasource.repository.IdentifierRepository
|
||||
import com.microsoft.did.sdk.datasource.file.models.MicrosoftUnprotectedBackup2020
|
||||
import com.microsoft.did.sdk.util.defaultTestSerializer
|
||||
import io.mockk.coEvery
|
||||
import io.mockk.coVerify
|
||||
import io.mockk.every
|
||||
import io.mockk.mockk
|
||||
import io.mockk.verify
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import kotlinx.serialization.json.Json
|
||||
import org.junit.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.fail
|
||||
|
||||
class MicrosoftBackupSerializerTest {
|
||||
private val identifierRepository = VerifiableCredentialUtil.getMockIdentifierRepository()
|
||||
private val keyStore = VerifiableCredentialUtil.getMockKeyStore()
|
||||
private val rawIdentifierUtility = RawIdentifierUtility(identifierRepository, keyStore)
|
||||
private val microsoftBackupSerializer = MicrosoftBackupSerializer(
|
||||
identifierRepository,
|
||||
keyStore,
|
||||
rawIdentifierUtility,
|
||||
defaultTestSerializer
|
||||
)
|
||||
|
||||
private val vcMetadata = VCMetadata(VerifiableCredentialUtil.testDisplayContract)
|
||||
private val backupData = MicrosoftBackup2020Data(
|
||||
WalletMetadata(),
|
||||
listOf(Pair(VerifiableCredentialUtil.testVerifiedCredential, vcMetadata))
|
||||
)
|
||||
|
||||
@Test
|
||||
fun importTest() {
|
||||
runBlocking {
|
||||
val rawData = MicrosoftUnprotectedBackup2020(
|
||||
mapOf(
|
||||
"test" to VerifiableCredentialUtil.testVerifiedCredential.raw,
|
||||
),
|
||||
mapOf(
|
||||
"test" to vcMetadata,
|
||||
),
|
||||
WalletMetadata(),
|
||||
listOf(
|
||||
VerifiableCredentialUtil.rawIdentifier
|
||||
)
|
||||
)
|
||||
val actual = microsoftBackupSerializer.import( rawData )
|
||||
assertEquals(
|
||||
backupData.verifiableCredentials,
|
||||
actual.verifiableCredentials
|
||||
)
|
||||
assertTrue(
|
||||
actual.walletMetadata is WalletMetadata
|
||||
)
|
||||
verify {
|
||||
keyStore.containsKey(VerifiableCredentialUtil.signKey.keyID)
|
||||
keyStore.containsKey(VerifiableCredentialUtil.encryptKey.keyID)
|
||||
keyStore.containsKey(VerifiableCredentialUtil.recoverKey.keyID)
|
||||
keyStore.containsKey(VerifiableCredentialUtil.updateKey.keyID)
|
||||
}
|
||||
coVerify {
|
||||
identifierRepository.insert(VerifiableCredentialUtil.testIdentifer)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// @Test
|
||||
// fun importHappyPathTest() {
|
||||
// runBlocking {
|
||||
// val testMetaImportCallback: suspend (WalletMetadata) -> Unit = {
|
||||
// assertEquals(walletMetadata, it, "Wallet metadata does not match")
|
||||
// }
|
||||
// val testVCImportCallback: suspend (VerifiableCredential, VCMetadata) -> Unit = { vc, meta ->
|
||||
// assertEquals(VerifiableCredentialUtil.testVerifiedCredential, vc, "VC doesn't match")
|
||||
// assertEquals(VerifiableCredentialUtil.testDisplayContract, meta.displayContract, "Display contract doesn't match")
|
||||
// }
|
||||
// val testVCListCallback: suspend() -> List<String> = {
|
||||
// emptyList()
|
||||
// }
|
||||
// val testDeleteCallback: suspend(String) -> Unit = {
|
||||
// fail("should not be called")
|
||||
// }
|
||||
// val idRepo: IdentifierRepository = mockk()
|
||||
// coEvery { idRepo.queryAllLocal() } returns ( emptyList() )
|
||||
// coEvery { idRepo.insert(VerifiableCredentialUtil.testIdentifer) } returns(Unit)
|
||||
// val keyStore: EncryptedKeyStore = mockk()
|
||||
// every { keyStore.containsKey(any()) } returns(false)
|
||||
// every { keyStore.storeKey(VerifiableCredentialUtil.signKey, "sign") } returns(Unit)
|
||||
// every { keyStore.storeKey(VerifiableCredentialUtil.updateKey, "update") } returns(Unit)
|
||||
// every { keyStore.storeKey(VerifiableCredentialUtil.recoverKey, "recover") } returns(Unit)
|
||||
// every { keyStore.storeKey(VerifiableCredentialUtil.encryptKey, "encrypt") } returns(Unit)
|
||||
// backup.import(testMetaImportCallback, testVCImportCallback, testVCListCallback, testDeleteCallback, idRepo, keyStore, Json)
|
||||
// }
|
||||
// }
|
||||
@Test
|
||||
fun createTest() {
|
||||
runBlocking {
|
||||
val actual = microsoftBackupSerializer.create(backupData)
|
||||
coVerify {
|
||||
identifierRepository.queryAllLocal()
|
||||
}
|
||||
assertTrue(actual.metaInf is WalletMetadata)
|
||||
assertEquals(1, actual.vcs.size)
|
||||
assertEquals(VerifiableCredentialUtil.testVerifiedCredential.raw,
|
||||
actual.vcs.values.first())
|
||||
assertEquals(1, actual.vcsMetaInf.size)
|
||||
assertEquals(vcMetadata, actual.vcsMetaInf.values.first())
|
||||
assertEquals(1, actual.identifiers.size)
|
||||
assertEquals(VerifiableCredentialUtil.rawIdentifier.id,
|
||||
actual.identifiers.first().id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
package com.microsoft.did.sdk.datasource.file
|
||||
|
||||
import android.util.VerifiableCredentialUtil
|
||||
import com.microsoft.did.sdk.crypto.keyStore.EncryptedKeyStore
|
||||
import com.microsoft.did.sdk.datasource.file.models.RawIdentity
|
||||
import com.microsoft.did.sdk.datasource.repository.IdentifierRepository
|
||||
|
|
@ -18,82 +19,36 @@ import kotlinx.coroutines.runBlocking
|
|||
import org.junit.Test
|
||||
import java.util.Base64
|
||||
import kotlin.random.Random
|
||||
import kotlin.test.BeforeTest
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class RawIdentiiferUtilityTest {
|
||||
private val expectedId = "did:example: ${Base64.getEncoder().encodeToString(Random.nextBytes(8))}"
|
||||
private val expectedName = Base64.getEncoder().encodeToString(Random.nextBytes(8))
|
||||
private val recoverKeyRef = "recover"
|
||||
private val updateKeyRef = "update"
|
||||
private val signKeyRef = "sign"
|
||||
private val encryptKeyRef = "encrypt"
|
||||
private val identifierRepository = VerifiableCredentialUtil.getMockIdentifierRepository()
|
||||
private val keyStore = VerifiableCredentialUtil.getMockKeyStore()
|
||||
private val rawIdentifierUtility = RawIdentifierUtility(identifierRepository, keyStore)
|
||||
|
||||
private val recoveryKey = mockk<JWK>()
|
||||
private val updateKey = mockk<JWK>()
|
||||
private val signatureKey = mockk<JWK>()
|
||||
private val encryptionKey = mockk<JWK>()
|
||||
private val identifierRepository = mockk<IdentifierRepository>()
|
||||
private val keyStore = mockk<EncryptedKeyStore>()
|
||||
|
||||
init {
|
||||
every { recoveryKey.keyID } returns(recoverKeyRef)
|
||||
every { recoveryKey.toJSONObject() } returns(mapOf<String, String>("kid" to recoverKeyRef))
|
||||
every { keyStore.getKey(recoverKeyRef) } returns (recoveryKey)
|
||||
every { updateKey.keyID } returns(updateKeyRef)
|
||||
every { updateKey.toJSONObject() } returns(mapOf<String, String>("kid" to updateKeyRef))
|
||||
every { keyStore.getKey(updateKeyRef) } returns (updateKey)
|
||||
every { signatureKey.keyID } returns(signKeyRef)
|
||||
every { signatureKey.toJSONObject() } returns(mapOf<String, String>("kid" to signKeyRef))
|
||||
every { keyStore.getKey(signKeyRef) } returns (signatureKey)
|
||||
every { encryptionKey.keyID } returns(encryptKeyRef)
|
||||
every { encryptionKey.toJSONObject() } returns(mapOf<String, String>("kid" to encryptKeyRef))
|
||||
every { keyStore.getKey(encryptKeyRef) } returns (encryptionKey)
|
||||
mockkStatic(JWK::class)
|
||||
every { JWK.parse( allAny<Map<String, Any>>() ) } answers {
|
||||
val obj = it.invocation.args.first() as Map<String, Any>
|
||||
val out = mockk<JWK>()
|
||||
|
||||
// why is there a crazy amount of conversion code here? Because I don't want to bother JWK to use real keys.
|
||||
val kid = obj["kid"] as String?
|
||||
val use = when(obj["use"]) {
|
||||
"enc" -> KeyUse.ENCRYPTION
|
||||
"sig" -> KeyUse.SIGNATURE
|
||||
else -> null
|
||||
}
|
||||
val ops = (obj["key_ops"] as? List<String>)?.mapNotNull { op -> when (op) {
|
||||
KeyOperation.UNWRAP_KEY.identifier() -> KeyOperation.UNWRAP_KEY
|
||||
KeyOperation.WRAP_KEY.identifier() -> KeyOperation.WRAP_KEY
|
||||
KeyOperation.ENCRYPT.identifier() -> KeyOperation.ENCRYPT
|
||||
KeyOperation.DECRYPT.identifier() -> KeyOperation.DECRYPT
|
||||
KeyOperation.SIGN.identifier() -> KeyOperation.SIGN
|
||||
KeyOperation.VERIFY.identifier() -> KeyOperation.VERIFY
|
||||
KeyOperation.DERIVE_BITS.identifier() -> KeyOperation.DERIVE_BITS
|
||||
KeyOperation.DERIVE_KEY.identifier() -> KeyOperation.DERIVE_KEY
|
||||
else -> null
|
||||
} }?.toSet()
|
||||
every { out.keyID } returns(kid)
|
||||
every { out.keyUse } returns(use)
|
||||
every { out.keyOperations } returns(ops)
|
||||
out
|
||||
}
|
||||
coEvery { identifierRepository.queryByIdentifier(expectedId) } returns( Identifier(
|
||||
expectedId,
|
||||
signKeyRef,
|
||||
encryptKeyRef,
|
||||
recoverKeyRef,
|
||||
updateKeyRef,
|
||||
expectedName
|
||||
))
|
||||
@Test
|
||||
fun parseRawIdentifierTest() {
|
||||
val actual = rawIdentifierUtility.parseRawIdentifier(VerifiableCredentialUtil.rawIdentifier)
|
||||
assertEquals(VerifiableCredentialUtil.testIdentifer, actual.first)
|
||||
assertEquals(4, actual.second.size, "expected four distinct keys")
|
||||
assertTrue(actual.second.contains(VerifiableCredentialUtil.encryptKey))
|
||||
assertTrue(actual.second.contains(VerifiableCredentialUtil.signKey))
|
||||
assertTrue(actual.second.contains(VerifiableCredentialUtil.updateKey))
|
||||
assertTrue(actual.second.contains(VerifiableCredentialUtil.recoverKey))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun getIdentiferKeysTest() {
|
||||
|
||||
fun getAllIdentifiersTest() {
|
||||
runBlocking {
|
||||
val actual = rawIdentifierUtility.getAllIdentifiers()
|
||||
assertEquals(1, actual.size, "expected one DID")
|
||||
assertEquals(VerifiableCredentialUtil.rawIdentifier.id, actual[0].id)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// @Test
|
||||
// fun didToRawIdentifierTest() {
|
||||
// runBlocking {
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ import com.microsoft.did.sdk.credential.models.VerifiableCredential
|
|||
import com.microsoft.did.sdk.credential.service.models.contracts.display.DisplayContract
|
||||
import com.microsoft.did.sdk.crypto.keyStore.EncryptedKeyStore
|
||||
import com.microsoft.did.sdk.datasource.repository.IdentifierRepository
|
||||
import com.microsoft.did.sdk.di.defaultTestSerializer
|
||||
import io.mockk.coEvery
|
||||
import io.mockk.every
|
||||
import io.mockk.mockk
|
||||
|
|
@ -19,24 +20,21 @@ import kotlinx.serialization.modules.polymorphic
|
|||
import kotlinx.serialization.modules.subclass
|
||||
import org.junit.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.fail
|
||||
|
||||
class MicrosoftUnprotectedBackup2020Test {
|
||||
private val walletMetadata = WalletMetadata()
|
||||
|
||||
@Serializable
|
||||
@SerialName("TestVCMetadata")
|
||||
private class TestVCMetadata(override val displayContract: DisplayContract) : VCMetadata() {}
|
||||
private val vcMetadata = TestVCMetadata(
|
||||
private val vcMetadata = VCMetadata(
|
||||
VerifiableCredentialUtil.testDisplayContract
|
||||
)
|
||||
private val rawId = VerifiableCredentialUtil.rawIdentifier
|
||||
|
||||
private val backup = MicrosoftUnprotectedBackup2020(
|
||||
mapOf("test" to VerifiableCredentialUtil.testVerifiedCredential.raw),
|
||||
mapOf("test" to vcMetadata),
|
||||
walletMetadata,
|
||||
listOf(rawId)
|
||||
listOf(VerifiableCredentialUtil.rawIdentifier)
|
||||
)
|
||||
|
||||
@Test
|
||||
|
|
@ -46,10 +44,8 @@ class MicrosoftUnprotectedBackup2020Test {
|
|||
|
||||
@Test
|
||||
fun vcsToIteratorTest() {
|
||||
val iterator = backup.vcsToIterator( Json { SerializersModule {
|
||||
polymorphic(VCMetadata::class) {
|
||||
subclass(TestVCMetadata::class)
|
||||
}
|
||||
} } )
|
||||
val iterator = backup.vcsToIterator( defaultTestSerializer )
|
||||
assertTrue(iterator.hasNext())
|
||||
assertEquals(iterator.next(), Pair(VerifiableCredentialUtil.testVerifiedCredential, vcMetadata))
|
||||
}
|
||||
}
|
||||
|
|
@ -5,4 +5,4 @@ package com.microsoft.did.sdk.util
|
|||
import com.microsoft.did.sdk.di.SdkModule
|
||||
|
||||
// Keep in sync with `fun defaultJsonSerializer()` in SdkModule
|
||||
val defaultTestSerializer = SdkModule().defaultJsonSerializer()
|
||||
val defaultTestSerializer = SdkModule().defaultJsonSerializer();
|
||||
Загрузка…
Ссылка в новой задаче