--- /dev/null
+package net.pterodactylus.sone.core
+
+import com.google.common.eventbus.*
+import freenet.client.*
+import freenet.keys.*
+import freenet.support.io.*
+import net.pterodactylus.sone.core.FreenetInterface.*
+import net.pterodactylus.sone.core.event.*
+import net.pterodactylus.sone.main.*
+import net.pterodactylus.sone.test.*
+import net.pterodactylus.util.version.Version
+import org.hamcrest.MatcherAssert.*
+import org.hamcrest.Matchers.equalTo
+import org.hamcrest.Matchers.instanceOf
+import org.junit.*
+import org.mockito.ArgumentCaptor.*
+import org.mockito.ArgumentMatchers.any
+import org.mockito.Mockito.never
+import org.mockito.Mockito.times
+import org.mockito.Mockito.verify
+import org.mockito.hamcrest.MockitoHamcrest.*
+import java.io.*
+import kotlin.Long.Companion.MAX_VALUE
+
+/**
+ * Unit test for [UpdateChecker].
+ */
+class UpdateCheckerTest {
+
+ private val eventBus = mock<EventBus>()
+ private val freenetInterface = mock<FreenetInterface>()
+ private val currentVersion = Version(1, 0, 0)
+ private val pluginHomepage = PluginHomepage("KSK@homepage")
+ private val updateChecker = UpdateChecker(eventBus, freenetInterface, currentVersion, pluginHomepage)
+
+ @Before
+ fun startUpdateChecker() {
+ updateChecker.start()
+ }
+
+ @Test
+ fun `new update checker does not have a latest version`() {
+ assertThat(updateChecker.hasLatestVersion(), equalTo(false))
+ assertThat(updateChecker.latestVersion, equalTo(currentVersion))
+ }
+
+ @Test
+ fun `starting an update checker register a usk`() {
+ verify(freenetInterface).registerUsk(any(FreenetURI::class.java), any(Callback::class.java))
+ }
+
+ @Test
+ fun `stopping an update checker unregisters a usk`() {
+ updateChecker.stop()
+ verify(freenetInterface).unregisterUsk(any(FreenetURI::class.java))
+ }
+
+ @Test
+ fun `callback does not download if new edition is not found`() {
+ setupCallbackWithEdition(MAX_VALUE, false)
+ verify(freenetInterface, never()).fetchUri(any(FreenetURI::class.java))
+ verify(eventBus, never()).post(argThat(instanceOf(UpdateFoundEvent::class.java)))
+ }
+
+ private fun setupCallbackWithEdition(edition: Long, newKnownGood: Boolean, newSlot: Boolean = false) {
+ val uri = forClass(FreenetURI::class.java)
+ val callback = forClass(Callback::class.java)
+ verify(freenetInterface).registerUsk(uri.capture(), callback.capture())
+ callback.value.editionFound(uri.value, edition, newKnownGood, newSlot)
+ }
+
+ @Test
+ fun `callback starts if new edition is found`() {
+ setupFetchResult(createFutureFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyEventIsFired(Version(99, 0, 0), 11865368297000L, false)
+ verifyThatUpdateCheckerKnowsLatestVersion(Version(99, 0, 0), 11865368297000L)
+ }
+
+ private fun createFutureFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("application/xml")
+ val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
+ "CurrentVersion/Version: 99.0.0\n" +
+ "CurrentVersion/ReleaseTime: 11865368297000\n" +
+ "DisruptiveVersion/0.1.2: true").toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ private fun verifyEventIsFired(version: Version, releaseTime: Long, disruptive: Boolean) {
+ val updateFoundEvent = forClass(UpdateFoundEvent::class.java)
+ verify(eventBus, times(1)).post(updateFoundEvent.capture())
+ assertThat(updateFoundEvent.value.version, equalTo(version))
+ assertThat(updateFoundEvent.value.releaseTime, equalTo(releaseTime))
+ assertThat(updateFoundEvent.value.isDisruptive, equalTo(disruptive))
+ }
+
+ private fun verifyThatUpdateCheckerKnowsLatestVersion(version: Version, releaseTime: Long) {
+ assertThat(updateChecker.latestVersion, equalTo(version))
+ assertThat(updateChecker.latestVersionDate, equalTo(releaseTime))
+ assertThat(updateChecker.hasLatestVersion(), equalTo(true))
+ }
+
+ @Test
+ fun `callback does not start if no new edition is found`() {
+ setupFetchResult(createPastFetchResult())
+ setupCallbackWithEdition(updateChecker.latestEdition, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun setupFetchResult(pastFetchResult: FetchResult) {
+ whenever(freenetInterface.fetchUri(any(FreenetURI::class.java))).thenAnswer { invocation ->
+ val freenetUri = invocation.arguments[0] as FreenetURI
+ Fetched(freenetUri, pastFetchResult)
+ }
+ }
+
+ private fun createPastFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("application/xml")
+ val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
+ "CurrentVersion/Version: 0.2\n" +
+ "CurrentVersion/ReleaseTime: 1289417883000").toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ @Test
+ fun `invalid update file does not start callback`() {
+ setupFetchResult(createInvalidFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun createInvalidFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("text/plain")
+ val fetched = ArrayBucket("Some other data.".toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ @Test
+ fun `non existing properties will not cause update to be found`() {
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun verifyNoUpdateFoundEventIsFired() {
+ verify(eventBus, never()).post(any(UpdateFoundEvent::class.java))
+ }
+
+ private fun verifyAFreenetUriIsFetched() {
+ verify(freenetInterface).fetchUri(any(FreenetURI::class.java))
+ }
+
+ @Test
+ fun `broken bucket does not cause update to be found`() {
+ setupFetchResult(createBrokenBucketFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun createBrokenBucketFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("text/plain")
+ val fetched = object : ArrayBucket("Some other data.".toByteArray()) {
+ override fun getInputStream() =
+ whenever(mock<InputStream>().read()).thenThrow(IOException()).getMock<InputStream>()
+ }
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ @Test
+ fun `invalid time does not cause an update to be found`() {
+ setupFetchResult(createInvalidTimeFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun createInvalidTimeFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("application/xml")
+ val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
+ "CurrentVersion/Version: 0.2\n" +
+ "CurrentVersion/ReleaseTime: invalid").toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ @Test
+ fun `invalid properties does not cause an update to be found`() {
+ setupFetchResult(createMissingTimeFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun createMissingTimeFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("application/xml")
+ val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\nCurrentVersion/Version: 0.2\n").toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ @Test
+ fun `invalid version does not cause an update to be found`() {
+ setupFetchResult(createInvalidVersionFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyNoUpdateFoundEventIsFired()
+ }
+
+ private fun createInvalidVersionFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("application/xml")
+ val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
+ "CurrentVersion/Version: foo\n" +
+ "CurrentVersion/ReleaseTime: 1289417883000").toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+ @Test
+ fun `disruptive version gets notification`() {
+ setupFetchResult(createDisruptiveVersionFetchResult())
+ setupCallbackWithEdition(MAX_VALUE, true)
+ verifyAFreenetUriIsFetched()
+ verifyEventIsFired(Version(1, 2, 3), 1289417883000L, true)
+ verifyThatUpdateCheckerKnowsLatestVersion(Version(1, 2, 3), 1289417883000L)
+ }
+
+ private fun createDisruptiveVersionFetchResult(): FetchResult {
+ val clientMetadata = ClientMetadata("application/xml")
+ val fetched = ArrayBucket(("# MapConfigurationBackendVersion=1\n" +
+ "CurrentVersion/Version: 1.2.3\n" +
+ "CurrentVersion/ReleaseTime: 1289417883000\n" +
+ "DisruptiveVersion/1.2.3: true").toByteArray())
+ return FetchResult(clientMetadata, fetched)
+ }
+
+}
projects / Sone.git / blobdiff