src/test/kotlin/net/pterodactylus/sone/core/DefaultElementLoaderTest.kt

   1 package net.pterodactylus.sone.core
   2
   3 import com.google.common.io.ByteStreams
   4 import com.google.common.io.Files
   5 import freenet.keys.FreenetURI
   6 import net.pterodactylus.sone.core.FreenetInterface.BackgroundFetchCallback
   7 import net.pterodactylus.sone.test.capture
   8 import net.pterodactylus.sone.test.mock
   9 import org.hamcrest.MatcherAssert
  10 import org.hamcrest.MatcherAssert.assertThat
  11 import org.hamcrest.Matchers
  12 import org.hamcrest.Matchers.`is`
  13 import org.hamcrest.Matchers.instanceOf
  14 import org.hamcrest.Matchers.nullValue
  15 import org.junit.Test
  16 import org.mockito.ArgumentMatchers.any
  17 import org.mockito.ArgumentMatchers.eq
  18 import org.mockito.Mockito.times
  19 import org.mockito.Mockito.verify
  20 import java.io.ByteArrayOutputStream
  21
  22 /**
  23  * Unit test for [DefaultElementLoaderTest].
  24  */
  25 class DefaultElementLoaderTest {
  26
  27         companion object {
  28                 private const val IMAGE_ID = "KSK@gpl.png"
  29         }
  30
  31         private val freenetInterface = mock<FreenetInterface>()
  32         private val elementLoader = DefaultElementLoader(freenetInterface)
  33         private val callback = capture<BackgroundFetchCallback>()
  34
  35         @Test
  36         fun `image loader starts request for link that is not known`() {
  37                 elementLoader.loadElement(IMAGE_ID)
  38                 verify(freenetInterface).startFetch(eq(FreenetURI(IMAGE_ID)), any<BackgroundFetchCallback>())
  39         }
  40
  41         @Test
  42         fun `element loader only starts request once`() {
  43                 elementLoader.loadElement(IMAGE_ID)
  44                 elementLoader.loadElement(IMAGE_ID)
  45                 verify(freenetInterface).startFetch(eq(FreenetURI(IMAGE_ID)), any<BackgroundFetchCallback>())
  46         }
  47
  48         @Test
  49         fun `element loader returns loading element on first call`() {
  50                 assertThat(elementLoader.loadElement(IMAGE_ID).loading, `is`(true))
  51         }
  52
  53         @Test
  54         fun `image loader can load image`() {
  55                 elementLoader.loadElement(IMAGE_ID)
  56                 verify(freenetInterface).startFetch(eq(FreenetURI(IMAGE_ID)), callback.capture())
  57             callback.value.loaded(FreenetURI(IMAGE_ID), "image/png", read("/static/images/unknown-image-0.png"))
  58                 val linkedElement = elementLoader.loadElement(IMAGE_ID)
  59                 assertThat(linkedElement.link, `is`(IMAGE_ID))
  60                 assertThat(linkedElement.loading, `is`(false))
  61                 assertThat(linkedElement, instanceOf(LinkedImage::class.java))
  62         }
  63
  64         @Test
  65         fun `image can be loaded again after it failed`() {
  66                 elementLoader.loadElement(IMAGE_ID)
  67                 verify(freenetInterface).startFetch(eq(FreenetURI(IMAGE_ID)), callback.capture())
  68                 callback.value.failed(FreenetURI(IMAGE_ID))
  69                 elementLoader.loadElement(IMAGE_ID)
  70                 verify(freenetInterface, times(2)).startFetch(eq(FreenetURI(IMAGE_ID)), callback.capture())
  71         }
  72
  73         private fun read(resource: String): ByteArray =
  74                         javaClass.getResourceAsStream(resource)?.use { input ->
  75                                 ByteArrayOutputStream().use {
  76                                         ByteStreams.copy(input, it)
  77                                         it
  78                                 }.toByteArray()
  79                         } ?: ByteArray(0)
  80
  81 }