1 package net.pterodactylus.sone.core
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.*
10 import freenet.keys.InsertableClientSSK.*
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.test.*
20 import net.pterodactylus.sone.test.Matchers.*
21 import net.pterodactylus.sone.test.TestUtil.*
22 import net.pterodactylus.sone.utils.*
23 import org.hamcrest.MatcherAssert.*
24 import org.hamcrest.Matchers.equalTo
25 import org.hamcrest.Matchers.notNullValue
26 import org.hamcrest.Matchers.nullValue
28 import org.junit.rules.*
30 import org.mockito.ArgumentCaptor.*
31 import org.mockito.ArgumentMatchers.eq
32 import org.mockito.Mockito.*
35 import kotlin.test.Test
38 * Unit test for [FreenetInterface].
40 class FreenetInterfaceTest {
44 val expectionException: ExpectedException = ExpectedException.none()
48 val silencedLogging = silencedLogging()
50 @Suppress("UnstableApiUsage")
51 private val eventBus = mock<EventBus>()
52 private val node = mock<Node>()
53 private val nodeClientCore = mock<NodeClientCore>()
54 private val highLevelSimpleClient: HighLevelSimpleClient = mock(HighLevelSimpleClient::class.java, withSettings().extraInterfaces(RequestClient::class.java))
55 private val randomSource = DummyRandomSource()
56 private val uskManager = mock<USKManager>()
57 private val sone = mock<Sone>()
58 private val callbackCaptor: ArgumentCaptor<USKCallback> = forClass(USKCallback::class.java)
59 private val image = mock<Image>()
60 private val insertToken: InsertToken
61 private val bucket = mock<Bucket>()
62 private val clientGetCallback: ArgumentCaptor<ClientGetCallback> = forClass(ClientGetCallback::class.java)
63 private val uri = FreenetURI("KSK@pgl.png")
64 private val fetchResult = mock<FetchResult>()
65 private val backgroundFetchCallback = mock<BackgroundFetchCallback>()
66 private val clientGetter = mock<ClientGetter>()
67 private val freenetInterface: FreenetInterface
70 whenever(nodeClientCore.makeClient(anyShort(), anyBoolean(), anyBoolean())).thenReturn(highLevelSimpleClient)
71 setField(node, "clientCore", nodeClientCore)
72 setField(node, "random", randomSource)
73 setField(nodeClientCore, "uskManager", uskManager)
74 setField(nodeClientCore, "clientContext", mock<ClientContext>())
75 freenetInterface = FreenetInterface(eventBus, node)
76 insertToken = freenetInterface.InsertToken(image)
77 insertToken.setBucket(bucket)
81 fun setupHighLevelSimpleClient() {
82 whenever(highLevelSimpleClient.fetchContext).thenReturn(mock())
83 whenever(highLevelSimpleClient.fetch(eq(uri), anyLong(), any(ClientGetCallback::class.java), any(FetchContext::class.java), anyShort())).thenReturn(clientGetter)
88 val insertSsk = createRandom(randomSource, "test-0")
89 whenever(sone.id).thenReturn(insertSsk.uri.routingKey.asFreenetBase64)
90 whenever(sone.requestUri).thenReturn(insertSsk.uri.uskForSSK())
94 fun setupCallbackCaptorAndUskManager() {
95 doNothing().whenever(uskManager).subscribe(any(USK::class.java), callbackCaptor.capture(), anyBoolean(), any(RequestClient::class.java))
99 fun `can fetch uri`() {
100 val freenetUri = FreenetURI("KSK@GPLv3.txt")
101 val fetchResult = createFetchResult()
102 whenever(highLevelSimpleClient.fetch(freenetUri)).thenReturn(fetchResult)
103 val fetched = freenetInterface.fetchUri(freenetUri)
104 assertThat(fetched, notNullValue())
105 assertThat(fetched!!.fetchResult, equalTo(fetchResult))
106 assertThat(fetched.freenetUri, equalTo(freenetUri))
110 fun `fetch follows redirect`() {
111 val freenetUri = FreenetURI("KSK@GPLv2.txt")
112 val newFreenetUri = FreenetURI("KSK@GPLv3.txt")
113 val fetchResult = createFetchResult()
114 val fetchException = FetchException(PERMANENT_REDIRECT, newFreenetUri)
115 whenever(highLevelSimpleClient.fetch(freenetUri)).thenThrow(fetchException)
116 whenever(highLevelSimpleClient.fetch(newFreenetUri)).thenReturn(fetchResult)
117 val fetched = freenetInterface.fetchUri(freenetUri)
118 assertThat(fetched!!.fetchResult, equalTo(fetchResult))
119 assertThat(fetched.freenetUri, equalTo(newFreenetUri))
123 fun `fetch returns null on fetch exceptions`() {
124 val freenetUri = FreenetURI("KSK@GPLv2.txt")
125 val fetchException = FetchException(ALL_DATA_NOT_FOUND)
126 whenever(highLevelSimpleClient.fetch(freenetUri)).thenThrow(fetchException)
127 val fetched = freenetInterface.fetchUri(freenetUri)
128 assertThat(fetched, nullValue())
131 private fun createFetchResult(): FetchResult {
132 val clientMetadata = ClientMetadata("text/plain")
133 val bucket = ArrayBucket("Some Data.".toByteArray())
134 return FetchResult(clientMetadata, bucket)
138 fun `inserting an image`() {
139 val temporaryImage = TemporaryImage("image-id")
140 temporaryImage.mimeType = "image/png"
141 val imageData = byteArrayOf(1, 2, 3, 4)
142 temporaryImage.imageData = imageData
143 val image = ImageImpl("image-id")
144 val insertToken = freenetInterface.InsertToken(image)
145 val insertContext = mock<InsertContext>()
146 whenever(highLevelSimpleClient.getInsertContext(anyBoolean())).thenReturn(insertContext)
147 val clientPutter = mock<ClientPutter>()
148 val insertBlockCaptor = forClass(InsertBlock::class.java)
149 whenever(highLevelSimpleClient.insert(insertBlockCaptor.capture(), eq(null as String?), eq(false), eq(insertContext), eq(insertToken), anyShort())).thenReturn(clientPutter)
150 freenetInterface.insertImage(temporaryImage, image, insertToken)
151 assertThat(insertBlockCaptor.value.data.inputStream, delivers(byteArrayOf(1, 2, 3, 4)))
152 assertThat(getPrivateField(insertToken, "clientPutter"), equalTo(clientPutter))
153 verify(eventBus).post(any(ImageInsertStartedEvent::class.java))
157 fun `insert exception causes a sone exception`() {
158 val temporaryImage = TemporaryImage("image-id")
159 temporaryImage.mimeType = "image/png"
160 val imageData = byteArrayOf(1, 2, 3, 4)
161 temporaryImage.imageData = imageData
162 val image = ImageImpl("image-id")
163 val insertToken = freenetInterface.InsertToken(image)
164 val insertContext = mock<InsertContext>()
165 whenever(highLevelSimpleClient.getInsertContext(anyBoolean())).thenReturn(insertContext)
166 val insertBlockCaptor = forClass(InsertBlock::class.java)
167 whenever(highLevelSimpleClient.insert(insertBlockCaptor.capture(), eq(null as String?), eq(false), eq(insertContext), eq(insertToken), anyShort())).thenThrow(InsertException::class.java)
168 expectionException.expect(SoneInsertException::class.java)
169 freenetInterface.insertImage(temporaryImage, image, insertToken)
173 fun `inserting a directory`() {
174 val freenetUri = mock<FreenetURI>()
175 val manifestEntries = HashMap<String, Any>()
176 val defaultFile = "index.html"
177 val resultingUri = mock<FreenetURI>()
178 whenever(highLevelSimpleClient.insertManifest(eq(freenetUri), eq(manifestEntries), eq(defaultFile))).thenReturn(resultingUri)
179 assertThat(freenetInterface.insertDirectory(freenetUri, manifestEntries, defaultFile), equalTo(resultingUri))
183 fun `insert exception is forwarded as sone exception`() {
184 whenever(highLevelSimpleClient.insertManifest(any(), any(), any())).thenThrow(InsertException::class.java)
185 expectionException.expect(SoneException::class.java)
186 freenetInterface.insertDirectory(null, null, null)
190 fun `sone with wrong request uri will not be subscribed`() {
191 whenever(sone.requestUri).thenReturn(FreenetURI("KSK@GPLv3.txt"))
192 freenetInterface.registerUsk(FreenetURI("KSK@GPLv3.txt"), null)
193 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
197 fun `registering a usk`() {
198 val freenetUri = createRandom(randomSource, "test-0").uri.uskForSSK()
199 val callback = mock<Callback>()
200 freenetInterface.registerUsk(freenetUri, callback)
201 verify(uskManager).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
205 fun `registering a non-usk key will not be subscribed`() {
206 val freenetUri = FreenetURI("KSK@GPLv3.txt")
207 val callback = mock<Callback>()
208 freenetInterface.registerUsk(freenetUri, callback)
209 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
213 fun `registering an active usk will subscribe to it correctly`() {
214 val freenetUri = createRandom(randomSource, "test-0").uri.uskForSSK()
215 val uskCallback = mock<USKCallback>()
216 freenetInterface.registerActiveUsk(freenetUri, uskCallback)
217 verify(uskManager).subscribe(any(USK::class.java), eq(uskCallback), eq(true), any(RequestClient::class.java))
221 fun `registering an inactive usk will subscribe to it correctly`() {
222 val freenetUri = createRandom(randomSource, "test-0").uri.uskForSSK()
223 val uskCallback = mock<USKCallback>()
224 freenetInterface.registerPassiveUsk(freenetUri, uskCallback)
225 verify(uskManager).subscribe(any(USK::class.java), eq(uskCallback), eq(false), any(RequestClient::class.java))
229 fun `registering an active non-usk will not subscribe to a usk`() {
230 val freenetUri = createRandom(randomSource, "test-0").uri
231 freenetInterface.registerActiveUsk(freenetUri, null)
232 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
236 fun `registering an inactive non-usk will not subscribe to a usk`() {
237 val freenetUri = createRandom(randomSource, "test-0").uri
238 freenetInterface.registerPassiveUsk(freenetUri, null)
239 verify(uskManager, never()).subscribe(any(USK::class.java), any(USKCallback::class.java), anyBoolean(), any(RequestClient::class.java))
243 fun `unregistering a not registered usk does nothing`() {
244 val freenetURI = createRandom(randomSource, "test-0").uri.uskForSSK()
245 freenetInterface.unregisterUsk(freenetURI)
246 verify(uskManager, never()).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
250 fun `unregistering a registered usk`() {
251 val freenetURI = createRandom(randomSource, "test-0").uri.uskForSSK()
252 val callback = mock<Callback>()
253 freenetInterface.registerUsk(freenetURI, callback)
254 freenetInterface.unregisterUsk(freenetURI)
255 verify(uskManager).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
259 fun `unregistering a not registered sone does nothing`() {
260 freenetInterface.unregisterUsk(sone)
261 verify(uskManager, never()).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
265 fun `unregistering aregistered sone unregisters the sone`() {
266 freenetInterface.registerActiveUsk(sone.requestUri, mock())
267 freenetInterface.unregisterUsk(sone)
268 verify(uskManager).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
272 fun `unregistering asone with awrong request key will not unsubscribe`() {
273 whenever(sone.requestUri).thenReturn(FreenetURI("KSK@GPLv3.txt"))
274 freenetInterface.registerUsk(sone.requestUri, null)
275 freenetInterface.unregisterUsk(sone)
276 verify(uskManager, never()).unsubscribe(any(USK::class.java), any(USKCallback::class.java))
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))
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))
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))
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))
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))
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))
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))
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))
355 fun `ignored methods do not throw exceptions`() {
356 insertToken.onResume(null)
357 insertToken.onFetchable(null)
358 insertToken.onGeneratedMetadata(null, null)
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))
374 fun `insert token supplier supplies insert tokens`() {
375 val insertTokenSupplier = InsertTokenSupplier(freenetInterface)
376 assertThat(insertTokenSupplier.apply(image), notNullValue())
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())
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))
393 fun `request is not cancelled for image mime type`() {
394 verifySnoopCancelsRequestForMimeType("image/png", false)
395 verify(backgroundFetchCallback, never()).failed(uri)
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)
406 fun `request is cancelled for video mime type`() {
407 verifySnoopCancelsRequestForMimeType("video/mkv", true)
408 verify(backgroundFetchCallback).failed(uri)
412 fun `request is cancelled for audio mime type`() {
413 verifySnoopCancelsRequestForMimeType("audio/mpeg", true)
414 verify(backgroundFetchCallback).failed(uri)
418 fun `request is cancelled for text mime type`() {
419 verifySnoopCancelsRequestForMimeType("text/plain", true)
420 verify(backgroundFetchCallback).failed(uri)
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))
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)
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)
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)
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>())