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

   1 package net.pterodactylus.sone.core
   2
   3 import com.google.common.base.Ticker
   4 import com.google.common.io.ByteStreams
   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.assertThat
  10 import org.hamcrest.Matchers.`is`
  11 import org.junit.Test
  12 import org.mockito.ArgumentMatchers.any
  13 import org.mockito.ArgumentMatchers.eq
  14 import org.mockito.Mockito.`when`
  15 import org.mockito.Mockito.times
  16 import org.mockito.Mockito.verify
  17 import java.io.ByteArrayOutputStream
  18 import java.util.concurrent.TimeUnit
  19
  20 /**
  21  * Unit test for [DefaultElementLoaderTest].
  22  */
  23 class DefaultElementLoaderTest {
  24
  25         companion object {
  26                 private const val IMAGE_ID = "KSK@gpl.png"
  27                 private val freenetURI = FreenetURI(IMAGE_ID)
  28                 private const val decomposedKey = "CHK@DCiVgTWW9nnWHJc9EVwtFJ6jAfBSVyy~rgiPvhUKbS4,mNY85V0x7dYcv7SnEYo1PCC6y2wNWMDNt-y9UWQx9fI,AAMC--8/fru%CC%88hstu%CC%88ck.jpg"
  29                 private const val normalizedKey = "CHK@DCiVgTWW9nnWHJc9EVwtFJ6jAfBSVyy~rgiPvhUKbS4,mNY85V0x7dYcv7SnEYo1PCC6y2wNWMDNt-y9UWQx9fI,AAMC--8/frühstück.jpg"
  30         }
  31
  32         private val freenetInterface = mock<FreenetInterface>()
  33         private val ticker = mock<Ticker>()
  34         private val elementLoader = DefaultElementLoader(freenetInterface, ticker)
  35         private val callback = capture<BackgroundFetchCallback>()
  36
  37         @Test
  38         fun `image loader starts request for link that is not known`() {
  39                 elementLoader.loadElement(IMAGE_ID)
  40                 verify(freenetInterface).startFetch(eq(freenetURI), any<BackgroundFetchCallback>())
  41         }
  42
  43         @Test
  44         fun `element loader only starts request once`() {
  45                 elementLoader.loadElement(IMAGE_ID)
  46                 elementLoader.loadElement(IMAGE_ID)
  47                 verify(freenetInterface).startFetch(eq(freenetURI), any<BackgroundFetchCallback>())
  48         }
  49
  50         @Test
  51         fun `element loader returns loading element on first call`() {
  52                 assertThat(elementLoader.loadElement(IMAGE_ID).loading, `is`(true))
  53         }
  54
  55         @Test
  56         fun `element loader does not cancel on image mime type`() {
  57                 elementLoader.loadElement(IMAGE_ID)
  58                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  59                 assertThat(callback.value.cancelForMimeType(freenetURI, "image/png"), `is`(false))
  60         }
  61
  62         @Test
  63         fun `element loader does  cancel on audio mime type`() {
  64                 elementLoader.loadElement(IMAGE_ID)
  65                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  66                 assertThat(callback.value.cancelForMimeType(freenetURI, "audio/mpeg"), `is`(true))
  67         }
  68
  69         @Test
  70         fun `element loader does not cancel on video mime type`() {
  71                 elementLoader.loadElement(IMAGE_ID)
  72                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  73                 assertThat(callback.value.cancelForMimeType(freenetURI, "video/mkv"), `is`(true))
  74         }
  75
  76         @Test
  77         fun `element loader does not cancel on text mime type`() {
  78                 elementLoader.loadElement(IMAGE_ID)
  79                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  80                 assertThat(callback.value.cancelForMimeType(freenetURI, "text/plain"), `is`(true))
  81         }
  82
  83         @Test
  84         fun `image loader can load image`() {
  85                 elementLoader.loadElement(decomposedKey)
  86                 verify(freenetInterface).startFetch(eq(FreenetURI(decomposedKey)), callback.capture())
  87                 callback.value.loaded(FreenetURI(normalizedKey), "image/png", read("/static/images/unknown-image-0.png"))
  88                 val linkedElement = elementLoader.loadElement(decomposedKey)
  89                 assertThat(linkedElement, `is`(LinkedElement(normalizedKey)))
  90         }
  91
  92         @Test
  93         fun `image is not loaded again after it failed`() {
  94                 elementLoader.loadElement(IMAGE_ID)
  95                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  96                 callback.value.failed(freenetURI)
  97                 assertThat(elementLoader.loadElement(IMAGE_ID).failed, `is`(true))
  98                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
  99         }
 100
 101         @Test
 102         fun `image is loaded again after failure cache is expired`() {
 103                 elementLoader.loadElement(IMAGE_ID)
 104                 verify(freenetInterface).startFetch(eq(freenetURI), callback.capture())
 105                 callback.value.failed(freenetURI)
 106                 `when`(ticker.read()).thenReturn(TimeUnit.MINUTES.toNanos(31))
 107                 val linkedElement = elementLoader.loadElement(IMAGE_ID)
 108                 assertThat(linkedElement.failed, `is`(false))
 109                 assertThat(linkedElement.loading, `is`(true))
 110                 verify(freenetInterface, times(2)).startFetch(eq(freenetURI), callback.capture())
 111         }
 112
 113         private fun read(resource: String): ByteArray =
 114                         javaClass.getResourceAsStream(resource)?.use { input ->
 115                                 ByteArrayOutputStream().use {
 116                                         ByteStreams.copy(input, it)
 117                                         it
 118                                 }.toByteArray()
 119                         } ?: ByteArray(0)
 120
 121 }