🔥 Remove “create” flag from session provider interface
[Sone.git] / src / test / kotlin / net / pterodactylus / sone / core / UpdateCheckerTest.kt
1 package net.pterodactylus.sone.core
2
3 import com.google.common.eventbus.*
4 import freenet.client.*
5 import freenet.keys.*
6 import freenet.support.io.*
7 import net.pterodactylus.sone.core.FreenetInterface.*
8 import net.pterodactylus.sone.core.event.*
9 import net.pterodactylus.sone.main.*
10 import net.pterodactylus.sone.test.*
11 import net.pterodactylus.util.version.Version
12 import org.hamcrest.MatcherAssert.*
13 import org.hamcrest.Matchers.equalTo
14 import org.hamcrest.Matchers.instanceOf
15 import org.junit.*
16 import org.mockito.ArgumentCaptor.*
17 import org.mockito.ArgumentMatchers.any
18 import org.mockito.Mockito.never
19 import org.mockito.Mockito.times
20 import org.mockito.Mockito.verify
21 import org.mockito.hamcrest.MockitoHamcrest.*
22 import java.io.*
23 import kotlin.Long.Companion.MAX_VALUE
24
25 /**
26  * Unit test for [UpdateChecker].
27  */
28 class UpdateCheckerTest {
29
30         private val eventBus = mock<EventBus>()
31         private val freenetInterface = mock<FreenetInterface>()
32         private val currentVersion = Version(1, 0, 0)
33         private val pluginHomepage = PluginHomepage("KSK@homepage")
34         private val updateChecker = UpdateChecker(eventBus, freenetInterface, currentVersion, pluginHomepage)
35
36         @Before
37         fun startUpdateChecker() {
38                 updateChecker.start()
39         }
40
41         @Test
42         fun `new update checker does not have a latest version`() {
43                 assertThat(updateChecker.hasLatestVersion(), equalTo(false))
44                 assertThat(updateChecker.latestVersion, equalTo(currentVersion))
45         }
46
47         @Test
48         fun `starting an update checker register a usk`() {
49                 verify(freenetInterface).registerUsk(any(FreenetURI::class.java), any(Callback::class.java))
50         }
51
52         @Test
53         fun `stopping an update checker unregisters a usk`() {
54                 updateChecker.stop()
55                 verify(freenetInterface).unregisterUsk(any(FreenetURI::class.java))
56         }
57
58         @Test
59         fun `callback does not download if new edition is not found`() {
60                 setupCallbackWithEdition(MAX_VALUE, false)
61                 verify(freenetInterface, never()).fetchUri(any(FreenetURI::class.java))
62                 verify(eventBus, never()).post(argThat(instanceOf(UpdateFoundEvent::class.java)))
63         }
64
65         private fun setupCallbackWithEdition(edition: Long, newKnownGood: Boolean, newSlot: Boolean = false) {
66                 val uri = forClass(FreenetURI::class.java)
67                 val callback = forClass(Callback::class.java)
68                 verify(freenetInterface).registerUsk(uri.capture(), callback.capture())
69                 callback.value.editionFound(uri.value, edition, newKnownGood, newSlot)
70         }
71
72         @Test
73         fun `callback starts if new edition is found`() {
74                 setupFetchResult(createFutureFetchResult())
75                 setupCallbackWithEdition(MAX_VALUE, true)
76                 verifyAFreenetUriIsFetched()
77                 verifyEventIsFired(Version(99, 0, 0), 11865368297000L, false)
78                 verifyThatUpdateCheckerKnowsLatestVersion(Version(99, 0, 0), 11865368297000L)
79         }
80
81         private fun createFutureFetchResult(): FetchResult {
82                 val clientMetadata = ClientMetadata("application/xml")
83                 val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
84                                 "CurrentVersion/Version: 99.0.0\n" +
85                                 "CurrentVersion/ReleaseTime: 11865368297000\n" +
86                                 "DisruptiveVersion/0.1.2: true").toByteArray())
87                 return FetchResult(clientMetadata, fetched)
88         }
89
90         private fun verifyEventIsFired(version: Version, releaseTime: Long, disruptive: Boolean) {
91                 val updateFoundEvent = forClass(UpdateFoundEvent::class.java)
92                 verify(eventBus, times(1)).post(updateFoundEvent.capture())
93                 assertThat(updateFoundEvent.value.version, equalTo(version))
94                 assertThat(updateFoundEvent.value.releaseTime, equalTo(releaseTime))
95                 assertThat(updateFoundEvent.value.isDisruptive, equalTo(disruptive))
96         }
97
98         private fun verifyThatUpdateCheckerKnowsLatestVersion(version: Version, releaseTime: Long) {
99                 assertThat(updateChecker.latestVersion, equalTo(version))
100                 assertThat(updateChecker.latestVersionDate, equalTo(releaseTime))
101                 assertThat(updateChecker.hasLatestVersion(), equalTo(true))
102         }
103
104         @Test
105         fun `callback does not start if no new edition is found`() {
106                 setupFetchResult(createPastFetchResult())
107                 setupCallbackWithEdition(updateChecker.latestEdition, true)
108                 verifyAFreenetUriIsFetched()
109                 verifyNoUpdateFoundEventIsFired()
110         }
111
112         private fun setupFetchResult(pastFetchResult: FetchResult) {
113                 whenever(freenetInterface.fetchUri(any(FreenetURI::class.java))).thenAnswer { invocation ->
114                         val freenetUri = invocation.arguments[0] as FreenetURI
115                         Fetched(freenetUri, pastFetchResult)
116                 }
117         }
118
119         private fun createPastFetchResult(): FetchResult {
120                 val clientMetadata = ClientMetadata("application/xml")
121                 val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
122                                 "CurrentVersion/Version: 0.2\n" +
123                                 "CurrentVersion/ReleaseTime: 1289417883000").toByteArray())
124                 return FetchResult(clientMetadata, fetched)
125         }
126
127         @Test
128         fun `invalid update file does not start callback`() {
129                 setupFetchResult(createInvalidFetchResult())
130                 setupCallbackWithEdition(MAX_VALUE, true)
131                 verifyAFreenetUriIsFetched()
132                 verifyNoUpdateFoundEventIsFired()
133         }
134
135         private fun createInvalidFetchResult(): FetchResult {
136                 val clientMetadata = ClientMetadata("text/plain")
137                 val fetched = ArrayBucket("Some other data.".toByteArray())
138                 return FetchResult(clientMetadata, fetched)
139         }
140
141         @Test
142         fun `non existing properties will not cause update to be found`() {
143                 setupCallbackWithEdition(MAX_VALUE, true)
144                 verifyAFreenetUriIsFetched()
145                 verifyNoUpdateFoundEventIsFired()
146         }
147
148         private fun verifyNoUpdateFoundEventIsFired() {
149                 verify(eventBus, never()).post(any(UpdateFoundEvent::class.java))
150         }
151
152         private fun verifyAFreenetUriIsFetched() {
153                 verify(freenetInterface).fetchUri(any(FreenetURI::class.java))
154         }
155
156         @Test
157         fun `broken bucket does not cause update to be found`() {
158                 setupFetchResult(createBrokenBucketFetchResult())
159                 setupCallbackWithEdition(MAX_VALUE, true)
160                 verifyAFreenetUriIsFetched()
161                 verifyNoUpdateFoundEventIsFired()
162         }
163
164         private fun createBrokenBucketFetchResult(): FetchResult {
165                 val clientMetadata = ClientMetadata("text/plain")
166                 val fetched = object : ArrayBucket("Some other data.".toByteArray()) {
167                         override fun getInputStream() =
168                                         whenever(mock<InputStream>().read()).thenThrow(IOException()).getMock<InputStream>()
169                 }
170                 return FetchResult(clientMetadata, fetched)
171         }
172
173         @Test
174         fun `invalid time does not cause an update to be found`() {
175                 setupFetchResult(createInvalidTimeFetchResult())
176                 setupCallbackWithEdition(MAX_VALUE, true)
177                 verifyAFreenetUriIsFetched()
178                 verifyNoUpdateFoundEventIsFired()
179         }
180
181         private fun createInvalidTimeFetchResult(): FetchResult {
182                 val clientMetadata = ClientMetadata("application/xml")
183                 val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
184                                 "CurrentVersion/Version: 0.2\n" +
185                                 "CurrentVersion/ReleaseTime: invalid").toByteArray())
186                 return FetchResult(clientMetadata, fetched)
187         }
188
189         @Test
190         fun `invalid properties does not cause an update to be found`() {
191                 setupFetchResult(createMissingTimeFetchResult())
192                 setupCallbackWithEdition(MAX_VALUE, true)
193                 verifyAFreenetUriIsFetched()
194                 verifyNoUpdateFoundEventIsFired()
195         }
196
197         private fun createMissingTimeFetchResult(): FetchResult {
198                 val clientMetadata = ClientMetadata("application/xml")
199                 val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\nCurrentVersion/Version: 0.2\n").toByteArray())
200                 return FetchResult(clientMetadata, fetched)
201         }
202
203         @Test
204         fun `invalid version does not cause an update to be found`() {
205                 setupFetchResult(createInvalidVersionFetchResult())
206                 setupCallbackWithEdition(MAX_VALUE, true)
207                 verifyAFreenetUriIsFetched()
208                 verifyNoUpdateFoundEventIsFired()
209         }
210
211         private fun createInvalidVersionFetchResult(): FetchResult {
212                 val clientMetadata = ClientMetadata("application/xml")
213                 val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
214                                 "CurrentVersion/Version: foo\n" +
215                                 "CurrentVersion/ReleaseTime: 1289417883000").toByteArray())
216                 return FetchResult(clientMetadata, fetched)
217         }
218
219         @Test
220         fun `disruptive version gets notification`() {
221                 setupFetchResult(createDisruptiveVersionFetchResult())
222                 setupCallbackWithEdition(MAX_VALUE, true)
223                 verifyAFreenetUriIsFetched()
224                 verifyEventIsFired(Version(1, 2, 3), 1289417883000L, true)
225                 verifyThatUpdateCheckerKnowsLatestVersion(Version(1, 2, 3), 1289417883000L)
226         }
227
228         private fun createDisruptiveVersionFetchResult(): FetchResult {
229                 val clientMetadata = ClientMetadata("application/xml")
230                 val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
231                                 "CurrentVersion/Version: 1.2.3\n" +
232                                 "CurrentVersion/ReleaseTime: 1289417883000\n" +
233                                 "DisruptiveVersion/1.2.3: true").toByteArray())
234                 return FetchResult(clientMetadata, fetched)
235         }
236
237 }