src/test/kotlin/net/pterodactylus/sone/freenet/wot/IdentityLoaderTest.kt

   1 /*
   2  * Sone - IdentityLoaderTest.kt - Copyright © 2013–2020 David Roden
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.pterodactylus.sone.freenet.wot
  19
  20 import org.hamcrest.MatcherAssert.assertThat
  21 import org.hamcrest.Matchers.containsInAnyOrder
  22 import org.hamcrest.Matchers.equalTo
  23 import org.hamcrest.Matchers.hasSize
  24 import org.hamcrest.Matchers.notNullValue
  25 import org.junit.Test
  26
  27 /**
  28  * Unit test for [IdentityLoader].
  29  */
  30 class IdentityLoaderTest {
  31
  32         private val ownIdentities = createOwnIdentities()
  33         private val webOfTrustConnector = object : TestWebOfTrustConnector() {
  34                 override fun loadAllOwnIdentities() = ownIdentities.toSet()
  35                 override fun loadTrustedIdentities(ownIdentity: OwnIdentity, context: String?) =
  36                                 when (ownIdentity) {
  37                                         ownIdentities[0] -> createTrustedIdentitiesForFirstOwnIdentity()
  38                                         ownIdentities[1] -> createTrustedIdentitiesForSecondOwnIdentity()
  39                                         ownIdentities[2] -> createTrustedIdentitiesForThirdOwnIdentity()
  40                                         ownIdentities[3] -> createTrustedIdentitiesForFourthOwnIdentity()
  41                                         else -> throw RuntimeException()
  42                                 }
  43         }
  44
  45         @Test
  46         fun loadingIdentities() {
  47                 val identityLoader = IdentityLoader(webOfTrustConnector, Context("Test"))
  48                 val identities = identityLoader.loadTrustedIdentities()
  49                 assertThat(identities.keys, hasSize(4))
  50                 assertThat(identities.keys, containsInAnyOrder(ownIdentities[0], ownIdentities[1], ownIdentities[2], ownIdentities[3]))
  51                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[0], createTrustedIdentitiesForFirstOwnIdentity())
  52                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[1], createTrustedIdentitiesForSecondOwnIdentity())
  53                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[2], emptySet())
  54                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[3], createTrustedIdentitiesForFourthOwnIdentity())
  55         }
  56
  57         @Test
  58         fun loadingIdentitiesWithoutContext() {
  59                 val identityLoaderWithoutContext = IdentityLoader(webOfTrustConnector)
  60                 val identities = identityLoaderWithoutContext.loadTrustedIdentities()
  61                 assertThat(identities.keys, hasSize(4))
  62                 assertThat(identities.keys, containsInAnyOrder(ownIdentities[0], ownIdentities[1], ownIdentities[2], ownIdentities[3]))
  63                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[0], createTrustedIdentitiesForFirstOwnIdentity())
  64                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[1], createTrustedIdentitiesForSecondOwnIdentity())
  65                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[2], createTrustedIdentitiesForThirdOwnIdentity())
  66                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[3], createTrustedIdentitiesForFourthOwnIdentity())
  67         }
  68
  69         private fun verifyIdentitiesForOwnIdentity(identities: Map<OwnIdentity, Collection<Identity>>, ownIdentity: OwnIdentity, trustedIdentities: Set<Identity>) {
  70                 assertThat(identities[ownIdentity], equalTo<Collection<Identity>>(trustedIdentities))
  71         }
  72
  73         @Test
  74         fun `loading all identities merges remote identities’ trust values`() {
  75                 val ownIdentity1 = createOwnIdentity("o1")
  76                 val ownIdentity2 = createOwnIdentity("o2")
  77                 val webOfTrustConnector = object : TestWebOfTrustConnector() {
  78                         override fun loadAllOwnIdentities() = setOf(ownIdentity1, ownIdentity2)
  79                         override fun loadAllIdentities(ownIdentity: OwnIdentity, context: String?) = when (ownIdentity) {
  80                                 ownIdentity1 -> setOf(createIdentity().setTrust(ownIdentity1, Trust(100, 50, 2)))
  81                                 else -> setOf(createIdentity().setTrust(ownIdentity2, Trust(80, 40, 2)))
  82                         }
  83                 }
  84                 val identityLoader = IdentityLoader(webOfTrustConnector)
  85                 val allIdentities = identityLoader.loadAllIdentities()
  86                 assertThat(allIdentities[ownIdentity1]!!.first().trust[ownIdentity2], notNullValue())
  87         }
  88
  89         @Test
  90         fun `loading trusted identities merges remote identities’ trust values`() {
  91                 val ownIdentity1 = createOwnIdentity("o1")
  92                 val ownIdentity2 = createOwnIdentity("o2")
  93                 val webOfTrustConnector = object : TestWebOfTrustConnector() {
  94                         override fun loadAllOwnIdentities() = setOf(ownIdentity1, ownIdentity2)
  95                         override fun loadTrustedIdentities(ownIdentity: OwnIdentity, context: String?) = when (ownIdentity) {
  96                                 ownIdentity1 -> setOf(createIdentity().setTrust(ownIdentity1, Trust(100, 50, 2)))
  97                                 else -> setOf(createIdentity().setTrust(ownIdentity2, Trust(80, 40, 2)))
  98                         }
  99                 }
 100                 val identityLoader = IdentityLoader(webOfTrustConnector)
 101                 val allIdentities = identityLoader.loadTrustedIdentities()
 102                 assertThat(allIdentities[ownIdentity1]!!.first().trust[ownIdentity2], notNullValue())
 103         }
 104
 105 }
 106
 107 private fun createOwnIdentities() = listOf(
 108                 createOwnIdentity("O1", "ON1", "OR1", "OI1", setOf("Test", "Test2"), mapOf("KeyA" to "ValueA", "KeyB" to "ValueB")),
 109                 createOwnIdentity("O2", "ON2", "OR2", "OI2", setOf("Test"), mapOf("KeyC" to "ValueC")),
 110                 createOwnIdentity("O3", "ON3", "OR3", "OI3", setOf("Test2"), mapOf("KeyE" to "ValueE", "KeyD" to "ValueD")),
 111                 createOwnIdentity("O4", "ON4", "OR$", "OI4", setOf("Test"), mapOf("KeyA" to "ValueA", "KeyD" to "ValueD"))
 112 )
 113
 114 private fun createTrustedIdentitiesForFirstOwnIdentity() = setOf(
 115                 createIdentity("I11", "IN11", "IR11", setOf("Test"), mapOf("KeyA" to "ValueA"))
 116 )
 117
 118 private fun createTrustedIdentitiesForSecondOwnIdentity() = setOf(
 119                 createIdentity("I21", "IN21", "IR21", setOf("Test", "Test2"), mapOf("KeyB" to "ValueB"))
 120 )
 121
 122 private fun createTrustedIdentitiesForThirdOwnIdentity() = setOf(
 123                 createIdentity("I31", "IN31", "IR31", setOf("Test", "Test3"), mapOf("KeyC" to "ValueC"))
 124 )
 125
 126 private fun createTrustedIdentitiesForFourthOwnIdentity(): Set<Identity> = emptySet()
 127
 128 private fun createOwnIdentity(id: String = "", nickname: String = "", requestUri: String = "", insertUri: String = "", contexts: Set<String> = setOf(), properties: Map<String, String> = mapOf()): OwnIdentity =
 129                 DefaultOwnIdentity(id, nickname, requestUri, insertUri).apply {
 130                         setContexts(contexts)
 131                         this.properties = properties
 132                 }
 133
 134 private fun createIdentity(id: String = "", nickname: String = "", requestUri: String = "", contexts: Set<String> = setOf(), properties: Map<String, String> = mapOf()): Identity =
 135                 DefaultIdentity(id, nickname, requestUri).apply {
 136                         setContexts(contexts)
 137                         this.properties = properties
 138                 }
 139
 140 private open class TestWebOfTrustConnector : WebOfTrustConnector {
 141
 142         override fun loadAllOwnIdentities() = emptySet<OwnIdentity>()
 143         override fun loadTrustedIdentities(ownIdentity: OwnIdentity, context: String?) = emptySet<Identity>()
 144         override fun loadAllIdentities(ownIdentity: OwnIdentity, context: String?) = emptySet<Identity>()
 145         override fun addContext(ownIdentity: OwnIdentity, context: String) = Unit
 146         override fun removeContext(ownIdentity: OwnIdentity, context: String) = Unit
 147         override fun setProperty(ownIdentity: OwnIdentity, name: String, value: String) = Unit
 148         override fun removeProperty(ownIdentity: OwnIdentity, name: String) = Unit
 149         override fun ping() = Unit
 150
 151 }