working container with adding keys

src/commonTest/kotlin/ContainerTest.kt

@@ -1,9 +1,6 @@
 import com.ionspin.kotlin.crypto.util.encodeToUByteArray
 import kotlinx.coroutines.test.runTest
-import net.sergeych.crypto2.Asymmetric
-import net.sergeych.crypto2.Container
-import net.sergeych.crypto2.SymmetricKey
-import net.sergeych.crypto2.initCrypto
+import net.sergeych.crypto2.*
 import kotlin.test.*
 
 class ContainerTest {
@@ -14,7 +11,7 @@ class ContainerTest {
         val syk2 = SymmetricKey.random()
         val data = "sergeych, ohm many.".encodeToUByteArray()
 
-        val c = Container.create(data, syk1)
+        val c = Container.createWith(data, syk1)
         assertFalse { c.isDecrypted }
         val c1 = Container.decode(c.encoded)
         assertFalse { c.isDecrypted }
@@ -35,7 +32,7 @@ class ContainerTest {
         val p3 = Asymmetric.generateKeys()
         val data = "sergeych, ohm many.".encodeToUByteArray()
 
-        val c = Container.create(data, p1.secretKey to p2.publicKey)
+        val c = Container.createWith(data, p1.secretKey to p2.publicKey)
         assertFalse { c.isDecrypted }
         val c1 = Container.decode(c.encoded)
         assertFalse { c.isDecrypted }
@@ -74,13 +71,125 @@ class ContainerTest {
         initCrypto()
         val syk1 = SymmetricKey.random()
         val syk2 = SymmetricKey.random()
-//        val syk3 = SymmetricKey.random()
+        val syk3 = SymmetricKey.random()
+        val p1 = Asymmetric.generateKeys()
+        val p2 = Asymmetric.generateKeys()
+        val p3 = Asymmetric.generateKeys()
+        val p4 = Asymmetric.generateKeys()
         val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
             .encodeToUByteArray()
 
-        val c = Container.create(data, syk1, syk2)
+        val c = Container.createWith(data, syk1, syk2) {
+            key(p1.secretKey to p3.publicKey)
+            key(p4.publicKey)
+        }
         assertFalse { c.isDecrypted }
-        val c1 = Container.decode(c.encoded)
+        var c1 = Container.decode(c.encoded)
         assertFalse { c1.isDecrypted }
+
+        assertNull(c1.decryptWith(syk3))
+        assertFalse { c1.isDecrypted }
+
+        assertContentEquals(data, c1.decryptWith(syk3, syk1))
+        assertTrue { c1.isDecrypted }
+
+        c1 = Container.decode(c.encoded)
+        assertFalse { c1.isDecrypted }
+        assertNull(c1.decryptWith(p2.secretKey, p1.secretKey))
+        assertContentEquals(data, c1.decryptWith(syk3, p3.secretKey))
+
+        c1 = Container.decode(c.encoded)
+        assertFalse { c1.isDecrypted }
+        assertContentEquals(data, c1.decryptWith(syk3, p4.secretKey))
+    }
+
+    @Test
+    fun testSingleGrowSymmetric() = runTest {
+        initCrypto()
+        val syk1 = SymmetricKey.random()
+        val syk2 = SymmetricKey.random()
+        val syk3 = SymmetricKey.random()
+        val p1 = Asymmetric.generateKeys()
+        val p3 = Asymmetric.generateKeys()
+        val p4 = Asymmetric.generateKeys()
+        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
+            .encodeToUByteArray()
+
+        var c = Container.createWith(data, syk1)
+
+        fun expectOpen(k: DecryptingKey) {
+            val c1 = Container.decode(c.encoded)
+            assertContentEquals(data, c1.decryptWith(k))
+        }
+
+        fun expectNotOpen(k: DecryptingKey) {
+            val c1 = Container.decode(c.encoded)
+            assertNull(c1.decryptWith(k))
+        }
+
+        expectOpen(syk1)
+        expectNotOpen(syk2)
+        expectNotOpen(p3.secretKey)
+
+        c.decryptWith(syk1)
+        assertTrue { c.isDecrypted }
+        assertNotNull(c.decryptedData)
+        c += syk2
+        expectOpen(syk1)
+        expectOpen(syk2)
+        expectNotOpen(syk3)
+        expectNotOpen(p3.secretKey)
+
+        c.decryptWith(syk1)
+        c += p3.publicKey
+        expectOpen(syk1)
+        expectOpen(syk2)
+        expectOpen(p3.secretKey)
+        expectNotOpen(syk3)
+        expectNotOpen(p4.secretKey)
+
+        c.decryptWith(syk1)
+        c += p1.secretKey to p4.publicKey
+        expectOpen(syk1)
+        expectOpen(syk2)
+        expectOpen(p3.secretKey)
+        expectNotOpen(syk3)
+        expectOpen(p4.secretKey)
+    }
+
+    @Test
+    fun testSingleGrowAsymmetric() = runTest {
+        initCrypto()
+        val syk1 = SymmetricKey.random()
+        val syk2 = SymmetricKey.random()
+        val syk3 = SymmetricKey.random()
+        val p1 = Asymmetric.generateKeys()
+        val p2 = Asymmetric.generateKeys()
+        val p3 = Asymmetric.generateKeys()
+        val p4 = Asymmetric.generateKeys()
+        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
+            .encodeToUByteArray()
+
+        var c = Container.createWith(data, p1.secretKey to p3.publicKey)
+
+        fun expectOpen(k: DecryptingKey) {
+            val c1 = Container.decode(c.encoded)
+            assertContentEquals(data, c1.decryptWith(k))
+        }
+
+        fun expectNotOpen(k: DecryptingKey) {
+            val c1 = Container.decode(c.encoded)
+            assertNull(c1.decryptWith(k))
+        }
+
+        expectNotOpen(syk1)
+        expectOpen(p3.secretKey)
+
+        c.decryptWith(p3.secretKey)
+
+        c += syk1
+        expectOpen(syk1)
+        expectNotOpen(syk2)
+        expectOpen(p3.secretKey)
     }
 }