src/test/kotlin/net/pterodactylus/sone/template/SoneAccessorTest.kt

   1 package net.pterodactylus.sone.template
   2
   3 import net.pterodactylus.sone.core.Core
   4 import net.pterodactylus.sone.data.Album
   5 import net.pterodactylus.sone.data.Image
   6 import net.pterodactylus.sone.data.Profile
   7 import net.pterodactylus.sone.data.Sone
   8 import net.pterodactylus.sone.data.Sone.SoneStatus
   9 import net.pterodactylus.sone.data.Sone.SoneStatus.downloading
  10 import net.pterodactylus.sone.data.Sone.SoneStatus.idle
  11 import net.pterodactylus.sone.data.Sone.SoneStatus.inserting
  12 import net.pterodactylus.sone.data.Sone.SoneStatus.unknown
  13 import net.pterodactylus.sone.freenet.L10nText
  14 import net.pterodactylus.sone.freenet.wot.Identity
  15 import net.pterodactylus.sone.freenet.wot.OwnIdentity
  16 import net.pterodactylus.sone.freenet.wot.Trust
  17 import net.pterodactylus.sone.test.mock
  18 import net.pterodactylus.sone.test.whenever
  19 import net.pterodactylus.sone.text.TimeText
  20 import net.pterodactylus.sone.text.TimeTextConverter
  21 import net.pterodactylus.util.template.TemplateContext
  22 import org.hamcrest.Matcher
  23 import org.hamcrest.MatcherAssert.assertThat
  24 import org.hamcrest.Matchers.contains
  25 import org.hamcrest.Matchers.equalTo
  26 import org.junit.Before
  27 import org.junit.Test
  28
  29 /**
  30  * Unit test for [SoneAccessor].
  31  */
  32 class SoneAccessorTest {
  33
  34         private val core = mock<Core>()
  35         private val timeTextConverter = mock<TimeTextConverter>()
  36         private val accessor = SoneAccessor(core, timeTextConverter)
  37         private val templateContext = mock<TemplateContext>()
  38         private val currentSone = mock<Sone>()
  39         private val currentIdentity = mock<OwnIdentity>()
  40         private val sone = mock<Sone>()
  41         private val remoteIdentity = mock<Identity>()
  42
  43         @Before
  44         fun setupSone() {
  45                 whenever(sone.id).thenReturn("sone-id")
  46                 whenever(sone.name).thenReturn("sone-name")
  47                 whenever(sone.profile).thenReturn(Profile(sone))
  48                 whenever(sone.identity).thenReturn(remoteIdentity)
  49                 whenever(currentSone.identity).thenReturn(currentIdentity)
  50         }
  51
  52         @Before
  53         fun setupTemplateContext() {
  54                 whenever(templateContext["currentSone"]).thenReturn(currentSone)
  55         }
  56
  57         private fun assertAccessorReturnValue(member: String, expected: Any?) {
  58                 assertThat(accessor.get(templateContext, sone, member), equalTo(expected))
  59         }
  60
  61         @Suppress("UNCHECKED_CAST")
  62         private fun <T : Any> assertAccessorReturnValueMatches(member: String, matcher: Matcher<in T>) {
  63                 assertThat(accessor.get(templateContext, sone, member) as T, matcher)
  64         }
  65
  66         @Test
  67         fun `accessor returns nice name of a sone`() {
  68                 assertAccessorReturnValue("niceName", "sone-name")
  69         }
  70
  71         @Test
  72         fun `accessor returns that given sone is not a friend of the current sone if there is no current sone`() {
  73                 whenever(templateContext["currentSone"]).thenReturn(null)
  74                 assertAccessorReturnValue("friend", false)
  75         }
  76
  77         @Test
  78         fun `accessor returns that given sone is not a friend of the current sone if the given sone is not a friend`() {
  79                 assertAccessorReturnValue("friend", false)
  80         }
  81
  82         @Test
  83         fun `accessor returns that given sone is a friend of the current sone if the given sone is a friend`() {
  84                 whenever(currentSone.hasFriend("sone-id")).thenReturn(true)
  85                 assertAccessorReturnValue("friend", true)
  86         }
  87
  88         @Test
  89         fun `accessor returns that the given sone is not the current sone if there is no current sone`() {
  90                 whenever(templateContext["currentSone"]).thenReturn(null)
  91                 assertAccessorReturnValue("current", false)
  92         }
  93
  94         @Test
  95         fun `accessor returns that the given sone is not the current sone if it is not`() {
  96                 assertAccessorReturnValue("current", false)
  97         }
  98
  99         @Test
 100         fun `accessor returns that the given sone is the current sone if it is `() {
 101                 whenever(templateContext["currentSone"]).thenReturn(sone)
 102                 assertAccessorReturnValue("current", true)
 103         }
 104
 105         @Test
 106         fun `accessor returns that a sone was not modified if the sone was not modified`() {
 107                 assertAccessorReturnValue("modified", false)
 108         }
 109
 110         @Test
 111         fun `accessor returns that a sone was modified if the sone was modified`() {
 112                 whenever(core.isModifiedSone(sone)).thenReturn(true)
 113                 assertAccessorReturnValue("modified", true)
 114         }
 115
 116         @Test
 117         fun `accessor returns the sone’s status`() {
 118                 val soneStatus = mock<SoneStatus>()
 119                 whenever(sone.status).thenReturn(soneStatus)
 120                 assertAccessorReturnValue("status", soneStatus)
 121         }
 122
 123         @Test
 124         fun `accessor returns that the sone’s status is unknown if it is unknown`() {
 125                 whenever(sone.status).thenReturn(unknown)
 126                 assertAccessorReturnValue("unknown", true)
 127         }
 128
 129         @Test
 130         fun `accessor returns that the sone’s status is not unknown if it is not unknown`() {
 131                 whenever(sone.status).thenReturn(mock<SoneStatus>())
 132                 assertAccessorReturnValue("unknown", false)
 133         }
 134
 135         @Test
 136         fun `accessor returns that the sone’s status is idle if it is idle`() {
 137                 whenever(sone.status).thenReturn(idle)
 138                 assertAccessorReturnValue("idle", true)
 139         }
 140
 141         @Test
 142         fun `accessor returns that the sone’s status is not idle if it is not idle`() {
 143                 whenever(sone.status).thenReturn(mock<SoneStatus>())
 144                 assertAccessorReturnValue("idle", false)
 145         }
 146
 147         @Test
 148         fun `accessor returns that the sone’s status is inserting if it is inserting`() {
 149                 whenever(sone.status).thenReturn(inserting)
 150                 assertAccessorReturnValue("inserting", true)
 151         }
 152
 153         @Test
 154         fun `accessor returns that the sone’s status is not inserting if it is not inserting`() {
 155                 whenever(sone.status).thenReturn(mock<SoneStatus>())
 156                 assertAccessorReturnValue("inserting", false)
 157         }
 158
 159         @Test
 160         fun `accessor returns that the sone’s status is downloading if it is downloading`() {
 161                 whenever(sone.status).thenReturn(downloading)
 162                 assertAccessorReturnValue("downloading", true)
 163         }
 164
 165         @Test
 166         fun `accessor returns that the sone’s status is not downloading if it is not downloading`() {
 167                 whenever(sone.status).thenReturn(mock<SoneStatus>())
 168                 assertAccessorReturnValue("downloading", false)
 169         }
 170
 171         @Test
 172         fun `accessor returns that the sone is new if it is not known`() {
 173                 assertAccessorReturnValue("new", true)
 174         }
 175
 176         @Test
 177         fun `accessor returns that the sone is not new if it is known`() {
 178                 whenever(sone.isKnown).thenReturn(true)
 179                 assertAccessorReturnValue("new", false)
 180         }
 181
 182         @Test
 183         fun `accessor returns that the sone is not locked if it is not locked`() {
 184                 assertAccessorReturnValue("locked", false)
 185         }
 186
 187         @Test
 188         fun `accessor returns that the sone is locked if it is locked`() {
 189                 whenever(core.isLocked(sone)).thenReturn(true)
 190                 assertAccessorReturnValue("locked", true)
 191         }
 192
 193         @Test
 194         fun `accessor returns l10n text for last update time`() {
 195                 whenever(sone.time).thenReturn(12345)
 196                 whenever(timeTextConverter.getTimeText(12345L)).thenReturn(TimeText(L10nText("l10n.key", listOf(3L)), 23456))
 197                 assertAccessorReturnValue("lastUpdatedText", L10nText("l10n.key", listOf(3L)))
 198         }
 199
 200         @Test
 201         fun `accessor returns null trust if there is no current sone`() {
 202                 whenever(templateContext["currentSone"]).thenReturn(null)
 203                 assertAccessorReturnValue("trust", null)
 204         }
 205
 206         @Test
 207         fun `accessor returns trust with null values if there is no trust from the current sone`() {
 208                 assertAccessorReturnValue("trust", Trust(null, null, null))
 209         }
 210
 211         @Test
 212         fun `accessor returns trust if there is trust from the current sone`() {
 213                 val trust = mock<Trust>()
 214                 whenever(remoteIdentity.getTrust(currentIdentity)).thenReturn(trust)
 215                 assertAccessorReturnValue("trust", trust)
 216         }
 217
 218         @Test
 219         fun `accessor returns all images in the correct order`() {
 220                 val images = listOf(mock<Image>(), mock<Image>(), mock<Image>(), mock<Image>(), mock<Image>())
 221                 val firstAlbum = createAlbum(listOf(), listOf(images[0], images[3]))
 222                 val secondAlbum = createAlbum(listOf(), listOf(images[1], images[4], images[2]))
 223                 val rootAlbum = createAlbum(listOf(firstAlbum, secondAlbum), listOf())
 224                 whenever(sone.rootAlbum).thenReturn(rootAlbum)
 225                 assertAccessorReturnValueMatches("allImages", contains(images[0], images[3], images[1], images[4], images[2]))
 226         }
 227
 228         private fun createAlbum(albums: List<Album>, images: List<Image>) =
 229                         mock<Album>().apply {
 230                                 whenever(this.albums).thenReturn(albums)
 231                                 whenever(this.images).thenReturn(images)
 232                         }
 233
 234         @Test
 235         fun `accessor returns all albums in the correct order`() {
 236                 val albums = listOf(mock<Album>(), mock<Album>(), mock<Album>(), mock<Album>(), mock<Album>())
 237                 val rootAlbum = createAlbum(albums, listOf())
 238                 whenever(sone.rootAlbum).thenReturn(rootAlbum)
 239                 assertAccessorReturnValueMatches("albums", contains(*albums.toTypedArray()))
 240         }
 241
 242         @Test
 243         fun `reflection accessor is used for other members`() {
 244             assertAccessorReturnValue("hashCode", sone.hashCode())
 245         }
 246
 247 }