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