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

   1 /*
   2  * Sone - IdentityLoaderTest.java - Copyright © 2013–2019 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 net.pterodactylus.sone.test.*
  21 import org.hamcrest.MatcherAssert.*
  22 import org.hamcrest.Matchers.*
  23 import org.junit.*
  24 import org.mockito.ArgumentMatchers.any
  25 import org.mockito.ArgumentMatchers.eq
  26 import org.mockito.Mockito.never
  27 import org.mockito.Mockito.verify
  28
  29 /**
  30  * Unit test for [IdentityLoader].
  31  */
  32 class IdentityLoaderTest {
  33
  34         private val webOfTrustConnector = mock<WebOfTrustConnector>()
  35         private val identityLoader = IdentityLoader(webOfTrustConnector, Context("Test"))
  36         private val identityLoaderWithoutContext = IdentityLoader(webOfTrustConnector)
  37
  38         @Before
  39         fun setup() {
  40                 val ownIdentities = createOwnIdentities()
  41                 whenever(webOfTrustConnector.loadAllOwnIdentities()).thenReturn(ownIdentities.toSet())
  42                 whenever(webOfTrustConnector.loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[0]), any())).thenReturn(createTrustedIdentitiesForFirstOwnIdentity())
  43                 whenever(webOfTrustConnector.loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[1]), any())).thenReturn(createTrustedIdentitiesForSecondOwnIdentity())
  44                 whenever(webOfTrustConnector.loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[2]), any())).thenReturn(createTrustedIdentitiesForThirdOwnIdentity())
  45                 whenever(webOfTrustConnector.loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[3]), any())).thenReturn(createTrustedIdentitiesForFourthOwnIdentity())
  46         }
  47
  48         private fun createOwnIdentities() = listOf(
  49                         createOwnIdentity("O1", "ON1", "OR1", "OI1", listOf("Test", "Test2"), mapOf("KeyA" to "ValueA", "KeyB" to "ValueB")),
  50                         createOwnIdentity("O2", "ON2", "OR2", "OI2", listOf("Test"), mapOf("KeyC" to "ValueC")),
  51                         createOwnIdentity("O3", "ON3", "OR3", "OI3", listOf("Test2"), mapOf("KeyE" to "ValueE", "KeyD" to "ValueD")),
  52                         createOwnIdentity("O4", "ON4", "OR$", "OI4", listOf("Test"), mapOf("KeyA" to "ValueA", "KeyD" to "ValueD"))
  53         )
  54
  55         private fun createTrustedIdentitiesForFirstOwnIdentity() = setOf(
  56                         createIdentity("I11", "IN11", "IR11", listOf("Test"), mapOf("KeyA" to "ValueA"))
  57         )
  58
  59         private fun createTrustedIdentitiesForSecondOwnIdentity() = setOf(
  60                         createIdentity("I21", "IN21", "IR21", listOf("Test", "Test2"), mapOf("KeyB" to "ValueB"))
  61         )
  62
  63         private fun createTrustedIdentitiesForThirdOwnIdentity() = setOf(
  64                         createIdentity("I31", "IN31", "IR31", listOf("Test", "Test3"), mapOf("KeyC" to "ValueC"))
  65         )
  66
  67         private fun createTrustedIdentitiesForFourthOwnIdentity(): Set<Identity> = emptySet()
  68
  69         private fun createOwnIdentity(id: String, nickname: String, requestUri: String, insertUri: String, contexts: List<String>, properties: Map<String, String>): OwnIdentity =
  70                         DefaultOwnIdentity(id, nickname, requestUri, insertUri).apply {
  71                                 setContexts(contexts)
  72                                 this.properties = properties
  73                         }
  74
  75         private fun createIdentity(id: String, nickname: String, requestUri: String, contexts: List<String>, properties: Map<String, String>): Identity =
  76                         DefaultIdentity(id, nickname, requestUri).apply {
  77                                 setContexts(contexts)
  78                                 this.properties = properties
  79                         }
  80
  81         @Test
  82         fun loadingIdentities() {
  83                 val ownIdentities = createOwnIdentities()
  84                 val identities = identityLoader.loadIdentities()
  85                 verify(webOfTrustConnector).loadAllOwnIdentities()
  86                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[0]), eq("Test"))
  87                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[1]), eq("Test"))
  88                 verify(webOfTrustConnector, never()).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[2]), any())
  89                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[3]), eq("Test"))
  90                 assertThat(identities.keys, hasSize(4))
  91                 assertThat(identities.keys, containsInAnyOrder(ownIdentities[0], ownIdentities[1], ownIdentities[2], ownIdentities[3]))
  92                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[0], createTrustedIdentitiesForFirstOwnIdentity())
  93                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[1], createTrustedIdentitiesForSecondOwnIdentity())
  94                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[2], emptySet())
  95                 verifyIdentitiesForOwnIdentity(identities, ownIdentities[3], createTrustedIdentitiesForFourthOwnIdentity())
  96         }
  97
  98         @Test
  99         fun loadingIdentitiesWithoutContext() {
 100                 val ownIdentities = createOwnIdentities()
 101                 val identities = identityLoaderWithoutContext.loadIdentities()
 102                 verify(webOfTrustConnector).loadAllOwnIdentities()
 103                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[0]), eq(null))
 104                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[1]), eq(null))
 105                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[2]), eq(null))
 106                 verify(webOfTrustConnector).loadTrustedIdentities(net.pterodactylus.sone.test.eq(ownIdentities[3]), eq(null))
 107                 assertThat(identities.keys, hasSize(4))
 108                 val firstOwnIdentity = ownIdentities[0]
 109                 val secondOwnIdentity = ownIdentities[1]
 110                 val thirdOwnIdentity = ownIdentities[2]
 111                 val fourthOwnIdentity = ownIdentities[3]
 112                 assertThat(identities.keys, containsInAnyOrder(firstOwnIdentity, secondOwnIdentity, thirdOwnIdentity, fourthOwnIdentity))
 113                 verifyIdentitiesForOwnIdentity(identities, firstOwnIdentity, createTrustedIdentitiesForFirstOwnIdentity())
 114                 verifyIdentitiesForOwnIdentity(identities, secondOwnIdentity, createTrustedIdentitiesForSecondOwnIdentity())
 115                 verifyIdentitiesForOwnIdentity(identities, thirdOwnIdentity, createTrustedIdentitiesForThirdOwnIdentity())
 116                 verifyIdentitiesForOwnIdentity(identities, fourthOwnIdentity, createTrustedIdentitiesForFourthOwnIdentity())
 117         }
 118
 119         private fun verifyIdentitiesForOwnIdentity(identities: Map<OwnIdentity, Collection<Identity>>, ownIdentity: OwnIdentity, trustedIdentities: Set<Identity>) {
 120                 assertThat(identities[ownIdentity], equalTo<Collection<Identity>>(trustedIdentities))
 121         }
 122
 123 }