Merge branch 'main' into release

Author: MrMatthewLayton

build.gradle

@@ -45,7 +45,7 @@ buildscript {
 }
 
 group 'io.onixlabs'
-version '2.0.0-rc1'
+version '2.0.0-rc2'
 
 subprojects {
     repositories {

onixlabs-corda-identity-framework-contract/src/main/kotlin/io/onixlabs/corda/identityframework/contract/Extensions.AbstractClaim.kt

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2020 Matthew Layton
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.identityframework.contract
+
+fun Iterable<AbstractClaim<*>>.containsDuplicateProperties(
+    property: String? = null,
+    ignoreCase: Boolean = false
+): Boolean {
+    val properties = map { if (ignoreCase) it.property.toLowerCase() else it.property }
+    val filteredProperties = properties.filter { property?.equals(it, ignoreCase) ?: true }
+    return filteredProperties.size != filteredProperties.distinct().size
+}
+
+/**
+ * Checks a collection of [AbstractClaim] instances for duplicate keys.
+ *
+ * @param isCaseSensitive Determines whether to perform case sensitive key checking.
+ * @param message The exception message to throw if the collection contains duplicate keys.
+ * @throws IllegalStateException if the collection contains duplicate keys.
+ */
+fun Iterable<AbstractClaim<*>>.checkForDuplicateProperties(
+    property: String? = null,
+    ignoreCase: Boolean = false,
+    message: String = "The claim collection contains duplicate keys."
+) = check(!containsDuplicateProperties(property, ignoreCase)) { message }

onixlabs-corda-identity-framework-contract/src/main/kotlin/io/onixlabs/corda/identityframework/contract/Extensions.kt renamed to onixlabs-corda-identity-framework-contract/src/main/kotlin/io/onixlabs/corda/identityframework/contract/Extensions.Any.kt

@@ -17,21 +17,8 @@
 package io.onixlabs.corda.identityframework.contract
 
 import kotlin.reflect.KVisibility
-import kotlin.reflect.full.declaredMemberProperties
 import kotlin.reflect.full.memberProperties
 
-/**
- * Checks a collection of [AbstractClaim] instances for duplicate keys.
- *
- * @param isCaseSensitive Determines whether to perform case sensitive key checking.
- * @param message The exception message to throw if the collection contains duplicate keys.
- * @throws IllegalStateException if the collection contains duplicate keys.
- */
-fun Iterable<AbstractClaim<*>>.checkForDuplicateKeys(
-    isCaseSensitive: Boolean = false,
-    message: String = "The claim collection contains duplicate keys."
-) = check(count() == distinctBy { if (isCaseSensitive) it.property else it.property.toLowerCase() }.size) { message }
-
 /**
  * Formats any object like a Kotlin data class.
  *

onixlabs-corda-identity-framework-contract/src/main/kotlin/io/onixlabs/corda/identityframework/contract/AttestationExtensions.kt renamed to onixlabs-corda-identity-framework-contract/src/main/kotlin/io/onixlabs/corda/identityframework/contract/Extensions.Attestation.kt

@@ -0,0 +1,123 @@
+package io.onixlabs.corda.identityframework.contract.general
+
+import io.onixlabs.corda.identityframework.contract.Claim
+import io.onixlabs.corda.identityframework.contract.checkForDuplicateProperties
+import io.onixlabs.corda.identityframework.contract.containsDuplicateProperties
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DuplicatePropertyTests {
+
+    @Test
+    fun `containsDuplicateProperties should return false when a collection does not contain duplicates`() {
+
+        // Arrange
+        val claims = listOf(
+            Claim("Property1", Unit),
+            Claim("PROPERTY1", Unit), // Not considered duplicate because case is preserved.
+            Claim("Property2", Unit),
+            Claim("Property3", Unit)
+        )
+
+        // Act
+        val result = claims.containsDuplicateProperties()
+
+        // Assert
+        assertFalse(result)
+    }
+
+    @Test
+    fun `containsDuplicateProperties should return true when a collection does contain duplicates (ignore case)`() {
+
+        // Arrange
+        val claims = listOf(
+            Claim("Property1", Unit),
+            Claim("PROPERTY1", Unit), // Considered duplicate because case is ignored.
+            Claim("Property2", Unit),
+            Claim("Property3", Unit)
+        )
+
+        // Act
+        val result = claims.containsDuplicateProperties(ignoreCase = true)
+
+        // Assert
+        assertTrue(result)
+    }
+
+    @Test
+    fun `containsDuplicateProperties should return false when a collection does not contain duplicates (property specified)`() {
+
+        // Arrange
+        val claims = listOf(
+            Claim("Property1", Unit),
+            Claim("PROPERTY1", Unit), // Not considered duplicate because case is preserved.
+            Claim("Property2", Unit),
+            Claim("Property3", Unit)
+        )
+
+        // Act
+        val result = claims.containsDuplicateProperties("Property1")
+
+        // Assert
+        assertFalse(result)
+    }
+
+    @Test
+    fun `containsDuplicateProperties should return true when a collection does not contain duplicates (property specified, ignore case)`() {
+
+        // Arrange
+        val claims = listOf(
+            Claim("Property1", Unit),
+            Claim("PROPERTY1", Unit), // Considered duplicate because case is ignored.
+            Claim("Property2", Unit),
+            Claim("Property3", Unit)
+        )
+
+        // Act
+        val result = claims.containsDuplicateProperties("Property1", ignoreCase = true)
+
+        // Assert
+        assertTrue(result)
+    }
+
+    @Test
+    fun `containsDuplicateProperties should return false when a collection does not contain duplicates (distinct property specified)`() {
+
+        // Arrange
+        val claims = listOf(
+            Claim("Property1", Unit),
+            Claim("PROPERTY1", Unit), // Considered duplicate because case is ignored.
+            Claim("Property2", Unit),
+            Claim("Property3", Unit)
+        )
+
+        // Act
+        val result = claims.containsDuplicateProperties("Property3")
+
+        // Assert
+        assertFalse(result)
+    }
+
+    @Test
+    fun `checkForDuplicateProperties should throw an exception when duplicate properties are detected`() {
+
+        // Arrange
+        val claims = listOf(
+            Claim("Property1", Unit),
+            Claim("Property1", Unit),
+            Claim("Property2", Unit),
+            Claim("Property3", Unit)
+        )
+
+        // Act
+        val exception = assertThrows<IllegalStateException> {
+            claims.checkForDuplicateProperties()
+        }
+
+        // Assert
+        assertEquals("The claim collection contains duplicate keys.", exception.message)
+    }
+}