1 package net.pterodactylus.fcp.quelaton;
3 import static org.hamcrest.MatcherAssert.assertThat;
4 import static org.hamcrest.Matchers.containsInAnyOrder;
5 import static org.hamcrest.Matchers.hasSize;
6 import static org.hamcrest.Matchers.is;
7 import static org.hamcrest.Matchers.notNullValue;
9 import java.io.ByteArrayInputStream;
11 import java.io.IOException;
12 import java.nio.charset.StandardCharsets;
13 import java.util.Collection;
14 import java.util.List;
15 import java.util.Optional;
16 import java.util.concurrent.ExecutionException;
17 import java.util.concurrent.ExecutorService;
18 import java.util.concurrent.Executors;
19 import java.util.concurrent.Future;
20 import java.util.stream.Collectors;
22 import net.pterodactylus.fcp.FcpKeyPair;
23 import net.pterodactylus.fcp.Key;
24 import net.pterodactylus.fcp.NodeData;
25 import net.pterodactylus.fcp.Peer;
26 import net.pterodactylus.fcp.Priority;
27 import net.pterodactylus.fcp.fake.FakeTcpServer;
28 import net.pterodactylus.fcp.quelaton.ClientGetCommand.Data;
30 import com.google.common.io.ByteStreams;
31 import com.google.common.io.Files;
32 import org.hamcrest.Description;
33 import org.hamcrest.Matcher;
34 import org.hamcrest.TypeSafeDiagnosingMatcher;
35 import org.junit.After;
36 import org.junit.Assert;
37 import org.junit.Test;
40 * Unit test for {@link DefaultFcpClient}.
42 * @author <a href="bombe@freenetproject.org">David ‘Bombe’ Roden</a>
44 public class DefaultFcpClientTest {
46 private static final String INSERT_URI =
47 "SSK@RVCHbJdkkyTCeNN9AYukEg76eyqmiosSaNKgE3U9zUw,7SHH53gletBVb9JD7nBsyClbLQsBubDPEIcwg908r7Y,AQECAAE/";
48 private static final String REQUEST_URI =
49 "SSK@wtbgd2loNcJCXvtQVOftl2tuWBomDQHfqS6ytpPRhfw,7SHH53gletBVb9JD7nBsyClbLQsBubDPEIcwg908r7Y,AQACAAE/";
51 private static int threadCounter = 0;
52 private final ExecutorService threadPool =
53 Executors.newCachedThreadPool(r -> new Thread(r, "Test-Thread-" + threadCounter++));
54 private final FakeTcpServer fcpServer;
55 private final DefaultFcpClient fcpClient;
57 public DefaultFcpClientTest() throws IOException {
58 fcpServer = new FakeTcpServer(threadPool);
59 fcpClient = new DefaultFcpClient(threadPool, "localhost", fcpServer.getPort(), () -> "Test");
63 public void tearDown() throws IOException {
67 @Test(expected = ExecutionException.class)
68 public void defaultFcpClientThrowsExceptionIfItCanNotConnect()
69 throws IOException, ExecutionException, InterruptedException {
70 Future<FcpKeyPair> keyPairFuture = fcpClient.generateKeypair().execute();
71 fcpServer.connect().get();
72 fcpServer.collectUntil(is("EndMessage"));
74 "CloseConnectionDuplicateClientName",
80 @Test(expected = ExecutionException.class)
81 public void defaultFcpClientThrowsExceptionIfConnectionIsClosed()
82 throws IOException, ExecutionException, InterruptedException {
83 Future<FcpKeyPair> keyPairFuture = fcpClient.generateKeypair().execute();
84 fcpServer.connect().get();
85 fcpServer.collectUntil(is("EndMessage"));
91 public void defaultFcpClientCanGenerateKeypair() throws ExecutionException, InterruptedException, IOException {
92 Future<FcpKeyPair> keyPairFuture = fcpClient.generateKeypair().execute();
94 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
95 String identifier = extractIdentifier(lines);
96 fcpServer.writeLine("SSKKeypair",
97 "InsertURI=" + INSERT_URI + "",
98 "RequestURI=" + REQUEST_URI + "",
99 "Identifier=" + identifier,
101 FcpKeyPair keyPair = keyPairFuture.get();
102 assertThat(keyPair.getPublicKey(), is(REQUEST_URI));
103 assertThat(keyPair.getPrivateKey(), is(INSERT_URI));
106 private void connectNode() throws InterruptedException, ExecutionException, IOException {
107 fcpServer.connect().get();
108 fcpServer.collectUntil(is("EndMessage"));
109 fcpServer.writeLine("NodeHello",
110 "CompressionCodecs=4 - GZIP(0), BZIP2(1), LZMA(2), LZMA_NEW(3)",
111 "Revision=build01466",
113 "Version=Fred,0.7,1.0,1466",
115 "ConnectionIdentifier=14318898267048452a81b36e7f13a3f0",
119 "NodeLanguage=ENGLISH",
126 public void clientGetCanDownloadData() throws InterruptedException, ExecutionException, IOException {
127 Future<Optional<Data>> dataFuture = fcpClient.clientGet().uri("KSK@foo.txt").execute();
129 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
130 assertThat(lines, matchesFcpMessage("ClientGet", "ReturnType=direct", "URI=KSK@foo.txt"));
131 String identifier = extractIdentifier(lines);
134 "Identifier=" + identifier,
136 "StartupTime=1435610539000",
137 "CompletionTime=1435610540000",
138 "Metadata.ContentType=text/plain;charset=utf-8",
142 Optional<Data> data = dataFuture.get();
143 assertThat(data.get().getMimeType(), is("text/plain;charset=utf-8"));
144 assertThat(data.get().size(), is(6L));
145 assertThat(ByteStreams.toByteArray(data.get().getInputStream()),
146 is("Hello\n".getBytes(StandardCharsets.UTF_8)));
149 private String extractIdentifier(List<String> lines) {
150 return lines.stream()
151 .filter(s -> s.startsWith("Identifier="))
152 .map(s -> s.substring(s.indexOf('=') + 1))
158 public void clientGetDownloadsDataForCorrectIdentifier()
159 throws InterruptedException, ExecutionException, IOException {
160 Future<Optional<Data>> dataFuture = fcpClient.clientGet().uri("KSK@foo.txt").execute();
162 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
163 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt"));
164 String identifier = extractIdentifier(lines);
167 "Identifier=not-test",
169 "StartupTime=1435610539000",
170 "CompletionTime=1435610540000",
171 "Metadata.ContentType=text/plain;charset=latin-9",
177 "Identifier=" + identifier,
179 "StartupTime=1435610539000",
180 "CompletionTime=1435610540000",
181 "Metadata.ContentType=text/plain;charset=utf-8",
185 Optional<Data> data = dataFuture.get();
186 assertThat(data.get().getMimeType(), is("text/plain;charset=utf-8"));
187 assertThat(data.get().size(), is(6L));
188 assertThat(ByteStreams.toByteArray(data.get().getInputStream()),
189 is("Hello\n".getBytes(StandardCharsets.UTF_8)));
193 public void clientGetRecognizesGetFailed() throws InterruptedException, ExecutionException, IOException {
194 Future<Optional<Data>> dataFuture = fcpClient.clientGet().uri("KSK@foo.txt").execute();
196 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
197 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt"));
198 String identifier = extractIdentifier(lines);
201 "Identifier=" + identifier,
205 Optional<Data> data = dataFuture.get();
206 assertThat(data.isPresent(), is(false));
210 public void clientGetRecognizesGetFailedForCorrectIdentifier()
211 throws InterruptedException, ExecutionException, IOException {
212 Future<Optional<Data>> dataFuture = fcpClient.clientGet().uri("KSK@foo.txt").execute();
214 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
215 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt"));
216 String identifier = extractIdentifier(lines);
219 "Identifier=not-test",
225 "Identifier=" + identifier,
229 Optional<Data> data = dataFuture.get();
230 assertThat(data.isPresent(), is(false));
233 @Test(expected = ExecutionException.class)
234 public void clientGetRecognizesConnectionClosed() throws InterruptedException, ExecutionException, IOException {
235 Future<Optional<Data>> dataFuture = fcpClient.clientGet().uri("KSK@foo.txt").execute();
237 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
238 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt"));
244 public void defaultFcpClientReusesConnection() throws InterruptedException, ExecutionException, IOException {
245 Future<FcpKeyPair> keyPair = fcpClient.generateKeypair().execute();
247 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
248 String identifier = extractIdentifier(lines);
251 "InsertURI=" + INSERT_URI + "",
252 "RequestURI=" + REQUEST_URI + "",
253 "Identifier=" + identifier,
257 keyPair = fcpClient.generateKeypair().execute();
258 lines = fcpServer.collectUntil(is("EndMessage"));
259 identifier = extractIdentifier(lines);
262 "InsertURI=" + INSERT_URI + "",
263 "RequestURI=" + REQUEST_URI + "",
264 "Identifier=" + identifier,
271 public void defaultFcpClientCanReconnectAfterConnectionHasBeenClosed()
272 throws InterruptedException, ExecutionException, IOException {
273 Future<FcpKeyPair> keyPair = fcpClient.generateKeypair().execute();
275 fcpServer.collectUntil(is("EndMessage"));
280 } catch (ExecutionException e) {
282 keyPair = fcpClient.generateKeypair().execute();
284 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
285 String identifier = extractIdentifier(lines);
288 "InsertURI=" + INSERT_URI + "",
289 "RequestURI=" + REQUEST_URI + "",
290 "Identifier=" + identifier,
297 public void clientGetWithIgnoreDataStoreSettingSendsCorrectCommands()
298 throws InterruptedException, ExecutionException, IOException {
299 fcpClient.clientGet().ignoreDataStore().uri("KSK@foo.txt").execute();
301 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
302 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt", "IgnoreDS=true"));
306 public void clientGetWithDataStoreOnlySettingSendsCorrectCommands()
307 throws InterruptedException, ExecutionException, IOException {
308 fcpClient.clientGet().dataStoreOnly().uri("KSK@foo.txt").execute();
310 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
311 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt", "DSonly=true"));
315 public void clientGetWithMaxSizeSettingSendsCorrectCommands()
316 throws InterruptedException, ExecutionException, IOException {
317 fcpClient.clientGet().maxSize(1048576).uri("KSK@foo.txt").execute();
319 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
320 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt", "MaxSize=1048576"));
324 public void clientGetWithPrioritySettingSendsCorrectCommands()
325 throws InterruptedException, ExecutionException, IOException {
326 fcpClient.clientGet().priority(Priority.interactive).uri("KSK@foo.txt").execute();
328 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
329 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt", "PriorityClass=1"));
333 public void clientGetWithRealTimeSettingSendsCorrectCommands()
334 throws InterruptedException, ExecutionException, IOException {
335 fcpClient.clientGet().realTime().uri("KSK@foo.txt").execute();
337 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
338 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt", "RealTimeFlag=true"));
342 public void clientGetWithGlobalSettingSendsCorrectCommands()
343 throws InterruptedException, ExecutionException, IOException {
344 fcpClient.clientGet().global().uri("KSK@foo.txt").execute();
346 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
347 assertThat(lines, matchesFcpMessage("ClientGet", "URI=KSK@foo.txt", "Global=true"));
350 private Matcher<List<String>> matchesFcpMessage(String name, String... requiredLines) {
351 return new TypeSafeDiagnosingMatcher<List<String>>() {
353 protected boolean matchesSafely(List<String> item, Description mismatchDescription) {
354 if (!item.get(0).equals(name)) {
355 mismatchDescription.appendText("FCP message is named ").appendValue(item.get(0));
358 for (String requiredLine : requiredLines) {
359 if (item.indexOf(requiredLine) < 1) {
360 mismatchDescription.appendText("FCP message does not contain ").appendValue(requiredLine);
368 public void describeTo(Description description) {
369 description.appendText("FCP message named ").appendValue(name);
370 description.appendValueList(", containing the lines ", ", ", "", requiredLines);
376 public void clientPutWithDirectDataSendsCorrectCommand()
377 throws IOException, ExecutionException, InterruptedException {
378 fcpClient.clientPut()
379 .from(new ByteArrayInputStream("Hello\n".getBytes()))
384 List<String> lines = fcpServer.collectUntil(is("Hello"));
385 assertThat(lines, matchesFcpMessage("ClientPut", "UploadFrom=direct", "DataLength=6", "URI=KSK@foo.txt"));
389 public void clientPutWithDirectDataSucceedsOnCorrectIdentifier()
390 throws InterruptedException, ExecutionException, IOException {
391 Future<Optional<Key>> key = fcpClient.clientPut()
392 .from(new ByteArrayInputStream("Hello\n".getBytes()))
397 List<String> lines = fcpServer.collectUntil(is("Hello"));
398 String identifier = extractIdentifier(lines);
401 "Identifier=not-the-right-one",
407 "Identifier=" + identifier,
410 assertThat(key.get().get().getKey(), is("KSK@foo.txt"));
414 public void clientPutWithDirectDataFailsOnCorrectIdentifier()
415 throws InterruptedException, ExecutionException, IOException {
416 Future<Optional<Key>> key = fcpClient.clientPut()
417 .from(new ByteArrayInputStream("Hello\n".getBytes()))
422 List<String> lines = fcpServer.collectUntil(is("Hello"));
423 String identifier = extractIdentifier(lines);
426 "Identifier=not-the-right-one",
432 "Identifier=" + identifier,
435 assertThat(key.get().isPresent(), is(false));
439 public void clientPutWithRenamedDirectDataSendsCorrectCommand()
440 throws InterruptedException, ExecutionException, IOException {
441 fcpClient.clientPut()
442 .named("otherName.txt")
443 .from(new ByteArrayInputStream("Hello\n".getBytes()))
448 List<String> lines = fcpServer.collectUntil(is("Hello"));
449 assertThat(lines, matchesFcpMessage("ClientPut", "TargetFilename=otherName.txt", "UploadFrom=direct",
450 "DataLength=6", "URI=KSK@foo.txt"));
454 public void clientPutWithRedirectSendsCorrectCommand()
455 throws IOException, ExecutionException, InterruptedException {
456 fcpClient.clientPut().redirectTo("KSK@bar.txt").uri("KSK@foo.txt").execute();
458 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
460 matchesFcpMessage("ClientPut", "UploadFrom=redirect", "URI=KSK@foo.txt", "TargetURI=KSK@bar.txt"));
464 public void clientPutWithFileSendsCorrectCommand() throws InterruptedException, ExecutionException, IOException {
465 fcpClient.clientPut().from(new File("/tmp/data.txt")).uri("KSK@foo.txt").execute();
467 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
469 matchesFcpMessage("ClientPut", "UploadFrom=disk", "URI=KSK@foo.txt", "Filename=/tmp/data.txt"));
473 public void clientPutWithFileCanCompleteTestDdaSequence()
474 throws IOException, ExecutionException, InterruptedException {
475 File tempFile = createTempFile();
476 fcpClient.clientPut().from(new File(tempFile.getParent(), "test.dat")).uri("KSK@foo.txt").execute();
478 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
479 String identifier = extractIdentifier(lines);
482 "Identifier=" + identifier,
486 lines = fcpServer.collectUntil(is("EndMessage"));
487 assertThat(lines, matchesFcpMessage(
489 "Directory=" + tempFile.getParent(),
490 "WantReadDirectory=true",
491 "WantWriteDirectory=false",
496 "Directory=" + tempFile.getParent(),
497 "ReadFilename=" + tempFile,
500 lines = fcpServer.collectUntil(is("EndMessage"));
501 assertThat(lines, matchesFcpMessage(
503 "Directory=" + tempFile.getParent(),
504 "ReadContent=test-content",
509 "Directory=" + tempFile.getParent(),
510 "ReadDirectoryAllowed=true",
513 lines = fcpServer.collectUntil(is("EndMessage"));
515 matchesFcpMessage("ClientPut", "UploadFrom=disk", "URI=KSK@foo.txt",
516 "Filename=" + new File(tempFile.getParent(), "test.dat")));
519 private File createTempFile() throws IOException {
520 File tempFile = File.createTempFile("test-dda-", ".dat");
521 tempFile.deleteOnExit();
522 Files.write("test-content", tempFile, StandardCharsets.UTF_8);
527 public void clientPutDoesNotReactToProtocolErrorForDifferentIdentifier()
528 throws InterruptedException, ExecutionException, IOException {
529 Future<Optional<Key>> key = fcpClient.clientPut().from(new File("/tmp/data.txt")).uri("KSK@foo.txt").execute();
531 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
532 String identifier = extractIdentifier(lines);
535 "Identifier=not-the-right-one",
541 "Identifier=" + identifier,
545 assertThat(key.get().get().getKey(), is("KSK@foo.txt"));
549 public void clientPutAbortsOnProtocolErrorOtherThan25()
550 throws InterruptedException, ExecutionException, IOException {
551 Future<Optional<Key>> key = fcpClient.clientPut().from(new File("/tmp/data.txt")).uri("KSK@foo.txt").execute();
553 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
554 String identifier = extractIdentifier(lines);
557 "Identifier=" + identifier,
561 assertThat(key.get().isPresent(), is(false));
565 public void clientPutDoesNotReplyToWrongTestDdaReply() throws IOException, ExecutionException,
566 InterruptedException {
567 File tempFile = createTempFile();
568 fcpClient.clientPut().from(new File(tempFile.getParent(), "test.dat")).uri("KSK@foo.txt").execute();
570 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
571 String identifier = extractIdentifier(lines);
574 "Identifier=" + identifier,
578 lines = fcpServer.collectUntil(is("EndMessage"));
579 assertThat(lines, matchesFcpMessage(
581 "Directory=" + tempFile.getParent(),
582 "WantReadDirectory=true",
583 "WantWriteDirectory=false",
588 "Directory=/some-other-directory",
589 "ReadFilename=" + tempFile,
594 "Directory=" + tempFile.getParent(),
595 "ReadFilename=" + tempFile,
598 lines = fcpServer.collectUntil(is("EndMessage"));
599 assertThat(lines, matchesFcpMessage(
601 "Directory=" + tempFile.getParent(),
602 "ReadContent=test-content",
608 public void clientPutSendsResponseEvenIfFileCanNotBeRead()
609 throws IOException, ExecutionException, InterruptedException {
610 File tempFile = createTempFile();
611 fcpClient.clientPut().from(new File(tempFile.getParent(), "test.dat")).uri("KSK@foo.txt").execute();
613 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
614 String identifier = extractIdentifier(lines);
617 "Identifier=" + identifier,
621 lines = fcpServer.collectUntil(is("EndMessage"));
622 assertThat(lines, matchesFcpMessage(
624 "Directory=" + tempFile.getParent(),
625 "WantReadDirectory=true",
626 "WantWriteDirectory=false",
631 "Directory=" + tempFile.getParent(),
632 "ReadFilename=" + tempFile + ".foo",
635 lines = fcpServer.collectUntil(is("EndMessage"));
636 assertThat(lines, matchesFcpMessage(
638 "Directory=" + tempFile.getParent(),
639 "ReadContent=failed-to-read",
645 public void clientPutDoesNotResendOriginalClientPutOnTestDDACompleteWithWrongDirectory()
646 throws IOException, ExecutionException, InterruptedException {
647 File tempFile = createTempFile();
648 fcpClient.clientPut().from(new File(tempFile.getParent(), "test.dat")).uri("KSK@foo.txt").execute();
650 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
651 String identifier = extractIdentifier(lines);
654 "Directory=/some-other-directory",
659 "Identifier=" + identifier,
663 lines = fcpServer.collectUntil(is("EndMessage"));
664 assertThat(lines, matchesFcpMessage(
666 "Directory=" + tempFile.getParent(),
667 "WantReadDirectory=true",
668 "WantWriteDirectory=false",
674 public void clientCanListPeers() throws IOException, ExecutionException, InterruptedException {
675 Future<Collection<Peer>> peers = fcpClient.listPeers().execute();
677 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
678 assertThat(lines, matchesFcpMessage(
680 "WithVolatile=false",
681 "WithMetadata=false",
684 String identifier = extractIdentifier(lines);
687 "Identifier=" + identifier,
693 "Identifier=" + identifier,
699 "Identifier=" + identifier,
702 assertThat(peers.get(), hasSize(2));
703 assertThat(peers.get().stream().map(Peer::getIdentity).collect(Collectors.toList()),
704 containsInAnyOrder("id1", "id2"));
708 public void clientCanListPeersWithMetadata() throws IOException, ExecutionException, InterruptedException {
709 Future<Collection<Peer>> peers = fcpClient.listPeers().includeMetadata().execute();
711 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
712 assertThat(lines, matchesFcpMessage(
714 "WithVolatile=false",
718 String identifier = extractIdentifier(lines);
721 "Identifier=" + identifier,
728 "Identifier=" + identifier,
735 "Identifier=" + identifier,
738 assertThat(peers.get(), hasSize(2));
739 assertThat(peers.get().stream().map(peer -> peer.getMetadata("foo")).collect(Collectors.toList()),
740 containsInAnyOrder("bar1", "bar2"));
744 public void clientCanListPeersWithVolatiles() throws IOException, ExecutionException, InterruptedException {
745 Future<Collection<Peer>> peers = fcpClient.listPeers().includeVolatile().execute();
747 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
748 assertThat(lines, matchesFcpMessage(
751 "WithMetadata=false",
754 String identifier = extractIdentifier(lines);
757 "Identifier=" + identifier,
764 "Identifier=" + identifier,
771 "Identifier=" + identifier,
774 assertThat(peers.get(), hasSize(2));
775 assertThat(peers.get().stream().map(peer -> peer.getVolatile("foo")).collect(Collectors.toList()),
776 containsInAnyOrder("bar1", "bar2"));
780 public void defaultFcpClientCanGetNodeInformation() throws InterruptedException, ExecutionException, IOException {
781 Future<NodeData> nodeData = fcpClient.getNode().execute();
783 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
784 String identifier = extractIdentifier(lines);
785 assertThat(lines, matchesFcpMessage(
787 "Identifier=" + identifier,
788 "GiveOpennetRef=false",
790 "WithVolatile=false",
795 "Identifier=" + identifier,
796 "ark.pubURI=SSK@3YEf.../ark",
799 "version=Fred,0.7,1.0,1466",
800 "lastGoodVersion=Fred,0.7,1.0,1466",
803 assertThat(nodeData.get(), notNullValue());
807 public void defaultFcpClientCanGetNodeInformationWithOpennetRef()
808 throws InterruptedException, ExecutionException, IOException {
809 Future<NodeData> nodeData = fcpClient.getNode().opennetRef().execute();
811 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
812 String identifier = extractIdentifier(lines);
813 assertThat(lines, matchesFcpMessage(
815 "Identifier=" + identifier,
816 "GiveOpennetRef=true",
818 "WithVolatile=false",
823 "Identifier=" + identifier,
825 "ark.pubURI=SSK@3YEf.../ark",
828 "version=Fred,0.7,1.0,1466",
829 "lastGoodVersion=Fred,0.7,1.0,1466",
832 assertThat(nodeData.get().getVersion().toString(), is("Fred,0.7,1.0,1466"));
836 public void defaultFcpClientCanGetNodeInformationWithPrivateData()
837 throws InterruptedException, ExecutionException, IOException {
838 Future<NodeData> nodeData = fcpClient.getNode().includePrivate().execute();
840 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
841 String identifier = extractIdentifier(lines);
842 assertThat(lines, matchesFcpMessage(
844 "Identifier=" + identifier,
845 "GiveOpennetRef=false",
847 "WithVolatile=false",
852 "Identifier=" + identifier,
854 "ark.pubURI=SSK@3YEf.../ark",
857 "version=Fred,0.7,1.0,1466",
858 "lastGoodVersion=Fred,0.7,1.0,1466",
859 "ark.privURI=SSK@XdHMiRl",
862 assertThat(nodeData.get().getARK().getPrivateURI(), is("SSK@XdHMiRl"));
866 public void defaultFcpClientCanGetNodeInformationWithVolatileData()
867 throws InterruptedException, ExecutionException, IOException {
868 Future<NodeData> nodeData = fcpClient.getNode().includeVolatile().execute();
870 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
871 String identifier = extractIdentifier(lines);
872 assertThat(lines, matchesFcpMessage(
874 "Identifier=" + identifier,
875 "GiveOpennetRef=false",
882 "Identifier=" + identifier,
884 "ark.pubURI=SSK@3YEf.../ark",
887 "version=Fred,0.7,1.0,1466",
888 "lastGoodVersion=Fred,0.7,1.0,1466",
889 "volatile.freeJavaMemory=205706528",
892 assertThat(nodeData.get().getVolatile("freeJavaMemory").toString(), is("205706528"));