From: David ‘Bombe’ Roden Date: Wed, 7 Aug 2019 06:25:20 +0000 (+0200) Subject: 🎨 Replace UpdateCheckerTest with Kotlin version X-Git-Tag: v81^2~132 X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=commitdiff_plain;h=a252a5d76e8ff8e89da3277a8e9472a499b3bc2b 🎨 Replace UpdateCheckerTest with Kotlin version --- diff --git a/src/test/java/net/pterodactylus/sone/core/UpdateCheckerTest.java b/src/test/java/net/pterodactylus/sone/core/UpdateCheckerTest.java deleted file mode 100644 index 548051a..0000000 --- a/src/test/java/net/pterodactylus/sone/core/UpdateCheckerTest.java +++ /dev/null @@ -1,260 +0,0 @@ -package net.pterodactylus.sone.core; - -import static java.lang.Long.MAX_VALUE; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.is; -import static org.mockito.ArgumentCaptor.forClass; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.mockito.hamcrest.MockitoHamcrest.argThat; - -import java.io.IOException; -import java.io.InputStream; - -import net.pterodactylus.sone.core.FreenetInterface.Callback; -import net.pterodactylus.sone.core.event.UpdateFoundEvent; -import net.pterodactylus.sone.main.PluginHomepage; -import net.pterodactylus.util.version.Version; - -import freenet.client.ClientMetadata; -import freenet.client.FetchResult; -import freenet.keys.FreenetURI; -import freenet.support.api.Bucket; -import freenet.support.io.ArrayBucket; - -import com.google.common.eventbus.EventBus; -import org.junit.Before; -import org.junit.Test; -import org.mockito.ArgumentCaptor; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.stubbing.Answer; - -/** - * Unit test for {@link UpdateChecker}. - */ -public class UpdateCheckerTest { - - private final EventBus eventBus = mock(EventBus.class); - private final FreenetInterface freenetInterface = mock(FreenetInterface.class); - private final Version currentVersion = new Version(1, 0, 0); - private final PluginHomepage pluginHomepage = new PluginHomepage("KSK@homepage"); - private final UpdateChecker updateChecker = new UpdateChecker(eventBus, freenetInterface, currentVersion, pluginHomepage); - - @Before - public void startUpdateChecker() { - updateChecker.start(); - } - - @Test - public void newUpdateCheckerDoesNotHaveALatestVersion() { - assertThat(updateChecker.hasLatestVersion(), is(false)); - assertThat(updateChecker.getLatestVersion(), is(currentVersion)); - } - - @Test - public void startingAnUpdateCheckerRegisterAUsk() { - verify(freenetInterface).registerUsk(any(FreenetURI.class), any(Callback.class)); - } - - @Test - public void stoppingAnUpdateCheckerUnregistersAUsk() { - updateChecker.stop(); - verify(freenetInterface).unregisterUsk(any(FreenetURI.class)); - } - - @Test - public void callbackDoesNotDownloadIfNewEditionIsNotFound() { - setupCallbackWithEdition(MAX_VALUE, false, false); - verify(freenetInterface, never()).fetchUri(any(FreenetURI.class)); - verify(eventBus, never()).post(argThat(instanceOf(UpdateFoundEvent.class))); - } - - private void setupCallbackWithEdition(long edition, boolean newKnownGood, boolean newSlot) { - ArgumentCaptor uri = forClass(FreenetURI.class); - ArgumentCaptor callback = forClass(Callback.class); - verify(freenetInterface).registerUsk(uri.capture(), callback.capture()); - callback.getValue().editionFound(uri.getValue(), edition, newKnownGood, newSlot); - } - - @Test - public void callbackStartsIfNewEditionIsFound() { - setupFetchResult(createFutureFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyEventIsFired(new Version(99, 0, 0), 11865368297000L, false); - verifyThatUpdateCheckerKnowsLatestVersion(new Version(99, 0, 0), 11865368297000L); - } - - private FetchResult createFutureFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("application/xml"); - Bucket fetched = new ArrayBucket(("# MapConfigurationBackendVersion=1\n" + - "CurrentVersion/Version: 99.0.0\n" + - "CurrentVersion/ReleaseTime: 11865368297000\n" + - "DisruptiveVersion/0.1.2: true").getBytes()); - return new FetchResult(clientMetadata, fetched); - } - - private void verifyEventIsFired(Version version, long releaseTime, boolean disruptive) { - ArgumentCaptor updateFoundEvent = forClass(UpdateFoundEvent.class); - verify(eventBus, times(1)).post(updateFoundEvent.capture()); - assertThat(updateFoundEvent.getValue().getVersion(), is(version)); - assertThat(updateFoundEvent.getValue().getReleaseTime(), is(releaseTime)); - assertThat(updateFoundEvent.getValue().isDisruptive(), is(disruptive)); - } - - private void verifyThatUpdateCheckerKnowsLatestVersion(Version version, long releaseTime) { - assertThat(updateChecker.getLatestVersion(), is(version)); - assertThat(updateChecker.getLatestVersionDate(), is(releaseTime)); - assertThat(updateChecker.hasLatestVersion(), is(true)); - } - - @Test - public void callbackDoesNotStartIfNoNewEditionIsFound() { - setupFetchResult(createPastFetchResult()); - setupCallbackWithEdition(updateChecker.getLatestEdition(), true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private void setupFetchResult(final FetchResult pastFetchResult) { - when(freenetInterface.fetchUri(any(FreenetURI.class))).thenAnswer(new Answer() { - @Override - public Fetched answer(InvocationOnMock invocation) throws Throwable { - FreenetURI freenetUri = (FreenetURI) invocation.getArguments()[0]; - return new Fetched(freenetUri, pastFetchResult); - } - }); - } - - private FetchResult createPastFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("application/xml"); - Bucket fetched = new ArrayBucket(("# MapConfigurationBackendVersion=1\n" + - "CurrentVersion/Version: 0.2\n" + - "CurrentVersion/ReleaseTime: 1289417883000").getBytes()); - return new FetchResult(clientMetadata, fetched); - } - - @Test - public void invalidUpdateFileDoesNotStartCallback() { - setupFetchResult(createInvalidFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private FetchResult createInvalidFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("text/plain"); - Bucket fetched = new ArrayBucket("Some other data.".getBytes()); - return new FetchResult(clientMetadata, fetched); - } - - @Test - public void nonExistingPropertiesWillNotCauseUpdateToBeFound() { - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private void verifyNoUpdateFoundEventIsFired() { - verify(eventBus, never()).post(any(UpdateFoundEvent.class)); - } - - private void verifyAFreenetUriIsFetched() { - verify(freenetInterface).fetchUri(any(FreenetURI.class)); - } - - @Test - public void brokenBucketDoesNotCauseUpdateToBeFound() { - setupFetchResult(createBrokenBucketFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private FetchResult createBrokenBucketFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("text/plain"); - Bucket fetched = new ArrayBucket("Some other data.".getBytes()) { - @Override - public InputStream getInputStream() { - try { - return when(mock(InputStream.class).read()).thenThrow(IOException.class).getMock(); - } catch (IOException ioe1) { - /* won’t throw here. */ - return null; - } - } - }; - return new FetchResult(clientMetadata, fetched); - } - - @Test - public void invalidTimeDoesNotCauseAnUpdateToBeFound() { - setupFetchResult(createInvalidTimeFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private FetchResult createInvalidTimeFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("application/xml"); - Bucket fetched = new ArrayBucket(("# MapConfigurationBackendVersion=1\n" + - "CurrentVersion/Version: 0.2\n" + - "CurrentVersion/ReleaseTime: invalid").getBytes()); - return new FetchResult(clientMetadata, fetched); - } - - @Test - public void invalidPropertiesDoesNotCauseAnUpdateToBeFound() { - setupFetchResult(createMissingTimeFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private FetchResult createMissingTimeFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("application/xml"); - Bucket fetched = new ArrayBucket(("# MapConfigurationBackendVersion=1\n" + - "CurrentVersion/Version: 0.2\n").getBytes()); - return new FetchResult(clientMetadata, fetched); - } - - @Test - public void invalidVersionDoesNotCauseAnUpdateToBeFound() { - setupFetchResult(createInvalidVersionFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyNoUpdateFoundEventIsFired(); - } - - private FetchResult createInvalidVersionFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("application/xml"); - Bucket fetched = new ArrayBucket(("# MapConfigurationBackendVersion=1\n" + - "CurrentVersion/Version: foo\n" + - "CurrentVersion/ReleaseTime: 1289417883000").getBytes()); - return new FetchResult(clientMetadata, fetched); - } - - @Test - public void disruptiveVersionGetsNotification() { - setupFetchResult(createDisruptiveVersionFetchResult()); - setupCallbackWithEdition(MAX_VALUE, true, false); - verifyAFreenetUriIsFetched(); - verifyEventIsFired(new Version(1, 2, 3), 1289417883000L, true); - verifyThatUpdateCheckerKnowsLatestVersion(new Version(1, 2, 3), 1289417883000L); - } - - private FetchResult createDisruptiveVersionFetchResult() { - ClientMetadata clientMetadata = new ClientMetadata("application/xml"); - Bucket fetched = new ArrayBucket(("# MapConfigurationBackendVersion=1\n" + - "CurrentVersion/Version: 1.2.3\n" + - "CurrentVersion/ReleaseTime: 1289417883000\n" + - "DisruptiveVersion/1.2.3: true").getBytes()); - return new FetchResult(clientMetadata, fetched); - } - -} diff --git a/src/test/kotlin/net/pterodactylus/sone/core/UpdateCheckerTest.kt b/src/test/kotlin/net/pterodactylus/sone/core/UpdateCheckerTest.kt new file mode 100644 index 0000000..3bc8a9e --- /dev/null +++ b/src/test/kotlin/net/pterodactylus/sone/core/UpdateCheckerTest.kt @@ -0,0 +1,237 @@ +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() + private val freenetInterface = mock() + 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().read()).thenThrow(IOException()).getMock() + } + 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) + } + +}