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.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
28 import org.junit.rules.*
30 import org.mockito.ArgumentCaptor.*
31 import org.mockito.ArgumentMatchers.eq
32 import org.mockito.Mockito.*
37 * Unit test for [FreenetInterface].
39 class FreenetInterfaceTest {
43 val expectionException: ExpectedException = ExpectedException.none()
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
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)
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)
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())
89 fun setupCallbackCaptorAndUskManager() {
90 doNothing().`when`(uskManager).subscribe(any(USK::class.java), callbackCaptor.capture(), anyBoolean(), any(RequestClient::class.java))
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))
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))
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())
126 private fun createFetchResult(): FetchResult {
127 val clientMetadata = ClientMetadata("text/plain")
128 val bucket = ArrayBucket("Some Data.".toByteArray())
129 return FetchResult(clientMetadata, bucket)
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))
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)
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))
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)
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
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))
350 fun `ignored methods do not throw exceptions`() {
351 insertToken.onResume(null)
352 insertToken.onFetchable(null)
353 insertToken.onGeneratedMetadata(null, null)
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))
369 fun `insert token supplier supplies insert tokens`() {
370 val insertTokenSupplier = InsertTokenSupplier(freenetInterface)
371 assertThat(insertTokenSupplier.apply(image), notNullValue())
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())
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))
388 fun `request is not cancelled for image mime type`() {
389 verifySnoopCancelsRequestForMimeType("image/png", false)
390 verify(backgroundFetchCallback, never()).failed(uri)
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)
401 fun `request is cancelled for video mime type`() {
402 verifySnoopCancelsRequestForMimeType("video/mkv", true)
403 verify(backgroundFetchCallback).failed(uri)
407 fun `request is cancelled for audio mime type`() {
408 verifySnoopCancelsRequestForMimeType("audio/mpeg", true)
409 verify(backgroundFetchCallback).failed(uri)
413 fun `request is cancelled for text mime type`() {
414 verifySnoopCancelsRequestForMimeType("text/plain", true)
415 verify(backgroundFetchCallback).failed(uri)
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))
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)
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)
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)