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