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

   1 package net.pterodactylus.sone.core
   2
   3 import freenet.keys.*
   4 import net.pterodactylus.sone.data.*
   5 import net.pterodactylus.sone.test.*
   6 import org.hamcrest.MatcherAssert.*
   7 import org.hamcrest.Matchers.equalTo
   8 import org.mockito.ArgumentMatchers.any
   9 import org.mockito.ArgumentMatchers.eq
  10 import org.mockito.Mockito.doAnswer
  11 import org.mockito.Mockito.never
  12 import org.mockito.Mockito.verify
  13 import kotlin.test.Test
  14
  15 /**
  16  * Unit test for [SoneRescuer].
  17  */
  18 class SoneRescuerTest {
  19
  20         private val core = mock<Core>()
  21         private val soneDownloader = mock<SoneDownloader>()
  22         private val sone = mock<Sone>().apply {
  23                 val soneUri = mock<FreenetURI>()
  24                 whenever(soneUri.edition).thenReturn(currentEdition)
  25                 whenever(requestUri).thenReturn(soneUri)
  26         }
  27         private val soneRescuer = SoneRescuer(core, soneDownloader, sone)
  28
  29         @Test
  30         fun newSoneRescuerIsNotFetchingAnything() {
  31                 assertThat(soneRescuer.isFetching, equalTo(false))
  32         }
  33
  34         @Test
  35         fun newSoneRescuerStartsAtCurrentEditionOfSone() {
  36                 assertThat(soneRescuer.currentEdition, equalTo(currentEdition))
  37         }
  38
  39         @Test
  40         fun newSoneRescuerHasANextEditionToGet() {
  41                 assertThat(soneRescuer.hasNextEdition(), equalTo(true))
  42         }
  43
  44         @Test
  45         fun soneRescuerDoesNotHaveANextEditionIfCurrentEditionIsZero() {
  46                 whenever(sone.requestUri.edition).thenReturn(0L)
  47                 val soneRescuer = SoneRescuer(core, soneDownloader, sone)
  48                 assertThat(soneRescuer.hasNextEdition(), equalTo(false))
  49         }
  50
  51         @Test
  52         fun nextEditionIsOneSmallerThanTheCurrentEdition() {
  53                 assertThat(soneRescuer.nextEdition, equalTo(currentEdition - 1))
  54         }
  55
  56         @Test
  57         fun lastFetchOfANewSoneRescuerWasSuccessful() {
  58                 assertThat(soneRescuer.isLastFetchSuccessful, equalTo(true))
  59         }
  60
  61         @Test
  62         fun mainLoopStopsWhenItShould() {
  63                 soneRescuer.stop()
  64                 soneRescuer.serviceRun()
  65         }
  66
  67         @Test
  68         fun successfulInsert() {
  69                 val fetchedSone = mock<Sone>()
  70                 returnUriOnInsert(fetchedSone, currentEdition - 1)
  71                 soneRescuer.startNextFetch()
  72                 soneRescuer.serviceRun()
  73                 verify(core).lockSone(eq(sone))
  74                 verify(core).updateSone(eq(fetchedSone), eq(true))
  75                 assertThat(soneRescuer.isLastFetchSuccessful, equalTo(true))
  76                 assertThat(soneRescuer.isFetching, equalTo(false))
  77                 assertThat(soneRescuer.currentEdition, equalTo(currentEdition - 1))
  78         }
  79
  80         @Test
  81         fun `starting fetch with skipping one edition skips one edition`() {
  82                 val fetchedSone = mock<Sone>()
  83                 returnUriOnInsert(fetchedSone, currentEdition - 2)
  84                 soneRescuer.startNextFetchWithSkip()
  85                 soneRescuer.serviceRun()
  86                 verify(core).lockSone(eq(sone))
  87                 verify(core).updateSone(eq(fetchedSone), eq(true))
  88                 assertThat(soneRescuer.isLastFetchSuccessful, equalTo(true))
  89                 assertThat(soneRescuer.isFetching, equalTo(false))
  90                 assertThat(soneRescuer.currentEdition, equalTo(currentEdition - 2))
  91         }
  92
  93         @Test
  94         fun nonSuccessfulInsertIsRecognized() {
  95                 returnUriOnInsert(null, (currentEdition - 1))
  96                 soneRescuer.startNextFetch()
  97                 soneRescuer.serviceRun()
  98                 verify(core).lockSone(eq(sone))
  99                 verify(core, never()).updateSone(any(Sone::class.java), eq(true))
 100                 assertThat(soneRescuer.isLastFetchSuccessful, equalTo(false))
 101                 assertThat(soneRescuer.isFetching, equalTo(false))
 102                 assertThat(soneRescuer.currentEdition, equalTo(currentEdition))
 103         }
 104
 105         private fun returnUriOnInsert(fetchedSone: Sone?, edition: Long) {
 106                 val keyWithMetaStrings = setupFreenetUri(edition)
 107                 doAnswer {
 108                         soneRescuer.stop()
 109                         fetchedSone
 110                 }.whenever(soneDownloader).fetchSone(eq(sone), eq(keyWithMetaStrings), eq(true))
 111         }
 112
 113         private fun setupFreenetUri(edition: Long): FreenetURI {
 114                 val sskKey = mock<FreenetURI>()
 115                 val keyWithDocName = mock<FreenetURI>()
 116                 val keyWithMetaStrings = mock<FreenetURI>()
 117                 whenever(keyWithDocName.setMetaString(eq(arrayOf("sone.xml")))).thenReturn(keyWithMetaStrings)
 118                 whenever(sskKey.setDocName(eq("Sone-" + edition))).thenReturn(keyWithDocName)
 119                 whenever(sone.requestUri.setKeyType(eq("SSK"))).thenReturn(sskKey)
 120                 return keyWithMetaStrings
 121         }
 122
 123 }
 124
 125 private const val currentEdition = 12L