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.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
29 import org.junit.rules.*
31 import org.mockito.ArgumentCaptor.*
32 import org.mockito.ArgumentMatchers.eq
33 import org.mockito.Mockito.*
36 import kotlin.test.Test
39 * Unit test for [FreenetInterface].
41 class FreenetInterfaceTest {
45 val expectionException: ExpectedException = ExpectedException.none()
49 val silencedLogging = silencedLogging()
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
72 setField(node, "random", randomSource)
73 freenetInterface = FreenetInterface(eventBus, node, uskManager, clientContext, soneUriCreator) { _, _, _ -> highLevelSimpleClient }
74 insertToken = freenetInterface.InsertToken(image)
75 insertToken.setBucket(bucket)
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)
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()))
92 fun setupCallbackCaptorAndUskManager() {
93 doNothing().whenever(uskManager).subscribe(any(USK::class.java), callbackCaptor.capture(), anyBoolean(), any(RequestClient::class.java))
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))
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))
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())
129 private fun createFetchResult(): FetchResult {
130 val clientMetadata = ClientMetadata("text/plain")
131 val bucket = ArrayBucket("Some Data.".toByteArray())
132 return FetchResult(clientMetadata, bucket)
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))
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)
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))
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)
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
351 fun `ignored methods do not throw exceptions`() {
352 insertToken.onResume(null)
353 insertToken.onFetchable(null)
354 insertToken.onGeneratedMetadata(null, null)
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))
370 fun `insert token supplier supplies insert tokens`() {
371 val insertTokenSupplier = InsertTokenSupplier(freenetInterface)
372 assertThat(insertTokenSupplier.apply(image), notNullValue())
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())
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))
389 fun `request is not cancelled for image mime type`() {
390 verifySnoopCancelsRequestForMimeType("image/png", false)
391 verify(backgroundFetchCallback, never()).failed(uri)
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)
402 fun `request is cancelled for video mime type`() {
403 verifySnoopCancelsRequestForMimeType("video/mkv", true)
404 verify(backgroundFetchCallback).failed(uri)
408 fun `request is cancelled for audio mime type`() {
409 verifySnoopCancelsRequestForMimeType("audio/mpeg", true)
410 verify(backgroundFetchCallback).failed(uri)
414 fun `request is cancelled for text mime type`() {
415 verifySnoopCancelsRequestForMimeType("text/plain", true)
416 verify(backgroundFetchCallback).failed(uri)
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))
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)
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)
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)
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>())