src/test/java/net/pterodactylus/fcp/quelaton/DefaultFcpClientTest.java

   1 package net.pterodactylus.fcp.quelaton;
   2
   3 import static org.hamcrest.MatcherAssert.assertThat;
   4 import static org.hamcrest.Matchers.containsInAnyOrder;
   5 import static org.hamcrest.Matchers.is;
   6
   7 import java.io.IOException;
   8 import java.nio.charset.StandardCharsets;
   9 import java.util.List;
  10 import java.util.Optional;
  11 import java.util.concurrent.ExecutionException;
  12 import java.util.concurrent.ExecutorService;
  13 import java.util.concurrent.Executors;
  14 import java.util.concurrent.Future;
  15
  16 import net.pterodactylus.fcp.FcpKeyPair;
  17 import net.pterodactylus.fcp.Priority;
  18 import net.pterodactylus.fcp.fake.FakeTcpServer;
  19 import net.pterodactylus.fcp.quelaton.ClientGetCommand.Data;
  20
  21 import com.google.common.io.ByteStreams;
  22 import org.junit.After;
  23 import org.junit.Test;
  24
  25 /**
  26  * Unit test for {@link DefaultFcpClient}.
  27  *
  28  * @author <a href="bombe@freenetproject.org">David ‘Bombe’ Roden</a>
  29  */
  30 public class DefaultFcpClientTest {
  31
  32         private static final String INSERT_URI = "SSK@RVCHbJdkkyTCeNN9AYukEg76eyqmiosSaNKgE3U9zUw,7SHH53gletBVb9JD7nBsyClbLQsBubDPEIcwg908r7Y,AQECAAE/";
  33         private static final String REQUEST_URI = "SSK@wtbgd2loNcJCXvtQVOftl2tuWBomDQHfqS6ytpPRhfw,7SHH53gletBVb9JD7nBsyClbLQsBubDPEIcwg908r7Y,AQACAAE/";
  34
  35         private static int threadCounter = 0;
  36         private final ExecutorService threadPool = Executors.newCachedThreadPool((r) -> new Thread(r, "Test-Thread-" + threadCounter++));
  37         private final FakeTcpServer fcpServer;
  38         private final DefaultFcpClient fcpClient;
  39
  40         public DefaultFcpClientTest() throws IOException {
  41                 fcpServer = new FakeTcpServer(threadPool);
  42                 fcpClient = new DefaultFcpClient(threadPool, "localhost", fcpServer.getPort(), () -> "Test", () -> "2.0");
  43         }
  44
  45         @After
  46         public void tearDown() throws IOException {
  47                 fcpServer.close();
  48         }
  49
  50         @Test
  51         public void defaultFcpClientCanGenerateKeypair() throws ExecutionException, InterruptedException, IOException {
  52                 Future<FcpKeyPair> keyPairFuture = fcpClient.generateKeypair().execute();
  53                 connectNode();
  54                 fcpServer.collectUntil(is("EndMessage"));
  55                 fcpServer.writeLine("SSKKeypair",
  56                         "InsertURI=" + INSERT_URI + "",
  57                         "RequestURI=" + REQUEST_URI + "",
  58                         "Identifier=My Identifier from GenerateSSK",
  59                         "EndMessage");
  60                 FcpKeyPair keyPair = keyPairFuture.get();
  61                 assertThat(keyPair.getPublicKey(), is(REQUEST_URI));
  62                 assertThat(keyPair.getPrivateKey(), is(INSERT_URI));
  63         }
  64
  65         private void connectNode() throws InterruptedException, ExecutionException, IOException {
  66                 fcpServer.connect().get();
  67                 fcpServer.collectUntil(is("EndMessage"));
  68                 fcpServer.writeLine("NodeHello",
  69                         "CompressionCodecs=4 - GZIP(0), BZIP2(1), LZMA(2), LZMA_NEW(3)",
  70                         "Revision=build01466",
  71                         "Testnet=false",
  72                         "Version=Fred,0.7,1.0,1466",
  73                         "Build=1466",
  74                         "ConnectionIdentifier=14318898267048452a81b36e7f13a3f0",
  75                         "Node=Fred",
  76                         "ExtBuild=29",
  77                         "FCPVersion=2.0",
  78                         "NodeLanguage=ENGLISH",
  79                         "ExtRevision=v29",
  80                         "EndMessage"
  81                 );
  82         }
  83
  84         @Test
  85         public void clientGetCanDownloadData() throws InterruptedException, ExecutionException, IOException {
  86                 Future<Optional<Data>> dataFuture = fcpClient.clientGet().identifier("test").uri("KSK@foo.txt");
  87                 connectNode();
  88                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
  89                 assertThat(lines, containsInAnyOrder(
  90                         "ClientGet",
  91                         "Identifier=test",
  92                         "ReturnType=direct",
  93                         "URI=KSK@foo.txt",
  94                         "EndMessage"
  95                 ));
  96                 fcpServer.writeLine(
  97                         "AllData",
  98                         "Identifier=test",
  99                         "DataLength=6",
 100                         "StartupTime=1435610539000",
 101                         "CompletionTime=1435610540000",
 102                         "Metadata.ContentType=text/plain;charset=utf-8",
 103                         "Data",
 104                         "Hello"
 105                 );
 106                 Optional<Data> data = dataFuture.get();
 107                 assertThat(data.get().getMimeType(), is("text/plain;charset=utf-8"));
 108                 assertThat(data.get().size(), is(6L));
 109                 assertThat(ByteStreams.toByteArray(data.get().getInputStream()), is("Hello\n".getBytes(StandardCharsets.UTF_8)));
 110         }
 111
 112         @Test
 113         public void clientGetDownloadsDataForCorrectIdentifier() throws InterruptedException, ExecutionException, IOException {
 114                 Future<Optional<Data>> dataFuture = fcpClient.clientGet().identifier("test").uri("KSK@foo.txt");
 115                 connectNode();
 116                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 117                 assertThat(lines, containsInAnyOrder(
 118                         "ClientGet",
 119                         "Identifier=test",
 120                         "ReturnType=direct",
 121                         "URI=KSK@foo.txt",
 122                         "EndMessage"
 123                 ));
 124                 fcpServer.writeLine(
 125                         "AllData",
 126                         "Identifier=not-test",
 127                         "DataLength=12",
 128                         "StartupTime=1435610539000",
 129                         "CompletionTime=1435610540000",
 130                         "Metadata.ContentType=text/plain;charset=latin-9",
 131                         "Data",
 132                         "Hello World"
 133                 );
 134                 fcpServer.writeLine(
 135                         "AllData",
 136                         "Identifier=test",
 137                         "DataLength=6",
 138                         "StartupTime=1435610539000",
 139                         "CompletionTime=1435610540000",
 140                         "Metadata.ContentType=text/plain;charset=utf-8",
 141                         "Data",
 142                         "Hello"
 143                 );
 144                 Optional<Data> data = dataFuture.get();
 145                 assertThat(data.get().getMimeType(), is("text/plain;charset=utf-8"));
 146                 assertThat(data.get().size(), is(6L));
 147                 assertThat(ByteStreams.toByteArray(data.get().getInputStream()), is("Hello\n".getBytes(StandardCharsets.UTF_8)));
 148         }
 149
 150         @Test
 151         public void clientGetRecognizesGetFailed() throws InterruptedException, ExecutionException, IOException {
 152                 Future<Optional<Data>> dataFuture = fcpClient.clientGet().identifier("test").uri("KSK@foo.txt");
 153                 connectNode();
 154                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 155                 assertThat(lines, containsInAnyOrder(
 156                         "ClientGet",
 157                         "Identifier=test",
 158                         "ReturnType=direct",
 159                         "URI=KSK@foo.txt",
 160                         "EndMessage"
 161                 ));
 162                 fcpServer.writeLine(
 163                         "GetFailed",
 164                         "Identifier=test",
 165                         "Code=3",
 166                         "EndMessage"
 167                 );
 168                 Optional<Data> data = dataFuture.get();
 169                 assertThat(data.isPresent(), is(false));
 170         }
 171
 172         @Test
 173         public void clientGetRecognizesGetFailedForCorrectIdentifier() throws InterruptedException, ExecutionException, IOException {
 174                 Future<Optional<Data>> dataFuture = fcpClient.clientGet().identifier("test").uri("KSK@foo.txt");
 175                 connectNode();
 176                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 177                 assertThat(lines, containsInAnyOrder(
 178                         "ClientGet",
 179                         "Identifier=test",
 180                         "ReturnType=direct",
 181                         "URI=KSK@foo.txt",
 182                         "EndMessage"
 183                 ));
 184                 fcpServer.writeLine(
 185                         "GetFailed",
 186                         "Identifier=not-test",
 187                         "Code=3",
 188                         "EndMessage"
 189                 );
 190                 fcpServer.writeLine(
 191                         "GetFailed",
 192                         "Identifier=test",
 193                         "Code=3",
 194                         "EndMessage"
 195                 );
 196                 Optional<Data> data = dataFuture.get();
 197                 assertThat(data.isPresent(), is(false));
 198         }
 199
 200         @Test
 201         public void clientGetRecognizesConnectionClosed() throws InterruptedException, ExecutionException, IOException {
 202                 Future<Optional<Data>> dataFuture = fcpClient.clientGet().identifier("test").uri("KSK@foo.txt");
 203                 connectNode();
 204                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 205                 assertThat(lines, containsInAnyOrder(
 206                         "ClientGet",
 207                         "Identifier=test",
 208                         "ReturnType=direct",
 209                         "URI=KSK@foo.txt",
 210                         "EndMessage"
 211                 ));
 212                 fcpServer.close();
 213                 Optional<Data> data = dataFuture.get();
 214                 assertThat(data.isPresent(), is(false));
 215         }
 216
 217         @Test
 218         public void clientGetWithIgnoreDataStoreSettingSendsCorrectCommands() throws InterruptedException, ExecutionException, IOException {
 219                 fcpClient.clientGet().ignoreDataStore().identifier("test").uri("KSK@foo.txt");
 220                 connectNode();
 221                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 222                 assertThat(lines, containsInAnyOrder(
 223                         "ClientGet",
 224                         "Identifier=test",
 225                         "ReturnType=direct",
 226                         "URI=KSK@foo.txt",
 227                         "IgnoreDS=true",
 228                         "EndMessage"
 229                 ));
 230         }
 231
 232         @Test
 233         public void clientGetWithDataStoreOnlySettingSendsCorrectCommands() throws InterruptedException, ExecutionException, IOException {
 234                 fcpClient.clientGet().dataStoreOnly().identifier("test").uri("KSK@foo.txt");
 235                 connectNode();
 236                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 237                 assertThat(lines, containsInAnyOrder(
 238                         "ClientGet",
 239                         "Identifier=test",
 240                         "ReturnType=direct",
 241                         "URI=KSK@foo.txt",
 242                         "DSonly=true",
 243                         "EndMessage"
 244                 ));
 245         }
 246
 247         @Test
 248         public void clientGetWithMaxSizeSettingSendsCorrectCommands() throws InterruptedException, ExecutionException, IOException {
 249                 fcpClient.clientGet().maxSize(1048576).identifier("test").uri("KSK@foo.txt");
 250                 connectNode();
 251                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 252                 assertThat(lines, containsInAnyOrder(
 253                         "ClientGet",
 254                         "Identifier=test",
 255                         "ReturnType=direct",
 256                         "URI=KSK@foo.txt",
 257                         "MaxSize=1048576",
 258                         "EndMessage"
 259                 ));
 260         }
 261
 262         @Test
 263         public void clientGetWithPrioritySettingSendsCorrectCommands() throws InterruptedException, ExecutionException, IOException {
 264                 fcpClient.clientGet().priority(Priority.interactive).identifier("test").uri("KSK@foo.txt");
 265                 connectNode();
 266                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 267                 assertThat(lines, containsInAnyOrder(
 268                         "ClientGet",
 269                         "Identifier=test",
 270                         "ReturnType=direct",
 271                         "URI=KSK@foo.txt",
 272                         "PriorityClass=1",
 273                         "EndMessage"
 274                 ));
 275         }
 276
 277         @Test
 278         public void clientGetWithRealTimeSettingSendsCorrectCommands() throws InterruptedException, ExecutionException, IOException {
 279                 fcpClient.clientGet().realTime().identifier("test").uri("KSK@foo.txt");
 280                 connectNode();
 281                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 282                 assertThat(lines, containsInAnyOrder(
 283                         "ClientGet",
 284                         "Identifier=test",
 285                         "ReturnType=direct",
 286                         "URI=KSK@foo.txt",
 287                         "RealTimeFlag=true",
 288                         "EndMessage"
 289                 ));
 290         }
 291
 292         @Test
 293         public void clientGetWithGlobalSettingSendsCorrectCommands() throws InterruptedException, ExecutionException, IOException {
 294                 fcpClient.clientGet().global().identifier("test").uri("KSK@foo.txt");
 295                 connectNode();
 296                 List<String> lines = fcpServer.collectUntil(is("EndMessage"));
 297                 assertThat(lines, containsInAnyOrder(
 298                         "ClientGet",
 299                         "Identifier=test",
 300                         "ReturnType=direct",
 301                         "URI=KSK@foo.txt",
 302                         "Global=true",
 303                         "EndMessage"
 304                 ));
 305         }
 306
 307 }