From ee01f7e6abd2e97491b42ad8bba383e6c3b9b5a9 Mon Sep 17 00:00:00 2001 From: Mircea Nistor Date: Fri, 20 Mar 2020 21:25:40 +0100 Subject: [PATCH 1/3] refactor: bump assertk to 0.22 & apply fixes --- build.gradle | 18 ++++----- .../UniversalStatusResolverTests.kt | 9 +++-- .../test/java/me/uport/sdk/ethrdid/DDOTest.kt | 3 +- .../uport/sdk/ethrdid/EthrDIDResolverTest.kt | 16 ++++---- .../me/uport/sdk/ethrdid/RegistryMapTest.kt | 7 +++- .../ethr_status/EthrStatusResolverTests.kt | 4 +- .../sdk/ethr_status/ParseRegistryIdTests.kt | 4 +- .../test/EthrDidDocumentTestHelpersTest.kt | 4 +- .../java/me/uport/sdk/jwt/JWTDecodeTest.kt | 16 ++++---- .../java/me/uport/sdk/jwt/JWTToolsJVMTest.kt | 30 +++++++------- .../java/me/uport/sdk/jwt/TimestampTests.kt | 40 ++++++++++++------- .../sdk/universaldid/DIDResolverImplTest.kt | 6 ++- .../sdk/universaldid/UniversalDIDTest.kt | 6 ++- .../uport/sdk/httpsdid/WebDIDResolverTest.kt | 6 ++- 14 files changed, 103 insertions(+), 66 deletions(-) diff --git a/build.gradle b/build.gradle index f96dc71..80a2b62 100644 --- a/build.gradle +++ b/build.gradle @@ -3,13 +3,13 @@ buildscript { ext { - kotlin_version = '1.3.70' - kotlin_serialization_version = '0.20.0' + kotlin_version = "1.3.70" + kotlin_serialization_version = "0.20.0" coroutines_version = "1.3.5" junit_version = "4.12" mockk_version = "1.9.3" - assertk_version = "0.13" + assertk_version = "0.22" detekt_version = "1.0.0-RC14" jacoco_version = "0.8.4" @@ -22,7 +22,7 @@ buildscript { khash_version = "1.0.0-RC5" kbase58_version = "0.1" spongycastle_version = "1.58.0.0" - uport_kotlin_common_version = "0.4.2" + uport_kotlin_common_version = "0.4.3" current_release_version = "0.3.5" } @@ -73,7 +73,7 @@ detekt { allprojects { - apply plugin: 'jacoco' + apply plugin: "jacoco" jacoco { toolVersion = jacoco_version @@ -82,7 +82,7 @@ allprojects { repositories { google() jcenter() - maven { url 'https://jitpack.io' } + maven { url "https://jitpack.io" } maven { url "https://kotlin.bintray.com/kotlinx" } // mavenLocal() } @@ -96,9 +96,9 @@ allprojects { } resolutionStrategy.eachDependency { DependencyResolveDetails details -> def requested = details.requested - if (requested.group == 'org.jetbrains.kotlin' && requested.name in [ - 'kotlin-reflect', 'kotlin-stdlib', 'kotlin-stdlib-common', - 'kotlin-stdlib-jdk7', 'kotlin-stdlib-jdk8', + if (requested.group == "org.jetbrains.kotlin" && requested.name in [ + "kotlin-reflect", "kotlin-stdlib", "kotlin-stdlib-common", + "kotlin-stdlib-jdk7", "kotlin-stdlib-jdk8", ]) { details.useVersion kotlin_version } diff --git a/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt b/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt index 2334bd6..289f153 100644 --- a/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt +++ b/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt @@ -2,8 +2,10 @@ package me.uport.sdk.credential_status +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlinx.coroutines.runBlocking import me.uport.credential_status.CredentialStatus @@ -58,9 +60,10 @@ class UniversalStatusResolverTests { coAssert { UniversalStatusResolver().checkStatus( "eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NkstUiJ9.eyJpYXQiOjE1NzMwNDczNTEsInN0YXR1cyI6eyJ0eXBlIjoiRXRoclN0YXR1c1JlZ2lzdHJ5MjAxOSIsImlkIjoicmlua2VieToweDFFNDY1MWRjYTVFZjM4NjM2ZTJFNEQ3QTZGZjRkMjQxM2ZDNTY0NTAifSwiaXNzIjoiZGlkOmV0aHI6MHgxZmNmOGZmNzhhYzUxMTdkOWM5OWI4MzBjNzRiNjY2OGQ2YWMzMjI5In0.MHabafA0UxJuQJ0Z-7Egb57WRlgj4_zf96B0LUhRyXgVDU5RABIczTTTXWjcuKVzhJc_-FuhRI8uQYmQQNxKzgA" - , didDoc + , + didDoc ) - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalStateException::class) } } @@ -74,7 +77,7 @@ class UniversalStatusResolverTests { "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c", didDoc ) - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt index 301f577..53196fa 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt @@ -2,6 +2,7 @@ package me.uport.sdk.ethrdid import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isSuccess import org.junit.Test class DDOTest { @@ -35,7 +36,7 @@ class DDOTest { assertThat { EthrDIDDocument.fromJson(docText) - }.doesNotThrowAnyException() + }.isSuccess() } diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt index aeb4696..039a8d4 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt @@ -9,12 +9,14 @@ import assertk.assertions.hasMessage import assertk.assertions.hasSize import assertk.assertions.isEmpty import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isGreaterThan import assertk.assertions.isInstanceOf import assertk.assertions.isNotEmpty import assertk.assertions.isNotEqualTo import assertk.assertions.isNotNull +import assertk.assertions.isSuccess import assertk.assertions.isTrue import io.mockk.coEvery import io.mockk.mockk @@ -398,7 +400,7 @@ class EthrDIDResolverTest { .addNetwork(EthrDIDNetwork("", "0xregistry", rpc)) .build() .wrapDidDocument("did:ethr:$identity", owner, listOf(event)) - }.doesNotThrowAnyException() + }.isSuccess() } @Test @@ -606,7 +608,7 @@ class EthrDIDResolverTest { coAssert { val ddo = resolver.resolve("did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a") assertThat(ddo).isEqualTo(referenceDDO) - }.doesNotThrowAnyException() + }.isSuccess() } @Test @@ -706,7 +708,7 @@ class EthrDIDResolverTest { coAssert { val ddo = resolver.resolve("did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a") assertThat(ddo).isEqualTo(referenceDDO) - }.doesNotThrowAnyException() + }.isSuccess() } @Test @@ -715,7 +717,7 @@ class EthrDIDResolverTest { coAssert { resolver.resolve("did:ethr:unknown:0xb9c5714089478a327f09197987f16f9e5d936e8a") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) hasMessage("Missing registry configuration for `unknown`. To resolve did:ethr:unknown:0x... you need to register an `EthrDIDNetwork` in the EthrDIDResolver.Builder") } @@ -813,7 +815,7 @@ class EthrDIDResolverTest { .build() coAssert { resolver.resolve("did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } @@ -845,7 +847,7 @@ class EthrDIDResolverTest { owner = "did:ethr:0xE6Fe788d8ca214A080b0f6aC7F48480b2AEfa9a6", publicKeyHex = "0x0295dda1dca7f80e308ef60155ddeac00e46b797fd40ef407f422e88d2467a27eb" ) - ) to emptyMap() + ) to emptyMap() ) } @@ -861,7 +863,7 @@ class EthrDIDResolverTest { .addNetwork(EthrDIDNetwork("", "0xregistry", rpc, "0x1")).build() coAssert { resolver.lastChanged("0xb9c5714089478a327f09197987f16f9e5d936e8a", rpc, "0xregistry") - }.thrownError { + }.isFailure().all { isInstanceOf(DidResolverError::class) } } diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/RegistryMapTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/RegistryMapTest.kt index c0173ca..8f4e852 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/RegistryMapTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/RegistryMapTest.kt @@ -1,8 +1,11 @@ package me.uport.sdk.ethrdid +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf +import assertk.assertions.isSuccess import me.uport.sdk.jsonrpc.JsonRPC import org.junit.Test @@ -49,7 +52,7 @@ class RegistryMapTest { assertThat { val unused = tested[""].registryAddress - }.doesNotThrowAnyException() + }.isSuccess() } @Test @@ -60,7 +63,7 @@ class RegistryMapTest { assertThat { val unused = tested["0x6123"] - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } diff --git a/ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt b/ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt index 0a7b186..8854980 100644 --- a/ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt +++ b/ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt @@ -2,8 +2,10 @@ package me.uport.sdk.ethr_status +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlinx.coroutines.runBlocking import me.uport.sdk.ethrdid.EthrDIDDocument @@ -86,7 +88,7 @@ class EthrStatusResolverTests { "eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NkstUiJ9.eyJpYXQiOjE1NzI5NjY3ODAsInN0YXR1cyI6eyJ0eXBlIjoidW5rbm93biIsImlkIjoic29tZXRoaW5nIHNvbWV0aGluZyJ9LCJpc3MiOiJkaWQ6ZXRocjoweGYzYmVhYzMwYzQ5OGQ5ZTI2ODY1ZjM0ZmNhYTU3ZGJiOTM1YjBkNzQifQ.WO4kUEYy3xzZR1VlofOm3e39e1XM227uIr-Z7Yb9YQcJJ-2PRcnQmecW5fDjIfF3EInS3rRd4TZmuVQOnhaKQAE\n" coAssert { ethrStatus.checkStatus(token, didDoc) - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalStateException::class) } } diff --git a/ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt b/ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt index bf15a67..d1c3715 100644 --- a/ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt +++ b/ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt @@ -2,8 +2,10 @@ package me.uport.sdk.ethr_status +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import org.junit.Test @@ -57,7 +59,7 @@ class ParseRegistryIdTests { invalidRegistryIDs.forEach { assertThat { ethrStatus.parseRegistryId(it) - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } diff --git a/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt b/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt index 2b06975..8e04d92 100644 --- a/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt +++ b/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt @@ -1,7 +1,9 @@ package me.uport.sdk.jwt.test +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import me.uport.sdk.ethrdid.EthrDIDDocument import me.uport.sdk.universaldid.AuthenticationEntry @@ -127,7 +129,7 @@ class EthrDIDTestHelpersTest { fun `throws error when given improper input`() { assertThat { EthrDIDTestHelpers.mockDocForAddress("bla bla") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } diff --git a/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt index 05a520a..819cd15 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt @@ -1,8 +1,10 @@ package me.uport.sdk.jwt +import assertk.all import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import me.uport.sdk.jwt.JWTUtils.Companion.splitToken import org.junit.Test @@ -39,13 +41,13 @@ class JWTDecodeTest { @Test fun `throws when splitting empty token`() { assertThat { splitToken("") } - .thrownError { isInstanceOf(IllegalArgumentException::class) } + .isFailure().all { isInstanceOf(IllegalArgumentException::class) } } @Test fun `throws when splitting incomplete token`() { assertThat { splitToken(invalidTokenOnlyHeader) } - .thrownError { isInstanceOf(IllegalArgumentException::class) } + .isFailure().all { isInstanceOf(IllegalArgumentException::class) } } @Test @@ -68,13 +70,13 @@ class JWTDecodeTest { @Test fun `throws when decoding incomplete token`() { assertThat { JWTTools().decode((invalidTokenEmptyPayload)) } - .thrownError { + .isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Payload cannot be empty") } assertThat { JWTTools().decode((invalidTokenEmptyHeader)) } - .thrownError { + .isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Header cannot be empty") } @@ -83,17 +85,17 @@ class JWTDecodeTest { @Test fun `throws on random token parts`() { assertThat { JWTTools().decode("blahhh.blahhh.blahhh") } - .thrownError { + .isFailure().all { isInstanceOf(InvalidJWTException::class) } assertThat { JWTTools().decode("$validTokenHeader.blahhh.blahhh") } - .thrownError { + .isFailure().all { isInstanceOf(InvalidJWTException::class) } assertThat { JWTTools().decode("blahhh.$validShareReqTokenPayload.blahhh") } - .thrownError { + .isFailure().all { isInstanceOf(InvalidJWTException::class) } diff --git a/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt index 145a2ad..fe9d017 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt @@ -1,7 +1,9 @@ package me.uport.sdk.jwt +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull @@ -209,7 +211,7 @@ class JWTToolsJVMTest { signer, algorithm = "some fancy but unknown algorithm" ) - }.thrownError { + }.isFailure().all { isInstanceOf(JWTEncodingException::class) } } @@ -235,7 +237,7 @@ class JWTToolsJVMTest { JWTTools(TestTimeProvider(1535102500000L)).verify( token = token ) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -263,7 +265,7 @@ class JWTToolsJVMTest { token = token, resolver = resolver ) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -290,7 +292,7 @@ class JWTToolsJVMTest { token = token, audience = "did:ethr:0x108209f4247b7fe6605b0f58f9145ec3269d0154" ) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -319,7 +321,7 @@ class JWTToolsJVMTest { resolver = resolver, audience = "did:ethr:0x108209f4247b7fe6605b0f58f9145ec3269d0154" ) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -335,7 +337,7 @@ class JWTToolsJVMTest { coAssert { JWTTools(TestTimeProvider(977317692000L)).verify(token) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -353,7 +355,7 @@ class JWTToolsJVMTest { coAssert { JWTTools(TestTimeProvider(977317692000L)).verify(token, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -369,7 +371,7 @@ class JWTToolsJVMTest { coAssert { JWTTools(TestTimeProvider(1576847292000L)).verify(token) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -387,7 +389,7 @@ class JWTToolsJVMTest { coAssert { JWTTools(TestTimeProvider(1576847292000L)).verify(token, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -412,7 +414,7 @@ class JWTToolsJVMTest { coAssert { JWTTools(TestTimeProvider(1547818630000L)).verify(token) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -438,7 +440,7 @@ class JWTToolsJVMTest { coAssert { JWTTools(TestTimeProvider(1547818630000L)).verify(token, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -577,7 +579,7 @@ class JWTToolsJVMTest { coAssert { JWTTools().resolveAuthenticator(alg, issuer, auth, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -617,7 +619,7 @@ class JWTToolsJVMTest { coAssert { JWTTools().resolveAuthenticator(alg, issuer, auth, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) } } @@ -651,7 +653,7 @@ class JWTToolsJVMTest { coAssert { JWTTools().resolveAuthenticator(alg, issuer, auth, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(JWTEncodingException::class) } } diff --git a/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt b/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt index 4171371..88752a1 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt @@ -1,9 +1,12 @@ package me.uport.sdk.jwt +import assertk.all import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf +import assertk.assertions.isSuccess import io.mockk.coEvery import io.mockk.mockk import io.mockk.spyk @@ -58,7 +61,8 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } @Test @@ -89,7 +93,8 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } @Deprecated( @@ -108,7 +113,8 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } @Test @@ -139,7 +145,8 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } @Deprecated( @@ -158,7 +165,7 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Jwt not valid before nbf: $FUTURE") } @@ -182,7 +189,7 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Jwt not valid before nbf: $FUTURE") } @@ -204,7 +211,7 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Jwt not valid before nbf: $FUTURE") } @@ -228,7 +235,7 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Jwt not valid before nbf: $FUTURE") } @@ -250,7 +257,9 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + + Unit } @Test @@ -281,7 +290,8 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } @Suppress("DEPRECATION") @@ -297,7 +307,7 @@ class TimestampTests { coAssert { tested.verify(jwt) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Jwt not valid yet (issued in the future) iat: $FUTURE") } @@ -321,7 +331,7 @@ class TimestampTests { coAssert { tested.verify(jwt, resolver) - }.thrownError { + }.isFailure().all { isInstanceOf(InvalidJWTException::class) hasMessage("Jwt not valid yet (issued in the future) iat: $FUTURE") } @@ -338,7 +348,8 @@ class TimestampTests { val tested = JWTTools(TestTimeProvider(NOW)) coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } @Test @@ -365,6 +376,7 @@ class TimestampTests { val tested = JWTTools(TestTimeProvider(NOW)) coAssert { tested.verify(jwt, resolver) - }.doesNotThrowAnyException() + }.isSuccess() + Unit } } diff --git a/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt b/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt index a159975..4caac89 100644 --- a/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt +++ b/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt @@ -1,8 +1,10 @@ package me.uport.sdk.universaldid +import assertk.all import assertk.assertThat import assertk.assertions.isEmpty import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlinx.coroutines.runBlocking import me.uport.sdk.testhelpers.coAssert @@ -36,7 +38,7 @@ class DIDResolverImplTest { coAssert { resolver.resolve("") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } @@ -50,7 +52,7 @@ class DIDResolverImplTest { coAssert { resolver.resolve("") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } diff --git a/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt b/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt index b4f75d9..af9169b 100644 --- a/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt +++ b/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt @@ -1,8 +1,10 @@ package me.uport.sdk.universaldid +import assertk.all import assertk.assertThat import assertk.assertions.isEmpty import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlinx.coroutines.runBlocking import me.uport.sdk.testhelpers.coAssert @@ -34,7 +36,7 @@ class UniversalDIDTest { coAssert { UniversalDID.resolve("") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } @@ -46,7 +48,7 @@ class UniversalDIDTest { coAssert { UniversalDID.resolve("") - }.thrownError { + }.isFailure().all { isInstanceOf(IllegalArgumentException::class) } } diff --git a/web-did/src/test/java/me/uport/sdk/httpsdid/WebDIDResolverTest.kt b/web-did/src/test/java/me/uport/sdk/httpsdid/WebDIDResolverTest.kt index 49bb2d1..7268ec7 100644 --- a/web-did/src/test/java/me/uport/sdk/httpsdid/WebDIDResolverTest.kt +++ b/web-did/src/test/java/me/uport/sdk/httpsdid/WebDIDResolverTest.kt @@ -1,7 +1,9 @@ package me.uport.sdk.httpsdid +import assertk.all import assertk.assertThat import assertk.assertions.isEqualTo +import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isTrue import io.mockk.coEvery @@ -95,7 +97,7 @@ class WebDIDResolverTest { coAssert { tested.resolve("did:web:example.com") - }.thrownError { + }.isFailure().all { isInstanceOf( listOf( IllegalArgumentException::class, @@ -116,7 +118,7 @@ class WebDIDResolverTest { coAssert { tested.resolve("did:https:example.com") - }.thrownError { + }.isFailure().all { isInstanceOf( listOf( IllegalArgumentException::class, From 9cc2550f15080eb3b2ea42e8a01f9c6dca83dcf1 Mon Sep 17 00:00:00 2001 From: Mircea Nistor Date: Fri, 20 Mar 2020 21:53:38 +0100 Subject: [PATCH 2/3] refactor: bump detekt to 1.6.0 & add config --- build.gradle | 5 +- detekt.yml | 610 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 612 insertions(+), 3 deletions(-) create mode 100644 detekt.yml diff --git a/build.gradle b/build.gradle index 80a2b62..79d29e4 100644 --- a/build.gradle +++ b/build.gradle @@ -10,7 +10,7 @@ buildscript { junit_version = "4.12" mockk_version = "1.9.3" assertk_version = "0.22" - detekt_version = "1.0.0-RC14" + detekt_version = "1.6.0" jacoco_version = "0.8.4" okhttp_version = "4.4.1" @@ -56,8 +56,7 @@ detekt { input = files( "$projectDir" ) - //config = "${projectDir}/detekt.yml" - filters = ".*test.*,.*/resources/.*,.*/tmp/.*,.*/build/.*" + config = files("${projectDir}/detekt.yml") parallel = true reports { xml { diff --git a/detekt.yml b/detekt.yml new file mode 100644 index 0000000..f5477c5 --- /dev/null +++ b/detekt.yml @@ -0,0 +1,610 @@ +build: + maxIssues: 0 + excludeCorrectable: false + weights: + # complexity: 2 + # LongParameterList: 1 + # style: 1 + # comments: 1 + +config: + validation: true + # when writing own rules with new properties, exclude the property path e.g.: "my_rule_set,.*>.*>[my_property]" + excludes: "" + +processors: + active: true + exclude: + - 'DetektProgressListener' + # - 'FunctionCountProcessor' + # - 'PropertyCountProcessor' + # - 'ClassCountProcessor' + # - 'PackageCountProcessor' + # - 'KtFileCountProcessor' + +console-reports: + active: true + exclude: + - 'ProjectStatisticsReport' + - 'ComplexityReport' + - 'NotificationReport' + # - 'FindingsReport' + - 'FileBasedFindingsReport' + +comments: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + CommentOverPrivateFunction: + active: false + CommentOverPrivateProperty: + active: false + EndOfSentenceFormat: + active: false + endOfSentenceFormat: ([.?!][ \t\n\r\f<])|([.?!:]$) + UndocumentedPublicClass: + active: false + searchInNestedClass: true + searchInInnerClass: true + searchInInnerObject: true + searchInInnerInterface: true + UndocumentedPublicFunction: + active: false + UndocumentedPublicProperty: + active: false + +complexity: + active: true + ComplexCondition: + active: true + threshold: 4 + ComplexInterface: + active: false + threshold: 10 + includeStaticDeclarations: false + ComplexMethod: + active: true + threshold: 15 + ignoreSingleWhenExpression: false + ignoreSimpleWhenEntries: false + ignoreNestingFunctions: false + nestingFunctions: run,let,apply,with,also,use,forEach,isNotNull,ifNull + LabeledExpression: + active: false + ignoredLabels: "" + LargeClass: + active: true + threshold: 600 + LongMethod: + active: true + threshold: 60 + LongParameterList: + active: true + threshold: 6 + ignoreDefaultParameters: false + MethodOverloading: + active: false + threshold: 6 + NestedBlockDepth: + active: true + threshold: 4 + StringLiteralDuplication: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + threshold: 3 + ignoreAnnotation: true + excludeStringsWithLessThan5Characters: true + ignoreStringsRegex: '$^' + TooManyFunctions: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + thresholdInFiles: 11 + thresholdInClasses: 11 + thresholdInInterfaces: 11 + thresholdInObjects: 11 + thresholdInEnums: 11 + ignoreDeprecated: false + ignorePrivate: false + ignoreOverridden: false + +coroutines: + active: true + GlobalCoroutineUsage: + active: false + RedundantSuspendModifier: + active: false + +empty-blocks: + active: true + EmptyCatchBlock: + active: true + allowedExceptionNameRegex: "^(_|(ignore|expected).*)" + EmptyClassBlock: + active: true + EmptyDefaultConstructor: + active: true + EmptyDoWhileBlock: + active: true + EmptyElseBlock: + active: true + EmptyFinallyBlock: + active: true + EmptyForBlock: + active: true + EmptyFunctionBlock: + active: true + ignoreOverridden: false + EmptyIfBlock: + active: true + EmptyInitBlock: + active: true + EmptyKtFile: + active: true + EmptySecondaryConstructor: + active: true + EmptyTryBlock: + active: true + EmptyWhenBlock: + active: true + EmptyWhileBlock: + active: true + +exceptions: + active: true + ExceptionRaisedInUnexpectedLocation: + active: false + methodNames: 'toString,hashCode,equals,finalize' + InstanceOfCheckForException: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + NotImplementedDeclaration: + active: false + PrintStackTrace: + active: false + RethrowCaughtException: + active: false + ReturnFromFinally: + active: false + ignoreLabeled: false + SwallowedException: + active: false + ignoredExceptionTypes: 'InterruptedException,NumberFormatException,ParseException,MalformedURLException' + allowedExceptionNameRegex: "^(_|(ignore|expected).*)" + ThrowingExceptionFromFinally: + active: false + ThrowingExceptionInMain: + active: false + ThrowingExceptionsWithoutMessageOrCause: + active: false + exceptions: 'IllegalArgumentException,IllegalStateException,IOException' + ThrowingNewInstanceOfSameException: + active: false + TooGenericExceptionCaught: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + exceptionNames: + - ArrayIndexOutOfBoundsException + - Error + - Exception + - IllegalMonitorStateException + - NullPointerException + - IndexOutOfBoundsException + - RuntimeException + - Throwable + allowedExceptionNameRegex: "^(_|(ignore|expected).*)" + TooGenericExceptionThrown: + active: true + exceptionNames: + - Error + - Exception + - Throwable + - RuntimeException + +formatting: + active: true + android: false + autoCorrect: true + AnnotationOnSeparateLine: + active: false + autoCorrect: true + ChainWrapping: + active: true + autoCorrect: true + CommentSpacing: + active: true + autoCorrect: true + EnumEntryNameCase: + active: false + autoCorrect: true + Filename: + active: true + FinalNewline: + active: true + autoCorrect: true + insertFinalNewLine: true + ImportOrdering: + active: false + autoCorrect: true + Indentation: + active: false + autoCorrect: true + indentSize: 4 + continuationIndentSize: 4 + MaximumLineLength: + active: true + maxLineLength: 120 + ModifierOrdering: + active: true + autoCorrect: true + MultiLineIfElse: + active: true + autoCorrect: true + NoBlankLineBeforeRbrace: + active: true + autoCorrect: true + NoConsecutiveBlankLines: + active: true + autoCorrect: true + NoEmptyClassBody: + active: true + autoCorrect: true + NoEmptyFirstLineInMethodBlock: + active: false + autoCorrect: true + NoLineBreakAfterElse: + active: true + autoCorrect: true + NoLineBreakBeforeAssignment: + active: true + autoCorrect: true + NoMultipleSpaces: + active: true + autoCorrect: true + NoSemicolons: + active: true + autoCorrect: true + NoTrailingSpaces: + active: true + autoCorrect: true + NoUnitReturn: + active: true + autoCorrect: true + NoUnusedImports: + active: true + autoCorrect: true + NoWildcardImports: + active: true + PackageName: + active: true + autoCorrect: true + ParameterListWrapping: + active: true + autoCorrect: true + indentSize: 4 + SpacingAroundColon: + active: true + autoCorrect: true + SpacingAroundComma: + active: true + autoCorrect: true + SpacingAroundCurly: + active: true + autoCorrect: true + SpacingAroundDot: + active: true + autoCorrect: true + SpacingAroundKeyword: + active: true + autoCorrect: true + SpacingAroundOperators: + active: true + autoCorrect: true + SpacingAroundParens: + active: true + autoCorrect: true + SpacingAroundRangeOperator: + active: true + autoCorrect: true + StringTemplate: + active: true + autoCorrect: true + +naming: + active: true + ClassNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + classPattern: '[A-Z$][a-zA-Z0-9$]*' + ConstructorParameterNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + parameterPattern: '[a-z][A-Za-z0-9]*' + privateParameterPattern: '[a-z][A-Za-z0-9]*' + excludeClassPattern: '$^' + ignoreOverridden: true + EnumNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + enumEntryPattern: '^[A-Z][_a-zA-Z0-9]*' + ForbiddenClassName: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + forbiddenName: '' + FunctionMaxLength: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + maximumFunctionNameLength: 30 + FunctionMinLength: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + minimumFunctionNameLength: 3 + FunctionNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + functionPattern: '^([a-z$][a-zA-Z$0-9]*)|(`.*`)$' + excludeClassPattern: '$^' + ignoreOverridden: true + FunctionParameterNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + parameterPattern: '[a-z][A-Za-z0-9]*' + excludeClassPattern: '$^' + ignoreOverridden: true + InvalidPackageDeclaration: + active: false + rootPackage: '' + MatchingDeclarationName: + active: true + mustBeFirst: true + MemberNameEqualsClassName: + active: true + ignoreOverridden: true + ObjectPropertyNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + constantPattern: '[A-Za-z][_A-Za-z0-9]*' + propertyPattern: '[A-Za-z][_A-Za-z0-9]*' + privatePropertyPattern: '(_)?[A-Za-z][_A-Za-z0-9]*' + PackageNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + packagePattern: '^[a-z]+(\.[a-z][A-Za-z0-9]*)*$' + TopLevelPropertyNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + constantPattern: '[A-Z][_A-Z0-9]*' + propertyPattern: '[A-Za-z][_A-Za-z0-9]*' + privatePropertyPattern: '_?[A-Za-z][_A-Za-z0-9]*' + VariableMaxLength: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + maximumVariableNameLength: 64 + VariableMinLength: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + minimumVariableNameLength: 1 + VariableNaming: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + variablePattern: '[a-z][A-Za-z0-9]*' + privateVariablePattern: '(_)?[a-z][A-Za-z0-9]*' + excludeClassPattern: '$^' + ignoreOverridden: true + +performance: + active: true + ArrayPrimitive: + active: true + ForEachOnRange: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + SpreadOperator: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + UnnecessaryTemporaryInstantiation: + active: true + +potential-bugs: + active: true + Deprecation: + active: false + DuplicateCaseInWhenExpression: + active: true + EqualsAlwaysReturnsTrueOrFalse: + active: true + EqualsWithHashCodeExist: + active: true + ExplicitGarbageCollectionCall: + active: true + HasPlatformType: + active: false + ImplicitDefaultLocale: + active: false + InvalidRange: + active: true + IteratorHasNextCallsNextMethod: + active: true + IteratorNotThrowingNoSuchElementException: + active: true + LateinitUsage: + active: false + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + excludeAnnotatedProperties: "" + ignoreOnClassesPattern: "" + MapGetWithNotNullAssertionOperator: + active: false + MissingWhenCase: + active: true + RedundantElseInWhen: + active: true + UnconditionalJumpStatementInLoop: + active: false + UnreachableCode: + active: true + UnsafeCallOnNullableType: + active: true + UnsafeCast: + active: false + UselessPostfixExpression: + active: false + WrongEqualsTypeParameter: + active: true + +style: + active: true + CollapsibleIfStatements: + active: false + DataClassContainsFunctions: + active: false + conversionFunctionPrefix: 'to' + DataClassShouldBeImmutable: + active: false + EqualsNullCall: + active: true + EqualsOnSignatureLine: + active: false + ExplicitCollectionElementAccessMethod: + active: false + ExplicitItLambdaParameter: + active: false + ExpressionBodySyntax: + active: false + includeLineWrapping: false + ForbiddenComment: + active: true + values: 'TODO:,FIXME:,STOPSHIP:' + allowedPatterns: "" + ForbiddenImport: + active: false + imports: '' + forbiddenPatterns: "" + ForbiddenMethodCall: + active: false + methods: '' + ForbiddenPublicDataClass: + active: false + ignorePackages: '*.internal,*.internal.*' + ForbiddenVoid: + active: false + ignoreOverridden: false + ignoreUsageInGenerics: false + FunctionOnlyReturningConstant: + active: true + ignoreOverridableFunction: true + excludedFunctions: 'describeContents' + excludeAnnotatedFunction: "dagger.Provides" + LibraryCodeMustSpecifyReturnType: + active: true + LoopWithTooManyJumpStatements: + active: true + maxJumpCount: 1 + MagicNumber: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + ignoreNumbers: '-1,0,1,2' + ignoreHashCodeFunction: true + ignorePropertyDeclaration: false + ignoreLocalVariableDeclaration: false + ignoreConstantDeclaration: true + ignoreCompanionObjectPropertyDeclaration: true + ignoreAnnotation: false + ignoreNamedArgument: true + ignoreEnums: false + ignoreRanges: false + MandatoryBracesIfStatements: + active: false + MaxLineLength: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + maxLineLength: 120 + excludePackageStatements: true + excludeImportStatements: true + excludeCommentStatements: false + MayBeConst: + active: true + ModifierOrder: + active: true + NestedClassesVisibility: + active: false + NewLineAtEndOfFile: + active: true + NoTabs: + active: false + OptionalAbstractKeyword: + active: true + OptionalUnit: + active: false + OptionalWhenBraces: + active: false + PreferToOverPairSyntax: + active: false + ProtectedMemberInFinalClass: + active: true + RedundantExplicitType: + active: false + RedundantVisibilityModifierRule: + active: false + ReturnCount: + active: true + max: 2 + excludedFunctions: "equals" + excludeLabeled: false + excludeReturnFromLambda: true + excludeGuardClauses: false + SafeCast: + active: true + SerialVersionUIDInSerializableClass: + active: false + SpacingBetweenPackageAndImports: + active: false + ThrowsCount: + active: true + max: 2 + TrailingWhitespace: + active: false + UnderscoresInNumericLiterals: + active: false + acceptableDecimalLength: 5 + UnnecessaryAbstractClass: + active: true + excludeAnnotatedClasses: "dagger.Module" + UnnecessaryAnnotationUseSiteTarget: + active: false + UnnecessaryApply: + active: false + UnnecessaryInheritance: + active: true + UnnecessaryLet: + active: false + UnnecessaryParentheses: + active: false + UntilInsteadOfRangeTo: + active: false + UnusedImports: + active: false + UnusedPrivateClass: + active: true + UnusedPrivateMember: + active: false + allowedNames: "(_|ignored|expected|serialVersionUID)" + UseArrayLiteralsInAnnotations: + active: false + UseCheckOrError: + active: false + UseDataClass: + active: false + excludeAnnotatedClasses: "" + allowVars: false + UseIfInsteadOfWhen: + active: false + UseRequire: + active: false + UselessCallOnNotNull: + active: true + UtilityClassWithPublicConstructor: + active: true + VarCouldBeVal: + active: false + WildcardImport: + active: true + excludes: "**/test/**,**/androidTest/**,**/*.Test.kt,**/*.Spec.kt,**/*.Spek.kt" + excludeImports: 'java.util.*,kotlinx.android.synthetic.*' From 497cfde36133f5e8879a8060acbdfd3f50d5e6f5 Mon Sep 17 00:00:00 2001 From: Mircea Nistor Date: Fri, 20 Mar 2020 23:25:10 +0100 Subject: [PATCH 3/3] refactor: fix detekt warnings --- .circleci/config.yml | 5 ++ build.gradle | 1 + .../StatusResolver.kt | 4 +- .../UniversalStatusResolver.kt | 17 +++-- .../Utils.kt | 4 +- .../UniversalStatusResolverTests.kt | 8 +-- detekt_baseline.xml | 13 ++++ .../uport/sdk/ethrdid/EthereumDIDRegistry.kt | 2 +- .../main/java/me/uport/sdk/ethrdid/EthrDID.kt | 2 +- .../me/uport/sdk/ethrdid/EthrDIDNetwork.kt | 2 +- .../me/uport/sdk/ethrdid/EthrDIDResolver.kt | 22 ++++-- .../test/java/me/uport/sdk/ethrdid/DDOTest.kt | 4 +- .../uport/sdk/ethrdid/EthrDIDResolverTest.kt | 4 +- .../java/me/uport/sdk/ethrdid/EthrDIDTest.kt | 2 +- .../EthrStatusResolver.kt | 12 ++-- .../RevocationContract.kt | 4 +- .../EthrStatusResolverTests.kt | 4 +- .../ParseRegistryIdTests.kt | 4 +- .../ValidRevokersTests.kt | 4 +- .../uport/sdk/jwt/test/EthrDIDTestHelpers.kt | 62 ++++++++-------- ...lpersTest.kt => EthrDIDTestHelpersTest.kt} | 2 +- jwt/src/main/java/me/uport/sdk/jwt/ECUtils.kt | 6 +- .../me/uport/sdk/jwt/JWTSignerAlgorithm.kt | 3 +- .../main/java/me/uport/sdk/jwt/JWTTools.kt | 22 ++++-- .../main/java/me/uport/sdk/jwt/JWTUtils.kt | 72 +++++++++---------- .../sdk/jwt/model/ArbitraryMapSerializer.kt | 3 +- .../java/me/uport/sdk/jwt/model/JwtPayload.kt | 26 +++++-- .../java/me/uport/sdk/jwt/ECUtilsKtTest.kt | 2 +- .../java/me/uport/sdk/jwt/JWTDecodeTest.kt | 6 +- .../uport/sdk/jwt/JWTSignerAlgorithmTest.kt | 2 +- .../java/me/uport/sdk/jwt/JWTToolsJVMTest.kt | 4 +- .../java/me/uport/sdk/jwt/JwtUtilsKtTest.kt | 4 +- .../java/me/uport/sdk/jwt/KeyRecoveryTest.kt | 3 +- .../me/uport/sdk/jwt/SerializationTesting.kt | 3 +- .../java/me/uport/sdk/jwt/TimestampTests.kt | 2 +- .../uport/sdk/jwt/model/JWTAlgorithmTest.kt | 2 +- .../me/uport/sdk/universaldid/DIDResolver.kt | 3 +- .../uport/sdk/universaldid/DIDResolverImpl.kt | 22 ++++-- .../me/uport/sdk/universaldid/UniversalDID.kt | 2 +- .../sdk/universaldid/DIDResolverImplTest.kt | 3 +- .../sdk/universaldid/UniversalDIDTest.kt | 3 +- .../me/uport/sdk/uportdefaults/Extensions.kt | 3 +- .../uport/sdk/uportdefaults/ExtensionsTest.kt | 2 +- .../sdk/uportdid/UportDIDResolverTest.kt | 2 +- .../sdk/uportdid/UportIdentityDocumentTest.kt | 2 +- 45 files changed, 221 insertions(+), 163 deletions(-) rename credential-status/src/main/java/me/uport/{credential_status => credentialstatus}/StatusResolver.kt (97%) rename credential-status/src/main/java/me/uport/{credential_status => credentialstatus}/UniversalStatusResolver.kt (68%) rename credential-status/src/main/java/me/uport/{credential_status => credentialstatus}/Utils.kt (92%) create mode 100644 detekt_baseline.xml rename ethr-status/src/main/java/me/uport/sdk/{ethr_status => ethrstatus}/EthrStatusResolver.kt (93%) rename ethr-status/src/main/java/me/uport/sdk/{ethr_status => ethrstatus}/RevocationContract.kt (97%) rename ethr-status/src/test/java/me/uport/sdk/{ethr_status => ethrstatus}/EthrStatusResolverTests.kt (99%) rename ethr-status/src/test/java/me/uport/sdk/{ethr_status => ethrstatus}/ParseRegistryIdTests.kt (98%) rename ethr-status/src/test/java/me/uport/sdk/{ethr_status => ethrstatus}/ValidRevokersTests.kt (99%) rename jwt-test/src/test/java/me/uport/sdk/jwt/test/{EthrDidDocumentTestHelpersTest.kt => EthrDIDTestHelpersTest.kt} (99%) diff --git a/.circleci/config.yml b/.circleci/config.yml index 0871dff..863b114 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -46,6 +46,11 @@ jobs: # upload test coverage report! - run: bash <(curl -s https://codecov.io/bash) + # run linter + - run: ./gradlew detekt + - store_artifacts: + path: ./build/reports + workflows: version: 2 workflow: diff --git a/build.gradle b/build.gradle index 79d29e4..1bdbc89 100644 --- a/build.gradle +++ b/build.gradle @@ -57,6 +57,7 @@ detekt { "$projectDir" ) config = files("${projectDir}/detekt.yml") + baseline = file("${projectDir}/detekt_baseline.xml") parallel = true reports { xml { diff --git a/credential-status/src/main/java/me/uport/credential_status/StatusResolver.kt b/credential-status/src/main/java/me/uport/credentialstatus/StatusResolver.kt similarity index 97% rename from credential-status/src/main/java/me/uport/credential_status/StatusResolver.kt rename to credential-status/src/main/java/me/uport/credentialstatus/StatusResolver.kt index a5ec1ab..5f3fadc 100644 --- a/credential-status/src/main/java/me/uport/credential_status/StatusResolver.kt +++ b/credential-status/src/main/java/me/uport/credentialstatus/StatusResolver.kt @@ -1,4 +1,4 @@ -package me.uport.credential_status +package me.uport.credentialstatus import me.uport.sdk.universaldid.DIDDocument @@ -41,4 +41,4 @@ interface StatusResolver { * Checks the status of a given credential and returns a [CredentialStatus] or throws an error */ suspend fun checkStatus(credential: String, didDoc: DIDDocument): CredentialStatus -} \ No newline at end of file +} diff --git a/credential-status/src/main/java/me/uport/credential_status/UniversalStatusResolver.kt b/credential-status/src/main/java/me/uport/credentialstatus/UniversalStatusResolver.kt similarity index 68% rename from credential-status/src/main/java/me/uport/credential_status/UniversalStatusResolver.kt rename to credential-status/src/main/java/me/uport/credentialstatus/UniversalStatusResolver.kt index 07fad60..577a2df 100644 --- a/credential-status/src/main/java/me/uport/credential_status/UniversalStatusResolver.kt +++ b/credential-status/src/main/java/me/uport/credentialstatus/UniversalStatusResolver.kt @@ -1,8 +1,6 @@ -package me.uport.credential_status +package me.uport.credentialstatus import me.uport.sdk.universaldid.DIDDocument -import me.uport.sdk.universaldid.UniversalDID.method -import me.uport.sdk.universaldid.UniversalDID.registerResolver /** * @@ -36,12 +34,13 @@ class UniversalStatusResolver : StatusResolver { val statusEntry = getStatusEntry(credential) - if (statusEntry.type.isBlank() || !resolvers.containsKey(statusEntry.type)) { - throw IllegalStateException("There is no StatusResolver registered to check status using '${statusEntry.type}' method.") - } else { - return resolvers[statusEntry.type]?.checkStatus(credential, didDoc) - ?: throw IllegalStateException("There StatusResolver for '$statusEntry.type' failed to resolve for an unknown reason.") + val resolver = resolvers[statusEntry.type] + + check(statusEntry.type.isNotBlank() && resolver != null) { + "There is no StatusResolver registered to check status using '${statusEntry.type}' method." } + + return resolver.checkStatus(credential, didDoc) } @@ -54,4 +53,4 @@ class UniversalStatusResolver : StatusResolver { } resolvers[resolver.method] = resolver } -} \ No newline at end of file +} diff --git a/credential-status/src/main/java/me/uport/credential_status/Utils.kt b/credential-status/src/main/java/me/uport/credentialstatus/Utils.kt similarity index 92% rename from credential-status/src/main/java/me/uport/credential_status/Utils.kt rename to credential-status/src/main/java/me/uport/credentialstatus/Utils.kt index c21a2ec..31bceab 100644 --- a/credential-status/src/main/java/me/uport/credential_status/Utils.kt +++ b/credential-status/src/main/java/me/uport/credentialstatus/Utils.kt @@ -1,4 +1,4 @@ -package me.uport.credential_status +package me.uport.credentialstatus import me.uport.sdk.jwt.JWTTools @@ -15,4 +15,4 @@ fun getStatusEntry(credential: String): StatusEntry { status["type"] ?: "", status["id"] ?: "" ) -} \ No newline at end of file +} diff --git a/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt b/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt index 289f153..868094e 100644 --- a/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt +++ b/credential-status/src/test/java/me/uport/sdk/credential_status/UniversalStatusResolverTests.kt @@ -8,9 +8,9 @@ import assertk.assertions.isEqualTo import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlinx.coroutines.runBlocking -import me.uport.credential_status.CredentialStatus -import me.uport.credential_status.StatusResolver -import me.uport.credential_status.UniversalStatusResolver +import me.uport.credentialstatus.CredentialStatus +import me.uport.credentialstatus.StatusResolver +import me.uport.credentialstatus.UniversalStatusResolver import me.uport.sdk.ethrdid.EthrDIDDocument import me.uport.sdk.testhelpers.coAssert import me.uport.sdk.universaldid.DIDDocument @@ -89,4 +89,4 @@ class UniversalStatusResolverTests { val result = resolver.checkStatus(successfulCred, didDoc) assertThat(result).isEqualTo(TestStatus(BigInteger.ONE)) } -} \ No newline at end of file +} diff --git a/detekt_baseline.xml b/detekt_baseline.xml new file mode 100644 index 0000000..00cd5c7 --- /dev/null +++ b/detekt_baseline.xml @@ -0,0 +1,13 @@ + + + + + MaxLineLength:UniversalDID.kt$UniversalDID$ override suspend fun resolve(did: String): DIDDocument + MaxLineLength:UniversalDID.kt$UniversalDID$?: + MaxLineLength:UniversalDID.kt$UniversalDID$throw IllegalStateException("There is no DIDResolver registered to resolve '$method' DIDs and none of the other ${resolvers.size} registered ones can do it.") + MaxLineLength:UportIdentityDocument.kt$UportIdentityDocument$val image: ProfilePicture? = null + MaxLineLength:UportIdentityDocument.kt$UportIdentityDocument$val publicEncKey: String? = null + MaxLineLength:UportIdentityDocument.kt$UportIdentityDocument$val publicKey: String? = null + TooGenericExceptionCaught:UniversalDID.kt$UniversalDID$ex: Exception + + diff --git a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthereumDIDRegistry.kt b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthereumDIDRegistry.kt index acdb4bd..019f8ff 100644 --- a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthereumDIDRegistry.kt +++ b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthereumDIDRegistry.kt @@ -1,4 +1,4 @@ -@file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass") +@file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass", "MagicNumber") package me.uport.sdk.ethrdid diff --git a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDID.kt b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDID.kt index b72311a..7ff0e1d 100644 --- a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDID.kt +++ b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDID.kt @@ -1,4 +1,4 @@ -@file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass") +@file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass", "MagicNumber") package me.uport.sdk.ethrdid diff --git a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDNetwork.kt b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDNetwork.kt index dc38c0a..96baf8c 100644 --- a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDNetwork.kt +++ b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDNetwork.kt @@ -46,4 +46,4 @@ fun EthNetwork.toEthrDIDNetwork() = chainId = networkId, registryAddress = ethrDidRegistry, rpc = JsonRPC(rpcUrl) - ) \ No newline at end of file + ) diff --git a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDResolver.kt b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDResolver.kt index 4f28c23..988e15b 100644 --- a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDResolver.kt +++ b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDResolver.kt @@ -92,9 +92,9 @@ open class EthrDIDResolver : DIDResolver { _registryMap[networkIdentifier] } catch (e: IllegalArgumentException) { throw IllegalArgumentException( - "Missing registry configuration for `$networkIdentifier`." + - " To resolve did:ethr:$networkIdentifier:0x... you need to register an `EthrDIDNetwork`" + - " in the EthrDIDResolver.Builder" + "Missing registry configuration for `$networkIdentifier`. To resolve " + + "did:ethr:$networkIdentifier:0x... you need to register an `EthrDIDNetwork` " + + "in the EthrDIDResolver.Builder" ) } @@ -114,7 +114,8 @@ open class EthrDIDResolver : DIDResolver { } /** - * Obtains the block number when the given identity was last changed, or [BigInteger.ZERO] if no change was ever made + * Obtains the block number when the given identity was last changed, or [BigInteger.ZERO] if + * no change was ever made * * @hide */ @@ -129,16 +130,19 @@ open class EthrDIDResolver : DIDResolver { rpc.ethCall(registryAddress, encodedCall) } catch (err: JsonRpcException) { throw DidResolverError( - "Unable to evaluate when or if the $identity was lastChanged because RPC endpoint responded with an error", + "Unable to evaluate when or if the $identity was lastChanged because RPC" + + " endpoint responded with an error", err ) } } /** - * Builds a simple_list of events associated with the [identity] in the ether-did-registry contract that resides at [registryAddress] + * Builds a simple_list of events associated with the [identity] in the ether-did-registry + * contract that resides at [registryAddress] * - * Since the Event classes are generated by bivrost-kotlin, they don't have a specific type so the simple_list id of type [Any] + * Since the Event classes are generated by bivrost-kotlin, they don't have a specific type + * so the simple_list id of type [Any] * * @hide */ @@ -252,6 +256,7 @@ open class EthrDIDResolver : DIDResolver { ) } + @Suppress("MagicNumber", "ReturnCount") internal fun processAttributeChanged( event: DIDAttributeChanged.Arguments, delegateCount: Int, @@ -329,6 +334,7 @@ open class EthrDIDResolver : DIDResolver { val key = "DIDDelegateChanged-$delegateType-$delegate" val validTo = event.validto.value.toLong() + @Suppress("MagicNumber") if (validTo >= _timeProvider.nowMs() / 1000L) { delegateIndex++ @@ -380,6 +386,7 @@ open class EthrDIDResolver : DIDResolver { private val didParsePattern = "^(did:)?((\\w+):)?((\\w+):)?((0x)([0-9a-fA-F]{40}))".toRegex() + @Suppress("ReturnCount") internal fun normalizeDid(did: String): String { val matchResult = didParsePattern.find(did) ?: return "" val (didHeader, _, didType, _, network, _, _, hexDigits) = matchResult.destructured @@ -413,6 +420,7 @@ open class EthrDIDResolver : DIDResolver { * Allows the use of a different clock than the system time. * This is usable for "was valid at" type of queries, and for deterministic checks. */ + @Suppress("unused") fun setTimeProvider(timeProvider: ITimeProvider): Builder { _clock = timeProvider return this diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt index 53196fa..2010981 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/DDOTest.kt @@ -37,7 +37,5 @@ class DDOTest { assertThat { EthrDIDDocument.fromJson(docText) }.isSuccess() - } - -} \ No newline at end of file +} diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt index 039a8d4..f679a70 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt @@ -1,4 +1,4 @@ -@file:Suppress("UnnecessaryVariable") +@file:Suppress("UnnecessaryVariable", "LargeClass", "LongMethod") package me.uport.sdk.ethrdid @@ -18,6 +18,7 @@ import assertk.assertions.isNotEqualTo import assertk.assertions.isNotNull import assertk.assertions.isSuccess import assertk.assertions.isTrue +import assertk.assertions.message import io.mockk.coEvery import io.mockk.mockk import io.mockk.slot @@ -719,6 +720,7 @@ class EthrDIDResolverTest { resolver.resolve("did:ethr:unknown:0xb9c5714089478a327f09197987f16f9e5d936e8a") }.isFailure().all { isInstanceOf(IllegalArgumentException::class) + println(this.message()) hasMessage("Missing registry configuration for `unknown`. To resolve did:ethr:unknown:0x... you need to register an `EthrDIDNetwork` in the EthrDIDResolver.Builder") } } diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDTest.kt index f8e43e5..c9a827c 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDTest.kt @@ -82,4 +82,4 @@ class EthrDIDTest { } } -} \ No newline at end of file +} diff --git a/ethr-status/src/main/java/me/uport/sdk/ethr_status/EthrStatusResolver.kt b/ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt similarity index 93% rename from ethr-status/src/main/java/me/uport/sdk/ethr_status/EthrStatusResolver.kt rename to ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt index 61435d5..cc633ca 100644 --- a/ethr-status/src/main/java/me/uport/sdk/ethr_status/EthrStatusResolver.kt +++ b/ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt @@ -1,9 +1,9 @@ -package me.uport.sdk.ethr_status +package me.uport.sdk.ethrstatus -import me.uport.credential_status.CredentialStatus -import me.uport.credential_status.StatusEntry -import me.uport.credential_status.StatusResolver -import me.uport.credential_status.getStatusEntry +import me.uport.credentialstatus.CredentialStatus +import me.uport.credentialstatus.StatusEntry +import me.uport.credentialstatus.StatusResolver +import me.uport.credentialstatus.getStatusEntry import me.uport.sdk.core.Networks import me.uport.sdk.core.hexToBigInteger import me.uport.sdk.jsonrpc.JsonRPC @@ -111,4 +111,4 @@ data class EthrStatus( * The block number when it was first revoked by the issuer, or [BigInteger.ZERO] if it was never revoked **/ val blockNumber: BigInteger -) : CredentialStatus \ No newline at end of file +) : CredentialStatus diff --git a/ethr-status/src/main/java/me/uport/sdk/ethr_status/RevocationContract.kt b/ethr-status/src/main/java/me/uport/sdk/ethrstatus/RevocationContract.kt similarity index 97% rename from ethr-status/src/main/java/me/uport/sdk/ethr_status/RevocationContract.kt rename to ethr-status/src/main/java/me/uport/sdk/ethrstatus/RevocationContract.kt index b90c646..e6b0d1a 100644 --- a/ethr-status/src/main/java/me/uport/sdk/ethr_status/RevocationContract.kt +++ b/ethr-status/src/main/java/me/uport/sdk/ethrstatus/RevocationContract.kt @@ -1,6 +1,6 @@ @file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass", "unused") -package me.uport.sdk.ethr_status +package me.uport.sdk.ethrstatus import pm.gnosis.model.Solidity import pm.gnosis.model.SolidityBase @@ -41,4 +41,4 @@ class RevocationContract { data class Arguments(val issuer: Solidity.Address, val digest: Solidity.Bytes32) } -} \ No newline at end of file +} diff --git a/ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt b/ethr-status/src/test/java/me/uport/sdk/ethrstatus/EthrStatusResolverTests.kt similarity index 99% rename from ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt rename to ethr-status/src/test/java/me/uport/sdk/ethrstatus/EthrStatusResolverTests.kt index 8854980..f58f4a9 100644 --- a/ethr-status/src/test/java/me/uport/sdk/ethr_status/EthrStatusResolverTests.kt +++ b/ethr-status/src/test/java/me/uport/sdk/ethrstatus/EthrStatusResolverTests.kt @@ -1,6 +1,6 @@ @file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass", "StringLiteralDuplication") -package me.uport.sdk.ethr_status +package me.uport.sdk.ethrstatus import assertk.all import assertk.assertThat @@ -92,4 +92,4 @@ class EthrStatusResolverTests { isInstanceOf(IllegalStateException::class) } } -} \ No newline at end of file +} diff --git a/ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt b/ethr-status/src/test/java/me/uport/sdk/ethrstatus/ParseRegistryIdTests.kt similarity index 98% rename from ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt rename to ethr-status/src/test/java/me/uport/sdk/ethrstatus/ParseRegistryIdTests.kt index d1c3715..d93cf06 100644 --- a/ethr-status/src/test/java/me/uport/sdk/ethr_status/ParseRegistryIdTests.kt +++ b/ethr-status/src/test/java/me/uport/sdk/ethrstatus/ParseRegistryIdTests.kt @@ -1,6 +1,6 @@ @file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass", "StringLiteralDuplication") -package me.uport.sdk.ethr_status +package me.uport.sdk.ethrstatus import assertk.all import assertk.assertThat @@ -64,4 +64,4 @@ class ParseRegistryIdTests { } } } -} \ No newline at end of file +} diff --git a/ethr-status/src/test/java/me/uport/sdk/ethr_status/ValidRevokersTests.kt b/ethr-status/src/test/java/me/uport/sdk/ethrstatus/ValidRevokersTests.kt similarity index 99% rename from ethr-status/src/test/java/me/uport/sdk/ethr_status/ValidRevokersTests.kt rename to ethr-status/src/test/java/me/uport/sdk/ethrstatus/ValidRevokersTests.kt index 6f346a0..8b0fbad 100644 --- a/ethr-status/src/test/java/me/uport/sdk/ethr_status/ValidRevokersTests.kt +++ b/ethr-status/src/test/java/me/uport/sdk/ethrstatus/ValidRevokersTests.kt @@ -1,6 +1,6 @@ @file:Suppress("UndocumentedPublicFunction", "UndocumentedPublicClass", "StringLiteralDuplication") -package me.uport.sdk.ethr_status +package me.uport.sdk.ethrstatus import assertk.assertThat import assertk.assertions.isEqualTo @@ -140,4 +140,4 @@ class ValidRevokersTests { val revokers = ethrStatus.getValidRevokers(didDoc) assertThat(revokers).isEqualTo(listOf("0x108209f4247b7fe6605b0f58f9145ec3269d0154")) } -} \ No newline at end of file +} diff --git a/jwt-test/src/main/java/me/uport/sdk/jwt/test/EthrDIDTestHelpers.kt b/jwt-test/src/main/java/me/uport/sdk/jwt/test/EthrDIDTestHelpers.kt index b7942bc..dafdbcb 100644 --- a/jwt-test/src/main/java/me/uport/sdk/jwt/test/EthrDIDTestHelpers.kt +++ b/jwt-test/src/main/java/me/uport/sdk/jwt/test/EthrDIDTestHelpers.kt @@ -5,39 +5,35 @@ import me.uport.sdk.universaldid.AuthenticationEntry import me.uport.sdk.universaldid.PublicKeyEntry import me.uport.sdk.universaldid.PublicKeyType -open class EthrDIDTestHelpers { - - companion object { - - //language=RegExp - private val didParsePattern = "^(did:)?((\\w+):)?((\\w+):)?(0x[0-9a-fA-F]{40})".toRegex() - - fun mockDocForAddress(potentialDID: String): EthrDIDDocument { - - val matchResult = didParsePattern.find(potentialDID) - ?: throw IllegalArgumentException("can't parse potentialDID or did") - val (_, _, _, _, network, address) = matchResult.destructured - val did = - if (network.isBlank() || network == "mainnet") "did:ethr:$address" else "did:ethr:$network:$address" - - return EthrDIDDocument( - id = did, - publicKey = listOf( - PublicKeyEntry( - id = "$did#owner", - type = PublicKeyType.Secp256k1VerificationKey2018, - owner = did, - ethereumAddress = address - ) - ), - authentication = listOf( - AuthenticationEntry( - type = PublicKeyType.Secp256k1SignatureAuthentication2018, - publicKey = "$did#owner" - ) +object EthrDIDTestHelpers { + + //language=RegExp + private val didParsePattern = "^(did:)?((\\w+):)?((\\w+):)?(0x[0-9a-fA-F]{40})".toRegex() + + fun mockDocForAddress(potentialDID: String): EthrDIDDocument { + + val matchResult = didParsePattern.find(potentialDID) + ?: throw IllegalArgumentException("can't parse potentialDID or did") + val (_, _, _, _, network, address) = matchResult.destructured + val did = + if (network.isBlank() || network == "mainnet") "did:ethr:$address" else "did:ethr:$network:$address" + + return EthrDIDDocument( + id = did, + publicKey = listOf( + PublicKeyEntry( + id = "$did#owner", + type = PublicKeyType.Secp256k1VerificationKey2018, + owner = did, + ethereumAddress = address + ) + ), + authentication = listOf( + AuthenticationEntry( + type = PublicKeyType.Secp256k1SignatureAuthentication2018, + publicKey = "$did#owner" ) ) - } + ) } - -} \ No newline at end of file +} diff --git a/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt b/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDIDTestHelpersTest.kt similarity index 99% rename from jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt rename to jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDIDTestHelpersTest.kt index 8e04d92..b7afae7 100644 --- a/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDidDocumentTestHelpersTest.kt +++ b/jwt-test/src/test/java/me/uport/sdk/jwt/test/EthrDIDTestHelpersTest.kt @@ -133,4 +133,4 @@ class EthrDIDTestHelpersTest { isInstanceOf(IllegalArgumentException::class) } } -} \ No newline at end of file +} diff --git a/jwt/src/main/java/me/uport/sdk/jwt/ECUtils.kt b/jwt/src/main/java/me/uport/sdk/jwt/ECUtils.kt index 8ad3329..5cb4611 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/ECUtils.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/ECUtils.kt @@ -1,4 +1,4 @@ -@file:Suppress("MoveVariableDeclarationIntoWhen", "MatchingDeclarationName") +@file:Suppress("MoveVariableDeclarationIntoWhen", "MatchingDeclarationName", "MagicNumber") package me.uport.sdk.jwt @@ -30,7 +30,8 @@ internal data class ECDSASignature internal constructor(val r: BigInteger, val s * on the secp256k1 elliptic curve * * @param messageHash The hash of the message. For JWT this is `sha256`, for ETH this is `keccak` - * @param signature the components of the signature. Only `r` and `s` are used for verification, the `v` component is ignored + * @param signature the components of the signature. Only `r` and `s` are used for verification, + * the `v` component is ignored * @param publicKey the public key to check against. * * @return `true` when there is a match or `false` otherwise @@ -55,6 +56,7 @@ internal fun ecVerify( /*** * Copied from Kethereum because it is a private method there */ +@Suppress("ReturnCount") internal fun recoverFromSignature( recId: Int, sig: ECDSASignature, diff --git a/jwt/src/main/java/me/uport/sdk/jwt/JWTSignerAlgorithm.kt b/jwt/src/main/java/me/uport/sdk/jwt/JWTSignerAlgorithm.kt index 90c0572..237a2c8 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/JWTSignerAlgorithm.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/JWTSignerAlgorithm.kt @@ -7,7 +7,8 @@ import me.uport.sdk.signer.signJWT import me.uport.sdk.signer.utf8 /** - * Abstracts the signature to a recoverable/non-recoverable JOSE encoding based on the jwt header or algorithm provided during construction + * Abstracts the signature to a recoverable/non-recoverable JOSE encoding based on the jwt header + * or algorithm provided during construction * * It supports "ES256K" and "ES256K-R" signing methods */ diff --git a/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt b/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt index f95ac9a..ef1f43f 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt @@ -1,4 +1,10 @@ -@file:Suppress("KDocUnresolvedReference", "EXPERIMENTAL_API_USAGE", "DEPRECATION") +@file:Suppress( + "KDocUnresolvedReference", + "EXPERIMENTAL_API_USAGE", + "DEPRECATION", + "ThrowsCount", + "MagicNumber" +) package me.uport.sdk.jwt @@ -12,8 +18,8 @@ import me.uport.sdk.core.clean0xPrefix import me.uport.sdk.core.decodeBase64 import me.uport.sdk.core.hexToByteArray import me.uport.sdk.core.toBase64UrlSafe -import me.uport.sdk.jwt.JWTUtils.Companion.normalizeKnownDID -import me.uport.sdk.jwt.JWTUtils.Companion.splitToken +import me.uport.sdk.jwt.JWTUtils.normalizeKnownDID +import me.uport.sdk.jwt.JWTUtils.splitToken import me.uport.sdk.jwt.model.ArbitraryMapSerializer import me.uport.sdk.jwt.model.JwtHeader import me.uport.sdk.jwt.model.JwtHeader.Companion.ES256K @@ -435,8 +441,14 @@ class JWTTools( supportedKeyTypes.contains(it.type) && (!auth || (authenticationKeys.contains(it.id))) } - if (auth && (authenticators.isEmpty())) throw InvalidJWTException("DID document for $issuer does not have public keys suitable for authenticating user") - if (authenticators.isEmpty()) throw InvalidJWTException("DID document for $issuer does not have public keys for $alg") + if (auth && (authenticators.isEmpty())) throw InvalidJWTException( + "DID document for $issuer" + + " does not have public keys suitable for authenticating user" + ) + if (authenticators.isEmpty()) throw InvalidJWTException( + "DID document for $issuer" + + " does not have public keys for $alg" + ) return authenticators } diff --git a/jwt/src/main/java/me/uport/sdk/jwt/JWTUtils.kt b/jwt/src/main/java/me/uport/sdk/jwt/JWTUtils.kt index 7ae3b92..b786a68 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/JWTUtils.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/JWTUtils.kt @@ -5,50 +5,48 @@ import me.uport.mnid.MNID /** * Utilities for dealing with known JWT and DID types and formats */ -class JWTUtils { - - companion object { - - /** - * convenience method used during token processing. - * Splits JWT into parts. - * @throws IllegalArgumentException if it can't split or if the number of parts != 3 - */ - fun splitToken(token: String): Triple { - val parts: List? = token.split('.', limit = 3) - if (parts !== null && parts.size == 3) { - return Triple(parts[0], parts[1], parts[2]) - } else { - throw IllegalArgumentException("Token must have 3 parts: Header, Payload, and Signature") - } +object JWTUtils { + + /** + * convenience method used during token processing. + * Splits JWT into parts. + * @throws IllegalArgumentException if it can't split or if the number of parts != 3 + */ + @Suppress("MagicNumber") + fun splitToken(token: String): Triple { + val parts: List? = token.split('.', limit = 3) + if (parts !== null && parts.size == 3) { + return Triple(parts[0], parts[1], parts[2]) + } else { + throw IllegalArgumentException("Token must have 3 parts: Header, Payload, and Signature") } + } + + /** + * Attempts to normalize a [potentialDID] to a known format. + * + * @return This will transform an ethereum address into an ethr-did + * and an MNID string into a uport-did + * Other cases return the original string + */ + fun normalizeKnownDID(potentialDID: String): String { + + val ethPattern = "^(0[xX])*([0-9a-fA-F]{40})".toRegex() - /** - * Attempts to normalize a [potentialDID] to a known format. - * - * @return This will transform an ethereum address into an ethr-did - * and an MNID string into a uport-did - * Other cases return the original string - */ - fun normalizeKnownDID(potentialDID: String): String { - - //ignore if it's already a did - if (potentialDID.matches("^did:(.*)?:.*".toRegex())) - return potentialDID - - //match an ethereum address - "^(0[xX])*([0-9a-fA-F]{40})".toRegex().find(potentialDID)?.let { + return when { + potentialDID.matches("^did:(.*)?:.*".toRegex()) -> + potentialDID + + potentialDID.matches(ethPattern) -> { + val it = ethPattern.matchEntire(potentialDID)!! val (_, hexDigits) = it.destructured return "did:ethr:0x$hexDigits" } - //match an MNID - if (MNID.isMNID(potentialDID)) { - return "did:uport:$potentialDID" - } + MNID.isMNID(potentialDID) -> + "did:uport:$potentialDID" - return potentialDID + else -> potentialDID } - } } diff --git a/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt b/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt index ce6a5c0..421f022 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt @@ -90,5 +90,4 @@ object ArbitraryMapSerializer : KSerializer> { val asJsonObj: JsonObject = value.toJsonObject() encoder.encode(JsonObjectSerializer, asJsonObj) } - -} \ No newline at end of file +} diff --git a/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt b/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt index d8e58cd..3abd273 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt @@ -32,18 +32,34 @@ data class JwtPayload( val verified: List? = null, val permissions: List? = null, - /** + /* * Specific to selective disclosure RESPONSE * Also includes verified */ - val req: String? = null, //original jwt request, REQUIRED for sign selective disclosure responses - val nad: String? = null, //The MNID of the Ethereum account requested using act in the Selective Disclosure Request - val dad: String? = null, //The devicekey as a regular hex encoded ethereum address as requested using act='devicekey' in the Selective Disclosure Request + /** + * original jwt request, REQUIRED for sign selective disclosure responses + */ + val req: String? = null, + + /** + * The MNID of the Ethereum account requested using act in the Selective Disclosure Request + */ + val nad: String? = null, + + /** + * The devicekey as a regular hex encoded ethereum address as requested + * using act='devicekey' in the Selective Disclosure Request + */ + val dad: String? = null, @SerialName("own") val own: Map? = null, - val capabilities: List? = null, //An array of JWT tokens giving client app the permissions requested. Currently a token allowing them to send push notifications + /** + * An array of JWT tokens giving client app the permissions requested. + * Currently a token allowing them to send push notifications + */ + val capabilities: List? = null, /** * Specific to Verification diff --git a/jwt/src/test/java/me/uport/sdk/jwt/ECUtilsKtTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/ECUtilsKtTest.kt index 85d36c0..ad4f3e3 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/ECUtilsKtTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/ECUtilsKtTest.kt @@ -29,4 +29,4 @@ class ECUtilsKtTest { val result = ecVerify(messageHash, referenceSignature, publicKey) assertThat(result).isTrue() } -} \ No newline at end of file +} diff --git a/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt index 819cd15..40a9d23 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/JWTDecodeTest.kt @@ -6,7 +6,7 @@ import assertk.assertions.hasMessage import assertk.assertions.isEqualTo import assertk.assertions.isFailure import assertk.assertions.isInstanceOf -import me.uport.sdk.jwt.JWTUtils.Companion.splitToken +import me.uport.sdk.jwt.JWTUtils.splitToken import org.junit.Test @@ -98,7 +98,5 @@ class JWTDecodeTest { .isFailure().all { isInstanceOf(InvalidJWTException::class) } - } - -} \ No newline at end of file +} diff --git a/jwt/src/test/java/me/uport/sdk/jwt/JWTSignerAlgorithmTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/JWTSignerAlgorithmTest.kt index e1a06d1..ce5e5b4 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/JWTSignerAlgorithmTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/JWTSignerAlgorithmTest.kt @@ -54,4 +54,4 @@ class JWTSignerAlgorithmTest { assertThat(signature).isEqualTo(expectedSignature) } -} \ No newline at end of file +} diff --git a/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt index fe9d017..617369e 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/JWTToolsJVMTest.kt @@ -1,3 +1,5 @@ +@file:Suppress("LargeClass") + package me.uport.sdk.jwt import assertk.all @@ -16,7 +18,7 @@ import me.uport.sdk.ethrdid.EthrDIDDocument import me.uport.sdk.ethrdid.EthrDIDNetwork import me.uport.sdk.ethrdid.EthrDIDResolver import me.uport.sdk.jsonrpc.JsonRPC -import me.uport.sdk.jwt.JWTUtils.Companion.normalizeKnownDID +import me.uport.sdk.jwt.JWTUtils.normalizeKnownDID import me.uport.sdk.jwt.model.JwtPayload import me.uport.sdk.jwt.test.EthrDIDTestHelpers import me.uport.sdk.signer.KPSigner diff --git a/jwt/src/test/java/me/uport/sdk/jwt/JwtUtilsKtTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/JwtUtilsKtTest.kt index 3132762..01b3591 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/JwtUtilsKtTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/JwtUtilsKtTest.kt @@ -1,7 +1,7 @@ package me.uport.sdk.jwt import assertk.assertions.isEqualTo -import me.uport.sdk.jwt.JWTUtils.Companion.normalizeKnownDID +import me.uport.sdk.jwt.JWTUtils.normalizeKnownDID import org.junit.Test class JwtUtilsKtTest { @@ -34,4 +34,4 @@ class JwtUtilsKtTest { assertk.assertThat(normalizeKnownDID(orig)).isEqualTo(expected) } } -} \ No newline at end of file +} diff --git a/jwt/src/test/java/me/uport/sdk/jwt/KeyRecoveryTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/KeyRecoveryTest.kt index 32654cc..002d0fd 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/KeyRecoveryTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/KeyRecoveryTest.kt @@ -38,5 +38,4 @@ class KeyRecoveryTest { } } } - -} \ No newline at end of file +} diff --git a/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt b/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt index 6327a24..d3cd703 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt @@ -70,5 +70,4 @@ class SerializationTesting { ) ) } - -} \ No newline at end of file +} diff --git a/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt b/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt index 88752a1..3c6a096 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/TimestampTests.kt @@ -14,7 +14,7 @@ import kotlinx.coroutines.runBlocking import me.uport.sdk.ethrdid.EthrDIDNetwork import me.uport.sdk.ethrdid.EthrDIDResolver import me.uport.sdk.jsonrpc.JsonRPC -import me.uport.sdk.jwt.test.EthrDIDTestHelpers.Companion.mockDocForAddress +import me.uport.sdk.jwt.test.EthrDIDTestHelpers.mockDocForAddress import me.uport.sdk.testhelpers.TestTimeProvider import me.uport.sdk.testhelpers.coAssert import me.uport.sdk.universaldid.DIDResolver diff --git a/jwt/src/test/java/me/uport/sdk/jwt/model/JWTAlgorithmTest.kt b/jwt/src/test/java/me/uport/sdk/jwt/model/JWTAlgorithmTest.kt index 6c3ac8b..7a46601 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/model/JWTAlgorithmTest.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/model/JWTAlgorithmTest.kt @@ -26,4 +26,4 @@ class JWTAlgorithmTest { val result = JwtHeader.fromJson("""{typ:"hello",alg:"world"}""") assertThat(result).isNotNull() } -} \ No newline at end of file +} diff --git a/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolver.kt b/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolver.kt index 7c58bfe..d3644ff 100644 --- a/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolver.kt +++ b/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolver.kt @@ -25,7 +25,8 @@ interface DIDResolver { /** * * Builds a [DIDResolverImpl] - * This class creates an[DIDResolverImpl] object and enables the registration of [DIDResolver] using the Builder pattern + * This class creates an[DIDResolverImpl] object and enables the registration of [DIDResolver] + * using the Builder pattern * */ class Builder { diff --git a/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolverImpl.kt b/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolverImpl.kt index cc21f13..67fcfb0 100644 --- a/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolverImpl.kt +++ b/universal-did/src/main/java/me/uport/sdk/universaldid/DIDResolverImpl.kt @@ -36,11 +36,14 @@ internal class DIDResolverImpl : DIDResolver { } /** - * Looks for a [DIDResolver] that can resolve the provided [did] either by method if the did contains one or by trial + * Looks for a [DIDResolver] that can resolve the provided [did] either by method if the did + * contains one or by trial * * @throws IllegalStateException if the proper resolver is not registered or produces `null` - * @throws IllegalArgumentException if the given [did] has no `method` but could be resolved by one of the registered resolvers and that one fails with `null` + * @throws IllegalArgumentException if the given [did] has no `method` but could be resolved + * by one of the registered resolvers and that one fails with `null` */ + @Suppress("TooGenericExceptionCaught") override suspend fun resolve(did: String): DIDDocument { val (method, _) = parse(did) @@ -55,14 +58,21 @@ internal class DIDResolverImpl : DIDResolver { null } }.firstOrNull() - ?: throw IllegalArgumentException("The provided did ($did) could not be resolved by any of the ${resolvers.size} registered resolvers") + ?: throw IllegalArgumentException( + "The provided did ($did) could not be resolved by any of the ${resolvers.size} registered resolvers" + ) } //no else clause, carry on if (resolvers.containsKey(method)) { return resolvers[method]?.resolve(did) - ?: throw IllegalStateException("There DIDResolver for '$method' failed to resolve '$did' for an unknown reason.") + ?: throw IllegalStateException( + "There DIDResolver for '$method' failed to resolve '$did' for an unknown reason." + ) } else { - throw IllegalStateException("There is no DIDResolver registered to resolve '$method' DIDs and none of the other ${resolvers.size} registered ones can do it.") + throw IllegalStateException( + "There is no DIDResolver registered to resolve '$method' DIDs and none of the other" + + " ${resolvers.size} registered ones can do it." + ) } } @@ -77,4 +87,4 @@ internal class DIDResolverImpl : DIDResolver { //language=RegExp private val didPattern = "^did:(.*?):(.+)".toRegex() -} \ No newline at end of file +} diff --git a/universal-did/src/main/java/me/uport/sdk/universaldid/UniversalDID.kt b/universal-did/src/main/java/me/uport/sdk/universaldid/UniversalDID.kt index 40dde93..aecce00 100644 --- a/universal-did/src/main/java/me/uport/sdk/universaldid/UniversalDID.kt +++ b/universal-did/src/main/java/me/uport/sdk/universaldid/UniversalDID.kt @@ -101,4 +101,4 @@ object UniversalDID : DIDResolver { //language=RegExp private val didPattern = "^did:(.*?):(.+)".toRegex() -} \ No newline at end of file +} diff --git a/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt b/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt index 4caac89..98553ac 100644 --- a/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt +++ b/universal-did/src/test/java/me/uport/sdk/universaldid/DIDResolverImplTest.kt @@ -109,5 +109,4 @@ class DIDResolverImplTest { //language=json assertThat(docString).isEqualTo("""{"@context":"test context","id":"example document","publicKey":[],"authentication":[],"service":[]}""") } - -} \ No newline at end of file +} diff --git a/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt b/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt index af9169b..2dadb53 100644 --- a/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt +++ b/universal-did/src/test/java/me/uport/sdk/universaldid/UniversalDIDTest.kt @@ -100,5 +100,4 @@ class UniversalDIDTest { //language=json assertThat(docString).isEqualTo("""{"@context":"test context","id":"example document","publicKey":[],"authentication":[],"service":[]}""") } - -} \ No newline at end of file +} diff --git a/uport-defaults/src/main/java/me/uport/sdk/uportdefaults/Extensions.kt b/uport-defaults/src/main/java/me/uport/sdk/uportdefaults/Extensions.kt index 4742870..c039ae1 100644 --- a/uport-defaults/src/main/java/me/uport/sdk/uportdefaults/Extensions.kt +++ b/uport-defaults/src/main/java/me/uport/sdk/uportdefaults/Extensions.kt @@ -11,6 +11,7 @@ import me.uport.sdk.universaldid.DIDResolver * all known networks and add using the DIDResolver Builder * */ +@Suppress("unused") fun DIDResolver.configureDefaultsWithInfura(infuraProjectId: String): DIDResolver { val mainnet = EthNetwork( @@ -60,4 +61,4 @@ fun DIDResolver.configureDefaultsWithInfura(infuraProjectId: String): DIDResolve WebDIDResolver() ) .build() -} \ No newline at end of file +} diff --git a/uport-defaults/src/test/java/me/uport/sdk/uportdefaults/ExtensionsTest.kt b/uport-defaults/src/test/java/me/uport/sdk/uportdefaults/ExtensionsTest.kt index 4a8d103..c1e52bb 100644 --- a/uport-defaults/src/test/java/me/uport/sdk/uportdefaults/ExtensionsTest.kt +++ b/uport-defaults/src/test/java/me/uport/sdk/uportdefaults/ExtensionsTest.kt @@ -43,4 +43,4 @@ class ExtensionsTest { assertThat(resolver.canResolve(it)).isTrue() } } -} \ No newline at end of file +} diff --git a/uport-did/src/test/java/me/uport/sdk/uportdid/UportDIDResolverTest.kt b/uport-did/src/test/java/me/uport/sdk/uportdid/UportDIDResolverTest.kt index b9ef114..8b56761 100644 --- a/uport-did/src/test/java/me/uport/sdk/uportdid/UportDIDResolverTest.kt +++ b/uport-did/src/test/java/me/uport/sdk/uportdid/UportDIDResolverTest.kt @@ -154,4 +154,4 @@ class UportDIDResolverTest { assertThat(tested.canResolve(it)).isFalse() } } -} \ No newline at end of file +} diff --git a/uport-did/src/test/java/me/uport/sdk/uportdid/UportIdentityDocumentTest.kt b/uport-did/src/test/java/me/uport/sdk/uportdid/UportIdentityDocumentTest.kt index 0758d30..f888b2b 100644 --- a/uport-did/src/test/java/me/uport/sdk/uportdid/UportIdentityDocumentTest.kt +++ b/uport-did/src/test/java/me/uport/sdk/uportdid/UportIdentityDocumentTest.kt @@ -15,4 +15,4 @@ class UportIdentityDocumentTest { val parsed = UportIdentityDocument.fromJson(legacyDoc) assertThat(parsed).isNotNull() } -} \ No newline at end of file +}