package net.pterodactylus.fcp.quelaton;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
+import java.util.function.Supplier;
import java.util.stream.Collectors;
import net.pterodactylus.fcp.ARK;
import net.pterodactylus.fcp.NodeRef;
import net.pterodactylus.fcp.Peer;
import net.pterodactylus.fcp.PeerNote;
+import net.pterodactylus.fcp.PluginInfo;
import net.pterodactylus.fcp.Priority;
import net.pterodactylus.fcp.fake.FakeTcpServer;
import net.pterodactylus.fcp.quelaton.ClientGetCommand.Data;
import com.google.common.io.ByteStreams;
import com.google.common.io.Files;
+import com.nitorcreations.junit.runners.NestedRunner;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeDiagnosingMatcher;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
+import org.junit.runner.RunWith;
/**
* Unit test for {@link DefaultFcpClient}.
*
* @author <a href="bombe@freenetproject.org">David ‘Bombe’ Roden</a>
*/
+@RunWith(NestedRunner.class)
public class DefaultFcpClientTest {
private static final String INSERT_URI =
private static final String REQUEST_URI =
"SSK@wtbgd2loNcJCXvtQVOftl2tuWBomDQHfqS6ytpPRhfw,7SHH53gletBVb9JD7nBsyClbLQsBubDPEIcwg908r7Y,AQACAAE/";
- private static int threadCounter = 0;
+ private int threadCounter = 0;
+ private final ExecutorService threadPool =
+ Executors.newCachedThreadPool(r -> new Thread(r, "Test-Thread-" + threadCounter++));
private final FakeTcpServer fcpServer;
private final DefaultFcpClient fcpClient;
public DefaultFcpClientTest() throws IOException {
- ExecutorService threadPool =
- Executors.newCachedThreadPool(r -> new Thread(r, "Test-Thread-" + threadCounter++));
fcpServer = new FakeTcpServer(threadPool);
fcpClient = new DefaultFcpClient(threadPool, "localhost", fcpServer.getPort(), () -> "Test");
}
@After
public void tearDown() throws IOException {
fcpServer.close();
+ threadPool.shutdown();
}
@Test(expected = ExecutionException.class)
assertThat(configData.get().getLongDescription("foo"), is("bar"));
}
+ @Test
+ public void defaultFcpClientCanGetConfigWithDataTypes()
+ throws InterruptedException, ExecutionException, IOException {
+ Future<ConfigData> configData = fcpClient.getConfig().withDataTypes().execute();
+ connectNode();
+ List<String> lines = fcpServer.collectUntil(is("EndMessage"));
+ String identifier = extractIdentifier(lines);
+ assertThat(lines, matchesFcpMessage(
+ "GetConfig",
+ "Identifier=" + identifier,
+ "WithDataTypes=true",
+ "EndMessage"
+ ));
+ fcpServer.writeLine(
+ "ConfigData",
+ "Identifier=" + identifier,
+ "dataType.foo=number",
+ "EndMessage"
+ );
+ assertThat(configData.get().getDataType("foo"), is("number"));
+ }
+
+ @Test
+ public void defaultFcpClientCanModifyConfigData() throws InterruptedException, ExecutionException, IOException {
+ Future<ConfigData> newConfigData = fcpClient.modifyConfig().set("foo.bar").to("baz").execute();
+ connectNode();
+ List<String> lines = fcpServer.collectUntil(is("EndMessage"));
+ String identifier = extractIdentifier(lines);
+ assertThat(lines, matchesFcpMessage(
+ "ModifyConfig",
+ "Identifier=" + identifier,
+ "foo.bar=baz",
+ "EndMessage"
+ ));
+ fcpServer.writeLine(
+ "ConfigData",
+ "Identifier=" + identifier,
+ "current.foo.bar=baz",
+ "EndMessage"
+ );
+ assertThat(newConfigData.get().getCurrent("foo.bar"), is("baz"));
+ }
+
+ public class PluginCommands {
+
+ private static final String CLASS_NAME = "foo.plugin.Plugin";
+
+ private List<String> lines;
+ private String identifier;
+
+ private void connectAndAssert(Supplier<Matcher<List<String>>> requestMatcher)
+ throws InterruptedException, ExecutionException, IOException {
+ connectNode();
+ lines = fcpServer.collectUntil(is("EndMessage"));
+ identifier = extractIdentifier(lines);
+ assertThat(lines, requestMatcher.get());
+ }
+
+ private void replyWithPluginInfo() throws IOException {
+ fcpServer.writeLine(
+ "PluginInfo",
+ "Identifier=" + identifier,
+ "PluginName=superPlugin",
+ "IsTalkable=true",
+ "LongVersion=1.2.3",
+ "Version=42",
+ "OriginUri=superPlugin",
+ "Started=true",
+ "EndMessage"
+ );
+ }
+
+ private void verifyPluginInfo(Future<Optional<PluginInfo>> pluginInfo)
+ throws InterruptedException, ExecutionException {
+ assertThat(pluginInfo.get().get().getPluginName(), is("superPlugin"));
+ assertThat(pluginInfo.get().get().getOriginalURI(), is("superPlugin"));
+ assertThat(pluginInfo.get().get().isTalkable(), is(true));
+ assertThat(pluginInfo.get().get().getVersion(), is("42"));
+ assertThat(pluginInfo.get().get().getLongVersion(), is("1.2.3"));
+ assertThat(pluginInfo.get().get().isStarted(), is(true));
+ }
+
+ public class LoadPlugin {
+
+ public class OfficialPlugins {
+
+ @Test
+ public void fromFreenet() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.loadPlugin().officialFromFreenet("superPlugin").execute();
+ connectAndAssert(() -> createMatcherForOfficialSource("freenet"));
+ assertThat(lines, not(contains(startsWith("Store="))));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void persistentFromFreenet() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.loadPlugin().addToConfig().officialFromFreenet("superPlugin").execute();
+ connectAndAssert(() -> createMatcherForOfficialSource("freenet"));
+ assertThat(lines, hasItem("Store=true"));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void fromHttps() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.loadPlugin().officialFromHttps("superPlugin").execute();
+ connectAndAssert(() -> createMatcherForOfficialSource("https"));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ private Matcher<List<String>> createMatcherForOfficialSource(String officialSource) {
+ return matchesFcpMessage(
+ "LoadPlugin",
+ "Identifier=" + identifier,
+ "PluginURL=superPlugin",
+ "URLType=official",
+ "OfficialSource=" + officialSource,
+ "EndMessage"
+ );
+ }
+
+ }
+
+ public class FromOtherSources {
+
+ private static final String FILE_PATH = "/path/to/plugin.jar";
+ private static final String URL = "http://server.com/plugin.jar";
+ private static final String KEY = "KSK@plugin.jar";
+
+ @Test
+ public void fromFile() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo = fcpClient.loadPlugin().fromFile(FILE_PATH).execute();
+ connectAndAssert(() -> createMatcher("file", FILE_PATH));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void fromUrl() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo = fcpClient.loadPlugin().fromUrl(URL).execute();
+ connectAndAssert(() -> createMatcher("url", URL));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void fromFreenet() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo = fcpClient.loadPlugin().fromFreenet(KEY).execute();
+ connectAndAssert(() -> createMatcher("freenet", KEY));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ private Matcher<List<String>> createMatcher(String urlType, String url) {
+ return matchesFcpMessage(
+ "LoadPlugin",
+ "Identifier=" + identifier,
+ "PluginURL=" + url,
+ "URLType=" + urlType,
+ "EndMessage"
+ );
+ }
+
+ }
+
+ public class Failed {
+
+ @Test
+ public void failedLoad() throws ExecutionException, InterruptedException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.loadPlugin().officialFromFreenet("superPlugin").execute();
+ connectNode();
+ List<String> lines = fcpServer.collectUntil(is("EndMessage"));
+ String identifier = extractIdentifier(lines);
+ fcpServer.writeLine(
+ "ProtocolError",
+ "Identifier=" + identifier,
+ "EndMessage"
+ );
+ assertThat(pluginInfo.get().isPresent(), is(false));
+ }
+
+ }
+
+ }
+
+ public class ReloadPlugin {
+
+ @Test
+ public void reloadingPluginWorks() throws InterruptedException, ExecutionException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo = fcpClient.reloadPlugin().plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> matchReloadPluginMessage());
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void reloadingPluginWithMaxWaitTimeWorks()
+ throws InterruptedException, ExecutionException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.reloadPlugin().waitFor(1234).plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> allOf(matchReloadPluginMessage(), hasItem("MaxWaitTime=1234")));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void reloadingPluginWithPurgeWorks()
+ throws InterruptedException, ExecutionException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.reloadPlugin().purge().plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> allOf(matchReloadPluginMessage(), hasItem("Purge=true")));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ @Test
+ public void reloadingPluginWithStoreWorks()
+ throws InterruptedException, ExecutionException, IOException {
+ Future<Optional<PluginInfo>> pluginInfo =
+ fcpClient.reloadPlugin().addToConfig().plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> allOf(matchReloadPluginMessage(), hasItem("Store=true")));
+ replyWithPluginInfo();
+ verifyPluginInfo(pluginInfo);
+ }
+
+ private Matcher<List<String>> matchReloadPluginMessage() {
+ return matchesFcpMessage(
+ "ReloadPlugin",
+ "Identifier=" + identifier,
+ "PluginName=" + CLASS_NAME,
+ "EndMessage"
+ );
+ }
+
+ }
+
+ public class RemovePlugin {
+
+ @Test
+ public void removingPluginWorks() throws InterruptedException, ExecutionException, IOException {
+ Future<Boolean> pluginRemoved = fcpClient.removePlugin().plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> matchPluginRemovedMessage());
+ replyWithPluginRemoved();
+ assertThat(pluginRemoved.get(), is(true));
+ }
+
+ @Test
+ public void removingPluginWithMaxWaitTimeWorks()
+ throws InterruptedException, ExecutionException, IOException {
+ Future<Boolean> pluginRemoved = fcpClient.removePlugin().waitFor(1234).plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> allOf(matchPluginRemovedMessage(), hasItem("MaxWaitTime=1234")));
+ replyWithPluginRemoved();
+ assertThat(pluginRemoved.get(), is(true));
+ }
+
+ @Test
+ public void removingPluginWithPurgeWorks()
+ throws InterruptedException, ExecutionException, IOException {
+ Future<Boolean> pluginRemoved = fcpClient.removePlugin().purge().plugin(CLASS_NAME).execute();
+ connectAndAssert(() -> allOf(matchPluginRemovedMessage(), hasItem("Purge=true")));
+ replyWithPluginRemoved();
+ assertThat(pluginRemoved.get(), is(true));
+ }
+
+ private void replyWithPluginRemoved() throws IOException {
+ fcpServer.writeLine(
+ "PluginRemoved",
+ "Identifier=" + identifier,
+ "PluginName=" + CLASS_NAME,
+ "EndMessage"
+ );
+ }
+
+ private Matcher<List<String>> matchPluginRemovedMessage() {
+ return matchesFcpMessage(
+ "RemovePlugin",
+ "Identifier=" + identifier,
+ "PluginName=" + CLASS_NAME,
+ "EndMessage"
+ );
+ }
+
+ }
+
+ }
+
}