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

   1 package net.pterodactylus.sone.core
   2
   3 import com.google.common.eventbus.*
   4 import freenet.client.*
   5 import freenet.client.FetchException.FetchExceptionMode.*
   6 import freenet.client.InsertException.*
   7 import freenet.client.async.*
   8 import freenet.crypt.*
   9 import freenet.keys.*
  10 import freenet.keys.InsertableClientSSK.*
  11 import freenet.node.*
  12 import freenet.node.RequestStarter.*
  13 import freenet.support.Base64
  14 import freenet.support.api.*
  15 import freenet.support.io.*
  16 import net.pterodactylus.sone.core.FreenetInterface.*
  17 import net.pterodactylus.sone.core.event.*
  18 import net.pterodactylus.sone.data.*
  19 import net.pterodactylus.sone.data.impl.*
  20 import net.pterodactylus.sone.test.*
  21 import net.pterodactylus.sone.test.Matchers.*
  22 import net.pterodactylus.sone.test.TestUtil.*
  23 import org.hamcrest.MatcherAssert.*
  24 import org.hamcrest.Matchers.equalTo
  25 import org.hamcrest.Matchers.notNullValue
  26 import org.hamcrest.Matchers.nullValue
  27 import org.junit.*
  28 import org.junit.rules.*
  29 import org.mockito.*
  30 import org.mockito.ArgumentCaptor.*
  31 import org.mockito.ArgumentMatchers.eq
  32 import org.mockito.Mockito.*
  33 import java.io.*
  34 import java.util.*
  35
  36 /**
  37  * Unit test for [FreenetInterface].
  38  */
  39 class FreenetInterfaceTest {
  40
  41         @Rule
  42         @JvmField
  43         val expectionException: ExpectedException = ExpectedException.none()
  44
  45         @Suppress("UnstableApiUsage")
  46         private val eventBus = mock<EventBus>()
  47         private val node = mock<Node>()
  48         private val nodeClientCore = mock<NodeClientCore>()
  49         private val highLevelSimpleClient: HighLevelSimpleClient = mock(HighLevelSimpleClient::class.java, withSettings().extraInterfaces(RequestClient::class.java))
  50         private val randomSource = DummyRandomSource()
  51         private val uskManager = mock<USKManager>()
  52         private val sone = mock<Sone>()
  53         private val callbackCaptor: ArgumentCaptor<USKCallback> = forClass(USKCallback::class.java)
  54         private val image = mock<Image>()
  55         private val insertToken: InsertToken
  56         private val bucket = mock<Bucket>()
  57         private val clientGetCallback: ArgumentCaptor<ClientGetCallback> = forClass(ClientGetCallback::class.java)
  58         private val uri = FreenetURI("KSK@pgl.png")
  59         private val fetchResult = mock<FetchResult>()
  60         private val backgroundFetchCallback = mock<BackgroundFetchCallback>()
  61         private val clientGetter = mock<ClientGetter>()
  62         private val freenetInterface: FreenetInterface
  63
  64         init {
  65                 whenever(nodeClientCore.makeClient(anyShort(), anyBoolean(), anyBoolean())).thenReturn(highLevelSimpleClient)
  66                 setField(node, "clientCore", nodeClientCore)
  67                 setField(node, "random", randomSource)
  68                 setField(nodeClientCore, "uskManager", uskManager)
  69                 setField(nodeClientCore, "clientContext", mock<ClientContext>())
  70                 freenetInterface = FreenetInterface(eventBus, node)
  71                 insertToken = freenetInterface.InsertToken(image)
  72                 insertToken.setBucket(bucket)
  73         }
  74
  75         @Before
  76         fun setupHighLevelSimpleClient() {
  77                 whenever(highLevelSimpleClient.fetchContext).thenReturn(mock())
  78                 whenever(highLevelSimpleClient.fetch(eq(uri), anyLong(), any(ClientGetCallback::class.java), any(FetchContext::class.java), anyShort())).thenReturn(clientGetter)
  79         }
  80
  81         @Before
  82         fun setupSone() {
  83                 val insertSsk = createRandom(randomSource, "test-0")
  84                 whenever(sone.id).thenReturn(Base64.encode(insertSsk.uri.routingKey))
  85                 whenever(sone.requestUri).thenReturn(insertSsk.uri.uskForSSK())
  86         }
  87
  88         @Before
  89         fun setupCallbackCaptorAndUskManager() {
  90                 doNothing().`when`(uskManager).subscribe(any(USK::class.java), callbackCaptor.capture(), anyBoolean(), any(RequestClient::class.java))
  91         }
  92
  93         @Test
  94         fun `can fetch uri`() {
  95                 val freenetUri = FreenetURI("KSK@GPLv3.txt")
  96                 val fetchResult = createFetchResult()
  97                 whenever(highLevelSimpleClient.fetch(freenetUri)).thenReturn(fetchResult)
  98                 val fetched = freenetInterface.fetchUri(freenetUri)
  99                 assertThat(fetched, notNullValue())
 100                 assertThat(fetched!!.fetchResult, equalTo(fetchResult))
 101                 assertThat(fetched.freenetUri, equalTo(freenetUri))
 102         }
 103
 104         @Test
 105         fun `fetch follows redirect`() {
 106                 val freenetUri = FreenetURI("KSK@GPLv2.txt")
 107                 val newFreenetUri = FreenetURI("KSK@GPLv3.txt")
 108                 val fetchResult = createFetchResult()
 109                 val fetchException = FetchException(PERMANENT_REDIRECT, newFreenetUri)
 110                 whenever(highLevelSimpleClient.fetch(freenetUri)).thenThrow(fetchException)
 111                 whenever(highLevelSimpleClient.fetch(newFreenetUri)).thenReturn(fetchResult)
 112                 val fetched = freenetInterface.fetchUri(freenetUri)
 113                 assertThat(fetched!!.fetchResult, equalTo(fetchResult))
 114                 assertThat(fetched.freenetUri, equalTo(newFreenetUri))
 115         }
 116
 117         @Test
 118         fun `fetch returns null on fetch exceptions`() {
 119                 val freenetUri = FreenetURI("KSK@GPLv2.txt")
 120                 val fetchException = FetchException(ALL_DATA_NOT_FOUND)
 121                 whenever(highLevelSimpleClient.fetch(freenetUri)).thenThrow(fetchException)
 122                 val fetched = freenetInterface.fetchUri(freenetUri)
 123                 assertThat(fetched, nullValue())
 124         }
 125
 126         private fun createFetchResult(): FetchResult {
 127                 val clientMetadata = ClientMetadata("text/plain")
 128                 val bucket = ArrayBucket("Some Data.".toByteArray())
 129                 return FetchResult(clientMetadata, bucket)
 130         }
 131
 132         @Test
 133         fun `inserting an image`() {
 134                 val temporaryImage = TemporaryImage("image-id")
 135                 temporaryImage.mimeType = "image/png"
 136                 val imageData = byteArrayOf(1, 2, 3, 4)
 137                 temporaryImage.imageData = imageData
 138                 val image = ImageImpl("image-id")
 139                 val insertToken = freenetInterface.InsertToken(image)
 140                 val insertContext = mock<InsertContext>()
 141                 whenever(highLevelSimpleClient.getInsertContext(anyBoolean())).thenReturn(insertContext)
 142                 val clientPutter = mock<ClientPutter>()
 143                 val insertBlockCaptor = forClass(InsertBlock::class.java)
 144                 whenever(highLevelSimpleClient.insert(insertBlockCaptor.capture(), eq(null as String?), eq(false), eq(insertContext), eq(insertToken), anyShort())).thenReturn(clientPutter)
 145                 freenetInterface.insertImage(temporaryImage, image, insertToken)
 146                 assertThat(insertBlockCaptor.value.data.inputStream, delivers(byteArrayOf(1, 2, 3, 4)))
 147                 assertThat(getPrivateField(insertToken, "clientPutter"), equalTo(clientPutter))
 148                 verify(eventBus).post(any(ImageInsertStartedEvent::class.java))
 149         }
 150
 151         @Test
 152         fun `insert exception causes a sone exception`() {
 153                 val temporaryImage = TemporaryImage("image-id")
 154                 temporaryImage.mimeType = "image/png"
 155                 val imageData = byteArrayOf(1, 2, 3, 4)
 156                 temporaryImage.imageData = imageData
 157                 val image = ImageImpl("image-id")
 158                 val insertToken = freenetInterface.InsertToken(image)
 159                 val insertContext = mock<InsertContext>()
 160                 whenever(highLevelSimpleClient.getInsertContext(anyBoolean())).thenReturn(insertContext)
 161                 val insertBlockCaptor = forClass(InsertBlock::class.java)
 162                 whenever(highLevelSimpleClient.insert(insertBlockCaptor.capture(), eq(null as String?), eq(false), eq(insertContext), eq(insertToken), anyShort())).thenThrow(InsertException::class.java)
 163                 expectionException.expect(SoneInsertException::class.java)
 164                 freenetInterface.insertImage(temporaryImage, image, insertToken)
 165         }
 166
 167         @Test
 168         fun `inserting a directory`() {
 169                 val freenetUri = mock<FreenetURI>()
 170                 val manifestEntries = HashMap<String, Any>()
 171                 val defaultFile = "index.html"
 172                 val resultingUri = mock<FreenetURI>()
 173                 whenever(highLevelSimpleClient.insertManifest(eq(freenetUri), eq(manifestEntries), eq(defaultFile))).thenReturn(resultingUri)
 174                 assertThat(freenetInterface.insertDirectory(freenetUri, manifestEntries, defaultFile), equalTo(resultingUri))
 175         }
 176
 177         @Test
 178         fun `insert exception is forwarded as sone exception`() {
 179                 whenever(highLevelSimpleClient.insertManifest(any(), any(), any())).thenThrow(InsertException::class.java)
 180                 expectionException.expect(SoneException::class.java)
 181                 freenetInterface.insertDirectory(null, null, null)
 182         }
 183
 184         @Test
 185         fun `sone with wrong request uri will not be subscribed`() {
 186                 whenever(sone.requestUri).thenReturn(FreenetURI("KSK@GPLv3.txt"))
 187                 freenetInterface.registerUsk(FreenetURI("KSK@GPLv3.txt"), null)
 188                 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
 189         }
 190
 191         @Test
 192         fun `registering a usk`() {
 193                 val freenetUri = createRandom(randomSource, "test-0").uri.uskForSSK()
 194                 val callback = mock<Callback>()
 195                 freenetInterface.registerUsk(freenetUri, callback)
 196                 verify(uskManager).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
 197         }
 198
 199         @Test
 200         fun `registering a non-usk key will not be subscribed`() {
 201                 val freenetUri = FreenetURI("KSK@GPLv3.txt")
 202                 val callback = mock<Callback>()
 203                 freenetInterface.registerUsk(freenetUri, callback)
 204                 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
 205         }
 206
 207         @Test
 208         fun `registering an active usk will subscribe to it correctly`() {
 209                 val freenetUri = createRandom(randomSource, "test-0").uri.uskForSSK()
 210                 val uskCallback = mock<USKCallback>()
 211                 freenetInterface.registerActiveUsk(freenetUri, uskCallback)
 212                 verify(uskManager).subscribe(any(USK::class.java), eq(uskCallback), eq(true), any(RequestClient::class.java))
 213         }
 214
 215         @Test
 216         fun `registering an inactive usk will subscribe to it correctly`() {
 217                 val freenetUri = createRandom(randomSource, "test-0").uri.uskForSSK()
 218                 val uskCallback = mock<USKCallback>()
 219                 freenetInterface.registerPassiveUsk(freenetUri, uskCallback)
 220                 verify(uskManager).subscribe(any(USK::class.java), eq(uskCallback), eq(false), any(RequestClient::class.java))
 221         }
 222
 223         @Test
 224         fun `registering an active non-usk will not subscribe to a usk`() {
 225                 val freenetUri = createRandom(randomSource, "test-0").uri
 226                 freenetInterface.registerActiveUsk(freenetUri, null)
 227                 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
 228         }
 229
 230         @Test
 231         fun `registering an inactive non-usk will not subscribe to a usk`() {
 232                 val freenetUri = createRandom(randomSource, "test-0").uri
 233                 freenetInterface.registerPassiveUsk(freenetUri, null)
 234                 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
 235         }
 236
 237         @Test
 238         fun `unregistering a not registered usk does nothing`() {
 239                 val freenetURI = createRandom(randomSource, "test-0").uri.uskForSSK()
 240                 freenetInterface.unregisterUsk(freenetURI)
 241                 verify(uskManager, never()).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
 242         }
 243
 244         @Test
 245         fun `unregistering a registered usk`() {
 246                 val freenetURI = createRandom(randomSource, "test-0").uri.uskForSSK()
 247                 val callback = mock<Callback>()
 248                 freenetInterface.registerUsk(freenetURI, callback)
 249                 freenetInterface.unregisterUsk(freenetURI)
 250                 verify(uskManager).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
 251         }
 252
 253         @Test
 254         fun `unregistering a not registered sone does nothing`() {
 255                 freenetInterface.unregisterUsk(sone)
 256                 verify(uskManager, never()).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
 257         }
 258
 259         @Test
 260         fun `unregistering aregistered sone unregisters the sone`() {
 261                 freenetInterface.registerActiveUsk(sone.requestUri, mock())
 262                 freenetInterface.unregisterUsk(sone)
 263                 verify(uskManager).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
 264         }
 265
 266         @Test
 267         fun `unregistering asone with awrong request key will not unsubscribe`() {
 268                 whenever(sone.requestUri).thenReturn(FreenetURI("KSK@GPLv3.txt"))
 269                 freenetInterface.registerUsk(sone.requestUri, null)
 270                 freenetInterface.unregisterUsk(sone)
 271                 verify(uskManager, never()).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
 272         }
 273
 274         @Test
 275         fun `callback for normal usk uses different priorities`() {
 276                 val callback = mock<Callback>()
 277                 val soneUri = createRandom(randomSource, "test-0").uri.uskForSSK()
 278                 freenetInterface.registerUsk(soneUri, callback)
 279                 assertThat(callbackCaptor.value.pollingPriorityNormal, equalTo(PREFETCH_PRIORITY_CLASS))
 280                 assertThat(callbackCaptor.value.pollingPriorityProgress, equalTo(INTERACTIVE_PRIORITY_CLASS))
 281         }
 282
 283         @Test
 284         fun `callback for normal usk forwards important parameters`() {
 285                 val callback = mock<Callback>()
 286                 val uri = createRandom(randomSource, "test-0").uri.uskForSSK()
 287                 freenetInterface.registerUsk(uri, callback)
 288                 val key = mock<USK>()
 289                 whenever(key.uri).thenReturn(uri)
 290                 callbackCaptor.value.onFoundEdition(3, key, null, false, 0.toShort(), null, true, true)
 291                 verify(callback).editionFound(eq(uri), eq(3L), eq(true), eq(true))
 292         }
 293
 294         @Test
 295         fun `fetched retains uri and fetch result`() {
 296                 val freenetUri = mock<FreenetURI>()
 297                 val fetchResult = mock<FetchResult>()
 298                 val (freenetUri1, fetchResult1) = Fetched(freenetUri, fetchResult)
 299                 assertThat(freenetUri1, equalTo(freenetUri))
 300                 assertThat(fetchResult1, equalTo(fetchResult))
 301         }
 302
 303         @Test
 304         fun `cancelling an insert will fire image insert aborted event`() {
 305                 val clientPutter = mock<ClientPutter>()
 306                 insertToken.setClientPutter(clientPutter)
 307                 val imageInsertStartedEvent = forClass(ImageInsertStartedEvent::class.java)
 308                 verify(eventBus).post(imageInsertStartedEvent.capture())
 309                 assertThat(imageInsertStartedEvent.value.image, equalTo(image))
 310                 insertToken.cancel()
 311                 val imageInsertAbortedEvent = forClass(ImageInsertAbortedEvent::class.java)
 312                 verify(eventBus, times(2)).post(imageInsertAbortedEvent.capture())
 313                 verify(bucket).free()
 314                 assertThat(imageInsertAbortedEvent.value.image, equalTo(image))
 315         }
 316
 317         @Test
 318         fun `failure without exception sends failed event`() {
 319                 val insertException = InsertException(mock<InsertException>())
 320                 insertToken.onFailure(insertException, null)
 321                 val imageInsertFailedEvent = forClass(ImageInsertFailedEvent::class.java)
 322                 verify(eventBus).post(imageInsertFailedEvent.capture())
 323                 verify(bucket).free()
 324                 assertThat(imageInsertFailedEvent.value.image, equalTo(image))
 325                 assertThat(imageInsertFailedEvent.value.cause, equalTo<Throwable>(insertException))
 326         }
 327
 328         @Test
 329         fun `failure sends failed event with exception`() {
 330                 val insertException = InsertException(InsertExceptionMode.INTERNAL_ERROR, "Internal error", null)
 331                 insertToken.onFailure(insertException, null)
 332                 val imageInsertFailedEvent = forClass(ImageInsertFailedEvent::class.java)
 333                 verify(eventBus).post(imageInsertFailedEvent.capture())
 334                 verify(bucket).free()
 335                 assertThat(imageInsertFailedEvent.value.image, equalTo(image))
 336                 assertThat(imageInsertFailedEvent.value.cause, equalTo(insertException as Throwable))
 337         }
 338
 339         @Test
 340         fun `failure because cancelled by user sends aborted event`() {
 341                 val insertException = InsertException(InsertExceptionMode.CANCELLED, null)
 342                 insertToken.onFailure(insertException, null)
 343                 val imageInsertAbortedEvent = forClass(ImageInsertAbortedEvent::class.java)
 344                 verify(eventBus).post(imageInsertAbortedEvent.capture())
 345                 verify(bucket).free()
 346                 assertThat(imageInsertAbortedEvent.value.image, equalTo(image))
 347         }
 348
 349         @Test
 350         fun `ignored methods do not throw exceptions`() {
 351                 insertToken.onResume(null)
 352                 insertToken.onFetchable(null)
 353                 insertToken.onGeneratedMetadata(null, null)
 354         }
 355
 356         @Test
 357         fun `generated uri is posted on success`() {
 358                 val generatedUri = mock<FreenetURI>()
 359                 insertToken.onGeneratedURI(generatedUri, null)
 360                 insertToken.onSuccess(null)
 361                 val imageInsertFinishedEvent = forClass(ImageInsertFinishedEvent::class.java)
 362                 verify(eventBus).post(imageInsertFinishedEvent.capture())
 363                 verify(bucket).free()
 364                 assertThat(imageInsertFinishedEvent.value.image, equalTo(image))
 365                 assertThat(imageInsertFinishedEvent.value.resultingUri, equalTo(generatedUri))
 366         }
 367
 368         @Test
 369         fun `insert token supplier supplies insert tokens`() {
 370                 val insertTokenSupplier = InsertTokenSupplier(freenetInterface)
 371                 assertThat(insertTokenSupplier.apply(image), notNullValue())
 372         }
 373
 374         @Test
 375         fun `background fetch can be started`() {
 376                 freenetInterface.startFetch(uri, backgroundFetchCallback)
 377                 verify(highLevelSimpleClient).fetch(eq(uri), anyLong(), any(ClientGetCallback::class.java), any(FetchContext::class.java), anyShort())
 378         }
 379
 380         @Test
 381         fun `background fetch registers snoop and restarts the request`() {
 382                 freenetInterface.startFetch(uri, backgroundFetchCallback)
 383                 verify(clientGetter).metaSnoop = any(SnoopMetadata::class.java)
 384                 verify(clientGetter).restart(eq(uri), anyBoolean(), any(ClientContext::class.java))
 385         }
 386
 387         @Test
 388         fun `request is not cancelled for image mime type`() {
 389                 verifySnoopCancelsRequestForMimeType("image/png", false)
 390                 verify(backgroundFetchCallback, never()).failed(uri)
 391         }
 392
 393         @Test
 394         fun `request is cancelled for null mime type`() {
 395                 verifySnoopCancelsRequestForMimeType(null, true)
 396                 verify(backgroundFetchCallback, never()).shouldCancel(eq(uri), any(), anyLong())
 397                 verify(backgroundFetchCallback).failed(uri)
 398         }
 399
 400         @Test
 401         fun `request is cancelled for video mime type`() {
 402                 verifySnoopCancelsRequestForMimeType("video/mkv", true)
 403                 verify(backgroundFetchCallback).failed(uri)
 404         }
 405
 406         @Test
 407         fun `request is cancelled for audio mime type`() {
 408                 verifySnoopCancelsRequestForMimeType("audio/mpeg", true)
 409                 verify(backgroundFetchCallback).failed(uri)
 410         }
 411
 412         @Test
 413         fun `request is cancelled for text mime type`() {
 414                 verifySnoopCancelsRequestForMimeType("text/plain", true)
 415                 verify(backgroundFetchCallback).failed(uri)
 416         }
 417
 418         private fun verifySnoopCancelsRequestForMimeType(mimeType: String?, cancel: Boolean) {
 419                 whenever(backgroundFetchCallback.shouldCancel(eq(uri), if (mimeType != null) eq(mimeType) else isNull(), anyLong())).thenReturn(cancel)
 420                 freenetInterface.startFetch(uri, backgroundFetchCallback)
 421                 val snoopMetadata = forClass(SnoopMetadata::class.java)
 422                 verify(clientGetter).metaSnoop = snoopMetadata.capture()
 423                 val metadata = mock<Metadata>()
 424                 whenever(metadata.mimeType).thenReturn(mimeType)
 425                 assertThat(snoopMetadata.value.snoopMetadata(metadata, mock()), equalTo(cancel))
 426         }
 427
 428         @Test
 429         fun `callback of background fetch is notified on success`() {
 430                 freenetInterface.startFetch(uri, backgroundFetchCallback)
 431                 verify(highLevelSimpleClient).fetch(eq(uri), anyLong(), clientGetCallback.capture(), any(FetchContext::class.java), anyShort())
 432                 whenever(fetchResult.mimeType).thenReturn("image/png")
 433                 whenever(fetchResult.asByteArray()).thenReturn(byteArrayOf(1, 2, 3, 4, 5))
 434                 clientGetCallback.value.onSuccess(fetchResult, mock())
 435                 verify(backgroundFetchCallback).loaded(uri, "image/png", byteArrayOf(1, 2, 3, 4, 5))
 436                 verifyNoMoreInteractions(backgroundFetchCallback)
 437         }
 438
 439         @Test
 440         fun `callback of background fetch is notified on failure`() {
 441                 freenetInterface.startFetch(uri, backgroundFetchCallback)
 442                 verify(highLevelSimpleClient).fetch(eq(uri), anyLong(), clientGetCallback.capture(), any(FetchContext::class.java), anyShort())
 443                 whenever(fetchResult.mimeType).thenReturn("image/png")
 444                 whenever(fetchResult.asByteArray()).thenReturn(byteArrayOf(1, 2, 3, 4, 5))
 445                 clientGetCallback.value.onFailure(FetchException(ALL_DATA_NOT_FOUND), mock())
 446                 verify(backgroundFetchCallback).failed(uri)
 447                 verifyNoMoreInteractions(backgroundFetchCallback)
 448         }
 449
 450         @Test
 451         fun `callback of background fetch is notified as failure if bucket can not be loaded`() {
 452                 freenetInterface.startFetch(uri, backgroundFetchCallback)
 453                 verify(highLevelSimpleClient).fetch(eq(uri), anyLong(), clientGetCallback.capture(), any(FetchContext::class.java), anyShort())
 454                 whenever(fetchResult.mimeType).thenReturn("image/png")
 455                 whenever(fetchResult.asByteArray()).thenThrow(IOException::class.java)
 456                 clientGetCallback.value.onSuccess(fetchResult, mock())
 457                 verify(backgroundFetchCallback).failed(uri)
 458                 verifyNoMoreInteractions(backgroundFetchCallback)
 459         }
 460
 461 }