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

   1 /*
   2  * Sone - IdentityChangeEventSenderTest.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 com.google.common.eventbus.EventBus
  21 import com.google.common.eventbus.Subscribe
  22 import net.pterodactylus.sone.freenet.wot.event.IdentityAddedEvent
  23 import net.pterodactylus.sone.freenet.wot.event.IdentityRemovedEvent
  24 import net.pterodactylus.sone.freenet.wot.event.IdentityUpdatedEvent
  25 import net.pterodactylus.sone.freenet.wot.event.OwnIdentityAddedEvent
  26 import net.pterodactylus.sone.freenet.wot.event.OwnIdentityRemovedEvent
  27 import org.hamcrest.MatcherAssert.assertThat
  28 import org.hamcrest.Matchers.contains
  29 import org.hamcrest.Matchers.containsInAnyOrder
  30 import org.junit.Test
  31
  32 /**
  33  * Unit test for [IdentityChangeEventSender].
  34  */
  35 class IdentityChangeEventSenderTest {
  36
  37         private val eventBus = EventBus()
  38         private val ownIdentities = listOf(
  39                         createOwnIdentity("O1", setOf("Test"), "KeyA" to "ValueA"),
  40                         createOwnIdentity("O2", setOf("Test2"), "KeyB" to "ValueB"),
  41                         createOwnIdentity("O3", setOf("Test3"), "KeyC" to "ValueC")
  42         )
  43         private val identities = listOf(
  44                         createIdentity("I1", setOf()),
  45                         createIdentity("I2", setOf()),
  46                         createIdentity("I3", setOf()),
  47                         createIdentity("I2", setOf("Test"))
  48         )
  49         private val identityChangeEventSender = IdentityChangeEventSender(eventBus, createOldIdentities())
  50
  51         @Test
  52         fun addingAnOwnIdentityIsDetectedAndReportedCorrectly() {
  53                 val newIdentities = createNewIdentities()
  54                 val ownIdentityRemovedEvents = mutableListOf<OwnIdentityRemovedEvent>()
  55                 eventBus.register(object {
  56                         @Subscribe
  57                         fun ownIdentityRemoved(ownIdentityRemovedEvent: OwnIdentityRemovedEvent) {
  58                                 ownIdentityRemovedEvents += ownIdentityRemovedEvent
  59                         }
  60                 })
  61                 val identityRemovedEvents = mutableListOf<IdentityRemovedEvent>()
  62                 eventBus.register(object {
  63                         @Subscribe
  64                         fun identityRemovedEvent(identityRemovedEvent: IdentityRemovedEvent) {
  65                                 identityRemovedEvents += identityRemovedEvent
  66                         }
  67                 })
  68                 val owIdentityAddedEvents = mutableListOf<OwnIdentityAddedEvent>()
  69                 eventBus.register(object {
  70                         @Subscribe
  71                         fun ownIdentityAdded(ownIdentityAddedEvent: OwnIdentityAddedEvent) {
  72                                 owIdentityAddedEvents += ownIdentityAddedEvent
  73                         }
  74                 })
  75                 val identityAddedEvents = mutableListOf<IdentityAddedEvent>()
  76                 eventBus.register(object {
  77                         @Subscribe
  78                         fun identityAdded(identityAddedEvent: IdentityAddedEvent) {
  79                                 identityAddedEvents += identityAddedEvent
  80                         }
  81                 })
  82                 val identityUpdatedEvents = mutableListOf<IdentityUpdatedEvent>()
  83                 eventBus.register(object {
  84                         @Subscribe
  85                         fun identityUpdatedEvent(identityUpdatedEvent: IdentityUpdatedEvent) {
  86                                 identityUpdatedEvents += identityUpdatedEvent
  87                         }
  88                 })
  89                 identityChangeEventSender.detectChanges(newIdentities)
  90                 assertThat(ownIdentityRemovedEvents, contains(OwnIdentityRemovedEvent(ownIdentities[0])))
  91                 assertThat(identityRemovedEvents, containsInAnyOrder(
  92                                 IdentityRemovedEvent(ownIdentities[0], identities[0]),
  93                                 IdentityRemovedEvent(ownIdentities[0], identities[1]),
  94                                 IdentityRemovedEvent(ownIdentities[1], identities[0])
  95                 ))
  96                 assertThat(owIdentityAddedEvents, contains(OwnIdentityAddedEvent(ownIdentities[2])))
  97                 assertThat(identityAddedEvents, containsInAnyOrder(
  98                                 IdentityAddedEvent(ownIdentities[2], identities[1]),
  99                                 IdentityAddedEvent(ownIdentities[2], identities[2]),
 100                                 IdentityAddedEvent(ownIdentities[1], identities[2])
 101                 ))
 102                 assertThat(identityUpdatedEvents, contains(IdentityUpdatedEvent(ownIdentities[1], identities[1])))
 103         }
 104
 105         private fun createNewIdentities() = mapOf(
 106                         ownIdentities[1] to listOf(identities[3], identities[2]),
 107                         ownIdentities[2] to listOf(identities[1], identities[2])
 108         )
 109
 110         private fun createOldIdentities() = mapOf(
 111                         ownIdentities[0] to listOf(identities[0], identities[1]),
 112                         ownIdentities[1] to listOf(identities[0], identities[1])
 113         )
 114
 115 }