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 freenet.keys.FreenetURI
   5 import net.pterodactylus.sone.core.FreenetInterface.BackgroundFetchCallback
   6 import net.pterodactylus.sone.test.capture
   7 import net.pterodactylus.sone.test.mock
   8 import org.hamcrest.MatcherAssert.assertThat
   9 import org.hamcrest.Matchers.`is`
  10 import org.hamcrest.Matchers.instanceOf
  11 import org.junit.Test
  12 import org.mockito.ArgumentMatchers.any
  13 import org.mockito.ArgumentMatchers.eq
  14 import org.mockito.Mockito.times
  15 import org.mockito.Mockito.verify
  16 import java.io.ByteArrayOutputStream
  17
  18 /**
  19  * Unit test for [DefaultElementLoaderTest].
  20  */
  21 class DefaultElementLoaderTest {
  22
  23         companion object {
  24                 private const val IMAGE_ID = "KSK@gpl.png"
  25                 private val freenetURI = FreenetURI(IMAGE_ID)
  26         }
  27
  28         private val freenetInterface = mock<FreenetInterface>()
  29         private val elementLoader = DefaultElementLoader(freenetInterface)
  30         private val callback = capture<BackgroundFetchCallback>()
  31
  32
  33         @Test
  34         fun `image loader starts request for link that is not known`() {
  35                 elementLoader.loadElement(IMAGE_ID)
  36                 verify(freenetInterface).startFetch(eq(freenetURI), any<BackgroundFetchCallback>())
  37         }
  38
  39         @Test
  40         fun `element loader only starts request once`() {
  41                 elementLoader.loadElement(IMAGE_ID)
  42                 elementLoader.loadElement(IMAGE_ID)
  43                 verify(freenetInterface).startFetch(eq(freenetURI), any<BackgroundFetchCallback>())
  44         }
  45
  46         @Test
  47         fun `element loader returns loading element on first call`() {
  48                 assertThat(elementLoader.loadElement(IMAGE_ID).loading, `is`(true))
  49         }
  50
  51         @Test
  52         fun `element loader does not cancel on image mime type`() {
  53                 elementLoader.loadElement(IMAGE_ID)
  54                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  55                 assertThat(callback.value.cancelForMimeType(freenetURI, "image/png"), `is`(false))
  56         }
  57
  58         @Test
  59         fun `element loader does  cancel on audio mime type`() {
  60                 elementLoader.loadElement(IMAGE_ID)
  61                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  62                 assertThat(callback.value.cancelForMimeType(freenetURI, "audio/mpeg"), `is`(true))
  63         }
  64
  65         @Test
  66         fun `element loader does not cancel on video mime type`() {
  67                 elementLoader.loadElement(IMAGE_ID)
  68                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  69                 assertThat(callback.value.cancelForMimeType(freenetURI, "video/mkv"), `is`(true))
  70         }
  71
  72         @Test
  73         fun `element loader does not cancel on text mime type`() {
  74                 elementLoader.loadElement(IMAGE_ID)
  75                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  76                 assertThat(callback.value.cancelForMimeType(freenetURI, "text/plain"), `is`(true))
  77         }
  78
  79         @Test
  80         fun `image loader can load image`() {
  81                 elementLoader.loadElement(IMAGE_ID)
  82                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  83                 callback.value.loaded(freenetURI, "image/png", read("/static/images/unknown-image-0.png"))
  84                 val linkedElement = elementLoader.loadElement(IMAGE_ID)
  85                 assertThat(linkedElement.link, `is`(IMAGE_ID))
  86                 assertThat(linkedElement.loading, `is`(false))
  87                 assertThat(linkedElement, instanceOf(LinkedImage::class.java))
  88         }
  89
  90         @Test
  91         fun `image can be loaded again after it failed`() {
  92                 elementLoader.loadElement(IMAGE_ID)
  93                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  94                 callback.value.failed(freenetURI)
  95                 elementLoader.loadElement(IMAGE_ID)
  96                 verify(freenetInterface, times(2)).startFetch(eq(freenetURI), callback.capture())
  97         }
  98
  99         private fun read(resource: String): ByteArray =
 100                         javaClass.getResourceAsStream(resource)?.use { input ->
 101                                 ByteArrayOutputStream().use {
 102                                         ByteStreams.copy(input, it)
 103                                         it
 104                                 }.toByteArray()
 105                         } ?: ByteArray(0)
 106
 107 }